Android: uses "import" section and inner classes for obtaining qualified JNI parameters.

base/android/jni_generator/jni_generator.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
 If you change this, please run and update the tests."""
 
 import collections
 import optparse
@@ skipping 76 matching lines @@
       'int': 'jint',
       'byte': 'jbyte',
       'boolean': 'jboolean',
       'long': 'jlong',
       'double': 'jdouble',
       'float': 'jfloat',
   }
   java_type_map = {
       'void': 'void',
       'String': 'jstring',
+      'java/lang/String': 'jstring',
   }
   if java_type in java_pod_type_map:
     return java_pod_type_map[java_type]
   elif java_type in java_type_map:
     return java_type_map[java_type]
   elif java_type.endswith('[]'):
     if java_type[:-2] in java_pod_type_map:
       return java_pod_type_map[java_type[:-2]] + 'Array'
     return 'jobjectArray'
   else:
     return 'jobject'
 
 
 class JniParams(object):
-  _UNKNOWN_JAVA_TYPE_PREFIX = 'UNKNOWN_JAVA_TYPE: '
-  _external_param_files = set()
-  _external_param_list = []
+  _imports = []
+  _fully_qualified_class = ''
+  _package = ''
+  _inner_classes = []
 
   @staticmethod
-  def ReadExternalParamList(external_param_files):
-    if not external_param_files:
-      return
-    assert not JniParams._external_param_files
-    JniParams._external_param_files = set(external_param_files)
-    for external_param_file in JniParams._external_param_files:
-      with file(external_param_file, 'r') as f:
-        contents = f.read()
-        JniParams._external_param_list += [x.strip()
-                                           for x in contents.splitlines()
-                                           if x and not x.startswith('#')]
+  def SetFullyQualifiedClass(fully_qualified_class):
+    JniParams._fully_qualified_class = 'L' + fully_qualified_class
+    JniParams._package = '/'.join(fully_qualified_class.split('/')[:-1])
+
+  @staticmethod
+  def ExtractImportsAndInnerClasses(contents):
+    contents = contents.replace('\n', '')
+    re_import = re.compile(r'import.*?(?P<class>\S*?);')
+    for match in re.finditer(re_import, contents):
+      JniParams._imports += ['L' + match.group('class').replace('.', '/')]
+
+    re_inner = re.compile(r'(class|interface)\s+?(?P<name>\w+?)\W')
+    for match in re.finditer(re_inner, contents):
+      inner = match.group('name')
+      if not JniParams._fully_qualified_class.endswith(inner):
+        JniParams._inner_classes += [JniParams._fully_qualified_class + '$' +
+                                     inner]
 
   @staticmethod
   def JavaToJni(param):
     """Converts a java param into a JNI signature type."""
     pod_param_map = {
         'int': 'I',
         'boolean': 'Z',
         'long': 'J',
         'double': 'D',
         'float': 'F',
         'byte': 'B',
         'void': 'V',
     }
     object_param_list = [
         'Ljava/lang/Boolean',
         'Ljava/lang/Integer',
         'Ljava/lang/Long',
         'Ljava/lang/Object',
         'Ljava/lang/String',
-        'Ljava/util/ArrayList',
-        'Ljava/util/HashMap',
-        'Ljava/util/List',
-        'Landroid/content/Context',
-        'Landroid/graphics/Bitmap',
-        'Landroid/graphics/Canvas',
-        'Landroid/graphics/Rect',
-        'Landroid/graphics/RectF',
-        'Landroid/graphics/Matrix',
-        'Landroid/graphics/Point',
-        'Landroid/graphics/SurfaceTexture',
-        'Landroid/graphics/SurfaceTexture$OnFrameAvailableListener',
-        'Landroid/media/MediaPlayer',
-        'Landroid/os/Message',
-        'Landroid/view/KeyEvent',
-        'Landroid/view/Surface',
-        'Landroid/view/View',
-        'Landroid/webkit/ValueCallback',
-        'Ljava/io/InputStream',
-        'Ljava/nio/ByteBuffer',
-        'Ljava/util/Vector',
     ]
     if param == 'byte[][]':
       return '[[B'
     prefix = ''
     # Array?
     if param[-2:] == '[]':
       prefix = '['
       param = param[:-2]
     # Generic?
     if '<' in param:
       param = param[:param.index('<')]
     if param in pod_param_map:
       return prefix + pod_param_map[param]
     if '/' in param:
       # Coming from javap, use the fully qualified param directly.
       return 'L' + param + ';'
-    for qualified_name in object_param_list + JniParams._external_param_list:
+    for qualified_name in (object_param_list +
+                           JniParams._imports +
+                           [JniParams._fully_qualified_class] +
+                           JniParams._inner_classes):
       if (qualified_name.endswith('/' + param) or
           qualified_name.endswith('$' + param.replace('.', '$')) or
           qualified_name == 'L' + param):
         return prefix + qualified_name + ';'
-    else:
-      return JniParams._UNKNOWN_JAVA_TYPE_PREFIX + prefix + param + ';'
+    # Type not found, falling back to same package as this class.
+    return prefix + 'L' + JniParams._package + '/' + param + ';'
 
   @staticmethod
   def Signature(params, returns, wrap):
     """Returns the JNI signature for the given datatypes."""
     items = ['(']
     items += [JniParams.JavaToJni(param.datatype) for param in params]
     items += [')']
     items += [JniParams.JavaToJni(returns)]
     if wrap:
       return '\n' + '\n'.join(['"' + item + '"' for item in items])
@@ skipping 10 matching lines @@
       items = p.split(' ')
       if 'final' in items:
         items.remove('final')
       param = Param(
           datatype=items[0],
           name=(items[1] if len(items) > 1 else 'p%s' % len(ret)),
       )
       ret += [param]
     return ret
 
-  @staticmethod
-  def CheckUnknownDatatypes(fully_qualified_class, items):
-    unknown_datatypes = JniParams._GetUnknownDatatypes(items)
-    if unknown_datatypes:
-      msg = ('There are a few unknown datatypes in %s' %
-             fully_qualified_class)
-      msg += '\nPlease, edit %s' % str(JniParams._external_param_files)
-      msg += '\nand add the JNI type(s):\n'
-      for unknown_datatype in unknown_datatypes:
-        msg += '\n%s in methods:\n' % unknown_datatype
-        msg += '\n '.join(unknown_datatypes[unknown_datatype])
-      raise SyntaxError(msg)
-
-  @staticmethod
-  def _GetUnknownDatatypes(items):
-    """Returns a list containing the unknown datatypes."""
-    unknown_types = {}
-    for item in items:
-      all_datatypes = ([JniParams.JavaToJni(param.datatype)
-                        for param in item.params] +
-                       [JniParams.JavaToJni(item.return_type)])
-      for d in all_datatypes:
-        if d.startswith(JniParams._UNKNOWN_JAVA_TYPE_PREFIX):
-          unknown_types[d] = (unknown_types.get(d, []) +
-                              [item.name or 'Unable to parse'])
-    return unknown_types
-
 
 def ExtractJNINamespace(contents):
   re_jni_namespace = re.compile('.*?@JNINamespace\("(.*?)"\)')
   m = re.findall(re_jni_namespace, contents)
   if not m:
     return ''
   return m[0]
 
 
 def ExtractFullyQualifiedJavaClassName(java_file_name, contents):
@@ skipping 21 matching lines @@
         java_class_name=match.group('java_class_name'),
         native_class_name=match.group('native_class_name'),
         return_type=match.group('return'),
         name=match.group('name').replace('native', ''),
         params=JniParams.Parse(match.group('params')))
     natives += [native]
   return natives
 
 
 def GetStaticCastForReturnType(return_type):
-  if return_type == 'String':
+  if return_type in ['String', 'java/lang/String']:
     return 'jstring'
+  elif return_type.endswith('[]'):
+    return 'jobjectArray'
   return None
 
 
 def GetEnvCall(is_constructor, is_static, return_type):
   """Maps the types availabe via env->Call__Method."""
   if is_constructor:
     return 'NewObject'
   env_call_map = {'boolean': 'Boolean',
                   'byte': 'Byte',
                   'char': 'Char',
@@ skipping 114 matching lines @@
 
 class JNIFromJavaP(object):
   """Uses 'javap' to parse a .class file and generate the JNI header file."""
 
   def __init__(self, contents, namespace):
     self.contents = contents
     self.namespace = namespace
     self.fully_qualified_class = re.match('.*?class (?P<class_name>.*?) ',
                                           contents[1]).group('class_name')
     self.fully_qualified_class = self.fully_qualified_class.replace('.', '/')
+    JniParams.SetFullyQualifiedClass(self.fully_qualified_class)
     self.java_class_name = self.fully_qualified_class.split('/')[-1]
     if not self.namespace:
       self.namespace = 'JNI_' + self.java_class_name
-    re_method = re.compile('(?P<prefix>.*?)(?P<return_type>\w+?) (?P<name>\w+?)'
+    re_method = re.compile('(?P<prefix>.*?)(?P<return_type>\S+?) (?P<name>\w+?)'
                            '\((?P<params>.*?)\)')
     self.called_by_natives = []
     for content in contents[2:]:
       match = re.match(re_method, content)
       if not match:
         continue
       self.called_by_natives += [CalledByNative(
           system_class=True,
           unchecked=False,
           static='static' in match.group('prefix'),
           java_class_name='',
-          return_type=match.group('return_type'),
+          return_type=match.group('return_type').replace('.', '/'),
           name=match.group('name'),
           params=JniParams.Parse(match.group('params').replace('.', '/')))]
     re_constructor = re.compile('.*? public ' +
                                 self.fully_qualified_class.replace('/', '.') +
                                 '\((?P<params>.*?)\)')
     for content in contents[2:]:
       match = re.match(re_constructor, content)
       if not match:
         continue
       self.called_by_natives += [CalledByNative(
@@ skipping 22 matching lines @@
     stdout, _ = p.communicate()
     jni_from_javap = JNIFromJavaP(stdout.split('\n'), namespace)
     return jni_from_javap
 
 
 class JNIFromJavaSource(object):
   """Uses the given java source file to generate the JNI header file."""
 
   def __init__(self, contents, fully_qualified_class):
     contents = self._RemoveComments(contents)
+    JniParams.SetFullyQualifiedClass(fully_qualified_class)
+    JniParams.ExtractImportsAndInnerClasses(contents)
     jni_namespace = ExtractJNINamespace(contents)
     natives = ExtractNatives(contents)
     called_by_natives = ExtractCalledByNatives(contents)
     if len(natives) == 0 and len(called_by_natives) == 0:
       raise SyntaxError('Unable to find any JNI methods for %s.' %
                         fully_qualified_class)
     inl_header_file_generator = InlHeaderFileGenerator(
         jni_namespace, fully_qualified_class, natives, called_by_natives)
     self.content = inl_header_file_generator.GetContent()
 
@@ skipping 30 matching lines @@
   """Generates an inline header file for JNI integration."""
 
   def __init__(self, namespace, fully_qualified_class, natives,
                called_by_natives):
     self.namespace = namespace
     self.fully_qualified_class = fully_qualified_class
     self.class_name = self.fully_qualified_class.split('/')[-1]
     self.natives = natives
     self.called_by_natives = called_by_natives
     self.header_guard = fully_qualified_class.replace('/', '_') + '_JNI'
-    JniParams.CheckUnknownDatatypes(self.fully_qualified_class,
-                                    self.natives + self.called_by_natives)
 
   def GetContent(self):
     """Returns the content of the JNI binding file."""
     template = Template("""\
 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // This file is autogenerated by
@@ skipping 443 matching lines @@
   option_parser.add_option('-n', dest='namespace',
                            help='Uses as a namespace in the generated header,'
                            ' instead of the javap class name.')
   option_parser.add_option('--input_file',
                            help='Single input file name. The output file name '
                            'will be derived from it. Must be used with '
                            '--output_dir.')
   option_parser.add_option('--output_dir',
                            help='The output directory. Must be used with '
                            '--input')
-  option_parser.add_option('--external_param_list',
-                           help='A file name containing a list with extra '
-                           'fully-qualified param names. Can be used multiple '
-                           'times.',
-                           action='append')
   options, args = option_parser.parse_args(argv)
-  JniParams.ReadExternalParamList(options.external_param_list)
   if options.jar_file:
     input_file = ExtractJarInputFile(options.jar_file, options.input_file,
                                      options.output_dir)
   else:
     input_file = options.input_file
   output_file = None
   if options.output_dir:
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
   GenerateJNIHeader(input_file, output_file, options.namespace)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))