Android中JNI调用

最新推荐文章于 2023-02-03 16:19:48 发布
最新推荐文章于 2023-02-03 16:19:48 发布
阅读量787 收藏
点赞数
分类专栏： android系统开发 文章标签： android jni class java module iterator

http://blog.csdn.net/xyz_lmn/article/details/6955031

  android支持使用NDK开发C程序，关于配置NDK环境问题应该不用再赘述了，这个网上有很多，这里通过一篇实例来讲述简单的JNI开发，大家可以参考这篇文章（Get Your Eclipse-Integrated NDK On!）搭建Eclipse编译C语言为so文件的开发环境。

        native方法实现步骤如下：

        1、在Java中声明native()方法，然后编译（javac）； 

      2、用javah产生一个.h文件； 

      3、编写包含.h文件的c文件

      4、编译c文件

      5、使用编译成功的so文件。

 

       第一步：

              1、声明native方法

                 

[java]  view plain copy
  1. public class Printf_Jni {  
  2.   
  3.      static {  
  4.             System.loadLibrary("com_nedu_jni_helloword_printf-jni");  
  5.         }  
  6.     public native void printHello();  
  7. }  

       2、javac编译

            进入java文件所在路径，调用javac命令，如图：

             

第二步：使用javah命令生成.h头文件，如图：

           

     这个要回到src目录下，不知道什么原因，如果在上面的javac路径下会报错，如图：

       

      使用javah命令生成的头文件如下：

[cpp]  view plain copy
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class com_nedu_jni_helloword_Printf_Jni */  
  4.   
  5. #ifndef _Included_com_nedu_jni_helloword_Printf_Jni  
  6. #define _Included_com_nedu_jni_helloword_Printf_Jni  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     com_nedu_jni_helloword_Printf_Jni 
  12.  * Method:    printHello 
  13.  * Signature: ()V 
  14.  */  
  15. JNIEXPORT void JNICALL Java_com_nedu_jni_helloword_Printf_1Jni_printHello  
  16.   (JNIEnv *, jobject);  
  17.   
  18. #ifdef __cplusplus  
  19. }  
  20. #endif  
  21. #endif  

第三步：编写c文件,代码如下：

[cpp]  view plain copy
  1. #include<stdio.h>    
  2. #include <stdlib.h>    
  3. #include "com_nedu_jni_helloword_Printf_Jni.h"    
  4. JNIEXPORT void JNICALL Java_com_nedu_jni_helloword_Printf_1Jni_printHello  
  5.   (JNIEnv *e, jobject j)    
  6. {    
  7.     printf("Hello world!");   
  8. }    

第四步，书写Android.mk文件，编译c文件
        Android.mk文件如下：

     

[plain]  view plain copy
  1. LOCAL_PATH := $(call my-dir)  
  2.   
  3. include $(CLEAR_VARS)  
  4.   
  5. LOCAL_MODULE    := com_nedu_jni_helloword_printf-jni  
  6. LOCAL_SRC_FILES :=Printf_Jni.c  
  7.   
  8. include $(BUILD_SHARED_LIBRARY)  


LOCAL_MODULE    := com_nedu_jni_helloword_printf-jniLOCAL_MODULE    := com_nedu_jni_helloword_printf-jniLOCAL_MODULE  表示so文件名

LOCAL_SRC_FILES 需要编译的文件

按照这篇文章（Get Your Eclipse-Integrated NDK On!）的介绍就可以在Eclipse编译了。

第五步：使用so文件：

    通过下面的代码加载so文件

[html]  view plain copy
  1. System.loadLibrary("com_nedu_jni_helloword_printf-jni");  


通过下面的代码加载so文件通过下面的代码加载so文件

调用如下：

[java]  view plain copy
  1. Printf_Jni print=new Printf_Jni();   
[java]  view plain copy
  1. print.printHello();  

 

http://blog.csdn.net/xyz_lmn/article/details/6956003

 前面一篇通过简单的例子介绍了android中JNI的使用。这一篇从基础上了解一些Java参数类型与本地参数类型区别。

 

1)        java中的返回值void和JNI中的void是完全对应的哦！（仅仅一个而已）。

2)        java中的基本数据类型（byte ,short ,int,long,float,double ,boolean,char－8种）在JNI中对应的数据类型只要在前面加上j就对应了（jbyte ,jshort ,jint,jlong,jfloat,jdouble ,jboolean,jchar）。

3)        java中的对象，包括类库中定义的类、接口以及自定义的类接口，都对应于JNI中的jobject。

4)        java中基本数据类型的数组对应与JNI中的j<type>array类型。（type就是上面说的8种基本数据类型）

5)        java中对象的数组对应于JNI中的jobjectArray类型。（在java中一切对象、接口以及数组都是对象）

 

       下图是JNI规范中java数据类型和JNI数据类型的映射图。

       第一幅为基本数据类型的映射图：

 

 

  第二幅为引用数据类型的映射图：

http://blog.csdn.net/xyz_lmn/article/details/6959545

一、 首先写了java文件：

[java]  view plain copy
  1. public class HeaderFile {  
  2.     private native void  doVoid();  
  3.     native int doShort();  
  4.     native void doArray(Object[] o );  
  5.     native int doInt(int i);      //byte ,short ,int,long,float,double ,boolean,char        
  6.     native int doInt(double d);    //byte ,short ,int,long,float,double ,boolean,char  
  7.     native int doInt(Object o);      
  8.     native int doInt(double d1,double d2);  
  9.     static native int doInt(double d1 ,double d2,double d3);  
  10.     static native int doInt(double d1 ,float f,boolean b ,char[] c );    
  11.      
  12.     native int doInt(int[] i);  
  13.     native int doInt(int[] i1,double[] i2 );      
  14.     static native int doInt(int[] i1,double[] i2 ,Object[] o );  
  15.      
  16.     public native String doString(String s);  
  17.     public native Object doObject(Object o );  
  18.     public native Enumeration doInterface(Iterator it);  
  19.     public native Student doStudent(Student s);  
  20.      
  21. //  native int[] doInt(int[] i);  //byte ,short ,int,long,float,double ,boolean,char  
  22.     public native String[] doString(String[] s);  
  23.     public native Object[] doObjects(Object[] o );  
  24.     public native Enumeration[] doInterface(Iterator[] it);  
  25.     public native Student[] doStudent(Student[] s);  
  26.             
  27.     public native static Object doAll(int[] i , String[] s , Student[] student );               
  28. }  

                         java文件中包含了private、public、protect等类型的方法，static 方法和非static 方法，返回类型有基础类型、对象等。

           二、下面看一下生成的头文件：

[cpp]  view plain copy
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class com_nedu_jni_helloword_HeaderFile */  
  4.   
  5. #ifndef _Included_com_nedu_jni_helloword_HeaderFile  
  6. #define _Included_com_nedu_jni_helloword_HeaderFile  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     com_nedu_jni_helloword_HeaderFile 
  12.  * Method:    doVoid 
  13.  * Signature: ()V 
  14.  */  
  15. JNIEXPORT void JNICALL Java_com_nedu_jni_helloword_HeaderFile_doVoid  
  16.   (JNIEnv *, jobject);  
  17.   
  18. /* 
  19.  * Class:     com_nedu_jni_helloword_HeaderFile 
  20.  * Method:    doShort 
  21.  * Signature: ()I 
  22.  */  
  23. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doShort  
  24.   (JNIEnv *, jobject);  
  25.   
  26. /* 
  27.  * Class:     com_nedu_jni_helloword_HeaderFile 
  28.  * Method:    doArray 
  29.  * Signature: ([Ljava/lang/Object;)V 
  30.  */  
  31. JNIEXPORT void JNICALL Java_com_nedu_jni_helloword_HeaderFile_doArray  
  32.   (JNIEnv *, jobject, jobjectArray);  
  33.   
  34. /* 
  35.  * Class:     com_nedu_jni_helloword_HeaderFile 
  36.  * Method:    doInt 
  37.  * Signature: (I)I 
  38.  */  
  39. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__I  
  40.   (JNIEnv *, jobject, jint);  
  41.   
  42. /* 
  43.  * Class:     com_nedu_jni_helloword_HeaderFile 
  44.  * Method:    doInt 
  45.  * Signature: (D)I 
  46.  */  
  47. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__D  
  48.   (JNIEnv *, jobject, jdouble);  
  49.   
  50. /* 
  51.  * Class:     com_nedu_jni_helloword_HeaderFile 
  52.  * Method:    doInt 
  53.  * Signature: (Ljava/lang/Object;)I 
  54.  */  
  55. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__Ljava_lang_Object_2  
  56.   (JNIEnv *, jobject, jobject);  
  57.   
  58. /* 
  59.  * Class:     com_nedu_jni_helloword_HeaderFile 
  60.  * Method:    doInt 
  61.  * Signature: (DD)I 
  62.  */  
  63. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__DD  
  64.   (JNIEnv *, jobject, jdouble, jdouble);  
  65.   
  66. /* 
  67.  * Class:     com_nedu_jni_helloword_HeaderFile 
  68.  * Method:    doInt 
  69.  * Signature: (DDD)I 
  70.  */  
  71. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__DDD  
  72.   (JNIEnv *, jclass, jdouble, jdouble, jdouble);  
  73.   
  74. /* 
  75.  * Class:     com_nedu_jni_helloword_HeaderFile 
  76.  * Method:    doInt 
  77.  * Signature: (DFZ[C)I 
  78.  */  
  79. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__DFZ_3C  
  80.   (JNIEnv *, jclass, jdouble, jfloat, jboolean, jcharArray);  
  81.   
  82. /* 
  83.  * Class:     com_nedu_jni_helloword_HeaderFile 
  84.  * Method:    doInt 
  85.  * Signature: ([I)I 
  86.  */  
  87. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt___3I  
  88.   (JNIEnv *, jobject, jintArray);  
  89.   
  90. /* 
  91.  * Class:     com_nedu_jni_helloword_HeaderFile 
  92.  * Method:    doInt 
  93.  * Signature: ([I[D)I 
  94.  */  
  95. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt___3I_3D  
  96.   (JNIEnv *, jobject, jintArray, jdoubleArray);  
  97.   
  98. /* 
  99.  * Class:     com_nedu_jni_helloword_HeaderFile 
  100.  * Method:    doInt 
  101.  * Signature: ([I[D[Ljava/lang/Object;)I 
  102.  */  
  103. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt___3I_3D_3Ljava_lang_Object_2  
  104.   (JNIEnv *, jclass, jintArray, jdoubleArray, jobjectArray);  
  105.   
  106. /* 
  107.  * Class:     com_nedu_jni_helloword_HeaderFile 
  108.  * Method:    doString 
  109.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  110.  */  
  111. JNIEXPORT jstring JNICALL Java_com_nedu_jni_helloword_HeaderFile_doString__Ljava_lang_String_2  
  112.   (JNIEnv *, jobject, jstring);  
  113.   
  114. /* 
  115.  * Class:     com_nedu_jni_helloword_HeaderFile 
  116.  * Method:    doObject 
  117.  * Signature: (Ljava/lang/Object;)Ljava/lang/Object; 
  118.  */  
  119. JNIEXPORT jobject JNICALL Java_com_nedu_jni_helloword_HeaderFile_doObject  
  120.   (JNIEnv *, jobject, jobject);  
  121.   
  122. /* 
  123.  * Class:     com_nedu_jni_helloword_HeaderFile 
  124.  * Method:    doInterface 
  125.  * Signature: (Ljava/util/Iterator;)Ljava/util/Enumeration; 
  126.  */  
  127. JNIEXPORT jobject JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInterface__Ljava_util_Iterator_2  
  128.   (JNIEnv *, jobject, jobject);  
  129.   
  130. /* 
  131.  * Class:     com_nedu_jni_helloword_HeaderFile 
  132.  * Method:    doStudent 
  133.  * Signature: (Lcom/nedu/jni/helloword/Student;)Lcom/nedu/jni/helloword/Student; 
  134.  */  
  135. JNIEXPORT jobject JNICALL Java_com_nedu_jni_helloword_HeaderFile_doStudent__Lcom_nedu_jni_helloword_Student_2  
  136.   (JNIEnv *, jobject, jobject);  
  137.   
  138. /* 
  139.  * Class:     com_nedu_jni_helloword_HeaderFile 
  140.  * Method:    doString 
  141.  * Signature: ([Ljava/lang/String;)[Ljava/lang/String; 
  142.  */  
  143. JNIEXPORT jobjectArray JNICALL Java_com_nedu_jni_helloword_HeaderFile_doString___3Ljava_lang_String_2  
  144.   (JNIEnv *, jobject, jobjectArray);  
  145.   
  146. /* 
  147.  * Class:     com_nedu_jni_helloword_HeaderFile 
  148.  * Method:    doObjects 
  149.  * Signature: ([Ljava/lang/Object;)[Ljava/lang/Object; 
  150.  */  
  151. JNIEXPORT jobjectArray JNICALL Java_com_nedu_jni_helloword_HeaderFile_doObjects  
  152.   (JNIEnv *, jobject, jobjectArray);  
  153.   
  154. /* 
  155.  * Class:     com_nedu_jni_helloword_HeaderFile 
  156.  * Method:    doInterface 
  157.  * Signature: ([Ljava/util/Iterator;)[Ljava/util/Enumeration; 
  158.  */  
  159. JNIEXPORT jobjectArray JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInterface___3Ljava_util_Iterator_2  
  160.   (JNIEnv *, jobject, jobjectArray);  
  161.   
  162. /* 
  163.  * Class:     com_nedu_jni_helloword_HeaderFile 
  164.  * Method:    doStudent 
  165.  * Signature: ([Lcom/nedu/jni/helloword/Student;)[Lcom/nedu/jni/helloword/Student; 
  166.  */  
  167. JNIEXPORT jobjectArray JNICALL Java_com_nedu_jni_helloword_HeaderFile_doStudent___3Lcom_nedu_jni_helloword_Student_2  
  168.   (JNIEnv *, jobject, jobjectArray);  
  169.   
  170. /* 
  171.  * Class:     com_nedu_jni_helloword_HeaderFile 
  172.  * Method:    doAll 
  173.  * Signature: ([I[Ljava/lang/String;[Lcom/nedu/jni/helloword/Student;)Ljava/lang/Object; 
  174.  */  
  175. JNIEXPORT jobject JNICALL Java_com_nedu_jni_helloword_HeaderFile_doAll  
  176.   (JNIEnv *, jclass, jintArray, jobjectArray, jobjectArray);  
  177.   
  178. #ifdef __cplusplus  
  179. }  
  180. #endif  
  181. #endif  


         三、头文件分析如下：

                       1、文件的前九行就不用说了，他们是是C、C++的头，应该很好理解。

          2、方法的注释部分，每个方法都有它的注释部分，这些都是相似的，对其中一个分析：

[plain]  view plain copy
  1. /*  
  2.  * Class:     com_nedu_jni_helloword_HeaderFile  
  3.  * Method:    doVoid  
  4.  * Signature: ()V  
  5.  */  

注释部分分为三部分Class、Method、Signature。

Class：表示Native方法的类名称。

Method：表示方法名称

Signature：是方法的标识，它是一个标识符，主要供我们在JNI操作java对象的方法使用的。

Signature一般是两部分构成，一个方法的参数，另一个是返回类型。方法参数在括号里面，返回类型在后面，

例如

[plain]  view plain copy
  1. ()V 返回为void，没有参数。  
[plain]  view plain copy
  1. (DFZ[C)I 返回为int，参数为double、float、char[]  
[plain]  view plain copy
  1. (Ljava/lang/String;)Ljava/lang/String;返回String，参数为String  


如果不清楚其中的字符含义，就不能知道其中的意思，其中字符对应有基本类型、对象类型、数组类型。分析如下

1）基本类型的对应关系如下：

2） 方法参数或者返回值为java中的对象时，必须以“L”加上其路径，不过此路径必须以“/”分开，自定义的对象也使用本规则，不在包中时直接“L”加上类名称。比如说java.lang.String为“java/lang/String”,com.nedu.jni.helloword.Student为"com/nedu/jni/helloword/Student"

3)方法参数或者返回值为数组时类型前加上[,例如[I表示int[],[[[D表示 double[][][]，即几维数组就加几个[。

看一下例子：

3、方法的声明

[cpp]  view plain copy
  1. JNIEXPORT void JNICALL Java_com_nedu_jni_helloword_HeaderFile_doArray(JNIEnv *,jobject,jobjectArray);  

      从上面的头文件可以看出方法基本有7部分组成。

          

1、3部分是都是JNI的关键字，表示此函数是要被JNI调用的。

2、表示方法的返回类型

4、为JNI中标识此方法来源于java的标识头

5、方法所在类的包名+类名

6、方法名

7、参数，它们有一个共同的特点，包含JNIEnv *――它是一个接口指针，用于定位函数表中的函数！

     在JNI规范中一般称  为   “Interface Pointer”。看到这儿好像和过程调用很类似了！是的，JNI中

     的操作过程，就是面向过程的！后面的jobject是  一个指向该类的指针，类似与C语言中的this。这个

     第二个参数是变化的，当该方法为类的实例方法时该参数为jobject；当该方法为类方法（即静态方法）

     时该参数为jclass，指向该类的class。

根据不同方法前缀生成的头文件比较如下：

1、static与非static的比较：

[cpp]  view plain copy
  1. /* 
  2.  * Class:     com_nedu_jni_helloword_HeaderFile 
  3.  * Method:    doInt 
  4.  * Signature: (DD)I 
  5.  */  
  6. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__DD  
  7.   (JNIEnv *, <span style="background-color: rgb(255, 0, 0);">jobject</span>, jdouble, jdouble);  
  8.   
  9. /* 
  10.  * Class:     com_nedu_jni_helloword_HeaderFile 
  11.  * Method:    doInt 
  12.  * Signature: (DDD)I 
  13.  */  
  14. JNIEXPORT jint JNICALL Java_com_nedu_jni_helloword_HeaderFile_doInt__DDD  
  15.   (JNIEnv *, <span style="color:#000000;background-color: rgb(255, 0, 0);">jclass</span>, jdouble, jdouble, jdouble);  

第一个是非static方法，第二个是static方法，不同点如上红色标记。其中的不同将在以后提到。

2、 private、friendly、protected以及public这些方法限制符不会在JNI的头文件中出现。这些访问修饰符只有在其它类

       使用这些方法时有效！JNI中不关心此修饰符！

http://blog.csdn.net/xyz_lmn/article/details/6966259

Android.mk文件是在使用NDK编译C代码时必须的文件，Android.mk文件中描述了哪些C文件将被编译且指明了如何编译。掌握Android.mk文件的编写主要是掌握其里头将要使用的一些关键字，先来看一个简单的例子，这个例子使用的是android NDK带的

HellJni的例子。

[plain]  view plain copy
  1. LOCAL_PATH := $(call my-dir)  
  2.   
  3. include $(CLEAR_VARS)  
  4.   
  5. LOCAL_MODULE    := hello-jni  
  6. LOCAL_SRC_FILES := hello-jni.c  
  7.   
  8. include $(BUILD_SHARED_LIBRARY)  


 

LOCAL_PATH 是描述所有要编译的C文件所在的根目录，这边的赋值为$(call my-dir)，代表根目录即为Android.mk所在的目录。

 

include $(CLEAR_VARS) 代表在使用NDK编译工具时对编译环境中所用到的全局变量清零，如LOCAL_MODULE，LOCAL_SRC_FILES等，因为在一次NDK编译过程中可能会多次调用Android.mk文件，中间用到的全局变量可能是变化的。关于这个问题看了下面比较复杂的例子可能就明白了。

 

LOCAL_MODULE 是最后生成库时的名字的一部分，给其加上前缀lib和后缀.so就是生成的共享库的名字libhello-jni.so。

 

LOCAL_SRC_FILES 指明要被编译的c文件的文件名

 

include $(BUILD_SHARED_LIBRARY) 指明NDK编译时将生成一些共享库

 

 

参考：

 

android编译系统makefile(Android.mk)写法

 

android makefile(android.mk)分析（序）

 

Android.mk的用法和基础

 


<!-- JiaThis Button BEGIN -->
<div id="ckepop">
 <a href="http://www.jiathis.com/share" class="jiathis jiathis_txt" target="_blank"><img src="http://v2.jiathis.com/code_mini/images/btn/v1/jiathis1.gif" border="0" /></a>
 <a class="jiathis_counter_style_margin:3px 0 0 2px"></a>
</div>
<script type="text/javascript" src="http://v2.jiathis.com/code_mini/jia.js" charset="utf-8"></script>
<!-- JiaThis Button END --><!-- JiaThis Button BEGIN -->
<div id="ckepop">
 <a href="http://www.jiathis.com/share" class="jiathis jiathis_txt" target="_blank"><img src="http://v2.jiathis.com/code_mini/images/btn/v1/jiathis1.gif" border="0" /></a>
 <a class="jiathis_counter_style_margin:3px 0 0 2px"></a>
</div>
<script type="text/javascript" src="http://v2.jiathis.com/code_mini/jia.js" charset="utf-8"></script>
<!-- JiaThis Button END -->

 

参考网址：

http://blog.csdn.net/xyz_lmn/article/details/6959545

 Android JNI入门第三篇——jni头文件分析 

http://blog.csdn.net/xyz_lmn/article/details/6966259

 Android JNI入门第四篇——Android.mk文件分析

http://blog.csdn.net/xyz_lmn/article/details/7017420

 Android JNI开发提高篇 

http://blog.csdn.net/xyz_lmn/article/details/6956003

 Android JNI入门第二篇——Java参数类型与本地参数类型对照

 

http://wenku.baidu.com/view/e9e28ca1b0717fd5360cdc18.html

JNI入门

http://www.ibm.com/developerworks/cn/java/j-jni/

使用 Java Native Interface 的最佳实践

http://helloxuweifu.iteye.com/blog/1168647

http://blog.csdn.net/kangyaping/article/details/6584027

JNI函数调用大全

 

http://newfaction.net/2010/11/30/java-jni-getfieldid-and-getmethodid-and-parameter-description.html

java jni GetFieldID 和 GetMethodID 以及参数的说明

http://hi.baidu.com/spmno/blog/item/7d4d764ea78a6809b3de0588.html

jni中使用数组的几个方法

http://xxw8393.blog.163.com/blog/static/3725683420107109411366/

JNI 返回结构体参数 

http://www.cnblogs.com/nicholas_f/archive/2010/11/30/1892124.html

JNI中java类型与C/C++类型对应关系

http://blog.csdn.net/sunny09290/article/details/6884994

JNI数据类型

http://www.cnblogs.com/liangwind/archive/2009/08/18/1925515.html

jni　--c/c++　数据类型、数组、对象

http://www.cnblogs.com/diyunpeng/archive/2009/09/24/1573296.html

Java有符号数与无符号数

http://www.stuhack.com/biancheng/java/35169.html

Java的基本数据类型是无符号的


niepengpeng333
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android工程调用jni算法（参数和返回值都为数组）
05-18
网上有很多资料介绍jni数组，但是往往都是或者传递的参数为数组或者返回值为数组，本人看后自己写了一个二者都为数组的情形 可以直接用eclipse进行导入
[转]Android JNI使用方法
weixin_34249678的博客
02-03 107
本文转自：http://www.open-open.com/lib/view/open1324909652374.html   经过几天的努力终于搞定了android JNI部分，下面将我的这个小程序和大家分享一下。android JNI是连接android Java部分和C/C++部分的纽带，完整使用JNI需要Java代码和C/C++代码。其中C/C++代码用于生成库文件，Java代码用于引...
Android JNI 数组操作
weixin_34013044的博客
07-06 175
JNI 中有两种数组操作，基础数据类型数组和对象数组，JNI 对待基础数据类型数组和对象数组是不一样的。 基本数据类型数组 对于基本数据类型数组，JNI 都有和 Java 相对应的结构，在使用起来和基本数据类型的使用类似。 在 Android JNI 基础知识篇提到了 Java 数组类型对应的 JNI 数组类型。比如，Java int 数...
Android中的jni调用
TOPGUN的专栏
08-02 936
原文地址：http://carywei.iteye.com/blog/1075647 Android JNI 使用的数据结构JNINativeMethod详解 2009-04-02 15:53 Andoird 中使用了一种不同传统Java JNI的方式来定义其native的函数。其中很重要的区别是Andorid使用了一种Java 和 C 函数的映射表数组，并在其中
android jni使用
u011324501的专栏
03-31 249
1、配置添加ndk，然后配置一下环境变量2、配置build.gradle,在defaultConfig中添加//配置ndk信息ndk{    moduleName "JniTest"    abiFilters "armeabi","armeabi-v7a","x86"}//配置so文件存放位置sourceSets.main {    jni.srcDirs = []    jniLibs.src...
Android使用JNI调用Python so解释器
07-11
Android使用JNI调用Python so解释器
Android通过JNI调用.so动态库
08-28
教你如何生成.h文件，使用window通过NDK编译出.so文件，如何通过JNI调用so文件
android中jni调用c++
10-31
简单的使用android中使用jni调用c++的代码
Android使用jni调用c++/c方法详解
01-20
以上append方法就是要调用c++/c中的方法。 JniTest是在Android.mk里约束好的，关于Android.mk的编写具体在后面详解。 3、使用javah -jni生成.h文件 编写好jni加载类之后，就要开始生成.h文件了，此文件相当于一个...
Android_Jni 简单调用
08-05
通过AndroidStudio使用CMake工具来开发jni，实现简单调用
android JNI的使用
w_xue的专栏
09-02 480
jni技术用于实现java与c/c++代码之间的连接。在android平台，通常用java代码实现应用的基本界面和交互逻辑，对于性能要求较高的代码则用c/c++实现，然后编译为.so库文件，在其中通过jni提供接口供java代码调用。 在java中调用c代码 编写java代码，其中需要本地实现的方法用native修饰 class Hello{ native void printH
Android的JNI使用
BlackSmith
11-14 758
最近一直在做6818平台的Android系统应用开发，但是对一些驱动的修改和Android的系统架构问题还是云里雾里。现在要完成的读写串口信息也忙了很久。在应用层调用c/c++的方法，就要使用Java的jni了。关于jni的技术，看了不少的文章，在这里贴出来记录一下。 ————————————————————————————————————————————————————————————————
在Android中使用JNI
gogo_wei的博客
09-22 4211
在Android中使用JNI JNI简介 JNI是Java Native Interface的缩写，使用JNI能够使运行在Java虚拟机上的程序和本地程序互相调用，本地程序可以是其它语言编写的，如C、C++ 或者汇编语言。当程序无法完全使用Java编写时（例如需要调用C/C++的库、与硬件进行交互、提高程序的性能、提高安全性防止反编译），可以通过JNI来编写本地方法。JNI还可以用于修改现有的本地...
Android中使用JNI（深度学习模型移动端部署初步）
feverd555的博客
02-03 453
Android中使用JNI（深度学习模型移动端部署初步）
Android学习笔记--JNI的使用方法
weixin_30500289的博客
01-14 78
1、JNI是什么 JNI是Java Native Interface的缩写，它提供若干的API实现Java与其他语言之间的通信。而Android Framework由基于Java语言的的Java层与基于C/C++语言的C/C++层组成，每个层中的功能模块都是以有相应的语言编写，并且两层中的大部分模块有着千丝万缕的联系。而在两层之间充当连接桥梁这一角色的就是JNI，它允许Java代码和C/C++编...
Android中JNI的使用方法
水月洞天
08-04 5612
做Android开发的程序员应该都知道，Android的开发语言我们都是在使用JAVA(Kotlin和Flutter我们暂时不考虑)。但是，有时候我们也需要使用到C语言进行一些功能的开发。这个时候我们就需要用到JNI了。 1.导入C语言的类 首先我们需要把C语言写的功能类放入我们的项目中。这里我直接从资料中找了一个，毕竟我不会写。路径在src/main/jni中 find_name.cpp #include <jni.h> #include <string.h> #inc
Android JNI使用入门
hongxue8888的博客
03-26 411
文章目录Java调用C++C++调用Javajavap -s 获取方法签名 参考：Java与CC++交互JNI编程 AndroidStudio使用JNI实现Log日志 中我们实现了一个简单的 Java调用C++的方法 的示例，接下里实现较复杂的Java与C++的交互。 Java调用C++ 在MainActivity.java中定义了native方法addTest01，并调用该方法传入对应的值，如下...
android中jni的调用
最新发布
06-08
以下是在 Android 中进行 JNI 调用的一般步骤： 1. 定义与声明本地方法：在 Java 层定义 native 方法，并在 C/C++ 层实现它。 2. 生成头文件：通过 javah 工具生成头文件，用于在 C/C++ 层中实现本地方法。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值