Parts rom Statistics Improvements

Signed-off-by: Nlipengzheng <lipengzheng1@huawei.com>

hb_internal/build/part_rom_statistics.py

@@ -16,100 +16,191 @@ limitations under the License.
 
 """
 
+
 import os
 import re
 import json
-from hb_internal.common.utils import hb_info
 
+from hb_internal.common.utils import hb_info
 
 file_paths = []
-part_names = []
-part_modules_path = {}
-part_modules_paths = []
-standard_part_rom = {}
 standard_part_roms = []
 
 
-def part_size_compare(out_path, part_name, part_size, fp):
+def part_size_compare(module_info_list, part_name, part_size, fp):
     for standard_part in standard_part_roms:
         if standard_part['part_name'] == part_name and standard_part['part_size'] != 'None':
-            sta_size = re.findall(r"\d+",standard_part['part_size'])
-            rea_size = re.findall(r"\d+",part_size)
+            sta_size = re.findall(r"\d+", standard_part['part_size'])
+            rea_size = re.findall(r"\d+", part_size)
             if int(sta_size[0]) >= int(rea_size[0]):
-                conform_str = ("part_name: " + part_name).ljust(55) + ("actual_size: " + part_size).ljust(25) + ("standard_size: " + standard_part['part_size']).ljust(25) + " 'rom' conform to the rules"
+                conform_str = ("part_name: " + part_name).ljust(55) + \
+                              ("actual_size: " + part_size).ljust(25) + \
+                              ("standard_size: " + standard_part['part_size']).ljust(25) + \
+                               " 'rom' conform to the rules"
                 hb_info(conform_str)
-                print(("part_name: " + part_name).ljust(55),("actual_size: " + part_size).ljust(25),("standard_size: " + standard_part['part_size']).ljust(25), " 'rom' conform to the rules",file = fp)
+                print("\n",
+                      ("part_name: " + part_name).ljust(55),
+                      ("actual_size: " + part_size).ljust(25),
+                      ("standard_size: " + standard_part['part_size']).ljust(25),
+                      " 'rom' conform to the rules",
+                      file=fp)
+                for module_info in module_info_list:
+                    print(" ".ljust(4),
+                          ("module_name: " + module_info["module_name"]).ljust(55),
+                          ("module_size: " + module_info["module_size"]).ljust(35),
+                          ("source: " + module_info["source"]).ljust(35),
+                          ("dest: " + ",".join(module_info["dest"])).ljust(35),
+                          file=fp)
             elif int(sta_size[0]) < int(rea_size[0]):
-                out_of_standard_str = ("part_name: "+ part_name).ljust(55) + ("actual_size: "+ part_size).ljust(25) + ("standard_size: "+ standard_part['part_size']).ljust(25) + " 'rom' out of standard"
+                out_of_standard_str = ("part_name: " + part_name).ljust(55) + \
+                                      ("actual_size: " + part_size).ljust(25) + \
+                                      ("standard_size: " + standard_part['part_size']).ljust(25) + \
+                                       " 'rom' out of standard"
                 hb_info(out_of_standard_str)
-                print(("part_name: " + part_name).ljust(55),("actual_size: " + part_size).ljust(25),("standard_size: " + standard_part['part_size']).ljust(25), " 'rom' out of standard",file = fp)
+                print("\n",
+                      ("part_name: " + part_name).ljust(55),
+                      ("actual_size: " + part_size).ljust(25),
+                      ("standard_size: " + standard_part['part_size']).ljust(25),
+                       " 'rom' out of standard",
+                      file=fp)
+                for module_info in module_info_list:
+                    print(" ".ljust(4),
+                          ("module_name: " + module_info["module_name"]).ljust(55),
+                          ("module_size: " + module_info["module_size"]).ljust(35),
+                          ("source: " + module_info["source"]).ljust(35),
+                          ("dest: " + ",".join(module_info["dest"])).ljust(35),
+                          file=fp)
         else:
             if standard_part['part_name'] == part_name and standard_part['part_size'] == 'None':
-                not_yet_standard_str = ("part_name: " + part_name).ljust(55) + ("actual_size: " + part_size).ljust(50) + "This part is not yet standard 'rom'".ljust(25)
+                not_yet_standard_str = ("part_name: " + part_name).ljust(55) + \
+                                       ("actual_size: " + part_size).ljust(50) + \
+                                        "This part is not yet standard 'rom'".ljust(25)
                 hb_info(not_yet_standard_str)
-                print(("part_name:" + part_name).ljust(55),("actual_size:" + part_size).ljust(50),"This part is not yet standard 'rom'".ljust(25),file = fp)
-
+                print("\n",
+                      ("part_name:" + part_name).ljust(55),
+                      ("actual_size:" + part_size).ljust(50),
+                      "This part is not yet standard 'rom'".ljust(25),
+                      file=fp)
+                for module_info in module_info_list:
+                    print(" ".ljust(4),
+                          ("module_name: " + module_info["module_name"]).ljust(55),
+                          ("module_size: " + module_info["module_size"]).ljust(35),
+                          ("source: " + module_info["source"]).ljust(35),
+                          ("dest: " + ",".join(module_info["dest"])).ljust(35),
+                          file=fp)
 
 
 def collect_part_name(root_path):
-    file_path = os.path.join(root_path, "packages/phone/system_install_parts.json")  
+    install_parts = []
+    file_path = os.path.join(root_path, "packages/phone/system_install_parts.json")
     if os.path.isfile(file_path):
-        with open(file_path, 'r') as file:
+        with open(file_path, 'rb') as file:
             file_json = json.load(file)
-            for part_list in file_json:
-                part_name = part_list["part_name"]
-                part_names.append(part_name)
-
-
-def _colletct_modules_json_path(root_path, part_name):
-    for file in os.listdir(root_path):
-        file_path = os.path.join(root_path, file)
-        if file == f'{part_name}_modules.json':
-            part_modules_path.clear()
-            part_modules_path["part_name"] = part_name 
-            part_modules_path["part_path"] = file_path
-            part_modules_paths.append(part_modules_path)
-        if os.path.isdir(file_path):
-            _colletct_modules_json_path(file_path,part_name)   
-
-
-def actual_rom_statistics(out_path, board):
-    collect_part_name(out_path)
-    module_json_path = os.path.join(out_path,'gen/out',board)
-    for part_name in part_names:
-        _colletct_modules_json_path(module_json_path,part_name)
-    file_path = os.path.join(out_path,'rom_statistics_table.log')
-    fp = open(file_path,"a+")
-    fp.seek(0)
-    fp.truncate()
-    for part_name_json_path in part_modules_paths:
-        with open(part_name_json_path['part_path'], 'r') as file:
-            file_json = json.load(file)
-            part_so_size = 0
-            for module_info in file_json:
-                module_info_path = module_info['module_info_file']    
-                with open(os.path.join(out_path, module_info_path), 'r') as file:             
+            for part_info in file_json:
+                part_info_dict = {}
+                part_info_dict["part_name"] = part_info["part_name"]
+                part_info_dict["part_info_file"] = part_info["part_info_file"]
+                install_parts.append(part_info_dict)
+    return install_parts
+
+
+def colletct_modules_json_path(out_path, install_parts):
+    module_info_list = []
+    for part_info_dict in install_parts:
+        part_info_path = os.path.join(out_path, part_info_dict["part_info_file"])
+        if os.path.isfile(part_info_path):
+            with open(part_info_path, 'rb') as file:
+                file_json = json.load(file)
+                for module_info in file_json:
+                    if module_info["part_name"] == part_info_dict["part_name"]:
+                        module_json_path = {}
+                        module_json_path["module_info_path"] = module_info["module_info_file"]
+                        module_json_path["part_name"] = module_info["part_name"]
+                        module_info_list.append(module_json_path)
+    return module_info_list
+
+
+def sum_of_statistics(out_path, part_name, module_info_list):
+    part_so_size = 0
+    module_list = []
+    for module_info in module_info_list:
+        if part_name == module_info['part_name']:
+            module_info_path = os.path.join(out_path, module_info['module_info_path'])
+            if os.path.isfile(module_info_path):
+                with open(module_info_path, 'rb') as file:
                     file_json = json.load(file)
                     so_file_dir = os.path.join(out_path, file_json["source"])
-                    if os.path.isfile(so_file_dir):                                       # 此处只判断有.so文件的rom    在*_module_info.json文件的"source"字段
-                        so_file_size = os.path.getsize(so_file_dir)
-                        part_so_size += so_file_size
-            part_so_size = f'{round(part_so_size/1024)}KB'
-            part_size_compare(out_path,part_name_json_path["part_name"], part_so_size,fp)
+                    if so_file_dir.endswith(".so"):
+                        if os.path.isfile(so_file_dir):
+                            module_info_dict = {}
+                            module_info_dict["module_name"] = file_json["label_name"]
+                            module_info_dict["source"] = file_json["source"]
+                            module_info_dict["dest"] = file_json["dest"]
+                            dest_num = len(file_json["dest"])
+                            so_file_size = os.path.getsize(so_file_dir) * dest_num
+                            part_so_size += so_file_size
+                            module_info_dict["module_size"] = f'{round(so_file_size)/1024}KB'
+                            module_list.append(module_info_dict)
+    return module_list, part_so_size
+
+
+def check_image_size(out_path):
+    image_list = []
+    image_path = os.path.join(out_path, 'packages/phone/images/')
+    if os.path.isdir(image_path):
+        for file in os.listdir(image_path):
+            if file.endswith(".img"):
+                image_dict = {}
+                img_path = os.path.join(image_path,file)
+                image_dict['img_size'] = os.path.getsize(img_path)
+                image_dict['img_name'] = file
+                image_list.append(image_dict)
+    return image_list
+
+
+def image_size_log(image_list, fp):
+    print("Image File Information Statistics:", file=fp)
+    for image_dict in image_list:
+        print(" ".ljust(4),
+              ("image name: " + image_dict['img_name']).ljust(35),
+              ("image size: " + str(image_dict['img_size'])).ljust(25),
+              file=fp)
+
+
+def actual_rom_statistics(out_path):
+    install_parts = collect_part_name(out_path)
+    module_info_list = colletct_modules_json_path(out_path, install_parts)
+
+    file_path = os.path.join(out_path, 'rom_statistics_table.log')
+    fp = open(file_path, "a+")
+    fp.seek(0)
+    fp.truncate()
+    
+    image_list = check_image_size(out_path)
+    image_size_log(image_list, fp)
+
+    for part_info_dict in install_parts:
+        statistics_result = sum_of_statistics(out_path, part_info_dict["part_name"], module_info_list)
+        part_so_size = f'{round(statistics_result[1]/1024)}KB'
+        part_size_compare(statistics_result[0],
+                            part_info_dict["part_name"],
+                            part_so_size,
+                            fp)
     fp.seek(0)
     fp.close()
 
 
 def read_bundle_json_file(file_path):
-    with open(file_path, 'r') as file:
+    with open(file_path, 'rb') as file:
         file_json = json.load(file)
-        standard_part_rom.clear()
+        standard_part_rom = {}
         standard_part_rom["part_name"] = file_json["component"]["name"]
-        if 'rom' not in file_json["component"].keys() or file_json["component"]["rom"] == '':           
+        if 'rom' not in file_json["component"].keys() or file_json["component"]["rom"] == '':
             standard_part_rom["part_size"] = 'None'
         else:
             standard_part_rom["part_size"] = file_json["component"]["rom"]
-        standard_part_roms.append(standard_part_rom)
+        if standard_part_roms.count(standard_part_rom) == 0:
+            standard_part_roms.append(standard_part_rom)
 
 
 def collect_bundle_json_path(part_root_path):
@@ -123,41 +214,41 @@ def collect_bundle_json_path(part_root_path):
 
 def read_subsystem_config(root_path):
     part_json_paths = []
-    part_json_path = os.path.join(root_path,'build/subsystem_config.json')
+    part_json_path = os.path.join(root_path, 'build/subsystem_config.json')
     if os.path.isfile(part_json_path):
         with open(part_json_path, 'r') as file:
             file_json = json.load(file)
             for part_info_valule in file_json.values():
-                for path_k,path_v in part_info_valule.items():
+                for path_k, path_v in part_info_valule.items():
                     if path_k == "path":
                         part_json_paths.append(path_v)
     return part_json_paths
-                      
+
 
 def read_ohos_config(root_path):
     file_path = os.path.join(root_path, "ohos_config.json")
     with open(file_path, 'r') as file:
         file_json = json.load(file)
         os_level = file_json["os_level"]
-        if os_level == 'mini' or os_level == 'small':
-            return -1
         out_path = file_json["out_path"]
         board = file_json["board"]
         product = file_json["product"]
-    return (out_path,board,product)
+    return (out_path, board, product, os_level)
 
 
 def output_part_rom_status(root_path):
     ohos_config = read_ohos_config(root_path)
-    if ohos_config == -1:
-        return -1     
-    part_paths = read_subsystem_config(root_path)
-    for part_path in part_paths:
-        part_root_path = os.path.join(root_path,part_path)
-        if os.path.isdir(part_root_path):
-            collect_bundle_json_path(part_root_path)
-
-    for json_file in file_paths:
-        read_bundle_json_file(json_file)
-    actual_rom_statistics(ohos_config[0],ohos_config[1])
-
+    if ohos_config[3] == "mini":
+        return -1
+    elif ohos_config[3] == "small":
+        return -1
+    else:
+        part_paths = read_subsystem_config(root_path)
+        for part_path in part_paths:
+            part_root_path = os.path.join(root_path, part_path)
+            if os.path.isdir(part_root_path):
+                collect_bundle_json_path(part_root_path)
+        for json_file in file_paths:
+            read_bundle_json_file(json_file)
+        actual_rom_statistics(ohos_config[0])
+    return 0