androidjni,Androidjni编程

android 怎么封装jni

一、底层实现:

网站建设哪家好，找创新互联建站！专注于网页设计、网站建设、微信开发、微信小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了新华免费建站欢迎大家使用！

c文件:hardware/libhardware_legacy/power/power.c

以其中set_screen_state(int)函数为例

其Android.mk中添加:

LOCAL_MODULE:= libpower 编译成lib

LOCAL_SRC_FILES += power.c

hardware/libhardware_legacy/power/power.c

1: int

2: set_screen_state(int on)

3: {

4: QEMU_FALLBACK(set_screen_state(on));

6: LOGI("*** set_screen_state %d", on);

8: initialize_fds();

10: //LOGI("go_to_sleep eventTime=%lld now=%lld g_error=%s\n", eventTime,

11: // systemTime(), strerror(g_error));

12:

13: if (g_error)

14: goto failure;

15:

16: char buf[32];

17: int len;

18: if(on)

19: len = snprintf(buf, sizeof(buf), "%s", on_state);

20: else

21: len = snprintf(buf, sizeof(buf), "%s", off_state);

22:

23: buf[sizeof(buf) - 1] = '\0';

24: len = write(g_fds[REQUEST_STATE], buf, len);

25: if(len 0) {

26: failure:

27: LOGE("Failed setting last user activity: g_error=%d\n", g_error);

28: }

29: return 0;

30: }

其头文件power.h中:

1: #if__cplusplus

2: extern "C" { //注1

3: #endif

4: enum {

5: PARTIAL_WAKE_LOCK = 1, // the cpu stays on, but the screen is off

6: FULL_WAKE_LOCK = 2 // the screen is also on

7: };

9: // while you have a lock held, the device will stay on at least at the

10: // level you request.

11: int acquire_wake_lock(int lock, const char* id);

12: int release_wake_lock(const char* id);

13:

14: // true if you want the screen on, false if you want it off

15: int set_screen_state(int on);

16:

17: // set how long to stay awake after the last user activity in seconds

18: int set_last_user_activity_timeout(int64_t delay);

19:

20:

21: #if __cplusplus

22: } // extern "C"

23: #endif

注1:

注1:extern表示其他的类已经定义了这段代码里面的内容，这里只是做声明。

"C”表示的一种编译和连接规约，这里为下一步c++调用其做准备.

比如void foo(int,int);该函数被C编译器编译后在库中的名字为_foo，

而C++编译器则会产生像_foo_int_int之类的名字用来支持函数重载和类型安全连接。

由于编译后的名字不同，C++程序不能直接调用C函数。

因此C++提供了一个C连接交换指定符号extern“C”来解决这个问题而不是一种语言。

C表示这段代码可以是符合C语言的编译和连接规约的任何语言，如Fortran、assembler等。

二、cpp构成jni桥梁

一个CPP文件调用之,则需添加其头文件,比如frameworks/base/core/jni/android_os_Power.cpp.

1: #include "JNIHelp.h"

2: #include "jni.h"

3: #include "android_runtime/AndroidRuntime.h"

4: #include hardware_legacy/power.h

5: namespace android{

6: ....

8: //定义函数:

9: static int setScreenState(JNIEnv *env, jobject clazz, jboolean on)

10: {

11: return set_screen_state(on);//以此实现cpp到c的调用

12: }

13:

14: static JNINativeMethod method_table[] = {//此处实现java对cpp的调用转化注2

15: { "acquireWakeLock", "(ILjava/lang/String;)V", (void*)acquireWakeLock },

16: { "releaseWakeLock", "(Ljava/lang/String;)V", (void*)releaseWakeLock },

17: { "setLastUserActivityTimeout", "(J)I", (void*)setLastUserActivityTimeout },

18: { "setScreenState", "(Z)I", (void*)setScreenState },

19: { "shutdown", "()V", (void*)android_os_Power_shutdown },

20: { "rebootNative", "(Ljava/lang/String;)V", (void*)android_os_Power_reboot },

21: };

22: int register_android_os_Power(JNIEnv *env) //此处注册jni

23: { //向VM(即AndroidRuntime)登记 gMethods[]表格所含的本地函数

24: return AndroidRuntime::registerNativeMethods(

25: env, "android/os/Power",

26: method_table, NELEM(method_table));

27: }

28: };

注2:

typedef struct {

const char* name; //Java中函数的名字

const char* signature; //用字符串是描述了函数的参数和返回值

void* fnPtr; //函数指针，指向C函数

} JNINativeMethod;

其中比较难以理解的是第二个参数，例如

"()V"

"(II)V"

"(Ljava/lang/String;Ljava/lang/String;)V"

实际上这些字符是与函数的参数类型一一对应的。

"()" 中的字符表示参数，后面的则代表返回值。例如"()V" 就表示void Func();

"(II)V" 表示 void Func(int, int);

具体的每一个字符的对应关系如下

字符 Java类型 C类型

V void void

Z jboolean boolean

I jint int

J jlong long

D jdouble double

F jfloat float

B jbyte byte

C jchar char

S jshort short

数组则以"["开始，用两个字符表示

[I jintArray int[]

[F jfloatArray float[]

[B jbyteArray byte[]

[C jcharArray char[]

[S jshortArray short[]

[D jdoubleArray double[]

[J jlongArray long[]

[Z jbooleanArray boolean[]

上面的都是基本类型。如果Java函数的参数是class，则以"L"开头，以";"结尾中间是用"/" 隔开的包及类名。而其对应的C函数名的参数则为jobject. 一个例外是String类，其对应的类为jstring

Ljava/lang/String; String jstring

Ljava/net/Socket; Socket jobject

如果JAVA函数位于一个嵌入类，则用$作为类名间的分隔符。

例如 "(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"

三、java的封装实现

frameworks/base/core/java/android/os/Power.java //此处路径跟cpp中注册jni处的路径是一致的.待细研究是否有关系

1: package android.os;

2: public class Power

3: {

4: ...

5: public static native int setScreenState(boolean on); //被native修饰的表示调用了非java语言的本地方法

6: ...

7: }

四、java中对其调用

frameworks/base/services/java/com/android/server/PowerManagerService.java

import android.os.Power;

public class PowerManagerService extends IPowerManager.Stub

implements LocalPowerManager, Watchdog.Monitor {

...

int err = Power.setScreenState(on);

...

}

android jni怎么使用

安装NDK,在eclipse里设置关联

首先你在类里面写native方法，如native String printHello();

设置静态方法块调用so文件，如static {System.loadLibrary("jnitest");}

右键工程-android tools-add native support

编写C/C++文件，对应.c/.cpp,如

JNIEXPORT jstring JNICALL Java_com_example_jnit_MainActivity_printHello

(JNIEnv *env, jobject obj){

return env-NewStringUTF("Hello world !");

}

编译运行

android 为什么要使用jni

android的jni可以使用c/c++来开发，相比java而言，运行的效率提高了很多，特别是在做一些图像算法，或者游戏逻辑的时候，使用jni将大大的提高效率。比如某个游戏要采用opengl，同样加载一个由1000个多边形组成的3d模型，jni要比java运算快好几倍，这样就保证了游戏运行的fps不会太低。

另外一个好处就是内存管理上面，java的内存管理全部由虚拟机来管理，C++由程序员来管理，利用率上面就好多了。

等等其他优点。

既然这么多的优点，为什么一个android程序不采用纯c来开发呢？因为是android的 UI framework采用java，所以，在UI上面还是采用java来开发。

如何在Android下使用JNI

1.引言

我们知道，Android系统的底层库由c/c++编写，上层Android应用程序通过Java虚拟机调用底层接口，衔接底层c/c++库与Java应用程序间的接口正是JNI（JavaNative Interface)。本文描述了如何在ubuntu下配置AndroidJNI的开发环境，以及如何编写一个简单的c函数库和JNI接口，并通过编写Java程序调用这些接口，最终运行在模拟器上的过程。

2.环境配置

2.1.安装jdk1.6

（1）从jdk官方网站下载jdk-6u29-linux-i586.bin文件。

（2）执行jdk安装文件

[html] view plaincopyprint?

01.$chmod a+x jdk-6u29-linux-i586.bin

02.$jdk-6u29-linux-i586.bin

$chmod a+x jdk-6u29-linux-i586.bin

$jdk-6u29-linux-i586.bin

(3)配置jdk环境变量

[html] view plaincopyprint?

01.$sudo vim /etc/profile

02.#JAVAEVIRENMENT

03.exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29

04.exportJRE_HOME=$JAVA_HOME/jre

05.exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH

06.exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

$sudo vim /etc/profile

#JAVAEVIRENMENT

exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29

exportJRE_HOME=$JAVA_HOME/jre

exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH

exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

保存后退出编辑，并重启系统。

（4）验证安装

[html] view plaincopyprint?

01.$java -version

02.javaversion "1.6.0_29"

03.Java(TM)SE Runtime Environment (build 1.6.0_29-b11)

04.JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)

05.$javah

06.用法：javah[选项]类

07.其中[选项]包括：

08.-help输出此帮助消息并退出

09.-classpath路径用于装入类的路径

10.-bootclasspath路径用于装入引导类的路径

12.-o文件输出文件（只能使用-d或-o中的一个）

13.-jni生成JNI样式的头文件（默认）

14.-version输出版本信息

15.-verbose启用详细输出

16.-force始终写入输出文件

17.使用全限定名称指定类（例

18.如，java.lang.Object）。

$java -version

javaversion "1.6.0_29"

Java(TM)SE Runtime Environment (build 1.6.0_29-b11)

JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)

$javah

用法：javah[选项]类

其中[选项]包括：

-help输出此帮助消息并退出

-classpath路径用于装入类的路径

-bootclasspath路径用于装入引导类的路径

-o文件输出文件（只能使用-d或-o中的一个）

-jni生成JNI样式的头文件（默认）

-version输出版本信息

-verbose启用详细输出

-force始终写入输出文件

使用全限定名称指定类（例

如，java.lang.Object）。2.2.安装android应用程序开发环境

ubuntu下安装android应用程序开发环境与windows类似，依次安装好以下软件即可：

（1）Eclipse

（2）ADT

（3）AndroidSDK

与windows下安装唯一不同的一点是，下载这些软件的时候要下载Linux版本的安装包。

安装好以上android应用程序的开发环境后，还可以选择是否需要配置emulator和adb工具的环境变量，以方便在进行JNI开发的时候使用。配置步骤如下：

把emulator所在目录android-sdk-linux/tools以及adb所在目录android-sdk-linux/platform-tools添加到环境变量中，android-sdk-linux指androidsdk安装包android-sdk_rxx-linux的解压目录。

[plain] view plaincopyprint?

01.$sudo vim /etc/profile

02.exportPATH=~/software/android/android-sdk-linux/tools:$PATH

03. exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH

$sudo vim /etc/profile

exportPATH=~/software/android/android-sdk-linux/tools:$PATH

exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH

编辑完毕后退出，并重启生效。

2.3.安装NDK

NDK是由android提供的编译android本地代码的一个工具。

（1）从androidndk官网下载ndk，目前最新版本为android-ndk-r6b-linux-x86.tar.bz2.

（2）解压ndk到工作目录：

[plain] view plaincopyprint?

01.$tar -xvf android-ndk-r6b-linux-x86.tar.bz2

02.$sudo mv android-ndk-r6b /usr/local/ndk

$tar -xvf android-ndk-r6b-linux-x86.tar.bz2

$sudo mv android-ndk-r6b /usr/local/ndk

（3）设置ndk环境变量

[plain] view plaincopyprint?

01.$sudo vim /etc/profile

02.exportPATH=/usr/local/ndk:$PATH

$sudo vim /etc/profile

exportPATH=/usr/local/ndk:$PATH

编辑完毕后保存退出，并重启生效

（4）验证安装

[plain] view plaincopyprint?

01.$ cd/usr/local/ndk/samples/hello-jni/

02.$ ndk-build

03.Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver

04.Gdbsetup : libs/armeabi/gdb.setup

05.Install : libhello-jni.so = libs/armeabi/libhello-jni.so

$ cd/usr/local/ndk/samples/hello-jni/

$ ndk-build

Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver

Gdbsetup : libs/armeabi/gdb.setup

Install : libhello-jni.so = libs/armeabi/libhello-jni.so

3.JNI实现

我们需要定义一个符合JNI接口规范的c/c++接口，这个接口不用太复杂，例如输出一个字符串。接下来，则需要把c/c++接口的代码文件编译成共享库（动态库）.so文件，并放到模拟器的相关目录下。最后，启动Java应用程序，就可以看到最终效果了。

3.1.编写Java应用程序代码

（1）启动Eclipse，新建android工程

Project：JNITest

Package：org.tonny.jni

Activity：JNITest

（2）编辑资源文件

编辑res/values/strings.xml文件如下：

编辑res/layout/main.xml文件

我们在主界面上添加了一个EditText控件和一个Button控件。

（3）编辑JNITest.java文件

static表示在系统第一次加载类的时候，先执行这一段代码，在这里表示加载动态库libJNITest.so文件。

再看这一段：

[java] view plaincopyprint?

01.privatenativeString GetReply();

privatenativeString GetReply();

native表示这个方法由本地代码定义，需要通过jni接口调用本地c/c++代码。

[java] view plaincopyprint?

01.publicvoidonClick(View arg0) {

02.edtName.setText(reply);

03.}

publicvoidonClick(View arg0) {

edtName.setText(reply);

}

这段代码表示点击按钮后，把native方法的返回的字符串显示到EditText控件。

（4）编译工程，生成.class文件。

3.2.用javah工具生成符合JNI规范的c语言头文件

在终端中，进入android工程所在的bin目录

[plain] view plaincopyprint?

01.$cd ~/project/Android/JNITest/bin

$cd ~/project/Android/JNITest/bin

我们用ls命令查看，可以看到bin目录下有个classes目录，其目录结构为classes/org/tonny/jni，即classes的子目录结构是android工程的包名org.tonny.jni。请注意，下面我们准备执行javah命令的时候，必须进入到org/tonny/jni的上级目录，即classes目录，否则javah会提示找不到相关的java类。

下面继续：

[plain] view plaincopyprint?

01.$cd classes

02.$javah org.tonny.jni.JNITest

03.$ls

04.org org_tonny_jni_JNITest.h

$cd classes

$javah org.tonny.jni.JNITest

$ls

org org_tonny_jni_JNITest.h

执行javahorg.tonny.jni.JNITest命令，在classes目录下会生成org_tonny_jni_JNITest.h头文件。如果不进入到classes目录下的话，也可以这样：

[plain] view plaincopyprint?

01.$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest

$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest

-classpath 参数表示装载类的目录。

3.3.编写c/c++代码

生成org_tonny_jni_JNITest.h头文件后，我们就可以编写相应的函数代码了。下面在android工程目录下新建jni目录，即~/project/Android/JNITest/jni，把org_tonny_jni_JNITest.h头文件拷贝到jni目录下，并在jni目录下新建org_tonny_jni_JNITest.c文件，编辑代码如下：

[cpp] view plaincopyprint?

01.#includejni.h

02.#includestring.h

03.#include"org_tonny_jni_JNITest.h"

04.

05.

06.JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply

07.(JNIEnv *env, jobject obj){

08.return(*env)-NewStringUTF(env,(char*)"Hello,JNITest");

09.}

#includejni.h

#includestring.h

#include"org_tonny_jni_JNITest.h"

JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply

(JNIEnv *env, jobject obj){

return(*env)-NewStringUTF(env,(char*)"Hello,JNITest");

}

我们可以看到，该函数的实现相当简单，返回一个字符串为："Hello,JNITest"

3.4.编写Android.mk文件

在~/project/Android/JNITest/jni目录下新建Android.mk文件，android可以根据这个文件的编译参数编译模块。编辑Android.mk文件如下：

[plain] view plaincopyprint?

01.LOCAL_PATH:= $(call my-dir)

02.include$(CLEAR_VARS)

03.LOCAL_MODULE := libJNITest

04.LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c

05.include$(BUILD_SHARED_LIBRARY)

LOCAL_PATH:= $(call my-dir)

include$(CLEAR_VARS)

LOCAL_MODULE := libJNITest

LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c

include$(BUILD_SHARED_LIBRARY)

LOCAL_MODULE表示编译的动态库名称

LOCAL_SRC_FILES 表示源代码文件

3.5.用ndk工具编译并生成.so文件

进入到JNITest的工程目录，执行ndk-build命令即可生成libJNITest.so文件。

[plain] view plaincopyprint?

01.$cd ~/project/Android/JNITest/

02.$ndk-build

03.Invalidattribute name:

04.package

05.Install : libJNITest.so = libs/armeabi/libJNITest.so

$cd ~/project/Android/JNITest/

$ndk-build

Invalidattribute name:

package

Install : libJNITest.so = libs/armeabi/libJNITest.so

可以看到，在工程目录的libs/armeabi目录下生成了libJNITest.so文件。

3.6.在模拟器上运行

（1）首先，我们把android模拟器启动起来。进入到emulator所在目录，执行emulator命令：

[plain] view plaincopyprint?

01.$cd ~/software/android/android-sdk-linux/tools

02.$./emulator @AVD-2.3.3-V10 -partition-size 512

$cd ~/software/android/android-sdk-linux/tools

$./emulator @AVD-2.3.3-V10 -partition-size 512

AVD-2.3.3-V10表示你的模拟器名称，与在Eclipse-AVDManager下的AVDName对应，-partition-size表示模拟器的存储设备容量。

（2）接下来，我们需要把libJNITest.so文件拷贝到模拟器的/system/lib目录下，执行以下命令：

[plain] view plaincopyprint?

01.$cd ~/project/Android/JNITest/libs/armeabi/

02.$adb remount

03.$adb push libJNITest.so /system/lib

04.80 KB/s (10084 bytes in 0.121s)

$cd ~/project/Android/JNITest/libs/armeabi/

$adb remount

$adb push libJNITest.so /system/lib

80 KB/s (10084 bytes in 0.121s)

当在终端上看到有80 KB/s (10084 bytes in 0.121s)传输速度等信息的时候，说明拷贝成功。

（3）在终端上执行JNITest程序，这个我们可以在Eclipse下，右键点击JNITest工程，RunAs-Android Application，即可在模拟器上启动程序

名称栏目：androidjni,Androidjni编程
转载源于：http://6mz.cn/article/hosdge.html

网站建设知识

androidjni,Androidjni编程

android 怎么封装jni

android jni怎么使用

android 为什么要使用jni

如何在Android下使用JNI

其他资讯