public static Dictionary<string, string> RetrieveAll(JniEnvironment environment)
        {
            Dictionary<string, string> properties = new Dictionary<string,string>();

            JniLocalFrame frame = environment.CreateLocalFrame(1);
            try
            {
                JniClass systemClazz = JniClass.FindClass(environment, "java/lang/System");
                string[] keyNames = GetJavaPropertyNames(environment, systemClazz);
                JniMethod getPropMid = systemClazz.GetStaticMethodId(environment, "getProperty", "(Ljava/lang/String;)Ljava/lang/String;");

                foreach (string keyName in keyNames)
                {
                    JValue[] paramArray = new JValue[1];
                    paramArray[0].AssignStringValue(environment, keyName);
                    try
                    {
                        string val = getPropMid.CallStaticStringMethod(environment, paramArray);
                        properties.Add(keyName, val);
                    }
                    finally
                    {
                        paramArray[0].Free(environment);
                    }
                }
            }
            finally
            {
                frame.SafePop();
            }

            return properties;
        }

 public static void CheckException(JniEnvironment environment)
 {
     if (JniThrowable.ExceptionCheck(environment))
     {
         ThrowCurrentException(environment);
     }
 }

        internal static void Init(JniEnvironment environment)
        {
            if (JavaVM.IsLogTypeEnabled(JavaVMLogTypes.RedirectStdOut | JavaVMLogTypes.RedirectStdErr))
            {
                JniLocalFrame frame = environment.CreateLocalFrame(1);
                try
                {
                    JniClass peer = JavaNativeMethodRegistrar.RegisterCounterpartAndReturnPeer(environment,
                        typeof(JavaStdStreamRedirector));

                    if (JavaVM.IsLogTypeEnabled(JavaVMLogTypes.RedirectStdOut))
                    {
                        HookStream(environment, peer, JavaVMLogTypes.RedirectStdOut, "redirectStdOut");
                    }

                    if (JavaVM.IsLogTypeEnabled(JavaVMLogTypes.RedirectStdErr))
                    {
                        HookStream(environment, peer, JavaVMLogTypes.RedirectStdErr, "redirectStdErr");
                    }
                }
                finally
                {
                    frame.SafePop();
                }
            }
        }

 internal JniThreadMonitor(JniEnvironment env, JniObject objectHandle)
 {
     JniObject.VerifyInputJniObject(objectHandle);
     mEnvironment = env;
     mObjectHandle = objectHandle;
     Enter();
 }

        public static void LogBannerProperties(JniEnvironment environment)
        {
            Dictionary<string, string> properties = RetrieveAll(environment);

            JavaVM.Log("Current Java System Properties");

            string[] logPropNames = {
                "java.version",
                "java.vendor",
                "java.home",
                "java.vm.version",
                "java.vm.vendor",
                "java.vm.name",
                "java.class.version",
                "java.class.path",
                "java.library.path",
                "os.name",
                "os.arch",
                "os.version",
                "user.name",
                };

            foreach (string logPropName in logPropNames)
            {
                JavaVM.Log(logPropName + " = " + properties[logPropName]);
            }
        }

 public static string ExtractStringFromHandle(JniEnvironment environment, IntPtr handle)
 {
     VerifyEnvironment(environment);
     unsafe
     {
         int length = GetStringLengthCore(environment, handle);
         char* p = JniEnvironment.Functions.GetStringCritical(environment.Handle, handle, null);
         if (p == null)
         {
             JniThrowable.ThrowCurrentException(environment);
         }
         try
         {
             // IMPORTANT - do not change code between GetStringCritical/ReleaseStringCritical.
             // See JNI documentation.
             return new String(p, 0, length);
         }
         finally
         {
             JniEnvironment.Functions.ReleaseStringCritical(environment.Handle, handle, p);
             // EXCEPTION CHECK: Do nothing, this method safe to call while exception is pending, does
             // not raise additional exceptions.
         }
     }
 }

 public static bool ExceptionCheck(JniEnvironment environment)
 {
     byte result = JniEnvironment.Functions.ExceptionCheck(environment.Handle);
     // EXCEPTION CHECK: Do nothing, this method safe to call while exception is pending, does
     // not raise additional exceptions.
     return JBooleanConverter.From(result);
 }

 private static void HookStream(JniEnvironment environment, JniClass nativeClazz, 
     JavaVMLogTypes hook, string javaHookMethod)
 {
     JniMethod outMid = nativeClazz.GetStaticMethodId(environment, javaHookMethod, "(I)V");
     JValue[] paramArray = new JValue[1];
     paramArray[0].AssignIntValue((int)hook);
     outMid.CallStaticVoidMethod(environment, paramArray);
 }

 public static JniLongArray PackLongArray(JniEnvironment environment, long[] sourceArray)
 {
     VerifyEnvironment(environment);
     if (sourceArray == null) { return null; }
     JniLongArray arrayHandle = NewLongArray(environment, sourceArray.Length);
     if (sourceArray.Length > 0)
     {
         arrayHandle.PackPrimitiveArray<long>(environment, sourceArray);
     }
     return arrayHandle;
 }

 public static JniIntArray PackIntArray(JniEnvironment environment, int[] sourceArray)
 {
     VerifyEnvironment(environment);
     if (sourceArray == null) { return null; }
     JniIntArray arrayHandle = NewIntArray(environment, sourceArray.Length);
     if (sourceArray.Length > 0)
     {
         arrayHandle.PackPrimitiveArray<int>(environment, sourceArray);
     }
     return arrayHandle;
 }

 public static JniCharArray PackCharArray(JniEnvironment environment, char[] sourceArray)
 {
     VerifyEnvironment(environment);
     if (sourceArray == null) { return null; }
     JniCharArray arrayHandle = NewCharArray(environment, sourceArray.Length);
     if (sourceArray.Length > 0)
     {
         arrayHandle.PackPrimitiveArray<char>(environment, sourceArray);
     }
     return arrayHandle;
 }

 public static JniByteArray PackByteArray(JniEnvironment environment, byte[] sourceArray)
 {
     VerifyEnvironment(environment);
     if (sourceArray == null) { return null; }
     JniByteArray arrayHandle = NewByteArray(environment, sourceArray.Length);
     if (sourceArray.Length > 0)
     {
         arrayHandle.PackPrimitiveArray<byte>(environment, sourceArray);
     }
     return arrayHandle;
 }

 internal JniClass(JniEnvironment environment, IntPtr handle, JniObjectLifecycle lifecycle)
     : base(environment, handle, lifecycle)
 {
     // TODO - make this instance global???
     if (!mStaticsInitialized)
     {
         mStaticsInitialized = true;
         JniClass localClassClass = this.GetObjectClass(environment);
         // NOTE: no need to NewGlobalRef class handle for java.lang.Class, will not be unloaded
         mGetNameMid = localClassClass.GetMethodId(environment, "getName", "()Ljava/lang/String;");
     }
 }

 public JniObject NewObjectCore(JniEnvironment environment, JValue[] arguments, JniConcreteObjectType concreteType)
 {
     VerifyEnvironment(environment);
     // NOTE: OK if "JValue[] arguments" is null
     IntPtr result = JniEnvironment.Functions.NewObjectA(environment.Handle, this.DeclaringClass.Handle, this.Handle, arguments);
     if (IntPtr.Zero == result)
     {
         JniThrowable.ThrowCurrentException(environment); // null result means an exception occurred
     }
     // EXCEPTION CHECK: Do nothing, already checked for exception above.
     return JniObject.CreateObjectOfType(environment, result, concreteType);
 }

 public double GetDoubleField(
     JniEnvironment environment,
     JniObject jniObject)
 {
     VerifyReturnType(JniType.Double);
     VerifyEnvironment(environment);
     VerifyNotStatic();
     VerifyInputJniObject(jniObject);
     double result = JniEnvironment.Functions.GetDoubleField(environment.Handle, jniObject.Handle, this.Handle);
     JniThrowable.CheckException(environment);
     return result;
 }

 public bool GetBooleanField(
     JniEnvironment environment,
     JniObject jniObject)
 {
     VerifyReturnType(JniType.Boolean);
     VerifyEnvironment(environment);
     VerifyNotStatic();
     VerifyInputJniObject(jniObject);
     byte result = JniEnvironment.Functions.GetBooleanField(environment.Handle, jniObject.Handle, this.Handle);
     JniThrowable.CheckException(environment);
     return JBooleanConverter.From(result);
 }

 public byte[] GetByteArrayRegion(
     JniEnvironment environment,
     int start,
     int length
     )
 {
     VerifyEnvironment(environment);
     byte[] result = new byte[length];
     JniEnvironment.Functions.GetByteArrayRegion(environment.Handle, this.Handle, start, length, result);
     JniThrowable.CheckException(environment);
     return result;
 }

 public JniEnvironment FromHandle(IntPtr environmentHandle)
 {
     lock (mMapEnvironments)
     {
         JniEnvironment env = FromHandleCore(environmentHandle);
         if (env == null)
         {
             env = new JniEnvironment(false, environmentHandle, CurrentUnmanagedThreadId);
             AddEnvironment(env);
         }
         return env;
     }
 }

 public static bool IsAssignableFrom(
     JniEnvironment environment,
     JniClass subclass,
     JniClass superclass
     )
 {
     VerifyEnvironment(environment);
     VerifyInputJniObject(subclass);
     VerifyInputJniObject(superclass);
     byte result = JniEnvironment.Functions.IsAssignableFrom(environment.Handle, subclass.Handle, superclass.Handle);
     JniThrowable.CheckException(environment);
     return JBooleanConverter.From(result);
 }

 public static JniBooleanArray NewBooleanArray(
     JniEnvironment environment,
     int length)
 {
     VerifyEnvironment(environment);
     IntPtr result = JniEnvironment.Functions.NewBooleanArray(environment.Handle, length);
     if (IntPtr.Zero == result)
     {
         JniThrowable.ThrowCurrentException(environment); // null result means an exception occurred
     }
     // EXCEPTION CHECK: Do nothing, already checked for exception above.
     return new JniBooleanArray(environment, result, JniObjectLifecycle.Local);
 }