JNI数据操作

最新推荐文章于 2024-04-16 10:05:45 发布
最新推荐文章于 2024-04-16 10:05:45 发布
阅读量352 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AS_MSDN/article/details/79530764
版权

本实例中包含:
- ByteArray的操作Java<->JNI双向操作
- Java的Object转C的struct以及struct转Java的Object
- ArrayList对象的操作
- Java 数组对象的解析
- malloc 需要free
- ByteArray需要release

//
// Created by liuhui on 2017/11/18.
//
#include <jni.h>
#include <math.h>
#include "Fp16Convert.h"

static jbyteArray normalizeFeatures2(JNIEnv *env, jbyte *feature_, int len);

uint64_t sTaskId = -1;
char *detectFeatureFromPicClazz = "com.xxx.xxx.xxx.model.DetectFaceFromPicture";
char *faceServiceNotificationClazz = "com.xxx.xxx.xxx.model.FaceServiceNotification";

//char* to jstring
int sto(JNIEnv *env, const char *pat) {
    return 1;
}

jstring charTojstring(JNIEnv *env, char *chars) {
    jclass strClass = env->FindClass("Ljava/lang/String;");
    jmethodID ctorID = env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
    jbyteArray bytes = env->NewByteArray(strlen(chars));
    env->SetByteArrayRegion(bytes, 0, strlen(chars), (jbyte *) chars);
    jstring encoding = env->NewStringUTF("utf-8");
    return (jstring) env->NewObject(strClass, ctorID, bytes, encoding);
}

__attribute__((section (".mytext"))) static void nativeFaceDtrDestroy(JNIEnv *env, jobject thiz) {
    //LOGW("facedtr_jni destroy");
    sTaskId = -1;

}

__attribute__((section (".mytext"))) static int
nativeFaceDtrGetModelLength(JNIEnv *env, jobject thiz,
                            jstring name) {
    if (name == NULL) {
        //LOGE("clazz can't be null");
        return -1;
    }
    char *clazzName = (char *) env->GetStringUTFChars(name, NULL);

    int result = -2;
    if (strlen(clazzName) == strlen(detectFeatureFromPicClazz) &&
        memcmp(clazzName, detectFeatureFromPicClazz, strlen(detectFeatureFromPicClazz)) == 0) {

        result = sizeof(xxx_xxx_mobile2movi_pic_bytes);
    } else if (strlen(clazzName) == strlen(faceServiceNotificationClazz) &&
               memcmp(clazzName, faceServiceNotificationClazz,
                      strlen(faceServiceNotificationClazz)) == 0) {
        result = sizeof(xx_xxx_movi2mobile_notification_t);
    }
    env->ReleaseStringChars(name, (const jchar *) clazzName);
    env->DeleteLocalRef(name);
    return result;

}

__attribute__((section (".mytext"))) static jbyteArray
nativeFaceDtrInitParamter(JNIEnv *env, jobject thiz, jobject paramter) {
    xxx_xxx_initialzation_paramter_t *initParamter = (xxx_xxx_initialzation_paramter_t *) malloc(
            sizeof(xxx.xxx_initialzation_paramter_t));
    jbyteArray jbyteArray1 = env->NewByteArray(sizeof(xxx.xxx_initialzation_paramter_t));
    //Getting class have two method :
    jclass jParamsCls = env->GetObjectClass(paramter);

    //parse taskId
    jfieldID taskIdTypeField = env->GetFieldID(jParamsCls, "taskId", "J");
    uint64_t taskId = env->GetLongField(paramter, taskIdTypeField);
    sTaskId = taskId;
    initParamter->taskId = taskId;
//    //LOGW("initParamter->taskId = %ld,sTaskId = %ld ", initParamter->taskId,sTaskId);
    //parse ServiceType
    jfieldID serviceTypeField = env->GetFieldID(jParamsCls, "serviceType", "I");
    uint16_t serviceType = env->GetIntField(paramter, serviceTypeField);
//    //LOGW("serviceType = %d ", serviceType);
    initParamter->serviceType = (service_type) serviceType;
    //parse multipleFaceDetectDelayTime
    jfieldID multipleFaceDetectDelayTimeField = env->GetFieldID(jParamsCls,
                                                                "multipleFaceDetectDelayTime", "I");
    uint16_t multipleFaceDetectDelayTime = env->GetIntField(paramter,
                                                            multipleFaceDetectDelayTimeField);
    initParamter->multipleFaceDetectDelayTime = multipleFaceDetectDelayTime;

    //解析Java Object对象
    jfieldID areaFiledId = env->GetFieldID(jParamsCls, "area",
                                           "Lcom/xxx/xxx/xxx/model/Area;");
    //it works
//    jfieldID areaFiledId = env->GetFieldID(jParamsCls,"area","com/xxx/glass3/sdk/facedtr/Area"); 
    jobject areaObj = env->GetObjectField(paramter, areaFiledId);
    jclass areaClass = env->FindClass("com/xxx/xxx/xxx/model/Area");
    jfieldID leftFiledId = env->GetFieldID(areaClass, "left", "I");
    jfieldID topFiledId = env->GetFieldID(areaClass, "top", "I");
    jfieldID rightFiledId = env->GetFieldID(areaClass, "right", "I");
    jfieldID bottomFiledId = env->GetFieldID(areaClass, "bottom", "I");
    uint16_t left = env->GetIntField(areaObj, leftFiledId);
    uint16_t top = env->GetIntField(areaObj, topFiledId);
    uint16_t right = env->GetIntField(areaObj, rightFiledId);
    uint16_t bottom = env->GetIntField(areaObj, bottomFiledId);
//    //LOGW("(left,top),(right,bottom)-> (%d,%d),(%d,%d)", left, top, right, bottom);
    area_t a;
    a.left = left;
    a.top = top;
    a.right = right;
    a.bottom = bottom;
    initParamter->area = a;

    //parse detect discrimatorn
    jfieldID detectDiscrimatornField = env->GetFieldID(jParamsCls, "detectDiscrimatorn",
                                                       "Lcom/xxx/xxx/xxx/model/DetectThreshold;");
    jobject detectDiscrimatornObj = env->GetObjectField(paramter, detectDiscrimatornField);
//    jclass detectDiscrimatornClz = env->FindClass("com/xxx/glass3/sdk/facedtr/DetectThreshold");
    jclass detectDiscrimatornClz = env->GetObjectClass(detectDiscrimatornObj);
    jfieldID minDetectWidthField = env->GetFieldID(detectDiscrimatornClz, "minDetectWidth", "I");
    jfieldID countOfFastField = env->GetFieldID(detectDiscrimatornClz, "countOfFast", "I");
    jfieldID yawField = env->GetFieldID(detectDiscrimatornClz, "yaw", "I");

    uint16_t minDetectWidth = env->GetIntField(detectDiscrimatornObj, minDetectWidthField);
    uint16_t countOfFast = env->GetIntField(detectDiscrimatornObj, countOfFastField);
    uint16_t yaw = env->GetIntField(detectDiscrimatornObj, yawField);
    detect_discrimator_t detect_discrimator1;
    detect_discrimator1.yaw = yaw;
    detect_discrimator1.minDetectWidth = minDetectWidth;
    detect_discrimator1.countOfFast = countOfFast;
    initParamter->detectDiscrimatorn = detect_discrimator1;
//    //LOGW("coutOfFast = %d, yaw = %d, minDetectWidthField = %d ", countOfFast, yaw, minDetectWidth);

    //parse detectResultType
    jfieldID detectResultTypeFiled = env->GetFieldID(jParamsCls, "detectResultType", "I");
    uint16_t detectResultType = env->GetIntField(paramter, detectResultTypeFiled);
    initParamter->detectResultType = (detect_result_type) detectResultType;
//    //LOGW("detectResultType = %d", detectResultType);

    //parse indicatorColorSize
    jfieldID indicatorColorSizeFiled = env->GetFieldID(jParamsCls, "indicatorColorSize", "I");
    uint16_t indicatorColorSize = env->GetIntField(paramter, indicatorColorSizeFiled);
    initParamter->indicatorColorSize = indicatorColorSize;
//    //LOGW("indicatorColorSize = %d", indicatorColorSize);

    //parse indicatorColors
    if (indicatorColorSize != 0) {
        jfieldID indicatorColorsField = env->GetFieldID(jParamsCls, "indicatorColors",
                                                        "[Lcom/xxx/xxx/xxx/model/IndicatorColor;");
        jobjectArray indicatorColorArrayObj = (jobjectArray) env->GetObjectField(paramter,
                                                                                 indicatorColorsField);
//        //LOGD("数组长度：%d", env->GetArrayLength(indicatorColorArrayObj));

        for (int i = 0; i < indicatorColorSize; i++) {
            jobject indicatorColorObj = env->GetObjectArrayElement(indicatorColorArrayObj, i);
            jclass indicatorClz = env->GetObjectClass(indicatorColorObj);
            jfieldID indicatorColorSizeFiled = env->GetFieldID(indicatorClz, "state", "I");
            uint16_t state = env->GetIntField(indicatorColorObj, indicatorColorSizeFiled);
            indicator_color_t indicatorColor;
            indicatorColor.state = (face_track_phase) state;

            jfieldID indicatorColorFiled = env->GetFieldID(indicatorClz, "color", "I");
            uint16_t color = env->GetIntField(indicatorColorObj, indicatorColorFiled);
            indicatorColor.color = color;
            initParamter->indicatorColors[i] = indicatorColor;
            env->DeleteLocalRef(indicatorClz);
            env->DeleteLocalRef(indicatorColorObj);
        }
        env->DeleteLocalRef(indicatorColorArrayObj);
//        //LOGW("状态对应颜色值结束了");
    }


    //parse Camera width and height
    jfieldID jfieldIDCameraWidth = env->GetFieldID(jParamsCls, "cameraPreviewWidth", "I");
    uint16_t cameraWidth = env->GetIntField(paramter, jfieldIDCameraWidth);
    initParamter->cameraPreviewWidth = cameraWidth;
    jfieldID jfieldIDCameraHeight = env->GetFieldID(jParamsCls, "cameraPreviewheight", "I");
    uint16_t cameraHeight = env->GetIntField(paramter, jfieldIDCameraHeight);
    initParamter->cameraPreviewHeight = cameraHeight;
//    //LOGW("paramter cameraWidth = %dpx,cameraHeight = %dpx", cameraWidth, cameraHeight);
    env->SetByteArrayRegion(jbyteArray1, 0, sizeof(xxx.xxx_initialzation_paramter_t),
                            (const jbyte *) initParamter);
    free(initParamter);
    initParamter = NULL;
    env->DeleteLocalRef(jParamsCls);
    env->DeleteLocalRef(areaObj);
    env->DeleteLocalRef(areaClass);
    env->DeleteLocalRef(detectDiscrimatornObj);
    env->DeleteLocalRef(detectDiscrimatornClz);
//    //LOGW("convert paramters to byte[] len:%d",env->GetArrayLength(jbyteArray1));
    return jbyteArray1;
}


__attribute__((section (".mytext"))) static void
nativeParseFaceNotificationCallback(JNIEnv *env, jobject thiz, jbyteArray array, jobject callback) {
//    jbyte *raw_msg = env->GetByteArrayElements(array, 0);
    jclass clazz = env->GetObjectClass(callback);
    jmethodID faceNotificationCallbackMethodId = env->GetMethodID(clazz,
                                                                  "onFaceNotificationCallback",
                                                                  "(Lcom/xxx/xxx/xxx/model/FaceServiceNotification;)V");
    jbyte *data = env->GetByteArrayElements(array, NULL);
    int arrayLength = env->GetArrayLength(array);

    jbyte *raw_msg = (jbyte *) malloc(arrayLength);

    if (data != NULL) {
        memcpy(raw_msg, data, arrayLength);
        env->ReleaseByteArrayElements(array, data, JNI_ABORT);
        env->DeleteLocalRef(array);
    }

    xxx.xxx_movi2mobile_notification_t *notification = (xxx_xxx_movi2mobile_notification_t *) raw_msg;
    if (sTaskId != notification->taskId) {
        //LOGE("两次TaskID不相同 sTaskID = %ld,last  taskId = %ld ", sTaskId, notification->taskId);
        if (notification->notificationType == 3) { //detect face from pic
            env->CallVoidMethod(callback, faceNotificationCallbackMethodId, NULL);
        }
        free(raw_msg);
        raw_msg = NULL;
        notification = NULL;
        env->DeleteLocalRef(clazz);
        return;
    }
    const uint8_t *src = notification->resultData;
    uint8_t *dest = (uint8_t *) malloc(FRAME_YUV_LEN);
    const int yLen = 1280 * 720;
    const int vLen = yLen / 4;

    memcpy(dest, notification->resultData, yLen);//Y data
    for (int i = 0; i < vLen; i++) {
        dest[yLen + 2 * i] = src[yLen + i];//V data
        dest[yLen + 2 * i + 1] = src[yLen + vLen + i];//U data
    }
    uint8_t *features = notification->features;
    int notificationType = notification->notificationType;
    if (LIKELY(clazz)) {
        //get hid method ID

//        //LOGE("faceNotificationCallbackMethodId");

        jclass faceServiceNotificationClazz = env->FindClass(
                "com/xxx/xxx.xxx/model/FaceServiceNotification");
//        //LOGE("faceServiceNotificationClazz");
        //new FaceServiceNotification
        if (LIKELY(faceServiceNotificationClazz)) {

            jmethodID hid_method_creator = env->GetMethodID(faceServiceNotificationClazz, "<init>",
                                                            "(I[BLjava/util/ArrayList;[B)V");
            //construct arealist
            jclass list_cls = env->FindClass("java/util/ArrayList");//获得ArrayList类引用
//            //LOGW("Get ArrayList class");

            jmethodID list_costruct = env->GetMethodID(list_cls, "<init>", "()V"); //获得得构造函数Id
            jobject areaArrayList = env->NewObject(list_cls, list_costruct); //创建一个Arraylist集合对象
//            //LOGW("create ArrayList instance areaArrayList");
            //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;
            jmethodID list_add = env->GetMethodID(list_cls, "add", "(Ljava/lang/Object;)Z");
            jclass areaClz = env->FindClass("com/xxx/xxx/xxx/model/Area");
            for (int i = 0; i < notification->areasize; ++i) {
                area_t area1 = notification->area[i];
                jmethodID area_method_creator = env->GetMethodID(areaClz, "<init>", "(IIII)V");
                jobject areaObj = env->NewObject(areaClz, area_method_creator, area1.left,
                                                 area1.top,
                                                 area1.right + area1.left,
                                                 area1.bottom + area1.top);
                //执行Arraylist类实例的add方法，添加一个Area对象
                env->CallBooleanMethod(areaArrayList, list_add, areaObj);
            }
            env->DeleteLocalRef(list_cls);
            env->DeleteLocalRef(areaClz);


            jbyteArray notificationData = env->NewByteArray(FRAME_YUV_LEN);
            env->SetByteArrayRegion(notificationData, 0, FRAME_YUV_LEN, (const jbyte *) dest);

//            jbyteArray featureData = env->NewByteArray(FEATURES_LEN);
//            env->SetByteArrayRegion(featureData, 0, FEATURES_LEN, (const jbyte *) features);
            //归一化后的数据
            jbyteArray featureData = normalizeFeatures2(env, (jbyte *) features, FEATURES_LEN);

            jobject hidInfoObj = env->NewObject(faceServiceNotificationClazz, hid_method_creator,
                                                notificationType, notificationData,
                                                areaArrayList, featureData);
            env->CallVoidMethod(callback, faceNotificationCallbackMethodId, hidInfoObj);
            env->DeleteLocalRef(notificationData);
            env->DeleteLocalRef(areaArrayList);
            env->DeleteLocalRef(featureData);
            env->DeleteLocalRef(hidInfoObj);
        }
        env->DeleteLocalRef(faceServiceNotificationClazz);
    }
    env->DeleteLocalRef(clazz);
    notification = NULL;
    if (raw_msg != NULL) {
        free(raw_msg);
        raw_msg = NULL;
    }
    if (LIKELY(dest)) {
        free(dest);
        dest = NULL;
    }
    env->DeleteLocalRef(array);
    src = NULL;
    env->DeleteLocalRef(callback);
}


__attribute__((section (".mytext"))) static jobject
nativeParseFaceServiceNotification(JNIEnv *env, jobject thiz, jbyteArray array) {
    //LOGW("nativeParseFaceServiceNotification");
    jbyte *data = env->GetByteArrayElements(array, NULL);
    int arrayLength = env->GetArrayLength(array);
    jbyte *raw_msg = (jbyte *) malloc(arrayLength);
    if (data != NULL) {
        memcpy(raw_msg, data, arrayLength);
        env->ReleaseByteArrayElements(array, data, JNI_ABORT);
        env->DeleteLocalRef(array);
    }

    jobject faceServerNotificationObj = NULL;
    xxx.xxx_movi2mobile_notification_t *notification = (xxx.xxx_movi2mobile_notification_t *) raw_msg;
    if (sTaskId != notification->taskId) {
        //LOGE("different taskID taskID1 = %ld,last  taskId2 = %ld ", sTaskId, notification->taskId);
        free(raw_msg);
        raw_msg = NULL;
        notification = NULL;
        return faceServerNotificationObj;
    }
    const uint8_t *src = notification->resultData;
    uint8_t *dest = (uint8_t *) malloc(FRAME_YUV_LEN);
    const int yLen = 1280 * 720;
    const int vLen = yLen / 4;

    memcpy(dest, notification->resultData, yLen);//Y data
    for (int i = 0; i < vLen; i++) {
        dest[yLen + 2 * i] = src[yLen + i];//V data
        dest[yLen + 2 * i + 1] = src[yLen + vLen + i];//U data
    }
    uint8_t *features = notification->features;
    int notificationType = notification->notificationType;
    jclass faceServiceNotificationClazz = env->FindClass(
            "com/xxx/xxx.xxx/model/FaceServiceNotification");
    //new FaceServiceNotification

    jmethodID hid_method_creator = env->GetMethodID(faceServiceNotificationClazz, "<init>",
                                                    "(I[BLjava/util/ArrayList;[B)V");
    //construct arealist
    jclass list_cls = env->FindClass("java/util/ArrayList");//获得ArrayList类引用
//            //LOGW("Get ArrayList class");

    jmethodID list_costruct = env->GetMethodID(list_cls, "<init>", "()V"); //获得得构造函数Id
    jobject areaArrayList = env->NewObject(list_cls, list_costruct); //创建一个Arraylist集合对象
//            //LOGW("create ArrayList instance areaArrayList");
    //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;
    jmethodID list_add = env->GetMethodID(list_cls, "add", "(Ljava/lang/Object;)Z");
    jclass areaClz = env->FindClass("com/xxx/xxx.xxx/model/Area");
    for (int i = 0; i < notification->areasize; ++i) {
        area_t area1 = notification->area[i];
        jmethodID area_method_creator = env->GetMethodID(areaClz, "<init>", "(IIII)V");
        jobject areaObj = env->NewObject(areaClz, area_method_creator, area1.left,
                                         area1.top,
                                         area1.right + area1.left,
                                         area1.bottom + area1.top);
        //执行Arraylist类实例的add方法，添加一个Area对象
        env->CallBooleanMethod(areaArrayList, list_add, areaObj);
    }
    env->DeleteLocalRef(list_cls);
    env->DeleteLocalRef(areaClz);


    jbyteArray notificationData = env->NewByteArray(FRAME_YUV_LEN);
    env->SetByteArrayRegion(notificationData, 0, FRAME_YUV_LEN, (const jbyte *) dest);

//            jbyteArray featureData = env->NewByteArray(FEATURES_LEN);
//            env->SetByteArrayRegion(featureData, 0, FEATURES_LEN, (const jbyte *) features);
    //归一化后的数据
    jbyteArray featureData = normalizeFeatures2(env, (jbyte *) features, FEATURES_LEN);

    faceServerNotificationObj = env->NewObject(faceServiceNotificationClazz, hid_method_creator,
                                               notificationType, notificationData,
                                               areaArrayList, featureData);
    env->DeleteLocalRef(notificationData);
    env->DeleteLocalRef(areaArrayList);
    env->DeleteLocalRef(featureData);
    env->DeleteLocalRef(faceServiceNotificationClazz);
    notification = NULL;
    if (raw_msg != NULL) {
        free(raw_msg);
        raw_msg = NULL;
    }
    if (LIKELY(dest)) {
        free(dest);
        dest = NULL;
    }
    env->DeleteLocalRef(array);
    src = NULL;
    return faceServerNotificationObj;
}

__attribute__((section (".mytext"))) static jbyteArray nativeGetFace(JNIEnv *env, jobject thiz,
                                                                     jint dataType, jint size,
                                                                     jint width, jint height,
                                                                     jbyteArray bytes_) {
//    //LOGW("facedtr_jni nativeGetFace");

    xxx.xxx_mobile2movi_pic_bytes_t *mobile2moviPicBytes = (xxx_xxx_mobile2movi_pic_bytes_t *) malloc(
            sizeof(xxx.xxx_mobile2movi_pic_bytes));
    mobile2moviPicBytes->dataType = dataType;
    mobile2moviPicBytes->size = size;
    mobile2moviPicBytes->pic_width = width;
    mobile2moviPicBytes->pic_height = height;
    jint len = 0;
    if (bytes_ != NULL) {
        len = env->GetArrayLength(bytes_);
    }
    jbyteArray jbyteArray1 = env->NewByteArray(sizeof(xxx.xxx_mobile2movi_pic_bytes));
    if (len > 0) {
        jboolean isCopy;
        jbyte *bytes = env->GetByteArrayElements(bytes_, &isCopy);
        memcpy(mobile2moviPicBytes->bytes, bytes, len);
    }
    env->SetByteArrayRegion(jbyteArray1, 0, sizeof(xxx.xxx_mobile2movi_pic_bytes),
                            (const jbyte *) mobile2moviPicBytes);
    free(mobile2moviPicBytes);

    mobile2moviPicBytes = NULL;
//    //LOGW("%d,%d",env->GetArrayLength(jbyteArray1), sizeof(*mobile2moviPicBytes));

    return jbyteArray1;
}


__attribute__((section (".mytext"))) static jbyteArray
normalizeFeatures(JNIEnv *env, jobject thiz, jbyteArray feature_) {
    jbyte *feature = env->GetByteArrayElements(feature_, NULL);
    jbyteArray result = normalizeFeatures2(env, feature, 1024);
    if (feature != NULL) {
        env->ReleaseByteArrayElements(feature_, feature, JNI_ABORT);
        env->DeleteLocalRef(feature_);
        feature = NULL;
    }
    return result;
}


static jbyteArray normalizeFeatures2(JNIEnv *env, jbyte *feature, int len) {
    //sto(env, KEY2);
    float norm_feature[256];
    float temp[512];
    for (int i = 0; i < 512; i++) {
        temp[i] = f16Tof32(*(unsigned int *) ((unsigned short *) feature + i));
    }

    const float *ptr = temp;
    float sum = 0.0;
    for (int i = 0; i < 512; i++) {
        float num = *ptr++;
        sum += num * num;
    }
    sum = sqrtf(sum);

    ptr = temp;
    float sum2 = 0;

    for (int i = 0; i < 512; i++) {
        temp[i] = *ptr++ / sum;
    }
    for (int i = 0; i < 256; i++) {
        unsigned int x1 = f32Tof16(temp[i * 2]);
        unsigned int x2 = f32Tof16(temp[i * 2 + 1]);
        unsigned int x = x2 << 16 | x1;
        norm_feature[i] = *(float *) &x;
    }

    jbyteArray result = env->NewByteArray(1024);
    env->SetByteArrayRegion(result, 0, 1024, (jbyte *) norm_feature);
    return result;
}


//**********************************************************************
//
//**********************************************************************
jint registerNativeMethods(JNIEnv *env, const char *class_name, JNINativeMethod *methods,
                           int num_methods) {
    int result = 0;

    jclass clazz = env->FindClass(class_name);
    if (LIKELY(clazz)) {
        int result = env->RegisterNatives(clazz, methods, num_methods);
        if (UNLIKELY(result < 0)) {
            //LOGD("registerNativeMethods failed(class=%s)", class_name);
        }
    } else {
        //LOGD("registerNativeMethods: class'%s' not found", class_name);
    }
    return result;
}

static JNINativeMethod methods[] = {
        {"nativeFaceDtrDestroy",                "()V",                                                                              (void *) nativeFaceDtrDestroy},
        {"nativeFaceDtrInitParamter",           "(Lcom/xxx/xxx/xxx/model/FaceInitParamter;)[B",                               (void *) nativeFaceDtrInitParamter},
        {"nativeGetFace",                       "(IIII[B)[B",                                                                       (void *) nativeGetFace},
        {"normalizeFeatures",                   "([B)[B",                                                                           (void *) normalizeFeatures},
        {"nativeParseFaceNotificationCallback", "([BLcom/xxx/xxx/xxx/glxss/security/listener/IOnFaceNotificationCallback;)V", (void *) nativeParseFaceNotificationCallback},
        {"nativeParseFaceServiceNotification",  "([B)Lcom/xxx/xxx/xxx/model/FaceServiceNotification;",                        (void *) nativeParseFaceServiceNotification},
        {"nativeFaceDtrGetModelLength",         "(Ljava/lang/String;)I",                                                            (void *) nativeFaceDtrGetModelLength},


};

int register_libFaceDtr(JNIEnv *env) {
    //LOGI("register_libfacedtr:");
    if (registerNativeMethods(env,
                              "com/xxx/xxx/xxx/glxss/FaceDtr",
                              methods, NUM_ARRAY_ELEMENTS(methods)) < 0) {
        return -1;
    }
    return 0;
}
AS_MSDN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于JNI技术，实现数据库查询，在C++中MD5匹配后回调至Java层的方案
Rivers.Huang
11-04 677
需求
（二）JNI 的数据类型
一个人的旅行的博客
03-11 330
目录JNI 的数据类型一、JNI 数据类型二、C通过JNI调用Java1、访问Java属性2、访问Java静态属性3、访问java方法4、访问静态方法5、访问构造方法6、访问父类的方法三、JNI字符串乱码问题四、JNI数组处理，传入一个数组，返回另一个数组 JNI 的数据类型 一、JNI 数据类型 Java基本数据类型与JNI数据类型的映射关系 Java数据类型 JNI数据类型 C/C++...
【NDK】【009】JNI类型和Java类型对应关系，C++类对象和Java类对象互转
天天向上 Up Up Up (*^▽^*)
06-20 626
JNI类型和Java类型对应关系 Java类型 JNI类型 真实C++类型 boolean jboolean uint8_t，unsigned char byte jbyte int8_t，signed char char jchar uint16_t，unsigned short short jshort int16_t，short int jint int32_t，int long jlong int64_t，long long float jfloat floa
如何在Android设备中用NDK编译SQLite并且对SQLite进行操作（增删）-How to Compile SQLite for Android using NDK
abcdefh123的专栏
12-30 6806
如何通过NDK中的C/C++代码来直接访问SQLite
java与c/c++之间的数据交互-----jni点滴【转】
雪梦科技
10-09 1456
原文：http://www.cnitblog.com/houcy/archive/2011/01/27/72733.html 最近作一个tiemsten数据库的项目，用到了jni技术。在这个项目中，我们用java来写界面和业务逻辑，用c语言写数据库odbc访问。单纯的o
【C/C++】uin8_t uint16_t uint32_t uint64_t数据类型解析
NoBack7--For the dream
07-05 5035
C语言中常用的基本数据类型有：char、short、int、long、float、double：在上述整型数据类型前加上unsigned，则为无符号类型：为了代码编写和阅读方便，我们通常会将数据类型名称声明为简写方式，即uin8_t/uint16_t/uint32_t/uint64_t，或者UINT8/UINT16/UINT32/UINT64。因此uin*_t并不是新的数据类型，而是通过关键字typedef声明后的数据形式。......
Android JNI开发详解(4)-数据操作
^_虫虫_^的专栏
05-24 383
原文出处：http://www.ccbu.cc/index.php/android/android-jni-data-operation.html 在前面关于JNI介绍的文章中我们知道，Java层和Navice层是两个世界，而JNI正是为了这个两个世界能够友好的相互沟通而设计的。既然是不同的两个世界，所有他们各自的数据类型定义也是不一样的，Java层和Native层都有自己的数据类型，在JNI中，这些数据类型又可以分为基本数据类型和引用数据类型，其中，基本数据类型是可以直接相互转换的，而引用数据类型则需要进
jni数据传递demo
08-30
这个"JNI数据传递demo"通过实际操作，帮助开发者理解如何在C/C++和Java之间高效、安全地传递不同类型的数据，进一步揭示了Android NDK编程的核心原理。通过实践这个示例，开发者可以更好地理解和掌握JNI技术，提升...
bitoperation_jni_AndroidJNI位操作_android_
09-28
在这个“bitoperation_jni”示例中，我们将探讨如何在Android JNI层进行位操作，这是对二进制数据进行低级别操作的一种方法，尤其适用于高效的数据处理和计算。 位操作是计算机科学中的基本概念，它们涉及到单个...
Android中的JNI数组操作教程
01-20
本教程将详细讲解在JNI中如何操作基础数据类型数组。 首先，JNI中处理的基础数据类型数组包括如int、byte、char、short、long、float和double等类型的数组。这些数组在JNI中有特定的表示形式，例如Java的int数组...
Android-sqlite数据库
07-12
使用AS-jni开发数据库相关文件，里面包含：libsqlite.so 、libsqliteX.so 、 classes.jar 、 sqlite3.dll 、 sqlite3.h
Java与JNI数据类型对照表
04-14
Java与JNI数据类型对照表,可能有许多不足之处，请大家参考一下。
Android 通过jni返回Mat数据类型方法
08-27
Android 通过JNI返回Mat数据类型方法 Android 应用程序开发中，为了提高代码的高效性，通常需要调用本地C++代码，JNI（Java Native Interface）是Java语言提供的和C/C++相互沟通的机制。特别是在使用OpenCV进行...
jni基本操作
09-01
1）传递基础数据类型 2）传递返回字符串类型 3）传递返回数组 4）Native层操作java类属性 5）Native层回调java方法 6）传递返回一个java类 7）Native线程回调java方法 8）Native调用第三方库
JNI配置信息保存
yanlonging的博客
08-31 241
Android本地数据安全尝试(下)——JNI
ttdevs
03-19 1920
Android本地数据安全尝试(下)——JNI
LevelDBJNI：一个高效、轻量级的数据存储库封装
最新发布
gitblog_00058的博客
04-16 318
LevelDBJNI：一个高效、轻量级的数据存储库封装 项目地址:https://gitcode.com/fusesource/leveldbjni LevelDBJNI 是一个基于 Google 的 LevelDB 数据库引擎的 Java 封装库，它允许 Java 开发者无缝地利用 LevelDB 的强大功能。LevelDB 是一款高性能、轻量级的键值对存储系统，特别适合于嵌入式应用和数据缓存。...
Android NDK（二）- JNI 基础
teletian的专栏
06-18 516
JNI 的一些基础知识
NDK-JNI数组数据处理
qq_42282862的博客
03-13 290
JNI
jni操作BufferedImage对象
11-01
需要注意的是，在JNI中，所有的数据都是通过指针传递的，所以你需要正确地管理这些指针。 ```c JNIEXPORT void JNICALL Java_com_yourpackage_YourClass_processImage(JNIEnv *env, jobject obj, jobject image) {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值