507 lines
19 KiB
Python
507 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
解析当前目录下的 common.ini 文件,获取cp0/cp2/gnss等信息生成version.txt文件
|
|
|
|
调用方法
|
|
python bt_version.py
|
|
"""
|
|
|
|
import os
|
|
import time
|
|
import re
|
|
#import ConfigParser
|
|
#from symbols import BMConfigDir
|
|
try:
|
|
# Python3
|
|
from configparser import ConfigParser
|
|
except ImportError:
|
|
# Python2
|
|
from ConfigParser import ConfigParser
|
|
|
|
CONFIG_FILE = "common.ini"
|
|
VERSION_TXT = "bt_version.txt"
|
|
|
|
SCRIPT_PATH = os.path.dirname(os.path.realpath(__file__))
|
|
|
|
class BT_VERSION(object):
|
|
def __init__(self, product, pac_time, target_board_path):
|
|
self.product = product
|
|
self.pac_time = pac_time
|
|
common_ini = self.parse_common_ini()
|
|
self.cp0_version = common_ini[0].strip()
|
|
self.cp2_version = common_ini[1].strip()
|
|
self.gnss_version = common_ini[2].strip()
|
|
self.cm4_version = common_ini[3].strip()
|
|
self.audio_version = common_ini[4].strip()
|
|
self.cp2_version_txt = ''
|
|
self.gnss_version_txt = ''
|
|
self.pac_name = ''
|
|
self.cm4_version_txt = ''
|
|
self.audio_version_txt = ''
|
|
self.cp_version_dict = {}
|
|
self.target_board_path = target_board_path
|
|
|
|
def get_pac_name(self):
|
|
print("====get_pac_name=====")
|
|
conf = BMConfigParser()
|
|
conf.read(os.path.join(self.product, "pac.ini.bak"))
|
|
pac_name = conf.get("Attr", "PAC_NAME")
|
|
self.pac_name = pac_name.split('.')[0]
|
|
print("pac_name:"+self.pac_name)
|
|
return self.pac_name
|
|
|
|
def get_pac_time(self):
|
|
print("====get_pac_time=====")
|
|
print("pac_time:"+str(self.pac_time))
|
|
return self.pac_time
|
|
|
|
def get_ap_vnd(self):
|
|
print("====get_ap_vnd=====")
|
|
board_path = self.product.split('cp_sign')[0]
|
|
odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
|
|
odm_build_date = os.popen("grep ro.odm.build.date= %s 2>/dev/null" % odm_prop_path).read().strip()
|
|
if odm_build_date:
|
|
ap_vnd_date = odm_build_date.split('=')[-1]
|
|
print("ap vnd date : " + ap_vnd_date)
|
|
return ap_vnd_date
|
|
else:
|
|
print("*****not find build.date*****")
|
|
return ""
|
|
|
|
def get_ap(self):
|
|
print("====get_ap=====")
|
|
board_path = self.product.split('cp_sign')[0]
|
|
odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
|
|
system_ext_prop_path = os.path.join(board_path, "system_ext", "etc", "build.prop")
|
|
odm_cmd = "grep ro.odm.build.description %s 2>/dev/null"%odm_prop_path
|
|
system_ext_cmd = "grep ro.system_ext.build.description %s 2>/dev/null"%system_ext_prop_path
|
|
odm_ap = os.popen(odm_cmd).read().strip()
|
|
system_ext_ap = os.popen(system_ext_cmd).read().strip()
|
|
|
|
if system_ext_ap and odm_ap:
|
|
system_ext_part = system_ext_ap.split('=')[-1]
|
|
ap = odm_ap.split('=')[-1].split(' ')[0] + system_ext_part[system_ext_part.find(' '):]
|
|
print("AP version(ro.build.description) combined: " + ap)
|
|
return ap
|
|
else:
|
|
print("*****not find build.description*****")
|
|
|
|
sys_prop_path = os.path.join(board_path, "system", "build.prop")
|
|
cmd = "grep ro.build.description %s 2>/dev/null"%sys_prop_path
|
|
ap = os.popen(cmd).read().strip()
|
|
if ap:
|
|
ap = ap.split('=')[-1]
|
|
print("AP version(ro.build.description)" + ap)
|
|
return ap
|
|
else:
|
|
print("*****not find ro.build.description*****")
|
|
|
|
cmd1 = 'find %s -maxdepth 1 -name "*.json"'%board_path
|
|
json_path_tmp = os.popen(cmd1).read().strip()
|
|
if not os.path.exists(json_path_tmp):
|
|
print("not find json file")
|
|
return ""
|
|
json_path, json_name = os.path.split(json_path_tmp)
|
|
current_cwd = os.getcwd()
|
|
os.chdir(board_path)
|
|
cmd2 = 'grep -ri \'"DISTRO_VERSION":\' %s'%json_name
|
|
ap = os.popen(cmd2).read().strip()
|
|
if not ap.strip():
|
|
os.chdir(current_cwd)
|
|
print("****not find DISTRO_VERSION****")
|
|
return ""
|
|
ap = ap.split('"')[3]
|
|
print("ap:" + ap)
|
|
os.chdir(current_cwd)
|
|
return ap
|
|
|
|
|
|
def get_cp0(self):
|
|
print("====get_cp0====")
|
|
cp0_version_options = self.cp0_version.split('\n')
|
|
print(cp0_version_options)
|
|
modem_value = ''
|
|
for modem_key in cp0_version_options:
|
|
value = self.get_modem_bin(modem_key)
|
|
modem_value = value.strip().strip('1@')
|
|
if not modem_value:
|
|
continue
|
|
break
|
|
|
|
if not modem_value:
|
|
print('*****modem_value is null*****')
|
|
return ''
|
|
img = modem_value.strip('./')
|
|
cmd = 'strings %s | grep "HW Version:" | awk \'{print $NF}\'' %(img)
|
|
hw_version = os.popen(cmd).read().strip()
|
|
cmd2 = 'strings %s | grep "BASE Version:" | awk \'{print $NF}\'' % (img)
|
|
base_version = os.popen(cmd2).read().strip()
|
|
cmd3 = 'strings %s | grep -Po "\d{2}-\d{2}-\d{4} \d{1,2}:\d{1,2}:\d{1,2}"' % (img)
|
|
kernel_time = os.popen(cmd3).read().strip()
|
|
cp0_version = '|'.join([base_version, hw_version, kernel_time])
|
|
print("CP0_Version:"+cp0_version)
|
|
return cp0_version
|
|
|
|
|
|
|
|
def get_cp2(self):
|
|
print('=====get_cp2=====')
|
|
# 优先从cp_version.txt中获取
|
|
if self.cp_version_dict.get("WCN"):
|
|
cp2_version = self.cp_version_dict.pop("WCN")
|
|
print("version_txt: cp_version.txt \ncp2_version:{}".format(cp2_version))
|
|
return cp2_version.strip()
|
|
|
|
cp2_version_options = self.cp2_version.split('\n')
|
|
print(cp2_version_options)
|
|
modem_value = ''
|
|
for modem_key in cp2_version_options:
|
|
value = self.get_modem_bin(modem_key)
|
|
modem_value = value.strip()
|
|
modem_value = modem_value.strip('1@')
|
|
if not modem_value:
|
|
continue
|
|
break
|
|
|
|
if not modem_value:
|
|
print('*****modem_value is null*****')
|
|
return ''
|
|
img = modem_value.strip('./')
|
|
tmp_path = os.path.dirname(img)
|
|
for i in range(10):
|
|
if not tmp_path:
|
|
print("*****not found cp2 version txt*****")
|
|
return ""
|
|
version_path = os.path.join(tmp_path, 'version.txt')
|
|
print("[CHECK]version path:" + version_path)
|
|
if os.path.isfile(version_path):
|
|
with open(version_path,'r') as f:
|
|
cp2_version = f.read()
|
|
print("version_txt: {} \ncp2_version:{}".format(version_path, cp2_version))
|
|
return cp2_version.strip()
|
|
tmp_path = os.path.dirname(tmp_path)
|
|
|
|
def get_firmware(self):
|
|
print("======get_firmware======")
|
|
versioninfo_path = "vendor/sprd/modules/gpsfirmware/versioninfo.txt"
|
|
if not os.path.exists(versioninfo_path):
|
|
print("*****not found gpsfirmware*****")
|
|
return ''
|
|
|
|
cmd = "grep 'GE2:' %s" % versioninfo_path
|
|
firmware = os.popen(cmd).read().strip()
|
|
if not firmware:
|
|
print("*****firmware is null*****")
|
|
return ''
|
|
firmware = firmware.split('@')[-1]
|
|
print(firmware)
|
|
return firmware
|
|
|
|
|
|
def get_gnss_version(self):
|
|
print("======get_gnss_version======")
|
|
# 优先从cp_version.txt中获取
|
|
if self.cp_version_dict.get("GNSS"):
|
|
gnss_version = self.cp_version_dict.pop("GNSS")
|
|
print("version_txt: cp_version.txt \ngnss_version:{}".format(gnss_version))
|
|
return gnss_version.strip()
|
|
|
|
gnss_version_options = self.gnss_version.split('\n')
|
|
print(gnss_version_options)
|
|
modem_value = ''
|
|
for modem_key in gnss_version_options:
|
|
value = self.get_modem_bin(modem_key)
|
|
modem_value = value.strip()
|
|
modem_value = modem_value.strip('1@')
|
|
if not modem_value:
|
|
continue
|
|
break
|
|
if not modem_value:
|
|
print('*****modem_value is null*****')
|
|
return ''
|
|
|
|
img = modem_value.strip('./')
|
|
tmp_path = os.path.dirname(img)
|
|
for i in range(10):
|
|
if not tmp_path:
|
|
print("*****not found gnss version txt*****")
|
|
return ""
|
|
version_path = os.path.join(tmp_path, 'version.txt')
|
|
print("[CHECK]version path:" + version_path)
|
|
if os.path.isfile(version_path):
|
|
with open(version_path,'r') as f:
|
|
gnss_version = f.read()
|
|
print("version_txt: {} \ngnss_version:{}".format(version_path, gnss_version))
|
|
return gnss_version.strip()
|
|
tmp_path = os.path.dirname(tmp_path)
|
|
|
|
def get_cm4_version(self):
|
|
print("======get_cm4_version======")
|
|
cm4_version_options = self.cm4_version.split('\n')
|
|
print(cm4_version_options)
|
|
modem_value = ''
|
|
for modem_key in cm4_version_options:
|
|
value = self.get_modem_bin(modem_key)
|
|
modem_value = value.strip()
|
|
modem_value = modem_value.strip('1@')
|
|
if not modem_value:
|
|
continue
|
|
break
|
|
if not modem_value:
|
|
print('*****modem_value is null*****')
|
|
return ''
|
|
|
|
img = modem_value.strip('./')
|
|
tmp_path = os.path.dirname(img)
|
|
for i in range(10):
|
|
if not tmp_path:
|
|
print("*****not found cm4 version txt*****")
|
|
return ""
|
|
version_path = os.path.join(tmp_path, 'version.txt')
|
|
print("[CHECK]version path:" + version_path)
|
|
if os.path.isfile(version_path):
|
|
with open(version_path,'r') as f:
|
|
cm4_version = f.read()
|
|
print("version_txt: {} \ncm4_version:{}".format(version_path, cm4_version))
|
|
return cm4_version.strip()
|
|
tmp_path = os.path.dirname(tmp_path)
|
|
|
|
def get_audio_version(self):
|
|
print("======get_audio_version======")
|
|
audio_version_options = self.audio_version.split('\n')
|
|
print(audio_version_options)
|
|
modem_value = ''
|
|
for modem_key in audio_version_options:
|
|
value = self.get_modem_bin(modem_key)
|
|
modem_value = value.strip()
|
|
modem_value = modem_value.strip('1@')
|
|
if not modem_value:
|
|
continue
|
|
break
|
|
if not modem_value:
|
|
print('*****modem_value is null*****')
|
|
return ''
|
|
|
|
img = modem_value.strip('./')
|
|
tmp_path = os.path.dirname(img)
|
|
for i in range(10):
|
|
if not tmp_path:
|
|
print("*****not found audio dsp version txt*****")
|
|
return ""
|
|
version_path = os.path.join(tmp_path, 'version.txt')
|
|
print("[CHECK]version path:" + version_path)
|
|
if os.path.isfile(version_path):
|
|
with open(version_path,'r') as f:
|
|
audio_version = f.read()
|
|
print("version_txt: {} \naudio_dsp_version:{}".format(version_path, audio_version))
|
|
if self.get_cp0().split("|")[0] == audio_version.strip() :
|
|
return ''
|
|
else:
|
|
return audio_version.strip()
|
|
tmp_path = os.path.dirname(tmp_path)
|
|
|
|
def get_product(self):
|
|
print("=====get_product=======")
|
|
board_path = self.product.split('cp_sign')[0]
|
|
odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
|
|
cmd = "grep ro.product.odm.name %s 2>/dev/null"%odm_prop_path
|
|
product = os.popen(cmd).read().strip().split('=')[-1]
|
|
if not product:
|
|
product = self.pac_name.split('-')[0]
|
|
print("product:"+product)
|
|
return product
|
|
|
|
|
|
def get_gms_version(self):
|
|
print("=====get_gms_version=====")
|
|
check_gms = self.pac_name.split('-')[-1].split('_')[0]
|
|
print("check_gms:"+check_gms)
|
|
if check_gms != "gms":
|
|
print("*****Is not gms product*****")
|
|
return ''
|
|
|
|
gms_version_txt = os.path.join(self.target_board_path, 'gms_version.txt')
|
|
if os.path.exists(gms_version_txt):
|
|
print('Load gms version from prebuilt file: ' + gms_version_txt)
|
|
with open(gms_version_txt, 'r') as gf:
|
|
gms_version = gf.readline().strip()
|
|
if gms_version:
|
|
print('Prebuilt gms version: ' + gms_version)
|
|
else:
|
|
print('Bad prebuilt gms version: ' + gms_version)
|
|
return gms_version
|
|
|
|
current_cwd = os.getcwd()
|
|
path = os.path.join(current_cwd, "vendor")
|
|
os.chdir(path)
|
|
cmd = "find -name \"gms.mk\" | xargs grep -ri \"ro.com.google.gmsversion\" \; 2>/dev/null | awk -F '=' '{print$NF}'"
|
|
gms_version = os.popen(cmd).read().strip()
|
|
|
|
if re.search("GMS_PACKAGE_VERSION_ID",gms_version):
|
|
os.chdir(path)
|
|
cmd_m = "find -name \"gms_package_version.mk\" | xargs grep -ri \"GMS_PACKAGE_VERSION_ID\" \; 2>/dev/null | awk -F ':=' '{print$NF}'"
|
|
gms_version = os.popen(cmd_m).read().strip()
|
|
print("gms_version:"+gms_version)
|
|
os.chdir(current_cwd)
|
|
return gms_version
|
|
|
|
|
|
def get_google_patch_version(self):
|
|
current_cwd = os.getcwd()
|
|
fileVer=current_cwd+"/build/core/version_defaults.mk"
|
|
if not os.path.exists(fileVer):
|
|
print('the file isnt exist:',fileVer)
|
|
return ''
|
|
|
|
with open(fileVer,'r') as fv:
|
|
for line in fv.readlines():
|
|
#line = re.sub('^\s+|\s+$','',line)
|
|
m=re.search('PLATFORM_SECURITY_PATCH\s*:=\s*(.*)',line,re.I)
|
|
if m:
|
|
return m.group(1)
|
|
print('dont get google gms version')
|
|
return ''
|
|
|
|
def get_mainline_version(self):
|
|
current_cwd = os.getcwd()
|
|
mainline_file_path = os.path.join(current_cwd, "vendor/partner_modules/INFO")
|
|
if not os.path.exists(mainline_file_path):
|
|
print("mainline_file not exists, file path: {}".format(mainline_file_path))
|
|
return ""
|
|
|
|
with open(mainline_file_path, 'r') as f:
|
|
for line in f.readlines():
|
|
if line.startswith("mainline_version:"):
|
|
value = line.replace("mainline_version:", "").strip()
|
|
return value
|
|
print("not found mainline version.")
|
|
return ""
|
|
|
|
def _load_cp_version(self, path):
|
|
print("=============== start load cp_version.txt =============== ")
|
|
with open(path, 'r') as f:
|
|
for line in f.readlines():
|
|
line = line.strip()
|
|
config_pair = line.split("=", 1)
|
|
if len(config_pair) == 2:
|
|
key, value = config_pair
|
|
if key and value:
|
|
self.cp_version_dict[key] = value
|
|
else:
|
|
print("cp_version.txt invalid line: {}".format(line))
|
|
else:
|
|
print("cp_version.txt invalid line: {}".format(line))
|
|
|
|
def out_version(self, target_board_path):
|
|
print("=============== make BT_VERSION start =======================")
|
|
version_path = os.path.join(self.product, VERSION_TXT)
|
|
if os.path.exists(version_path):
|
|
os.remove(version_path)
|
|
|
|
# 加载cp_version.txt
|
|
cp_version_path = os.path.join(target_board_path, "cp_version.txt")
|
|
if os.path.isfile(cp_version_path):
|
|
self._load_cp_version(cp_version_path)
|
|
|
|
with open(version_path, 'w') as out_f:
|
|
out_f.write("["+self.get_pac_name()+"]")
|
|
out_f.write("\n")
|
|
out_f.write("PAC_Time="+self.get_pac_time())
|
|
out_f.write("\n")
|
|
out_f.write("AP="+self.get_ap())
|
|
out_f.write("\n")
|
|
# 解耦分支获取vnd分支编译时间戳
|
|
ap_vnd = self.get_ap_vnd()
|
|
if ap_vnd:
|
|
out_f.write("AP_VND="+ap_vnd)
|
|
out_f.write("\n")
|
|
out_f.write("CP0="+self.get_cp0())
|
|
out_f.write("\n")
|
|
out_f.write("CP2="+self.get_cp2())
|
|
out_f.write("\n")
|
|
out_f.write("CM4="+self.get_cm4_version())
|
|
out_f.write("\n")
|
|
out_f.write("AUDIO_DSP="+self.get_audio_version())
|
|
out_f.write("\n")
|
|
out_f.write("firmware="+self.get_firmware())
|
|
out_f.write("\n")
|
|
out_f.write("gnss_version="+self.get_gnss_version())
|
|
out_f.write("\n")
|
|
out_f.write("Product="+self.get_product())
|
|
out_f.write("\n")
|
|
out_f.write("gms_version="+self.get_gms_version())
|
|
out_f.write("\n")
|
|
out_f.write("Google_security_patch="+self.get_google_patch_version())
|
|
out_f.write("\n")
|
|
out_f.write("mainline_version="+self.get_mainline_version())
|
|
|
|
# 将cp_version.txt其他字段写入
|
|
if self.cp_version_dict:
|
|
for ik, iv in self.cp_version_dict.items():
|
|
out_f.write("{}={}\n".format(ik, iv))
|
|
|
|
print("=============== make BT_VERSION end =======================")
|
|
|
|
def parse_common_ini(self):
|
|
conf = BMConfigParser()
|
|
common_ini = os.path.join(SCRIPT_PATH, CONFIG_FILE)
|
|
if not os.path.exists(common_ini):
|
|
print("*****not find common.ini*****")
|
|
return ""
|
|
conf.read(common_ini)
|
|
cp0_version = conf.get("cp0_version", "partition")
|
|
cp2_version = conf.get("cp2_version", "partition")
|
|
gnss_version = conf.get("gnss_version", "partition")
|
|
cm4_version = conf.get("cm4_version", "partition")
|
|
audio_version = conf.get("audio_version", "partition")
|
|
|
|
param = [cp0_version,cp2_version,gnss_version,cm4_version,audio_version]
|
|
return param
|
|
|
|
def get_modem_bin(self, modem_key):
|
|
conf = BMConfigParser()
|
|
conf.read(os.path.join(self.product, "pac.ini.bak"))
|
|
modem_keys = conf.options("pac_list")
|
|
if modem_key not in modem_keys:
|
|
return ""
|
|
modem_bin = conf.get("pac_list", modem_key)
|
|
return modem_bin.strip()
|
|
|
|
def find_cp2_txt(self, dir):
|
|
if not os.path.exists(dir):
|
|
print("find_cp2_txt--not find "+str(dir))
|
|
return
|
|
for file in os.listdir(dir):
|
|
file_tmp = os.path.join(dir, file)
|
|
if os.path.isfile(file_tmp):
|
|
if file == "version.txt":
|
|
self.cp2_version_txt = file_tmp
|
|
break
|
|
else:
|
|
if file == ".git":
|
|
continue
|
|
self.find_cp2_txt(file_tmp)
|
|
|
|
def find_gnss_txt(self, dir):
|
|
if not os.path.exists(dir):
|
|
print("find_gnss_txt--not find "+str(dir))
|
|
return
|
|
for file in os.listdir(dir):
|
|
file_tmp = os.path.join(dir, file)
|
|
if os.path.isfile(file_tmp):
|
|
if file == "version.txt":
|
|
self.gnss_version_txt = file_tmp
|
|
break
|
|
else:
|
|
if file == ".git":
|
|
continue
|
|
self.find_gnss_txt(file_tmp)
|
|
|
|
class BMConfigParser(ConfigParser):
|
|
def __init__(self, defaults=None):
|
|
ConfigParser.__init__(self, defaults=defaults)
|
|
|
|
def optionxform(self, option_str):
|
|
return option_str
|