visual studio 2017 创建 android 本地共享库(.so) 并从 C# android 项目中调用

Developing Xamarin Android Native Applications

★★★★★

★★★★

★★★

★★

★

February 23, 2015 by Ankit Asthana // 11 Comments

• Share

 

• 0
• 0

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 installVisual 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

Back
to
top

Download Visual Studio