Android NDK JNI 入门笔记-day02-基本数据类型数据传递

最新推荐文章于 2023-03-19 22:47:24 发布
最新推荐文章于 2023-03-19 22:47:24 发布
阅读量243 收藏 2
点赞数
分类专栏： NDK 文章标签： android ndk jni
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binglingziyu/article/details/105001582
版权

* Android NDK JNI 入门笔记目录 *

Java & JNI 基本数据类型

Java 中的基本数据类型包括 boolean，byte，char，short，int，long，float，double 这几种。

而用 C/C++ 编写 native 代码时，是不能直接使用 Java 的数据类型的。

所以 JNI 提供了 jboolean、jbyte、jchar、jshort、jint、jlong、jfloat、jdouble。

Java 基本数据类型与 JNI 数据类型的映射关系

Java TypeNative TypeDescription
booleanjbooleanunsigned 8 bits
bytejbytesigned 8 bits
charjcharunsigned 16 bits
shortjshortsigned 16 bits
intjintsigned 32 bits
longjlongsigned 64 bits
floatjfloat32 bits
doublejdouble64 bits
voidvoidN/A

基本数据类型传递-练习工程

Day02 创建新项目

Java -> Native

点击每个按钮，将 Java 的基本数据类型传递到 Native，Native 代码（C/C++）中将数据打印到日志。

java-to-native

JavaToNativeActivity.java

public class JavaToNativeActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_java_to_native);
        setTitle("Java -> Native");
    }

    public void booleanTest(View view) {
        NativeUtil.javaBooleanToNative(true);
        NativeUtil.javaBooleanToNative(false);
    }

    public void byteTest(View view) {
        NativeUtil.javaByteToNative(Byte.MIN_VALUE);
        NativeUtil.javaByteToNative(Byte.MAX_VALUE);
        NativeUtil.javaByteToNative(Byte.parseByte("123"));
    }

    public void charTest(View view) {
        NativeUtil.javaCharToNative(Character.MIN_VALUE);
        NativeUtil.javaCharToNative(Character.MAX_VALUE);
        NativeUtil.javaCharToNative('A');
        NativeUtil.javaCharToNative('B');
        NativeUtil.javaCharToNative('C');
    }

    public void shortTest(View view) {
        NativeUtil.javaShortToNative(Short.MIN_VALUE);
        NativeUtil.javaShortToNative(Short.MAX_VALUE);
        NativeUtil.javaShortToNative(Short.parseShort("999"));
    }

    public void intTest(View view) {
        NativeUtil.javaIntToNative(Integer.MIN_VALUE);
        NativeUtil.javaIntToNative(Integer.MAX_VALUE);
        NativeUtil.javaIntToNative(Integer.parseInt("999999"));
    }

    public void longTest(View view) {
        NativeUtil.javaLongToNative(Long.MIN_VALUE);
        NativeUtil.javaLongToNative(Long.MAX_VALUE);
        NativeUtil.javaLongToNative(Long.parseLong("999999999"));
    }

    public void floatTest(View view) {
        NativeUtil.javaFloatToNative(Float.MIN_VALUE);
        NativeUtil.javaFloatToNative(Float.MAX_VALUE);
        NativeUtil.javaFloatToNative(999999.8F);
    }

    public void doubleTest(View view) {
        NativeUtil.javaDoubleToNative(Double.MIN_NORMAL);
        NativeUtil.javaDoubleToNative(Double.MAX_VALUE);
        NativeUtil.javaDoubleToNative(999999999.8);
    }

}

NativeUtil.java

public class NativeUtil {

    static {
        System.loadLibrary("native-lib");
    }

    public native static void javaBooleanToNative(boolean value);

    public native static void javaByteToNative(byte value);

    public native static void javaCharToNative(char value);

    public native static void javaShortToNative(short value);

    public native static void javaIntToNative(int value);

    public native static void javaLongToNative(long value);

    public native static void javaFloatToNative(float value);

    public native static void javaDoubleToNative(double value);

}

native-lib.cpp

#include <jni.h>
#include <string>
#include <android/log.h>
#include <math.h>

#define LOG_TAG  "C_TAG"
#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
//LOGD("hello.length=%d",helloLen);

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaBooleanToNative(JNIEnv *env, jclass clazz, jboolean value) {
    LOGD("Java Boolean: %d", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaByteToNative(JNIEnv *env, jclass clazz, jbyte value) {
    LOGD("Java Byte: %d", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaCharToNative(JNIEnv *env, jclass clazz, jchar value) {
    LOGD("Java Char: %d", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaShortToNative(JNIEnv *env, jclass clazz, jshort value) {
    LOGD("Java Short: %d", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaIntToNative(JNIEnv *env, jclass clazz, jint value) {
    LOGD("Java Int: %d", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaLongToNative(JNIEnv *env, jclass clazz, jlong value) {
    LOGD("Java Long: %lld", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaFloatToNative(JNIEnv *env, jclass clazz, jfloat value) {
    LOGD("Java Float: %f", value);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaDoubleToNative(JNIEnv *env, jclass clazz, jdouble value) {
    LOGD("Java Double: %lf", value);
}

点击每个按钮，在 Logcat 中查看输出日志

D/C_TAG: Java Boolean: 1
D/C_TAG: Java Boolean: 0
D/C_TAG: Java Byte: -128
D/C_TAG: Java Byte: 127
    Java Byte: 123
D/C_TAG: Java Char: 0
    Java Char: 65535
    Java Char: 65
    Java Char: 66
    Java Char: 67
D/C_TAG: Java Short: -32768
D/C_TAG: Java Short: 32767
    Java Short: 999
D/C_TAG: Java Int: -2147483648
    Java Int: 2147483647
    Java Int: 999999
D/C_TAG: Java Long: -9223372036854775808
    Java Long: 9223372036854775807
    Java Long: 999999999
D/C_TAG: Java Float: 0.000000
    Java Float: 340282346638528859811704183484516925440.000000
    Java Float: 999999.812500
D/C_TAG: Java Double: 0.000000
    Java Double: 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000
    Java Double: 999999999.800000

Java <- Navive

点击每个按钮，将从 Native 代码（C/C++）中获取 Java 的基本数据类型。

native-to-java

NativeToJavaActivity.java

public class NativeToJavaActivity extends AppCompatActivity {

    private TextView booleanText;
    private TextView byteText;
    private TextView charText;
    private TextView shortText;
    private TextView intText;
    private TextView longText;
    private TextView floatText;
    private TextView doubleText;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_native_to_java);
        setTitle("Native -> Java");

        booleanText = findViewById(R.id.boolean_text);
        byteText = findViewById(R.id.byte_text);
        charText = findViewById(R.id.char_text);
        shortText = findViewById(R.id.short_text);
        intText = findViewById(R.id.int_text);
        longText = findViewById(R.id.long_text);
        floatText = findViewById(R.id.float_text);
        doubleText = findViewById(R.id.double_text);
    }

    public void booleanTest(View view) {
        boolean value = NativeUtil.javaBooleanFromNative();
        booleanText.setText("value = " + value);
    }

    public void byteTest(View view) {
        byte value = NativeUtil.javaByteFromNative();
        byteText.setText("value = " + value);
    }

    public void charTest(View view) {
        char value = NativeUtil.javaCharFromNative();
        charText.setText("value = " + value);
    }

    public void shortTest(View view) {
        short value = NativeUtil.javaShortFromNative();
        shortText.setText("value = " + value);
    }

    public void intTest(View view) {
        int value = NativeUtil.javaIntFromNative();
        intText.setText("value = " + value);
    }

    public void longTest(View view) {
        long value = NativeUtil.javaLongFromNative();
        longText.setText("value = " + value);
    }

    public void floatTest(View view) {
        float value = NativeUtil.javaFloatFromNative();
        floatText.setText("value = " + value);
    }

    public void doubleTest(View view) {
        double value = NativeUtil.javaDoubleFromNative();
        doubleText.setText("value = " + value);
    }

}

NativeUtil.java

public class NativeUtil {

    static {
        System.loadLibrary("native-lib");
    }
    
    public native static boolean javaBooleanFromNative();

    public native static byte javaByteFromNative();

    public native static char javaCharFromNative();

    public native static short javaShortFromNative();

    public native static int javaIntFromNative();

    public native static long javaLongFromNative();

    public native static float javaFloatFromNative();

    public native static double javaDoubleFromNative();

}

native-lib.cpp

#include <jni.h>
#include <string>
#include <android/log.h>
#include <math.h>

#define LOG_TAG  "C_TAG"
#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
//LOGD("hello.length=%d",helloLen);

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaBooleanFromNative(JNIEnv *env, jclass clazz) {
    return JNI_TRUE;
}

extern "C"
JNIEXPORT jbyte JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaByteFromNative(JNIEnv *env, jclass clazz) {
    return 123;
}

extern "C"
JNIEXPORT jchar JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaCharFromNative(JNIEnv *env, jclass clazz) {
    return 'A';
}

extern "C"
JNIEXPORT jshort JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaShortFromNative(JNIEnv *env, jclass clazz) {
    return 999;
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaIntFromNative(JNIEnv *env, jclass clazz) {
    return 999999;
}

extern "C"
JNIEXPORT jlong JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaLongFromNative(JNIEnv *env, jclass clazz) {
    return 999999999;
}

extern "C"
JNIEXPORT jfloat JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaFloatFromNative(JNIEnv *env, jclass clazz) {
    return 999999.8;
}

extern "C"
JNIEXPORT jdouble JNICALL
Java_com_ihubin_ndkjni_NativeUtil_javaDoubleFromNative(JNIEnv *env, jclass clazz) {
    return 999999999.8;
}

点击每个按钮，进行测试

native-to-java-result

Java <-> Native

点击每个按钮，将和 Native(C/C++) 传递、获取 Java 的基本数据类型。

java-and-native

JavaNativeActivity.java

public class JavaNativeActivity extends AppCompatActivity {

    private TextView charConcatText;
    private TextView sumText;
    private TextView twoExpText;
    private TextView calcMoneyText;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_java_native);
        setTitle("Java <-> Native");

        charConcatText = findViewById(R.id.char_concat_text);
        sumText = findViewById(R.id.sum_text);
        twoExpText = findViewById(R.id.two_exp_text);
        calcMoneyText = findViewById(R.id.calc_money_text);
    }


    public void charConcatTest(View view) {
        String value = NativeUtil.charConcatTest('A', 'B', 'C');
        charConcatText.setText("A+B+C=" + value);
    }

    public void sumTest(View view) {
        int numOne = 123;
        int numTwo = 456;
        int value = NativeUtil.sumText(numOne, numTwo);
        sumText.setText(numOne + "+" + numTwo + "=" + value);
    }

    public void twoExpTest(View view) {
        int value = NativeUtil.twoExpTest(10);
        twoExpText.setText("2^10=" + value);
    }

    public void calcMoneyTest(View view) {
        double apple = 12.4;
        double banana = 99.8;
        double orange = 101.1;
        String value = NativeUtil.calcMoneyTest(apple, banana, orange);
        calcMoneyText.setText(value);
    }

}

NativeUtil.java

public class NativeUtil {

    static {
        System.loadLibrary("native-lib");
    }

    public native static String charConcatTest(char a, char b, char c);

    public native static int sumText(int i, int j);

    public native static int twoExpTest(int exp);

    public native static String calcMoneyTest(double v, double v1, double v2);
    
}

native-lib.cpp

#include <jni.h>
#include <string>
#include <android/log.h>
#include <math.h>

#define LOG_TAG  "C_TAG"
#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
//LOGD("hello.length=%d",helloLen);


extern "C"
JNIEXPORT jstring JNICALL
Java_com_ihubin_ndkjni_NativeUtil_charConcatTest(JNIEnv *env, jclass clazz, jchar a, jchar b,
                                                 jchar c) {
    char charArray[4];
    charArray[0] = a;
    charArray[1] = b;
    charArray[2] = c;
    charArray[3] = '\0';
    return env->NewStringUTF(charArray);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_ihubin_ndkjni_NativeUtil_sumText(JNIEnv *env, jclass clazz, jint i, jint j) {
    return i + j;
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_ihubin_ndkjni_NativeUtil_twoExpTest(JNIEnv *env, jclass clazz, jint exp) {
    return pow(2, exp);
}

extern "C"
JNIEXPORT jstring JNICALL
Java_com_ihubin_ndkjni_NativeUtil_calcMoneyTest(JNIEnv *env, jclass clazz, jdouble v, jdouble v1,
                                                jdouble v2) {
    double totalMoney = v + v1 + v2;
    char *resultStr = new char();
    sprintf(resultStr, "总计：%f", totalMoney);
    return env->NewStringUTF(resultStr);
}

点击每个按钮，进行测试

java-and-native-result

至此，我们已经学会了在 Android 项目中与 Native(C/C++) 进行数据交换。

代码：

NDKJNIday02

参考资料：

Oracle - JNI Types and Data Structures

JNI 打印 log 信息

binglingziyu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android NDK jint和jstring转换 以及jstring转换成jint的详解
安卓兼职framework和app工程师的博客
06-22 1831
前言 在进行NDK开发中，会遇到jint和jstring类型互相转换的事情，下面就这两种类型转换做个笔记，仅供参考 1.jint转换成jsting jstring Java_Package_MyTester_NMethod (JNIEnv *env, jobject obj) { jint number = 23456; char str[20]; sprintf(str, "%d",number); return env->NewStringUTF(buf); }
Android NDK的基本使用，这一篇就够了
N0tExpecterr0r的博客
11-16 3099
JNI 概念 JNI是Java Native Interface的简写，它可以使Java与其他语言(如C、C++)进行交互。 它是Java调用Native语言的一种特性，属于Java语言的范畴，与Android无关。 为何需要JNI Java的源文件非常容易被反编译，而通过Native语言生成的.so库文件则不容易被反编译。 有时候会有一种情况就是当我们使用Java时需要使用到一些库来实现某些功...
Android JNI开发（5）--数据传递
猿诗人的博客
09-21 1330
首先JNI中的数据类型有基本数据类型和引用类型： 基本数据类型为：Java类型 JNI类型 描述 boolean jboolean unsigned 8 bits byte jbyte signed 8 bits char jchar unsigned 16 bits sh
Android中JNI编程基础
liugec的博客
06-24 374
JNI编程基础 JNI数据类型 JNIEXPORT 和 JNICALL，定义在jni_md.h头文件中。 JNIEXPORT： ​ 在 Windows 中,定义为__declspec(dllexport)。因为Windows编译 dll 动态库规定，如果动态库中的函数要被外部调用，需要在函数声明中添加此标识，表示将该函数导出在外部可以调用。 ​ 在 Linux/Unix/Mac os/Android 这种 Like Unix系统中，定义为__attribute__ ((visibility ("defau
Android JNI(一)——NDK与JNI基础
Hunter2916的博客
03-19 213
NDK 其中NDK的全拼是：Native Develop Kit。那我们先来看下Android NDK官网是对NDK怎么解释的关键文字如下：Android NDK 是一套允许您使用原生代码语言(例如C和C++)实现部分应用的工具集。在开发某些类型应用时，这有助于您重复使用以这些语言编写的代码库。简单的来说:Android NDK 就是一套工具集合，允许你使用C/C++语言来实现应用程序的部分功能。NDK 是Native Develop Kit的含义，从含义很容易理解，本地开发。
android-ndk（android-ndk-r26b-windows.zip）
最新发布
10-20
android-ndk（android-ndk-r26b-windows.zip）适用于Windows系统
android-ndk（android-ndk-r23b-windows.zip）
10-20
android-ndk（android-ndk-r23b-windows.zip）适用于Windows系统
android-ndk（android-ndk-r25b-windows.zip）
10-20
android-ndk（android-ndk-r25b-windows.zip）适用于Windows系统
android-ndk（android-ndk-r25b-linux.zip）
10-20
android-ndk（android-ndk-r25b-linux.zip）适用于Linux系统
android-ndk（android-ndk-r25b-darwin.zip）
10-20
android-ndk（android-ndk-r25b-darwin.zip）适用于macOS系统
android函数传递参数,android之JNI参数传递
weixin_30727701的博客
05-25 565
从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计 的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。让我们看一些使用JNI的简单例子吧。使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接...
Android NDK 开发（二）JNI 传递参数和返回值
热门推荐
stromxu 的专栏
10-06 2万+
前言我们在使用 JNI 时最常问到的是 JAVA 和 C/C++之间如何传递数据，以及数据类型之间如何 互相映射。我们从整数等基本类型和数组、字符串等普通的对象类型开始讲述。至于如何传递任意对象，将在后面会更新。原文链接请标明： http://blog.csdn.net/u011974987/article/details/52743495 本文出自:【stromxu的博客】正文继JNI简介及
Android jni开发-4（jni基本数据传递）
liu540885284的专栏
01-01 578
java传递基本数据给jni
Android jni中数组参数的传递方式
u010503912的专栏
07-15 4600
1、背景 今天调试了一下Android jni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是： C代码，入口函数   #include #include jint Java_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv* env, jobject
字符串参数传递与返回值（转）
weixin_34199335的博客
01-23 325
转载请注明出处！ 原文地址链接：http://blog.csdn.net/zgyulongfei/article/details/7409441   在编程的时候我们不仅需要使用无参的函数，有参数的函数也是必须的。 这次我编写一个函数用来传递String类型参数，并输出该函数的返回值。 编写java类：   [java] view plaincopy cla...
【Android NDK 开发】JNI 方法解析 ( int 数组传递 | jintArray 类型 | 数组转换 | 获取数组长度 | 获取数组元素 | 指针遍历数组 | 数组返回值设置 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-28 9607
I . jintArray 类型说明 II . jboolean 类型说明 III . GetIntArrayElements 方法解析 ( jintArray -> jint* | int* ) IV . jarray 类型说明 V . GetArrayLength 方法解析 ( 获取 jarray 数组长度 ) VI . 日志打印 VII . 遍历 int 数组 VIII . ReleaseIntArrayElements 方法说明 ( 释放 C/C++ 中的 int 数组 ) IX . 完整代码示例
Android NDK开发：JNI基础篇
cfanr
08-05 1726
Android NDK开发：JNI基础篇 JNI 概念 1.1 概念JNI 全称 Java Native Interface，Java 本地化接口，可以通过 JNI 调用系统提供的 API。操作系统，无论是 Linux，Windows 还是 Mac OS，或者一些汇编语言写的底层硬件驱动都是 C/C++ 写的。Java和C/C++不同 ，它不会直接编译成平台机器码，而是编译成虚拟机可以运行的Java
android-ndk-r12b-windows-x86.zip
07-12
android-ndk-r12b-windows-x86.zip 是一个 Android NDK 的压缩文件。Android NDK (Native Development Kit) 是一个让开发者能够使用 C 或 C++ 程序语言编写 Android 应用的工具集合。它主要用于开发需要高性能或使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值