1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "firmware_update_helper.h"
17
18 namespace OHOS {
19 namespace UpdateService {
BuildTaskId(const std::vector<FirmwareComponent> & componentList)20 std::string FirmwareUpdateHelper::BuildTaskId(const std::vector<FirmwareComponent> &componentList)
21 {
22 if (componentList.empty()) {
23 return "";
24 }
25 std::string taskId;
26 for (const FirmwareComponent &component : componentList) {
27 if (!taskId.empty()) {
28 taskId.append("_");
29 }
30 taskId.append(component.versionId);
31 }
32 return Sha256Utils::CalculateHashCode(taskId);
33 }
34
ClearFirmwareInfo()35 void FirmwareUpdateHelper::ClearFirmwareInfo()
36 {
37 FIRMWARE_LOGI("ClearFirmwareInfo");
38
39 FirmwareTask task;
40 FirmwareTaskOperator firmwareTaskOperator;
41 firmwareTaskOperator.QueryTask(task);
42 firmwareTaskOperator.DeleteAll();
43 FirmwareComponentOperator().DeleteAll();
44 FirmwareFileUtils::DeleteDownloadFiles();
45 }
46
47 // 此处为桩函数，默认电量足够。
IsBatteryEnough(int32_t batteryLimit)48 bool FirmwareUpdateHelper::IsBatteryEnough(int32_t batteryLimit)
49 {
50 return true;
51 }
52
GetInstallType()53 InstallType FirmwareUpdateHelper::GetInstallType()
54 {
55 InstallType installType = InstallType::QUICK_FIX;
56 if (DeviceAdapter::GetBootSlot() == Firmware::BOOTSLOTS_AB_UPDATE_VALUE) {
57 installType = IsStreamUpgrade() ? InstallType::STREAM_INSTALLLER : InstallType::SYS_INSTALLER;
58 } else {
59 installType = InstallType::UPDATER;
60 }
61 FIRMWARE_LOGI("get installType(bootsloot) %{public}d", CAST_INT(installType));
62 return installType;
63 }
64
IsUpgradeFailed(UpgradeStatus status)65 bool FirmwareUpdateHelper::IsUpgradeFailed(UpgradeStatus status)
66 {
67 return status == UpgradeStatus::DOWNLOAD_FAIL ||
68 status == UpgradeStatus::PACKAGE_TRANS_FAIL ||
69 status == UpgradeStatus::INSTALL_FAIL ||
70 status == UpgradeStatus::UPDATE_FAIL ||
71 status == UpgradeStatus::VERIFY_FAIL;
72 }
73
BuildHotaVersionComponent(std::vector<FirmwareComponent> & hotaComponents)74 VersionComponent FirmwareUpdateHelper::BuildHotaVersionComponent(std::vector<FirmwareComponent> &hotaComponents)
75 {
76 VersionComponent hotaVersionComponent;
77 hotaVersionComponent.componentId = hotaComponents[0].componentId;
78 hotaVersionComponent.upgradeAction = UpgradeAction::UPGRADE;
79 hotaVersionComponent.componentType = CAST_INT(ComponentType::OTA);
80 InstallType InstallType = FirmwareUpdateHelper::GetInstallType();
81 size_t effectiveMode;
82 if (InstallType == InstallType::SYS_INSTALLER || InstallType == InstallType::STREAM_INSTALLLER) {
83 effectiveMode = static_cast<size_t>(EffectiveMode::LIVE_AND_COLD);
84 } else {
85 effectiveMode = static_cast<size_t>(EffectiveMode::COLD);
86 }
87 hotaVersionComponent.effectiveMode = effectiveMode;
88 size_t otaMode;
89 if (InstallType == InstallType::SYS_INSTALLER) {
90 otaMode = static_cast<size_t>(OtaMode::AB_REGULAR_OTA);
91 } else if (InstallType == InstallType::STREAM_INSTALLLER) {
92 otaMode = static_cast<size_t>(OtaMode::AB_STREAM_OTA);
93 } else {
94 otaMode = static_cast<size_t>(OtaMode::REGULAR_OTA);
95 }
96 hotaVersionComponent.otaMode = otaMode;
97 hotaVersionComponent.innerVersion = hotaComponents[0].targetBlVersionNumber;
98 hotaVersionComponent.displayVersion = hotaComponents[0].targetBlDisplayVersionNumber;
99 for (const auto &component : hotaComponents) {
100 hotaVersionComponent.size += static_cast<size_t>(component.size);
101 }
102 return hotaVersionComponent;
103 }
104
BuildNewVersionInfo(const std::vector<FirmwareComponent> & components,std::vector<VersionComponent> & versionComponents)105 void FirmwareUpdateHelper::BuildNewVersionInfo(const std::vector<FirmwareComponent> &components,
106 std::vector<VersionComponent> &versionComponents)
107 {
108 if (components.empty()) {
109 FIRMWARE_LOGI("BuildNewVersionInfo component is null");
110 return;
111 }
112 std::vector<FirmwareComponent> hotaComponents;
113 for (auto &component : components) {
114 if (component.blVersionType == CAST_INT(BlType::HOTA_TYPE)) {
115 hotaComponents.push_back(component);
116 }
117 if (component.blVersionType == CAST_INT(BlType::DYNAMIC_TYPE)) {
118 hotaComponents.push_back(component);
119 }
120 }
121
122 if (!hotaComponents.empty()) {
123 VersionComponent hotaVersionComponent = BuildHotaVersionComponent(hotaComponents);
124 versionComponents.push_back(hotaVersionComponent);
125 }
126 }
127
BuildCurrentVersionInfo(CurrentVersionInfo & currentVersionInfo)128 void FirmwareUpdateHelper::BuildCurrentVersionInfo(CurrentVersionInfo ¤tVersionInfo)
129 {
130 currentVersionInfo.osVersion = DeviceAdapter::GetOsVersion();
131 currentVersionInfo.deviceName = DeviceAdapter::GetDeviceName();
132
133 std::shared_ptr<FirmwarePreferencesUtil> utils = DelayedSingleton<FirmwarePreferencesUtil>::GetInstance();
134 VersionComponent hotaVersionComponent;
135 hotaVersionComponent.displayVersion = DeviceAdapter::GetDisplayVersion();
136 hotaVersionComponent.innerVersion = DeviceAdapter::GetRealVersion();
137 hotaVersionComponent.descriptionInfo.descriptionType = DescriptionType::ID;
138 hotaVersionComponent.componentId = utils->ObtainString(Firmware::HOTA_CURRENT_COMPONENT_ID, "");
139 hotaVersionComponent.componentType = CAST_INT(ComponentType::OTA);
140 currentVersionInfo.versionComponents.push_back(hotaVersionComponent);
141 }
142
IsUpgradePackagesReady(const std::vector<FirmwareComponent> & componentList)143 bool FirmwareUpdateHelper::IsUpgradePackagesReady(const std::vector<FirmwareComponent> &componentList)
144 {
145 if (componentList.empty()) {
146 FIRMWARE_LOGE("IsUpgradePackagesReady: componentList is null!");
147 return false;
148 }
149
150 return std::all_of(componentList.begin(), componentList.end(), [](const FirmwareComponent &component) {
151 if (!FileUtils::IsFileExist(component.spath)) {
152 FIRMWARE_LOGE("IsUpgradePackagesReady: package [%{public}s] is not exist!", component.spath.c_str());
153 return false;
154 }
155 int64_t realSize = FileUtils::GetFileSize(component.spath);
156 if (realSize != component.size) {
157 FIRMWARE_LOGE("IsUpgradePackagesReady: calculate component size %{public}s != DB component size %{public}s",
158 std::to_string(realSize).c_str(), std::to_string(component.size).c_str());
159 return false;
160 }
161 return true;
162 });
163 }
164
IsStreamUpgrade()165 bool FirmwareUpdateHelper::IsStreamUpgrade()
166 {
167 std::vector<FirmwareComponent> components;
168 FirmwareComponentOperator().QueryAll(components);
169 return IsStreamUpgrade(components);
170 }
171
IsStreamUpgrade(const std::vector<FirmwareComponent> & componentList)172 bool FirmwareUpdateHelper::IsStreamUpgrade(const std::vector<FirmwareComponent> &componentList)
173 {
174 if (componentList.empty()) {
175 FIRMWARE_LOGI("FirmwareUpdateHelper::IsStreamUpgrade componentList is empty");
176 return false;
177 }
178 return (componentList[0].otaType == OtaType::AB_STREAM);
179 }
180
181 } // namespace UpdateService
182 } // namespace OHOS