Xamarin UI Test - different element selectors for Phone / Tablet - xamarin

I am looking at Xamarin UI test as a POC for a native Android and iOS app. Not used Xamarin before or C, so I am bluffing my way through at the moment. I have managed to get it running on the Android Phone version of the app, but how do I make it clever enough to look for different elements between the Phone / Tablet implementation? Going further I will be trying to make the POC cross platform so will need to take into account the platform too.
I have seen references to platform and idiom but not sure how to use them in the Tests.cs file.
Thanks.

Related

Migrate existing UWP app to work as Xamarin APP

I have existing UWP apps that I would now like to migrate to Xamarin, so that I can run them on Android devices. What are the most viable and/or practical approaches for doing this?
In some cases I will also want to continue to run these apps on Microsoft devices. I'd prefer not to have two code-bases to maintain, but that might be an option for some apps. A couple of the apps are available on the MS Apps Store.
The UWP apps are relatively cleanly architected, with separate layers and physical projects separating the UI from data access, logic, etc.
Worse-case I can make a new (Xamarin) project and UI from scratch, but what about the other projects / layers? What are my options for those? E.g. copy and paste - retain the old code/solutions (for future UWP-based support if necessary), create copies of the old (non-UI) code/projects in the new Xamarin solution (with a new Xamarin UI).
This post How do I add Xamarin Forms to an existing UWP XAML app? talks about "multiple types of Xamarin code sharing strategies and UI strategies" but doesn't provide any details or references.
This post Adding UWP option to Xamarin cross-platform application seems to be talking about doing it the other way around: taking a Xamarin app and delivering it as UWP.
What are the most viable and/or practical approaches for doing this?
Currently, there is no tool that could directly convert a UWP app into a Xarmain App. Based on your description, you will need to create a new Xamarin app to make your app available in both Android and Windows, or even more on IOS.
You could build a Xamarin.Forms app for your scenario. Xamarin.Forms allows developers to build Xamarin.iOS, Xamarin.Android, and Windows applications from a single shared codebase. As #Jason mentioned, if your app is well architected with data, domain, and service layers, those can probably be reused in Xamarin.Forms app. And the Xamarin.Forms app will convert the code into performant native controls on each platform. So you don't need to write extra code for each platform for the same function.

React native vs Xamarin forms

We need to build a commercial mobile app that is supported on iOS, Android and UWP platforms. We have been looking at react native and xamarin forms to do so. What is more recommended/preferable technology to implement this?
Reasons why we wanted to use react native in first place:
1) more experience in JavaScript
2) Some of the UI designs in our mobile app includes having cross platform features which by default could be native to either IOS or android. Such as having icon badges on tab items, having toggle search box in navigation bar. On react native we found these were more easily achievable by git hub plugins but in xamarin forms you need to write custom renderers to achieve so.
Reasons why started investigating on xamarin forms: Since the app needs to run windows phones too, we stared using react native XP plugin to support that. But end prototype on windows phone wasn't very impressive in terms of performance and user experience of some of react native plugins we have used. Plus we also had to do quite a bit UI customisation in terms of specifying width/heights to make components work.
I have been develop on Xamarin a few years now. My honest opinion is that there is a lot of third party libraries and components that only has support for Android and iOS only. Maybe you you check out what third party libraries you need and work back from there.
If Windows Phones are an honest target for you going forward, unless you can limit to those capable of UWP apps (Win 10 Mobile) then scratch Xamarin from the list. Windows Phone 8 and 8.1 support is deprecated and will be dropped soon from Forms.

Porting android app to xamarin or windows native questions

So, I have been developing an android app for some time, and I was requested to try porting this app to windows phone too. In order to reduce the hassle in trying to maintain two separate versions of the same app, I decided to try to port this app into xamarin, because I have heard that its performance is better than hybrid apps. These are my questions with regard to xamarin:-
I want to maintain the same look and feel which I had in my original app into my cross platform app, and at the same time, make it distinct in the windows version. What are the things I can do to achieve this effect?
Is it rather better for me to port this app to windows phone native, because of added problems in trying to create a common app?
Are there any restrictions with regard to Windows store when publishing xamarin apps?
Xamarin doesn't really cover Windows UWP apps, only in the notion that they have the UI Framework Xamarin.Forms running on that platform. Meaning, that what you are making is a native Windows UWP app.
What Xamarin is great at is when you start targeting more than one platform and you have structured your code in a way that it can be reused on the supported platforms. This could for instance be done by putting most of your logic and behavior into a Portable Class Library/NETStandard library and consume it in your apps.
A Typical pattern for making platform agnostic logic and behavior for your apps, is the pattern known as Model-View-ViewModel, where the View is platform specific, while the Model and ViewModel usually are platform agnostic. The ViewModel is where the behavior resides and it is what ties the Model together with the View.
Usually the ViewModel wouldn't directly know the View, but there would be a layer in between (glue), such as XAML or a binding engine from MvvmCross, MvvmLight or ReactiveUI to name some MVVM libraries.
What Xamarin provides is the ability to write C# code for Android and iOS, which greatly enables you to share code between those two platforms, but also all the Windows platforms. Hence, UI, is very much dependent on each of the platforms on their own.
You can, of course, use Xamarin.Forms as a UI abstraction layer, which produces a native UI using the native UI controls to get a similar app on all the targeted platforms.
First of all you need to know there are different styles of Xamarin development, who will share more or less content.
If you use Xamarin Forms you have a Main project non-related to any platform (where you create the views and clases), and specific platform projects who adapt the controls to each native style.
If you develop using Xamarin Classic, you have a Shared project where you only develop data-related classes, and specific platform project with their own views and classes with native-friendly controls and native similar functions, but I think, there is no direct Xamarin Clasic Windows Project.
So if you only want to have two apps who look native both, but with same structure and functionalities Xamarin Forms will be the best option for you, cause you only develop "one single app" who becomes native-style like this:
If what you want is to have different apps, with different functionalities and diferent content, then you need to go for Xamarin Classic. What I recomend you to do then is develop the windows phone in native, but put all of the code you can in a shared library. Then you can create a Xamarin classic Android app and use the shared library. You will still need to mantain two different apps, but you will only need to change the "core" code only one time.
If you use Xamarin Forms to do a UWP windows app I don't think you have any problem to publish it, think Xamarin is from Microsoft.

Buiding iOS app from Xamarin Android app

I am an iOS developer & I have to start work on Xamarin platform project for iOS. So I have some basic queries as a beginner in Xamarin. I have already initiated study from Link1 Link2
App is developed in Android On Xamarin & now I have to develop the same app for iOS(iPhone+iPad).
So my question are
Can I reuse the C# code written for Android app in iOS?
I have to redesign the UI for iOS devices? (As per my knowledge "YES" plz
confirm if I am wrong)
.Any idea or any suggestion would be great for me.
Thanks
Well, that depends.
If you had been using Xamarin.Forms you would only need to build one project which would then compile into a .apk (Android) and .ipa (iOS) distribution binary. Thus, by choosing Forms, you would only need to design and build the UI once as logic and UI is shared between all platforms.
On the other hand, you can chose to build your application using Xamarin.Android and Xamarin.iOS. In doing so, you can share the logic (e.g. ViewModels, Services, Converters) only. The rest will have to be built platform specific. So in the ladder case, you wouldn't be able to reuse the C# code which you've built for Android on iOS, as the platforms differ.
As Demitrian said earlier, using Xamarin.Forms allows you to build a single project.
If you want to use Xamarin.Android and Xamarin.iOS, which I do, you can build a solution containing an Android project and an iOS project, then add a Shared Project to your solution containing the common code, like classes, models, HTTP actions, etc. That way, you can save some programming time, while still taking advantage of each platform's specificities.

Should I choose Xamarin native or Xamarin.Forms for existing Android app?

We have an android application and want to recreate it for cross platform.
What are the facts for or against Xamarin native and forms?
The advantage of native would be, we could reuse all the xml-layouts while we have to recreate the iOS view in either XAML or XIB?
Is there anything what is really a blocker?
I'll comment based on Giorgi's answer with some actual insight and refer to the copied bullet points:
This is a resume of the experience i've gathered in the past 6 months:
Xamarin.Forms is best for:
Apps that require little platform-specific functionality
Wrong. With DI you can use any device functionality you could possibly want. Check out XLabs on GitHub if you doubt this.
Apps where code sharing is more important than custom UI
Kind of nonsense really. You can write your own renderers to represent controls of each platform in the way you want. I've also written more difficult renderers for custom controls such as a SideDrawer. In android i was done in 2 days, iOS about 2 weeks (android renderer was just a wrapper for the native control)
Developers comfortable with XAML
well yeah and anyone who enjoys convenient UI development. Mind you that there is a learning curve with xaml (which i already knew at the time i started from WPF development). But from what i have seen it's not that different from android.
Xamarin.iOS & Xamarin.Android are best for:
Apps with interactions that require native behavior
While hacking your solution up natively is certainly faster you can instead be done rather quick if purchase good controls / know a good native implementation and mirror it in C#, since the API in C# is very similar to the native one.
Apps that use many platform-specific APIs
Not sure why Xamarin is doing anti advertisement against forms. I had little trouble with it so far
Apps where custom UI is more important than
code sharing
Probably true, but it's also harder to keep UI functionality inline and you will need more manpower.
Things to consider about forms:
Forms seems to be stabilizing at the moment and i am sure Microsoft will do their best to turn it into a solid, reliable product (build issues have been a nightmare in the past sometimes, but it has gotten better over time)
The XAML for Xamarin is less developed compared to WPF XAML, though very similar. Recent nuget updates however provide mirrored functionality at an impressive rate. The vast majority of features you expect and love about XAML are present.
List performance is bad if you don't do your research (here). Performance increased loads in that area.
If i had to make the choice again i'd still go for forms. While there are sometimes things which seem flawed / bad you can usually figure out a clean fix somehow, while spending most of your time actually developing the app. (sometimes you will still find things which just make you frown why something isn't implemented, like the Margin property being implemented only just after microsoft purchased xamarin)
If you end up having a requirement of nested lists, make sure to have a look at embeded native controls in order to achieve the maximum performance - this was essential for a product i was working at. See this
According to Xamarin.Forms main page:
Xamarin.Forms is best for:
Apps that require little platform-specific functionality
Apps where code sharing is more important than custom UI
Developers comfortable with XAML
Xamarin.iOS & Xamarin.Android are best for:
Apps with interactions that require native behavior
Apps that use many platform-specific APIs
Apps where custom UI is more important than code sharing
Giorgis answer is the right one, but since you added some more constraints here are my thoughts.
I would analyze the current app. How much code is business logic which can be shared? How customized is the UI, should it look more native or more the same and how will it change in the future? If you plan to change a lot in UI and platforms should look similar, it might be easier to switch to forms.
Also consider if are you planning to develop for Windows Phone? If yes, you might save a lot of time just for this third platform.
After all there is one thing which I would also keep in mind. Developing in Xamarin.Forms does not mean, you cannot develop native. It is just an additional framework. In worst case you can still do everything natively.
Personally I use Xamarin.iOS & Xamarin.Android with MvvmCross, that way I can keep full control of the native UI on each platform while maximizing code reuse.
From Xamarin website (who knows better than them?):
Xamarin.Forms is best for:
Data entry apps
Prototypes and proofs-of-concept
Apps that require little platform-specific functionality
Apps where code sharing is more important than custom UI
[https://developer.xamarin.com/guides/xamarin-forms/]
With Xamarin.Forms at runtime, each page and its controls are mapped to platform-specific native user interface elements.
With Native Xamarin.Android and Xamarin.iOS apps leverage platform-specific hardware acceleration, and are compiled for native performance. This can’t be achieved with solutions that interpret code at runtime.
"Xamarin.iOS - The best way to build native iOS apps."
Ship native app bundles on the App Store. Our Ahead-of-Time (AOT) compiler compiles Xamarin.iOS apps directly to native ARM assembly
code, meaning your app is a native platform binary.
Access any iOS API. We bring 100% of Apple’s iOS SDK to C#, enhancing Objective-C APIs with stronger types and .NET naming
conventions so you feel right at home.
Call existing Objective-C code from C#. Use your existing Objective-C code, frameworks, and custom controls in your Xamarin app
using our automatic binding generator.
Build WatchKit apps. Use Xamarin Studio or Visual Studio to build new Watch Apps, edit Watch user interfaces in the iOS Designer, and
debug Watch apps in the iOS Simulator.
Stay up-to-date with Apple. We released same-day support for iOS 5, iOS 6, iOS 7, and iOS 8 so your apps can take advantage of the
latest iOS features as soon as possible.
[https://www.xamarin.com/platform]
"Xamarin.Android - The best way to build native Android apps."
Ship native Android packages. Xamarin.Android uses just-in-time compilation for sophisticated runtime optimization of your app’s
performance, meaning your app is a native Android APK.
Access any Android API, including new form factors. We bring 100% of Google’s Android APIs to C#, enhancing Java APIs with async support
and .NET naming conventions so you feel right at home.
Call existing Java code from C#. Use your existing Java code, frameworks, and custom controls in your Xamarin app using our
automatic binding generator.
Build Android Wear apps. With access to 100% API support for Android Wear, create full-featured applications capable of running on
Android Wear devices. Stay up-to-date with Android. Xamarin stays
up-to-date with the most current APIs from Google, so you can always
use the latest features in your apps.
[https://www.xamarin.com/platform]

Resources