1 files changed, 327 insertions, 205 deletions

diff --git a/service/jni/jni_helper.cpp b/service/jni/jni_helper.cpp
index ef67391b5..73209619e 100644
--- a/service/jni/jni_helper.cpp
+++ b/service/jni/jni_helper.cpp
@@ -31,471 +31,593 @@ namespace android {
 
 /* JNI Helpers for wifi_hal implementation */
 
-void throwException( JNIEnv *env, const char *message, int line )
+JNIHelper::JNIHelper(JavaVM *vm)
+{
+    vm->AttachCurrentThread(&mEnv, NULL);
+    mVM = vm;
+}
+
+JNIHelper::JNIHelper(JNIEnv *env)
+{
+    mVM  = NULL;
+    mEnv = env;
+}
+
+JNIHelper::~JNIHelper()
+{
+    if (mVM != NULL) {
+        // mVM->DetachCurrentThread();  /* 'attempting to detach while still running code' */
+        mVM = NULL;                     /* not really required; but may help debugging */
+        mEnv = NULL;                    /* not really required; but may help debugging */
+    }
+}
+
+jobject JNIHelper::newGlobalRef(jobject obj) {
+    return mEnv->NewGlobalRef(obj);
+}
+
+void JNIHelper::deleteGlobalRef(jobject obj) {
+    mEnv->DeleteGlobalRef(obj);
+}
+
+jobject JNIHelper::newLocalRef(jobject obj) {
+    return mEnv->NewLocalRef(obj);
+}
+
+void JNIHelper::deleteLocalRef(jobject obj) {
+    mEnv->DeleteLocalRef(obj);
+}
+
+void JNIHelper::throwException(const char *message, int line)
 {
     ALOGE("error at line %d: %s", line, message);
 
     const char *className = "java/lang/Exception";
 
-    jclass exClass = (env)->FindClass(className );
+    jclass exClass = mEnv->FindClass(className );
     if ( exClass == NULL ) {
         ALOGE("Could not find exception class to throw error");
         ALOGE("error at line %d: %s", line, message);
         return;
     }
 
-    (env)->ThrowNew(exClass, message);
+    mEnv->ThrowNew(exClass, message);
 }
 
-jboolean getBoolField(JNIEnv *env, jobject obj, const char *name)
+jboolean JNIHelper::getBoolField(jobject obj, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, "Z");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "Z");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
 
-    jboolean value = (env)->GetBooleanField(obj, field);
-    env->DeleteLocalRef(cls);
-    return value;
+    return mEnv->GetBooleanField(obj, field);
 }
 
-jint getIntField(JNIEnv *env, jobject obj, const char *name)
+jint JNIHelper::getIntField(jobject obj, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, "I");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "I");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
 
-    jint value = (env)->GetIntField(obj, field);
-    env->DeleteLocalRef(cls);
-    return value;
+    return mEnv->GetIntField(obj, field);
 }
 
-jbyte getByteField(JNIEnv *env, jobject obj, const char *name)
+jbyte JNIHelper::getByteField(jobject obj, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, "B");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "B");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
 
-    jbyte value = (env)->GetByteField(obj, field);
-    env->DeleteLocalRef(cls);
-    return value;
+    return mEnv->GetByteField(obj, field);
 }
 
-jlong getLongField(JNIEnv *env, jobject obj, const char *name)
+jlong JNIHelper::getLongField(jobject obj, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, "J");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "J");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
 
-    jlong value = (env)->GetLongField(obj, field);
-    env->DeleteLocalRef(cls);
-    return value;
+    return mEnv->GetLongField(obj, field);
 }
 
-jlong getStaticLongField(JNIEnv *env, jobject obj, const char *name)
+JNIObject<jstring> JNIHelper::getStringField(jobject obj, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jlong result = getStaticLongField(env, cls, name);
-    env->DeleteLocalRef(cls);
-    return result;
+    JNIObject<jobject> m = getObjectField(obj, name, "Ljava/lang/String;");
+    if (m == NULL) {
+        THROW(*this, "Error in accessing field");
+        return JNIObject<jstring>(*this, NULL);
+    }
+
+    return JNIObject<jstring>(*this, (jstring)m.detach());
 }
 
-jlong getStaticLongField(JNIEnv *env, jclass cls, const char *name)
+bool JNIHelper::getStringFieldValue(jobject obj, const char *name, char *buf, int size)
 {
-    jfieldID field = (env)->GetStaticFieldID(cls, name, "J");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "Ljava/lang/String;");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
-    //ALOGE("getStaticLongField %s %p", name, cls);
 
-    return (env)->GetStaticLongField(cls, field);
+    JNIObject<jobject> value(*this, mEnv->GetObjectField(obj, field));
+    JNIObject<jstring> string(*this, (jstring)value.clone());
+    ScopedUtfChars chars(mEnv, string);
+
+    const char *utf = chars.c_str();
+    if (utf == NULL) {
+        THROW(*this, "Error in accessing value");
+        return false;
+    }
+
+    if (*utf != 0 && size < 1) {
+        return false;
+    }
+
+    strncpy(buf, utf, size);
+    if (size > 0) {
+        buf[size - 1] = 0;
+    }
+
+    return true;
+}
+
+jlong JNIHelper::getStaticLongField(jobject obj, const char *name)
+{
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    return getStaticLongField(cls, name);
 }
 
-jobject getObjectField(JNIEnv *env, jobject obj, const char *name, const char *type)
+jlong JNIHelper::getStaticLongField(jclass cls, const char *name)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, type);
+    jfieldID field = mEnv->GetStaticFieldID(cls, name, "J");
     if (field == 0) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return 0;
     }
+    //ALOGE("getStaticLongField %s %p", name, cls);
+    return mEnv->GetStaticLongField(cls, field);
+}
 
-    jobject value = (env)->GetObjectField(obj, field);
-    env->DeleteLocalRef(cls);
-    return value;
+JNIObject<jobject> JNIHelper::getObjectField(jobject obj, const char *name, const char *type)
+{
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, type);
+    if (field == 0) {
+        THROW(*this, "Error in accessing field");
+        return JNIObject<jobject>(*this, NULL);
+    }
+
+    return JNIObject<jobject>(*this, mEnv->GetObjectField(obj, field));
+}
+
+JNIObject<jobjectArray> JNIHelper::getArrayField(jobject obj, const char *name, const char *type)
+{
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, type);
+    if (field == 0) {
+        THROW(*this, "Error in accessing field");
+        return JNIObject<jobjectArray>(*this, NULL);
+    }
+
+    return JNIObject<jobjectArray>(*this, (jobjectArray)mEnv->GetObjectField(obj, field));
 }
 
-jlong getLongArrayField(JNIEnv *env, jobject obj, const char *name, int index)
+jlong JNIHelper::getLongArrayField(jobject obj, const char *name, int index)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, "[J");
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, "[J");
     if (field == 0) {
-        THROW(env, "Error in accessing field definition");
+        THROW(*this, "Error in accessing field definition");
         return 0;
     }
 
-    jlongArray array = (jlongArray)(env)->GetObjectField(obj, field);
+    JNIObject<jlongArray> array(*this, (jlongArray)mEnv->GetObjectField(obj, field));
     if (array == NULL) {
-        THROW(env, "Error in accessing array");
+        THROW(*this, "Error in accessing array");
         return 0;
     }
 
-    jlong *elem = (env)->GetLongArrayElements(array, 0);
+    jlong *elem = mEnv->GetLongArrayElements(array, 0);
     if (elem == NULL) {
-        THROW(env, "Error in accessing index element");
+        THROW(*this, "Error in accessing index element");
         return 0;
     }
 
     jlong value = elem[index];
-    (env)->ReleaseLongArrayElements(array, elem, 0);
-
-    env->DeleteLocalRef(array);
-    env->DeleteLocalRef(cls);
-
+    mEnv->ReleaseLongArrayElements(array, elem, 0);
     return value;
 }
 
-jlong getStaticLongArrayField(JNIEnv *env, jobject obj, const char *name, int index)
+jlong JNIHelper::getStaticLongArrayField(jobject obj, const char *name, int index)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jlong result = getStaticLongArrayField(env, cls, name, index);
-    env->DeleteLocalRef(cls);
-    return result;
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    return getStaticLongArrayField(cls, name, index);
 }
 
-jlong getStaticLongArrayField(JNIEnv *env, jclass cls, const char *name, int index)
+jlong JNIHelper::getStaticLongArrayField(jclass cls, const char *name, int index)
 {
-    jfieldID field = (env)->GetStaticFieldID(cls, name, "[J");
+    jfieldID field = mEnv->GetStaticFieldID(cls, name, "[J");
     if (field == 0) {
-        THROW(env, "Error in accessing field definition");
+        THROW(*this, "Error in accessing field definition");
         return 0;
     }
 
-    jlongArray array = (jlongArray)(env)->GetStaticObjectField(cls, field);
-    jlong *elem = (env)->GetLongArrayElements(array, 0);
+    JNIObject<jlongArray> array(*this, (jlongArray)mEnv->GetStaticObjectField(cls, field));
+    jlong *elem = mEnv->GetLongArrayElements(array, 0);
     if (elem == NULL) {
-        THROW(env, "Error in accessing index element");
+        THROW(*this, "Error in accessing index element");
         return 0;
     }
 
     jlong value = elem[index];
-    (env)->ReleaseLongArrayElements(array, elem, 0);
-
-    env->DeleteLocalRef(array);
+    mEnv->ReleaseLongArrayElements(array, elem, 0);
     return value;
 }
 
-jobject getObjectArrayField(JNIEnv *env, jobject obj, const char *name, const char *type, int index)
+JNIObject<jobject> JNIHelper::getObjectArrayField(jobject obj, const char *name, const char *type,
+int index)
 {
-    jclass cls = (env)->GetObjectClass(obj);
-    jfieldID field = (env)->GetFieldID(cls, name, type);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
+    jfieldID field = mEnv->GetFieldID(cls, name, type);
     if (field == 0) {
-        THROW(env, "Error in accessing field definition");
-        return 0;
+        THROW(*this, "Error in accessing field definition");
+        return JNIObject<jobject>(*this, NULL);
     }
 
-    jobjectArray array = (jobjectArray)(env)->GetObjectField(obj, field);
-    jobject elem = (env)->GetObjectArrayElement(array, index);
-    if (elem == NULL) {
-        THROW(env, "Error in accessing index element");
-        return 0;
+    JNIObject<jobjectArray> array(*this, (jobjectArray)mEnv->GetObjectField(obj, field));
+    JNIObject<jobject> elem(*this, mEnv->GetObjectArrayElement(array, index));
+    if (elem.isNull()) {
+        THROW(*this, "Error in accessing index element");
+        return JNIObject<jobject>(*this, NULL);
     }
-
-    env->DeleteLocalRef(array);
-    env->DeleteLocalRef(cls);
     return elem;
 }
 
-void setIntField(JNIEnv *env, jobject obj, const char *name, jint value)
+void JNIHelper::setIntField(jobject obj, const char *name, jint value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "I");
+    jfieldID field = mEnv->GetFieldID(cls, name, "I");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetIntField(obj, field, value);
-    env->DeleteLocalRef(cls);
+    mEnv->SetIntField(obj, field, value);
 }
 
-void setByteField(JNIEnv *env, jobject obj, const char *name, jbyte value)
+void JNIHelper::setByteField(jobject obj, const char *name, jbyte value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "B");
+    jfieldID field = mEnv->GetFieldID(cls, name, "B");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetByteField(obj, field, value);
-    env->DeleteLocalRef(cls);
+    mEnv->SetByteField(obj, field, value);
 }
 
-void setBooleanField(JNIEnv *env, jobject obj, const char *name, jboolean value)
+void JNIHelper::setBooleanField(jobject obj, const char *name, jboolean value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "Z");
+    jfieldID field = mEnv->GetFieldID(cls, name, "Z");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetBooleanField(obj, field, value);
-    env->DeleteLocalRef(cls);
+    mEnv->SetBooleanField(obj, field, value);
 }
 
-void setLongField(JNIEnv *env, jobject obj, const char *name, jlong value)
+void JNIHelper::setLongField(jobject obj, const char *name, jlong value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "J");
+    jfieldID field = mEnv->GetFieldID(cls, name, "J");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetLongField(obj, field, value);
-    env->DeleteLocalRef(cls);
+    mEnv->SetLongField(obj, field, value);
 }
 
-void setStaticLongField(JNIEnv *env, jobject obj, const char *name, jlong value)
+void JNIHelper::setStaticLongField(jobject obj, const char *name, jlong value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    setStaticLongField(env, cls, name, value);
-    env->DeleteLocalRef(cls);
+    setStaticLongField(cls, name, value);
 }
 
-void setStaticLongField(JNIEnv *env, jclass cls, const char *name, jlong value)
+void JNIHelper::setStaticLongField(jclass cls, const char *name, jlong value)
 {
-    jfieldID field = (env)->GetStaticFieldID(cls, name, "J");
+    jfieldID field = mEnv->GetStaticFieldID(cls, name, "J");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetStaticLongField(cls, field, value);
+    mEnv->SetStaticLongField(cls, field, value);
 }
 
-void setLongArrayField(JNIEnv *env, jobject obj, const char *name, jlongArray value)
+void JNIHelper::setLongArrayField(jobject obj, const char *name, jlongArray value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
-    } else {
-        ALOGD("cls = %p", cls);
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "[J");
+    jfieldID field = mEnv->GetFieldID(cls, name, "[J");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetObjectField(obj, field, value);
-    ALOGD("array field set");
-
-    env->DeleteLocalRef(cls);
+    mEnv->SetObjectField(obj, field, value);
 }
 
-void setStaticLongArrayField(JNIEnv *env, jobject obj, const char *name, jlongArray value)
+void JNIHelper::setStaticLongArrayField(jobject obj, const char *name, jlongArray value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
-    } else {
-        ALOGD("cls = %p", cls);
     }
 
-    setStaticLongArrayField(env, cls, name, value);
-    env->DeleteLocalRef(cls);
+    setStaticLongArrayField(cls, name, value);
 }
 
-void setStaticLongArrayField(JNIEnv *env, jclass cls, const char *name, jlongArray value)
+void JNIHelper::setStaticLongArrayField(jclass cls, const char *name, jlongArray value)
 {
-    jfieldID field = (env)->GetStaticFieldID(cls, name, "[J");
+    jfieldID field = mEnv->GetStaticFieldID(cls, name, "[J");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetStaticObjectField(cls, field, value);
+    mEnv->SetStaticObjectField(cls, field, value);
     ALOGD("array field set");
 }
 
-void setLongArrayElement(JNIEnv *env, jobject obj, const char *name, int index, jlong value)
+void JNIHelper::setLongArrayElement(jobject obj, const char *name, int index, jlong value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
-    } else {
-        ALOGD("cls = %p", cls);
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, "[J");
+    jfieldID field = mEnv->GetFieldID(cls, name, "[J");
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
-    } else {
-        ALOGD("field = %p", field);
     }
 
-    jlongArray array = (jlongArray)(env)->GetObjectField(obj, field);
+    JNIObject<jlongArray> array(*this, (jlongArray)mEnv->GetObjectField(obj, field));
     if (array == NULL) {
-        THROW(env, "Error in accessing array");
+        THROW(*this, "Error in accessing array");
         return;
-    } else {
-        ALOGD("array = %p", array);
     }
 
-    jlong *elem = (env)->GetLongArrayElements(array, NULL);
+    jlong *elem = mEnv->GetLongArrayElements(array, NULL);
     if (elem == NULL) {
-        THROW(env, "Error in accessing index element");
+        THROW(*this, "Error in accessing index element");
         return;
     }
 
     elem[index] = value;
-    env->ReleaseLongArrayElements(array, elem, 0);
-    env->DeleteLocalRef(array);
-    env->DeleteLocalRef(cls);
+    mEnv->ReleaseLongArrayElements(array, elem, 0);
 }
 
-void setObjectField(JNIEnv *env, jobject obj, const char *name, const char *type, jobject value)
+void JNIHelper::setObjectField(jobject obj, const char *name, const char *type, jobject value)
 {
-    jclass cls = (env)->GetObjectClass(obj);
+    JNIObject<jclass> cls(*this, mEnv->GetObjectClass(obj));
     if (cls == NULL) {
-        THROW(env, "Error in accessing class");
+        THROW(*this, "Error in accessing class");
         return;
     }
 
-    jfieldID field = (env)->GetFieldID(cls, name, type);
+    jfieldID field = mEnv->GetFieldID(cls, name, type);
     if (field == NULL) {
-        THROW(env, "Error in accessing field");
+        THROW(*this, "Error in accessing field");
         return;
     }
 
-    (env)->SetObjectField(obj, field, value);
-    env->DeleteLocalRef(cls);
+    mEnv->SetObjectField(obj, field, value);
 }
 
-jboolean setStringField(JNIEnv *env, jobject obj, const char *name, const char *value)
+jboolean JNIHelper::setStringField(jobject obj, const char *name, const char *value)
 {
+    JNIObject<jstring> str(*this, mEnv->NewStringUTF(value));
 
-    jstring str = env->NewStringUTF(value);
-
-    if (env->ExceptionCheck()) {
-        env->ExceptionDescribe();
-        env->ExceptionClear();
+    if (mEnv->ExceptionCheck()) {
+        mEnv->ExceptionDescribe();
+        mEnv->ExceptionClear();
         return false;
     }
 
     if (str == NULL) {
-        ALOGE("Error in string allocation");
+        THROW(*this, "Error creating string");
         return false;
     }
 
-    setObjectField(env, obj, name, "Ljava/lang/String;", str);
-    env->DeleteLocalRef(str);
+    setObjectField(obj, name, "Ljava/lang/String;", str);
     return true;
 }
 
-void reportEvent(JNIEnv *env, jclass cls, const char *method, const char *signature, ...)
+void JNIHelper::reportEvent(jclass cls, const char *method, const char *signature, ...)
 {
     va_list params;
     va_start(params, signature);
 
-    jmethodID methodID = env->GetStaticMethodID(cls, method, signature);
-    if (methodID == NULL) {
+    jmethodID methodID = mEnv->GetStaticMethodID(cls, method, signature);
+    if (methodID == 0) {
         ALOGE("Error in getting method ID");
         return;
     }
 
-    env->CallStaticVoidMethodV(cls, methodID, params);
-    if (env->ExceptionCheck()) {
-        env->ExceptionDescribe();
-        env->ExceptionClear();
+    mEnv->CallStaticVoidMethodV(cls, methodID, params);
+    if (mEnv->ExceptionCheck()) {
+        mEnv->ExceptionDescribe();
+        mEnv->ExceptionClear();
+    }
+
+    va_end(params);
+}
+
+jboolean JNIHelper::callStaticMethod(jclass cls, const char *method, const char *signature, ...)
+{
+    va_list params;
+    va_start(params, signature);
+
+    jmethodID methodID = mEnv->GetStaticMethodID(cls, method, signature);
+    if (methodID == 0) {
+        ALOGE("Error in getting method ID");
+        return false;
+    }
+
+    jboolean result = mEnv->CallStaticBooleanMethodV(cls, methodID, params);
+    if (mEnv->ExceptionCheck()) {
+        mEnv->ExceptionDescribe();
+        mEnv->ExceptionClear();
+        return false;
     }
+
     va_end(params);
+    return result;
 }
 
-jobject createObject(JNIEnv *env, const char *className)
+JNIObject<jobject> JNIHelper::createObject(const char *className)
 {
-    jclass cls = env->FindClass(className);
+    JNIObject<jclass> cls(*this, mEnv->FindClass(className));
     if (cls == NULL) {
         ALOGE("Error in finding class %s", className);
-        return NULL;
+        return JNIObject<jobject>(*this, NULL);
     }
 
-    jmethodID constructor = env->GetMethodID(cls, "<init>", "()V");
-    if (constructor == NULL) {
+    jmethodID constructor = mEnv->GetMethodID(cls, "<init>", "()V");
+    if (constructor == 0) {
         ALOGE("Error in constructor ID for %s", className);
-        return NULL;
+        return JNIObject<jobject>(*this, NULL);
     }
-    jobject obj = env->NewObject(cls, constructor);
+
+    JNIObject<jobject> obj(*this, mEnv->NewObject(cls, constructor));
     if (obj == NULL) {
         ALOGE("Could not create new object of %s", className);
-        return NULL;
+        return JNIObject<jobject>(*this, NULL);
     }
 
-    env->DeleteLocalRef(cls);
     return obj;
 }
 
-jobjectArray createObjectArray(JNIEnv *env, const char *className, int num)
+JNIObject<jobjectArray> JNIHelper::createObjectArray(const char *className, int num)
 {
-    jclass cls = env->FindClass(className);
+    JNIObject<jclass> cls(*this, mEnv->FindClass(className));
     if (cls == NULL) {
         ALOGE("Error in finding class %s", className);
-        return NULL;
+        return JNIObject<jobjectArray>(*this, NULL);
     }
 
-    jobjectArray array = env->NewObjectArray(num, cls, NULL);
-    if (array == NULL) {
+    JNIObject<jobject> array(*this, mEnv->NewObjectArray(num, cls.get(), NULL));
+    if (array.get() == NULL) {
         ALOGE("Error in creating array of class %s", className);
-        return NULL;
+        return JNIObject<jobjectArray>(*this, NULL);
     }
 
-    env->DeleteLocalRef(cls);
-    return array;
+    return JNIObject<jobjectArray>(*this, (jobjectArray)array.detach());
+}
+
+JNIObject<jobject> JNIHelper::getObjectArrayElement(jobjectArray array, int index)
+{
+    return JNIObject<jobject>(*this, mEnv->GetObjectArrayElement(array, index));
+}
+
+JNIObject<jobject> JNIHelper::getObjectArrayElement(jobject array, int index)
+{
+    return getObjectArrayElement((jobjectArray)array, index);
+}
+
+int JNIHelper::getArrayLength(jarray array) {
+    return mEnv->GetArrayLength(array);
+}
+
+JNIObject<jobjectArray> JNIHelper::newObjectArray(int num, const char *className, jobject val) {
+    JNIObject<jclass> cls(*this, mEnv->FindClass(className));
+    if (cls == NULL) {
+        ALOGE("Error in finding class %s", className);
+        return JNIObject<jobjectArray>(*this, NULL);
+    }
+
+    return JNIObject<jobjectArray>(*this, mEnv->NewObjectArray(num, cls, val));
+}
+
+JNIObject<jbyteArray> JNIHelper::newByteArray(int num) {
+    return JNIObject<jbyteArray>(*this, mEnv->NewByteArray(num));
+}
+
+JNIObject<jintArray> JNIHelper::newIntArray(int num) {
+    return JNIObject<jintArray>(*this, mEnv->NewIntArray(num));
+}
+
+JNIObject<jlongArray> JNIHelper::newLongArray(int num) {
+    return JNIObject<jlongArray>(*this, mEnv->NewLongArray(num));
+}
+
+JNIObject<jstring> JNIHelper::newStringUTF(const char *utf) {
+    return JNIObject<jstring>(*this, mEnv->NewStringUTF(utf));
+}
+
+void JNIHelper::setObjectArrayElement(jobjectArray array, int index, jobject obj) {
+    mEnv->SetObjectArrayElement(array, index, obj);
+}
+
+void JNIHelper::setByteArrayRegion(jbyteArray array, int from, int to, jbyte *bytes) {
+    mEnv->SetByteArrayRegion(array, from, to, bytes);
+}
+
+void JNIHelper::setIntArrayRegion(jintArray array, int from, int to, jint *ints) {
+    mEnv->SetIntArrayRegion(array, from, to, ints);
+}
+
+void JNIHelper::setLongArrayRegion(jlongArray array, int from, int to, jlong *longs) {
+    mEnv->SetLongArrayRegion(array, from, to, longs);
 }
 
 }; // namespace android