src/xwalk/tools/reflection_generator/java_method.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2014 Intel Corporation. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 import re
   8
   9 from collections import OrderedDict
  10 from string import Template
  11
  12 def ConvertClassExpressionToClassType(class_name):
  13   """ Turn "final HashMap<String>" to HashMap.class. """
  14   return '%s.class' % class_name.split()[-1].split('<')[0]
  15
  16
  17 def ConvertPrimitiveTypeToObject(class_name):
  18   primitive_map = {
  19       'byte': 'Byte',
  20       'short': 'Short',
  21       'int': 'Integer',
  22       'long': 'Long',
  23       'float': 'Float',
  24       'double': 'Double',
  25       'char': 'Character',
  26       'boolean': 'Boolean',
  27   }
  28   return primitive_map.get(class_name, class_name)
  29
  30
  31 def HasCreateInternally(java_data):
  32   java_data_instance = java_data.GetInstanceJavaData()
  33   if java_data_instance:
  34     return java_data_instance.HasCreateInternallyAnnotation()
  35   else:
  36     return java_data.HasCreateInternallyAnnotation()
  37
  38
  39 class ParamStringType(object):
  40   INTERNAL_DECLARE = 1
  41   BRIDGE_DECLARE = 2
  42   BRIDGE_DECLARE_FOR_WRAPPER = 3
  43   BRIDGE_PASS_TO_SUPER = 4
  44   BRIDGE_PASS_TO_WRAPPER = 5
  45   INTERNAL_PASS_TO_BRIDGE = 6
  46   BRIDGE_OVERRIDE_CONDITION = 7
  47   WRAPPER_DECLARE = 8
  48   WRAPPER_DECLARE_FOR_BRIDGE = 9
  49   WRAPPER_PASS_TO_BRIDGE = 10
  50
  51
  52 class MethodStringType(object):
  53   BRIDGE_CONSTRUCTOR = 1
  54   BRIDGE_STATIC = 2
  55   BRIDGE_SUPER = 3
  56   BRIDGE_OVERRIDE = 4
  57   BRIDGE_WRAPPER = 5
  58   WRAPPER_CONSTRUCTOR = 6
  59   WRAPPER_STATIC = 7
  60   WRAPPER_BRIDGE = 8
  61   WRAPPER_INTERFACE = 9
  62
  63
  64 class Method(object):
  65   """Internal representaion of a method."""
  66   ANNOTATION_PRE_WRAPLINE = 'preWrapperLines'
  67   ANNOTATION_POST_WRAPLINE = 'postWrapLines'
  68
  69   def __init__(self, class_name, class_loader,
  70       is_constructor, is_static, is_abstract,
  71       method_name, method_return, params, annotation, doc=''):
  72     self._class_name = class_name
  73     self._class_loader = class_loader
  74     self._is_constructor = is_constructor
  75     self._is_static = is_static
  76     self._is_abstract = is_abstract
  77     self._method_name = method_name
  78     self._method_return = method_return
  79     self._params = OrderedDict() # Use OrderedDict to avoid parameter misorder.
  80     self._method_annotations = {}
  81     self._method_doc = doc
  82     self._class_java_data = ''
  83     self._method_declare_name = ''
  84     self._internal_params_declare = ''
  85     self._bridge_params_declare = ''
  86     self._bridge_params_declare_for_wrapper = ''
  87     self._bridge_params_pass_to_super = ''
  88     self._bridge_params_pass_to_wrapper = ''
  89     self._internal_params_pass_to_bridge = ''
  90     self._bridge_override_condition = ''
  91     self._wrapper_params_declare = ''
  92     self._wrapper_params_declare_for_bridge = ''
  93     self._wrapper_params_pass_to_bridge = ''
  94     self._strings_prepared = False
  95     self.ParseMethodParams(params)
  96     self.ParseMethodAnnotation(annotation)
  97
  98   def IsInternalClass(self, clazz):
  99     return self._class_loader.IsInternalClass(clazz)
 100
 101   def LoadJavaClass(self, clazz):
 102     return self._class_loader.LoadJavaClass(clazz)
 103
 104   def GenerateDoc(self, doc):
 105     return self._class_loader.GenerateDoc(doc)
 106
 107   @property
 108   def is_constructor(self):
 109     return self._is_constructor
 110
 111   @property
 112   def is_static(self):
 113     return self._is_static
 114
 115   @property
 116   def is_abstract(self):
 117     return self._is_abstract
 118
 119   @property
 120   def method_name(self):
 121     return self._method_name
 122
 123   @property
 124   def method_return(self):
 125     return self._method_return
 126
 127   @property
 128   def params(self):
 129     return self._params
 130
 131   @property
 132   def method_annotations(self):
 133     return self._method_annotations
 134
 135   @property
 136   def method_doc(self):
 137     return self._method_doc
 138
 139   def ParseMethodParams(self, params):
 140     # TODO(shouqun): Currently, generic parameters are not supported.
 141     # The support of generic types should be added if such cases happen.
 142     if not params or params == '':
 143       return
 144     for param in params.split(','):
 145       param = param.strip()
 146       param_list = param.split()
 147       param_type = ' '.join(param_list[:-1]) # To handle modifiers
 148       param_name = param_list[-1]
 149       self._params[param_name] = param_type
 150
 151   def ParseMethodAnnotation(self, annotation):
 152     pre_wrapline_re = re.compile('preWrapperLines\s*=\s*\{\s*('
 153         '?P<pre_wrapline>(".*")(,\s*".*")*)\s*\}')
 154     for match in re.finditer(pre_wrapline_re, annotation):
 155       pre_wrapline = self.FormatWrapperLine(match.group('pre_wrapline'))
 156       self._method_annotations[self.ANNOTATION_PRE_WRAPLINE] = pre_wrapline
 157
 158     post_wrapline_re = re.compile('postWrapperLines\s*=\s*\{\s*('
 159         '?P<post_wrapline>(".*")(,\s*".*")*)\s*\}')
 160     for match in re.finditer(post_wrapline_re, annotation):
 161       post_wrapline = self.FormatWrapperLine(match.group('post_wrapline'))
 162       self._method_annotations[self.ANNOTATION_POST_WRAPLINE] = post_wrapline
 163
 164   def FormatWrapperLine(self, annotation_value):
 165     """ annotaion_value is a java string array which each element is an
 166         individual line. Probably like: '    "line1",\n    "line2"'
 167         This method is turnning it to '    line1\n    line2'
 168     """
 169     lines = []
 170     exec('lines = [%s]' % annotation_value.replace('\n', ''))
 171     template = Template('\n'.join(lines))
 172     values = {}
 173     for arg in range(1, len(self.params.keys())+1):
 174       values['param%d' % arg] = self.params.keys()[arg-1]
 175     return template.substitute(values)
 176
 177   def GetBridgeParamsStringDeclareForWrapper(self):
 178     self.PrepareStrings()
 179     return self._bridge_params_declare_for_wrapper
 180
 181   def GetWrapperParamsStringDeclareForBridge(self):
 182     self.PrepareStrings()
 183     return self._wrapper_params_declare_for_bridge
 184
 185   def GetMethodDeclareName(self):
 186     self.PrepareStrings()
 187     return self._method_declare_name
 188
 189   def PrepareStrings(self):
 190     if self._strings_prepared:
 191       return
 192     self._class_java_data = self.LoadJavaClass(self._class_name)
 193     self._method_declare_name = self.GenerateMethodDeclareName()
 194
 195     self._internal_params_declare = ', '.join(
 196         self.GetFormattedParamArray(ParamStringType.INTERNAL_DECLARE))
 197     self._bridge_params_declare = ', '.join(
 198         self.GetFormattedParamArray(ParamStringType.BRIDGE_DECLARE))
 199     self._bridge_params_declare_for_wrapper = ', '.join(
 200         self.GetFormattedParamArray(
 201             ParamStringType.BRIDGE_DECLARE_FOR_WRAPPER, insert_empty=True))
 202     self._bridge_params_pass_to_super = ', '.join(
 203         self.GetFormattedParamArray(ParamStringType.BRIDGE_PASS_TO_SUPER))
 204     self._bridge_params_pass_to_wrapper = ', '.join(
 205         self.GetFormattedParamArray(
 206             ParamStringType.BRIDGE_PASS_TO_WRAPPER, insert_empty=True))
 207     self._internal_params_pass_to_bridge = ', '.join(
 208         self.GetFormattedParamArray(ParamStringType.INTERNAL_PASS_TO_BRIDGE))
 209     self._bridge_override_condition = ' && '.join(
 210         self.GetFormattedParamArray(ParamStringType.BRIDGE_OVERRIDE_CONDITION))
 211     self._wrapper_params_declare = ', '.join(
 212         self.GetFormattedParamArray(ParamStringType.WRAPPER_DECLARE))
 213     self._wrapper_params_declare_for_bridge = ', '.join(
 214         self.GetFormattedParamArray(ParamStringType.WRAPPER_DECLARE_FOR_BRIDGE,
 215                                     insert_empty=True))
 216     self._wrapper_params_pass_to_bridge = ', '.join(
 217         self.GetFormattedParamArray(
 218             ParamStringType.WRAPPER_PASS_TO_BRIDGE, insert_empty=True))
 219
 220     self._strings_prepared = True
 221
 222   def GetFormattedParamArray(self, param_string_type,
 223       append_empty=False, insert_empty=False):
 224     """ Return the array of params with specified format.
 225         append or insert an empty string on demand for cases
 226         that need extra splitter when using the array.
 227     """
 228     formatted_params = []
 229     for param_name in self._params:
 230       param_type = self._params[param_name]
 231       formatted_param = self.FormatSingleParam(
 232           param_type, param_name, param_string_type)
 233       if formatted_param:
 234         formatted_params.append(formatted_param)
 235     if append_empty:
 236       formatted_params.append('')
 237     if insert_empty:
 238       formatted_params.insert(0, '')
 239     return formatted_params
 240
 241   def FormatSingleParam(self, param_type, param_name, param_string_type):
 242     is_internal_class = self.IsInternalClass(param_type)
 243     if is_internal_class:
 244       java_data = self.LoadJavaClass(param_type)
 245     if param_string_type == ParamStringType.INTERNAL_DECLARE:
 246       # the way internal declares its params, will be used in bridge's override
 247       # call.
 248       #   XWalkViewInternal view => XWalkViewInternal view
 249       return '%s %s' % (param_type, param_name)
 250     elif param_string_type == ParamStringType.BRIDGE_DECLARE:
 251       # the way bridge declares its params, will be used in bridge's wrapper
 252       # call and super call.
 253       #   XWalkViewInternal view => XWalkViewBridge view
 254       if is_internal_class:
 255         return '%s %s' % (java_data.UseAsTypeInBridgeAndBridgeSuperCall(),
 256                           param_name)
 257       else:
 258         return '%s %s' % (param_type, param_name)
 259     elif param_string_type == ParamStringType.BRIDGE_DECLARE_FOR_WRAPPER:
 260       # the way bridge declares its params for wrapper, will turn the param
 261       # type to class<?> value for reflection to use.
 262       #   XWalkViewInternal view => "org.xwalk.core.XWalkView"
 263       #   DirectionInternal direnction => enumDirectionClass
 264       #   String name => String.class
 265       if is_internal_class:
 266         return '"%s"' % java_data.GetFullWrapperName()
 267       else:
 268         # TODO(wang16): Here only detects enum declared in the same class as
 269         # the method itself. Using enum across class is not supported.
 270         enums = self._class_java_data.enums
 271         if param_type in enums:
 272           return enums[param_type].EnumClassName()
 273         else:
 274           return ConvertClassExpressionToClassType(param_type)
 275     elif param_string_type == ParamStringType.BRIDGE_PASS_TO_SUPER:
 276       # the way bridge passes the param to super
 277       #   XWalkViewInternal view => view
 278       if is_internal_class:
 279         return java_data.UseAsInstanceInBridgeSuperCall(param_name)
 280       else:
 281         return param_name
 282     elif param_string_type == ParamStringType.BRIDGE_PASS_TO_WRAPPER:
 283       # the way bridge passes the param to wrapper
 284       #   XWalkViewInternal view => view.getWrapper()
 285       #   DirectionInternal direction => ConvertDirectionInternal(direction)
 286       if is_internal_class:
 287         return java_data.UseAsInstanceInBridgeCall(param_name)
 288       else:
 289         # TODO(wang16): Here only detects enum declared in the same class as
 290         # the method itself. Using enum across class is not supported.
 291         enums = self._class_java_data.enums
 292         if param_type in enums:
 293           return 'Convert%s(%s)' % (param_type, param_name)
 294         else:
 295           return param_name
 296     elif param_string_type == ParamStringType.INTERNAL_PASS_TO_BRIDGE:
 297       # the way bridge accepts param from internal
 298       #   XWalkViewInternal view => (XWalkViewBridge) view
 299       if is_internal_class:
 300         return java_data.UseAsInstanceInBridgeOverrideCall(param_name)
 301       else:
 302         return param_name
 303     elif param_string_type == ParamStringType.BRIDGE_OVERRIDE_CONDITION:
 304       # the way bridge uses as the condition for whether call super or
 305       # call wrapper in override call
 306       #   XWalkViewInternal view => (view instanceof XWalkViewBridge)
 307       if is_internal_class and not HasCreateInternally(java_data):
 308         return'(%s instanceof %s)' % (
 309             param_name,
 310             java_data.UseAsTypeInBridgeAndBridgeSuperCall())
 311       else:
 312         return None
 313     elif param_string_type == ParamStringType.WRAPPER_DECLARE:
 314       # the way wrapper declare the param
 315       #   XWalkViewInternal view => XWalkView view
 316       #   DirectionInternal direction => Direction direction
 317       if is_internal_class:
 318         return '%s %s' % (java_data.UseAsTypeInWrapperCall(), param_name)
 319       elif param_type in self._class_java_data.enums:
 320         # TODO(wang16): Here only detects enum declared in the same class as
 321         # the method itself. Using enum across class is not supported.
 322         return '%s %s' % (param_type.replace('Internal', ''), param_name)
 323       else:
 324         return '%s %s' % (param_type, param_name)
 325     elif param_string_type == ParamStringType.WRAPPER_DECLARE_FOR_BRIDGE:
 326       # the way wrapper declares its params for bridge, will turn the param
 327       # type to class<?> value for reflection to use.
 328       #   XWalkViewInternal view => "org.xwalk.core.internal.XWalkViewBridge"
 329       #   DirectionInternal direction => enumDirectionClass
 330       #   String name => String.class
 331
 332       # TODO(wang16): Currently there is no internal classes for static method.
 333       # Need to support it in future.
 334       if is_internal_class:
 335         return '"%s"' % java_data.GetFullBridgeName()
 336       else:
 337         # TODO(wang16): Here only detects enum declared in the same class as
 338         # the method itself. Using enum across class is not supported.
 339         enums = self._class_java_data.enums
 340         if param_type in enums:
 341           return enums[param_type].EnumClassName()
 342         else:
 343           return ConvertClassExpressionToClassType(param_type)
 344     elif param_string_type == ParamStringType.WRAPPER_PASS_TO_BRIDGE:
 345       # the way wrapper passes param to bridge
 346       #   XWalkViewInternal view => view.getBridge()
 347       #   DirectionInternal direction => ConvertDirection(direction)
 348       if is_internal_class:
 349         return java_data.UseAsInstanceInWrapperCall(param_name)
 350       elif param_type in self._class_java_data.enums:
 351         # TODO(wang16): Here only detects enum declared in the same class as
 352         # the method itself. Using enum across class is not supported.
 353         return 'Convert%s(%s)' % (param_type.replace('Internal', ''),
 354                                   param_name)
 355       else:
 356         return param_name
 357     else:
 358       pass
 359
 360   def GenerateMethodDeclareName(self):
 361     name = self.method_name
 362     for param_name in self.params:
 363       # Remove modifier and generic type.
 364       name += ConvertClassExpressionToClassType(
 365           self.params[param_name]).replace('.class', '')
 366     if self._is_constructor:
 367       return '%sConstructor' % name
 368     else:
 369       return '%sMethod' % name
 370
 371   def GenerateBridgeConstructor(self):
 372     template = Template(
 373         '    public ${NAME}(${PARAMS}, Object wrapper) {\n' +
 374         '        super(${PARAMS_PASSING});\n' +
 375         '        this.wrapper = wrapper;\n' +
 376         '        try {\n' +
 377         '            reflectionInit();\n' +
 378         '        } catch (Exception e) {\n' +
 379         '            ReflectionHelper.handleException(e);\n'+
 380         '        }\n' +
 381         '    }\n\n')
 382     value = {'NAME': self._class_java_data.bridge_name,
 383              'PARAMS': self._bridge_params_declare,
 384              'PARAMS_PASSING': self._bridge_params_pass_to_super}
 385     return template.substitute(value)
 386
 387   def GenerateBridgeStaticMethod(self):
 388     no_return_value = self._method_return == 'void'
 389     template = Template(
 390         '    public static ${RETURN_TYPE} ${NAME}($PARAMS) {\n' +
 391         '        ${RETURN}${CLASS_NAME}.${NAME}(${PARAMS_PASSING});\n' +
 392         '    }\n\n')
 393     value = {'RETURN_TYPE': self.method_return,
 394              'NAME': self.method_name,
 395              'PARAMS': self._bridge_params_declare,
 396              'RETURN': '' if no_return_value else 'return ',
 397              'CLASS_NAME': self._class_name,
 398              'PARAMS_PASSING': self._bridge_params_pass_to_super}
 399     return template.substitute(value)
 400
 401   def GenerateBridgeOverrideMethod(self):
 402     no_return_value = self._method_return == 'void'
 403     if not self._bridge_override_condition:
 404       return '    @Override\n'
 405     template = Template(
 406         '    @Override\n' +
 407         '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 408         '        if (${IF_CONDITION}) {\n' +
 409         '            ${RETURN}${NAME}(${BRIDGE_PARAMS_PASSING});\n' +
 410         '        } else {\n' +
 411         '            ${RETURN}super.${NAME}(${PARAMS_PASSING});\n' +
 412         '        }\n' +
 413         '    }\n\n')
 414     value = {'NAME': self.method_name,
 415              'RETURN_TYPE': self.method_return,
 416              'PARAMS': self._internal_params_declare,
 417              'RETURN': '' if no_return_value else 'return ',
 418              'IF_CONDITION': self._bridge_override_condition,
 419              'PARAMS_PASSING': self._bridge_params_pass_to_super,
 420              'BRIDGE_PARAMS_PASSING': self._internal_params_pass_to_bridge}
 421     return template.substitute(value)
 422
 423   def GenerateBridgeWrapperMethod(self):
 424     no_return_value = self._method_return == 'void'
 425     return_is_internal = self.IsInternalClass(self._method_return)
 426     if return_is_internal:
 427       return_type_java_data = self.LoadJavaClass(self._method_return)
 428
 429     match_obj = re.search(
 430         r'ValueCallback<([A-Za-z]+)Internal> ([a-zA-Z0-9_$]+)(,|$)',
 431         self._bridge_params_declare)
 432     if match_obj :
 433       callback_type = match_obj.group(1)
 434       callback = match_obj.group(2)
 435
 436       template = Template(
 437           '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 438           '        final ValueCallback<' + callback_type + 'Internal> ' +
 439           callback + '2 = ' +  callback + ';\n' +
 440           '        ${RETURN}ReflectionHelper.invokeMethod(\n' +
 441           '            ${METHOD_DECLARE_NAME}, wrapper${PARAMS_PASSING});\n' +
 442           '    }\n\n')
 443
 444       params_passing = re.sub(
 445           str(callback),
 446           '\n            new ValueCallback<Object>() {\n' +
 447           '                @Override\n' +
 448           '                public void onReceiveValue(Object value) {\n' +
 449           '                    ' + callback + '2.onReceiveValue((' +
 450           callback_type +
 451           'Bridge) ReflectionHelper.getBridgeOrWrapper(value));\n' +
 452           '                }\n' +
 453           '            }',
 454           self._bridge_params_pass_to_wrapper)
 455     elif return_is_internal:
 456       template = Template(
 457           '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 458           '        ${RETURN}ReflectionHelper.getBridgeOrWrapper(' +
 459           'ReflectionHelper.invokeMethod(\n' +
 460           '            ${METHOD_DECLARE_NAME}, wrapper${PARAMS_PASSING}));\n' +
 461           '    }\n\n')
 462       params_passing = self._bridge_params_pass_to_wrapper
 463     else :
 464       template = Template(
 465           '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 466           '        ${RETURN}ReflectionHelper.invokeMethod(\n' +
 467           '            ${METHOD_DECLARE_NAME}, wrapper${PARAMS_PASSING});\n' +
 468           '    }\n\n')
 469       params_passing = self._bridge_params_pass_to_wrapper
 470
 471     if no_return_value:
 472       return_statement = ''
 473     elif return_is_internal:
 474       return_statement = 'return (%s)' % return_type_java_data.bridge_name
 475     else:
 476       return_statement = 'return (%s)' % (
 477           ConvertPrimitiveTypeToObject(self.method_return))
 478     value = {'RETURN_TYPE': self.method_return,
 479              'NAME': self.method_name,
 480              'METHOD_DECLARE_NAME': self._method_declare_name,
 481              'PARAMS': self._bridge_params_declare,
 482              'RETURN': return_statement,
 483              'PARAMS_PASSING': params_passing}
 484     return template.substitute(value)
 485
 486   def GenerateBridgeSuperMethod(self):
 487     no_return_value = self._method_return == 'void'
 488     return_is_internal = self.IsInternalClass(self._method_return)
 489     if return_is_internal:
 490       return_type_java_data = self.LoadJavaClass(self._method_return)
 491
 492     if self._is_abstract:
 493       return ''
 494
 495     if self._class_java_data.HasCreateInternallyAnnotation():
 496       if no_return_value:
 497         template = Template(
 498             '    public void ${NAME}Super(${PARAMS}) {\n' +
 499             '        if (internal == null) {\n' +
 500             '            super.${NAME}(${PARAM_PASSING});\n' +
 501             '        } else {\n' +
 502             '            internal.${NAME}(${PARAM_PASSING});\n' +
 503             '        }\n' +
 504             '    }\n\n')
 505       else:
 506         template = Template(
 507             '    public ${RETURN_TYPE} ${NAME}Super(${PARAMS}) {\n' +
 508             '        ${INTERNAL_RETURN_TYPE} ret;\n' +
 509             '        if (internal == null) {\n' +
 510             '            ret = super.${NAME}(${PARAM_PASSING});\n' +
 511             '        } else {\n' +
 512             '            ret = internal.${NAME}(${PARAM_PASSING});\n' +
 513             '        }\n' +
 514             '        ${IF_NULL_RETURN_NULL}\n' +
 515             '        return ${RETURN_VALUE};\n' +
 516             '    }\n\n')
 517     else:
 518       if no_return_value:
 519         template = Template(
 520             '    public void ${NAME}Super(${PARAMS}) {\n' +
 521             '        super.${NAME}(${PARAM_PASSING});\n' +
 522             '    }\n\n')
 523       else:
 524         template = Template(
 525             '    public ${RETURN_TYPE} ${NAME}Super(${PARAMS}) {\n' +
 526             '        ${INTERNAL_RETURN_TYPE} ret;\n' +
 527             '        ret = super.${NAME}(${PARAM_PASSING});\n' +
 528             '        ${IF_NULL_RETURN_NULL}\n' +
 529             '        return ${RETURN_VALUE};\n' +
 530             '    }\n\n')
 531
 532     if return_is_internal:
 533       return_value = return_type_java_data.UseAsReturnInBridgeSuperCall('ret')
 534       method_return = return_type_java_data.bridge_name
 535     else:
 536       return_value = 'ret'
 537       method_return = self._method_return
 538
 539     if ConvertPrimitiveTypeToObject(method_return) != method_return:
 540       # it's returning prmitive type, so it can't be null.
 541       if_null_return_null = ''
 542     else:
 543       if_null_return_null = 'if (ret == null) return null;'
 544     value = {
 545         'RETURN_TYPE': method_return,
 546         'INTERNAL_RETURN_TYPE': self.method_return,
 547         'NAME': self.method_name,
 548         'PARAM_PASSING': self._bridge_params_pass_to_super,
 549         'PARAMS': self._bridge_params_declare,
 550         'IF_NULL_RETURN_NULL': if_null_return_null,
 551         'RETURN_VALUE': return_value
 552     }
 553
 554     return template.substitute(value)
 555
 556   def GenerateWrapperConstructor(self):
 557     # TODO(wang16): Currently, only support pre/post wrapper lines for
 558     # Constructors.
 559     template = Template(
 560         '${DOC}\n' +
 561         '    public ${CLASS_NAME}(${PARAMS}) {\n' +
 562         '${PRE_WRAP_LINES}\n' +
 563         '        bridge = ReflectionHelper.createInstance(' +
 564         '\"${CONSTRUCTOR_DECLARE_NAME}\"${PARAMS_PASSING}, this);\n' +
 565         '        try {\n' +
 566         '            reflectionInit();\n' +
 567         '        } catch(Exception e) {\n' +
 568         '            ReflectionHelper.handleException(e);\n' +
 569         '        }\n' +
 570         '${POST_WRAP_LINES}\n' +
 571         '    }\n\n')
 572     value = {'CLASS_NAME': self._class_java_data.wrapper_name,
 573              'DOC': self.GenerateDoc(self.method_doc),
 574              'PARAMS': self._wrapper_params_declare,
 575              'PARAMS_PASSING': self._wrapper_params_pass_to_bridge,
 576              'CONSTRUCTOR_DECLARE_NAME': self._method_declare_name,
 577              'PRE_WRAP_LINES': self._method_annotations.get(
 578                  self.ANNOTATION_PRE_WRAPLINE, ''),
 579              'POST_WRAP_LINES': self._method_annotations.get(
 580                  self.ANNOTATION_POST_WRAPLINE, '')}
 581     return template.substitute(value)
 582
 583   def GenerateWrapperStaticMethod(self):
 584     no_return_value = self._method_return == 'void'
 585     template = Template(
 586         '    public static ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 587         '       Class<?> clazz = ReflectionHelper.loadClass(' +
 588         '\"${FULL_BRIDGE_NAME}\");\n' +
 589         '       Method method = ReflectionHelper.loadMethod(clazz, ' +
 590         '\"${NAME}\"${PARAMS_DECLARE_FOR_BRIDGE});\n' +
 591         '       ${RETURN}ReflectionHelper.invokeMethod(method, null' +
 592         '${PARAMS_PASSING});\n' +
 593         '    }\n\n')
 594     if no_return_value:
 595       return_state = ''
 596     else:
 597       return_state = 'return (%s)' % ConvertPrimitiveTypeToObject(
 598           self.method_return)
 599     value = {'RETURN_TYPE': self.method_return,
 600              'NAME': self.method_name,
 601              'FULL_BRIDGE_NAME': self._class_java_data.GetFullBridgeName(),
 602              'PARAMS_DECLARE_FOR_BRIDGE':
 603                  self._wrapper_params_declare_for_bridge,
 604              'PARAMS_PASSING': self._wrapper_params_pass_to_bridge,
 605              'PARAMS': self._wrapper_params_declare,
 606              'RETURN': return_state}
 607     return template.substitute(value)
 608
 609   def GenerateWrapperBridgeMethod(self):
 610     no_return_value = self._method_return == 'void'
 611     return_is_internal = self.IsInternalClass(self._method_return)
 612     if return_is_internal:
 613       return_type_java_data = self.LoadJavaClass(self._method_return)
 614
 615     if self.is_abstract:
 616       template = Template(
 617           '${DOC}\n' +
 618           '    public abstract ${RETURN_TYPE} ${NAME}(${PARAMS});\n\n')
 619     elif return_is_internal:
 620       template = Template(
 621           '${DOC}\n' +
 622           '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 623           '        return (${RETURN_TYPE})ReflectionHelper.' +
 624           'getBridgeOrWrapper(\n' +
 625           '            ReflectionHelper.invokeMethod(' +
 626           '${METHOD_DECLARE_NAME}, bridge${PARAMS_PASSING}));\n' +
 627           '    }\n\n')
 628     else:
 629       template = Template(
 630           '${DOC}\n' +
 631           '    public ${RETURN_TYPE} ${NAME}(${PARAMS}) {\n' +
 632           '        ${RETURN}ReflectionHelper.invokeMethod(' +
 633           '${METHOD_DECLARE_NAME}, bridge${PARAMS_PASSING});\n' +
 634           '    }\n\n')
 635     if return_is_internal:
 636       return_type = return_type_java_data.wrapper_name
 637     else:
 638       return_type = self.method_return
 639     if no_return_value:
 640       return_state = ''
 641     else:
 642       return_state = 'return (%s)' % ConvertPrimitiveTypeToObject(return_type)
 643     value = {'RETURN_TYPE': return_type,
 644              'RETURN': return_state,
 645              'DOC': self.GenerateDoc(self.method_doc),
 646              'NAME': self.method_name,
 647              'PARAMS': re.sub(r'ValueCallback<([A-Za-z]+)Internal>',
 648                   r'ValueCallback<\1>',self._wrapper_params_declare),
 649              'METHOD_DECLARE_NAME': self._method_declare_name,
 650              'PARAMS_PASSING': self._wrapper_params_pass_to_bridge}
 651
 652     return template.substitute(value)
 653
 654   def GenerateWrapperInterface(self):
 655     return_is_internal = self.IsInternalClass(self._method_return)
 656     if return_is_internal:
 657       return_type_java_data = self.LoadJavaClass(self._method_return)
 658
 659     template = Template(
 660         '${DOC}\n' +
 661         '    public ${RETURN_TYPE} ${NAME}(${PARAMS});\n\n')
 662     if return_is_internal:
 663       return_type = return_type_java_data.wrapper_name
 664     else:
 665       return_type = self.method_return
 666     value = {'RETURN_TYPE': return_type,
 667              'DOC': self.GenerateDoc(self.method_doc),
 668              'NAME': self.method_name,
 669              'PARAMS': self._wrapper_params_declare}
 670     return template.substitute(value)
 671
 672   def GenerateMethodsStringForBridge(self):
 673     self.PrepareStrings()
 674     if self._is_constructor:
 675       return self.GenerateBridgeConstructor()
 676     elif self._is_static:
 677       return self.GenerateBridgeStaticMethod()
 678     else:
 679       return '%s%s%s%s' % (
 680           '    private Method %s;\n' % self._method_declare_name,
 681           self.GenerateBridgeOverrideMethod(),
 682           self.GenerateBridgeWrapperMethod(),
 683           self.GenerateBridgeSuperMethod())
 684
 685   def GenerateMethodsStringForWrapper(self):
 686     self.PrepareStrings()
 687     if self._is_constructor:
 688       return self.GenerateWrapperConstructor()
 689     elif self._is_static:
 690       return self.GenerateWrapperStaticMethod()
 691     elif self._is_abstract:
 692       return self.GenerateWrapperBridgeMethod()
 693     else:
 694       return '%s%s' % (
 695           '    private Method %s;\n' % self._method_declare_name,
 696           self.GenerateWrapperBridgeMethod())
 697
 698   def GenerateMethodsStringForInterface(self):
 699     self.PrepareStrings()
 700     return self.GenerateWrapperInterface()