AndroidJNI学习之Concepts

Concepts

Before Beginning

This guide assumes that you are:

• Already familiar with concepts inherent in native programming and in Android development.
• Working in Eclipse, and using the Android Development Tools (ADT), except where otherwise noted.

Introduction

This section provides a high-level explanation of how the NDK works. The Android NDK is a set of tools allowing you to embed C or C&＃43;&＃43; (“native code”) into your Android apps. The ability to use native code in Android apps can be particularly useful to developers who wish to do one or more of the following:

• Port their apps between platforms.
• Reuse existing libraries, or provide their own libraries for reuse.
• Increase performance in certain cases, particularly computationally intensive ones like games.

How it Works

This section introduces the main components used in building a native application for Android, and goes on to describe the process of building and packaging.

Main components

You should have an understanding of the following components as you build your app:

在你建造你的应用程序时你应该对一下的组件有一个认识

• ndk-build: The ndk-build script launches the build scripts at the heart of the NDK. These scripts:

  ndk-build  ndk-build  脚本在NDK内部启动这个建造脚本

  • Automatically probe your development system and app project file to determine what to build.
  • 自动检测你的开发系统和应用程序工程文件去检测要如何去构造。
  • Generate binaries.
  • 生成二进制文件
  • Copy the binaries to your app&＃39;s project path.
  • 复制这二进制文件到你的应用程序工程路径下

  For more information, see ndk-build.

• Java: From your Java source, the Android build process generates .dex (Dalvik EXecutable) files, which are what the Android OS runs in the Dalvik Virtual Machine (“DVM”). Even if your app contains no Java source code at all, the build process still generates a .dex executable file within which the native component runs.

  java&＃xff1a;

• When developing Java components, use the native keyword to indicate methods implemented as native code. For example, the following function declaration tells the compiler that the implementation is in a native library:

• 在开发java组件时&＃xff0c;使用native 关键字去表明方法是本地代码的实现。例如&＃xff0c;一下的方法声明告诉编辑器这实现是在本地库中&＃xff0c;

  public native int add(int  x, int  y);

• Native shared libraries: The NDK builds these libraries, or .so files, from your native source code.

  NDK从你的本地源代码中构建函数库或者.so文件

• Note: If two libraries implement respective methods with the same signature, a link error occurs. In C, "signature" means method name only. In C&＃43;&＃43;, "signature" means not only method name, but also its argument names and types.

如果两个函数库用一样的签名实现各自的方法&＃xff0c;会发生连接错误。在C中&＃xff0c;签名只意味着方法名&＃xff0c;在C&＃43;&＃43;中签名不单单代表方法名&＃xff0c;也代表参数名和类型。

• Native static libraries: The NDK can also build static libraries, or .a files, which you can link against other libraries.

本地静态函数库&＃xff1a;NDK也可以建造本地静态函数库或者a文件。你可以再次连接到其他的函数库

• Java Native Interface (JNI): The JNI is the interface via which the Java and C&＃43;&＃43; components talk to one another. This guide assumes knowledge of the JNI; for information about it, consult the Java Native Interface Specification.

java 本地接口JNI&＃xff1a;JNI是一种接口&＃xff0c;是java 和C&＃43;&＃43;组件交流的的一种方式&＃xff0c;本指南假设的知识信息是关于JNI的&＃xff0c;

• Application Binary Interface (ABI): The ABI defines exactly how your app&＃39;s machine code is expected to interact with the system at runtime. The NDK builds .so files against these definitions. Different ABIs correspond to different architectures: The NDK includes ABI support for ARMEABI (default), MIPS, and x86. For more information, see ABI Management.

应用程序库函数接口ABI定义了如何以运行的系统所期望的方式解析你应用程序机器代码并与之交互&＃xff0c;NDK构造的so文件与这些定义相反&＃xff0c;

• Manifest: If you are writing an app with no Java component to it, you must declare the NativeActivityclass in the manifest. Native Activities and Applications provides more detail on how to do this, under “Using the native_activity.h interface.”
• 清单:如果您正在编写一个应用程序没有Java组件,必须声明中的NativeActivityclass清单。本机的活动和应用程序提供了更多的细节关于如何做到这一点,在“使用native_activity。h接口。”

The following two items are only required for building using the ndk-build script, and for debugging using thendk-gdb script.

• Android.mk: You must create an Android.mk configuration file inside your jni folder. The ndk-buildscript looks at this file, which defines the module and its name, the source files to be compiled, build flags and libraries to link.
• 你需要创建一耳光android&＃xff0c;mk配置文件在你的jni文件夹中&＃xff0c;ndk-build脚本查看着文件夹&＃xff0c;它定义了模块及其名称,编译源文件,建立旗帜和库链接。

• Application.mk: This file enumerates and describes the modules that your app requires. This information includes:

  这文件描述和计算你应用程序需要的模块

  ABIs used to compile for specific platforms.

• 本地库函数接通使用去编译指定的平台

  • Toolchains.
  • 工具链
  • Standard libraries to include (static and dynamic STLport or default system).
  • 加入标准的库函数

Flow

The general flow for developing a native app for Android is as follows:

1. Design your app, deciding which parts to implement in Java, and which parts to implement as native code.

   Note: While it is possible to completely avoid Java, you are likely to find the Android Java framework useful for tasks including controlling the display and UI.

2. Create an Android app Project in Eclipse as you would for any other Android project.
3. If you are writing a native-only app, declare the NativeActivity class in AndroidManifest.xml. You can do so from the Eclipse/ADT Android Manifest Editor, or by hand-editing the file. For more information, see theNative Activities and Applications.
4. Create an Android.mk file describing the native library, including name, flags, linked libraries, and source files to be compiled in the ‘JNI’ directory.
5. Optionally, you can create an Application.mk file configuring the target ABIs, toolchain, release/debug mode, and STL. For any of these that you do not specify, the following default values are used, respectively:
   • ABI: armeabi
   • Toolchain: GCC 4.8
   • Mode: Release
   • STL: system
6. Place your native source under the project&＃39;s jni directory.
7. Use ndk-build to compile the native (.so, .a) libraries.
8. Build the Java component, producing the executable .dex file.
9. Package everything into an APK file, containing .so, .dex, and other files needed for your app to run.

Note that Eclipse can perform steps 7. through 9. in a single operation.

Native Activities and Applications

The Android SDK provides a helper class, NativeActivity, that allows you to write a completely native activity.NativeActivity handles the communication between the Android framework and your native code, so you do not have to subclass it or call its methods. All you need to do is declare your application to be native in yourAndroidManifest.xml file, and begin creating your native application.

An Android application using NativeActivity still runs in its own virtual machine, sandboxed from other applications. You can therefore still access Android framework APIs through the JNI. In certain cases, however–such as for sensors, input events, and assets–the NDK provides native interfaces that you can use instead of having to call across the JNI. For more information about such support, see Android NDK Native APIs.

Regardless of whether or not you are developing a native activity, we recommend that you create your projects with the traditional Android build tools. Doing so helps ensure building and packaging of Android applications with the correct structure.

The Android NDK provides you with two choices to implement your native activity:

• The native_activity.h header defines the native version of the NativeActivity class. It contains the callback interface and data structures that you need to create your native activity. Because the main thread of your application handles the callbacks, your callback implementations must not be blocking. If they block, you might receive ANR (Application Not Responding) errors because your main thread is unresponsive until the callback returns.
• The android_native_app_glue.h file defines a static helper library built on top of the native_activity.hinterface. It spawns another thread, which handles things such as callbacks or input events in an event loop. Moving these events to a separate thread prevents any callbacks from blocking your main thread.

The /sources/android/native_app_glue/android_native_app_glue.c source is also available, allowing you to modify the implementation.

For more information on how to use this static library, examine the native-activity sample application and its documentation. Further reading is also available in the comments in the/sources/android/native_app_glue/android_native_app_glue.h file.

Using the native_activity.h interface

To implement a native activity with the native_activity.h interface:

1. Create a jni/ directory in your project&＃39;s root directory. This directory stores all of your native code.
2. Declare your native activity in the AndroidManifest.xml file.

   Because your application has no Java code, set android:hasCode to false.

   You must set the android:name attribute of the activity tag to NativeActivity.

               android:label&＃61;"&＃64;string/app_name">

   Note: You can subclass NativeActivity. If you do, use the name of the subclass instead ofNativeActivity.

   The android:value attribute of the meta-data tag specifies the name of the shared library containing the entry point to the application (such as C/C&＃43;&＃43; main), omitting the lib prefix and .so suffix from the library name.

                         android:value&＃61;"native-activity" />
           
             
             
           
         
       
     

3. Create a file for your native activity, and implement the function named in the ANativeActivity_onCreatevariable. The app calls this function when the native activity starts. This function, analogous to main in C/C&＃43;&＃43;, receives a pointer to an ANativeActivity structure, which contains function pointers to the various callback implementations that you need to write. Set the applicable callback function pointers inANativeActivity->callbacks to the implementations of your callbacks.
4. Set the ANativeActivity->instance field to the address of any instance of specific data that you want to use.
5. Implement anything else that you want your activity to do upon starting.
6. Implement the rest of the callbacks that you set in ANativeActivity->callbacks. For more information on when the callbacks are called, see Managing the Activity Lifecycle.
7. Develop the rest of your application.
8. Create an Android.mk file in the jni/ directory of your project to describe your native module to the build system. For more information, see Android.mk.
9. Once you have an Android.mk file, compile your native code using the ndk-build command.

   $ cd //
$ /ndk-build

10. Build and install your Android project as usual, using Ant or Eclipse. If your native code is in the jni/directory, the build script automatically packages the .so file(s) built from it into the APK.