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 import("//build/config/android/internal_rules.gni") 7 import("//tools/grit/grit_rule.gni") 8 9 assert(is_android) 10 11 12 # Declare a jni target 13 # 14 # This target generates the native jni bindings for a set of .java files. 15 # 16 # See base/android/jni_generator/jni_generator.py for more info about the 17 # format of generating JNI bindings. 18 # 19 # Variables 20 # sources: list of .java files to generate jni for 21 # jni_package: subdirectory path for generated bindings 22 # 23 # Example 24 # generate_jni("foo_jni") { 25 # sources = [ 26 # "android/java/src/org/chromium/foo/Foo.java", 27 # "android/java/src/org/chromium/foo/FooUtil.java", 28 # ] 29 # jni_package = "foo" 30 # } 31 template("generate_jni") { 32 if (defined(invoker.testonly)) { testonly = invoker.testonly } 33 34 assert(defined(invoker.sources)) 35 assert(defined(invoker.jni_package)) 36 jni_package = invoker.jni_package 37 base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}" 38 jni_output_dir = "${base_output_dir}/jni" 39 40 jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h" 41 42 foreach_target_name = "${target_name}__jni_gen" 43 action_foreach(foreach_target_name) { 44 script = "//base/android/jni_generator/jni_generator.py" 45 depfile = "$target_gen_dir/$target_name.{{source_name_part}}.d" 46 sources = invoker.sources 47 inputs = [ jni_generator_include ] 48 outputs = [ 49 depfile, 50 "${jni_output_dir}/{{source_name_part}}_jni.h" 51 ] 52 53 args = [ 54 "--depfile", rebase_path(depfile, root_build_dir), 55 "--input_file={{source}}", 56 "--optimize_generation=1", 57 "--ptr_type=long", 58 "--output_dir", rebase_path(jni_output_dir, root_build_dir), 59 "--includes", rebase_path(jni_generator_include, "//"), 60 ] 61 if (defined(invoker.jni_generator_jarjar_file)) { 62 args += [ 63 "--jarjar", rebase_path(jni_generator_jarjar_file, root_build_dir), 64 ] 65 } 66 } 67 68 config("jni_includes_${target_name}") { 69 include_dirs = [ base_output_dir ] 70 } 71 72 group(target_name) { 73 deps = [ ":$foreach_target_name" ] 74 public_configs = [ ":jni_includes_${target_name}" ] 75 76 if (defined(invoker.deps)) { 77 deps += invoker.deps 78 } 79 if (defined(invoker.public_deps)) { 80 public_deps = invoker.public_deps 81 } 82 } 83 } 84 85 86 # Declare a jni target for a prebuilt jar 87 # 88 # This target generates the native jni bindings for a set of classes in a .jar. 89 # 90 # See base/android/jni_generator/jni_generator.py for more info about the 91 # format of generating JNI bindings. 92 # 93 # Variables 94 # classes: list of .class files in the jar to generate jni for. These should 95 # include the full path to the .class file. 96 # jni_package: subdirectory path for generated bindings 97 # jar_file: the path to the .jar. If not provided, will default to the sdk's 98 # android.jar 99 # 100 # deps, public_deps: As normal 101 # 102 # Example 103 # generate_jar_jni("foo_jni") { 104 # classes = [ 105 # "android/view/Foo.class", 106 # ] 107 # jni_package = "foo" 108 # } 109 template("generate_jar_jni") { 110 if (defined(invoker.testonly)) { testonly = invoker.testonly } 111 112 assert(defined(invoker.classes)) 113 assert(defined(invoker.jni_package)) 114 115 if (defined(invoker.jar_file)) { 116 jar_file = invoker.jar_file 117 } else { 118 jar_file = android_sdk_jar 119 } 120 121 jni_package = invoker.jni_package 122 base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}" 123 jni_output_dir = "${base_output_dir}/jni" 124 125 jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h" 126 127 # TODO(cjhopman): make jni_generator.py support generating jni for multiple 128 # .class files from a .jar. 129 jni_actions = [] 130 foreach(class, invoker.classes) { 131 _classname_list = [] 132 _classname_list = process_file_template( 133 [class], "{{source_name_part}}") 134 classname = _classname_list[0] 135 jni_target_name = "${target_name}__jni_${classname}" 136 jni_actions += [ ":$jni_target_name" ] 137 action(jni_target_name) { 138 depfile = "$target_gen_dir/$target_name.d" 139 script = "//base/android/jni_generator/jni_generator.py" 140 sources = [ 141 jni_generator_include, 142 jar_file, 143 ] 144 outputs = [ 145 depfile, 146 "${jni_output_dir}/${classname}_jni.h" 147 ] 148 149 args = [ 150 "--depfile", rebase_path(depfile, root_build_dir), 151 "--jar_file", rebase_path(jar_file, root_build_dir), 152 "--input_file", class, 153 "--optimize_generation=1", 154 "--ptr_type=long", 155 "--output_dir", rebase_path(jni_output_dir, root_build_dir), 156 "--includes", rebase_path(jni_generator_include, root_build_dir), 157 ] 158 } 159 } 160 161 config("jni_includes_${target_name}") { 162 include_dirs = [ base_output_dir ] 163 } 164 165 group(target_name) { 166 deps = jni_actions 167 if (defined(invoker.deps)) { 168 deps += invoker.deps 169 } 170 if (defined(invoker.public_deps)) { 171 public_deps = invoker.public_deps 172 } 173 public_configs = [ ":jni_includes_${target_name}" ] 174 } 175 } 176 177 178 # Declare a target for c-preprocessor-generated java files 179 # 180 # This target generates java files using the host C pre-processor. Each file in 181 # sources will be compiled using the C pre-processor. If include_path is 182 # specified, it will be passed (with --I) to the pre-processor. 183 # 184 # This target will create a single .srcjar. Adding this target to an 185 # android_library target's srcjar_deps will make the generated java files be 186 # included in that library's final outputs. 187 # 188 # Variables 189 # sources: list of files to be processed by the C pre-processor. For each 190 # file in sources, there will be one .java file in the final .srcjar. For a 191 # file named FooBar.template, a java file will be created with name 192 # FooBar.java. 193 # inputs: additional compile-time dependencies. Any files 194 # `#include`-ed in the templates should be listed here. 195 # package_name: this will be the subdirectory for each .java file in the 196 # .srcjar. 197 # 198 # Example 199 # java_cpp_template("foo_generated_enum") { 200 # sources = [ 201 # "android/java/templates/Foo.template", 202 # ] 203 # inputs = [ 204 # "android/java/templates/native_foo_header.h", 205 # ] 206 # 207 # package_name = "org/chromium/base/library_loader" 208 # include_path = "android/java/templates" 209 # } 210 template("java_cpp_template") { 211 if (defined(invoker.testonly)) { testonly = invoker.testonly } 212 213 assert(defined(invoker.sources)) 214 package_name = invoker.package_name + "" 215 216 if (defined(invoker.include_path)) { 217 include_path = invoker.include_path + "" 218 } else { 219 include_path = "//" 220 } 221 222 action_foreach("${target_name}__apply_gcc") { 223 script = "//build/android/gyp/gcc_preprocess.py" 224 if (defined(invoker.inputs)) { 225 inputs = invoker.inputs + [] 226 } 227 depfile = "${target_gen_dir}/${target_name}_{{source_name_part}}.d" 228 229 sources = invoker.sources 230 231 gen_dir = "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}" 232 gcc_template_output_pattern = "${gen_dir}/{{source_name_part}}.java" 233 234 outputs = [ 235 depfile, 236 gcc_template_output_pattern 237 ] 238 239 args = [ 240 "--depfile", rebase_path(depfile, root_build_dir), 241 "--include-path", rebase_path(include_path, root_build_dir), 242 "--output", rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java", 243 "--template={{source}}", 244 ] 245 246 if (defined(invoker.defines)) { 247 foreach(def, invoker.defines) { 248 args += ["--defines", def] 249 } 250 } 251 } 252 253 apply_gcc_outputs = get_target_outputs(":${target_name}__apply_gcc") 254 base_gen_dir = get_label_info(":${target_name}__apply_gcc", "target_gen_dir") 255 256 srcjar_path = "${target_gen_dir}/${target_name}.srcjar" 257 zip("${target_name}__zip_srcjar") { 258 inputs = apply_gcc_outputs 259 output = srcjar_path 260 base_dir = base_gen_dir 261 } 262 263 group(target_name) { 264 deps = [ 265 ":${target_name}__zip_srcjar" 266 ] 267 } 268 } 269 270 # Declare a target for generating Java classes from C++ enums. 271 # 272 # This target generates Java files from C++ enums using a script. 273 # 274 # This target will create a single .srcjar. Adding this target to an 275 # android_library target's srcjar_deps will make the generated java files be 276 # included in that library's final outputs. 277 # 278 # Variables 279 # sources: list of files to be processed by the script. For each annotated 280 # enum contained in the sources files the script will generate a .java 281 # file with the same name as the name of the enum. 282 # 283 # outputs: list of outputs, relative to the output_dir. These paths are 284 # verified at build time by the script. To get the list programatically run: 285 # python build/android/gyp/java_cpp_enum.py --output_dir=. \ 286 # --print_output_only path/to/header/file.h 287 # 288 # Example 289 # java_cpp_enum("foo_generated_enum") { 290 # sources = [ 291 # "src/native_foo_header.h", 292 # ] 293 # outputs = [ 294 # "org/chromium/FooEnum.java", 295 # ] 296 # } 297 template("java_cpp_enum") { 298 if (defined(invoker.testonly)) { testonly = invoker.testonly } 299 300 assert(defined(invoker.sources)) 301 assert(defined(invoker.outputs)) 302 303 action("${target_name}__generate_enum") { 304 sources = rebase_path(invoker.sources, root_build_dir) 305 script = "//build/android/gyp/java_cpp_enum.py" 306 gen_dir = "${target_gen_dir}/${target_name}/enums" 307 outputs = get_path_info( 308 rebase_path(invoker.outputs, ".", gen_dir), "abspath") 309 310 args = [ 311 "--output_dir", rebase_path(gen_dir, root_build_dir), 312 ] 313 foreach(output, rebase_path(outputs, root_build_dir)) { 314 args += ["--assert_file", output] 315 } 316 args += sources 317 } 318 319 generate_enum_outputs = get_target_outputs(":${target_name}__generate_enum") 320 base_gen_dir = get_label_info(":${target_name}__generate_enum", 321 "target_gen_dir") 322 323 srcjar_path = "${target_gen_dir}/${target_name}.srcjar" 324 zip("${target_name}__zip_srcjar") { 325 inputs = generate_enum_outputs 326 output = srcjar_path 327 base_dir = base_gen_dir 328 } 329 330 group(target_name) { 331 deps = [ 332 ":${target_name}__zip_srcjar" 333 ] 334 } 335 } 336 337 338 # Declare an Android resources target 339 # 340 # This creates a resources zip file that will be used when building an Android 341 # library or apk and included into a final apk. 342 # 343 # To include these resources in a library/apk, this target should be listed in 344 # the library's deps. A library/apk will also include any resources used by its 345 # own dependencies. 346 # 347 # Variables 348 # deps: Specifies the dependencies of this target. Any Android resources 349 # listed in deps will be included by libraries/apks that depend on this 350 # target. 351 # resource_dirs: List of directories containing resources for this target. 352 # android_manifest: AndroidManifest.xml for this target. Defaults to 353 # //build/android/AndroidManifest.xml. 354 # custom_package: java package for generated .java files. 355 # v14_verify_only: If true, don't generate v14/v17 resources and just verify 356 # that the resources are v14-compliant (see 357 # build/android/gyp/generate_v14_compatible_resources.py). Defaults to 358 # false. 359 # 360 # Example 361 # android_resources("foo_resources") { 362 # deps = [":foo_strings_grd"] 363 # resource_dirs = ["res"] 364 # custom_package = "org.chromium.foo" 365 # } 366 template("android_resources") { 367 if (defined(invoker.testonly)) { testonly = invoker.testonly } 368 369 assert(defined(invoker.resource_dirs)) 370 assert(defined(invoker.android_manifest) || defined(invoker.custom_package)) 371 372 base_path = "$target_gen_dir/$target_name" 373 zip_path = base_path + ".resources.zip" 374 srcjar_path = base_path + ".srcjar" 375 build_config = base_path + ".build_config" 376 377 write_build_config("${target_name}__build_config") { 378 type = "android_resources" 379 resources_zip = zip_path 380 srcjar = srcjar_path 381 if (defined(invoker.deps)) { deps = invoker.deps } 382 if (defined(invoker.android_manifest)) { android_manifest = invoker.android_manifest } 383 if (defined(invoker.custom_package)) { custom_package = invoker.custom_package } 384 } 385 386 android_manifest = "//build/android/AndroidManifest.xml" 387 if (defined(invoker.android_manifest)) { 388 android_manifest = invoker.android_manifest 389 } 390 391 process_resources("${target_name}__process_resources") { 392 resource_dirs = invoker.resource_dirs 393 if (defined(invoker.custom_package)) { 394 custom_package = invoker.custom_package 395 } 396 397 if (defined(invoker.v14_verify_only)) { 398 v14_verify_only = invoker.v14_verify_only 399 } 400 } 401 402 group(target_name) { 403 deps = [ 404 ":${target_name}__build_config", 405 ":${target_name}__process_resources", 406 ] 407 } 408 } 409 410 411 # Declare a target that generates localized strings.xml from a .grd file. 412 # 413 # If this target is included in the deps of an android resources/library/apk, 414 # the strings.xml will be included with that target. 415 # 416 # Variables 417 # deps: Specifies the dependencies of this target. 418 # grd_file: Path to the .grd file to generate strings.xml from. 419 # outputs: Expected grit outputs (see grit rule). 420 # 421 # Example 422 # java_strings_grd("foo_strings_grd") { 423 # grd_file = "foo_strings.grd" 424 # } 425 template("java_strings_grd") { 426 if (defined(invoker.testonly)) { testonly = invoker.testonly } 427 428 base_path = "$target_gen_dir/$target_name" 429 resources_zip = base_path + ".resources.zip" 430 build_config = base_path + ".build_config" 431 432 write_build_config("${target_name}__build_config") { 433 type = "android_resources" 434 if (defined(invoker.deps)) { 435 deps = invoker.deps 436 } 437 } 438 439 # Put grit files into this subdirectory of target_gen_dir. 440 extra_output_path = target_name + "_grit_output" 441 442 grit_target_name = "${target_name}__grit" 443 grit_output_dir = "$target_gen_dir/$extra_output_path" 444 grit(grit_target_name) { 445 grit_flags = [ 446 "-E", "ANDROID_JAVA_TAGGED_ONLY=false", 447 ] 448 output_dir = grit_output_dir 449 resource_ids = "" 450 source = invoker.grd_file 451 outputs = invoker.outputs 452 } 453 454 # This needs to get outputs from grit's internal target, not the final 455 # source_set. 456 generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit") 457 458 zip("${target_name}__zip") { 459 base_dir = grit_output_dir 460 inputs = generate_strings_outputs 461 output = resources_zip 462 } 463 464 group(target_name) { 465 deps = [ 466 ":${target_name}__build_config", 467 ":${target_name}__zip", 468 ] 469 } 470 } 471 472 473 # Declare an Android library target 474 # 475 # This target creates an Android library containing java code and Android 476 # resources. 477 # 478 # Variables 479 # deps: Specifies the dependencies of this target. Java targets in this list 480 # will be added to the javac classpath. Android resources in dependencies 481 # will be used when building this library. 482 # java_files: List of .java files included in this library. 483 # srcjar_deps: List of srcjar dependencies. The .java files in the srcjars 484 # will be added to java_files and be included in this library. 485 # chromium_code: If true, extra analysis warning/errors will be enabled. 486 # jar_excluded_patterns: List of patterns of .class files to exclude from the 487 # final jar. 488 # proguard_preprocess: If true, proguard preprocessing will be run. This can 489 # be used to remove unwanted parts of the library. 490 # proguard_config: Path to the proguard config for preprocessing. 491 # 492 # DEPRECATED_java_in_dir: Directory containing java files. All .java files in 493 # this directory will be included in the library. This is only supported to 494 # ease the gyp->gn conversion and will be removed in the future. 495 # 496 # Example 497 # android_library("foo_java") { 498 # java_files = [ 499 # "android/org/chromium/foo/Foo.java", 500 # "android/org/chromium/foo/FooInterface.java", 501 # "android/org/chromium/foo/FooService.java", 502 # ] 503 # deps = [ 504 # ":bar_java" 505 # ] 506 # srcjar_deps = [ 507 # ":foo_generated_enum" 508 # ] 509 # jar_excluded_patterns = [ 510 # "*/FooService.class", "*/FooService##*.class" 511 # ] 512 # } 513 template("android_library") { 514 if (defined(invoker.testonly)) { testonly = invoker.testonly } 515 516 assert(defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir)) 517 _base_path = "$target_gen_dir/$target_name" 518 _build_config = _base_path + ".build_config" 519 _jar_path = _base_path + ".jar" 520 _dex_path = _base_path + ".dex.jar" 521 522 write_build_config("${target_name}__build_config") { 523 type = "android_library" 524 525 deps = [] 526 if (defined(invoker.deps)) { 527 deps += invoker.deps 528 } 529 530 build_config = _build_config 531 jar_path = _jar_path 532 dex_path = _dex_path 533 } 534 535 _chromium_code = true 536 if (defined(invoker.chromium_code)) { 537 _chromium_code = invoker.chromium_code 538 } 539 540 android_java_library(target_name) { 541 chromium_code = _chromium_code 542 if (defined(invoker.java_files)) { 543 java_files = invoker.java_files 544 } else { 545 DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir 546 } 547 build_config = _build_config 548 jar_path = _jar_path 549 dex_path = _dex_path 550 551 if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) { 552 proguard_preprocess = true 553 proguard_config = invoker.proguard_config 554 } 555 556 jar_excluded_patterns = [ 557 "*/R.class", "*/R##*.class", 558 "*/Manifest.class", "*/Manifest##*.class", 559 ] 560 if (defined(invoker.jar_excluded_patterns)) { 561 jar_excluded_patterns += invoker.jar_excluded_patterns 562 } 563 564 if (defined(invoker.srcjar_deps)) { 565 srcjar_deps = invoker.srcjar_deps 566 } 567 } 568 } 569 570 571 # Declare an Android library target for a prebuilt jar 572 # 573 # This target creates an Android library containing java code and Android 574 # resources. 575 # 576 # Variables 577 # deps: Specifies the dependencies of this target. Java targets in this list 578 # will be added to the javac classpath. Android resources in dependencies 579 # will be used when building this library. 580 # jar_path: Path to the prebuilt jar. 581 # proguard_preprocess: If true, proguard preprocessing will be run. This can 582 # be used to remove unwanted parts of the library. 583 # proguard_config: Path to the proguard config for preprocessing. 584 # 585 # Example 586 # android_java_prebuilt("foo_java") { 587 # jar_path = "foo.jar" 588 # deps = [ 589 # ":foo_resources", 590 # ":bar_java" 591 # ] 592 # } 593 template("android_java_prebuilt") { 594 if (defined(invoker.testonly)) { testonly = invoker.testonly } 595 596 assert(defined(invoker.jar_path)) 597 _base_path = "${target_gen_dir}/$target_name" 598 _jar_path = _base_path + ".jar" 599 _dex_path = _base_path + ".dex.jar" 600 _build_config = _base_path + ".build_config" 601 602 write_build_config("${target_name}__build_config") { 603 type = "android_library" 604 605 deps = [] 606 if (defined(invoker.deps)) { 607 deps += invoker.deps 608 } 609 build_config = _build_config 610 jar_path = _jar_path 611 dex_path = _dex_path 612 } 613 614 java_prebuilt("${target_name}__process_jar") { 615 if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) { 616 proguard_preprocess = true 617 proguard_config = invoker.proguard_config 618 } 619 620 build_config = _build_config 621 input_jar_path = invoker.jar_path 622 output_jar_path = _jar_path 623 } 624 625 dex("${target_name}__dex") { 626 sources = [_jar_path] 627 output = _dex_path 628 } 629 630 group(target_name) { 631 deps = [ 632 ":${target_name}__dex", 633 ] 634 } 635 } 636 637 638 639 # Declare an Android apk target 640 # 641 # This target creates an Android APK containing java code, resources, assets, 642 # and (possibly) native libraries. 643 # 644 # Variables 645 # android_manifest: Path to AndroidManifest.xml. 646 # datadeps: List of dependencies needed at runtime. These will be built but 647 # won't change the generated .apk in any way (in fact they may be built 648 # after the .apk is). 649 # deps: List of dependencies. All Android java resources and libraries in the 650 # "transitive closure" of these dependencies will be included in the apk. 651 # Note: this "transitive closure" actually only includes such targets if 652 # they are depended on through android_library or android_resources targets 653 # (and so not through builtin targets like 'action', 'group', etc). 654 # java_files: List of .java files to include in the apk. 655 # srcjar_deps: List of srcjar dependencies. The .java files in the srcjars 656 # will be added to java_files and be included in this apk. 657 # apk_name: Name for final apk. 658 # final_apk_path: Path to final built apk. Default is 659 # $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name. 660 # native_libs: List paths of native libraries to include in this apk. If these 661 # libraries depend on other shared_library targets, those dependencies will 662 # also be included in the apk. 663 # testonly: Marks this target as "test-only". 664 # 665 # DEPRECATED_java_in_dir: Directory containing java files. All .java files in 666 # this directory will be included in the library. This is only supported to 667 # ease the gyp->gn conversion and will be removed in the future. 668 # 669 # Example 670 # android_apk("foo_apk") { 671 # android_manifest = "AndroidManifest.xml" 672 # java_files = [ 673 # "android/org/chromium/foo/FooApplication.java", 674 # "android/org/chromium/foo/FooActivity.java", 675 # ] 676 # deps = [ 677 # ":foo_support_java" 678 # ":foo_resources" 679 # ] 680 # srcjar_deps = [ 681 # ":foo_generated_enum" 682 # ] 683 # native_libs = [ 684 # native_lib_path 685 # ] 686 # } 687 template("android_apk") { 688 if (defined(invoker.testonly)) { testonly = invoker.testonly } 689 690 assert(defined(invoker.final_apk_path) || defined(invoker.apk_name)) 691 gen_dir = "$target_gen_dir/$target_name" 692 base_path = "$gen_dir/$target_name" 693 build_config = "$base_path.build_config" 694 resources_zip_path = "$base_path.resources.zip" 695 all_resources_zip_path = "$base_path.resources.all.zip" 696 jar_path = "$base_path.jar" 697 final_dex_path = "$gen_dir/classes.dex" 698 _template_name = target_name 699 _final_apk_path = "" 700 if (defined(invoker.final_apk_path)) { 701 _final_apk_path = invoker.final_apk_path 702 } else if (defined(invoker.apk_name)) { 703 _final_apk_path = "$root_build_dir/apks/" + invoker.apk_name + ".apk" 704 } 705 _dist_jar_path_list = process_file_template( 706 [ _final_apk_path ], 707 "$root_build_dir/test.lib.java/{{source_name_part}}.jar" 708 ) 709 _dist_jar_path = _dist_jar_path_list[0] 710 711 _native_libs = [] 712 if (defined(invoker.native_libs)) { 713 _native_libs = invoker.native_libs 714 _native_libs_dir = base_path + "/libs" 715 } 716 717 _keystore_path = android_default_keystore_path 718 _keystore_name = android_default_keystore_name 719 _keystore_password = android_default_keystore_password 720 721 if (defined(invoker.keystore_path)) { 722 _keystore_path = invoker.keystore_path 723 _keystore_name = invoker.keystore_name 724 _keystore_password = invoker.keystore_password 725 } 726 727 _srcjar_deps = [] 728 if (defined(invoker.srcjar_deps)) { 729 _srcjar_deps += invoker.srcjar_deps 730 } 731 732 _rebased_build_config = rebase_path(build_config, root_build_dir) 733 734 write_build_config("${_template_name}__build_config") { 735 type = "android_apk" 736 dex_path = final_dex_path 737 resources_zip = resources_zip_path 738 739 if (defined(invoker.deps)) { 740 deps = invoker.deps 741 } 742 743 native_libs = _native_libs 744 } 745 746 final_deps = [] 747 748 final_deps += [":${_template_name}__process_resources"] 749 process_resources("${_template_name}__process_resources") { 750 srcjar_path = "${target_gen_dir}/${target_name}.srcjar" 751 android_manifest = invoker.android_manifest 752 resource_dirs = ["//build/android/ant/empty/res"] 753 zip_path = resources_zip_path 754 generate_constant_ids = true 755 } 756 _srcjar_deps += [":${_template_name}__process_resources"] 757 758 if (_native_libs != []) { 759 _use_chromium_linker = false 760 _enable_chromium_linker_tests = false 761 _load_library_from_apk = false 762 _native_lib_version_name = "" 763 764 765 java_cpp_template("${_template_name}__native_libraries_java") { 766 package_name = "org/chromium/base/library_loader" 767 sources = [ 768 "//base/android/java/templates/NativeLibraries.template", 769 ] 770 inputs = [ 771 build_config, 772 ] 773 774 defines = [ 775 "NATIVE_LIBRARIES_LIST=" + 776 "@FileArg($_rebased_build_config:native:java_libraries_list)", 777 "NATIVE_LIBRARIES_VERSION_NUMBER=\"$_native_lib_version_name\"", 778 ] 779 if (_use_chromium_linker) { 780 defines += ["ENABLED_CHROMIUM_LINKER"] 781 } 782 if (_load_library_from_apk) { 783 defines += ["ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE"] 784 } 785 if (_enable_chromium_linker_tests) { 786 defines += ["ENABLE_CHROMIUM_LINKER_TESTS"] 787 } 788 } 789 _srcjar_deps += [ ":${_template_name}__native_libraries_java" ] 790 } 791 792 final_deps += [ ":${_template_name}__java" ] 793 android_java_library("${_template_name}__java") { 794 android_manifest = invoker.android_manifest 795 if (defined(invoker.java_files)) { 796 java_files = invoker.java_files 797 } else if (defined(invoker.DEPRECATED_java_in_dir)) { 798 DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir 799 } else { 800 java_files = [] 801 } 802 srcjar_deps = _srcjar_deps 803 dex_path = base_path + ".dex.jar" 804 } 805 806 if (_dist_jar_path != "") { 807 # TODO(cjhopman): This is only ever needed to calculate the list of tests to 808 # run. See build/android/pylib/instrumentation/test_jar.py. We should be 809 # able to just do that calculation at build time instead. 810 action("${_template_name}__create_dist_jar") { 811 script = "//build/android/gyp/create_dist_jar.py" 812 depfile = "$target_gen_dir/$target_name.d" 813 inputs = [ build_config ] 814 outputs = [ 815 depfile, 816 _dist_jar_path, 817 ] 818 args = [ 819 "--depfile", rebase_path(depfile, root_build_dir), 820 "--output", rebase_path(_dist_jar_path, root_build_dir), 821 "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)", 822 ] 823 inputs += [ jar_path ] 824 _rebased_jar_path = rebase_path([ jar_path ], root_build_dir) 825 args += [ 826 "--inputs=$_rebased_jar_path", 827 ] 828 } 829 } 830 831 final_deps += [":${_template_name}__final_dex"] 832 dex("${_template_name}__final_dex") { 833 deps = [ ":${_template_name}__java" ] 834 sources = [ jar_path ] 835 inputs = [ build_config ] 836 output = final_dex_path 837 dex_arg_key = "${_rebased_build_config}:apk_dex:dependency_dex_files" 838 args = [ "--inputs=@FileArg($dex_arg_key)" ] 839 } 840 841 if (_native_libs != []) { 842 copy_ex("${_template_name}__prepare_native") { 843 clear_dir = true 844 inputs = [ 845 build_config 846 ] 847 dest = "$_native_libs_dir/$android_app_abi" 848 args = [ 849 "--files=@FileArg(${_rebased_build_config}:native:libraries)", 850 ] 851 if (is_debug) { 852 rebased_gdbserver = rebase_path(android_gdbserver, root_build_dir) 853 args += [ 854 "--files=[\"$rebased_gdbserver\"]" 855 ] 856 } 857 } 858 } 859 860 final_deps += [":${_template_name}__create"] 861 create_apk("${_template_name}__create") { 862 apk_path = _final_apk_path 863 android_manifest = invoker.android_manifest 864 resources_zip = all_resources_zip_path 865 dex_path = final_dex_path 866 867 if (defined(invoker.asset_location)) { 868 asset_location = invoker.asset_location 869 } 870 871 keystore_name = _keystore_name 872 keystore_path = _keystore_path 873 keystore_password = _keystore_password 874 875 if (_native_libs != []) { 876 native_libs_dir = _native_libs_dir 877 deps = [":${_template_name}__prepare_native"] 878 } 879 } 880 881 group(target_name) { 882 deps = final_deps 883 if (defined(invoker.datadeps)) { 884 # TODO(cjhopman): Fix this when group datadeps works. 885 deps += invoker.datadeps 886 } 887 } 888 } 889 890 891 # Declare an Android gtest apk 892 # 893 # This target creates an Android apk for running gtest-based unittests. 894 # 895 # Variables 896 # deps: Specifies the dependencies of this target. These will be passed to 897 # the underlying android_apk invocation and should include the java and 898 # resource dependencies of the apk. 899 # unittests_dep: This should be the label of the gtest native target. This 900 # target must be defined previously in the same file. 901 # unittests_binary: The name of the binary produced by the unittests_dep 902 # target, relative to the root build directory. If unspecified, it assumes 903 # the name of the unittests_dep target (which will be correct unless that 904 # target specifies an "output_name". 905 # TODO(brettw) make this automatic by allowing get_target_outputs to 906 # support executables. 907 # 908 # Example 909 # unittest_apk("foo_unittests_apk") { 910 # deps = [ ":foo_java", ":foo_resources" ] 911 # unittests_dep = ":foo_unittests" 912 # } 913 template("unittest_apk") { 914 testonly = true 915 916 assert(defined(invoker.unittests_dep), "Need unittests_dep for $target_name") 917 918 test_suite_name = get_label_info(invoker.unittests_dep, "name") 919 920 if (defined(invoker.unittests_binary)) { 921 unittests_binary = root_out_dir + "/" + invoker.unittests_binary 922 } else { 923 unittests_binary = root_out_dir + "/lib.stripped/lib" + test_suite_name + ".so" 924 } 925 926 android_apk(target_name) { 927 _apk_name = test_suite_name 928 final_apk_path = "$root_build_dir/${_apk_name}_apk/${_apk_name}-debug.apk" 929 java_files = [ 930 "//testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java" 931 ] 932 android_manifest = "//testing/android/java/AndroidManifest.xml" 933 unittests_outputs = [ unittests_binary ] 934 native_libs = [unittests_outputs[0]] 935 if (defined(invoker.deps)) { 936 deps = invoker.deps 937 } 938 datadeps = [ 939 "//tools/android/md5sum", 940 ] 941 } 942 } 943 944 # Generate .java files from .aidl files. 945 # 946 # This target will store the .java files in a srcjar and should be included in 947 # an android_library or android_apk's srcjar_deps. 948 # 949 # Variables 950 # sources: Paths to .aidl files to compile. 951 # import_include: Path to directory containing .java files imported by the 952 # .aidl files. 953 # interface_file: Preprocessed aidl file to import. 954 # 955 # Example 956 # android_aidl("foo_aidl") { 957 # import_include = "java/src" 958 # sources = [ 959 # "java/src/com/foo/bar/FooBarService.aidl", 960 # "java/src/com/foo/bar/FooBarServiceCallback.aidl", 961 # ] 962 # } 963 template("android_aidl") { 964 if (defined(invoker.testonly)) { testonly = invoker.testonly } 965 966 srcjar_path = "${target_gen_dir}/${target_name}.srcjar" 967 aidl_path = "${android_sdk_build_tools}/aidl" 968 framework_aidl = "$android_sdk/framework.aidl" 969 970 action(target_name) { 971 script = "//build/android/gyp/aidl.py" 972 sources = invoker.sources 973 974 imports = [ framework_aidl ] 975 if (defined(invoker.interface_file)) { 976 assert(invoker.interface_file != "") 977 imports += [ invoker.interface_file ] 978 } 979 980 inputs = [ 981 aidl_path, 982 ] + imports 983 984 depfile = "${target_gen_dir}/${target_name}.d" 985 outputs = [ 986 depfile, 987 srcjar_path 988 ] 989 rebased_imports = rebase_path(imports, root_build_dir) 990 args = [ 991 "--depfile", rebase_path(depfile, root_build_dir), 992 "--aidl-path", rebase_path(aidl_path, root_build_dir), 993 "--imports=$rebased_imports", 994 "--srcjar", rebase_path(srcjar_path, root_build_dir), 995 ] 996 if (defined(invoker.import_include) && invoker.import_include != "") { 997 # TODO(cjhopman): aidl supports creating a depfile. We should be able to 998 # switch to constructing a depfile for the overall action from that 999 # instead of having all the .java files in the include paths as inputs. 1000 rebased_import_includes = rebase_path( 1001 [invoker.import_include], root_build_dir) 1002 args += [ "--includes=$rebased_import_includes" ] 1003 1004 _java_files_build_rel = exec_script( 1005 "//build/android/gyp/find.py", 1006 rebase_path([invoker.import_include], root_build_dir), 1007 "list lines" 1008 ) 1009 _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir) 1010 inputs += _java_files 1011 } 1012 args += rebase_path(sources, root_build_dir) 1013 } 1014 } 1015 1016 # Creates a dist directory for a native executable. 1017 # 1018 # Running a native executable on a device requires all the shared library 1019 # dependencies of that executable. To make it easier to install and run such an 1020 # executable, this will create a directory containing the native exe and all 1021 # it's library dependencies. 1022 # 1023 # Note: It's usually better to package things as an APK than as a native 1024 # executable. 1025 # 1026 # Variables 1027 # dist_dir: Directory for the exe and libraries. Everything in this directory 1028 # will be deleted before copying in the exe and libraries. 1029 # binary: Path to (stripped) executable. 1030 # 1031 # Example 1032 # create_native_executable_dist("foo_dist") { 1033 # dist_dir = "$root_build_dir/foo_dist" 1034 # binary = "$root_build_dir/exe.stripped/foo" 1035 # } 1036 template("create_native_executable_dist") { 1037 if (defined(invoker.testonly)) { testonly = invoker.testonly } 1038 1039 dist_dir = invoker.dist_dir 1040 binary = invoker.binary 1041 final_deps = [] 1042 template_name = target_name 1043 1044 libraries_list = "${target_gen_dir}/${template_name}_library_dependencies.list" 1045 1046 # TODO(gyp) 1047 #'dependencies': [ 1048 #'<(DEPTH)/build/android/setup.gyp:copy_system_libraries', 1049 #], 1050 1051 stripped_libraries_dir = "$root_build_dir/lib.stripped" 1052 final_deps += [ ":${template_name}__find_library_dependencies" ] 1053 action("${template_name}__find_library_dependencies") { 1054 script = "//build/android/gyp/write_ordered_libraries.py" 1055 depfile = "$target_gen_dir/$target_name.d" 1056 inputs = [ 1057 binary, 1058 android_readelf, 1059 ] 1060 outputs = [ 1061 depfile, 1062 libraries_list, 1063 ] 1064 rebased_binaries = rebase_path([ binary ], root_build_dir) 1065 args = [ 1066 "--depfile", rebase_path(depfile, root_build_dir), 1067 "--input-libraries=$rebased_binaries", 1068 "--libraries-dir", rebase_path(stripped_libraries_dir, root_build_dir), 1069 "--output", rebase_path(libraries_list, root_build_dir), 1070 "--readelf", rebase_path(android_readelf, root_build_dir), 1071 ] 1072 } 1073 1074 final_deps += [ ":${template_name}__copy_libraries_and_exe" ] 1075 copy_ex("${template_name}__copy_libraries_and_exe") { 1076 clear_dir = true 1077 inputs = [ 1078 binary, 1079 libraries_list 1080 ] 1081 dest = dist_dir 1082 rebased_binaries_list = rebase_path([ binary ], root_build_dir) 1083 rebased_libraries_list = rebase_path(libraries_list, root_build_dir) 1084 args = [ 1085 "--files=$rebased_binaries_list", 1086 "--files=@FileArg($rebased_libraries_list:libraries)", 1087 ] 1088 } 1089 1090 group(target_name) { 1091 deps = final_deps 1092 } 1093 } 1094
