Android应用---基于NDK的samples例程hello-jni学习NDK开发

Android应用---基于NDK的samples例程hello-jni学习NDK开发

NDK下载地址：http://developer.android.com/tools/sdk/ndk/index.html，下载解压为android-ndk-r10b，此目录下的samples\hello-jni就是NDK自带的例子，先来看编译前后和用eclipse导入前后目录的差别图：

图1

(1)  解压后原始的目录见图1左边的目录结构。

(2)  进入D:\ADT-bundle\android-ndk-r10b\samples\hello-jni目录，用ndk-build编译会生成libs和obj目录。

(3)  打开Eclipse，导入hello-jni后新增.settings、assets、bin和gen文件夹，以及.classpath与.project文件。

采用NDK开发APP部分功能的APK工程的目录结构介绍如下，新建Android工程后，右击工程名字，选择Android Tools--->Add Native Support可增加C/C++来开发APP的部分的功能。

包名：com.example.hellojni，类名：HelloJni

1.     .classpath和.project文件

从图1可知，用Eclipse导入hello-jni工程时会生成这两个文件，Eclipse将项目数据就是保存在这两个文件中。

1.1  .project文件

.project文件保存关于项目中包含哪些文件、如何使用它们、如何构建项目等方面的信息，以及更多的详细信息。

<?xmlversion="1.0" encoding="UTF-8"?>
<projectDescription>
<!-- 工程名称 -->
       <name>HelloJni</name>
<!—工程注释描述 -->
       <comment></comment>
       <projects>
       </projects>
       <!—builder指定 -->
       <buildSpec>
              <buildCommand>
                     <name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
                     <arguments>
                     </arguments>
              </buildCommand>
              <buildCommand>
                     <name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
                     <arguments>
                     </arguments>
              </buildCommand>
              <buildCommand>
                     <name>org.eclipse.jdt.core.javabuilder</name>
                     <arguments>
                     </arguments>
              </buildCommand>
              <buildCommand>
                     <name>com.android.ide.eclipse.adt.ApkBuilder</name>
                     <arguments>
                     </arguments>
              </buildCommand>
       </buildSpec>
       <natures>
              <nature>com.android.ide.eclipse.adt.AndroidNature</nature>
              <nature>org.eclipse.jdt.core.javanature</nature>
       </natures>
</projectDescription>

运行时需要的额外Eclipse插件<natures></natures>，及其具体加载方式信息<buildSpec></buildSpec>

Project Buildersand Natures的详细介绍，请参考：

http://www.eclipse.org/articles/Article-Builders/builders.html

1.2  .classpath文件

.classpath的位置定义了你这个项目在编译时所使用的$CLASSPATH，设置Classpath的目的，在于告诉Java执行环境，在哪些目录下可以找到您所要执行的Java程序所需要的类或者包。

<?xmlversion="1.0" encoding="UTF-8"?>
<classpath>
       <classpathentry kind="src"path="src"/>
       <classpathentry kind="src"path="gen"/>
       <classpathentry kind="con"path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
       <classpathentryexported="true" kind="con"path="com.android.ide.eclipse.adt.LIBRARIES"/>
       <classpathentryexported="true" kind="con"path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
       <classpathentrykind="output" path="bin/classes"/>
</classpath>

从数据上我们容易看出，上面描述了工程的依赖文件：

(1)  kind="src"，指定源文件位置, 对应工程属性Java build path中Source项中的一项, kind="src" 指明为源文件, 源文件路径path，如HelloJni.java保存在i\src\com\example\hellojni下面，而自动生成的BuildConfig.java和R.java保存在i\gen\com\example\hellojni目录下。

图2

(2)  kind="con"，con指container，就是程序运行的容器，或者说是运行环境也可以。

(3)  kind="output"，表示生成的.class文件，比如HelloJni.class存放的路径，见图2。

(4)  exported="true"表示导入第三方库，但这里实际上没有导入，见下图：

图3

总体上说这个文件就是配置整个工程的运行环境。

Eclipse打开hello-jni工程，默认情况下是看不到.classpath和.project文件的，需要

图4

不选择.*resources就OK了。

2.     AndroidManifest.XML

<?xmlversion="1.0" encoding="utf-8"?>
<manifestxmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example.hellojni"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdkandroid:minSdkVersion="3" />
    <applicationandroid:label="@string/app_name"
                android:debuggable="true">
        <activityandroid:name=".HelloJni"
                 android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <categoryandroid:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

这是应用程序HelloJni的配置文件，它所用的Activity组件HelloJni需要在这里配置才能使用。

3.     project.properties文件

主要内容如下：

# Project target.
target=android-19

定义了目标平台的API版本，此文件是由Android工具自动生成，不能手动修改。

4.     .settings和assets文件夹

.settigns文件夹下只有org.eclipse.jdt.core.prefs这文件，内容如下：

eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
org.eclipse.jdt.core.compiler.compliance=1.6
org.eclipse.jdt.core.compiler.source=1.6

1.6这里应该表示是JDK的版本，Windows->Preferences-->java->Compiler-->compilercompliance level可以设置，但是设置后并不会修改此文件。

Assets文件夹是空的。

5.     src\com\example\hellojni\HelloJni.java

packagecom.example.hellojni;

importandroid.app.Activity;
importandroid.widget.TextView;
importandroid.os.Bundle;

public classHelloJni extends Activity
{
    /** Called when the activity is firstcreated. */
    @Override
    public void onCreate(BundlesavedInstanceState)
    {
        super.onCreate(savedInstanceState);

        /* Create a TextView and set itscontent.
         * the text is retrieved by calling anative
         * function.
         */
        TextView  tv = new TextView(this);
        tv.setText( stringFromJNI() );
        setContentView(tv);
    }

    /* A native method that is implemented bythe
     * 'hello-jni' native library, which ispackaged
     * with this application.
     */
    public native String  stringFromJNI();

    /* This is another native methoddeclaration that is *not*
     * implemented by 'hello-jni'. This issimply to show that
     * you can declare as many native methodsin your Java code
     * as you want, their implementation issearched in the
     * currently loaded native libraries onlythe first time
     * you call them.
     *
     * Trying to call this function will resultin a
     * java.lang.UnsatisfiedLinkError exception!
     */
    public native String  unimplementedStringFromJNI();

    /* this is used to load the 'hello-jni'library on application
     * startup. The library has already beenunpacked into
     */data/data/com.example.hellojni/lib/libhello-jni.so at
     * installation time by the packagemanager.
     */
    static {
       System.loadLibrary("hello-jni");
    }
}

这里说明两点：

(1)  声明JNI办法

public nativeString  stringFromJNI();
public nativeString  unimplementedStringFromJNI();

可以看到这两个办法的声明中有native关键字，表示为本地办法，也就是说这两个办法是通过本地代码C/C++来实现的。

(2)  加载动态链接库

static {
       System.loadLibrary("hello-jni");
}

根据注释，可以知道在APP启动时会调用此代码来加载hello-jni动态链接库(完整名字为libhello-jni.so)。libhello-jni.so在被加载之前已经被放入到/data/data/com.example.HelloJni/lib/目录下。

static区声明的代码会先于onCreate方法执行。如果你的程序中有多个类，而且如果HelloJni这个类不是你应用程序的入口，那么hello-jni这个库会在第一次使用HelloJni这个类的时候加载。

JAVA通过JNI调用本地方法，而本地方法是以库文件的形式存放的（在WINDOWS平台上是DLL文件形式，在Android上是SO文件形式

6.     Jni下的源代码文件

从第5部分我们知道在HelloJni.java声明了JNI方法，但是需要用C/C++来实现的，可通过javah命令来生成对应的头文件，然后再根据头文件来写C/C++代码。

6.1  生成相应的.h文件

参考http://www.cnblogs.com/hibraincol/archive/2011/05/30/2063847.html，进入hello-jni目录下，用命令javah -classpath bin -d jnicom.example.hellojni.HelloJni

-classpath bin：表示类的路劲

-d jni: 表示生成的头文件存放的目录

com.example.hellojni.HelloJni则是完整类名

这一步的成功要建立在已经在 bin/com/example/hellojni/  目录下生成了 HelloJni.class的基础之上(编译该JAVA程序文件，生成CLASS，再用JAVAH命令，JNI就会生成C/C++的头文件)。

按照这个办法，编译出错：提示无法找到com.example.hellojni.HelloJni类文件，原因是我bin目录下还有一层目录 classes，然后改为下面的命令：

javah -classpathbin/classes -d jni com.example.hellojni.HelloJni

还是出错，提示无法找到android.app.Activity的类文件，参考：

http://blog.csdn.net/hejinjing_tom_com/article/details/8125648， 最后成功生成.h头文件的命令为：javah -classpath “D:\ADT-bundle\sdk\platforms\android-19\android.jar”;bin/classes-d
jni com.example.hellojni.HelloJni，如下图：

图5

在\jni文件及下生成com_example_hellojni_HelloJni.h文件。

/* DO NOT EDITTHIS FILE - it is machine generated */
#include<jni.h>
/* Header forclass com_example_hellojni_HelloJni */

#ifndef_Included_com_example_hellojni_HelloJni
#define_Included_com_example_hellojni_HelloJni
#ifdef __cplusplus
extern"C" {
#endif
#undefcom_example_hellojni_HelloJni_MODE_PRIVATE
#definecom_example_hellojni_HelloJni_MODE_PRIVATE 0L
…
/*
 * Class:    com_example_hellojni_HelloJni
 * Method:   stringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstringJNICALL Java_com_example_hellojni_HelloJni_stringFromJNI
  (JNIEnv *, jobject);

/*
 * Class:    com_example_hellojni_HelloJni
 * Method:   unimplementedStringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstringJNICALL Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

可以看到java定义的JNI方法stringFromJNI()，对应在C/C++方法是Java_com_example_hellojni_HelloJni_stringFromJNI，名字很长，不过比较有规律，按照java_pacakege_class_method 形式来命名，这里JNIEXPORT和JNICALL都是JNI的关键字，表示此函数是要被JNI调用的。

Signature:()Ljava/lang/String;

()表示函数的参数为空（这里为空是指除了JNIEnv *, jobject 这两个参数之外没有其他参数，JNIEnv*, jobject是所有jni函数必有的两个参数，分别表示jni环境和对应的java类（或对象）本身），Ljava/lang/String; 表示函数的返回值是java的String对象。

6.2  hello-jni.c

#include<string.h>
#include<jni.h>

/* This is a trivialJNI example where we use a native method
 * to return a new VM String. See thecorresponding Java source
 * file located at:
 *
 *  apps/samples/hello-jni/project/src/com/example/hellojni/HelloJni.java
 */
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI(JNIEnv* env,
                                                 jobject thiz )
{
       …
    return (*env)->NewStringUTF(env,"Hello from JNI !  Compiled with ABI" ABI ".");
}

这里只是实现了Java_com_example_hellojni_HelloJni_stringFromJNI方法，而 Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI方法并没有实现，因为在HelloJni.java中只调用了stringFromJNI()方法，所以unimplementedStringFromJNI()方法没有实现也没关系，不过建议最好还是把所有java中定义的本地方法都实现了。

Java_com_example_hellojni_HelloJni_stringFromJNI()函数只是简单的返回了一个内容为 " Hello from JNI !  Compiled with ABI " ABI "." 的jstring对象（对应于java中的String对象）。

6.3  Android.mk文件

LOCAL_PATH :=$(call my-dir)

include$(CLEAR_VARS)

LOCAL_MODULE    := hello-jni
LOCAL_SRC_FILES :=hello-jni.c

include$(BUILD_SHARED_LIBRARY)

(1)  LOCAL_PATH:= $(call my-dir)

一个Android.mk 文件首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’, 由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。

(2)  include$(CLEAR_VARS)

CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如 LOCAL_MODULE, LOCAL_SRC_FILES,LOCAL_STATIC_LIBRARIES, 等等...),

除LOCAL_PATH 。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。

(3)  LOCAL_MODULE    := hello-jni

编译的目标对象，LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。

注意：编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'hello-jni'的共享库模块，将会生成'libhello-jni.so'文件。

重要注意事项：

如果你把库命名为‘libhello-jni’，编译系统将不会添加任何的lib前缀，也会生成 'libhello-jni.so'，这是为了支持来源于Android平台的源代码的Android.mk文件，如果你确实需要这么做的话。

(4)  LOCAL_SRC_FILES:= hello-jni.c

LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。

注意，默认的C++源码文件的扩展名是’.cpp’. 指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION变量，不要忘记开始的小圆点（也就是’.cxx’,而不是’cxx’）

(5)  include$(BUILD_SHARED_LIBRARY)

BUILD_SHARED_LIBRARY表示编译生成共享库，是编译系统提供的变量，指向一个GNU Makefile脚本，负责收集自从上次调用'include $(CLEAR_VARS)'以来，定义在LOCAL_XXX变量中的所有信息，并且决定编译什么，如何正确地去做。还有 BUILD_STATIC_LIBRARY变量表示生成静态库：lib$(LOCAL_MODULE).a， BUILD_EXECUTABLE 表示生成可执行文件。

6.4  Application.mk文件

APP_ABI := all

Application.mk用来描述你的工程下的native模块, 一般放在$PROJECT/jni/Application.mk, 其中$PROJECT表示你的工程目录，这样就可以被ndk-build脚本文件找到

APP_ABI

在默认情况下，NDK会使用'armeabi' ABI 来生成二进制机器码，这是基于ARMv5TE的浮点运算CPU，这可以通过使用此变量来选项不同的ABI(Application Binary Interface).

例如:支持基于armv7 FPU指令集的设备:

APP_ABI :=armeabi-v7a

支持IA-32指令集：

APP_ABI := x86

同时支持三种：

APP_ABI := armeabiarmeabi-v7a x86

从NDK-r7版本后，同时支持三种还可以这样写：

APP_ABI := all

有关ABI更详细的内容请参考文档：docs/CPU-ARCH-ABIS.html。

6.5  编译生成.so共享库文件

进入工程hello-jni目录下，用ndk-build编译，生成libhello-jni.so，如下图：

图6

7.     生成apk

打开Eclipse导入HelloJni工程，重新编译生成apk，libhello-jni.so共享库会一起打包在apk文件内，在模拟器中看看运行结果：

图7

参考链接：

为何要用到NDK?

http://www.cnblogs.com/hibraincol/archive/2011/05/30/2063847.html

总结用cygwin+eclipse+NDK编译hellojni的详细步骤，以及所遇到问题的解决方法

http://www.verydemo.com/demo_c131_i6149.html

Eclipse .classpath文件浅谈:

http://mx19841031.iteye.com/blog/225593

NDK Application.mk使用手册

http://www.oschina.net/question/565065_93983