Merge b

lizhanwei

2020-01-08 2bd86aabc7a0eb9d0f3eaeaef7f4eba63f62bbaa

 lib/src/main/cpp/native-lib.cpp

@@ -22,51 +22,6 @@
const int RTK_PLATFORM_PORT = 12125;
const uint8_t phone[] = {0x20,0x19,0x10,0x15,0x00,0x00,0x00,0x01};

#define IMEI_LENGTH         15

char * GetImei(void)
{
    JNIEnv *env;
    static char imei[IMEI_LENGTH + 1] = {0};

    LOGD("JNI_GetImei");

    if (strlen(imei) == 0) {
        bool ready_in_java_env = false;

        if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
            // Attach主线程
            if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
                LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
                return imei;
            }
        } else {
            ready_in_java_env = true;
        }

        jclass cls = env->GetObjectClass(sg_obj);
        jmethodID fun = env->GetMethodID(cls, "javaGetImei", "()Ljava/lang/String;");

        jstring ret = (jstring) env->CallObjectMethod(sg_obj, fun);

        if (ret != NULL) {
            const char *pret = env->GetStringUTFChars(ret, JNI_FALSE);
            strcpy(imei, pret);
        }

        env->DeleteLocalRef(cls);

        if (!ready_in_java_env) {
            //Detach主线程
            if (sg_jvm->DetachCurrentThread() != JNI_OK) {
                LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
                return imei;
            }
        }
    }
    return imei;
}

int DESEncrypt(const uint8_t *key, int key_length,
        const uint8_t *plaintext, int plaintext_length,
        uint8_t **ciphertext)
@@ -116,183 +71,6 @@
        }
    }
    return ciphertext_length;
}

void SetPlatformKey(const uint8_t *key, int length)
{
    JNIEnv *env;
    bool ready_in_java_env = false;

    LOGD("JNI_SetPlatformKey");

    if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        // Attach主线程
        if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return;
        }
    } else {
        ready_in_java_env = true;
    }

    jbyteArray jni_cmd = env->NewByteArray(length);
    env->SetByteArrayRegion(jni_cmd, 0, length, (jbyte *) key);

    jclass cls = env->GetObjectClass(sg_obj);
    jmethodID fun = env->GetMethodID(cls, "SetPlatformKey", "([B)V");

    env->CallVoidMethod(sg_obj, fun, jni_cmd);

    env->DeleteLocalRef(jni_cmd);
    env->DeleteLocalRef(cls);

    if (!ready_in_java_env) {
        //Detach主线程
        if (sg_jvm->DetachCurrentThread() != JNI_OK) {
            LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
        }
    }
}

void DelPlatformKey(void)
{
    JNIEnv *env;
    bool ready_in_java_env = false;

    if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        // Attach主线程
        if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return;
        }
    } else {
        ready_in_java_env = true;
    }

    jclass cls = env->GetObjectClass(sg_obj);
    jmethodID fun = env->GetMethodID(cls, "DeletePlatformKey", "()V");

    env->CallVoidMethod(sg_obj, fun);

    env->DeleteLocalRef(cls);

    if (!ready_in_java_env) {
        //Detach主线程
        if (sg_jvm->DetachCurrentThread() != JNI_OK) {
            LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
        }
    }
}

int GetPlatformKey(uint8_t *pkey)
{
    JNIEnv *env;
    bool ready_in_java_env = false;
    uint8_t key[64] = {0};
    int key_len = 0;

    LOGD("JNI_GetPlatformKey");

    if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        // Attach主线程
        if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return 0;
        }
    } else {
        ready_in_java_env = true;
    }

    jclass cls = env->GetObjectClass(sg_obj);
    jmethodID fun = env->GetMethodID(cls, "GetPlatformKey", "()[B");

    jbyteArray jni_cmd = (jbyteArray) env->CallObjectMethod(sg_obj, fun);

    if (jni_cmd != NULL) {
        key_len = env->GetArrayLength(jni_cmd);
        if (key_len <= sizeof(key)) {
            env->GetByteArrayRegion(jni_cmd, 0, key_len, (jbyte *) key);
            memcpy(pkey, key, key_len);
        } else {
            key_len = 0;
        }
    }

    env->DeleteLocalRef(cls);

    if (!ready_in_java_env) {
        //Detach主线程
        if (sg_jvm->DetachCurrentThread() != JNI_OK) {
            LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
        }
    }
    return key_len;
}

void SetSharedValue(const char *key, int value)
{
    JNIEnv *env;
    bool ready_in_java_env = false;

    LOGD("JNI_SetSharedValue");

    if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        // Attach主线程
        if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return;
        }
    } else {
        ready_in_java_env = true;
    }

    jclass cls = env->GetObjectClass(sg_obj);
    jmethodID fun = env->GetMethodID(cls, "SetSharedValue", "(Ljava/lang/String;I)V");

    env->CallVoidMethod(sg_obj, fun, env->NewStringUTF(key), value);

    env->DeleteLocalRef(cls);

    if (!ready_in_java_env) {
        //Detach主线程
        if (sg_jvm->DetachCurrentThread() != JNI_OK) {
            LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
        }
    }
}

int GetSharedValue(const char *key)
{
    JNIEnv *env;
    bool ready_in_java_env = false;
    int value = 0;

    LOGD("JNI_GetSharedValue");

    if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        // Attach主线程
        if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return value;
        }
    } else {
        ready_in_java_env = true;
    }

    jclass cls = env->GetObjectClass(sg_obj);
    jmethodID fun = env->GetMethodID(cls, "GetSharedValue", "(Ljava/lang/String;)I");

    value = env->CallIntMethod(sg_obj, fun, env->NewStringUTF(key));

    env->DeleteLocalRef(cls);

    if (!ready_in_java_env) {
        //Detach主线程
        if (sg_jvm->DetachCurrentThread() != JNI_OK) {
            LOGE("%s: DetachCurrentThread() failed", __FUNCTION__);
        }
    }
    return value;
}

void TextSpeak(const char *text)