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
18namespace OHOS {
19namespace UpdateEngine {
20std::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
35void 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// 此处为桩函数，默认电量足够。
48bool FirmwareUpdateHelper::IsBatteryEnough(int32_t batteryLimit)
49{
50    return true;
51}
52
53InstallType FirmwareUpdateHelper::GetInstallType()
54{
55    InstallType installType = (DeviceAdapter::GetBootSlot()) == Firmware::BOOTSLOTS_AB_UPDATE_VALUE ?
56        InstallType::SYS_INSTALLER : InstallType::UPDATER;
57    FIRMWARE_LOGI("get installType(bootsloot) %{public}d", CAST_INT(installType));
58    return installType;
59}
60
61bool FirmwareUpdateHelper::IsUpgradeFailed(UpgradeStatus status)
62{
63    return status == UpgradeStatus::DOWNLOAD_FAIL ||
64           status == UpgradeStatus::PACKAGE_TRANS_FAIL ||
65           status == UpgradeStatus::INSTALL_FAIL ||
66           status == UpgradeStatus::UPDATE_FAIL ||
67           status == UpgradeStatus::VERIFY_FAIL;
68}
69
70VersionComponent FirmwareUpdateHelper::BuildHotaVersionComponent(std::vector<FirmwareComponent> &hotaComponents)
71{
72    VersionComponent hotaVersionComponent;
73    hotaVersionComponent.componentId = hotaComponents[0].componentId;
74    hotaVersionComponent.upgradeAction = UpgradeAction::UPGRADE;
75    hotaVersionComponent.componentType = CAST_INT(ComponentType::OTA);
76    hotaVersionComponent.effectiveMode = FirmwareUpdateHelper::GetInstallType() == InstallType::SYS_INSTALLER ?
77        static_cast<size_t>(EffectiveMode::LIVE_AND_COLD): static_cast<size_t>(EffectiveMode::COLD);
78    hotaVersionComponent.innerVersion = hotaComponents[0].targetBlVersionNumber;
79    hotaVersionComponent.displayVersion = hotaComponents[0].targetBlDisplayVersionNumber;
80    for (const auto &component : hotaComponents) {
81        hotaVersionComponent.size += static_cast<size_t>(component.size);
82    }
83    return hotaVersionComponent;
84}
85
86void FirmwareUpdateHelper::BuildNewVersionInfo(const std::vector<FirmwareComponent> &components,
87    std::vector<VersionComponent> &versionComponents)
88{
89    if (components.empty()) {
90        FIRMWARE_LOGI("BuildNewVersionInfo component is null");
91        return;
92    }
93    std::vector<FirmwareComponent> hotaComponents;
94    for (auto &component : components) {
95        if (component.blVersionType == CAST_INT(BlType::HOTA_TYPE)) {
96            hotaComponents.push_back(component);
97        }
98        if (component.blVersionType == CAST_INT(BlType::DYNAMIC_TYPE)) {
99            hotaComponents.push_back(component);
100        }
101    }
102
103    if (!hotaComponents.empty()) {
104        VersionComponent hotaVersionComponent = BuildHotaVersionComponent(hotaComponents);
105        versionComponents.push_back(hotaVersionComponent);
106    }
107}
108
109void FirmwareUpdateHelper::BuildCurrentVersionInfo(CurrentVersionInfo &currentVersionInfo)
110{
111    currentVersionInfo.osVersion = DeviceAdapter::GetOsVersion();
112    currentVersionInfo.deviceName = DeviceAdapter::GetDeviceName();
113
114    std::shared_ptr<FirmwarePreferencesUtil> utils = DelayedSingleton<FirmwarePreferencesUtil>::GetInstance();
115    VersionComponent hotaVersionComponent;
116    hotaVersionComponent.displayVersion = DeviceAdapter::GetDisplayVersion();
117    hotaVersionComponent.innerVersion = DeviceAdapter::GetRealVersion();
118    hotaVersionComponent.descriptionInfo.descriptionType = DescriptionType::ID;
119    hotaVersionComponent.componentId = utils->ObtainString(Firmware::HOTA_CURRENT_COMPONENT_ID, "");
120    hotaVersionComponent.componentType = CAST_INT(ComponentType::OTA);
121    currentVersionInfo.versionComponents.push_back(hotaVersionComponent);
122}
123
124bool FirmwareUpdateHelper::IsUpgradePackagesReady(const std::vector<FirmwareComponent> &componentList)
125{
126    if (componentList.empty()) {
127        FIRMWARE_LOGE("IsUpgradePackagesReady: componentList is null!");
128        return false;
129    }
130
131    return std::all_of(componentList.begin(), componentList.end(), [](const FirmwareComponent &component) {
132        if (!FileUtils::IsFileExist(component.spath)) {
133            FIRMWARE_LOGE("IsUpgradePackagesReady: package [%{public}s] is not exist!", component.spath.c_str());
134            return false;
135        }
136        int64_t realSize = FileUtils::GetFileSize(component.spath);
137        if (realSize != component.size) {
138            FIRMWARE_LOGE("IsUpgradePackagesReady: calculate component size %{public}s != DB component size %{public}s",
139                std::to_string(realSize).c_str(), std::to_string(component.size).c_str());
140            return false;
141        }
142        return true;
143    });
144}
145} // namespace UpdateEngine
146} // namespace OHOS