Android: generates JNI bindings for constructors in system classes.

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.
 
 # TODO (qinmin): Need to refactor this file as base should not know about
 # higher level concepts. Currently this file has knowledge about higher level
 # java classes.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
@@ skipping 60 matching lines @@
 
 class CalledByNative(object):
   """Describes a java method exported to c/c++"""
 
   def __init__(self, **kwargs):
     self.system_class = kwargs['system_class']
     self.unchecked = kwargs['unchecked']
     self.static = kwargs['static']
     self.java_class_name = kwargs['java_class_name']
     self.return_type = kwargs['return_type']
-    self.env_call = kwargs['env_call']
     self.name = kwargs['name']
     self.params = kwargs['params']
     self.method_id_var_name = kwargs.get('method_id_var_name', None)
+    self.is_constructor = kwargs.get('is_constructor', False)
+    self.env_call = GetEnvCall(self.is_constructor, self.static,
+                               self.return_type)
+    self.static_cast = GetStaticCastForReturnType(self.return_type)
 
 
 def JavaDataTypeToC(java_type):
   """Returns a C datatype for the given java type."""
   java_pod_type_map = {
       'int': 'jint',
       'byte': 'jbyte',
       'boolean': 'jboolean',
       'long': 'jlong',
       'double': 'jdouble',
@@ skipping 35 matching lines @@
       '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$OnFrameAvailableListener',
       'Landroid/os/Message',
       'Landroid/view/KeyEvent',
       'Landroid/view/Surface',
       'Landroid/view/View',
       'Landroid/webkit/ValueCallback',
       'Ljava/io/InputStream',
       'Ljava/nio/ByteBuffer',
       'Ljava/util/Vector',
   ]
   app_param_list = [
@@ skipping 52 matching lines @@
   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]
   for qualified_name in object_param_list + app_param_list:
     if (qualified_name.endswith('/' + param) or
-        qualified_name.endswith('$' + param.replace('.', '$'))):
+        qualified_name.endswith('$' + param.replace('.', '$')) or
+        qualified_name == 'L' + param):
       return prefix + qualified_name + ';'
   else:
     return UNKNOWN_JAVA_TYPE_PREFIX + prefix + param + ';'
 
 
 def JniSignature(params, returns, wrap):
   """Returns the JNI signature for the given datatypes."""
   items = ['(']
   items += [JavaParamToJni(param.datatype) for param in params]
   items += [')']
@@ skipping 67 matching lines @@
         static='static' in match.group('qualifiers'),
         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=ParseParams(match.group('params')))
     natives += [native]
   return natives
 
 
-def GetEnvCallForReturnType(return_type):
+def GetStaticCastForReturnType(return_type):
+  if return_type == 'String':
+    return 'jstring'
+  return None
+
+
+def GetEnvCall(is_constructor, is_static, return_type):
   """Maps the types availabe via env->Call__Method."""
-  env_call_map = {'boolean': ('Boolean', ''),
-                  'byte': ('Byte', ''),
-                  'char': ('Char', ''),
-                  'short': ('Short', ''),
-                  'int': ('Int', ''),
-                  'long': ('Long', ''),
-                  'float': ('Float', ''),
-                  'void': ('Void', ''),
-                  'double': ('Double', ''),
-                  'String': ('Object', 'jstring'),
-                  'Object': ('Object', ''),
+  if is_constructor:
+    return 'NewObject'
+  env_call_map = {'boolean': 'Boolean',
+                  'byte': 'Byte',
+                  'char': 'Char',
+                  'short': 'Short',
+                  'int': 'Int',
+                  'long': 'Long',
+                  'float': 'Float',
+                  'void': 'Void',
+                  'double': 'Double',
+                  'Object': 'Object',
                  }
-  return env_call_map.get(return_type, ('Object', ''))
+  call = env_call_map.get(return_type, 'Object')
+  if is_static:
+    call = 'Static' + call
+  return 'Call' + call + 'Method'
 
 
 def GetMangledMethodName(name, jni_signature):
   """Returns a mangled method name for a (name, jni_signature) pair.
 
      The returned name can be used as a C identifier and will be unique for all
      valid overloads of the same method.
 
   Args:
      name: string.
@@ skipping 57 matching lines @@
     ParseError: if unable to parse.
   """
   called_by_natives = []
   for match in re.finditer(RE_CALLED_BY_NATIVE, contents):
     called_by_natives += [CalledByNative(
         system_class=False,
         unchecked='Unchecked' in match.group('Unchecked'),
         static='static' in match.group('prefix'),
         java_class_name=match.group('annotation') or '',
         return_type=match.group('return_type'),
-        env_call=GetEnvCallForReturnType(match.group('return_type')),
         name=match.group('name'),
         params=ParseParams(match.group('params')))]
   # Check for any @CalledByNative occurrences that weren't matched.
   unmatched_lines = re.sub(RE_CALLED_BY_NATIVE, '', contents).split('\n')
   for line1, line2 in zip(unmatched_lines, unmatched_lines[1:]):
     if '@CalledByNative' in line1:
       raise ParseError('could not parse @CalledByNative method signature',
                        line1, line2)
   return MangleCalledByNatives(called_by_natives)
 
 
 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 (.*?) ',
-                                          contents[1]).group(1)
+    self.fully_qualified_class = re.match('.*?class (?P<class_name>.*?) ',
+                                          contents[1]).group('class_name')
     self.fully_qualified_class = self.fully_qualified_class.replace('.', '/')
     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('(.*?)(\w+?) (\w+?)\((.*?)\)')
+    re_method = re.compile('(?P<prefix>.*?)(?P<return_type>\w+?) (?P<name>\w+?)'
+                           '\((?P<params>.*?)\)')
     self.called_by_natives = []
-    for method in contents[2:]:
-      match = re.match(re_method, method)
+    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(1),
+          static='static' in match.group('prefix'),
           java_class_name='',
-          return_type=match.group(2),
-          name=match.group(3),
-          params=ParseParams(match.group(4)),
-          env_call=GetEnvCallForReturnType(match.group(2)))]
+          return_type=match.group('return_type'),
+          name=match.group('name'),
+          params=ParseParams(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(
+          system_class=False,
+          unchecked=False,
+          static=False,
+          java_class_name='',
+          return_type=self.fully_qualified_class,
+          name='Constructor',
+          params=ParseParams(match.group('params').replace('.', '/')),
+          is_constructor=True)]
     self.called_by_natives = MangleCalledByNatives(self.called_by_natives)
     self.inl_header_file_generator = InlHeaderFileGenerator(
         self.namespace, self.fully_qualified_class, [], self.called_by_natives)
 
   def GetContent(self):
     return self.inl_header_file_generator.GetContent()
 
   @staticmethod
   def CreateFromClass(class_file, namespace):
     class_name = os.path.splitext(os.path.basename(class_file))[0]
@@ skipping 298 matching lines @@
     function_header_with_unused_template = Template("""\
 ${FUNCTION_SIGNATURE} __attribute__ ((unused));
 ${FUNCTION_SIGNATURE} {""")
     template = Template("""
 static jmethodID g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = 0;
 ${FUNCTION_HEADER}
   /* Must call RegisterNativesImpl()  */
   DCHECK(g_${JAVA_CLASS}_clazz);
   DCHECK(g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
   ${RETURN_DECLARATION}
-  ${PRE_CALL}env->Call${STATIC}${ENV_CALL}Method(${FIRST_PARAM_IN_CALL},
+  ${PRE_CALL}env->${ENV_CALL}(${FIRST_PARAM_IN_CALL},
       g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}${PARAMS_IN_CALL})${POST_CALL};
   ${CHECK_EXCEPTION}
   ${RETURN_CLAUSE}
 }""")
-    if called_by_native.static:
+    if called_by_native.static or called_by_native.is_constructor:
       first_param_in_declaration = ''
       first_param_in_call = ('g_%s_clazz' %
                              (called_by_native.java_class_name or
                               self.class_name))
     else:
       first_param_in_declaration = ', jobject obj'
       first_param_in_call = 'obj'
     params_in_declaration = self.GetCalledByNativeParamsInDeclaration(
         called_by_native)
     if params_in_declaration:
       params_in_declaration = ', ' + params_in_declaration
     params_for_call = ', '.join(param.name
                                 for param in called_by_native.params)
     if params_for_call:
       params_for_call = ', ' + params_for_call
     pre_call = ''
     post_call = ''
-    if called_by_native.env_call[1]:
-      pre_call = 'static_cast<%s>(' % called_by_native.env_call[1]
+    if called_by_native.static_cast:
+      pre_call = 'static_cast<%s>(' % called_by_native.static_cast
       post_call = ')'
     check_exception = ''
     if not called_by_native.unchecked:
       check_exception = 'base::android::CheckException(env);'
     return_type = JavaDataTypeToC(called_by_native.return_type)
     return_declaration = ''
     return_clause = ''
     if return_type != 'void':
       pre_call = '  ' + pre_call
       return_declaration = return_type + ' ret ='
       if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
         return_type = 'ScopedJavaLocalRef<' + return_type + '>'
         return_clause = 'return ' + return_type + '(env, ret);'
       else:
         return_clause = 'return ret;'
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
         'METHOD': called_by_native.name,
         'RETURN_TYPE': return_type,
         'RETURN_DECLARATION': return_declaration,
         'RETURN_CLAUSE': return_clause,
         'FIRST_PARAM_IN_DECLARATION': first_param_in_declaration,
         'PARAMS_IN_DECLARATION': params_in_declaration,
         'STATIC': 'Static' if called_by_native.static else '',
         'PRE_CALL': pre_call,
         'POST_CALL': post_call,
-        'ENV_CALL': called_by_native.env_call[0],
+        'ENV_CALL': called_by_native.env_call,
         'FIRST_PARAM_IN_CALL': first_param_in_call,
         'PARAMS_IN_CALL': params_for_call,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'CHECK_EXCEPTION': check_exception,
     }
     values['FUNCTION_SIGNATURE'] = (
         function_signature_template.substitute(values))
     if called_by_native.system_class:
       values['FUNCTION_HEADER'] = (
           function_header_with_unused_template.substitute(values))
@@ skipping 56 matching lines @@
       values = {'JAVA_CLASS': clazz}
       ret += [template.substitute(values)]
     return '\n'.join(ret)
 
   def GetMethodIDImpl(self, called_by_native):
     """Returns the implementation of GetMethodID."""
     template = Template("""\
   g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} =
       base::android::Get${STATIC}MethodID(
           env, g_${JAVA_CLASS}_clazz,
-          "${NAME}",
+          "${JNI_NAME}",
           ${JNI_SIGNATURE});
 """)
+    jni_name = called_by_native.name
+    jni_return_type = called_by_native.return_type
+    if called_by_native.is_constructor:
+      jni_name = '<init>'
+      jni_return_type = 'void'
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
-        'NAME': called_by_native.name,
+        'JNI_NAME': jni_name,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'STATIC': 'Static' if called_by_native.static else '',
         'JNI_SIGNATURE': JniSignature(called_by_native.params,
-                                      called_by_native.return_type,
+                                      jni_return_type,
                                       True)
     }
     return template.substitute(values)
 
 
 def WrapOutput(output):
   ret = []
   for line in output.splitlines():
     # Do not wrap lines under 80 characters or preprocessor directives.
     if len(line) < 80 or line.lstrip()[:1] == '#':
@@ skipping 90 matching lines @@
     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))