build/config/android/internal_rules.gni

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import("//build/config/android/config.gni")
   6
   7 assert(is_android)
   8
   9
  10 rebased_android_sdk = rebase_path(android_sdk, root_build_dir)
  11 rebased_android_sdk_root = rebase_path(android_sdk_root, root_build_dir)
  12 rebased_android_sdk_build_tools = rebase_path(android_sdk_build_tools, root_build_dir)
  13
  14 android_sdk_jar = "$android_sdk/android.jar"
  15 rebased_android_sdk_jar = rebase_path(android_sdk_jar, root_build_dir)
  16
  17 template("android_lint") {
  18   if (defined(invoker.testonly)) { testonly = invoker.testonly }
  19
  20   jar_path = invoker.jar_path
  21   android_manifest = invoker.android_manifest
  22   java_files = invoker.java_files
  23   base_path = "$target_gen_dir/$target_name"
  24
  25   action(target_name) {
  26     script = "//build/android/gyp/lint.py"
  27     result_path = base_path + "/result.xml"
  28     config_path = base_path + "/config.xml"
  29     suppressions_file = "//build/android/lint/suppressions.xml"
  30     inputs = [
  31       suppressions_file,
  32       android_manifest,
  33       jar_path,
  34     ] + java_files
  35
  36     outputs = [
  37       config_path,
  38       result_path
  39     ]
  40
  41     rebased_java_files = rebase_path(java_files, root_build_dir)
  42
  43     args = [
  44       "--lint-path=$rebased_android_sdk_root/tools/lint",
  45       "--config-path", rebase_path(suppressions_file, root_build_dir),
  46       "--manifest-path", rebase_path(android_manifest, root_build_dir),
  47       "--product-dir=.",
  48       "--jar-path", rebase_path(jar_path, root_build_dir),
  49       "--processed-config-path", rebase_path(config_path, root_build_dir),
  50       "--result-path", rebase_path(result_path, root_build_dir),
  51       "--java-files=$rebased_java_files",
  52       "--enable",
  53     ]
  54   }
  55 }
  56
  57
  58 template("dex") {
  59   if (defined(invoker.testonly)) { testonly = invoker.testonly }
  60
  61   assert(defined(invoker.sources))
  62   assert(defined(invoker.output))
  63   action(target_name) {
  64     script = "//build/android/gyp/dex.py"
  65     depfile = "$target_gen_dir/$target_name.d"
  66     sources = invoker.sources
  67     outputs = [depfile, invoker.output]
  68     if (defined(invoker.inputs)) {
  69       inputs = invoker.inputs
  70     }
  71
  72     if (defined(invoker.deps)) {
  73       deps = invoker.deps
  74     }
  75
  76     rebased_output = rebase_path(invoker.output, root_build_dir)
  77
  78     args = [
  79       "--depfile", rebase_path(depfile, root_build_dir),
  80       "--android-sdk-tools", rebased_android_sdk_build_tools,
  81       "--dex-path", rebased_output,
  82     ]
  83
  84     if (defined(invoker.no_locals) && invoker.no_locals) {
  85       args += [
  86         "--no-locals=1"
  87       ]
  88     }
  89
  90     if (defined(invoker.args)) {
  91       args += invoker.args
  92     }
  93
  94     args += rebase_path(invoker.sources, root_build_dir)
  95   }
  96 }
  97
  98
  99 # Creates a zip archive of the inputs.
 100 # If base_dir is provided, the archive paths will be relative to it.
 101 template("zip") {
 102   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 103
 104   assert(defined(invoker.inputs))
 105   assert(defined(invoker.output))
 106
 107   rebase_inputs = rebase_path(invoker.inputs, root_build_dir)
 108   rebase_output = rebase_path(invoker.output, root_build_dir)
 109   action(target_name) {
 110     script = "//build/android/gn/zip.py"
 111     depfile = "$target_gen_dir/$target_name.d"
 112     inputs = invoker.inputs
 113     outputs = [
 114       depfile,
 115       invoker.output
 116     ]
 117     args = [
 118       "--depfile", rebase_path(depfile, root_build_dir),
 119       "--inputs=$rebase_inputs",
 120       "--output=$rebase_output",
 121     ]
 122     if (defined(invoker.base_dir)) {
 123       args += [
 124         "--base-dir", rebase_path(invoker.base_dir, root_build_dir)
 125       ]
 126     }
 127   }
 128 }
 129
 130
 131 # Write the target's .build_config file. This is a json file that contains a
 132 # dictionary of information about how to build this target (things that
 133 # require knowledge about this target's dependencies and cannot be calculated
 134 # at gn-time). There is a special syntax to add a value in that dictionary to
 135 # an action/action_foreachs args:
 136 #   --python-arg=@FileArg($rebased_build_config_path:key0:key1)
 137 # At runtime, such an arg will be replaced by the value in the build_config.
 138 # See build/android/gyp/write_build_config.py and
 139 # build/android/gyp/util/build_utils.py:ExpandFileArgs
 140 template("write_build_config") {
 141   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 142
 143   assert(defined(invoker.type))
 144   assert(defined(invoker.build_config))
 145
 146   type = invoker.type
 147   build_config = invoker.build_config
 148
 149   assert(type == "android_apk" || type == "java_library" || type == "android_resources")
 150
 151   action(target_name) {
 152     script = "//build/android/gyp/write_build_config.py"
 153     depfile = "$target_gen_dir/$target_name.d"
 154     inputs = []
 155
 156     deps = []
 157     if (defined(invoker.deps)) {
 158       deps += invoker.deps
 159     }
 160
 161     possible_deps_configs = []
 162     foreach(d, deps) {
 163       dep_gen_dir = get_label_info(d, "target_gen_dir")
 164       dep_name = get_label_info(d, "name")
 165       possible_deps_configs += [ "$dep_gen_dir/$dep_name.build_config" ]
 166     }
 167     rebase_possible_deps_configs = rebase_path(possible_deps_configs)
 168
 169     outputs = [
 170       depfile,
 171       build_config
 172     ]
 173
 174     args = [
 175       "--type", type,
 176       "--depfile", rebase_path(depfile, root_build_dir),
 177       "--possible-deps-configs=$rebase_possible_deps_configs",
 178       "--build-config", rebase_path(build_config, root_build_dir),
 179     ]
 180
 181     is_java_library = type == "java_library"
 182     is_apk = type == "android_apk"
 183     is_android_resources = type == "android_resources"
 184
 185     supports_android = (is_apk || is_android_resources ||
 186         (is_java_library && defined(invoker.supports_android) &&
 187          invoker.supports_android))
 188     requires_android = (is_apk || is_android_resources ||
 189         (is_java_library && defined(invoker.requires_android) &&
 190          invoker.requires_android))
 191
 192     assert(!requires_android || supports_android, "requires_android requires" +
 193         " supports_android")
 194     # Mark these variables as used.
 195     assert(is_java_library || true)
 196     assert(is_apk || true)
 197     assert(is_android_resources || true)
 198
 199     if (is_java_library || is_apk) {
 200       args += [
 201         "--jar-path", rebase_path(invoker.jar_path, root_build_dir),
 202       ]
 203     }
 204
 205     if (is_apk || (is_java_library && supports_android)) {
 206       args += [
 207         "--dex-path", rebase_path(invoker.dex_path, root_build_dir),
 208       ]
 209     }
 210     if (supports_android) {
 211       args += [ "--supports-android" ]
 212     }
 213     if (requires_android) {
 214       args += [ "--requires-android" ]
 215     }
 216
 217     if (is_android_resources || is_apk) {
 218       assert(defined(invoker.resources_zip))
 219       args += [
 220         "--resources-zip", rebase_path(invoker.resources_zip, root_build_dir),
 221       ]
 222       if (defined(invoker.android_manifest)) {
 223         inputs += [
 224           invoker.android_manifest
 225         ]
 226         args += [
 227           "--android-manifest", rebase_path(invoker.android_manifest, root_build_dir),
 228         ]
 229       }
 230       if (defined(invoker.custom_package)) {
 231         args += [
 232           "--package-name", invoker.custom_package
 233         ]
 234       }
 235     }
 236
 237     if (is_apk) {
 238       if (defined(invoker.native_libs)) {
 239         rebased_native_libs = rebase_path(invoker.native_libs, root_build_dir)
 240         rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
 241         args += [
 242           "--native-libs=$rebased_native_libs",
 243           "--readelf-path=$rebased_android_readelf",
 244         ]
 245       }
 246     }
 247
 248     if (defined(invoker.srcjar)) {
 249       args += [
 250         "--srcjar", rebase_path(invoker.srcjar, root_build_dir)
 251       ]
 252     }
 253   }
 254 }
 255
 256
 257 template("process_java_prebuilt") {
 258   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 259
 260   _input_jar_path = invoker.input_jar_path
 261   _output_jar_path = invoker.output_jar_path
 262   _jar_toc_path = _output_jar_path + ".TOC"
 263
 264   assert(invoker.build_config != "")
 265
 266   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 267     _proguard_jar_path = "$android_sdk_root/tools/proguard/lib/proguard.jar"
 268     _proguard_config_path = invoker.proguard_config
 269     _build_config = invoker.build_config
 270     _rebased_build_config = rebase_path(_build_config, root_build_dir)
 271     action("${target_name}__proguard_process") {
 272       script = "//build/android/gyp/proguard.py"
 273       inputs = [
 274         android_sdk_jar,
 275         _proguard_jar_path,
 276         _build_config,
 277         _input_jar_path,
 278         _proguard_config_path,
 279       ]
 280       depfile = "${target_gen_dir}/${target_name}.d"
 281       outputs = [
 282         depfile,
 283         _output_jar_path,
 284       ]
 285       args = [
 286         "--depfile", rebase_path(depfile, root_build_dir),
 287         "--proguard-path", rebase_path(_proguard_jar_path, root_build_dir),
 288         "--input-path", rebase_path(_input_jar_path, root_build_dir),
 289         "--output-path", rebase_path(_output_jar_path, root_build_dir),
 290         "--proguard-config", rebase_path(_proguard_config_path, root_build_dir),
 291         "--classpath", rebased_android_sdk_jar,
 292         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 293       ]
 294     }
 295   } else {
 296     copy("${target_name}__copy_jar") {
 297       sources = [_input_jar_path]
 298       outputs = [_output_jar_path]
 299     }
 300   }
 301
 302   action("${target_name}__jar_toc") {
 303     script = "//build/android/gyp/jar_toc.py"
 304     depfile = "$target_gen_dir/$target_name.d"
 305     outputs = [
 306       depfile,
 307       _jar_toc_path,
 308       _jar_toc_path + ".md5.stamp"
 309     ]
 310     inputs = [ _output_jar_path ]
 311     args = [
 312       "--depfile", rebase_path(depfile, root_build_dir),
 313       "--jar-path", rebase_path(_output_jar_path, root_build_dir),
 314       "--toc-path", rebase_path(_jar_toc_path, root_build_dir),
 315     ]
 316   }
 317
 318   group(target_name) {
 319     deps = [
 320       ":${target_name}__jar_toc"
 321     ]
 322   }
 323 }
 324
 325
 326 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 327 # zipaligns the apk.
 328 template("create_apk") {
 329   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 330
 331   _android_manifest = invoker.android_manifest
 332   _base_path = invoker.base_path
 333   _final_apk_path = invoker.apk_path
 334   _resources_zip = invoker.resources_zip
 335   _dex_path = invoker.dex_path
 336   _keystore_path = invoker.keystore_path
 337   _keystore_name = invoker.keystore_name
 338   _keystore_password = invoker.keystore_password
 339   _load_library_from_apk = invoker.load_library_from_apk
 340
 341   _deps = []
 342   if (defined(invoker.deps)) {
 343     _deps = invoker.deps
 344   }
 345
 346   _native_libs_dir = "//build/android/empty/res"
 347   if (defined(invoker.native_libs_dir)) {
 348       _native_libs_dir = invoker.native_libs_dir
 349   }
 350
 351   _asset_location = "//build/android/empty/res"
 352   if (defined(invoker.asset_location)) {
 353     _asset_location = invoker.asset_location
 354   }
 355
 356   _version_code = invoker.version_code
 357   _version_name = invoker.version_name
 358
 359   _base_apk_path = _base_path + ".apk_intermediates"
 360
 361   _resource_packaged_apk_path = _base_apk_path + ".ap_"
 362   _packaged_apk_path = _base_apk_path + ".unfinished.apk"
 363   _shared_resources = defined(invoker.shared_resources) && invoker.shared_resources
 364
 365
 366   _configuration_name = "Release"
 367   if (is_debug) {
 368     _configuration_name = "Debug"
 369   }
 370
 371   action("${target_name}__package_resources") {
 372     deps = _deps
 373
 374     script = "//build/android/gyp/package_resources.py"
 375     depfile = "${target_gen_dir}/${target_name}.d"
 376     inputs = [
 377       _android_manifest,
 378       _resources_zip,
 379     ]
 380     outputs = [depfile, _resource_packaged_apk_path]
 381
 382     _rebased_resources_zips = [rebase_path(_resources_zip, root_build_dir)]
 383     args = [
 384         "--depfile", rebase_path(depfile, root_build_dir),
 385         "--android-sdk", rebased_android_sdk,
 386         "--android-sdk-tools", rebased_android_sdk_build_tools,
 387
 388         "--configuration-name=$_configuration_name",
 389
 390         "--android-manifest", rebase_path(_android_manifest, root_build_dir),
 391         "--version-code", _version_code,
 392         "--version-name", _version_name,
 393
 394         "--asset-dir", rebase_path(_asset_location, root_build_dir),
 395         "--resource-zips=$_rebased_resources_zips",
 396
 397         "--apk-path", rebase_path(_resource_packaged_apk_path, root_build_dir),
 398       ]
 399
 400     if (_shared_resources) {
 401       args += ["--shared-resources"]
 402     }
 403   }
 404
 405   action("${target_name}__package") {
 406     script = "//build/android/gyp/ant.py"
 407     _ant_script = "//build/android/ant/apk-package.xml"
 408
 409     depfile = "$target_gen_dir/$target_name.d"
 410
 411     inputs = [
 412       _dex_path,
 413       _resource_packaged_apk_path,
 414       _ant_script
 415     ]
 416
 417     outputs = [
 418       depfile,
 419       _packaged_apk_path,
 420     ]
 421
 422     _rebased_emma_jar = ""
 423     _rebased_resource_packaged_apk_path = rebase_path(
 424         _resource_packaged_apk_path, root_build_dir)
 425     _rebased_packaged_apk_path = rebase_path(_packaged_apk_path, root_build_dir)
 426     _rebased_native_libs_dir = rebase_path(_native_libs_dir, root_build_dir)
 427     _rebased_dex_path = rebase_path(_dex_path, root_build_dir)
 428     args = [
 429       "--depfile", rebase_path(depfile, root_build_dir),
 430       "--",
 431       "-quiet",
 432       "-DANDROID_SDK_ROOT=$rebased_android_sdk_root",
 433       "-DANDROID_SDK_TOOLS=$rebased_android_sdk_build_tools",
 434       "-DRESOURCE_PACKAGED_APK_NAME=$_rebased_resource_packaged_apk_path",
 435       "-DCONFIGURATION_NAME=$_configuration_name",
 436       "-DNATIVE_LIBS_DIR=$_rebased_native_libs_dir",
 437       "-DOUT_DIR=",
 438       "-DUNSIGNED_APK_PATH=$_rebased_packaged_apk_path",
 439       "-DEMMA_INSTRUMENT=0",
 440       "-DEMMA_DEVICE_JAR=$_rebased_emma_jar",
 441       "-DDEX_FILE_PATH=$_rebased_dex_path",
 442
 443       "-Dbasedir=.",
 444       "-buildfile", rebase_path(_ant_script, root_build_dir)
 445     ]
 446   }
 447
 448   action("${target_name}__finalize") {
 449     script = "//build/android/gyp/finalize_apk.py"
 450     depfile = "$target_gen_dir/$target_name.d"
 451
 452     sources = [_packaged_apk_path]
 453     inputs = [_keystore_path]
 454     outputs = [depfile, _final_apk_path]
 455
 456     args = [
 457       "--depfile", rebase_path(depfile, root_build_dir),
 458       "--zipalign-path", rebase_path(zipalign_path, root_build_dir),
 459       "--unsigned-apk-path", rebase_path(_packaged_apk_path, root_build_dir),
 460       "--final-apk-path", rebase_path(_final_apk_path, root_build_dir),
 461       "--key-path", rebase_path(_keystore_path, root_build_dir),
 462       "--key-name", _keystore_name,
 463       "--key-passwd", _keystore_password,
 464     ]
 465     if (_load_library_from_apk) {
 466       _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
 467       inputs += [
 468         _rezip_jar_path
 469       ]
 470       args += [
 471         "--load-library-from-zip-file=1",
 472         "--rezip-apk-jar-path", rebase_path(_rezip_jar_path, root_build_dir)
 473       ]
 474     }
 475   }
 476
 477   group(target_name) {
 478     deps = [":${target_name}__finalize"]
 479   }
 480 }
 481
 482 template("java_prebuilt_impl") {
 483   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 484   _supports_android = (
 485       defined(invoker.supports_android) && invoker.supports_android)
 486
 487   assert(defined(invoker.jar_path))
 488   _base_path = "${target_gen_dir}/$target_name"
 489   _jar_path = _base_path + ".jar"
 490   _build_config = _base_path + ".build_config"
 491
 492   if (_supports_android) {
 493     _dex_path = _base_path + ".dex.jar"
 494   }
 495
 496   _final_deps = []
 497   _template_name = target_name
 498
 499
 500   _final_deps += [ ":${_template_name}__build_config" ]
 501   write_build_config("${_template_name}__build_config") {
 502     type = "java_library"
 503     supports_android = _supports_android
 504     requires_android = (defined(invoker.requires_android) &&
 505         invoker.requires_android)
 506
 507     deps = []
 508     if (defined(invoker.deps)) {
 509       deps += invoker.deps
 510     }
 511     build_config = _build_config
 512     jar_path = _jar_path
 513     if (_supports_android) {
 514       dex_path = _dex_path
 515     }
 516   }
 517
 518   _final_deps += [ ":${_template_name}__process_jar" ]
 519   process_java_prebuilt("${_template_name}__process_jar") {
 520     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 521       proguard_preprocess = true
 522       proguard_config = invoker.proguard_config
 523     }
 524
 525     build_config = _build_config
 526     input_jar_path = invoker.jar_path
 527     output_jar_path = _jar_path
 528   }
 529
 530   if (_supports_android) {
 531     _final_deps += [ ":${_template_name}__dex" ]
 532     dex("${_template_name}__dex") {
 533       sources = [_jar_path]
 534       output = _dex_path
 535     }
 536   }
 537
 538   group(target_name) {
 539     deps = _final_deps
 540   }
 541 }
 542
 543
 544 # Compiles and jars a set of java files.
 545 #
 546 # Outputs:
 547 #  $jar_path.jar
 548 #  $jar_path.jar.TOC
 549 #
 550 # Variables
 551 #   java_files: List of .java files to compile.
 552 #   java_deps: List of java dependencies. These should all have a .jar output
 553 #     at "${target_gen_dir}/${target_name}.jar.
 554 #   chromium_code: If true, enable extra warnings.
 555 #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
 556 #     dependencies srcjar outputs will be compiled and added to the output jar.
 557 #   jar_path: Use this to explicitly set the output jar path. Defaults to
 558 #     "${target_gen_dir}/${target_name}.jar.
 559 template("compile_java") {
 560   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 561
 562   assert(defined(invoker.java_files))
 563   assert(defined(invoker.build_config))
 564   assert(defined(invoker.jar_path))
 565
 566   _java_files = invoker.java_files
 567   _final_jar_path = invoker.jar_path
 568   _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
 569
 570   _build_config = invoker.build_config
 571
 572   _jar_excluded_patterns = []
 573   if (defined(invoker.jar_excluded_patterns)) {
 574     _jar_excluded_patterns += invoker.jar_excluded_patterns
 575   }
 576
 577   _chromium_code = false
 578   if (defined(invoker.chromium_code)) {
 579     _chromium_code = invoker.chromium_code
 580   }
 581
 582   _srcjar_deps = []
 583   if (defined(invoker.srcjar_deps)) {
 584     _srcjar_deps += invoker.srcjar_deps
 585   }
 586
 587   _java_srcjars = []
 588   if (defined(invoker.srcjars)) {
 589     _java_srcjars = invoker.srcjars
 590   }
 591   foreach(dep, _srcjar_deps) {
 592     _dep_gen_dir = get_label_info(dep, "target_gen_dir")
 593     _dep_name = get_label_info(dep, "name")
 594     _java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
 595   }
 596   # Mark srcjar_deps as used.
 597   assert(_srcjar_deps == [] || true)
 598
 599   _system_jars = []
 600   if (defined(invoker.android) && invoker.android) {
 601     _system_jars += [ android_sdk_jar ]
 602   }
 603
 604   _rebased_build_config = rebase_path(_build_config, root_build_dir)
 605   _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
 606
 607   _template_name = target_name
 608   _final_deps = [ ":${_template_name}__javac" ]
 609   action("${_template_name}__javac") {
 610     script = "//build/android/gyp/javac.py"
 611     depfile = "$target_gen_dir/$target_name.d"
 612     deps = []
 613     outputs = [
 614       depfile,
 615       _intermediate_jar_path,
 616       _intermediate_jar_path + ".md5.stamp"
 617     ]
 618     sources = _java_files + _java_srcjars
 619     inputs = _system_jars + [ _build_config ]
 620
 621     _rebased_system_jars = rebase_path(_system_jars, root_build_dir)
 622     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
 623     _rebased_depfile = rebase_path(depfile, root_build_dir)
 624     args = [
 625       "--depfile=$_rebased_depfile",
 626       "--classpath=$_rebased_system_jars",
 627       "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 628       "--jar-path=$_rebased_jar_path",
 629       "--java-srcjars=$_rebased_java_srcjars",
 630       "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
 631       "--jar-excluded-classes=$_jar_excluded_patterns",
 632     ]
 633     if (_chromium_code) {
 634       args += [ "--chromium-code=1" ]
 635     }
 636
 637     if (defined(invoker.main_class)) {
 638       args += [
 639         "--main-class", invoker.main_class
 640       ]
 641     }
 642
 643     args += rebase_path(_java_files, root_build_dir)
 644   }
 645
 646   _final_deps += [ ":${_template_name}__finish" ]
 647   process_java_prebuilt("${_template_name}__finish") {
 648     build_config = _build_config
 649     input_jar_path = _intermediate_jar_path
 650     output_jar_path = _final_jar_path
 651     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 652       proguard_preprocess = invoker.proguard_preprocess
 653       proguard_config = invoker.proguard_config
 654     }
 655   }
 656
 657   group(target_name) {
 658     deps = _final_deps
 659   }
 660 }
 661
 662
 663 template("java_library_impl") {
 664   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 665
 666   assert(defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir)
 667       || defined(invoker.srcjars) || defined(invoker.srcjar_deps))
 668   _base_path = "$target_gen_dir/$target_name"
 669   _jar_path = _base_path + ".jar"
 670   if (defined(invoker.jar_path)) {
 671     _jar_path = invoker.jar_path
 672   }
 673   _template_name = target_name
 674
 675   _final_deps = []
 676   _final_datadeps = []
 677   if (defined(invoker.datadeps)) {
 678     _final_datadeps = invoker.datadeps
 679   }
 680
 681   _supports_android = (defined(invoker.supports_android) &&
 682     invoker.supports_android)
 683   _requires_android = (defined(invoker.requires_android) &&
 684     invoker.requires_android)
 685
 686   if (_supports_android) {
 687     _dex_path = _base_path + ".dex.jar"
 688     if (defined(invoker.dex_path)) {
 689       _dex_path = invoker.dex_path
 690     }
 691   }
 692
 693   if (defined(invoker.override_build_config)) {
 694     _build_config = invoker.override_build_config
 695   } else {
 696     _build_config = _base_path + ".build_config"
 697     _final_deps += [ ":${_template_name}__build_config" ]
 698     write_build_config("${_template_name}__build_config") {
 699       type = "java_library"
 700       supports_android = _supports_android
 701       requires_android = _requires_android
 702
 703       deps = []
 704       if (defined(invoker.deps)) {
 705         deps += invoker.deps
 706       }
 707
 708       build_config = _build_config
 709       jar_path = _jar_path
 710       if (_supports_android) {
 711         dex_path = _dex_path
 712       }
 713     }
 714   }
 715
 716   _chromium_code = true
 717   if (defined(invoker.chromium_code)) {
 718     _chromium_code = invoker.chromium_code
 719   }
 720
 721   _srcjar_deps = []
 722   if (defined(invoker.srcjar_deps)) {
 723     _srcjar_deps = invoker.srcjar_deps
 724   }
 725
 726   _srcjars = []
 727   if (defined(invoker.srcjars)) {
 728     _srcjars = invoker.srcjars
 729   }
 730
 731   _java_files = []
 732   if (defined(invoker.java_files)) {
 733     _java_files = invoker.java_files
 734   } else if (defined(invoker.DEPRECATED_java_in_dir)) {
 735     _src_dir = invoker.DEPRECATED_java_in_dir + "/src"
 736     _src_dir_exists = exec_script("//build/dir_exists.py",
 737           [ rebase_path(_src_dir, root_build_dir) ],
 738           "string")
 739     assert(_src_dir_exists == "False",
 740         "In GN, java_in_dir should be the fully specified java directory " +
 741         "(i.e. including the trailing \"/src\")")
 742
 743     _java_files_build_rel = exec_script(
 744         "//build/android/gyp/find.py",
 745         [
 746           "--pattern",
 747           "*.java",
 748           rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir)
 749         ],
 750         "list lines"
 751         )
 752     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
 753   }
 754   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 755
 756   _final_deps += [ ":${_template_name}__compile_java" ]
 757   compile_java("${_template_name}__compile_java") {
 758     jar_path = _jar_path
 759     build_config = _build_config
 760     java_files = _java_files
 761     srcjar_deps = _srcjar_deps
 762     srcjars = _srcjars
 763     chromium_code = _chromium_code
 764     android = _requires_android
 765
 766     if (defined(invoker.jar_excluded_patterns)) { jar_excluded_patterns = invoker.jar_excluded_patterns }
 767     if (defined(invoker.main_class)) { main_class = invoker.main_class }
 768     if (defined(invoker.proguard_preprocess)) { proguard_preprocess = invoker.proguard_preprocess }
 769     if (defined(invoker.proguard_config)) { proguard_config = invoker.proguard_config }
 770     if (defined(invoker.dist_jar_path)) { dist_jar_path = invoker.dist_jar_path }
 771   }
 772
 773   if (defined(invoker.main_class)) {
 774     _final_deps += [ ":${_template_name}__binary_script" ]
 775     action("${_template_name}__binary_script") {
 776       script = "//build/android/gyp/create_java_binary_script.py"
 777       depfile = "$target_gen_dir/$target_name.d"
 778       java_script = "$root_build_dir/bin/$_template_name"
 779       inputs = [ _build_config ]
 780       outputs = [
 781         depfile,
 782         java_script,
 783       ]
 784       _rebased_build_config = rebase_path(_build_config, root_build_dir)
 785       args = [
 786         "--depfile", rebase_path(depfile, root_build_dir),
 787         "--output", rebase_path(java_script, root_build_dir),
 788         "--classpath=@FileArg($_rebased_build_config:java:full_classpath)",
 789         "--jar-path", rebase_path(_jar_path, root_build_dir),
 790         "--main-class", invoker.main_class,
 791       ]
 792     }
 793   }
 794
 795   if (_supports_android) {
 796     if (defined(invoker.chromium_code) && invoker.chromium_code) {
 797       _android_manifest = "//build/android/AndroidManifest.xml"
 798       if (defined(invoker.android_manifest)) {
 799         _android_manifest = invoker.android_manifest
 800       }
 801
 802       _final_datadeps += [ ":${_template_name}__lint" ]
 803       android_lint("${_template_name}__lint") {
 804         android_manifest = _android_manifest
 805         jar_path = _jar_path
 806         java_files = _java_files
 807       }
 808     }
 809
 810     _final_deps += [ ":${_template_name}__dex" ]
 811     dex("${_template_name}__dex") {
 812       sources = [_jar_path]
 813       output = _dex_path
 814     }
 815   }
 816
 817   group(target_name) {
 818     deps = _final_deps
 819     datadeps = _final_datadeps
 820   }
 821 }
 822
 823
 824 # Runs process_resources.py
 825 template("process_resources") {
 826   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 827
 828   zip_path = invoker.zip_path
 829   srcjar_path = invoker.srcjar_path
 830   build_config = invoker.build_config
 831   resource_dirs = invoker.resource_dirs
 832   android_manifest = invoker.android_manifest
 833
 834   non_constant_id = true
 835   if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
 836     non_constant_id = false
 837   }
 838
 839   action(target_name) {
 840     script = "//build/android/gyp/process_resources.py"
 841
 842     depfile = "$target_gen_dir/$target_name.d"
 843     outputs = [
 844       depfile,
 845       zip_path,
 846       srcjar_path,
 847     ]
 848
 849     sources_build_rel = exec_script(
 850         "//build/android/gyp/find.py",
 851         rebase_path(resource_dirs, root_build_dir),
 852         "list lines"
 853         )
 854     sources = rebase_path(sources_build_rel, ".", root_build_dir)
 855
 856     inputs = [
 857       build_config,
 858       android_manifest,
 859     ]
 860
 861     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
 862     rebase_build_config = rebase_path(build_config, root_build_dir)
 863     args = [
 864       "--depfile", rebase_path(depfile, root_build_dir),
 865       "--android-sdk", rebase_path(android_sdk, root_build_dir),
 866       "--android-sdk-tools", rebase_path(android_sdk_build_tools, root_build_dir),
 867       "--android-manifest", rebase_path(android_manifest, root_build_dir),
 868
 869       "--resource-dirs=$rebase_resource_dirs",
 870       "--srcjar-out", rebase_path(srcjar_path, root_build_dir),
 871       "--resource-zip-out", rebase_path(zip_path, root_build_dir),
 872
 873       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
 874       "--extra-res-packages=@FileArg($rebase_build_config:resources:extra_package_names)",
 875     ]
 876
 877     if (non_constant_id) {
 878       args += [ "--non-constant-id" ]
 879     }
 880
 881     if (defined(invoker.custom_package)) {
 882       args += [
 883         "--custom-package", invoker.custom_package,
 884       ]
 885     }
 886
 887     if (defined(invoker.v14_verify_only) && invoker.v14_verify_only) {
 888       args += ["--v14-verify-only"]
 889     }
 890
 891     if (defined(invoker.shared_resources) &&
 892         invoker.shared_resources) {
 893       args += ["--shared-resources"]
 894     }
 895
 896     if (defined(invoker.all_resources_zip_path)) {
 897       all_resources_zip = invoker.all_resources_zip_path
 898       outputs += [ all_resources_zip ]
 899       args += [
 900         "--all-resources-zip-out", rebase_path(all_resources_zip, root_build_dir)
 901       ]
 902     }
 903
 904     if (defined(invoker.args)) {
 905       args += invoker.args
 906     }
 907   }
 908 }
 909
 910 template("copy_ex") {
 911   if (defined(invoker.testonly)) { testonly = invoker.testonly }
 912
 913   action(target_name) {
 914     script = "//build/android/gyp/copy_ex.py"
 915
 916     if (defined(invoker.deps)) { deps = invoker.deps }
 917
 918     sources = []
 919     if (defined(invoker.sources)) {
 920       sources += invoker.sources
 921     }
 922
 923     inputs = []
 924     if (defined(invoker.inputs)) {
 925       inputs += invoker.inputs
 926     }
 927
 928     depfile = "$target_gen_dir/$target_name.d"
 929     outputs = [
 930       depfile,
 931     ]
 932
 933     args = [
 934       "--depfile", rebase_path(depfile, root_build_dir),
 935       "--dest", rebase_path(invoker.dest, root_build_dir),
 936     ]
 937     rebased_sources = rebase_path(sources, root_build_dir)
 938     args += [ "--files=$rebased_sources" ]
 939
 940     if (defined(invoker.clear_dir) && invoker.clear_dir) {
 941       args += ["--clear"]
 942     }
 943
 944     if (defined(invoker.args)) {
 945       args += invoker.args
 946     }
 947   }
 948 }