Developing Xamarin Android Native Applications

Xamarin has quickly become a popular way for creating cross-platform mobile applications promoting true code-reuse while allowing developers to create native* (native here means natural to the platform) user interfaces, providing them access to full spectrum of functionality exposed by the underlying platform/device and guaranteeing native* performance by allowing applications to leverage platform specific hardware acceleration. To add on, Xamarin integrates fully into Visual Studio and allows development of iOS, Android and Windows applications alike.

So what does this mean for our true native (C/C++) developers? Well if you take a look at Xamarin’s current approach for the android platform, it allows for leveraging android native (C/C++) libraries when building end-end Xamarin Android applications.

This approach currently however involves mucking around with the Xamarin Android project files in Visual Studio and adding the Item-Group pointing to the prebuilt dynamic shared library mentioned here in the Xamarin Android guides. Typically this native dynamic shared library is developed in another IDE (commonly, Eclipse), which adds further complexity given developers now have to worry about using two IDE’s and absorbing the fun that comes from the added complexity to edit, build and debug their application specially when working in the native (C/C++) library layer.

With Visual Studio 2015 CTP 6, this is no longer the case and developers can now create even this native (C/C++) library in Visual Studio, we (the C++ cross-platform mobile team) have been working with Xamarin in order to provide a smooth experience when developing Xamarin Android Native applications. This blog highlights a few of the enablement made available with Visual Studio 2015 CTP 6 and while all the work has not been finished yet, we are excited for you try it out and provide us feedback.

Getting Started

As a pre-requisite for being able to follow this blog, developers need to install Visual Studio 2015 CTP6 with Visual C++ cross-platform mobile bits and Xamarin optional packages. Once these bits have been installed you have everything you need to start developing Xamarin Android Native applications entirely in Visual Studio. Let us start with creating a Xamarin Android Project. For purposes of this blog let’s choose the simplest of Xamarin Android templates ‘Blank App (Android)’ from the File->New project menu and create a new project called ‘XamarinNativeExample’.

Next to the existing solution let’s add a dynamic shared library project from the ‘Visual C++ – Cross-Platform node’ and call it ‘NativeLibrary’.

Once we are done, our solution should have two projects (a Xamarin Android project and a C++ Dynamic Shared Library project) in solution explorer.

Referencing Android Native libraries from a Xamarin Android project

As mentioned in the abstract of this blog traditionally developers leveraging native android binaries would have to go build them in other IDE’s and then to leverage these pre-built android native binaries within a Xamarin Android project they would have to muck around with the Xamarin Android project. With the work we have done referencing the native binary is as simple as adding a project reference between the ‘XamarinNativeExample’ and the ‘NativeLibrary’ projects. The process is illustrated in the images below:

Once the reference has been added, under the references section for the ‘XamarinNativeExample’ project the ‘NativeLibrary’ entry should be found. One would notice that this reference is currently not resolved, this is a known issue and even though the reference doesn’t resolve at design time the application package file (.apk) that is built would contain the native library.

Next let us go ahead and add some code in our native library and invoke it from our Xamarin Android project. In the ‘NativeLibrary.cpp’ source file within the ‘NativeLibrary’ project, add the following function. This function will be invoked every time the button defined in our Xamarin Android project is clicked.

int clickCount = 1;
int getClickCount() {

   return clickCount++;

}

To call this function from the Xamarin Android project ‘XamarinNativeExample’, add the following code in ‘MainActivity.cs’ file.

[DllImport(“libNativeLibrary.so“)]
public extern static int getClickCount(); 

This Dllimport attribute will load the android native library at application runtime. For using this attribute the ‘using System.Runtime.InteropServices;’ namespace will also be required in your source. Next let us modify the existing source line in the ‘OnCreate’ function. OnCreate method is the first method to be called when the activity is created. This modification in the OnCreate function will allow us to call the ‘getClickCount’ function from the native library whenever the user clicks the button. 

button.Click += delegate { button.Text = string.Format(“{0} clicks!“, getClickCount()); };

At this point we are almost done but before we go ahead and build our solution and test out our new Xamarin Android Native Application, the active solution platform needs to be setup appropriately (ARM or x86 depending upon the choice of your debug target) as shown in the figure below.

Lastly let us make sure that we have named our ‘NativeLibrary’ correctly by viewing the ‘Target Name’ property in the NativeLibrary project property pages.

At this point we are all set to go ahead and build/deploy our application to an Android device or emulator. In case you had any issues following this blog, the solution being presented in this blog can be found here

Debugging an Android Native Library in a Xamarin Android Application

In addition to being able to consume and build a native android library easily in a Xamarin Android application. The Visual studio experience will also allow developers to easily debug their native android library code being consumed within the Xamarin Android application. To demonstrate this, continuing with our example bring up the property pages for the ‘XamarinNativeExample’ project and choose the ‘Native’ debugger option in the ‘Android Options’ menu as shown in the figure below.

 

 Next let us bring up the ‘NativeLibrary.cpp’ source and set a breakpoint in our ‘getClickCount()’ function and start debugging (F5). Once the application starts up, on every button click the break-point we set should be hit.

 

While this is a trivial example, all other debug features such as expression evaluation, watch window, auto window work with this experience as well.


Wrap Up
 

This blog should provide you insight into the work that the Visual Studio team has done in partnership with Xamarin to enable a smooth experience when building Xamarin Android Native applications. We would love you folks to try this experience out and provide your feedback. Additionally If you would like us to talk about a specific topic on our blogs please let us know.  As a reminder the goal with this CTP release is for us to collect feedback and learn from you. We are considering future support for other platforms too and your feedback is critical in shaping the direction of our product. 

Sharing feedback is easy! Make feature suggestions on UserVoice, log bugs you find on our Connect site and send us a smile or frown from inside the IDE. You can also leave comments below. In addition to this if you are  looking to have a directed conversation with our product team on this topic, please reach out to us through email (aasthan@microsoft.com). We would love to know more and connect with you.  

XamarinNativeExample.zip