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 
49 namespace OHOS {
50 namespace UpdateEngine {
51 constexpr int32_t INIT_DELAY_TIME = 5; // 进程启动延时时间5秒，为了安装重启之后可以看到版本号及时刷新
52 constexpr int32_t PROCESS_EXIT_DELAY_TIME = 1; // 进程退出等待时间，单位：秒
53 constexpr uint64_t PULLUP_AFTER_TERMINATE_INTERVAL = 5; // 终止升级后SA拉起间隔
54 
FirmwareManager()55 FirmwareManager::FirmwareManager() {}
56 
~FirmwareManager()57 FirmwareManager::~FirmwareManager()
58 {
59     DelayedSingleton<FirmwareEventListener>::GetInstance()->UnregisterNetChangedListener();
60 }
61 
Init(StartupReason startupReason)62 void 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 
DelayInit(StartupReason startupReason)82 void 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 
RestoreUpdate()104 void 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 
IsIdle()128 bool 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 
GetScheduleTasks()142 std::vector<ScheduleTask> FirmwareManager::GetScheduleTasks()
143 {
144     ScheduleTask scheduleTask;
145     return {scheduleTask};
146 }
147 
Exit()148 bool FirmwareManager::Exit()
149 {
150     FIRMWARE_LOGI("FirmwareManager Exit");
151     return true;
152 }
153 
DoCancelDownload(BusinessError & businessError)154 void 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 
DoTerminateUpgrade(BusinessError & businessError)168 void 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 
DoCheck(OnCheckComplete onCheckComplete)188 void 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 
DoDownload(const DownloadOptions & downloadOptions,BusinessError & businessError)201 void 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 
CanInstall(void)213 bool 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 
DoInstall(const UpgradeOptions & upgradeOptions,BusinessError & businessError,InstallType installType)226 void 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 
DoAutoDownloadSwitchChanged(bool isDownloadSwitchOn)244 void 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 
DoClearError(BusinessError & businessError)266 void 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 
HandleEvent(CommonEventType event)283 void 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 
HandleBootComplete()298 void 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 
HandleNetChanged()315 void 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调用后正常启动
HandleBootUpdateOnStatusProcess(const FirmwareTask & task)351 void 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 
HandleBootUpdateSuccess(const FirmwareTask & task,const std::map<std::string,UpdateResult> & resultMap)370 void 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 
HandleBootUpdateFail(const FirmwareTask & task,const std::map<std::string,UpdateResult> & resultMap)398 void 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安装中重启，进度回退为下载完成
HandleBootInstallOnStatusProcess(FirmwareTask & task)432 void 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 
HandleBootDownloadOnStatusProcess(FirmwareTask & task)452 void FirmwareManager::HandleBootDownloadOnStatusProcess(FirmwareTask &task)
453 {
454     // 下载中重启，清除记录和数据
455     FIRMWARE_LOGI("HandleBootDownloadOnStatusProcess ClearFirmwareInfo");
456     FirmwareUpdateHelper::ClearFirmwareInfo();
457 }
458 
HandleBootDownloadPauseStatusProcess(FirmwareTask & task)459 void FirmwareManager::HandleBootDownloadPauseStatusProcess(FirmwareTask &task)
460 {
461     FirmwareUpdateHelper::ClearFirmwareInfo();
462 }
463 
HandleResumeDownload(FirmwareTask & task)464 void FirmwareManager::HandleResumeDownload(FirmwareTask &task)
465 {
466     FIRMWARE_LOGI("HandleResumeDownload");
467 }
468 
HandleBootDownloadedStatusProcess(FirmwareTask & task)469 void FirmwareManager::HandleBootDownloadedStatusProcess(FirmwareTask &task)
470 {
471     FIRMWARE_LOGI("HandleBootDownloadedStatusProcess");
472 }
473 
DoAutoDownload(const FirmwareTask & task)474 void FirmwareManager::DoAutoDownload(const FirmwareTask &task)
475 {
476     FIRMWARE_LOGI("DoAutoDownload");
477 }
478 
NotifyInitEvent()479 void 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