1#!/usr/bin/env python 2# -*- coding: utf-8 -*- 3# Copyright (c) 2021 Huawei Device Co., Ltd. 4# Licensed under the Apache License, Version 2.0 (the "License"); 5# you may not use this file except in compliance with the License. 6# You may obtain a copy of the License at 7# 8# http://www.apache.org/licenses/LICENSE-2.0 9# 10# Unless required by applicable law or agreed to in writing, software 11# distributed under the License is distributed on an "AS IS" BASIS, 12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13# See the License for the specific language governing permissions and 14# limitations under the License. 15 16import os 17import sys 18import load_bundle_file 19 20sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 21from scripts.util.file_utils import read_json_file, write_json_file, write_file # noqa: E402, E501 pylint: disable=C0413, E0611 22 23import_list = """ 24# import("//build/ohos.gni") 25# import("//build/ohos_var.gni") 26import("//build/ohos/ohos_part.gni") 27import("//build/ohos/ohos_kits.gni") 28import("//build/ohos/ohos_test.gni") 29""" 30 31part_template = """ 32ohos_part("{}") {{ 33 subsystem_name = "{}" 34 module_list = [ 35 {} 36 ] 37 origin_name = "{}" 38 variant = "{}" 39}}""" 40 41inner_kits_template = """ 42ohos_inner_kits("{0}_inner_kits") {{ 43 sdk_libs = [ 44{1} 45 ] 46 part_name = "{0}" 47 origin_name = "{2}" 48 variant = "{3}" 49}}""" 50 51system_kits_template = """ 52ohos_system_kits("{0}_system_kits") {{ 53 sdk_libs = [ 54{1} 55 ] 56 part_name = "{0}" 57 origin_name = "{2}" 58 variant = "{3}" 59}}""" 60 61test_template = """ 62ohos_part_test("{0}_test") {{ 63 testonly = true 64 test_packages = [ 65 {1} 66 ] 67 deps = [":{0}"] 68 part_name = "{0}" 69 subsystem_name = "{2}" 70}}""" 71 72 73def _normalize(label, path): 74 if not label.startswith('//'): 75 label = '//{}/{}'.format(path, label) 76 return label 77 78def get_syscap_from_bundle(bundle_file): 79 if not os.path.exists(bundle_file): 80 raise Exception( 81 "config file '{}' doesn't exist.".format(bundle_file)) 82 bundle_config = read_json_file(bundle_file) 83 if bundle_config is None: 84 raise Exception("read file '{}' failed.".format(bundle_file)) 85 part_name = bundle_config.get('component').get('name') 86 part_syscap = bundle_config.get('component').get('syscap') 87 return part_name, part_syscap 88 89def read_build_file(ohos_build_file): 90 if not os.path.exists(ohos_build_file): 91 raise Exception( 92 "config file '{}' doesn't exist.".format(ohos_build_file)) 93 subsystem_config = read_json_file(ohos_build_file) 94 if subsystem_config is None: 95 raise Exception("read file '{}' failed.".format(ohos_build_file)) 96 return subsystem_config 97 98 99class PartObject(object): 100 """"part object info, description part variant.""" 101 102 def __init__(self, part_name, variant_name, part_config, toolchain, 103 subsystem_name, target_arch): 104 self._origin_name = part_name 105 if variant_name != 'phone': 106 _real_name = '{}_{}'.format(part_name, variant_name) 107 else: 108 _real_name = part_name 109 self._part_name = _real_name 110 self._variant_name = variant_name 111 self._subsystem_name = subsystem_name 112 self._feature_list = [] 113 self._toolchain = toolchain 114 self._inner_kits_info = {} 115 self._kits = [] 116 self._target_arch = target_arch 117 self._system_capabilities = [] 118 self._parsing_config(self._part_name, part_config, subsystem_name) 119 120 @classmethod 121 def _parsing_kits_lib(cls, kit_lib, is_inner_kits=False): 122 lib_config = [] 123 lib_type = kit_lib.get('type') 124 if lib_type is None: 125 lib_type = 'so' if is_inner_kits else 'jar' 126 label = kit_lib.get('name') 127 if label is None: 128 raise Exception("kits lib config incorrect, required for name.") 129 lib_config.append(' type = "{}"'.format(lib_type)) 130 lib_config.append(' name = "{}"'.format(label)) 131 if lib_type == 'so' and 'header' in kit_lib: 132 header = kit_lib.get('header') 133 header_files = header.get('header_files') 134 lib_config.append(' header = {') 135 lib_config.append(' header_files = [') 136 for h_file in header_files: 137 lib_config.append(' "{}",'.format(h_file)) 138 lib_config.append(' ]') 139 header_base = header.get('header_base') 140 lib_config.append(' header_base = "{}"'.format(header_base)) 141 lib_config.append(' }') 142 if is_inner_kits is False and 'javadoc' in kit_lib: 143 javadoc_val = kit_lib.get('javadoc') 144 lib_config.append(' javadoc = {') 145 resource_dir = javadoc_val.get('resource_dir') 146 lib_config.append( 147 ' resource_dir = "{}"'.format(resource_dir)) 148 lib_config.append(' }') 149 return lib_config 150 151 def _parsing_inner_kits(self, part_name, inner_kits_info, build_gn_content, 152 target_arch): 153 inner_kits_libs_gn = [] 154 for inner_kits_lib in inner_kits_info: 155 inner_kits_libs_gn.append(' {') 156 inner_kits_libs_gn.extend( 157 self._parsing_kits_lib(inner_kits_lib, True)) 158 inner_kits_libs_gn.append(' },') 159 160 inner_kits_libs_gn_line = '\n'.join(inner_kits_libs_gn) 161 inner_kits_def = inner_kits_template.format(part_name, 162 inner_kits_libs_gn_line, 163 self._origin_name, 164 self._variant_name) 165 build_gn_content.append(inner_kits_def) 166 # output inner kits info to resolve external deps 167 _libs_info = {} 168 for inner_kits_lib in inner_kits_info: 169 info = {'part_name': part_name} 170 label = inner_kits_lib.get('name') 171 lib_name = label.split(':')[1] 172 info['label'] = label 173 info['name'] = lib_name 174 lib_type = inner_kits_lib.get('type') 175 if lib_type is None: 176 lib_type = 'so' 177 info['type'] = lib_type 178 prebuilt = inner_kits_lib.get('prebuilt_enable') 179 if prebuilt: 180 info['prebuilt_enable'] = prebuilt 181 prebuilt_source_libs = inner_kits_lib.get('prebuilt_source') 182 prebuilt_source = prebuilt_source_libs.get(target_arch) 183 info['prebuilt_source'] = prebuilt_source 184 else: 185 info['prebuilt_enable'] = False 186 # header files 187 if lib_type == 'so': 188 header = inner_kits_lib.get('header') 189 if header is None: 190 raise Exception( 191 "header not configuration, part_name = '{}'".format( 192 part_name)) 193 header_base = header.get('header_base') 194 if header_base is None: 195 raise Exception( 196 "header base not configuration, part_name = '{}'". 197 format(part_name)) 198 info['header_base'] = header_base 199 info['header_files'] = header.get('header_files') 200 _libs_info[lib_name] = info 201 self._inner_kits_info = _libs_info 202 203 def _parsing_system_kits(self, part_name, system_kits_info, 204 build_gn_content): 205 system_kits_libs_gn = [] 206 kits = [] 207 for _kits_lib in system_kits_info: 208 system_kits_libs_gn.append(' {') 209 system_kits_libs_gn.extend(self._parsing_kits_lib( 210 _kits_lib, False)) 211 kits.append('"{}"'.format(_kits_lib.get('name'))) 212 system_kits_libs_gn.append(' },') 213 _kits_libs_gn_line = '\n'.join(system_kits_libs_gn) 214 system_kits_def = system_kits_template.format(part_name, 215 _kits_libs_gn_line, 216 self._origin_name, 217 self._variant_name) 218 build_gn_content.append(system_kits_def) 219 self._kits = kits 220 221 def _parsing_config(self, part_name, part_config, subsystem_name): 222 self._part_target_list = [] 223 build_gn_content = [] 224 build_gn_content.append(import_list) 225 226 # ohos part 227 if 'module_list' not in part_config: 228 raise Exception( 229 "ohos.build incorrect, part name: '{}'".format(part_name)) 230 module_list = part_config.get('module_list') 231 if len(module_list) == 0: 232 module_list_line = '' 233 else: 234 module_list_line = '"{}",'.format('",\n "'.join(module_list)) 235 parts_definition = part_template.format(part_name, subsystem_name, 236 module_list_line, 237 self._origin_name, 238 self._variant_name) 239 build_gn_content.append(parts_definition) 240 241 # part inner kits 242 if part_config.get('inner_kits'): 243 self._part_target_list.append('inner_kits') 244 inner_kits_info = part_config.get('inner_kits') 245 self._parsing_inner_kits(part_name, inner_kits_info, 246 build_gn_content, self._target_arch) 247 # part system kits 248 if part_config.get('system_kits'): 249 self._part_target_list.append('system_kits') 250 system_kits_info = part_config.get('system_kits') 251 self._parsing_system_kits(part_name, system_kits_info, 252 build_gn_content) 253 # part test list 254 if part_config.get('test_list'): 255 self._part_target_list.append('test') 256 test_list = part_config.get('test_list') 257 test_list_line = '"{}",'.format('",\n "'.join(test_list)) 258 test_def = test_template.format(part_name, test_list_line, 259 subsystem_name) 260 build_gn_content.append(test_def) 261 self._build_gn_content = build_gn_content 262 # feature 263 if part_config.get('feature_list'): 264 self._feature_list = part_config.get('feature_list') 265 # check feature 266 for _feature_name in self._feature_list: 267 if not _feature_name.startswith('{}_'.format( 268 self._origin_name)): 269 raise Exception( 270 "part feature list config incorrect," 271 " part_name='{}', feature_name='{}'".format( 272 self._origin_name, _feature_name)) 273 274 # system_capabilities is a list attribute of a part in ohos.build 275 if part_config.get('system_capabilities'): 276 self._system_capabilities = part_config.get('system_capabilities') 277 278 def part_name(self): 279 """part name.""" 280 return self._part_name 281 282 def part_variant(self): 283 """part variant.""" 284 return self._variant_name 285 286 def toolchain(self): 287 """current part variant toolchain.""" 288 return self._toolchain 289 290 def part_inner_kits(self): 291 """part inner kits.""" 292 return self._inner_kits_info 293 294 def part_kits(self): 295 """part kits.""" 296 return self._kits 297 298 def write_build_gn(self, config_output_dir): 299 """output build gn.""" 300 part_gn_file = os.path.join(config_output_dir, self._part_name, 301 'BUILD.gn') 302 write_file(part_gn_file, '\n'.join(self._build_gn_content)) 303 304 def get_target_label(self, config_output_relpath): 305 """target label.""" 306 if config_output_relpath.startswith('/'): 307 raise Exception("args config output relative path is incorrect.") 308 if self._toolchain == '': 309 return "//{0}/{1}:{1}".format(config_output_relpath, 310 self._part_name) 311 else: 312 return "//{0}/{1}:{1}({2})".format(config_output_relpath, 313 self._part_name, 314 self._toolchain) 315 316 def part_group_targets(self, config_output_relpath): 317 """part group target.""" 318 if config_output_relpath.startswith('/'): 319 raise Exception("args config output relative path is incorrect.") 320 _labels = {} 321 _labels['part'] = self.get_target_label(config_output_relpath) 322 for group_label in self._part_target_list: 323 if group_label == 'phony': 324 _labels[group_label] = "//{0}/{1}:{1}_{2}".format( 325 config_output_relpath, self._part_name, group_label) 326 continue 327 if self._toolchain == '': 328 _labels[group_label] = "//{0}/{1}:{1}_{2}".format( 329 config_output_relpath, self._part_name, group_label) 330 else: 331 _labels[group_label] = "//{0}/{1}:{1}_{2}({3})".format( 332 config_output_relpath, self._part_name, group_label, 333 self._toolchain) 334 return _labels 335 336 def part_info(self): 337 """part info.""" 338 _info = {} 339 _info['part_name'] = self._part_name 340 _info['origin_part_name'] = self._origin_name 341 _info['toolchain_label'] = self._toolchain 342 _info['variant_name'] = self._variant_name 343 _info['subsystem_name'] = self._subsystem_name 344 _info['system_capabilities'] = self._system_capabilities 345 346 if self._feature_list: 347 _info['feature_list'] = self._feature_list 348 if self._variant_name != 'phone': 349 toolchain_name = self._toolchain.split(':')[1] 350 _build_out_dir = toolchain_name 351 else: 352 _build_out_dir = '.' 353 _info['build_out_dir'] = _build_out_dir 354 return _info 355 356 357class LoadBuildConfig(object): 358 """load build config file and parse configuration info.""" 359 360 def __init__(self, source_root_dir, subsystem_build_info, 361 config_output_dir, variant_toolchains, subsystem_name, 362 target_arch, ignored_subsystems): 363 self._source_root_dir = source_root_dir 364 self._build_info = subsystem_build_info 365 self._config_output_relpath = config_output_dir 366 self._is_load = False 367 self._parts_variants = {} 368 self._part_list = {} 369 self._part_targets_label = {} 370 self._variant_toolchains = variant_toolchains 371 self._subsystem_name = subsystem_name 372 self._target_arch = target_arch 373 self._ignored_subsystems = ignored_subsystems 374 self._parts_info_dict = {} 375 self._phony_targets = {} 376 self._parts_path_dict = {} 377 self._part_hisysevent_config = {} 378 self._parts_module_list = {} 379 380 def _parsing_config(self, parts_config): 381 _parts_info_dict = {} 382 _variant_phony_targets = {} 383 for part_name, value in parts_config.items(): 384 if 'variants' in value: 385 variants = value.get('variants') 386 if len(variants) == 0: 387 variants = ['phone'] 388 else: 389 variants = ['phone'] 390 _build_target = {} 391 _targets_label = {} 392 _parts_info = [] 393 for variant in variants: 394 toolchain = self._variant_toolchains.get(variant) 395 if toolchain is None: 396 continue 397 part_obj = PartObject(part_name, variant, value, toolchain, 398 self._subsystem_name, self._target_arch) 399 real_part_name = part_obj.part_name() 400 self._part_list[real_part_name] = part_obj 401 402 subsystem_config_dir = os.path.join( 403 self._config_output_relpath, self._subsystem_name) 404 part_obj.write_build_gn( 405 os.path.join(self._source_root_dir, subsystem_config_dir)) 406 407 _target_label = part_obj.get_target_label(subsystem_config_dir) 408 _build_target[variant] = _target_label 409 _targets_label[real_part_name] = part_obj.part_group_targets( 410 subsystem_config_dir) 411 _parts_info.append(part_obj.part_info()) 412 if variant != 'phone': 413 _variant_phony_targets[real_part_name] = _target_label 414 self._part_targets_label.update(_targets_label) 415 self._parts_variants[part_name] = _build_target 416 if 'hisysevent_config' in value: 417 _config_files = value.get('hisysevent_config') 418 for _config_file in _config_files: 419 if not _config_file.startswith('//'): 420 raise Exception( 421 "part '{}' hisysevent config incorrest.".format( 422 part_name)) 423 self._part_hisysevent_config[part_name] = _config_files 424 _parts_info_dict[part_name] = _parts_info 425 self._parts_info_dict = _parts_info_dict 426 self._phony_targets = _variant_phony_targets 427 428 def _merge_build_config(self): 429 _build_files = self._build_info.get('build_files') 430 subsystem_name = None 431 parts_info = {} 432 parts_path_dict = {} 433 for _build_file in _build_files: 434 if _build_file.endswith('bundle.json'): 435 bundle_part_obj = load_bundle_file.BundlePartObj(_build_file) 436 _parts_config = bundle_part_obj.to_ohos_build() 437 else: 438 _parts_config = read_build_file(_build_file) 439 _subsystem_name = _parts_config.get('subsystem') 440 if subsystem_name and _subsystem_name != subsystem_name: 441 raise Exception( 442 "subsystem name config incorrect in '{}'.".format( 443 _build_file)) 444 subsystem_name = _subsystem_name 445 _curr_parts_info = _parts_config.get('parts') 446 for _pname in _curr_parts_info.keys(): 447 parts_path_dict[_pname] = os.path.relpath( 448 os.path.dirname(_build_file), self._source_root_dir) 449 parts_info.update(_curr_parts_info) 450 subsystem_config = {} 451 subsystem_config['subsystem'] = subsystem_name 452 subsystem_config['parts'] = parts_info 453 return subsystem_config, parts_path_dict 454 455 def parse_syscap_info(self): 456 _build_files = self._build_info.get('build_files') 457 subsystem_syscap = [] 458 for _build_file in _build_files: 459 if _build_file.endswith('bundle.json'): 460 part_name, part_syscap = get_syscap_from_bundle(_build_file) 461 subsystem_syscap.append({'component': part_name, 'syscap': part_syscap}) 462 return subsystem_syscap 463 464 def parse(self): 465 """parse part info from build config file.""" 466 if self._is_load: 467 return 468 subsystem_config, parts_path_dict = self._merge_build_config() 469 parts_config = subsystem_config.get('parts') 470 self._parts_module_list.update(parts_config) 471 self._parsing_config(parts_config) 472 self._parts_path_dict = parts_path_dict 473 self._is_load = True 474 475 def parts_variants(self): 476 """parts varinats info.""" 477 self.parse() 478 return self._parts_variants 479 480 def parts_inner_kits_info(self): 481 """parts inner kits info.""" 482 self.parse() 483 _parts_inner_kits = {} 484 for part_obj in self._part_list.values(): 485 _parts_inner_kits[ 486 part_obj.part_name()] = part_obj.part_inner_kits() 487 return _parts_inner_kits 488 489 def parts_build_targets(self): 490 """parts build target label.""" 491 self.parse() 492 return self._part_targets_label 493 494 def parts_name_list(self): 495 """parts name list.""" 496 self.parse() 497 return list(self._part_list.keys()) 498 499 def parts_info(self): 500 """parts info.""" 501 self.parse() 502 return self._parts_info_dict 503 504 def parts_phony_target(self): 505 """parts phony target info""" 506 self.parse() 507 return self._phony_targets 508 509 def parts_kits_info(self): 510 """parts kits info.""" 511 self.parse() 512 _parts_kits = {} 513 for part_obj in self._part_list.values(): 514 _parts_kits[part_obj.part_name()] = part_obj.part_kits() 515 return _parts_kits 516 517 def parts_path_info(self): 518 """parts to path info.""" 519 self.parse() 520 return self._parts_path_dict 521 522 def parts_hisysevent_config(self): 523 self.parse() 524 return self._part_hisysevent_config 525 526 def parts_modules_info(self): 527 self.parse() 528 return self._parts_module_list 529 530 531def _output_parts_info(parts_config_dict, config_output_path): 532 parts_info_output_path = os.path.join(config_output_path, "parts_info") 533 # parts_info.json 534 if 'parts_info' in parts_config_dict: 535 parts_info = parts_config_dict.get('parts_info') 536 parts_info_file = os.path.join(parts_info_output_path, 537 "parts_info.json") 538 write_json_file(parts_info_file, parts_info) 539 _part_subsystem_dict = {} 540 for key, value in parts_info.items(): 541 for _info in value: 542 _sub_name = _info.get('subsystem_name') 543 _part_subsystem_dict[key] = _sub_name 544 break 545 _part_subsystem_file = os.path.join(parts_info_output_path, 546 "part_subsystem.json") 547 write_json_file(_part_subsystem_file, _part_subsystem_dict) 548 549 # subsystem_parts.json 550 if 'subsystem_parts' in parts_config_dict: 551 subsystem_parts = parts_config_dict.get('subsystem_parts') 552 subsystem_parts_file = os.path.join(parts_info_output_path, 553 "subsystem_parts.json") 554 write_json_file(subsystem_parts_file, subsystem_parts) 555 # adapter mini system 556 for _sub_name, _p_list in subsystem_parts.items(): 557 _output_info = {} 558 _output_info['parts'] = _p_list 559 _sub_info_output_file = os.path.join(config_output_path, 560 'mini_adapter', 561 '{}.json'.format(_sub_name)) 562 write_json_file(_sub_info_output_file, _output_info) 563 564 # parts_variants.json 565 if 'parts_variants' in parts_config_dict: 566 parts_variants = parts_config_dict.get('parts_variants') 567 parts_variants_info_file = os.path.join(parts_info_output_path, 568 "parts_variants.json") 569 write_json_file(parts_variants_info_file, parts_variants) 570 571 # inner_kits_info.json 572 if 'parts_inner_kits_info' in parts_config_dict: 573 parts_inner_kits_info = parts_config_dict.get('parts_inner_kits_info') 574 parts_inner_kits_info_file = os.path.join(parts_info_output_path, 575 "inner_kits_info.json") 576 write_json_file(parts_inner_kits_info_file, parts_inner_kits_info) 577 578 # parts_targets.json 579 if 'parts_targets' in parts_config_dict: 580 parts_targets = parts_config_dict.get('parts_targets') 581 parts_targets_info_file = os.path.join(parts_info_output_path, 582 "parts_targets.json") 583 write_json_file(parts_targets_info_file, parts_targets) 584 585 # phony_targets.json 586 if 'phony_target' in parts_config_dict: 587 phony_target = parts_config_dict.get('phony_target') 588 phony_target_info_file = os.path.join(parts_info_output_path, 589 "phony_target.json") 590 write_json_file(phony_target_info_file, phony_target) 591 592 # paths_path_info.json 593 if 'parts_path_info' in parts_config_dict: 594 parts_path_info = parts_config_dict.get('parts_path_info') 595 parts_path_info_file = os.path.join(parts_info_output_path, 596 'parts_path_info.json') 597 write_json_file(parts_path_info_file, parts_path_info) 598 path_to_parts = {} 599 for _key, _val in parts_path_info.items(): 600 _p_list = path_to_parts.get(_val, []) 601 _p_list.append(_key) 602 path_to_parts[_val] = _p_list 603 path_to_parts_file = os.path.join(parts_info_output_path, 604 'path_to_parts.json') 605 write_json_file(path_to_parts_file, path_to_parts) 606 607 # hisysevent_config 608 if 'hisysevent_config' in parts_config_dict: 609 hisysevent_config = parts_config_dict.get('hisysevent_config') 610 hisysevent_info_file = os.path.join(parts_info_output_path, 611 'hisysevent_configs.json') 612 write_json_file(hisysevent_info_file, hisysevent_config) 613 614 # _parts_modules_info 615 if 'parts_modules_info' in parts_config_dict: 616 parts_modules_info = parts_config_dict.get('parts_modules_info') 617 _output_info = {} 618 _all_p_info = [] 619 for key, value in parts_modules_info.items(): 620 _p_info = {} 621 _p_info['part_name'] = key 622 _module_list = value.get('module_list') 623 _p_info['module_list'] = _module_list 624 _all_p_info.append(_p_info) 625 _output_info['parts'] = _all_p_info 626 parts_modules_info_file = os.path.join(parts_info_output_path, 627 'parts_modules_info.json') 628 write_json_file(parts_modules_info_file, _output_info) 629 630 631def get_parts_info(source_root_dir, 632 config_output_relpath, 633 subsystem_info, 634 variant_toolchains, 635 target_arch, 636 ignored_subsystems, 637 build_xts=False): 638 """parts info, 639 get info from build config file. 640 """ 641 parts_variants = {} 642 parts_inner_kits_info = {} 643 parts_kits_info = {} 644 parts_targets = {} 645 parts_info = {} 646 subsystem_parts = {} 647 _phony_target = {} 648 _parts_path_info = {} 649 _parts_hisysevent_config = {} 650 _parts_modules_info = {} 651 system_syscap = [] 652 for subsystem_name, build_config_info in subsystem_info.items(): 653 if subsystem_name == 'xts' and build_xts is False: 654 continue 655 build_loader = LoadBuildConfig(source_root_dir, build_config_info, 656 config_output_relpath, 657 variant_toolchains, subsystem_name, 658 target_arch, ignored_subsystems) 659 _parts_variants = build_loader.parts_variants() 660 parts_variants.update(_parts_variants) 661 _inner_kits_info = build_loader.parts_inner_kits_info() 662 parts_inner_kits_info.update(_inner_kits_info) 663 parts_kits_info.update(build_loader.parts_kits_info()) 664 _parts_targets = build_loader.parts_build_targets() 665 parts_targets.update(_parts_targets) 666 subsystem_parts[subsystem_name] = build_loader.parts_name_list() 667 parts_info.update(build_loader.parts_info()) 668 _phony_target.update(build_loader.parts_phony_target()) 669 _parts_path_info.update(build_loader.parts_path_info()) 670 _parts_hisysevent_config.update(build_loader.parts_hisysevent_config()) 671 _parts_modules_info.update(build_loader.parts_modules_info()) 672 system_syscap.extend(build_loader.parse_syscap_info()) 673 parts_config_dict = {} 674 parts_config_dict['parts_info'] = parts_info 675 parts_config_dict['subsystem_parts'] = subsystem_parts 676 parts_config_dict['parts_variants'] = parts_variants 677 parts_config_dict['parts_inner_kits_info'] = parts_inner_kits_info 678 parts_config_dict['parts_kits_info'] = parts_kits_info 679 parts_config_dict['parts_targets'] = parts_targets 680 parts_config_dict['phony_target'] = _phony_target 681 parts_config_dict['parts_path_info'] = _parts_path_info 682 parts_config_dict['hisysevent_config'] = _parts_hisysevent_config 683 parts_config_dict['parts_modules_info'] = _parts_modules_info 684 _output_parts_info(parts_config_dict, 685 os.path.join(source_root_dir, config_output_relpath)) 686 parts_config_dict['syscap_info'] = system_syscap 687 return parts_config_dict 688