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_manager.h"
17
18#include <cstdlib>
19#include <thread>
20
21#include "config_parse.h"
22#include "dupdate_errno.h"
23#include "dupdate_upgrade_helper.h"
24#ifdef NETMANAGER_BASE_ENABLE
25#include "dupdate_net_manager.h"
26#endif
27#include "file_utils.h"
28#include "firmware_callback_utils.h"
29#include "firmware_changelog_utils.h"
30#include "firmware_common.h"
31#include "firmware_constant.h"
32#include "firmware_database.h"
33#include "firmware_event_listener.h"
34#include "firmware_flow_manager.h"
35#include "firmware_iexecute_mode.h"
36#include "firmware_log.h"
37#include "firmware_manual_check_mode.h"
38#include "firmware_download_mode.h"
39#include "firmware_install_apply_mode.h"
40#include "firmware_status_cache.h"
41#include "firmware_task_operator.h"
42#include "firmware_update_helper.h"
43#include "progress_thread.h"
44#include "schedule_task.h"
45#include "startup_schedule.h"
46#include "string_utils.h"
47#include "time_utils.h"
48
49namespace OHOS {
50namespace UpdateEngine {
51constexpr int32_t INIT_DELAY_TIME = 5; // 进程启动延时时间5秒，为了安装重启之后可以看到版本号及时刷新
52constexpr int32_t PROCESS_EXIT_DELAY_TIME = 1; // 进程退出等待时间，单位：秒
53constexpr uint64_t PULLUP_AFTER_TERMINATE_INTERVAL = 5; // 终止升级后SA拉起间隔
54
55FirmwareManager::FirmwareManager() {}
56
57FirmwareManager::~FirmwareManager()
58{
59    DelayedSingleton<FirmwareEventListener>::GetInstance()->UnregisterNetChangedListener();
60}
61
62void FirmwareManager::Init(StartupReason startupReason)
63{
64    DelayedSingleton<ConfigParse>::GetInstance()->LoadConfigInfo(); // 启动读取配置信息
65    FIRMWARE_LOGI("FirmwareManager Init");
66
67    // 当StartupReason为PROCESS_ENV_RESET时, 会进行以下处理：
68    // 1. 删除Firmware目录（FIRMWARE_DIR_INFOS）中的所有允许删除的目录中的所有文件及子目录
69    // 2. 清空Firmware SP（FirmwarePreferencesUtil）中所有记录
70    // 3. 删除数据库（FirmwareDatabase/DownloadDatabase）
71    if (startupReason == StartupReason::PROCESS_ENV_RESET) {
72        FileUtils::DestroyBaseDirectory(FIRMWARE_DIR_INFOS);
73        preferencesUtil_->RemoveAll();
74        DelayedSingleton<FirmwareDatabase>::GetInstance()->DeleteDbStore();
75    }
76    FileUtils::InitAndCreateBaseDirs(FIRMWARE_DIR_INFOS);
77
78    std::thread initThread([this, startupReason] { this->DelayInit(startupReason); });
79    initThread.detach();
80}
81
82void FirmwareManager::DelayInit(StartupReason startupReason)
83{
84    FIRMWARE_LOGI("FirmwareManager DelayInit startupReason %{public}d", startupReason);
85    RestoreUpdate();
86    DelayedSingleton<FirmwareEventListener>::GetInstance()->RegisterNetChangedListener();
87
88    auto eventType = CommonEventType::PROCESS_INIT;
89    if (startupReason == StartupReason::DEVICE_REBOOT) {
90        // 重启启动，延时5秒，等待系统初始化完再恢复周期提醒alarm | 执行升级结果判断  避免出现通知hap拉不起的问题
91        sleep(INIT_DELAY_TIME);
92        eventType = CommonEventType::BOOT_COMPLETE;
93    }
94
95    // 以下两种情况会向OUC发送初始启动消息：
96    // 1. DUE启动原因为StartupReason::PROCESS_ENV_RESET，DUE缓存数据清空
97    // 2. DUE首次启动，还未向OUC发送过初始启动消息
98    NotifyInitEvent();
99
100    // 处理 设备重启/进程初始化 事件
101    HandleEvent(eventType);
102}
103
104void FirmwareManager::RestoreUpdate()
105{
106    FirmwareTask firmwareTask;
107    FirmwareTaskOperator().QueryTask(firmwareTask);
108    FIRMWARE_LOGI("RestoreUpdate status: %{public}d", firmwareTask.status);
109    if (firmwareTask.status == UpgradeStatus::DOWNLOAD_PAUSE) {
110        HandleBootDownloadPauseStatusProcess(firmwareTask);
111        return;
112    }
113    if (firmwareTask.status == UpgradeStatus::DOWNLOADING) {
114        HandleBootDownloadOnStatusProcess(firmwareTask);
115        return;
116    }
117    if (firmwareTask.status == UpgradeStatus::DOWNLOAD_SUCCESS) {
118        HandleBootDownloadedStatusProcess(firmwareTask);
119        return;
120    }
121
122    if (firmwareTask.status == UpgradeStatus::INSTALLING) {
123        HandleBootInstallOnStatusProcess(firmwareTask);
124        return;
125    }
126}
127
128bool FirmwareManager::IsIdle()
129{
130    if (DelayedSingleton<FirmwareStatusCache>::GetInstance()->IsChecking()) {
131        FIRMWARE_LOGI("FirmwareManager IsIdle checking");
132        return false;
133    }
134
135    FirmwareTask task;
136    FirmwareTaskOperator().QueryTask(task);
137    bool isIdle = !task.isExistTask;
138    FIRMWARE_LOGI("FirmwareManager IsIdle:%{public}s", StringUtils::GetBoolStr(isIdle).c_str());
139    return isIdle;
140}
141
142std::vector<ScheduleTask> FirmwareManager::GetScheduleTasks()
143{
144    ScheduleTask scheduleTask;
145    return {scheduleTask};
146}
147
148bool FirmwareManager::Exit()
149{
150    FIRMWARE_LOGI("FirmwareManager Exit");
151    return true;
152}
153
154void FirmwareManager::DoCancelDownload(BusinessError &businessError)
155{
156    FirmwareTask task;
157    FirmwareTaskOperator().QueryTask(task);
158    if (!task.isExistTask) {
159        FIRMWARE_LOGI("DoCancelDownload no task");
160        businessError.Build(CallResult::FAIL, "no download task to cancel!");
161        businessError.AddErrorMessage(CAST_INT(DUPDATE_ERR_DOWNLOAD_COMMON_ERROR), "no download task to cancel!");
162        return;
163    }
164    ProgressThread::isCancel_ = true;
165    return;
166}
167
168void FirmwareManager::DoTerminateUpgrade(BusinessError &businessError)
169{
170    ScheduleTask scheduleTask;
171    scheduleTask.startupReason = StartupReason::PROCESS_ENV_RESET;
172    scheduleTask.minDelayTime = PULLUP_AFTER_TERMINATE_INTERVAL;
173    if (!DelayedSingleton<StartupSchedule>::GetInstance()->Schedule(scheduleTask)) {
174        FIRMWARE_LOGE("DoTerminateUpgrade fail");
175        businessError.AddErrorMessage(CAST_INT(DUPDATE_ERR_INTERNAL_ERROR), "terminate upgrade error!");
176        return;
177    }
178
179    // 主线程拉起子线程之后向OUC返回回调结果，子线程sleep 1秒之后，DUE进程退出
180    auto execFunc = []() {
181        sleep(PROCESS_EXIT_DELAY_TIME);
182        _Exit(0);
183    };
184    std::thread th = std::thread(execFunc);
185    th.detach();
186}
187
188void FirmwareManager::DoCheck(OnCheckComplete onCheckComplete)
189{
190    auto *flowManager = new FirmwareFlowManager();
191    std::shared_ptr<FirmwareIExecuteMode> executeMode =
192        std::make_shared<FirmwareManualCheckMode>([=](BusinessError &businessError, CheckResult &checkResult) {
193            FIRMWARE_LOGI("FirmwareManager DoCheck newVersionInfoResult");
194            onCheckComplete(businessError, checkResult);
195            delete flowManager;
196        });
197    flowManager->SetExecuteMode(executeMode);
198    flowManager->Start();
199}
200
201void FirmwareManager::DoDownload(const DownloadOptions &downloadOptions, BusinessError &businessError)
202{
203    auto *flowManager = new FirmwareFlowManager();
204    std::shared_ptr<FirmwareIExecuteMode> executeMode =
205        std::make_shared<FirmwareDownloadMode>(downloadOptions, businessError, [=]() {
206            FIRMWARE_LOGI("FirmwareManager DoDownload finish");
207            delete flowManager;
208        });
209    flowManager->SetExecuteMode(executeMode);
210    flowManager->Start();
211}
212
213bool FirmwareManager::CanInstall(void)
214{
215    FirmwareTask task;
216    FirmwareTaskOperator firmwareTaskOperator;
217    firmwareTaskOperator.QueryTask(task);
218    FIRMWARE_LOGI("check can install task.status:%{public}d", CAST_INT(task.status));
219    if (FirmwareUpdateHelper::GetInstallType() == InstallType::SYS_INSTALLER) {
220        return task.status == UpgradeStatus::DOWNLOAD_SUCCESS || task.status == UpgradeStatus::INSTALL_SUCCESS;
221    } else {
222        return task.status == UpgradeStatus::DOWNLOAD_SUCCESS;
223    }
224}
225
226void FirmwareManager::DoInstall(const UpgradeOptions &upgradeOptions, BusinessError &businessError,
227    InstallType installType)
228{
229    FIRMWARE_LOGI("FirmwareManager DoInstall upgradeOptions order:%{public}d, installType = %{public}d",
230        CAST_INT(upgradeOptions.order), CAST_INT(installType));
231    if (!CanInstall()) {
232        FIRMWARE_LOGI("status can not Install");
233        return;
234    }
235    FirmwareFlowManager *flowManager = new FirmwareFlowManager();
236    std::shared_ptr<FirmwareIExecuteMode> executeMode =
237        std::make_shared<FirmwareInstallApplyMode>(upgradeOptions, businessError, installType, [=]() {
238            FIRMWARE_LOGI("FirmwareManager DoInstall finish");
239        });
240    flowManager->SetExecuteMode(executeMode);
241    flowManager->Start();
242}
243
244void FirmwareManager::DoAutoDownloadSwitchChanged(bool isDownloadSwitchOn)
245{
246    FIRMWARE_LOGI("DoAutoDownloadSwitchChanged isDownloadSwitchOn %{public}s", isDownloadSwitchOn ? "on" : "off");
247    preferencesUtil_->SaveBool(Firmware::AUTO_DOWNLOAD_SWITCH, isDownloadSwitchOn);
248    FirmwareTask task;
249    FirmwareTaskOperator().QueryTask(task);
250    if (!task.isExistTask) {
251        FIRMWARE_LOGI("DoAutoDownloadSwitchChanged no task");
252        return;
253    }
254    FIRMWARE_LOGI("DoAutoDownloadSwitchChanged current task status %{public}d", task.status);
255    // 当前是否有搜索完待下载的包
256    if (task.status != UpgradeStatus::CHECK_VERSION_SUCCESS) {
257        return;
258    }
259    if (!isDownloadSwitchOn) {
260        // 开关关，发送新版本通知
261        DelayedSingleton<FirmwareCallbackUtils>::GetInstance()->NotifyEvent(
262            task.taskId, EventId::EVENT_DOWNLOAD_WAIT, UpgradeStatus::CHECK_VERSION_SUCCESS);
263    }
264}
265
266void FirmwareManager::DoClearError(BusinessError &businessError)
267{
268    FirmwareTask task;
269    FirmwareTaskOperator().QueryTask(task);
270    if (!task.isExistTask) {
271        FIRMWARE_LOGI("DoClearError has no task");
272        return;
273    }
274    if (!FirmwareUpdateHelper::IsUpgradeFailed(task.status)) {
275        businessError.Build(CallResult::FAIL, "please check status before clear error");
276        businessError.AddErrorMessage(CAST_INT(DUPDATE_ERR_UPDATE_COMMON_ERROR),
277            "please check status before clear error");
278        return;
279    }
280    FirmwareUpdateHelper::ClearFirmwareInfo();
281}
282
283void FirmwareManager::HandleEvent(CommonEventType event)
284{
285    FIRMWARE_LOGI("handleEvent event %{public}d", static_cast<uint32_t>(event));
286    switch (event) {
287        case CommonEventType::NET_CHANGED:
288            HandleNetChanged();
289            break;
290        case CommonEventType::BOOT_COMPLETE:
291            HandleBootComplete();
292            break;
293        default:
294            break;
295    }
296}
297
298void FirmwareManager::HandleBootComplete()
299{
300    FIRMWARE_LOGI("HandleBootComplete");
301    FirmwareTask task;
302    FirmwareTaskOperator().QueryTask(task);
303    if (!task.isExistTask) {
304        FIRMWARE_LOGI("HandleBootComplete has no task");
305        return;
306    }
307
308    FIRMWARE_LOGI("HandleBootComplete status %{public}d", CAST_INT(task.status));
309    if (task.status == UpgradeStatus::UPDATING) {
310        HandleBootUpdateOnStatusProcess(task);
311        return;
312    }
313}
314
315void FirmwareManager::HandleNetChanged()
316{
317    FIRMWARE_LOGI("HandleNetChanged");
318    #ifdef NETMANAGER_BASE_ENABLE
319    if (!DelayedSingleton<NetManager>::GetInstance()->IsNetAvailable()) {
320        FIRMWARE_LOGE("HandleNetChanged network not available.");
321        ProgressThread::isNoNet_ = true;
322        return;
323    }
324
325    ProgressThread::isNoNet_ = false;
326    FirmwareTask task;
327    FirmwareTaskOperator().QueryTask(task);
328    FIRMWARE_LOGI("HandleNetChanged status %{public}d", task.status);
329
330    if (!DelayedSingleton<NetManager>::GetInstance()->IsNetAvailable(NetType::NOT_METERED_WIFI)) {
331        return;
332    }
333
334    if (task.status == UpgradeStatus::DOWNLOAD_PAUSE) {
335        HandleResumeDownload(task);
336        return;
337    }
338
339    if (task.status == UpgradeStatus::CHECK_VERSION_SUCCESS) {
340        bool isDownloadSwitchOn = preferencesUtil_->ObtainBool(Firmware::AUTO_DOWNLOAD_SWITCH, false);
341        FIRMWARE_LOGI("HandleNetChanged isDownloadSwitchOn %{public}s",
342            StringUtils::GetBoolStr(isDownloadSwitchOn).c_str());
343        if (isDownloadSwitchOn) {
344            DoAutoDownload(task);
345        }
346    }
347    #endif
348}
349
350// updater调用后正常启动
351void FirmwareManager::HandleBootUpdateOnStatusProcess(const FirmwareTask &task)
352{
353    FIRMWARE_LOGI("HandleBootUpdateOnStatusProcess");
354    FirmwareResultProcess resultProcess;
355    std::map<std::string, UpdateResult> resultMap;
356    std::vector<FirmwareComponent> components;
357    FirmwareComponentOperator().QueryAll(components);
358    switch (resultProcess.GetUpdaterResult(components, resultMap)) {
359        case UpdateResultCode::SUCCESS:
360            HandleBootUpdateSuccess(task, resultMap);
361            break;
362        case UpdateResultCode::FAILURE:
363            HandleBootUpdateFail(task, resultMap);
364            break;
365        default:
366            break;
367    }
368}
369
370void FirmwareManager::HandleBootUpdateSuccess(const FirmwareTask &task,
371    const std::map<std::string, UpdateResult> &resultMap)
372{
373    preferencesUtil_->SaveString(Firmware::UPDATE_ACTION, "upgrade");
374    std::vector<FirmwareComponent> components;
375    FirmwareComponentOperator().QueryAll(components);
376    std::vector<VersionComponent> versionComponents;
377    for (const auto &component : components) {
378        VersionComponent versionComponent;
379        versionComponent.componentType = CAST_INT(ComponentType::OTA);
380        versionComponent.componentId = component.componentId;
381        versionComponent.upgradeAction = UpgradeAction::UPGRADE;
382        versionComponent.displayVersion = component.targetBlDisplayVersionNumber;
383        versionComponent.innerVersion = component.targetBlVersionNumber;
384        versionComponent.componentExtra = JsonBuilder().Append("{}").ToJson();
385        versionComponents.push_back(versionComponent);
386    }
387
388    DelayedSingleton<FirmwareChangelogUtils>::GetInstance()->SaveHotaCurrentVersionComponentId();
389    if (task.combinationType == CombinationType::HOTA) {
390        FIRMWARE_LOGI("notify upgrade success");
391        DelayedSingleton<FirmwareCallbackUtils>::GetInstance()->NotifyEvent(task.taskId, EventId::EVENT_UPGRADE_SUCCESS,
392            UpgradeStatus::UPDATE_SUCCESS, ErrorMessage{}, versionComponents);
393        FirmwareUpdateHelper::ClearFirmwareInfo();
394        return;
395    }
396}
397
398void FirmwareManager::HandleBootUpdateFail(const FirmwareTask &task,
399    const std::map<std::string, UpdateResult> &resultMap)
400{
401    preferencesUtil_->SaveString(Firmware::UPDATE_ACTION, "recovery");
402    std::vector<FirmwareComponent> components;
403    FirmwareComponentOperator().QueryAll(components);
404    std::vector<VersionComponent> versionComponents;
405    for (const auto &component : components) {
406        VersionComponent versionComponent;
407        versionComponent.componentType = CAST_INT(ComponentType::OTA);
408        versionComponent.componentId = component.componentId;
409        versionComponent.upgradeAction = UpgradeAction::UPGRADE;
410        versionComponent.displayVersion = component.targetBlDisplayVersionNumber;
411        versionComponent.innerVersion = component.targetBlVersionNumber;
412        versionComponent.componentExtra = JsonBuilder().Append("{}").ToJson();
413        versionComponents.push_back(versionComponent);
414    }
415
416    ErrorMessage errorMessage;
417    for (const auto &result : resultMap) {
418        if (result.second.result == UPDATER_RESULT_FAILURE) {
419            errorMessage.errorCode = CAST_INT(result.second.GetUpdateResultCode());
420            errorMessage.errorMessage = result.second.reason;
421            break;
422        }
423    }
424
425    DelayedSingleton<FirmwareCallbackUtils>::GetInstance()->NotifyEvent(task.taskId, EventId::EVENT_UPGRADE_FAIL,
426        UpgradeStatus::UPDATE_FAIL, errorMessage, versionComponents);
427    FIRMWARE_LOGI("upgrade fail");
428    FirmwareUpdateHelper::ClearFirmwareInfo();
429}
430
431// sysInstaller安装中重启，进度回退为下载完成
432void FirmwareManager::HandleBootInstallOnStatusProcess(FirmwareTask &task)
433{
434    FIRMWARE_LOGI("HandleBootInstallOnStatusProcess");
435    FirmwareTaskOperator().UpdateProgressByTaskId(
436        task.taskId, UpgradeStatus::DOWNLOAD_SUCCESS, Firmware::ONE_HUNDRED);
437    std::vector<FirmwareComponent> firmwareComponentList;
438    FirmwareComponentOperator firmwareComponentOperator;
439    firmwareComponentOperator.QueryAll(firmwareComponentList);
440    for (const FirmwareComponent &component : firmwareComponentList) {
441        if (component.status == UpgradeStatus::INSTALLING) {
442            firmwareComponentOperator.UpdateProgressByUrl(
443                component.url, UpgradeStatus::DOWNLOAD_SUCCESS, Firmware::ONE_HUNDRED);
444        }
445    }
446    BusinessError businessError;
447    UpgradeOptions upgradeOptions;
448    upgradeOptions.order = Order::INSTALL_AND_APPLY;
449    DoInstall(upgradeOptions, businessError, InstallType::SYS_INSTALLER);
450}
451
452void FirmwareManager::HandleBootDownloadOnStatusProcess(FirmwareTask &task)
453{
454    // 下载中重启，清除记录和数据
455    FIRMWARE_LOGI("HandleBootDownloadOnStatusProcess ClearFirmwareInfo");
456    FirmwareUpdateHelper::ClearFirmwareInfo();
457}
458
459void FirmwareManager::HandleBootDownloadPauseStatusProcess(FirmwareTask &task)
460{
461    FirmwareUpdateHelper::ClearFirmwareInfo();
462}
463
464void FirmwareManager::HandleResumeDownload(FirmwareTask &task)
465{
466    FIRMWARE_LOGI("HandleResumeDownload");
467}
468
469void FirmwareManager::HandleBootDownloadedStatusProcess(FirmwareTask &task)
470{
471    FIRMWARE_LOGI("HandleBootDownloadedStatusProcess");
472}
473
474void FirmwareManager::DoAutoDownload(const FirmwareTask &task)
475{
476    FIRMWARE_LOGI("DoAutoDownload");
477}
478
479void FirmwareManager::NotifyInitEvent()
480{
481    bool dueInitFlag = preferencesUtil_->ObtainBool(Constant::DUE_INIT_FLAG, false);
482    FIRMWARE_LOGI("DUE_INIT_FLAG is %{public}s", StringUtils::GetBoolStr(dueInitFlag).c_str());
483    if (!dueInitFlag) {
484        preferencesUtil_->SaveBool(Constant::DUE_INIT_FLAG, true);
485        DelayedSingleton<FirmwareCallbackUtils>::GetInstance()->NotifyEvent("", EventId::EVENT_INITIALIZE,
486            UpgradeStatus::INIT);
487    }
488}
489} // namespace UpdateEngine
490} // namespace OHOS
491