1# Copyright (c) 2021 Huawei Device Co., Ltd.
2# Licensed under the Apache License, Version 2.0 (the "License");
3# you may not use this file except in compliance with the License.
4# You may obtain a copy of the License at
5#
6#     http://www.apache.org/licenses/LICENSE-2.0
7#
8# Unless required by applicable law or agreed to in writing, software
9# distributed under the License is distributed on an "AS IS" BASIS,
10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11# See the License for the specific language governing permissions and
12# limitations under the License.
13
14import("//build/config/python.gni")
15import("//build/ohos_var.gni")
16import("//build/templates/metadata/module_info.gni")
17
18if (is_ohos) {
19  import("//build/config/ohos/abi.gni")
20}
21
22template("merge_profile") {
23  forward_variables_from(invoker, [ "testonly" ])
24  assert(defined(invoker.hap_profile),
25         "hap_profile must be defined for compile_resources")
26  action(target_name) {
27    forward_variables_from(invoker,
28                           [
29                             "meta_data",
30                             "hap_profile",
31                             "generated_profile",
32                             "deps",
33                           ])
34    script = "//build/scripts/merge_profile.py"
35    depfile = "$target_gen_dir/$target_name.d"
36
37    _rebased_metadata = rebase_path(meta_data, root_build_dir)
38    inputs = [
39      meta_data,
40      hap_profile,
41    ]
42    args = [
43      "--resources-dir=@FileArg($_rebased_metadata:root:resources)",
44      "--depfile",
45      rebase_path(depfile, root_build_dir),
46      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
47      "--hap-profile",
48      rebase_path(hap_profile, root_build_dir),
49      "--generated-profile",
50      rebase_path(generated_profile, root_build_dir),
51      "--release-type",
52      release_type,
53      "--api-version",
54      api_version,
55    ]
56    outputs = [ generated_profile ]
57  }
58}
59
60template("compile_resources") {
61  forward_variables_from(invoker, [ "testonly" ])
62  assert(defined(invoker.hap_profile),
63         "hap_profile must be defined for compile_resources")
64  assert(
65      defined(invoker.packaged_resources) ||
66          defined(invoker.generated_header_dir),
67      "hap_profile or generated_header_dir must be defined for compile_resources")
68  _generate_resource = defined(invoker.packaged_resources)
69  if (_generate_resource) {
70    _packaged_resources = invoker.packaged_resources
71  }
72  _generate_header = defined(invoker.generated_header_dir)
73  if (_generate_header) {
74    _generated_header_file = invoker.generated_header_dir + "/ResourceTable.h"
75  }
76  action_with_pydeps(target_name) {
77    forward_variables_from(invoker,
78                           [
79                             "meta_data",
80                             "hap_profile",
81                             "deps",
82                           ])
83    script = "//build/scripts/compile_resources.py"
84    depfile = "$target_gen_dir/$target_name.d"
85    if (defined(deps)) {
86      deps += [
87        "//developtools/global_resource_tool:restool($host_toolchain)",
88        "//developtools/global_resource_tool:restool_id_defined($host_toolchain)",
89      ]
90    } else {
91      deps = [
92        "//developtools/global_resource_tool:restool($host_toolchain)",
93        "//developtools/global_resource_tool:restool_id_defined($host_toolchain)",
94      ]
95    }
96    restool_path =
97        get_label_info(
98            "//developtools/global_resource_tool:restool($host_toolchain)",
99            "root_out_dir") + "/developtools/global_resource_tool/restool"
100    _rebased_metadata = rebase_path(meta_data, root_build_dir)
101    inputs = [
102      meta_data,
103      restool_path,
104      hap_profile,
105    ]
106    args = [
107      "--resources-dir=@FileArg($_rebased_metadata:root:resources)",
108      "--depfile",
109      rebase_path(depfile, root_build_dir),
110      "--restool-path",
111      rebase_path(restool_path, root_build_dir),
112      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
113      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
114    ]
115    outputs = []
116    if (_generate_resource) {
117      outputs += [ _packaged_resources ]
118      args += [
119        "--output-resources-zipfile",
120        rebase_path(_packaged_resources, root_build_dir),
121      ]
122    }
123    if (_generate_header) {
124      outputs += [ _generated_header_file ]
125      args += [
126        "--output-header-file",
127        rebase_path(_generated_header_file, root_build_dir),
128      ]
129    }
130  }
131}
132
133template("package_app") {
134  forward_variables_from(invoker, [ "testonly" ])
135  assert(defined(invoker.hap_profile),
136         "hap_profile must be defined for $target_name")
137  assert(defined(invoker.hap_path), "hap_path must be defined for $target_name")
138  action_with_pydeps(target_name) {
139    forward_variables_from(invoker,
140                           [
141                             "deps",
142                             "shared_libraries",
143                             "hap_profile",
144                             "hap_path",
145                             "packaged_resources",
146                             "packaged_js_assets",
147                             "meta_data",
148                             "private_key_path",
149                             "signature_algorithm",
150                             "certificate_profile",
151                             "keystore_path",
152                             "keystore_password",
153                             "key_alias",
154                             "certificate_file",
155                             "install_module_info",
156                             "enable_ark",
157                             "build_mode",
158                             "compatible_version",
159                           ])
160    script = "//build/scripts/hapbuilder.py"
161    depfile = "$target_gen_dir/$target_name.d"
162    _rebased_metadata = rebase_path(meta_data, root_build_dir)
163    outputs = [ hap_path ]
164    args = [
165      "--depfile",
166      rebase_path(depfile, root_build_dir),
167      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
168      "--hapsigner",
169      rebase_path(hapsigner, root_build_dir),
170      "--hap-packing-tool",
171      rebase_path(hap_packing_tool, root_build_dir),
172      "--hap-path",
173      rebase_path(hap_path, root_build_dir),
174      "--packaged-resources",
175      rebase_path(packaged_resources, root_build_dir),
176      "--packaged-js-assets",
177      rebase_path(packaged_js_assets, root_build_dir),
178      "--assets=@FileArg($_rebased_metadata:root:assets)",
179      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
180      "--build-mode",
181      build_mode,
182    ]
183
184    inputs = [
185      hap_profile,
186      hapsigner,
187      hap_packing_tool,
188      packaged_js_assets,
189      packaged_resources,
190      meta_data,
191    ]
192
193    _private_key_path = default_hap_private_key_path
194    if (defined(private_key_path)) {
195      _private_key_path = private_key_path
196    }
197    _signature_algorithm = default_signature_algorithm
198    if (defined(signature_algorithm)) {
199      _signature_algorithm = signature_algorithm
200    }
201    _key_alias = default_key_alias
202    if (defined(key_alias)) {
203      _key_alias = key_alias
204    }
205    _keystore_path = default_keystore_path
206    if (defined(keystore_path)) {
207      _keystore_path = keystore_path
208    }
209    _keystore_password = default_keystore_password
210    if (defined(keystore_password)) {
211      _keystore_password = keystore_password
212    }
213    _certificate_file = default_hap_certificate_file
214    if (defined(certificate_file)) {
215      _certificate_file = certificate_file
216    }
217
218    inputs += [
219      certificate_profile,
220      _keystore_path,
221      _certificate_file,
222    ]
223    _sign_hap_py_path = "//build/scripts/app_sign.py"
224    if (defined(sign_hap_py_path) && defined(compatible_version)) {
225      _sign_hap_py_path = sign_hap_py_path
226    }
227
228    args += [
229      "--sign_hap_py_path",
230      rebase_path(_sign_hap_py_path),
231    ]
232    if (defined(sign_hap_py_path)) {
233      if (defined(compatible_version)) {
234        _sign_compatible_version = compatible_version
235        args += [
236          "--sign_compatible_version",
237          _sign_compatible_version,
238        ]
239      } else {
240        _target_label = get_label_info(target_name, "label_no_toolchain")
241        print(
242            "warning: Please set compatible_version in ${_target_label} for remote sign")
243      }
244    }
245    args += [
246      "--private-key-path",
247      _private_key_path,
248      "--sign-algo",
249      _signature_algorithm,
250      "--certificate-profile",
251      rebase_path(certificate_profile, root_build_dir),
252      "--keyalias",
253      _key_alias,
254      "--keystore-path",
255      rebase_path(_keystore_path, root_build_dir),
256      "--keystorepasswd",
257      _keystore_password,
258      "--certificate-file",
259      rebase_path(_certificate_file, root_build_dir),
260    ]
261
262    if (defined(shared_libraries)) {
263      foreach(lib, shared_libraries) {
264        _module_info = get_label_info(lib, "target_out_dir") + "/" +
265                       get_label_info(lib, "name") + "_module_info.json"
266        _rebased_module_info = rebase_path(_module_info, root_build_dir)
267        args += [ "--dso=@FileArg($_rebased_module_info:source)" ]
268      }
269      if (is_ohos) {
270        args += [
271          "--ohos-app-abi",
272          ohos_app_abi,
273        ]
274      }
275    }
276
277    if (defined(install_module_info)) {
278      metadata = {
279        install_modules = [ install_module_info ]
280      }
281    }
282    if (defined(enable_ark) && enable_ark) {
283      _ark_deps = [
284        "//arkcompiler/ets_frontend/es2panda:es2abc_js_file($host_toolchain)",
285        "//arkcompiler/ets_frontend/es2panda:es2panda_build($host_toolchain)",
286      ]
287      if (defined(deps)) {
288        deps += _ark_deps
289      } else {
290        deps = _ark_deps
291      }
292      _js2abc_js = get_label_info(
293                       "//arkcompiler/ets_frontend/es2panda:es2abc_js_file($host_toolchain)",
294                       "target_out_dir") + "/ts2abc.js"
295      args += [
296        "--nodejs-path",
297        rebase_path(nodejs, root_build_dir),
298        "--js2abc-js",
299        rebase_path(_js2abc_js, root_build_dir),
300        "--enable-ark",
301      ]
302      inputs += [
303        nodejs,
304        _js2abc_js,
305      ]
306    }
307  }
308}
309
310template("compile_js_assets") {
311  forward_variables_from(invoker, [ "testonly" ])
312  assert(defined(invoker.meta_data) && defined(invoker.packaged_js_assets),
313         "meta_data and packaged_js_assets must be for compile_js_assets")
314
315  _packaged_js_assets = invoker.packaged_js_assets
316  action_with_pydeps(target_name) {
317    forward_variables_from(invoker,
318                           [
319                             "deps",
320                             "meta_data",
321                             "hap_profile",
322                             "build_mode",
323                             "js2abc",
324                             "ets2abc",
325                             "main_target_name",
326                           ])
327    script = "//build/scripts/build_js_assets.py"
328    depfile = "$target_gen_dir/$target_name.d"
329    outputs = [ _packaged_js_assets ]
330
331    _rebased_metadata = rebase_path(meta_data, root_build_dir)
332
333    if (!defined(deps)) {
334      deps = []
335    }
336    deps += [
337      "//arkcompiler/ets_frontend/es2panda:build_es2abc_for_hap($host_toolchain)",
338      "//developtools/ace_ets2bundle:ets_loader_ark_hap",
339      "//developtools/ace_js2bundle:ace_loader_ark_hap",
340      "//third_party/parse5:parse5_ark_hap",
341      "//third_party/weex-loader:weex_loader_ark_hap",
342    ]
343    _ace_loader_home =
344        get_label_info("//developtools/ace_js2bundle:ace_loader_node_modules",
345                       "target_out_dir") + "/ace_loader_ark"
346    _webpack_config_js = "${_ace_loader_home}/webpack.rich.config.js"
347    _ets_loader_home =
348        get_label_info("//developtools/ace_ets2bundle:ets_loader_node_modules",
349                       "target_out_dir") + "/ets_loader_ark"
350    _webpack_config_ets = "${_ets_loader_home}/webpack.config.js"
351    _webpack_js = "${_ace_loader_home}/node_modules/webpack/bin/webpack.js"
352    _webpack_ets = "${_ets_loader_home}/node_modules/webpack/bin/webpack.js"
353    _manifest_file_path = "${target_gen_dir}/manifest_file"
354
355    inputs = [
356      meta_data,
357      nodejs,
358    ]
359
360    args = [
361      "--js-assets-dir=@FileArg($_rebased_metadata:root:js_assets)",
362      "--ets-assets-dir=@FileArg($_rebased_metadata:root:ets_assets)",
363      "--js-forms-dir=@FileArg($_rebased_metadata:root:js_forms)",
364      "--testrunner-dir=@FileArg($_rebased_metadata:root:testrunner)",
365      "--output",
366      rebase_path(_packaged_js_assets, root_build_dir),
367      "--depfile",
368      rebase_path(depfile, root_build_dir),
369      "--nodejs-path",
370      rebase_path(nodejs, root_build_dir),
371      "--webpack-js",
372      rebase_path(_webpack_js, root_build_dir),
373      "--webpack-ets",
374      rebase_path(_webpack_ets, root_build_dir),
375      "--webpack-config-js",
376      rebase_path(_webpack_config_js, root_build_dir),
377      "--webpack-config-ets",
378      rebase_path(_webpack_config_ets, root_build_dir),
379      "--build-mode",
380      build_mode,
381      "--ace-loader-home",
382      rebase_path(_ace_loader_home, root_build_dir),
383      "--ets-loader-home",
384      rebase_path(_ets_loader_home, root_build_dir),
385      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
386      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
387      "--manifest-file-path",
388      rebase_path(_manifest_file_path, root_build_dir),
389    ]
390    if (defined(testonly) && testonly == true) {
391      _js_sources_file = target_gen_dir + "/$main_target_name.sources"
392      args += [
393        "--js-sources-file",
394        rebase_path(_js_sources_file, root_build_dir),
395      ]
396      outputs += [ _js_sources_file ]
397    }
398
399    if (js2abc || ets2abc) {
400      _es2abc_dir = get_label_info(
401              "//arkcompiler/ets_frontend/es2panda:es2panda_build($host_toolchain)",
402              "target_out_dir")
403      if (ets2abc) {
404        args += [ "--ets2abc" ]
405      } else if (js2abc) {
406        args += [ "--js2abc" ]
407      }
408      args += [
409        "--ark-es2abc-dir",
410        rebase_path(_es2abc_dir, root_build_dir),
411      ]
412    }
413
414    if (defined(hap_profile)) {
415      inputs += [ hap_profile ]
416    }
417  }
418}
419
420template("app_sign") {
421  forward_variables_from(invoker, [ "testonly" ])
422  sign_variables = [
423    "deps",
424    "private_key_path",
425    "signature_algorithm",
426    "certificate_profile",
427    "keystore_password",
428    "key_alias",
429    "certificate_file",
430    "keystore_path",
431    "unsigned_hap_path_list",
432    "hap_out_dir",
433    "hap_name",
434    "install_module_info",
435    "compatible_version",
436  ]
437  if (defined(invoker.hap_list)) {
438    sign_variables += [ "hap_list" ]
439  }
440  action(target_name) {
441    forward_variables_from(invoker, sign_variables)
442    _sign_hap_py_path = "//build/scripts/app_sign.py"
443    if (defined(sign_hap_py_path) && defined(compatible_version)) {
444      _sign_hap_py_path = sign_hap_py_path
445    }
446    script = _sign_hap_py_path
447    _private_key_path = default_hap_private_key_path
448    if (defined(private_key_path)) {
449      _private_key_path = private_key_path
450    }
451    _key_alias = default_key_alias
452    if (defined(key_alias)) {
453      _key_alias = key_alias
454    }
455    _signature_algorithm = default_signature_algorithm
456    if (defined(signature_algorithm)) {
457      _signature_algorithm = signature_algorithm
458    }
459    _keystore_path = default_keystore_path
460    if (defined(keystore_path)) {
461      _keystore_path = keystore_path
462    }
463    _certificate_file = default_hap_certificate_file
464    if (defined(certificate_file)) {
465      _certificate_file = certificate_file
466    }
467    _keystore_password = default_keystore_password
468    if (defined(keystore_password)) {
469      _keystore_password = keystore_password
470    }
471    if (defined(certificate_profile)) {
472      _certificate_profile = certificate_profile
473    }
474
475    inputs = [
476      hapsigner,
477      certificate_profile,
478      _keystore_path,
479      _certificate_file,
480    ]
481
482    outputs = [ "${target_out_dir}/${target_name}.stamp" ]
483
484    args = [
485      "--keyPwd",
486      _private_key_path,
487      "--sign-algo",
488      _signature_algorithm,
489      "--profileFile",
490      rebase_path(_certificate_profile, root_build_dir),
491      "--keyalias",
492      _key_alias,
493      "--keystoreFile",
494      rebase_path(_keystore_path, root_build_dir),
495      "--keystorePwd",
496      _keystore_password,
497      "--certificate-file",
498      rebase_path(_certificate_file, root_build_dir),
499      "--hapsigner",
500      rebase_path(hapsigner, root_build_dir),
501      "--unsigned-hap-path-list",
502      rebase_path(unsigned_hap_path_list, root_build_dir),
503      "--hap-out-dir",
504      rebase_path(hap_out_dir, root_build_dir),
505      "--hap-name",
506      hap_name,
507    ]
508    if (defined(invoker.hap_list)) {
509      args += [
510        "--hap-list",
511        rebase_path(hap_list, root_build_dir),
512      ]
513    }
514
515    if (defined(sign_hap_py_path)) {
516      if (defined(compatible_version)) {
517        _sign_compatible_version = compatible_version
518        args += [
519          "--compatible_version",
520          _sign_compatible_version,
521        ]
522      } else {
523        _target_label = get_label_info(target_name, "label_no_toolchain")
524        print(
525            "warning: Please set compatible_version in ${_target_label} for remote sign")
526      }
527    }
528
529    if (defined(install_module_info)) {
530      metadata = {
531        install_modules = [ install_module_info ]
532      }
533    }
534  }
535}
536
537template("compile_app") {
538  forward_variables_from(invoker, [ "testonly" ])
539  nodejs_version = "v16.20.2"
540  if (host_os == "mac") {
541    _nodejs = "//prebuilts/build-tools/common/nodejs/node-${nodejs_version}-darwin-x64/bin/node"
542  } else {
543    _nodejs = "//prebuilts/build-tools/common/nodejs/node-${nodejs_version}-${host_os}-x64/bin/node"
544  }
545  action(target_name) {
546    forward_variables_from(invoker,
547                           [
548                             "deps",
549                             "cwd",
550                             "build_mode",
551                             "build_profile",
552                             "app_profile",
553                             "hap_profile",
554                             "build_level",
555                             "assemble_type",
556                             "sdk_home",
557                             "unsigned_hap_path_list",
558                             "system_lib_deps",
559                             "hap_out_dir",
560                             "hap_name",
561                             "install_module_info",
562                             "test_hap",
563                             "test_module",
564                             "module_libs_dir",
565                             "sdk_type_name",
566                             "build_modules",
567                             "hvigor_home",
568                           ])
569    script = "//build/scripts/compile_app.py"
570    outputs = [ unsigned_hap_path_list ]
571
572    args = [
573      "--nodejs",
574      rebase_path(_nodejs, root_build_dir),
575      "--cwd",
576      rebase_path(cwd, root_build_dir),
577      "--build-profile",
578      rebase_path(build_profile, root_build_dir),
579      "--sdk-home",
580      rebase_path(sdk_home),
581      "--output-file",
582      rebase_path(unsigned_hap_path_list, root_build_dir),
583      "--ohpm-registry",
584      ohpm_registry,
585    ]
586
587    if (defined(hvigor_home) && hvigor_home != "") {
588      args += [
589        "--hvigor-home",
590        rebase_path(hvigor_home, root_build_dir),
591      ]
592    }
593
594    if (defined(build_mode) && build_mode == "debug") {
595      args += [ "--enable-debug" ]
596    }
597
598    if (defined(test_hap) && test_hap) {
599      args += [ "--test-hap" ]
600    }
601
602    if (defined(test_module) && test_module != "") {
603      args += [
604        "--test-module",
605        test_module,
606      ]
607    }
608    if (defined(module_libs_dir) && module_libs_dir != "") {
609      args += [
610        "--module-libs-dir",
611        module_libs_dir,
612      ]
613    }
614    if (defined(build_level) && build_level != "") {
615      args += [
616        "--build-level",
617        build_level,
618      ]
619    }
620    if (defined(assemble_type) && assemble_type != "") {
621      args += [
622        "--assemble-type",
623        assemble_type,
624      ]
625    }
626    if (defined(system_lib_deps)) {
627      args += [ "--system-lib-module-info-list" ]
628      foreach(_lib_deps, system_lib_deps) {
629        _lib_out_name = get_label_info(_lib_deps, "name")
630        _lib_out_dir = get_label_info(_lib_deps, "target_out_dir")
631        args +=
632            [ rebase_path("${_lib_out_dir}/${_lib_out_name}_module_info.json",
633                          root_build_dir) ]
634      }
635
636      if (is_ohos) {
637        args += [
638          "--ohos-app-abi",
639          ohos_app_abi,
640        ]
641      }
642    }
643    if (defined(sdk_type_name) && sdk_type_name != []) {
644      args += [ "--sdk-type-name" ]
645      args += sdk_type_name
646    }
647    if (defined(build_modules) && build_modules != []) {
648      args += [ "--build-modules" ]
649      args += build_modules
650    }
651    if (use_hvigor_cache) {
652      args += [ "--use-hvigor-cache" ]
653    }
654    if (hvigor_obfuscation) {
655      args += [ "--hvigor-obfuscation" ]
656    }
657    if (defined(install_module_info)) {
658      metadata = {
659        install_modules = [ install_module_info ]
660      }
661    }
662  }
663}
664