Merge pull request #124 from mkitti/javaref

Create JavaRef, JavaLocalRef, and JavaGlobalRef to hold references and manage memory

Author: mkitti

Project.toml

@@ -6,10 +6,18 @@ version = "0.7.4"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 WinReg = "1b915085-20d7-51cf-bf83-8f477d6f5128"
 
 [compat]
-julia = "1"
 DataStructures = "0.17"
 WinReg = "0.3.1"
+julia = "1"
+
+[extras]
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Taro = "61d0e4fa-4e73-5030-88a9-ae4c27b203dd"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+
+[targets]
+test = ["Taro", "Pkg", "Test","DataFrames"]

src/JNI.jl

@@ -26,7 +26,7 @@ using Dates
 end
 
 
-import Base: convert, unsafe_convert, unsafe_string
+import Base: convert, unsafe_convert, unsafe_string, Ptr
 
 JULIA_COPY_STACKS = false
 

src/JavaCall.jl

@@ -1,28 +1,32 @@
+convert(::Type{Ptr{Nothing}}, obj::JavaObject{T}) where T = Ptr(obj)
+
 convert(::Type{JString}, str::AbstractString) = JString(str)
 convert(::Type{JObject}, str::AbstractString) = convert(JObject, JString(str))
 
 #Cast java object from S to T . Needed for polymorphic calls
 function convert(::Type{JavaObject{T}}, obj::JavaObject{S}) where {T,S}
     if isConvertible(T, S)   #Safe static cast
-        ptr = JNI.NewLocalRef(obj.ptr)
+        ptr = JNI.NewLocalRef(Ptr(obj))
         ptr === C_NULL && geterror()
         return JavaObject{T}(ptr)
     end
     isnull(obj) && throw(ArgumentError("Cannot convert NULL"))
-    realClass = JNI.GetObjectClass(obj.ptr)
+    realClass = JNI.GetObjectClass(Ptr(obj))
     if isConvertible(T, realClass)  #dynamic cast
-        ptr = JNI.NewLocalRef(obj.ptr)
+        ptr = JNI.NewLocalRef(Ptr(obj))
         ptr === C_NULL && geterror()
         return JavaObject{T}(ptr)
     end
     throw(JavaCallError("Cannot cast java object from $S to $T"))
 end
 
 #Is java type convertible from S to T.
-isConvertible(T, S) = JNI.IsAssignableFrom(metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE
-isConvertible(T, S::Ptr{Nothing} ) = JNI.IsAssignableFrom(S, metaclass(T).ptr) == JNI_TRUE
+isConvertible(T, S) = JNI.IsAssignableFrom(Ptr(metaclass(S)), Ptr(metaclass(T))) == JNI_TRUE
+isConvertible(T, S::Ptr{Nothing} ) = JNI.IsAssignableFrom(S, Ptr(metaclass(T))) == JNI_TRUE
 
-unsafe_convert(::Type{Ptr{Nothing}}, cls::JavaMetaClass) = cls.ptr
+unsafe_convert(::Type{Ptr{Nothing}}, cls::JavaMetaClass) = Ptr(cls)
+unsafe_convert(::Type{Ptr{Nothing}}, obj::JavaObject) = Ptr(obj)
+unsafe_convert(::Type{Ptr{Nothing}}, ref::JavaRef) = Ptr(ref)
 
 # Get the JNI/C type for a particular Java type
 function real_jtype(rettype)
@@ -88,10 +92,10 @@ function convert_arg(argtype::Type{Array{T,1}}, arg) where T<:JavaObject
     carg = convert(argtype, arg)
     sz = length(carg)
     init = carg[1]
-    arrayptr = JNI.NewObjectArray(sz, metaclass(T).ptr, init.ptr)
+    arrayptr = JNI.NewObjectArray(sz, Ptr(metaclass(T)), Ptr(init))
     arrayptr === C_NULL && geterror()
     for i=2:sz
-        JNI.SetObjectArrayElement(arrayptr, i-1, carg[i].ptr)
+        JNI.SetObjectArrayElement(arrayptr, i-1, Ptr(carg[i]))
     end
     return carg, JavaObject{argtype}(arrayptr)
 end
@@ -258,10 +262,10 @@ end
 function unsafe_string(jstr::JString)  #jstr must be a jstring obtained via a JNI call
     if isnull(jstr); return ""; end #Return empty string to keep type stability. But this is questionable
     pIsCopy = Array{jboolean}(undef, 1)
-    #buf::Ptr{UInt8} = JNI.GetStringUTFChars(jstr.ptr, pIsCopy)
-    buf = JNI.GetStringUTFChars(jstr.ptr, pIsCopy)
+    #buf::Ptr{UInt8} = JNI.GetStringUTFChars(Ptr(jstr), pIsCopy)
+    buf = JNI.GetStringUTFChars(Ptr(jstr), pIsCopy)
     s = unsafe_string(buf)
-    JNI.ReleaseStringUTFChars(jstr.ptr, buf)
+    JNI.ReleaseStringUTFChars(Ptr(jstr), buf)
     return s
 end
 
@@ -275,11 +279,11 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBoole
                   (:jdouble,  :(JNI.GetDoubleArrayElements),  :(JNI.ReleaseDoubleArrayElements)) ]
     m = quote
         function convert(::Type{Array{$(x),1}}, obj::JObject)
-            sz = JNI.GetArrayLength(obj.ptr)
-            arr = $y(obj.ptr, Ptr{jboolean}(C_NULL))
+            sz = JNI.GetArrayLength(Ptr(obj))
+            arr = $y(Ptr(obj), Ptr{jboolean}(C_NULL))
             jl_arr::Array = unsafe_wrap(Array, arr, Int(sz))
             jl_arr = deepcopy(jl_arr)
-            $z(obj.ptr, arr, Int32(0))
+            $z(Ptr(obj), arr, Int32(0))
             return jl_arr
         end
     end
@@ -288,10 +292,10 @@ end
 
 
 function convert(::Type{Array{T, 1}}, obj::JObject) where T
-    sz = JNI.GetArrayLength(obj.ptr)
+    sz = JNI.GetArrayLength(Ptr(obj))
     ret = Array{T}(undef, sz)
     for i=1:sz
-        ptr = JNI.GetObjectArrayElement(obj.ptr, i-1)
+        ptr = JNI.GetObjectArrayElement(Ptr(obj), i-1)
         ret[i] = convert(T, JObject(ptr))
     end
     return ret

src/convert.jl

@@ -1,17 +1,99 @@
-struct JavaMetaClass{T}
+"""
+    JavaRef is abstract parent for JavaLocalRef, JavaGlobalRef, and JavaNullRef in the JavaCall Module
+
+    It is distinct from its parent type, JavaCall.JNI.AbstractJavaRef, since its use is defined in 
+    JavaCall itself rather than the JNI submodule.
+"""
+abstract type JavaRef <: JNI.AbstractJavaRef end
+
+"""
+    JavaLocalRef is a JavaRef that is meant to be used with local variables in a function call.
+    After the function call these references may be freed and garbage collected. See note about
+    JNI memory management below.
+
+    This is the default reference type returned from the JNI.
+
+    Use this with JNI.PushLocalFrame / JNI.PopLocalFrame for memory management.
+    Also see JNI.EnsureLocalCapacity.
+
+    The internal pointer should be deleted using JNI.DeleteLocalRef
+"""
+struct JavaLocalRef <: JavaRef
     ptr::Ptr{Nothing}
 end
 
-#The metaclass, sort of equivalent to a the
-JavaMetaClass(T, ptr) = JavaMetaClass{T}(ptr)
+"""
+    JavaGlobalRef is a JavaRef that is meant to be used with global variables that live beyond 
+    a single function call.
+"""
+struct JavaGlobalRef <: JavaRef
+    ptr::Ptr{Nothing}
+end
+
+"""
+    JavaNullRef is a JavaRef that serves as a placeholder to mark where references have already been deleted.
 
-mutable struct JavaObject{T}
+    See J_NULL
+"""
+struct JavaNullRef <: JavaRef
     ptr::Ptr{Nothing}
+    JavaNullRef() = new(C_NULL)
+end
+
+""" Constant JavaNullRef """
+const J_NULL = JavaNullRef()
+
+Ptr(ref::JavaRef) = ref.ptr
+Ptr{Nothing}(ref::JavaRef) = ref.ptr
+
+JavaLocalRef(ref::JavaRef) = JavaLocalRef(JNI.NewLocalRef(Ptr(ref)))
+JavaGlobalRef(ref::JavaRef) = JavaGlobalRef(JNI.NewGlobalRef(Ptr(ref)))
+
+# _deleteref does local/global reference deletion without null or state checking
+_deleteref(ref::JavaLocalRef ) = JNI.DeleteLocalRef( Ptr(ref))
+_deleteref(ref::JavaGlobalRef) = JNI.DeleteGlobalRef(Ptr(ref))
+
+"""
+    deleteref deletes a JavaRef using either JNI.DeleteLocalRef or JNI.DeleteGlobalRef
+"""
+function deleteref(x::JavaRef)
+    if x.ptr == C_NULL; return; end
+    if !JNI.is_env_loaded(); return; end;
+    _deleteref(x)
+    return
+end
+
+"""
+    JavaMetaClass represents meta information about a Java class
+
+    These are usually cached in _jmc_cache and are meant to live
+    as long as the cache is valid.
+"""
+struct JavaMetaClass{T} <: JNI.AbstractJavaRef
+    ref::JavaRef
+end
+
+#The metaclass, sort of equivalent to a the
+JavaMetaClass(T, ref::JavaRef) = JavaMetaClass{T}(ref)
+JavaMetaClass(T, ptr::Ptr{Nothing}) = JavaMetaClass{T}(JavaGlobalRef(ptr))
+
+ref(mc::JavaMetaClass{T}) where T = mc.ref
+Ptr(mc::JavaMetaClass{T}) where T = Ptr(mc.ref)
+Ptr{Nothing}(mc::JavaMetaClass{T}) where T = Ptr(mc.ref)
+
+"""
+    JavaObject{T} is the main JavaCall type representing either an instance
+    or a static class
+
+    T is usually a symbol referring a Java class name
+"""
+mutable struct JavaObject{T} <: JNI.AbstractJavaRef
+    ref::JavaRef
 
     #This below is ugly. Once we stop supporting 0.5, this can be replaced by
     # function JavaObject{T}(ptr) where T
-    function JavaObject{T}(ptr) where T
-        j = new{T}(ptr)
+    function JavaObject{T}(ref) where T
+        j = new{T}(ref)
         finalizer(deleteref, j)
         return j
     end
@@ -20,17 +102,28 @@ mutable struct JavaObject{T}
     JavaObject{T}(argtypes::Tuple, args...) where {T} = jnew(T, argtypes, args...)
 end
 
+# JavaObject Construction
 JavaObject(T, ptr) = JavaObject{T}(ptr)
 JavaObject{T}() where {T} = JavaObject{T}((),)
+JavaObject{T}(ptr::Ptr{Nothing}) where {T} = JavaObject{T}(JavaLocalRef(ptr))
 
-function deleteref(x::JavaObject)
-    if x.ptr == C_NULL; return; end
-    if !JNI.is_env_loaded(); return; end;
-    JNI.DeleteLocalRef(x.ptr)
-    x.ptr=C_NULL #Safety in case this function is called direcly, rather than at finalize
-    return
-end
+# JavaObject Reference Management
+ref(x::JavaObject{T}) where T = x.ref
+copyref(x::JavaObject{T}) where T = JavaObject{T}(JavaLocalRef(x.ref))
+deleteref(x::JavaObject{T}) where T = ( deleteref(x.ref); x.ref = J_NULL )
+
+# Obtain the underlying pointer for a JavaObject
+Ptr(x::JavaObject{T}) where T = Ptr(x.ref)
+Ptr{Nothing}(x::JavaObject{T}) where T = Ptr(x.ref)
 
+"""
+   jglobal(x::JavaObject) creates a new JavaGlobalRef and deletes the prior JavaRef
+"""
+function jglobal(x::JavaObject)
+    gref = JavaGlobalRef(JNI.NewGlobalRef(Ptr(x)))
+    deleteref(x.ref)
+    x.ref = gref
+end
 
 """
 ```
@@ -44,7 +137,7 @@ Checks if the passed JavaObject is null or not
 ### Returns
 true if the passed object is null else false
 """
-isnull(obj::JavaObject) = obj.ptr == C_NULL
+isnull(obj::JavaObject) = Ptr(obj) == C_NULL
 isnull(obj::Ptr{Nothing}) = obj == C_NULL
 
 """
@@ -59,7 +152,7 @@ Checks if the passed JavaMetaClass is null or not
 ### Returns
 true if the passed object is null else false
 """
-isnull(obj::JavaMetaClass) = obj.ptr == C_NULL
+isnull(obj::JavaMetaClass) = Ptr(obj) == C_NULL
 
 const JClass = JavaObject{Symbol("java.lang.Class")}
 const JObject = JavaObject{Symbol("java.lang.Object")}
@@ -82,7 +175,7 @@ jvalue(v::Integer)::JNI.jvalue = JNI.jvalue(v)
 jvalue(v::Float32) = jvalue(reinterpret(Int32, v))
 jvalue(v::Float64) = jvalue(reinterpret(Int64, v))
 jvalue(v::Ptr) = jvalue(Int(v))
-jvalue(v::JavaObject) = jvalue(v.ptr)
+jvalue(v::JavaObject) = jvalue(Ptr(v))
 
 
 function _jimport(juliaclass)
@@ -108,7 +201,7 @@ end
 function jnew(T::Symbol, argtypes::Tuple, args...)
     assertroottask_or_goodenv()
     sig = method_signature(Nothing, argtypes...)
-    jmethodId = JNI.GetMethodID(metaclass(T).ptr, String("<init>"), sig)
+    jmethodId = JNI.GetMethodID(Ptr(metaclass(T)), String("<init>"), sig)
     if jmethodId == C_NULL
         throw(JavaCallError("No constructor for $T with signature $sig"))
     end
@@ -120,7 +213,7 @@ function jcall(typ::Type{JavaObject{T}}, method::AbstractString, rettype::Type,
                args... ) where T
     assertroottask_or_goodenv()
     sig = method_signature(rettype, argtypes...)
-    jmethodId = JNI.GetStaticMethodID(metaclass(T).ptr, String(method), sig)
+    jmethodId = JNI.GetStaticMethodID(Ptr(metaclass(T)), String(method), sig)
     jmethodId==C_NULL && geterror(true)
     _jcall(metaclass(T), jmethodId, C_NULL, rettype, argtypes, args...)
 end
@@ -129,21 +222,21 @@ end
 function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes::Tuple, args... )
     assertroottask_or_goodenv()
     sig = method_signature(rettype, argtypes...)
-    jmethodId = JNI.GetMethodID(metaclass(obj).ptr, String(method), sig)
+    jmethodId = JNI.GetMethodID(Ptr(metaclass(obj)), String(method), sig)
     jmethodId==C_NULL && geterror(true)
     _jcall(obj, jmethodId, C_NULL, rettype,  argtypes, args...)
 end
 
 function jfield(typ::Type{JavaObject{T}}, field::AbstractString, fieldType::Type) where T
     assertroottask_or_goodenv()
-    jfieldID  = JNI.GetStaticFieldID(metaclass(T).ptr, String(field), signature(fieldType))
+    jfieldID  = JNI.GetStaticFieldID(Ptr(metaclass(T)), String(field), signature(fieldType))
     jfieldID==C_NULL && geterror(true)
     _jfield(metaclass(T), jfieldID, fieldType)
 end
 
 function jfield(obj::JavaObject, field::AbstractString, fieldType::Type)
     assertroottask_or_goodenv()
-    jfieldID  = JNI.GetFieldID(metaclass(obj).ptr, String(field), signature(fieldType))
+    jfieldID  = JNI.GetFieldID(Ptr(metaclass(obj)), String(field), signature(fieldType))
     jfieldID==C_NULL && geterror(true)
     _jfield(obj, jfieldID, fieldType)
 end
@@ -160,7 +253,7 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanField), :(JNI.GetStaticBooleanFiel
     m = quote
         function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type{$(x)})
             callmethod = ifelse( typeof(obj)<:JavaObject, $y , $z )
-            result = callmethod(obj.ptr, jfieldID)
+            result = callmethod(Ptr(obj), jfieldID)
             result==C_NULL && geterror()
             return convert_result(fieldType, result)
         end
@@ -170,7 +263,7 @@ end
 
 function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type)
     callmethod = ifelse( typeof(obj)<:JavaObject, JNI.GetObjectField , JNI.GetStaticObjectField )
-    result = callmethod(obj.ptr, jfieldID)
+    result = callmethod(Ptr(obj), jfieldID)
     result==C_NULL && geterror()
     return convert_result(fieldType, result)
 end
@@ -197,7 +290,7 @@ for (x, y, z) in [(:jboolean, :(JNI.CallBooleanMethodA), :(JNI.CallStaticBoolean
             isnull(obj) && throw(JavaCallError("Attempt to call method on Java NULL"))
             savedArgs, convertedArgs = convert_args(argtypes, args...)
             GC.@preserve savedArgs begin
-                result = callmethod(obj.ptr, jmethodId, Array{JNI.jvalue}(jvalue.(convertedArgs)))
+                result = callmethod(Ptr(obj), jmethodId, Array{JNI.jvalue}(jvalue.(convertedArgs)))
             end
             deleteref.(filter(x->isa(x,JavaObject),convertedArgs))
             result==C_NULL && geterror()
@@ -224,7 +317,7 @@ function _jcall(obj, jmethodId::Ptr{Nothing}, callmethod::Union{Function,Ptr{Not
     isnull(obj) && error("Attempt to call method on Java NULL")
     savedArgs, convertedArgs = convert_args(argtypes, args...)
     GC.@preserve savedArgs begin
-        result = callmethod(obj.ptr, jmethodId, Array{JNI.jvalue}(jvalue.(convertedArgs)))
+        result = callmethod(Ptr(obj), jmethodId, Array{JNI.jvalue}(jvalue.(convertedArgs)))
     end
     deleteref.(filter(x->isa(x,JavaObject),convertedArgs))
     result==C_NULL && geterror()

src/core.jl

@@ -15,7 +15,7 @@ struct JNINativeInterface #struct JNINativeInterface_ {
     FromReflectedField::Ptr{Nothing} #jfieldID ( *FromReflectedField)(JNIEnv *env, jobject field);
     ToReflectedMethod::Ptr{Nothing} #jobject ( *ToReflectedMethod) (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
 
-    GetSuperClass::Ptr{Nothing}  #jclass ( *GetSuperclass) (JNIEnv *env, jclass sub);
+    GetSuperclass::Ptr{Nothing}  #jclass ( *GetSuperclass) (JNIEnv *env, jclass sub);
     IsAssignableFrom::Ptr{Nothing} #jboolean ( *IsAssignableFrom) (JNIEnv *env, jclass sub, jclass sup);
 
     ToReflectedField::Ptr{Nothing} #jobject ( *ToReflectedField)(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);

src/jnienv.jl

@@ -41,6 +41,10 @@ function decl_arg_type(t, s)
     end
   elseif t == "jsize" #|| t == "jint" || t == "jlong" || t == "jshort" || t == "jbyte"
     return Integer
+  elseif t == "jobject"
+    return "jobject_arg"
+  elseif t == "jobjectArray"
+    return "jobjectArray_arg"
   end
 
   if t == "void"