android ndk开发

已于 2022-03-23 14:58:51 修改
阅读量2.8k 收藏 3
点赞数
分类专栏： android基础 文章标签： android
于 2022-03-19 02:32:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/day_moon/article/details/123588299
版权
JNI 开发流程主要分为以下 6 步：
• 编写声明了 native 方法的 Java 类
• 将 Java 源代码编译成 class 字节码文件
• 用 javah -jni 命令生成 .h 头文件（javah 是 jdk 自带的一个命令，-jni 参数表示将 class 中用native 声明
的函数生成 JNI 规则的函数）
• 用本地代码实现 .h头 文件中的函数
• 将本地代码编译成动态库（Windows：\*.dll，linux/unix：\*.so，mac os x：\*.jnilib）
• 拷贝动态库至 java.library.path 本地库搜索目录下，并运行 Java 程序 
MainActivity类
  static {
        System.loadLibrary("HelloWorld");//引入so包
    }
    public static native String sayHi();//调用c/c++



//生成h头文件
1.先选中java目录，然后右击open in ,选 Terminal。也就是进入java目录输入命令
javah -classpath . -jni com.example.myapplication.MainActivity


//新建一个cpp文件 把头文件复制粘贴进来
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_sayHi
        (JNIEnv *env, jclass){
    return env->NewStringUTF("from c语言");
};

//生成动态库方式 
１) cmake
2)  ndk-build 
下面我用得是cmake


CMakeLists.txt
cmake_minimum_required(VERSION 3.18.1)
project("HelloWorld")
add_library( # Sets the name of the library.
        HelloWorld
        SHARED
        native-lib.cpp)
find_library( # Sets the name of the path variable.
        log-lib
        log)
target_link_libraries( # Specifies the target library.
        HelloWorld
        ${log-lib})


app.gradle
defaultConfig {
       ...
        externalNativeBuild {
            cmake {
                cppFlags ''
            }
        }
 }
 externalNativeBuild {
        cmake {
            path file('src/main/cpp/CMakeLists.txt')
            version '3.18.1'
        }
 }

2.传参数给c/c++和返回

MainActivity类
public static native String sayHi(String name);


/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_sayHi
        (JNIEnv *env, jclass jclass, jstring jstring){
    //定义变量
    const char *c_str=NULL;
    char buff[128] ={0};
    //jstring转char
    c_str = (*env).GetStringUTFChars(jstring, NULL);
    if (c_str == NULL)
    {
        return NULL;
    }
    //释放jstring指向Char的指针
    (*env).ReleaseStringUTFChars(jstring, c_str);
    //发送格式化输出到buff所指向的字符串(c_str)
    sprintf(buff, "hello %s", c_str);
    return (*env).NewStringUTF(buff);
}

3.数据类型对应(注意类型之间的对应)

MainActivity类
 public static native void myTest(short s, int i, long l, float f, double d, char c,
                                   boolean z, byte b, String str, Object obj, Student p, int[] arr);


C文件
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_myTest
        (JNIEnv *env, jclass cls, jshort s, jint i, jlong l, jfloat f,
         jdouble d, jchar c, jboolean z, jbyte b, jstring j_str, jobject jobj1, jobject job2, jintArray j_int_arr)
        {
            printf("s=%hd, i=%d, l=%ld, f=%f, d=%lf, c=%c, z=%c, b=%d", s, i, l, f, d, c, z, b);
            const char *c_str = NULL;
            c_str = (*env).GetStringUTFChars(j_str,NULL);
            if (c_str == NULL)
            {
                return; // memory out
            }
            (*env).ReleaseStringUTFChars(j_str, c_str);
            printf("c_str: %s\n", (char*)c_str);
        }
#ifdef __cplusplus

1.返回字符串

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    public static native String sayHi(String name);
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView textView=findViewById(R.id.tv_hi);
        textView.setText(sayHi("gu"));
    }
}

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_sayHi
        (JNIEnv *env, jclass jclass, jstring jstring){
    //定义变量
    const char *c_str=NULL;
    char buff[128] ={0};
    //jstring拷贝
    c_str = (*env).GetStringUTFChars(jstring, NULL);
    if (c_str == NULL)
    {
        return NULL;
    }
    //发送格式化输出到buff所指向的字符串(c_str)
    sprintf(buff, "hello %s", c_str);
    //释放jstring指向Char的指针
    (*env).ReleaseStringUTFChars(jstring, c_str);
    return (*env).NewStringUTF(buff);
}
#ifdef __cplusplus
}
#endif
#endif






错误用法：
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_sayHi
        (JNIEnv *env, jclass jclass, jstring jstring){
    //定义变量
    const jchar *c_str = NULL;
    char buff[128] = "hello";
    char *pBuff = buff + 6;
    /*
* 在GetStringCritical/RealeaseStringCritical之间是一个关键区。
* 在这关键区之中,绝对不能呼叫JNI的其他函数和会造成当前线程中断或是会让当前线程等待的任何本地代码，
* 否则将造成关键区代码执行区间垃圾回收器停止运作，任何触发垃圾回收器的线程也会暂停。
* 其他触发垃圾回收器的线程不能前进直到当前线程结束而激活垃圾回收器。
*/
    c_str=(*env).GetStringCritical(jstring,NULL); 返回源字符串指针的可能性
    if (c_str ==NULL){
        return NULL;
    }
    while (*c_str)
    {
        *pBuff++=*c_str++;
    }
    (*env).ReleaseStringCritical(jstring,c_str);
    return (*env).NewStringUTF(buff);
}



#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_sayHi
        (JNIEnv *env, jclass jclass, jstring jstring){
    jsize len=(*env).GetStringLength(jstring);
    char buff[128]="hello ";
    char* pBuff=buff+6;
    // 将JVM中的字符串以utf-8编码拷入C缓冲区,该函数内部不会分配内存空间
    (*env).GetStringUTFRegion(jstring, 0, len, pBuff);
    return (*env).NewStringUTF(buff);
}
#ifdef __cplusplus
}
#endif
#endif

2.返回数组

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    private native int sumArray(int[] arr);
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView textView = findViewById(R.id.tv_hi);

        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
        int sum = sumArray(arr);
        textView.setText("返回=="+sum);
    }
}

第一种
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jint JNICALL Java_com_example_myapplication_MainActivity_sumArray
        (JNIEnv *env, jobject obj, jintArray j_array){
    jint i, sum = 0;
    jint *c_array;
    jint arr_len;
// 可能数组中的元素在内存中是不连续的，JVM可能会复制所有原始数据到缓冲区，然后返回这个缓冲区的指针
    c_array = (*env).GetIntArrayElements(j_array,NULL);
    if (c_array == NULL) {
        return 0; // JVM复制原始数据到缓冲区失败
    }
    arr_len = (*env).GetArrayLength(j_array);
    printf("arr_len = %d\n", arr_len);
    for (i = 0; i < arr_len; i++) {
        sum += c_array[i];
    }
    (*env).ReleaseIntArrayElements(j_array, c_array, 0); // 释放可能复制的缓冲区
    return sum;
}
#ifdef __cplusplus
}
#endif
#endif


第二种
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jint JNICALL Java_com_example_myapplication_MainActivity_sumArray
        (JNIEnv *env, jobject obj, jintArray j_array){
    jint  i,sum=0;
    jint *c_array;
    jint arr_len;
    //1. 获取数组长度
    arr_len=(*env).GetArrayLength(j_array);
    //2. 根据数组长度和数组元素的数据类型申请存放java数组元素的缓冲区
    c_array=  (jint*)malloc(sizeof(jint)*arr_len);
    //3. 初始化缓冲区
    memset(c_array,0,sizeof(jint)*arr_len);
    //4. 拷贝Java数组中的所有元素到缓冲区中
    (*env).GetIntArrayRegion(j_array,0,arr_len,c_array);
    for ( i = 0; i <arr_len ; ++i) {
        sum+=c_array[i];//5. 累加数组元素的和
    }
    free(c_array); //6. 释放存储数组元素的缓冲区
    return sum;
}
#ifdef __cplusplus
}
#endif
#endif

二维数组

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    sayHi
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jobjectArray JNICALL Java_com_example_myapplication_MainActivity_initInt2DArray
        (JNIEnv *env, jobject obj, jint size)
        {
            jobjectArray result;
            jclass clsIntArray;
            jint i,j;
     // 1.获得一个int型二维数组类的引用
    clsIntArray = (*env).FindClass("[I");
    if (clsIntArray == NULL)
    {
        return NULL;
    }
// 2.创建一个数组对象（里面每个元素用clsIntArray表示）
    result = (*env).NewObjectArray(size,clsIntArray,NULL);
    if (result == NULL)
    {
        return NULL;
    }
// 3.为数组元素赋值
    for (i = 0; i < size; ++i)
    {
        jint buff[256];
        jintArray intArr = (*env).NewIntArray(size);//创建一个 JNI 的 int 数组
        if (intArr == NULL)
        {
            return NULL;
        }
        for (j = 0; j < size; j++)
        {
            buff[j] = i + j;
        }
        //buff[]缓冲中的内容复制到新分配的一维数组中去
        (*env).SetIntArrayRegion(intArr, 0,size,buff);
        //在外层循环中依次将 int[]数组赋值到 jobjectArray 数组中
        (*env).SetObjectArrayElement(result, i, intArr);
        //DeleteLocalRef 将新创建的 jintArray 引用从引用表中移除
        (*env).DeleteLocalRef(intArr);
    }
    return result;
}



#ifdef __cplusplus
}
#endif
#endif


下面是java
public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    private native int[][] initInt2DArray(int size);
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView textView = findViewById(R.id.tv_hi);

        int[][] arr = initInt2DArray(3);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.format("arr[%d][%d] = %d\n", i, j, arr[i][j]);
            }
        }
        textView.setText("返回==");
    }
}

CC++访问 Java 实例方法和静态方法

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    public static native void callJavaStaticMethod();
    public static native void callJavaInstaceMethod();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        callJavaStaticMethod();
        callJavaInstaceMethod();
    }
}

public class ClassMethod {
    private static void callStaticMethod(String str, int i) {
        System.out.format("ClassMethod::callStaticMethod called!-->str=%s," +
                " i=%d\n", str, i);
    }
    private void callInstanceMethod(String str, int i) {
        System.out.format("ClassMethod::callInstanceMethod called!-->str=%s, " +
                "i=%d\n", str, i);
    }
}



/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    callJavaStaticMethod
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_callJavaStaticMethod
        (JNIEnv *env, jclass cls){
    jclass clazz = NULL;
    jstring str_arg = NULL;
    jmethodID mid_static_method;
// 1、从classpath路径下搜索ClassMethod这个类，并返回该类的Class对象
    clazz =(*env).FindClass("com/example/myapplication/ClassMethod");
    if (clazz == NULL) {
        return;
    }
// 2、从clazz类中查找callStaticMethod方法
    mid_static_method = (*env).GetStaticMethodID(clazz,"callStaticMethod","(Ljava/lang/String;I)V");
    if (mid_static_method == NULL) {
        printf("找不到callStaticMethod这个静态方法。");
        return;
    }
// 3、调用clazz类的callStaticMethod静态方法
    str_arg = (*env).NewStringUTF("我是静态方法");
    (*env).CallStaticVoidMethod(clazz,mid_static_method, str_arg, 100);
// 删除局部引用
    (*env).DeleteLocalRef(clazz);
    (*env).DeleteLocalRef(str_arg);
}

/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    callJavaInstaceMethod
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_callJavaInstaceMethod
        (JNIEnv *env, jclass cls){
    jclass clazz = NULL;
    jobject jobj = NULL;
    jmethodID mid_construct = NULL;
    jmethodID mid_instance = NULL;
    jstring str_arg = NULL;
// 1、从classpath路径下搜索ClassMethod这个类，并返回该类的Class对象
    clazz = (*env).FindClass("com/example/myapplication/ClassMethod");
    if (clazz == NULL) {
        printf("找不到'com.study.jnilearn.ClassMethod'这个类");
        return;
    }
// 2、获取类的默认构造方法ID
    mid_construct = (*env).GetMethodID(clazz, "<init>","()V");
    if (mid_construct == NULL) {
        printf("找不到默认的构造方法");
        return;
    }
// 3、查找实例方法的ID
    mid_instance = (*env).GetMethodID( clazz, "callInstanceMethod", "(Ljava/lang/String;I)V");
    if (mid_instance == NULL) {
        return;
    }
// 4、创建该类的实例
    jobj = (*env).NewObject(clazz,mid_construct);
    if (jobj == NULL) {
        printf("在com.study.jnilearn.ClassMethod类中找不到callInstanceMethod方法");
        return;
    }
// 5、调用对象的实例方法
    str_arg = (*env).NewStringUTF("我是实例方法");
    (*env).CallVoidMethod(jobj,mid_instance,str_arg,200);
// 删除局部引用
    (*env).DeleteLocalRef(clazz);
    (*env).DeleteLocalRef(jobj);
    (*env).DeleteLocalRef(str_arg);
};

#ifdef __cplusplus
}
#endif
#endif

CC++ 访问 Java 实例变量和静态变量

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    private native static void accessInstanceField(ClassField obj);
    private native static void accessStaticField();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ClassField obj = new ClassField();
        obj.setNum(10);
        obj.setStr("Hello");
// 本地代码访问和修改ClassField为中的静态属性num
        accessStaticField();
        accessInstanceField(obj);
// 输出本地代码修改过后的值
        System.out.println("In Java--->ClassField.num = " + obj.getNum());
        System.out.println("In Java--->ClassField.str = " + obj.getStr());
    }
}

public class ClassField {
    private static int num;
    private String str;
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        ClassField.num = num;
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
}



/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    accessInstanceField
 * Signature: (Lcom/example/myapplication/ClassField;)V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_accessInstanceField
        (JNIEnv *env, jclass cls, jobject obj){
    jclass clazz;
    jfieldID fid;
    jstring j_str;
    jstring j_newStr;
    const char *c_str = NULL;
// 1.获取AccessField类的Class引用
    clazz = (*env).GetObjectClass(obj);
    if (clazz == NULL) {
        return;
    }
    // 2. 获取AccessField类实例变量str的属性ID
    fid = (*env).GetFieldID(clazz,"str", "Ljava/lang/String;");
    if (clazz == NULL) {
        return;
    }
// 3. 获取实例变量str的值
    j_str = (jstring)(*env).GetObjectField(obj,fid);
// 4. 将unicode编码的java字符串转换成C风格字符串
    c_str = (*env).GetStringUTFChars(j_str,NULL);
    if (c_str == NULL) {
        return;
    }
    printf("In C--->ClassField.str = %s\n", c_str);//没有打印  In c--->ClassField.str=Hello
    (*env).ReleaseStringUTFChars( j_str, c_str);
// 5. 修改实例变量str的值
    j_newStr = (*env).NewStringUTF("This is C String");
    if (j_newStr == NULL) {
        return;
    }
    (*env).SetObjectField( obj, fid, j_newStr);
// 6.删除局部引用
    (*env).DeleteLocalRef( clazz);
    (*env).DeleteLocalRef( j_str);
    (*env).DeleteLocalRef( j_newStr);
};

/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    accessStaticField
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_accessStaticField
        (JNIEnv *env, jclass cls){
    jclass clazz;
    jfieldID fid;
    jint num;
//1.获取ClassField类的Class引用
    clazz = (*env).FindClass("com/example/myapplication/ClassField");
    if (clazz == NULL) { // 错误处理
        return;
    }
//2.获取ClassField类静态变量num的属性ID
    fid = (*env).GetStaticFieldID( clazz, "num", "I");
    if (fid == NULL) {
        return;
    }
// 3.获取静态变量num的值
    num = (*env).GetStaticIntField(clazz,fid);
    printf("In C--.ClassField.num = %d\n", num);//没有打印 In c--->ClassField.num=10
// 4.修改静态变量num的值
    (*env).SetStaticIntField( clazz, fid, 80);
// 删除属部引用
    (*env).DeleteLocalRef(clazz);
};

#ifdef __cplusplus
}
#endif
#endif

构造方法和父类实例方法

public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
        System.out.println("Animal Construct call...");
    }
    public String getName() {
        System.out.println("Animal.getName Call...");
        return this.name;
    }
    public void run() {
        System.out.println("Animal.run...");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
        System.out.println("Cat Construct call....");
    }
    @Override
    public String getName() {
        return "My name is " + this.name;
    }
    @Override
    public void run() {
        System.out.println(name + " Cat.run...");
    }
}


public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    public native static void callSuperInstanceMethod();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        callSuperInstanceMethod();
    }
}



/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    callSuperInstanceMethod
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_callSuperInstanceMethod
        (JNIEnv *env, jclass cls){
    jclass cls_cat;
    jclass cls_animal;
    jmethodID mid_cat_init;
    jmethodID mid_run;
    jmethodID mid_getName;
    jstring c_str_name;
    jobject obj_cat;
    const char *name = NULL;
// 1、获取Cat类的class引用 com.example.myapplication
    cls_cat = (*env).FindClass( "com/example/myapplication/Cat");
    if (cls_cat == NULL) {
        return;
    }
// 2、获取Cat的构造方法ID(构造方法的名统一为：<init>)
    mid_cat_init = (*env).GetMethodID(cls_cat, "<init>", "(Ljava/lang/String;)V");
    if (mid_cat_init == NULL) {
        return; // 没有找到只有一个参数为String的构造方法
    }
// 3、创建一个String对象，作为构造方法的参数
    c_str_name = (*env).NewStringUTF("汤姆猫");
    if (c_str_name == NULL) {
        return; // 创建字符串失败（内存不够）
    }
    // 4、创建Cat对象的实例(调用对象的构造方法并初始化对象)
    obj_cat = (*env).NewObject(cls_cat, mid_cat_init,c_str_name);
    if (obj_cat == NULL) {
        return;
    }
//-------------- 5、调用Cat父类Animal的run和getName方法 --------------
    cls_animal = (*env).FindClass("com/example/myapplication/Animal");
    if (cls_animal == NULL) {
        return;
    }
// 例1： 调用父类的run方法
    mid_run = (*env).GetMethodID(cls_animal, "run", "()V"); // 获取父类Animal中run方法的id
    if (mid_run == NULL) {
        return;
    }
// 注意：obj_cat是Cat的实例，cls_animal是Animal的Class引用，mid_run是Animal类中的方法ID
    (*env).CallNonvirtualVoidMethod(obj_cat, cls_animal, mid_run);
// 例2：调用父类的getName方法
// 获取父类Animal中getName方法的id
    mid_getName = (*env).GetMethodID(cls_animal, "getName", "()Ljava/lang/String;");
    if (mid_getName == NULL) {
        return;
    }
    c_str_name = static_cast<jstring>((*env).CallNonvirtualObjectMethod(obj_cat, cls_animal,
                                                                        mid_getName));
    name = (*env).GetStringUTFChars(c_str_name, NULL);
    printf("In C: Animal Name is %s\n", name);
// 释放从java层获取到的字符串所分配的内存
    (*env).ReleaseStringUTFChars(c_str_name, name);
    quit:
// 删除局部引用（jobject或jobject的子类才属于引用变量），允许VM释放被局部变量所引用的资源
    (*env).DeleteLocalRef(cls_cat);
    (*env).DeleteLocalRef(cls_animal);
    (*env).DeleteLocalRef(c_str_name);
    (*env).DeleteLocalRef(obj_cat);
}
#ifdef __cplusplus
}
#endif
#endif

使用时缓存

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
    }
    private String str = "Hello";
    public native void accessField();
    public native String newString(char[] chars, int len);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        accessField();
        char chars[] = new char[7];
        chars[0] = '1';
        chars[1] = '2';
        chars[2] = '3';
        chars[3] = '4';
        chars[4] = '5';
        chars[5] = '6';
        chars[6] = '7';
        String str = newString(chars, 6);
        System.out.println(str);
    }
}



/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    accessField
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_accessField
        (JNIEnv *env, jobject obj)
{
// 第一次访问时将字段存到内存数据区，直到程序结束才会释放，可以起到缓存的作用
    static jfieldID fid_str = NULL;
    jclass cls_AccessCache;
    jstring j_str;
    const char *c_str;
    cls_AccessCache = (*env).GetObjectClass(obj); // 获取该对象的Class引用
    if (cls_AccessCache == NULL) {
        return;
    }
// 先判断字段ID之前是否已经缓存过，如果已经缓存过则不进行查找
    if (fid_str == NULL) {
        fid_str = (*env).GetFieldID(cls_AccessCache,"str","Ljava/lang/String;");
        // 再次判断是否找到该类的str字段
        if (fid_str == NULL) {
            return;
        } }
    j_str = static_cast<jstring>((*env).GetObjectField(obj, fid_str)); // 获取字段的值
    c_str = (*env).GetStringUTFChars(j_str, NULL);
    if (c_str == NULL) {
        return; // 内存不够
    }
    printf("In C:\n str = \"%s\"\n", c_str);
    (*env).ReleaseStringUTFChars( j_str, c_str); // 释放从从JVM新分配字符串的内存空间
// 修改字段的值
    j_str = (*env).NewStringUTF( "12345");
    if (j_str == NULL) {
        return;
    }
    (*env).SetObjectField( obj, fid_str, j_str);
// 释放本地引用
    (*env).DeleteLocalRef(cls_AccessCache);
    (*env).DeleteLocalRef(j_str);
}

/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    newString
 * Signature: ([CI)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_myapplication_MainActivity_newString
        (JNIEnv *env, jobject obj, jcharArray j_char_arr, jint len)
{
    jcharArray elemArray;
    jchar *chars = NULL;
    jstring j_str = NULL;
    static jclass cls_string = NULL;
    static jmethodID cid_string = NULL;
// 注意：这里缓存局引用的做法是错误，这里做为一个反面教材提醒大家，下面会说到。
    if (cls_string == NULL) {
        cls_string = (*env).FindClass("java/lang/String");
        if (cls_string == NULL) {
            return NULL;
        } }
// 缓存String的构造方法ID
    if (cid_string == NULL) {
        cid_string = (*env).GetMethodID(cls_string, "<init>", "([C)V");
        if (cid_string == NULL) {
            return NULL;
        } }
    printf("In C array Len: %d\n", len);
// 创建一个字符数组
    elemArray = (*env).NewCharArray(len);
    if (elemArray == NULL) {
        return NULL;
    }
// 获取数组的指针引用，注意：不能直接将jcharArray作为SetCharArrayRegion函数最后一个参数
    chars = (*env).GetCharArrayElements(j_char_arr,NULL);
    if (chars == NULL) {
        return NULL;
    }
// 将Java字符数组中的内容复制指定长度到新的字符数组中
    (*env).SetCharArrayRegion(elemArray, 0, len, chars);
// 调用String对象的构造方法，创建一个指定字符数组为内容的String对象
    j_str = static_cast<jstring>((*env).NewObject(cls_string, cid_string, elemArray));
// 释放本地引用
    (*env).DeleteLocalRef(elemArray);
    return j_str;
}

#ifdef __cplusplus
}
#endif
#endif

类静态初始化缓存

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("HelloWorld");
        initIDs();
    }
    public static native void initIDs();
    public native void nativeMethod();
    public void callback() {
        System.out.println("AccessCache.callback invoked!");
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
      nativeMethod();
    }
}



/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include <cstdio>
/* Header for class com_example_myapplication_MainActivity */

#ifndef _Included_com_example_myapplication_MainActivity
#define _Included_com_example_myapplication_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
jmethodID MID_AccessCache_callback;
/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    initIDs
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_initIDs
        (JNIEnv *env, jclass cls)
{
    printf("initIDs called!!!\n");
    MID_AccessCache_callback = (*env).GetMethodID(cls,"callback","()V");
}

/*
 * Class:     com_example_myapplication_MainActivity
 * Method:    nativeMethod
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_myapplication_MainActivity_nativeMethod
        (JNIEnv *env, jobject obj) {
    printf("In C Java_com_study_jnilearn_AccessCache_nativeMethod called!!!\n");
    (*env).CallVoidMethod(obj, MID_AccessCache_callback);
}

#ifdef __cplusplus
}
#endif
#endif
JNI 局部引用、全局引用和弱全局引用
day_moon
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android NDK开发基础
BC时间
04-21 4427
仅作为个人学习记录，请小心求证。 https://developer.android.com/ndk/guides?hl=zh-cn 前言 NDK即Native Development Kit，是Android上用来开发c/c++的开发工具包。 安装步骤：https://developer.android.com/studio/projects/install-ndk 一、基础用法 在local.properties中配置ndk目录： ndk.dir=/Users/bc/android-ndk-r1.
android开发之NDK配置开发
qq_42282862的博客
06-01 4428
输入命令javah -jni com.example.mr5.jnidemo.JniUtil --------包名+类名。3、将CMake的安装路径添加到PATH环境变量，或将其添加到项目的local.properties文件中，如下所示。5、在local.properties的文件添加NDK的路径和SDK的路径。8、在build.gradle文件中ndk的模块。
2024年超详细的Android NDK开发环境搭建(1)，2024年最新面试指导书籍
最新发布
2401_84520150的博客
05-08 632
*要想成为高级安卓工程师，必须掌握许多基础的知识。**在工作中，这些原理可以极大的帮助我们理解技术，在面试中，更是可以帮助我们应对大厂面试官的刁难。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
NDK开发史诗级入门教程
yuhaibing111的博客
02-27 6040
ndk全称Native Developer Kits，Android NDK也是Android SDK的一个扩展集，用来扩展SDK的功能。NDK打通了Java和C/C++之间的开发障碍，让Android开发者也可以使用C/C++语言开发APP。众所周知：Java是在C/C++之上的语言，语言金字塔越往上对开发者就更加贴近，也就是更容易开发，但是性能相对也就越低。越往下对开发人员的要求也就越高，但是实现后的产品性能也越高，因为可以自己控制内存等模块的使用，而不是让Java虚拟机自行处理。NDK的使用场景。
Android Studio之NDK开发
yinshenk的博客
02-18 1万+
Android Studio之NDK开发 一、 前言 NDK全称是Native Development Kit，是Android提供的一个开发工具包，能够快速将开发的C,C++的动态库，协议软件包，以及优秀的软件工具，用so和应用打包成APK，自由地在Android上运行。而NDK开发工具，就是将C/C++程序，编译成为Android环境可运行的程序，再者，通过NDK实现Android中实现JNI编程。那么JNI又是啥呢？JNI的全称是Java Native Interface，即Java的本地接口，JNI
Android之NDK开发
cc_lq的专栏
03-08 861
http://www.cnblogs.com/devinzhang/archive/2012/02/29/2373729.html  一、NDK产生的背景 　　Android平台从诞生起，就已经支持C、C++开发。众所周知，Android的SDK基于Java实现，这意味着基于Android SDK进行开发的第三方应用都必须使用Java语言。但这并不等同于“第三方应用只能使用Ja
Android Ndk开发
05-24
在Android平台上，NDK（Native Development Kit）是一个关键的开发工具，它允许开发者编写C和C++代码，并将其集成到Android应用中。本教程将详细阐述NDK的基础知识，包括其功能、适用场景、API稳定性、构建过程以及...
Android NDK开发入门
08-31
在搭建NDK开发环境时，首先需要从官方网站或第三方镜像站点下载NDK安装包，然后解压到合适的位置。在Windows环境下，安装过程就是简单的解压文件。接着，需要配置系统环境变量，将NDK的路径添加到系统的PATH变量中，...
Android NDK开发PPT
06-21
具体步骤包括下载并安装Android NDK的安装包，下载Cygwin，然后配置Cygwin以适应NDK开发环境，并验证环境是否能正常工作。 而从版本7开始，NDK不再依赖于Cygwin，开发者可以直接在Eclipse中为Android项目添加...
Android NDK 开发教程
01-05
Android NDK 是在SDK前面又加上了“原生”二字，即Native Development Kit，因此又被Google称为“NDK”。 众所周知，Android程序运行在Dalvik虚拟机中，NDK允许用户使用类似C / C++之类的原生代码语言执行部分程序...
androidndk开发实战
04-06
《Android NDK开发实战》是针对移动应用开发者的一份宝贵资源，主要涵盖了如何在Android平台上进行原生代码开发。NDK（Native Development Kit）是Google为Android提供的一个工具集，它允许开发者使用C和C++编写性能...
android ndk 开发
08-23
android ndk 开发总结，总结android ndk开发过程中的经验！
安卓NDK开发——使用CMake封装CPP文件成so库并调用so库
知来者逆的博客
12-19 2548
演示了NDK项目是如何导入与调用C++代码的，但很多时候，C++的实现代码并不能都给别人，所要把.cpp文件封装成.so文件，只留api接口给用户调用。要封装成.so文件分步，一是指定so文件输出的目录，二是指定哪些.cpp文件封装成.so 。
Android NDK的开发流程
little762的博客
03-30 421
1.下载并配置NDK 步骤1：下载NDK 下载NDK Android官网下载地址 解压。将解压路径设置为：Android Studio的SDK目录里，并命名为ndk-bundle。（Android Studio会自动检查该路径进行配置，从而省去了收到配置ndk的工作） 步骤2： 配置NDK环境变量 在系统环境变量里面创建NDK_HOME 将NDK_HOME追加到Path环境变量下...
NDK开发流程
weixin_47100830的博客
11-22 2081
ndk开发流程
安卓开发之NDK开发基础(一)
iris的博客
05-26 2742
暑期实习找到了A的安全开发，提前学习下NDK开发的简单流程。 项目创建 新建一个Empty Activity： 右键点击 app/src/ 下的 main 目录，然后New > Directory，为目录输入一个名称（例如 cpp）并点击 OK： 右键点击刚刚创建的cpp目录，然后 New > C/C++ Source File，输入一个名称，例如 test-ndk： 然后右键点击选中 app ，然后选择 New > File，输入CMakeLists.txt 作为文件名并点击 OK
Android NDK开发（一）环境搭建及运行示例
m0_70082867的博客
05-06 987
NDK提供了一系列的工具，帮助开发者快速开发C（或C++）的动态库，并能自动将so和java应用一起打包成apk。这些工具对开发者的帮助是巨大的。NDK集成了交叉编译器，并提供了相应的mk文件隔离CPU、平台、ABI等差异，开发人员只需要简单修改mk文件（指出“哪些文件需要编译”、“编译特性要求”等），就可以创建出so。NDK可以自动地将so和Java应用一起打包，极大地减轻了开发人员的打包工作。 2.NDK提供了一份稳定、功能有限的API头文件声明 Google明确声明该API是稳定的，在后续所有版本中都
安卓驱动开发
liuliuhelingdao的博客
10-05 867
总结：AVD：安卓模拟器，一个虚拟的安卓系统，ADT：安卓开发工具链，是eclipse的一个插件，SDK：提供不同版本的api，而在eclipse上做android开发时用到SDK+ADT来配置基本开发环境，AVD来运行调试App。AVD是安卓版本模拟器，由于安卓版本非常多，所以在安卓SDK中每一个安卓版本都对应一个AVD。此步中，需要安安卓SDK并配置，安装Eclipse，安装ADT并配置，建立AVD。此步中，需要安装NDK，安装CDT，配置安卓NDK的集成开发环境，3.安装安卓NDK开发环境。
Android：JNI 与 NDK到底是什么？（含实例教学）
热门推荐
Carson带你学Android
06-14 18万+
前言 在Android开发中，使用 NDK开发的需求正逐渐增大 但很多人却搞不懂 JNI 与 NDK 到底是怎么回事 今天，我将先介绍JNI 与 NDK & 之间的区别，手把手进行 NDK的使用教学，希望你们会喜欢 目录1. JNI介绍1.1 简介 定义：Java Native Interface，即 Java本地接口 作用： 使得Java 与 本地其他类型语言（如C、C++）交互 即在 Ja
Android ndk开发
09-09
Android NDK开发是指利用NDK（Native Development Kit）将C/C++开发的代码编译成so库，然后通过JNI（Java Native Interface）让Java程序调用。在Android开发中，默认使用的是Android SDK进行Java语言的开发，而对于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值