weave/src/wrappers/jni/jni-utils/JNIUtils.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 2013-2017 Nest Labs, Inc.
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 /**
  *    @file
  *      Utility functions for building Java native libraries.
  *
  */

 #include <jni.h>

 #include <Weave/Core/WeaveCore.h>
 #include <Weave/Support/CodeUtils.h>

 #include "JNIUtils.h"


 namespace nl {
 namespace Weave {

 JavaVM *JNIUtils::sJVM;
 jclass JNIUtils::sJavaObjectClass;
 jclass JNIUtils::sWeaveErrorClass;

 WEAVE_ERROR JNIUtils::Init(JavaVM *jvm, JNIEnv *env, const char *weaveErrorClassName)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     if (sJavaObjectClass == NULL)
     {
         err = GetGlobalClassRef(env, "java/lang/Object", sJavaObjectClass);
         SuccessOrExit(err);
     }

     if (sWeaveErrorClass == NULL)
     {
         err = GetGlobalClassRef(env, weaveErrorClassName, sWeaveErrorClass);
         SuccessOrExit(err);
     }

     sJVM = jvm;

 exit:
     return err;
 }

 void JNIUtils::Shutdown(JNIEnv *env)
 {
     if (sJavaObjectClass != NULL)
     {
         env->DeleteGlobalRef(sJavaObjectClass);
         sJavaObjectClass = NULL;
     }
     if (sWeaveErrorClass != NULL)
     {
         env->DeleteGlobalRef(sWeaveErrorClass);
         sWeaveErrorClass = NULL;
     }
 }

 static WEAVE_ERROR MakeClassName(const char *basePackageName, const char *relativeClassName, char *& classNameBuf)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     size_t totalLen = strlen(basePackageName) + strlen(relativeClassName) + 2;

     classNameBuf = (char *)realloc(classNameBuf, totalLen);
     VerifyOrExit(classNameBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     snprintf(classNameBuf, totalLen, "%s/%s", basePackageName, relativeClassName);

 exit:
     return err;
 }

 WEAVE_ERROR JNIUtils::RegisterLibraryMethods(JNIEnv *env, const char *basePackageName, const JNILibraryMethod *libMethods, size_t numLibMethods)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jint regRes;
     char *className = NULL;

     for (size_t i = 0; i < numLibMethods; i++)
     {
         const JNILibraryMethod& libMethod = libMethods[i];

         err = MakeClassName(basePackageName, libMethod.ClassName, className);
         SuccessOrExit(err);

         jclass cls = env->FindClass(className);
         VerifyOrExit(cls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

         JNINativeMethod nativeMethod;
         nativeMethod.name = (char *)libMethod.MethodName;
         nativeMethod.signature = (char *)libMethod.MethodSignature;
         nativeMethod.fnPtr = libMethod.MethodFunction;

         regRes = env->RegisterNatives(cls, &nativeMethod, 1);
         VerifyOrExit(regRes == 0, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

 exit:
     if (className != NULL)
     {
         free(className);
     }
     return err;
 }

 void JNIUtils::ThrowError(JNIEnv *env, WEAVE_ERROR errToThrow)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jthrowable ex;

     // Do nothing for WEAVE_NO_ERROR, or if the error indicates that a Java exception has already
     // been thrown.
     VerifyOrExit(errToThrow != WEAVE_NO_ERROR && errToThrow != WEAVE_JNI_ERROR_EXCEPTION_THROWN, );

     // Convert the error to a throwable.
     err = N2J_Error(env, errToThrow, ex);
     SuccessOrExit(err);

     // Throw it.
     env->Throw(ex);

 exit:
     return;
 }

 WEAVE_ERROR J2N_ByteArray(JNIEnv *env, jbyteArray inArray, uint8_t *& outArray, uint32_t& outArrayLen)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     outArrayLen = env->GetArrayLength(inArray);

     outArray = (uint8_t *)malloc(outArrayLen);
     VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY);

     if (outArrayLen != 0)
     {
         env->ExceptionClear();
         env->GetByteArrayRegion(inArray, 0, outArrayLen, (jbyte *)outArray);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         if (outArray != NULL)
         {
             free(outArray);
             outArray = NULL;
         }
     }

     return err;
 }

 // A version of J2N_ByteArray that copies into an existing buffer, rather than allocating memory.
 WEAVE_ERROR J2N_ByteArrayInPlace(JNIEnv *env, jbyteArray inArray, uint8_t * outArray, uint32_t maxArrayLen)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     uint32_t arrayLen;

     VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     arrayLen = env->GetArrayLength(inArray);
     VerifyOrExit(arrayLen <= maxArrayLen, err = WEAVE_ERROR_INVALID_ARGUMENT);

     if (arrayLen != 0)
     {
         env->ExceptionClear();
         env->GetByteArrayRegion(inArray, 0, arrayLen, (jbyte *)outArray);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

 exit:
     return err;
 }

 WEAVE_ERROR JNIUtils::N2J_ByteArray(JNIEnv *env, const uint8_t *inArray, uint32_t inArrayLen, jbyteArray& outArray)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     outArray = env->NewByteArray((int)inArrayLen);
     VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY);

     env->ExceptionClear();
     env->SetByteArrayRegion(outArray, 0, inArrayLen, (jbyte *)inArray);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

 exit:
     return err;
 }

 WEAVE_ERROR J2N_EnumVal(JNIEnv *env, jobject enumObj, int& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass enumCls = NULL;
     jfieldID fieldId;

     enumCls = env->GetObjectClass(enumObj);
     VerifyOrExit(enumCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(enumCls, "val", "I");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     outVal = env->GetIntField(enumObj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

 exit:
     env->DeleteLocalRef(enumCls);
     return err;
 }

 WEAVE_ERROR J2N_EnumFieldVal(JNIEnv *env, jobject obj, const char *fieldName, const char *fieldType, int& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL, enumCls = NULL;
     jfieldID fieldId;
     jobject enumObj = NULL;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, fieldType);
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     enumObj = env->GetObjectField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

     if (enumObj != NULL)
     {
         enumCls = env->GetObjectClass(enumObj);
         VerifyOrExit(enumCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

         fieldId = env->GetFieldID(enumCls, "val", "I");
         VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

         env->ExceptionClear();
         outVal = env->GetIntField(enumObj, fieldId);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }
     else
         outVal = -1;

 exit:
     env->DeleteLocalRef(enumCls);
     env->DeleteLocalRef(enumObj);
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR J2N_ShortFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jshort& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL;
     jfieldID fieldId;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, "S");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     outVal = env->GetShortField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

 exit:
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR J2N_IntFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jint& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL;
     jfieldID fieldId;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, "I");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     outVal = env->GetIntField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

 exit:
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR J2N_LongFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jlong& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL;
     jfieldID fieldId;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, "J");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     outVal = env->GetLongField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

 exit:
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR J2N_StringFieldVal(JNIEnv *env, jobject obj, const char *fieldName, char *& outVal)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL;
     jfieldID fieldId;
     jstring strObj = NULL;
     const char *nativeStr;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, "Ljava/lang/String;");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     strObj = (jstring)env->GetObjectField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

     if (strObj != NULL)
     {
         nativeStr = env->GetStringUTFChars(strObj, 0);
         outVal = strdup(nativeStr);
         env->ReleaseStringUTFChars(strObj, nativeStr);
     }
     else
         outVal = NULL;

 exit:
     env->DeleteLocalRef(strObj);
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR J2N_ByteArrayFieldVal(JNIEnv *env, jobject obj, const char *fieldName, uint8_t *& outArray, uint32_t& outArrayLen)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass objCls = NULL;
     jfieldID fieldId;
     jbyteArray byteArrayObj = NULL;

     objCls = env->GetObjectClass(obj);
     VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     fieldId = env->GetFieldID(objCls, fieldName, "[B");
     VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

     env->ExceptionClear();
     byteArrayObj = (jbyteArray)env->GetObjectField(obj, fieldId);
     VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

     if (byteArrayObj != NULL)
     {
         err = J2N_ByteArray(env, byteArrayObj, outArray, outArrayLen);
         SuccessOrExit(err);
     }
     else
     {
         outArray = NULL;
         outArrayLen = 0;
     }

 exit:
     env->DeleteLocalRef(byteArrayObj);
     env->DeleteLocalRef(objCls);
     return err;
 }

 WEAVE_ERROR JNIUtils::N2J_Error(JNIEnv *env, WEAVE_ERROR inErr, jthrowable& outEx)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jmethodID constructor;
     const char *errStr = NULL;
     jstring errStrObj = NULL;
     jclass exCls = NULL;

     if (inErr == WEAVE_ERROR_INVALID_ARGUMENT)
     {
         exCls = env->FindClass("java/lang/IllegalArgumentException");
         VerifyOrExit(exCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

         constructor = env->GetMethodID(exCls, "<init>", "()V");
         VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

         env->ExceptionClear();
         outEx = (jthrowable)env->NewObject(exCls, constructor);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

     else if (inErr == WEAVE_ERROR_INCORRECT_STATE)
     {
         exCls = env->FindClass("java/lang/IllegalStateException");
         VerifyOrExit(exCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

         constructor = env->GetMethodID(exCls, "<init>", "()V");
         VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

         env->ExceptionClear();
         outEx = (jthrowable)env->NewObject(exCls, constructor);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

     else {
         constructor = env->GetMethodID(sWeaveErrorClass, "<init>", "(ILjava/lang/String;)V");
         VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

         switch (inErr)
         {
         case WEAVE_JNI_ERROR_TYPE_NOT_FOUND          : errStr = "JNI type not found"; break;
         case WEAVE_JNI_ERROR_METHOD_NOT_FOUND        : errStr = "JNI method not found"; break;
         case WEAVE_JNI_ERROR_FIELD_NOT_FOUND         : errStr = "JNI field not found"; break;
         default:                                     ; errStr = nl::ErrorStr(inErr); break;
         }
         errStrObj = (errStr != NULL) ? env->NewStringUTF(errStr) : NULL;

         env->ExceptionClear();
         outEx = (jthrowable)env->NewObject(sWeaveErrorClass, constructor, (jint)inErr, errStrObj);
         VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
     }

 exit:
     env->DeleteLocalRef(errStrObj);
     env->DeleteLocalRef(exCls);
     return err;
 }

 WEAVE_ERROR JNIUtils::GetGlobalClassRef(JNIEnv *env, const char *clsType, jclass& outCls)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     jclass cls = NULL;

     cls = env->FindClass(clsType);
     VerifyOrExit(cls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

     outCls = (jclass)env->NewGlobalRef((jobject)cls);
     VerifyOrExit(outCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

 exit:
     env->DeleteLocalRef(cls);
     return err;
 }


 } // namespace Weave
 } // namespave nl
	/*
	*
	* Copyright (c) 2013-2017 Nest Labs, Inc.
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @file
	* Utility functions for building Java native libraries.
	*
	*/

	#include <jni.h>

	#include <Weave/Core/WeaveCore.h>
	#include <Weave/Support/CodeUtils.h>

	#include "JNIUtils.h"


	namespace nl {
	namespace Weave {

	JavaVM *JNIUtils::sJVM;
	jclass JNIUtils::sJavaObjectClass;
	jclass JNIUtils::sWeaveErrorClass;

	WEAVE_ERROR JNIUtils::Init(JavaVM jvm, JNIEnv env, const char *weaveErrorClassName)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	if (sJavaObjectClass == NULL)
	{
	err = GetGlobalClassRef(env, "java/lang/Object", sJavaObjectClass);
	SuccessOrExit(err);
	}

	if (sWeaveErrorClass == NULL)
	{
	err = GetGlobalClassRef(env, weaveErrorClassName, sWeaveErrorClass);
	SuccessOrExit(err);
	}

	sJVM = jvm;

	exit:
	return err;
	}

	void JNIUtils::Shutdown(JNIEnv *env)
	{
	if (sJavaObjectClass != NULL)
	{
	env->DeleteGlobalRef(sJavaObjectClass);
	sJavaObjectClass = NULL;
	}
	if (sWeaveErrorClass != NULL)
	{
	env->DeleteGlobalRef(sWeaveErrorClass);
	sWeaveErrorClass = NULL;
	}
	}

	static WEAVE_ERROR MakeClassName(const char basePackageName, const char relativeClassName, char *& classNameBuf)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	size_t totalLen = strlen(basePackageName) + strlen(relativeClassName) + 2;

	classNameBuf = (char *)realloc(classNameBuf, totalLen);
	VerifyOrExit(classNameBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	snprintf(classNameBuf, totalLen, "%s/%s", basePackageName, relativeClassName);

	exit:
	return err;
	}

	WEAVE_ERROR JNIUtils::RegisterLibraryMethods(JNIEnv env, const char basePackageName, const JNILibraryMethod *libMethods, size_t numLibMethods)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jint regRes;
	char *className = NULL;

	for (size_t i = 0; i < numLibMethods; i++)
	{
	const JNILibraryMethod& libMethod = libMethods[i];

	err = MakeClassName(basePackageName, libMethod.ClassName, className);
	SuccessOrExit(err);

	jclass cls = env->FindClass(className);
	VerifyOrExit(cls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	JNINativeMethod nativeMethod;
	nativeMethod.name = (char *)libMethod.MethodName;
	nativeMethod.signature = (char *)libMethod.MethodSignature;
	nativeMethod.fnPtr = libMethod.MethodFunction;

	regRes = env->RegisterNatives(cls, &nativeMethod, 1);
	VerifyOrExit(regRes == 0, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	exit:
	if (className != NULL)
	{
	free(className);
	}
	return err;
	}

	void JNIUtils::ThrowError(JNIEnv *env, WEAVE_ERROR errToThrow)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jthrowable ex;

	// Do nothing for WEAVE_NO_ERROR, or if the error indicates that a Java exception has already
	// been thrown.
	VerifyOrExit(errToThrow != WEAVE_NO_ERROR && errToThrow != WEAVE_JNI_ERROR_EXCEPTION_THROWN, );

	// Convert the error to a throwable.
	err = N2J_Error(env, errToThrow, ex);
	SuccessOrExit(err);

	// Throw it.
	env->Throw(ex);

	exit:
	return;
	}

	WEAVE_ERROR J2N_ByteArray(JNIEnv env, jbyteArray inArray, uint8_t & outArray, uint32_t& outArrayLen)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	outArrayLen = env->GetArrayLength(inArray);

	outArray = (uint8_t *)malloc(outArrayLen);
	VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY);

	if (outArrayLen != 0)
	{
	env->ExceptionClear();
	env->GetByteArrayRegion(inArray, 0, outArrayLen, (jbyte *)outArray);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	if (outArray != NULL)
	{
	free(outArray);
	outArray = NULL;
	}
	}

	return err;
	}

	// A version of J2N_ByteArray that copies into an existing buffer, rather than allocating memory.
	WEAVE_ERROR J2N_ByteArrayInPlace(JNIEnv env, jbyteArray inArray, uint8_t outArray, uint32_t maxArrayLen)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	uint32_t arrayLen;

	VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	arrayLen = env->GetArrayLength(inArray);
	VerifyOrExit(arrayLen <= maxArrayLen, err = WEAVE_ERROR_INVALID_ARGUMENT);

	if (arrayLen != 0)
	{
	env->ExceptionClear();
	env->GetByteArrayRegion(inArray, 0, arrayLen, (jbyte *)outArray);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	exit:
	return err;
	}

	WEAVE_ERROR JNIUtils::N2J_ByteArray(JNIEnv env, const uint8_t inArray, uint32_t inArrayLen, jbyteArray& outArray)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	outArray = env->NewByteArray((int)inArrayLen);
	VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY);

	env->ExceptionClear();
	env->SetByteArrayRegion(outArray, 0, inArrayLen, (jbyte *)inArray);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	exit:
	return err;
	}

	WEAVE_ERROR J2N_EnumVal(JNIEnv *env, jobject enumObj, int& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass enumCls = NULL;
	jfieldID fieldId;

	enumCls = env->GetObjectClass(enumObj);
	VerifyOrExit(enumCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(enumCls, "val", "I");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	outVal = env->GetIntField(enumObj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	exit:
	env->DeleteLocalRef(enumCls);
	return err;
	}

	WEAVE_ERROR J2N_EnumFieldVal(JNIEnv env, jobject obj, const char fieldName, const char *fieldType, int& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL, enumCls = NULL;
	jfieldID fieldId;
	jobject enumObj = NULL;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, fieldType);
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	enumObj = env->GetObjectField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	if (enumObj != NULL)
	{
	enumCls = env->GetObjectClass(enumObj);
	VerifyOrExit(enumCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(enumCls, "val", "I");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	outVal = env->GetIntField(enumObj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}
	else
	outVal = -1;

	exit:
	env->DeleteLocalRef(enumCls);
	env->DeleteLocalRef(enumObj);
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR J2N_ShortFieldVal(JNIEnv env, jobject obj, const char fieldName, jshort& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL;
	jfieldID fieldId;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, "S");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	outVal = env->GetShortField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	exit:
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR J2N_IntFieldVal(JNIEnv env, jobject obj, const char fieldName, jint& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL;
	jfieldID fieldId;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, "I");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	outVal = env->GetIntField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	exit:
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR J2N_LongFieldVal(JNIEnv env, jobject obj, const char fieldName, jlong& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL;
	jfieldID fieldId;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, "J");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	outVal = env->GetLongField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	exit:
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR J2N_StringFieldVal(JNIEnv env, jobject obj, const char fieldName, char *& outVal)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL;
	jfieldID fieldId;
	jstring strObj = NULL;
	const char *nativeStr;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, "Ljava/lang/String;");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	strObj = (jstring)env->GetObjectField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	if (strObj != NULL)
	{
	nativeStr = env->GetStringUTFChars(strObj, 0);
	outVal = strdup(nativeStr);
	env->ReleaseStringUTFChars(strObj, nativeStr);
	}
	else
	outVal = NULL;

	exit:
	env->DeleteLocalRef(strObj);
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR J2N_ByteArrayFieldVal(JNIEnv env, jobject obj, const char fieldName, uint8_t *& outArray, uint32_t& outArrayLen)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass objCls = NULL;
	jfieldID fieldId;
	jbyteArray byteArrayObj = NULL;

	objCls = env->GetObjectClass(obj);
	VerifyOrExit(objCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	fieldId = env->GetFieldID(objCls, fieldName, "[B");
	VerifyOrExit(fieldId != NULL, err = WEAVE_JNI_ERROR_METHOD_NOT_FOUND);

	env->ExceptionClear();
	byteArrayObj = (jbyteArray)env->GetObjectField(obj, fieldId);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	if (byteArrayObj != NULL)
	{
	err = J2N_ByteArray(env, byteArrayObj, outArray, outArrayLen);
	SuccessOrExit(err);
	}
	else
	{
	outArray = NULL;
	outArrayLen = 0;
	}

	exit:
	env->DeleteLocalRef(byteArrayObj);
	env->DeleteLocalRef(objCls);
	return err;
	}

	WEAVE_ERROR JNIUtils::N2J_Error(JNIEnv *env, WEAVE_ERROR inErr, jthrowable& outEx)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jmethodID constructor;
	const char *errStr = NULL;
	jstring errStrObj = NULL;
	jclass exCls = NULL;

	if (inErr == WEAVE_ERROR_INVALID_ARGUMENT)
	{
	exCls = env->FindClass("java/lang/IllegalArgumentException");
	VerifyOrExit(exCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	constructor = env->GetMethodID(exCls, "<init>", "()V");
	VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	env->ExceptionClear();
	outEx = (jthrowable)env->NewObject(exCls, constructor);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	else if (inErr == WEAVE_ERROR_INCORRECT_STATE)
	{
	exCls = env->FindClass("java/lang/IllegalStateException");
	VerifyOrExit(exCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	constructor = env->GetMethodID(exCls, "<init>", "()V");
	VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	env->ExceptionClear();
	outEx = (jthrowable)env->NewObject(exCls, constructor);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	else {
	constructor = env->GetMethodID(sWeaveErrorClass, "<init>", "(ILjava/lang/String;)V");
	VerifyOrExit(constructor != NULL, err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);

	switch (inErr)
	{
	case WEAVE_JNI_ERROR_TYPE_NOT_FOUND : errStr = "JNI type not found"; break;
	case WEAVE_JNI_ERROR_METHOD_NOT_FOUND : errStr = "JNI method not found"; break;
	case WEAVE_JNI_ERROR_FIELD_NOT_FOUND : errStr = "JNI field not found"; break;
	default: ; errStr = nl::ErrorStr(inErr); break;
	}
	errStrObj = (errStr != NULL) ? env->NewStringUTF(errStr) : NULL;

	env->ExceptionClear();
	outEx = (jthrowable)env->NewObject(sWeaveErrorClass, constructor, (jint)inErr, errStrObj);
	VerifyOrExit(!env->ExceptionCheck(), err = WEAVE_JNI_ERROR_EXCEPTION_THROWN);
	}

	exit:
	env->DeleteLocalRef(errStrObj);
	env->DeleteLocalRef(exCls);
	return err;
	}

	WEAVE_ERROR JNIUtils::GetGlobalClassRef(JNIEnv env, const char clsType, jclass& outCls)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	jclass cls = NULL;

	cls = env->FindClass(clsType);
	VerifyOrExit(cls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	outCls = (jclass)env->NewGlobalRef((jobject)cls);
	VerifyOrExit(outCls != NULL, err = WEAVE_JNI_ERROR_TYPE_NOT_FOUND);

	exit:
	env->DeleteLocalRef(cls);
	return err;
	}


	} // namespace Weave
	} // namespave nl