Merge branch 'release/0.3.13'

Author: yulingtianxia

dart_native/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.13
+
+* [Fix] Memory leaks on Android.
+
 ## 0.3.12
 
 * [Feature] Support List/Array for Android.

dart_native/android/src/main/jni/dart_native.cpp

@@ -16,6 +16,8 @@ extern "C" {
 static JavaVM *gJvm = nullptr;
 static jobject gClassLoader;
 static jmethodID gFindClassMethod;
+static JNIEnv *gCurEnv = nullptr;
+static pthread_key_t detachKey = 0;
 
 typedef void (*NativeMethodCallback)(
     void *targetPtr,
@@ -46,18 +48,33 @@ JNIEnv *getEnv() {
     return env;
 }
 
+void detachThreadDestructor(void* arg) {
+  NSLog("detach from current thread");
+  gJvm->DetachCurrentThread();
+  detachKey = 0;
+}
+
+void attachThread() {
+  if (detachKey == 0) {
+    NSLog("attach to current thread");
+    pthread_key_create(&detachKey, detachThreadDestructor);
+    gJvm->AttachCurrentThread(&gCurEnv, NULL);
+    pthread_setspecific(detachKey, nullptr);
+  }
+}
+
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *pjvm, void *reserved) {
     NSLog("JNI_OnLoad");
     gJvm = pjvm;  // cache the JavaVM pointer
-    auto env = getEnv();
+    gCurEnv = getEnv();
     //replace with one of your classes in the line below
-    auto randomClass = env->FindClass("com/dartnative/dart_native/DartNativePlugin");
-    jclass classClass = env->GetObjectClass(randomClass);
-    auto classLoaderClass = env->FindClass("java/lang/ClassLoader");
-    auto getClassLoaderMethod = env->GetMethodID(classClass, "getClassLoader",
+    auto randomClass = gCurEnv->FindClass("com/dartnative/dart_native/DartNativePlugin");
+    jclass classClass = gCurEnv->GetObjectClass(randomClass);
+    auto classLoaderClass = gCurEnv->FindClass("java/lang/ClassLoader");
+    auto getClassLoaderMethod = gCurEnv->GetMethodID(classClass, "getClassLoader",
                                                  "()Ljava/lang/ClassLoader;");
-    gClassLoader = env->NewGlobalRef(env->CallObjectMethod(randomClass, getClassLoaderMethod));
-    gFindClassMethod = env->GetMethodID(classLoaderClass, "findClass",
+    gClassLoader = gCurEnv->NewGlobalRef(gCurEnv->CallObjectMethod(randomClass, getClassLoaderMethod));
+    gFindClassMethod = gCurEnv->GetMethodID(classLoaderClass, "findClass",
                                         "(Ljava/lang/String;)Ljava/lang/Class;");
 
     NSLog("JNI_OnLoad finish");
@@ -77,18 +94,20 @@ char *generateSignature(char **argTypes) {
   if (argTypes != nullptr)
   {
     for (; *argTypes; ++argTypes, ++argCount) {
-      signature = spliceChar(signature, *argTypes);
+      char *templeSignature = spliceChar(signature, *argTypes);
+      signature = templeSignature;
+      free(templeSignature);
     }
   }
   return spliceChar(signature, const_cast<char *>(")"));
 }
 
-void fillArgs(void **args, char **argTypes, jvalue *argValues, JNIEnv *curEnv) {
+void fillArgs(void **args, char **argTypes, jvalue *argValues) {
   for(jsize index(0); *argTypes ; ++args, ++index, ++argTypes) {
     char *argType = *argTypes;
     if (strlen(argType) > 1) {
       if (strcmp(argType, "Ljava/lang/String;") == 0) {
-        argValues[index].l = curEnv->NewStringUTF((char *)*args);
+        argValues[index].l = gCurEnv->NewStringUTF((char *)*args);
       }
       else {
         jobject object = callbackObjCache.count(*args) ? callbackObjCache[*args] : static_cast<jobject>(*args);
@@ -137,61 +156,38 @@ jclass findClass(JNIEnv *env, const char *name) {
     return nativeClass;
 }
 
-jobject newObject(JNIEnv *env, jclass cls, void **args, char **argTypes) {
+jobject newObject(jclass cls, void **args, char **argTypes) {
   char *signature = generateSignature(argTypes);
   jvalue *argValues = new jvalue[strlen(signature) - 2];
   if (strlen(signature) - 2 > 0) {
-    fillArgs(args, argTypes, argValues, env);
+    fillArgs(args, argTypes, argValues);
   }
-  jmethodID constructor = env->GetMethodID(cls, "<init>", spliceChar(signature, const_cast<char *>("V")));
-  jobject newObj = env->NewObjectA(cls, constructor, argValues);
+  char *constructorSig = spliceChar(signature, const_cast<char *>("V"));
+  jmethodID constructor = gCurEnv->GetMethodID(cls, "<init>", constructorSig);
+  jobject newObj = gCurEnv->NewObjectA(cls, constructor, argValues);
   free(argValues);
+  free(constructorSig);
   return newObj;
 }
 
 void *createTargetClass(char *targetClassName, void **args, char **argTypes) {
-    JNIEnv *curEnv;
-    bool bShouldDetach = false;
-
-    auto error = gJvm->GetEnv((void **) &curEnv, JNI_VERSION_1_6);
-    if (error < 0) {
-        error = gJvm->AttachCurrentThread(&curEnv, nullptr);
-        bShouldDetach = true;
-        NSLog("AttachCurrentThread : %d", error);
-    }
-
-    jclass cls = findClass(curEnv, targetClassName);
+    attachThread();
 
-    jobject newObj = curEnv->NewGlobalRef(newObject(curEnv, cls, args, argTypes));
-    cache[newObj] = static_cast<jclass>(curEnv->NewGlobalRef(cls));
+    jclass cls = findClass(gCurEnv, targetClassName);
 
-
-    if (bShouldDetach) {
-        gJvm->DetachCurrentThread();
-    }
+    jobject newObj = gCurEnv->NewGlobalRef(newObject(cls, args, argTypes));
+    cache[newObj] = static_cast<jclass>(gCurEnv->NewGlobalRef(cls));
 
     return newObj;
 }
 
 
 void releaseTargetClass(void *classPtr) {
-    JNIEnv *curEnv;
-    bool bShouldDetach = false;
-
-    auto error = gJvm->GetEnv((void **) &curEnv, JNI_VERSION_1_6);
-    if (error < 0) {
-        error = gJvm->AttachCurrentThread(&curEnv, nullptr);
-        bShouldDetach = true;
-        NSLog("AttachCurrentThread : %d", error);
-    }
+    attachThread();
 
     jobject object = static_cast<jobject>(classPtr);
     cache.erase(object);
-    curEnv->DeleteGlobalRef(object);
-
-    if (bShouldDetach) {
-        gJvm->DetachCurrentThread();
-    }
+    gCurEnv->DeleteGlobalRef(object);
 }
 
 void retain(void *classPtr) {
@@ -216,82 +212,75 @@ void release(void *classPtr) {
 }
 
 void *invokeNativeMethodNeo(void *classPtr, char *methodName, void **args, char **argTypes, char *returnType) {
-    JNIEnv *curEnv;
-    bool bShouldDetach = false;
     void *nativeInvokeResult = nullptr;
 
-    auto error = gJvm->GetEnv((void **) &curEnv, JNI_VERSION_1_6);
-    if (error < 0) {
-        gJvm->AttachCurrentThread(&curEnv, nullptr);
-        bShouldDetach = true;
-    }
+    attachThread();
     jobject object = static_cast<jobject>(classPtr);
     jclass cls = cache[object];
     char *signature = generateSignature(argTypes);
     jvalue *argValues = new jvalue[strlen(signature) - 2];
     if ((strlen(signature) - 2) > 0) {
-      fillArgs(args, argTypes, argValues, curEnv);
+      fillArgs(args, argTypes, argValues);
     }
-    jmethodID method = curEnv->GetMethodID(cls, methodName, spliceChar(signature, returnType));
-    NSLog("call method: %s descriptor: %s", methodName, spliceChar(signature, returnType));
+    char *methodSignature = spliceChar(signature, returnType);
+    jmethodID method = gCurEnv->GetMethodID(cls, methodName, methodSignature);
+    NSLog("call method: %s descriptor: %s", methodName, methodSignature);
 
-  if (strlen(returnType) > 1) {
+    if (strlen(returnType) > 1) {
         if (strcmp(returnType, "Ljava/lang/String;") == 0) {
-            jstring javaString = (jstring)curEnv->CallObjectMethodA(object, method, argValues);
+            jstring javaString = (jstring)gCurEnv->CallObjectMethodA(object, method, argValues);
             jboolean isCopy = JNI_FALSE;
-            nativeInvokeResult = (char *) curEnv->GetStringUTFChars(javaString, &isCopy);
+            nativeInvokeResult = (char *) gCurEnv->GetStringUTFChars(javaString, &isCopy);
         }
         else {
-            jobject obj = curEnv->NewGlobalRef(curEnv->CallObjectMethodA(object, method, argValues));
-            jclass objCls = curEnv->GetObjectClass(obj);
+            jobject obj = gCurEnv->NewGlobalRef(gCurEnv->CallObjectMethodA(object, method, argValues));
+            jclass objCls = gCurEnv->GetObjectClass(obj);
             //store class value
-            cache[obj] = static_cast<jclass>(curEnv->NewGlobalRef(objCls));
+            cache[obj] = static_cast<jclass>(gCurEnv->NewGlobalRef(objCls));
             nativeInvokeResult = obj;
         }
     }
     else if (strcmp(returnType, "C") == 0) {
-        auto nativeChar = curEnv->CallCharMethodA(object, method, argValues);
+        auto nativeChar = gCurEnv->CallCharMethodA(object, method, argValues);
         nativeInvokeResult = (void *) nativeChar;
     }
     else if(strcmp(returnType, "I") == 0) {
-        auto nativeInt = curEnv->CallIntMethodA(object, method, argValues);
+        auto nativeInt = gCurEnv->CallIntMethodA(object, method, argValues);
         nativeInvokeResult = (void *) nativeInt;
     }
     else if(strcmp(returnType, "D") == 0) {
-        auto nativeDouble = curEnv->CallDoubleMethodA(object, method, argValues);
+        auto nativeDouble = gCurEnv->CallDoubleMethodA(object, method, argValues);
         double cDouble = (double) nativeDouble;
         memcpy(&nativeInvokeResult, &cDouble, sizeof(double));
     }
     else if(strcmp(returnType, "F") == 0) {
-        auto nativeDouble = curEnv->CallFloatMethodA(object, method, argValues);
+        auto nativeDouble = gCurEnv->CallFloatMethodA(object, method, argValues);
         float cDouble = (float) nativeDouble;
         memcpy(&nativeInvokeResult, &cDouble, sizeof(float));
     }
     else if(strcmp(returnType, "B") == 0) {
-        auto nativeByte = curEnv->CallByteMethodA(object, method, argValues);
+        auto nativeByte = gCurEnv->CallByteMethodA(object, method, argValues);
         nativeInvokeResult = (void *) nativeByte;
     }
     else if(strcmp(returnType, "S") == 0) {
-        auto nativeShort = curEnv->CallShortMethodA(object, method, argValues);
+        auto nativeShort = gCurEnv->CallShortMethodA(object, method, argValues);
         nativeInvokeResult = (void *) nativeShort;
     }
     else if(strcmp(returnType, "J") == 0) {
-        auto nativeLong = curEnv->CallLongMethodA(object, method, argValues);
+        auto nativeLong = gCurEnv->CallLongMethodA(object, method, argValues);
         nativeInvokeResult = (void *) nativeLong;
     }
     else if(strcmp(returnType, "Z") == 0) {
-      auto nativeBool = curEnv->CallBooleanMethodA(object, method, argValues);
+      auto nativeBool = gCurEnv->CallBooleanMethodA(object, method, argValues);
       nativeInvokeResult = (void *) nativeBool;
     }
     else if(strcmp(returnType, "V") == 0) {
-        curEnv->CallVoidMethodA(object, method, argValues);
+      gCurEnv->CallVoidMethodA(object, method, argValues);
     }
 
     free(argValues);
+    free(methodSignature);
     free(signature);
-    if (bShouldDetach) {
-        gJvm->DetachCurrentThread();
-    }
     return nativeInvokeResult;
 }
 
@@ -318,31 +307,21 @@ NativeMethodCallback getCallbackMethod(jlong targetAddr, char *functionName) {
 }
 
 void registerNativeCallback(void *target, char* targetName, char *funName, void *callback) {
-    JNIEnv *curEnv;
-    bool bShouldDetach = false;
-    auto error = gJvm->GetEnv((void **) &curEnv, JNI_VERSION_1_6);
-    if (error < 0) {
-        error = gJvm->AttachCurrentThread(&curEnv, nullptr);
-        bShouldDetach = true;
-        NSLog("AttachCurrentThread : %d", error);
-    }
+    attachThread();
 
-    jclass callbackManager = findClass(curEnv, "com/dartnative/dart_native/CallbackManager");
-    jmethodID registerCallback = curEnv->GetStaticMethodID(callbackManager, "registerCallback", "(JLjava/lang/String;)Ljava/lang/Object;");
+    jclass callbackManager = findClass(gCurEnv, "com/dartnative/dart_native/CallbackManager");
+    jmethodID registerCallback = gCurEnv->GetStaticMethodID(callbackManager, "registerCallback", "(JLjava/lang/String;)Ljava/lang/Object;");
     jlong targetAddr = (jlong)target;
     jvalue *argValues = new jvalue[2];
     argValues[0].j = targetAddr;
-    argValues[1].l = curEnv->NewStringUTF(targetName);
-    jobject callbackOJ = curEnv->NewGlobalRef(curEnv->CallStaticObjectMethodA(callbackManager, registerCallback, argValues));
+    argValues[1].l = gCurEnv->NewStringUTF(targetName);
+    jobject callbackOJ = gCurEnv->NewGlobalRef(gCurEnv->CallStaticObjectMethodA(callbackManager, registerCallback, argValues));
     callbackObjCache[target] = callbackOJ;
     targetCache[targetAddr] = target;
 
     registerCallbackManager(targetAddr, funName, callback);
-    curEnv->DeleteLocalRef(callbackManager);
+    gCurEnv->DeleteLocalRef(callbackManager);
     free(argValues);
-    if (bShouldDetach) {
-        gJvm->DetachCurrentThread();
-    }
 }
 
 // Dart extensions
@@ -407,10 +386,9 @@ JNIEXPORT jobject JNICALL Java_com_dartnative_dart_1native_CallbackInvocationHan
     char **argTypes = new char *[argTypeLength + 1];
     void **arguments = new void *[argTypeLength];
     for (int i = 0; i < argTypeLength; ++i) {
-        jobject argType = env->GetObjectArrayElement(arg_types, i);
+        jstring argTypeString = (jstring) env->GetObjectArrayElement(arg_types, i);
         jobject argument = env->GetObjectArrayElement(args, i);
 
-        jstring argTypeString = (jstring) argType;
         argTypes[i] = (char *) env->GetStringUTFChars(argTypeString, 0);
         env->DeleteLocalRef(argTypeString);
         //todo optimization
@@ -451,7 +429,7 @@ JNIEXPORT jobject JNICALL Java_com_dartnative_dart_1native_CallbackInvocationHan
     }
     char *returnType = (char *) env->GetStringUTFChars(return_type, 0);
     argTypes[argTypeLength] = returnType;
-    const Work work = [dartObject, argTypes, arguments, arg_count, funName, &sem, isSemInitSuccess, return_type]() {
+    const Work work = [dartObject, argTypes, arguments, arg_count, funName, &sem, isSemInitSuccess]() {
         NativeMethodCallback methodCallback = getCallbackMethod(dartObject, funName);
         void *target = targetCache[dartObject];
         if (methodCallback != NULL && target != nullptr) {
@@ -469,10 +447,12 @@ JNIEXPORT jobject JNICALL Java_com_dartnative_dart_1native_CallbackInvocationHan
     jobject callbackResult = NULL;
 
     if (isSemInitSuccess) {
-        NSLog("wait");
+        NSLog("wait work execute");
         sem_wait(&sem);
         //todo optimization
-        if (strcmp(returnType, "Ljava/lang/String;") == 0) {
+        if (returnType == nullptr) {
+          NSLog("void");
+        } else if (strcmp(returnType, "Ljava/lang/String;") == 0) {
             callbackResult = env->NewStringUTF((char *) arguments[0]);
         } else if (strcmp(returnType, "Z") == 0) {
             jclass booleanClass = env->FindClass("java/lang/Boolean");
@@ -483,9 +463,10 @@ JNIEXPORT jobject JNICALL Java_com_dartnative_dart_1native_CallbackInvocationHan
         sem_destroy(&sem);
     }
 
+    free(returnType);
     free(funName);
-    free(argTypes);
     free(arguments);
+    free(argTypes);
 
     return callbackResult;
 }

dart_native/example/lib/android/delegate_stub.dart

@@ -5,7 +5,7 @@ import 'package:dart_native_example/android/runtimestub.dart';
 
 class DelegateStub extends JObject with SampleDelegate {
   DelegateStub([Pointer ptr])
-      : super("com/dartnative/dart_native_example/SampleDelegate", ptr) {
+      : super("com/dartnative/dart_native_example/SampleDelegate", pointer: ptr) {
     super.registerSampleDelegate();
   }
 

dart_native/example/lib/android/entity.dart

@@ -2,7 +2,7 @@ import 'dart:ffi';
 
 import 'package:dart_native/dart_native.dart';
 class Entity extends JObject {
-  Entity([Pointer ptr]) : super("com/dartnative/dart_native_example/Entity", ptr);
+  Entity([Pointer ptr]) : super("com/dartnative/dart_native_example/Entity", pointer: ptr);
 
   int getCurrentTime() {
     return invoke('getCurrentTime', [], "I");

dart_native/example/pubspec.lock

@@ -168,7 +168,7 @@ packages:
       path: ".."
       relative: true
     source: path
-    version: "0.3.12"
+    version: "0.3.13"
   dart_native_gen:
     dependency: transitive
     description:

dart_native/lib/src/android/foundation/collection/jarray.dart

@@ -21,7 +21,7 @@ class JArray extends JSubclass<List> {
 
   JArray.fromPointer(Pointer<Void> ptr) : super.fromPointer(ptr, CLS_ARRAY_OBJECT) {
     JObject converter = JObject("com/dartnative/dart_native/ArrayListConverter");
-    raw = JList.fromPointer(converter.invoke("arrayToList", [JObject("java/lang/Object", ptr)], "Ljava/util/List;")).raw;
+    raw = JList.fromPointer(converter.invoke("arrayToList", [JObject("java/lang/Object", pointer: ptr)], "Ljava/util/List;")).raw;
   }
 }
 

dart_native/lib/src/android/foundation/collection/jlist.dart

@@ -51,9 +51,9 @@ Pointer<Void> _new(dynamic value, String clsName) {
 }
 
 String _getItemClass(Pointer<Void> itemPtr) {
-  JObject templeObject = JObject("java/lang/Object", itemPtr);
+  JObject templeObject = JObject("java/lang/Object", pointer: itemPtr);
   templeObject = JObject("java/lang/Class",
-      templeObject.invoke("getClass", null, "Ljava/lang/Class;"));
+      pointer: templeObject.invoke("getClass", null, "Ljava/lang/Class;"));
 
   return templeObject.invoke("getName", null, "Ljava/lang/String;");
 }