Reflect class (#534)

jnius/jnius_conversion.pxi

@@ -138,6 +138,7 @@ cdef convert_jobject_to_python(JNIEnv *j_env, definition, jobject j_object):
     r = definition[1:-1]
     cdef JavaObject ret_jobject
     cdef JavaClass ret_jc
+    cdef JavaClass c    
     cdef jclass retclass
     cdef jmethodID retmeth
 
@@ -200,18 +201,31 @@ cdef convert_jobject_to_python(JNIEnv *j_env, definition, jobject j_object):
         retmeth = j_env[0].GetMethodID(j_env, retclass, 'charValue', '()C')
         return ord(j_env[0].CallCharMethod(j_env, j_object, retmeth))
 
-    if r not in jclass_register:
+    from .reflect import Object
+    if (r,(_DEFAULT_INCLUDE_PROTECTED, _DEFAULT_INCLUDE_PRIVATE)) not in jclass_register:
         if r.startswith('$Proxy'):
             # only for $Proxy on android, don't use autoclass. The dalvik vm is
             # not able to give us introspection on that one (FindClass return
-            # NULL).
-            from .reflect import Object
+            # NULL).            
             ret_jc = Object(noinstance=True)
         else:
-            from .reflect import autoclass
-            ret_jc = autoclass(r.replace('/', '.'))(noinstance=True)
+            from .reflect import reflect_class, Class
+            # find_javaclass can raise an exception, but here that just means
+            # that we need to seek the Class instance from the instance, rather than JNI
+            c = find_javaclass(r, raise_error=False)
+            if c is None:
+                # The class may have come from another ClassLoader
+                # we need to get the Class from the instance itself
+
+                #TODO: can we cache the following method id, or do we it already somewhere?
+                obj_class = j_env[0].FindClass(j_env, "java/lang/Object");
+                get_class_method_id = j_env[0].GetMethodID(j_env, obj_class, "getClass", "()Ljava/lang/Class;")
+                retclass = <jclass*> j_env[0].CallObjectMethod(j_env, j_object, get_class_method_id)
+                c = Class(noinstance=True)
+                c.instanciate_from(create_local_ref(j_env, retclass))
+            ret_jc = reflect_class(c, include_protected=_DEFAULT_INCLUDE_PROTECTED, include_private=_DEFAULT_INCLUDE_PRIVATE)(noinstance=True)
     else:
-        ret_jc = jclass_register[r](noinstance=True)
+        ret_jc = jclass_register[(r,(_DEFAULT_INCLUDE_PROTECTED, _DEFAULT_INCLUDE_PRIVATE))](noinstance=True)
     ret_jc.instanciate_from(create_local_ref(j_env, j_object))
     return ret_jc
 

jnius/jnius_export_class.pxi

@@ -111,11 +111,13 @@ class MetaJavaBase(type):
 cdef dict jclass_register = {}
 
 
-# NOTE: The classparams default value in MetaJavaClass.__new__ and
-# MetaJavaClass.get_javaclass need to be consistent with the include_protected
-# and include_private default values in reflect.autoclass.
+# these default params are parameterized so that MetaJavaClass.__new__, 
+# MetaJavaClass.get_javaclass, and reflect.autoclass can be consistent.
+_DEFAULT_INCLUDE_PROTECTED=True
+_DEFAULT_INCLUDE_PRIVATE=True
+
 class MetaJavaClass(MetaJavaBase):
-    def __new__(meta, classname, bases, classDict, classparams=(True, True)):
+    def __new__(meta, classname, bases, classDict, classparams=(_DEFAULT_INCLUDE_PROTECTED, _DEFAULT_INCLUDE_PRIVATE)):
         meta.resolve_class(classDict)
         tp = type.__new__(meta, str(classname), bases, classDict)
         jclass_register[(classDict['__javaclass__'], classparams)] = tp
@@ -160,7 +162,7 @@ class MetaJavaClass(MetaJavaBase):
         return super(MetaJavaClass, cls).__subclasscheck__(value)
 
     @staticmethod
-    def get_javaclass(name, classparams=(False, False)):
+    def get_javaclass(name, classparams=(_DEFAULT_INCLUDE_PROTECTED, _DEFAULT_INCLUDE_PRIVATE)):
         return jclass_register.get((name, classparams))
 
     @classmethod
@@ -207,17 +209,29 @@ class MetaJavaClass(MetaJavaBase):
                 raise JavaException('Unable to create the class'
                         ' {0}'.format(__javaclass__))
         else:
-            class_name = str_for_c(__javaclass__)
-            jcs.j_cls = j_env[0].FindClass(j_env,
-                    <char *>class_name)
-            if jcs.j_cls == NULL:
-                raise JavaException('Unable to find the class'
+
+            if '_class' in classDict:
+                 #we have a python copy of the class object, in classDict['_class']. lets use this instead of FindClass
+
+                # classDict['_class'] is a jnius.reflect.Class, which extends JavaClass
+                # The jobject for that JavaClass is the jclass that we need to instantiate this object
+                JavaClass.copy_storage(classDict['_class'], jcs)
+                if jcs.j_cls == NULL:
+                    raise JavaException('_class instance did not have a reference'
+                        ' {0}'.format(__javaclass__))
+            else:
+                class_name = str_for_c(__javaclass__)
+                jcs.j_cls = j_env[0].FindClass(j_env,
+                        <char *>class_name)
+                if jcs.j_cls == NULL:
+                    raise JavaException('Unable to find the class'
                         ' {0}'.format(__javaclass__))
 
-        # XXX do we need to grab a ref here?
-        # -> Yes, according to http://developer.android.com/training/articles/perf-jni.html
-        #    in the section Local and Global References
-        jcs.j_cls = j_env[0].NewGlobalRef(j_env, jcs.j_cls)
+                # XXX do we need to grab a ref here?
+                # -> Yes, according to http://developer.android.com/training/articles/perf-jni.html
+                #    in the section Local and Global References
+                jcs.j_cls = j_env[0].NewGlobalRef(j_env, jcs.j_cls)
+                # we only need this for a NEW FindClass call
 
         classDict['__cls_storage'] = jcs
 
@@ -271,6 +285,9 @@ cdef class JavaClass(object):
             self.resolve_methods()
             self.resolve_fields()
 
+    cdef void copy_storage(self, JavaClassStorage jcs) except *:
+        jcs.j_cls = <jclass> self.j_self.obj
+
     cdef void instanciate_from(self, LocalRef j_self) except *:
         self.j_self = j_self
         self.resolve_methods()

jnius/jnius_export_func.pxi

@@ -14,16 +14,23 @@ def cast(destclass, obj):
     return jc
 
 
-def find_javaclass(namestr):
+def find_javaclass(namestr, raise_error=True):
     namestr = namestr.replace('.', '/')
     cdef bytes name = str_for_c(namestr)
     from .reflect import Class
     cdef JavaClass cls
     cdef jclass jc
     cdef JNIEnv *j_env = get_jnienv()
+    cdef jthrowable
 
     jc = j_env[0].FindClass(j_env, name)
-    check_exception(j_env)
+    if raise_error:
+        check_exception(j_env)
+    else:
+        exc = j_env[0].ExceptionOccurred(j_env)
+        if exc:
+            j_env[0].ExceptionClear(j_env)
+        return None
 
     cls = Class(noinstance=True)
     cls.instanciate_from(create_local_ref(j_env, jc))

jnius/reflect.py

@@ -9,10 +9,10 @@
 from .jnius import (
     JavaClass, MetaJavaClass, JavaMethod, JavaStaticMethod,
     JavaField, JavaStaticField, JavaMultipleMethod, find_javaclass,
-    JavaException
+    JavaException, _DEFAULT_INCLUDE_PROTECTED, _DEFAULT_INCLUDE_PRIVATE
 )
 
-__all__ = ('autoclass', 'ensureclass', 'protocol_map')
+__all__ = ('autoclass', 'ensureclass', 'protocol_map', 'reflect_class')
 
 log = getLogger(__name__)
 
@@ -25,6 +25,7 @@ class Class(with_metaclass(MetaJavaClass, JavaClass)):
         ('(Ljava/lang/String,Z,Ljava/lang/ClassLoader;)Ljava/langClass;', True, False),
         ('(Ljava/lang/String;)Ljava/lang/Class;', True, False), ])
     getClassLoader = JavaMethod('()Ljava/lang/ClassLoader;')
+    getClass = JavaMethod('()Ljava/lang/Class;')
     getClasses = JavaMethod('()[Ljava/lang/Class;')
     getComponentType = JavaMethod('()Ljava/lang/Class;')
     getConstructor = JavaMethod('([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;')
@@ -55,6 +56,7 @@ class Class(with_metaclass(MetaJavaClass, JavaClass)):
     isInstance = JavaMethod('(Ljava/lang/Object;)Z')
     isInterface = JavaMethod('()Z')
     isPrimitive = JavaMethod('()Z')
+    hashCode = JavaMethod('()I')
     newInstance = JavaMethod('()Ljava/lang/Object;')
     toString = JavaMethod('()Ljava/lang/String;')
 
@@ -213,36 +215,64 @@ def identify_hierarchy(cls, level, concrete=True):
     yield cls, level
 
 
-# NOTE: if you change the include_protected or include_private default values,
-# you also must change the classparams default value in MetaJavaClass.__new__
-# and MetaJavaClass.get_javaclass.
-def autoclass(clsname, include_protected=True, include_private=True):
+def autoclass(clsname,
+              include_protected=_DEFAULT_INCLUDE_PROTECTED,
+              include_private=_DEFAULT_INCLUDE_PRIVATE):
+    '''
+        Auto-reflects a class based on its name. 
+
+        Parameters:
+            clsname (str): string name of the class, e.g. "java.util.HashMap"
+            include_protected (boolean): whether protected methods and fields should be included
+            include_private (boolean): whether protected methods and fields should be included
+
+        Returns:
+            Returns a Python object representing the static class.
+    '''
     jniname = clsname.replace('.', '/')
     cls = MetaJavaClass.get_javaclass(jniname, classparams=(include_protected, include_private))
     if cls:
         return cls
 
-    classDict = {}
-    cls_start_packagename = '.'.join(clsname.split('.')[:-1])
-
     # c = Class.forName(clsname)
     c = find_javaclass(clsname)
     if c is None:
         raise Exception('Java class {0} not found'.format(c))
         return None
 
-    classDict['_class'] = c
+    return reflect_class(c, include_protected, include_private)
+
+
+# NOTE: See also comments on autoclass() on include_protected or include_private default values
+def reflect_class(cls_object, include_protected=_DEFAULT_INCLUDE_PROTECTED, include_private=_DEFAULT_INCLUDE_PRIVATE):
+    '''
+        Create a python wrapping class with the attributes and methods of the corresponding java class, from a python instance of the desired reflected java class.
+
+        Parameters:
+            cls_object (Class): a Python instance of a java.lang.Class object.
+            include_protected (boolean): whether protected methods and fields should be included
+            include_private (boolean): whether protected methods and fields should be included
+
+        Returns:
+            Returns a Python object representing the static class.
+    '''
+
+    clsname = cls_object.getName()
+    classDict = {}
+    cls_start_packagename = '.'.join(clsname.split('.')[:-1])
+
+    classDict['_class'] = cls_object
 
     constructors = []
-    for constructor in c.getConstructors():
+    for constructor in cls_object.getConstructors():
         sig = '({0})V'.format(
             ''.join([get_signature(x) for x in constructor.getParameterTypes()]))
         constructors.append((sig, constructor.isVarArgs()))
     classDict['__javaconstructor__'] = constructors
 
-    class_hierachy = list(identify_hierarchy(c, 0, not c.isInterface()))
+    class_hierachy = list(identify_hierarchy(cls_object, 0, not cls_object.isInterface()))
 
-    log.debug("autoclass(%s) intf %r hierarchy is %s" % (clsname,c.isInterface(),str(class_hierachy)))
+    log.debug("autoclass(%s) intf %r hierarchy is %s" % (clsname,cls_object.isInterface(),str(class_hierachy)))
     cls_done=set()
 
     cls_methods = defaultdict(list)
@@ -320,19 +350,11 @@ def autoclass(clsname, include_protected=True, include_private=True):
                 get_signature(method.getReturnType()))
             if log.isEnabledFor(DEBUG):
                 log_method(method, name, sig)
-            classDict[name] = (JavaStaticMethod if static else JavaMethod)(sig, varargs=varargs)
-            # methods that fit the characteristics of a JavaBean's methods get turned into properties.
-            # these added properties should not supercede any other methods or fields.
-            if name != 'getClass' and bean_getter(name) and len(method.getParameterTypes()) == 0:
-                lowername = lower_name(name[2 if name.startswith('is') else 3:])
-                if lowername in classDict:
-                    # don't add this to classDict if the property will replace a method or field.
-                    continue
-                classDict[lowername] = (lambda n: property(lambda self: getattr(self, n)()))(name)
+            _add_single_method(classDict, name, static, sig, varargs)
         else:
             # multiple signatures
             signatures = []
-            log.debug("method %s has %d multiple signatures in hierarchy of cls %s" % (name, len(cls_methods[name]), c))
+            log.debug("method %s has %d multiple signatures in hierarchy of cls %s" % (name, len(cls_methods[name]), clsname))
 
             paramsig_to_level=defaultdict(lambda: float('inf'))
             # we now identify if any have the same signature, as we will call the _lowest_ in the hierarchy,
@@ -357,8 +379,14 @@ def autoclass(clsname, include_protected=True, include_private=True):
                     log_method(method, name, sig)
                 signatures.append((sig, Modifier.isStatic(method.getModifiers()), method.isVarArgs()))
 
-            log.debug("method selected %d multiple signatures of %s" % (len(signatures), str(signatures)))
-            classDict[name] = JavaMultipleMethod(signatures)
+            if len(signatures) > 1:
+                log.debug("method selected %d multiple signatures of %s" % (len(signatures), str(signatures)))
+                classDict[name] = JavaMultipleMethod(signatures)
+            elif len(signatures) == 1:
+                (sig, static, varargs) = signatures[0]
+                if log.isEnabledFor(DEBUG):
+                    log_method(method, name, sig)
+                _add_single_method(classDict, name, static, sig, varargs)
 
     # check whether any classes in the hierarchy appear in the protocol_map
     for cls, _ in class_hierachy:
@@ -375,6 +403,16 @@ def autoclass(clsname, include_protected=True, include_private=True):
         classDict,
         classparams=(include_protected, include_private))
 
+def _add_single_method(classDict, name, static, sig, varargs):
+    classDict[name] = (JavaStaticMethod if static else JavaMethod)(sig, varargs=varargs)
+    # methods that fit the characteristics of a JavaBean's methods get turned into properties.
+    # these added properties should not supercede any other methods or fields.
+    if name != 'getClass' and bean_getter(name) and sig.startswith("()"):
+        lowername = lower_name(name[2 if name.startswith('is') else 3:])
+        if lowername in classDict:
+            # don't add this to classDict if the property will replace a method or field.
+            return
+        classDict[lowername] = (lambda n: property(lambda self: getattr(self, n)()))(name)
 
 def _getitem(self, index):
     ''' dunder method for List '''

tests/test_reflect.py

@@ -5,7 +5,7 @@
 from jnius.reflect import autoclass
 from jnius import cast
 from jnius.reflect import identify_hierarchy
-from jnius import find_javaclass
+from jnius import find_javaclass, MetaJavaClass
 
 def identify_hierarchy_dict(cls, level, concrete=True):
     return({ cls.getName() : level for cls,level in identify_hierarchy(cls, level, concrete) })
@@ -102,3 +102,10 @@ def test_list_iteration(self):
         words.add('world')
         self.assertEqual(['hello', 'world'], [word for word in words])
 
+    def test_autoclass_default_params(self):
+        cls_name = 'javax.crypto.Cipher'
+        jni_name = cls_name.replace('.', '/')
+        if MetaJavaClass.get_javaclass(jni_name) is not None:
+                    self.skipTest("%s already loaded - has this test run more than once?" % cls_name)
+        self.assertIsNotNone(autoclass(cls_name))
+        self.assertIsNotNone(MetaJavaClass.get_javaclass(jni_name))

tests/test_reflect_class.py

@@ -0,0 +1,57 @@
+
+
+import unittest
+from jnius.reflect import autoclass, reflect_class
+
+class ReflectTest(unittest.TestCase):
+
+    def test_reflect_class(self):
+        cls_loader = autoclass("java.lang.ClassLoader").getSystemClassLoader()
+
+        # choose an obscure class that jnius hasnt seen before during unit tests
+        cls_name = "java.util.zip.CRC32"
+        from jnius import MetaJavaClass
+        if MetaJavaClass.get_javaclass(cls_name) is not None:
+            self.skipTest("%s already loaded - has this test run more than once?" % cls_name)
+
+        cls = cls_loader.loadClass(cls_name)
+        # we get a Class object
+        self.assertEqual("java.lang.Class", cls.getClass().getName())
+        # which represents CRC32
+        self.assertEqual(cls_name, cls.getName())
+        # lets make that into a python obj representing the class
+        pyclass = reflect_class(cls)
+        # check it refers to the same thing
+        self.assertEqual(cls_name.replace('.', '/'), pyclass.__javaclass__)
+        # check we can instantiate it
+        instance = pyclass()
+        self.assertIsNotNone(instance)
+
+
+    def test_dynamic_jar(self):
+        # the idea behind this test is to:
+        # 1. load an external jar file using an additional ClassLoader
+        # 2. check we can instantate the Class instance
+        # 3. check we can reflect the Class instance
+        # 4. check we can call a method that returns an object that can only be accessed using the additional ClassLoader
+        jar_url = "https://repo1.maven.org/maven2/commons-io/commons-io/2.6/commons-io-2.6.jar"
+        url = autoclass("java.net.URL")(jar_url)
+        sys_cls_loader = autoclass("java.lang.ClassLoader").getSystemClassLoader()
+        new_cls_loader = autoclass("java.net.URLClassLoader").newInstance([url], sys_cls_loader)
+        cls_object = new_cls_loader.loadClass("org.apache.commons.io.IOUtils")
+        self.assertIsNotNone(cls_object)
+        io_utils = reflect_class(cls_object)
+        self.assertIsNotNone(io_utils)
+
+        stringreader = autoclass("java.io.StringReader")("test1\ntest2")
+        #lineIterator returns an object of class LineIterator - here we check that jnius can reflect that, despite not being in the boot classpath
+        lineiter = io_utils.lineIterator(stringreader)
+        self.assertEqual("test1", lineiter.next())
+        self.assertEqual("test2", lineiter.next())
+
+        # Equivalent Java code:  
+        # var new_cls_loader = java.net.URLClassLoader.newInstance(new java.net.URL[] {new java.net.URL("https://repo1.maven.org/maven2/commons-io/commons-io/2.6/commons-io-2.6.jar")}, ClassLoader.getSystemClassLoader())
+        # var cls = new_cls_loader.loadClass("org.apache.commons.io.IOUtils")
+        # var sr = new java.io.StringReader("test1\ntest2")
+        # var m = $2.getMethod("lineIterator", Reader.class)
+        # m.invoke(null, (Object) sr)