Just looking into Nativescript; the "core" bit of it seems really interesting in that you can call native APIs directly from JS, but it seems it is a completely different API for iOS and Droid (e.g. matching the respective native APIs on each platform). See attached screen shot. Does anyone know if someone has made a common JS API between iOS and Droid for nativescript core? At least a subset of calls? Otherwise you still have 2 APIs to deal with (doubling the code base), but at least it is one language.
ios vs. android api
Related
Is it possible to write a mobile app using .NET 6 but still maintain platform specific implementation of UI
So this would involve still using UIViewControllers for iOS and Activities for Android without taking the MAUI approach of writing the UI in a cross platform manner.
If this is possible could you point us at some documentation around how this is achieved.
I haven't tried to follow the instructions yet but the links provided by #Paramjit in the comments to my original question seem to provide the answer I was looking for, namely that MAUI isn' the only mobile option in .NET 6:
https://www.andreasnesheim.no/converting-xamarin-android-template-to-net-6/
https://www.andreasnesheim.no/converting-xamarin-ios-template-to-net-6/
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.
I want to introduce 'Zendesk' chat support in my application. I have tried to search but not get the process of including. Please suggest any idea. Thanks in advance.
Zendesk documentation appears to only indicate native support for Android and iOS. Xamarin can link the SDKs individually for each build -- see Xamarin documentation for this (links included but not summarized due to length), but won't handle bridging the difference between the two. Windows will not be supported by this option. If you only want to target Android and iOS, you can use these options and create wrapper classes with a common interface.
Alternatively, if you badly need Windows support and are comfortable with web technologies, the web sdk offers a full api. Xamarin forms supports a webview in which you can load the web sdk, and either build a GUI in the webview or make api calls via the web sdk.
Links detailing including native libraries:
https://developer.xamarin.com/guides/android/advanced_topics/using_native_libraries/
https://developer.xamarin.com/guides/ios/advanced_topics/native_interop/
Note -- above link is specifically for native libraries, which I believe is correct for Zendesk's SDK. If not, there is also a guide for objective-c libraries on the Xamarin website.
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]
I am currently working on Xamarin project and after some research, I am confused about how cross platform UI works.
Let's take the 3 following smartphones:
Samsung Galaxy S5
iPhone 6 Microsoft
Lumia 640 LTE
Three phones with three different types of controls. Samsung has 3 buttons at the bottom, whereas the iPhone has just 1 button. The Microsoft phone has 3 buttons like the Samsung, but those are different. So this is why I am confused.
The cross platform design shown in the tutorials such as this tutorial shows a shared design.
However, my goal isn't to make the same interface for each platform. I saw this article which is similar to what I want to make. We have the same app logic, but the design depends of the platform
In order: Android, iOS and Windows Phone
Now, here is the app architecture proposed by Xamarin
To achieve a different design per platform, I must not create a "Forms Xaml Page" in the shared project, but create 3 different pages (1 per platform). However, I'm not sure how this can be achieved.
At the launch, each app executes the following code line:
LoadApplication(new App());
So, if I make 3 different interfaces, how can I load the one specific to the platform the app is running on?
Also, if we use the MVC pattern (I know about MVVM, I just do not understand it at the moment), make 3 differents views, each one with a controller, but only share models/data/motor. (MVC -> 1M/3V/3C).
A good approach for a cross-platform project with platform-specific UIs is to use MvvmCross or a similar library.
The TipCalc-Project is a sample app which shares business logic via a Portable Class Library (PCL) and makes use of the MVVM-pattern (Model View ViewModel). You have a separated UI-project per platform (Android, iOS, ...) and reuse the functionality from your PCL.
This allows to share a large amount of your business code without using Xamarin.Forms and without any compromises regarding your UI.
You should have a basic understanding of MVVM and Dependency Injection for this approach.
With Xamarin.Forms, you are sharing the app logic and potentially all of the UI code by using the Forms API. This means the app interface will be fairly similar on all platforms.
With the non-Forms approach you share the app logic and then any UI code can go in the platform specific project and use the platform specific API.
Reading your requirements, I would suggest you look towards the non-Forms based approach of sharing code with Xamarin, rather than using Forms.
We have some good guides to get your started with this as well as a sample and case study.