1 /*
2 * Copyright (c) 2022 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 "quick_fix_manager_apply_task.h"
17
18 #include "application_state_observer_stub.h"
19 #include "common_event_data.h"
20 #include "common_event_manager.h"
21 #include "common_event_support.h"
22 #include "hilog_wrapper.h"
23 #include "hitrace_meter.h"
24 #include "quick_fix_callback_stub.h"
25 #include "quick_fix_error_utils.h"
26 #include "quick_fix_manager_service.h"
27 #include "quick_fix/quick_fix_status_callback_host.h"
28 #include "want.h"
29
30 namespace OHOS {
31 namespace AAFwk {
32 namespace {
33 // same with quick_fix_result_info
34 constexpr const char *QUICK_FIX_BUNDLE_NAME = "bundleName";
35 constexpr const char *QUICK_FIX_BUNDLE_VERSION_CODE = "bundleVersionCode";
36 constexpr const char *QUICK_FIX_PATCH_VERSION_CODE = "patchVersionCode";
37 constexpr const char *QUICK_FIX_IS_SO_CONTAINED = "isSoContained";
38 constexpr const char *QUICK_FIX_TYPE = "type";
39 constexpr const char *QUICK_FIX_MODULE_NAME = "moduleNames";
40
41 // common event key
42 constexpr const char *APPLY_RESULT = "applyResult";
43 constexpr const char *APPLY_RESULT_INFO = "applyResultInfo";
44 constexpr const char *BUNDLE_NAME = "bundleName";
45 constexpr const char *BUNDLE_VERSION = "bundleVersion";
46 constexpr const char *PATCH_VERSION = "patchVersion";
47
48 // timeout task
49 constexpr const char *TIMEOUT_TASK_NAME = "timeoutTask";
50 constexpr int64_t TIMEOUT_TASK_DELAY_TIME = 5000;
51 } // namespace
52
53 class QuickFixManagerStatusCallback : public AppExecFwk::QuickFixStatusCallbackHost {
54 public:
QuickFixManagerStatusCallback(std::shared_ptr<QuickFixManagerApplyTask> applyTask)55 explicit QuickFixManagerStatusCallback(std::shared_ptr<QuickFixManagerApplyTask> applyTask)
56 : applyTask_(applyTask)
57 {}
58
~QuickFixManagerStatusCallback()59 virtual ~QuickFixManagerStatusCallback()
60 {
61 HILOG_DEBUG("destroyed.");
62 }
63
OnPatchDeployed(const std::shared_ptr<AppExecFwk::QuickFixResult> & result)64 void OnPatchDeployed(const std::shared_ptr<AppExecFwk::QuickFixResult> &result) override
65 {
66 HILOG_DEBUG("function called.");
67 if (applyTask_ == nullptr) {
68 HILOG_ERROR("Apply task is nullptr, result is %{public}s.", result->ToString().c_str());
69 return;
70 }
71
72 int32_t ret = QUICK_FIX_OK;
73 do {
74 if (result->GetResCode() != 0) {
75 HILOG_ERROR("Deploy quick fix failed, result is %{public}s.", result->ToString().c_str());
76 ret = QUICK_FIX_DEPLOY_FAILED;
77 break;
78 }
79
80 if (!applyTask_->SetQuickFixInfo(result)) {
81 HILOG_ERROR("Set quick fix info failed");
82 ret = QUICK_FIX_SET_INFO_FAILED;
83 break;
84 }
85
86 applyTask_->HandlePatchDeployed();
87 } while (0);
88
89 if (ret != QUICK_FIX_OK) {
90 applyTask_->NotifyApplyStatus(ret);
91 applyTask_->RemoveSelf();
92 }
93 applyTask_->RemoveTimeoutTask();
94 }
95
OnPatchSwitched(const std::shared_ptr<AppExecFwk::QuickFixResult> & result)96 void OnPatchSwitched(const std::shared_ptr<AppExecFwk::QuickFixResult> &result) override
97 {
98 HILOG_DEBUG("function called.");
99 if (applyTask_ == nullptr) {
100 HILOG_ERROR("Apply task is nullptr, result is %{public}s.", result->ToString().c_str());
101 return;
102 }
103
104 int32_t ret = QUICK_FIX_OK;
105 do {
106 if (result->GetResCode() != 0) {
107 HILOG_ERROR("Switch quick fix failed, result is %{public}s.", result->ToString().c_str());
108 ret = QUICK_FIX_SWICH_FAILED;
109 break;
110 }
111
112 applyTask_->HandlePatchSwitched();
113 } while (0);
114
115 if (ret != QUICK_FIX_OK) {
116 applyTask_->NotifyApplyStatus(ret);
117 applyTask_->RemoveSelf();
118 }
119 applyTask_->RemoveTimeoutTask();
120 }
121
OnPatchDeleted(const std::shared_ptr<AppExecFwk::QuickFixResult> & result)122 void OnPatchDeleted(const std::shared_ptr<AppExecFwk::QuickFixResult> &result) override
123 {
124 HILOG_DEBUG("function called.");
125 if (applyTask_ == nullptr) {
126 HILOG_ERROR("Apply task is nullptr, result is %{public}s.", result->ToString().c_str());
127 return;
128 }
129
130 int32_t ret = QUICK_FIX_OK;
131 do {
132 if (result->GetResCode() != 0) {
133 HILOG_ERROR("Delete quick fix failed, result is %{public}s.", result->ToString().c_str());
134 ret = QUICK_FIX_DELETE_FAILED;
135 break;
136 }
137
138 applyTask_->HandlePatchDeleted();
139 } while (0);
140
141 if (ret != QUICK_FIX_OK) {
142 applyTask_->NotifyApplyStatus(ret);
143 applyTask_->RemoveSelf();
144 }
145 applyTask_->RemoveTimeoutTask();
146 }
147
148 private:
149 std::shared_ptr<QuickFixManagerApplyTask> applyTask_;
150 };
151
152 class QuickFixMgrAppStateObserver : public AppExecFwk::ApplicationStateObserverStub {
153 public:
QuickFixMgrAppStateObserver(std::shared_ptr<QuickFixManagerApplyTask> applyTask)154 explicit QuickFixMgrAppStateObserver(std::shared_ptr<QuickFixManagerApplyTask> applyTask)
155 : applyTask_(applyTask)
156 {}
157
~QuickFixMgrAppStateObserver()158 virtual ~QuickFixMgrAppStateObserver()
159 {
160 HILOG_DEBUG("destroyed.");
161 }
162
OnProcessDied(const AppExecFwk::ProcessData & processData)163 void OnProcessDied(const AppExecFwk::ProcessData &processData) override
164 {
165 HILOG_INFO("process died, bundle name is %{public}s.", processData.bundleName.c_str());
166
167 if (applyTask_ == nullptr) {
168 HILOG_ERROR("Apply task is nullptr, bundle name is %{public}s.", processData.bundleName.c_str());
169 return;
170 }
171
172 bool isRunning = applyTask_->GetRunningState();
173 if (!isRunning) {
174 applyTask_->HandlePatchDeployed();
175 }
176
177 applyTask_->UnregAppStateObserver();
178 }
179
180 private:
181 std::shared_ptr<QuickFixManagerApplyTask> applyTask_;
182 };
183
184 class QuickFixNotifyCallback : public AppExecFwk::QuickFixCallbackStub {
185 public:
QuickFixNotifyCallback(std::shared_ptr<QuickFixManagerApplyTask> applyTask)186 explicit QuickFixNotifyCallback(std::shared_ptr<QuickFixManagerApplyTask> applyTask)
187 : applyTask_(applyTask)
188 {}
189
~QuickFixNotifyCallback()190 virtual ~QuickFixNotifyCallback()
191 {
192 HILOG_DEBUG("destroyed.");
193 }
194
OnLoadPatchDone(int32_t resultCode,int32_t recordId)195 void OnLoadPatchDone(int32_t resultCode, [[maybe_unused]] int32_t recordId) override
196 {
197 HILOG_DEBUG("function called.");
198 if (resultCode != 0) {
199 HILOG_ERROR("Notify app load patch failed with %{public}d.", resultCode);
200 applyTask_->NotifyApplyStatus(QUICK_FIX_NOTIFY_LOAD_PATCH_FAILED);
201 applyTask_->RemoveSelf();
202 return;
203 }
204
205 applyTask_->PostDeleteQuickFixTask();
206 }
207
OnUnloadPatchDone(int32_t resultCode,int32_t recordId)208 void OnUnloadPatchDone(int32_t resultCode, [[maybe_unused]] int32_t recordId) override
209 {
210 HILOG_DEBUG("function called.");
211 if (resultCode != 0) {
212 HILOG_ERROR("Notify app load patch failed with %{public}d.", resultCode);
213 applyTask_->NotifyApplyStatus(QUICK_FIX_NOTIFY_UNLOAD_PATCH_FAILED);
214 applyTask_->RemoveSelf();
215 return;
216 }
217
218 applyTask_->PostSwitchQuickFixTask();
219 }
220
OnReloadPageDone(int32_t resultCode,int32_t recordId)221 void OnReloadPageDone(int32_t resultCode, [[maybe_unused]] int32_t recordId) override
222 {
223 HILOG_DEBUG("function called.");
224 if (resultCode != 0) {
225 HILOG_ERROR("Notify app load patch failed with %{public}d.", resultCode);
226 applyTask_->NotifyApplyStatus(QUICK_FIX_NOTIFY_RELOAD_PAGE_FAILED);
227 applyTask_->RemoveSelf();
228 return;
229 }
230
231 applyTask_->NotifyApplyStatus(QUICK_FIX_OK);
232 applyTask_->RemoveSelf();
233 }
234
235 private:
236 std::shared_ptr<QuickFixManagerApplyTask> applyTask_;
237 };
238
~QuickFixManagerApplyTask()239 QuickFixManagerApplyTask::~QuickFixManagerApplyTask()
240 {
241 HILOG_DEBUG("destroyed.");
242 }
243
Run(const std::vector<std::string> & quickFixFiles)244 void QuickFixManagerApplyTask::Run(const std::vector<std::string> &quickFixFiles)
245 {
246 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
247 HILOG_INFO("Run apply task.");
248 PostDeployQuickFixTask(quickFixFiles);
249 }
250
HandlePatchDeployed()251 void QuickFixManagerApplyTask::HandlePatchDeployed()
252 {
253 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
254 HILOG_DEBUG("function called.");
255
256 isRunning_ = GetRunningState();
257 if (isRunning_ && isSoContained_) {
258 return RegAppStateObserver();
259 } else if (isRunning_ && !isSoContained_) {
260 ApplicationQuickFixInfo quickFixInfo;
261 auto service = quickFixMgrService_.promote();
262 if (service == nullptr) {
263 HILOG_ERROR("Quick fix service is nullptr.");
264 NotifyApplyStatus(QUICK_FIX_NOTIFY_UNLOAD_PATCH_FAILED);
265 RemoveSelf();
266 return;
267 }
268
269 auto ret = service->GetApplyedQuickFixInfo(bundleName_, quickFixInfo);
270 if (ret == QUICK_FIX_OK && !quickFixInfo.appqfInfo.hqfInfos.empty()) {
271 // if there exist old version hqfInfo, need to unload.
272 HILOG_DEBUG("Need unload patch firstly.");
273 return PostNotifyUnloadRepairPatchTask();
274 }
275 }
276
277 PostSwitchQuickFixTask();
278 }
279
HandlePatchSwitched()280 void QuickFixManagerApplyTask::HandlePatchSwitched()
281 {
282 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
283 HILOG_DEBUG("function called.");
284
285 if (isRunning_ && !isSoContained_) {
286 return PostNotifyLoadRepairPatchTask();
287 }
288
289 PostDeleteQuickFixTask();
290 }
291
HandlePatchDeleted()292 void QuickFixManagerApplyTask::HandlePatchDeleted()
293 {
294 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
295 HILOG_DEBUG("function called.");
296
297 if (isRunning_ && !isSoContained_ && type_ == AppExecFwk::QuickFixType::HOT_RELOAD) {
298 return PostNotifyHotReloadPageTask();
299 }
300
301 NotifyApplyStatus(QUICK_FIX_OK);
302 RemoveSelf();
303 }
304
PostDeployQuickFixTask(const std::vector<std::string> & quickFixFiles)305 void QuickFixManagerApplyTask::PostDeployQuickFixTask(const std::vector<std::string> &quickFixFiles)
306 {
307 sptr<AppExecFwk::IQuickFixStatusCallback> callback = new (std::nothrow) QuickFixManagerStatusCallback(
308 shared_from_this());
309 if (callback ==nullptr) {
310 HILOG_ERROR("callback is nullptr.");
311 return;
312 }
313 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
314 auto deployTask = [thisWeakPtr, quickFixFiles, callback]() {
315 auto applyTask = thisWeakPtr.lock();
316 if (applyTask == nullptr) {
317 HILOG_ERROR("PostDeployQuickFixTask, Apply task is nullptr.");
318 return;
319 }
320
321 if (applyTask->bundleQfMgr_ == nullptr) {
322 HILOG_ERROR("PostDeployQuickFixTask, Bundle quick fix manager is nullptr.");
323 applyTask->NotifyApplyStatus(QUICK_FIX_BUNDLEMGR_INVALID);
324 applyTask->RemoveSelf();
325 return;
326 }
327
328 auto ret = applyTask->bundleQfMgr_->DeployQuickFix(quickFixFiles, callback);
329 if (ret != 0) {
330 HILOG_ERROR("PostDeployQuickFixTask, Deploy quick fix failed with %{public}d.", ret);
331 applyTask->NotifyApplyStatus(QUICK_FIX_DEPLOY_FAILED);
332 applyTask->RemoveSelf();
333 return;
334 }
335 };
336 if (eventHandler_ == nullptr || !eventHandler_->PostTask(deployTask)) {
337 HILOG_ERROR("Post deploy task failed.");
338 }
339 PostTimeOutTask();
340 }
341
PostSwitchQuickFixTask()342 void QuickFixManagerApplyTask::PostSwitchQuickFixTask()
343 {
344 sptr<AppExecFwk::IQuickFixStatusCallback> callback = new (std::nothrow) QuickFixManagerStatusCallback(
345 shared_from_this());
346 if (callback ==nullptr) {
347 HILOG_ERROR("callback is nullptr.");
348 return;
349 }
350 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
351 auto switchTask = [thisWeakPtr, callback]() {
352 auto applyTask = thisWeakPtr.lock();
353 if (applyTask == nullptr) {
354 HILOG_ERROR("PostSwitchQuickFixTask, Apply task is nullptr.");
355 return;
356 }
357
358 if (applyTask->bundleQfMgr_ == nullptr) {
359 HILOG_ERROR("PostSwitchQuickFixTask, Bundle quick fix manager is nullptr.");
360 applyTask->NotifyApplyStatus(QUICK_FIX_BUNDLEMGR_INVALID);
361 applyTask->RemoveSelf();
362 return;
363 }
364
365 auto ret = applyTask->bundleQfMgr_->SwitchQuickFix(applyTask->bundleName_, true, callback);
366 if (ret != 0) {
367 HILOG_ERROR("PostSwitchQuickFixTask, Switch quick fix failed with %{public}d.", ret);
368 applyTask->NotifyApplyStatus(QUICK_FIX_SWICH_FAILED);
369 applyTask->RemoveSelf();
370 return;
371 }
372 };
373 if (eventHandler_ == nullptr || !eventHandler_->PostTask(switchTask)) {
374 HILOG_ERROR("Post switch task failed.");
375 }
376 PostTimeOutTask();
377 }
378
PostDeleteQuickFixTask()379 void QuickFixManagerApplyTask::PostDeleteQuickFixTask()
380 {
381 auto callback = new (std::nothrow) QuickFixManagerStatusCallback(shared_from_this());
382 if (callback ==nullptr) {
383 HILOG_ERROR("callback is nullptr.");
384 return;
385 }
386 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
387 auto deleteTask = [thisWeakPtr, callback]() {
388 auto applyTask = thisWeakPtr.lock();
389 if (applyTask == nullptr) {
390 HILOG_ERROR("PostDeleteQuickFixTask, Apply task is nullptr.");
391 return;
392 }
393
394 if (applyTask->bundleQfMgr_ == nullptr) {
395 HILOG_ERROR("PostDeleteQuickFixTask, Bundle quick fix manager is nullptr.");
396 applyTask->NotifyApplyStatus(QUICK_FIX_BUNDLEMGR_INVALID);
397 applyTask->RemoveSelf();
398 return;
399 }
400
401 auto ret = applyTask->bundleQfMgr_->DeleteQuickFix(applyTask->bundleName_, callback);
402 if (ret != 0) {
403 HILOG_ERROR("PostDeleteQuickFixTask, Delete quick fix failed with %{public}d.", ret);
404 applyTask->NotifyApplyStatus(QUICK_FIX_DELETE_FAILED);
405 applyTask->RemoveSelf();
406 return;
407 }
408 };
409 if (eventHandler_ == nullptr || !eventHandler_->PostTask(deleteTask)) {
410 HILOG_ERROR("Post delete task failed.");
411 }
412 PostTimeOutTask();
413 }
414
PostTimeOutTask()415 void QuickFixManagerApplyTask::PostTimeOutTask()
416 {
417 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
418 auto timeoutTask = [thisWeakPtr]() {
419 auto applyTask = thisWeakPtr.lock();
420 if (applyTask == nullptr) {
421 HILOG_ERROR("Apply task is nullptr.");
422 return;
423 }
424
425 applyTask->NotifyApplyStatus(QUICK_FIX_PROCESS_TIMEOUT);
426 applyTask->RemoveSelf();
427 };
428 if (eventHandler_ == nullptr || !eventHandler_->PostTask(timeoutTask, TIMEOUT_TASK_NAME, TIMEOUT_TASK_DELAY_TIME)) {
429 HILOG_ERROR("Post delete task failed.");
430 }
431 }
432
RemoveTimeoutTask()433 void QuickFixManagerApplyTask::RemoveTimeoutTask()
434 {
435 if (eventHandler_ == nullptr) {
436 HILOG_ERROR("event handler is nullptr.");
437 return;
438 }
439 eventHandler_->RemoveTask(TIMEOUT_TASK_NAME);
440 }
441
SetQuickFixInfo(const std::shared_ptr<AppExecFwk::QuickFixResult> & result)442 bool QuickFixManagerApplyTask::SetQuickFixInfo(const std::shared_ptr<AppExecFwk::QuickFixResult> &result)
443 {
444 auto resultJson = nlohmann::json::parse(result->ToString());
445 const auto &jsonObjectEnd = resultJson.end();
446 if ((resultJson.find(QUICK_FIX_BUNDLE_NAME) == jsonObjectEnd)
447 || (resultJson.find(QUICK_FIX_BUNDLE_VERSION_CODE) == jsonObjectEnd)
448 || (resultJson.find(QUICK_FIX_PATCH_VERSION_CODE) == jsonObjectEnd)
449 || (resultJson.find(QUICK_FIX_IS_SO_CONTAINED) == jsonObjectEnd)
450 || (resultJson.find(QUICK_FIX_TYPE) == jsonObjectEnd)
451 || (resultJson.find(QUICK_FIX_MODULE_NAME) == jsonObjectEnd)) {
452 HILOG_ERROR("Incomplete result.");
453 return false;
454 }
455
456 bundleName_ = resultJson.at(QUICK_FIX_BUNDLE_NAME).get<std::string>();
457 bundleVersionCode_ = resultJson.at(QUICK_FIX_BUNDLE_VERSION_CODE).get<int>();
458 patchVersionCode_ = resultJson.at(QUICK_FIX_PATCH_VERSION_CODE).get<int>();
459 isSoContained_ = resultJson.at(QUICK_FIX_IS_SO_CONTAINED).get<bool>();
460 type_ = static_cast<AppExecFwk::QuickFixType>(resultJson.at(QUICK_FIX_TYPE).get<int32_t>());
461 if (type_ != AppExecFwk::QuickFixType::PATCH && type_ != AppExecFwk::QuickFixType::HOT_RELOAD) {
462 HILOG_ERROR("Quick fix type is invalid.");
463 return false;
464 }
465 moduleNames_ = resultJson.at(QUICK_FIX_MODULE_NAME).get<std::vector<std::string>>();
466
467 HILOG_INFO("bundleName: %{public}s, bundleVersion: %{public}d, patchVersion: %{public}d, soContained: %{public}d, "
468 "type: %{public}d.", bundleName_.c_str(), bundleVersionCode_, patchVersionCode_, isSoContained_,
469 static_cast<int32_t>(type_));
470 return true;
471 }
472
GetRunningState()473 bool QuickFixManagerApplyTask::GetRunningState()
474 {
475 if (appMgr_ == nullptr) {
476 HILOG_ERROR("App manager is nullptr.");
477 return false;
478 }
479
480 auto ret = appMgr_->GetAppRunningStateByBundleName(bundleName_);
481 HILOG_INFO("Process running state of [%{public}s] is %{public}d.", bundleName_.c_str(), ret);
482 return ret;
483 }
484
NotifyApplyStatus(int32_t applyResult)485 void QuickFixManagerApplyTask::NotifyApplyStatus(int32_t applyResult)
486 {
487 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
488 HILOG_DEBUG("function called.");
489
490 Want want;
491 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_QUICK_FIX_APPLY_RESULT);
492 want.SetParam(APPLY_RESULT, QuickFixErrorUtil::GetErrorCode(applyResult));
493 want.SetParam(APPLY_RESULT_INFO, QuickFixErrorUtil::GetErrorMessage(applyResult));
494 want.SetParam(BUNDLE_NAME, bundleName_);
495 want.SetParam(BUNDLE_VERSION, bundleVersionCode_);
496 want.SetParam(PATCH_VERSION, patchVersionCode_);
497
498 std::string moduleName = std::accumulate(moduleNames_.begin(), moduleNames_.end(), std::string(""),
499 [moduleName = moduleNames_](const std::string &name, const std::string &str) {
500 return (str == moduleName.front()) ? (name + str) : (name + "," + str);
501 });
502 want.SetModuleName(moduleName);
503
504 EventFwk::CommonEventData commonData {want};
505 EventFwk::CommonEventManager::PublishCommonEvent(commonData);
506 }
507
PostNotifyLoadRepairPatchTask()508 void QuickFixManagerApplyTask::PostNotifyLoadRepairPatchTask()
509 {
510 sptr<AppExecFwk::IQuickFixCallback> callback = new (std::nothrow) QuickFixNotifyCallback(shared_from_this());
511 if (callback ==nullptr) {
512 HILOG_ERROR("callback is nullptr.");
513 return;
514 }
515 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
516 auto loadPatchTask = [thisWeakPtr, callback]() {
517 auto applyTask = thisWeakPtr.lock();
518 if (applyTask == nullptr) {
519 HILOG_ERROR("Apply task is nullptr.");
520 return;
521 }
522
523 if (applyTask->appMgr_ == nullptr) {
524 HILOG_ERROR("Appmgr is nullptr.");
525 applyTask->NotifyApplyStatus(QUICK_FIX_APPMGR_INVALID);
526 applyTask->RemoveSelf();
527 return;
528 }
529
530 auto ret = applyTask->appMgr_->NotifyLoadRepairPatch(applyTask->bundleName_, callback);
531 if (ret != 0) {
532 HILOG_ERROR("Notify app load patch failed.");
533 applyTask->NotifyApplyStatus(QUICK_FIX_NOTIFY_LOAD_PATCH_FAILED);
534 applyTask->RemoveSelf();
535 }
536 };
537 if (eventHandler_ == nullptr || !eventHandler_->PostTask(loadPatchTask)) {
538 HILOG_ERROR("Post delete task failed.");
539 }
540 PostTimeOutTask();
541 }
542
PostNotifyUnloadRepairPatchTask()543 void QuickFixManagerApplyTask::PostNotifyUnloadRepairPatchTask()
544 {
545 sptr<AppExecFwk::IQuickFixCallback> callback = new (std::nothrow) QuickFixNotifyCallback(shared_from_this());
546 if (callback ==nullptr) {
547 HILOG_ERROR("callback is nullptr.");
548 return;
549 }
550 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
551 auto unloadPatchTask = [thisWeakPtr, callback]() {
552 auto applyTask = thisWeakPtr.lock();
553 if (applyTask == nullptr) {
554 HILOG_ERROR("Apply task is nullptr.");
555 return;
556 }
557
558 if (applyTask->appMgr_ == nullptr) {
559 HILOG_ERROR("Appmgr is nullptr.");
560 applyTask->NotifyApplyStatus(QUICK_FIX_APPMGR_INVALID);
561 applyTask->RemoveSelf();
562 return;
563 }
564
565 auto ret = applyTask->appMgr_->NotifyUnLoadRepairPatch(applyTask->bundleName_, callback);
566 if (ret != 0) {
567 HILOG_ERROR("Notify app unload patch failed.");
568 applyTask->NotifyApplyStatus(QUICK_FIX_NOTIFY_UNLOAD_PATCH_FAILED);
569 applyTask->RemoveSelf();
570 }
571 };
572 if (eventHandler_ == nullptr || !eventHandler_->PostTask(unloadPatchTask)) {
573 HILOG_ERROR("Post delete task failed.");
574 }
575 PostTimeOutTask();
576 }
577
PostNotifyHotReloadPageTask()578 void QuickFixManagerApplyTask::PostNotifyHotReloadPageTask()
579 {
580 sptr<AppExecFwk::IQuickFixCallback> callback = new (std::nothrow) QuickFixNotifyCallback(shared_from_this());
581 if (callback ==nullptr) {
582 HILOG_ERROR("callback is nullptr.");
583 return;
584 }
585 std::weak_ptr<QuickFixManagerApplyTask> thisWeakPtr(weak_from_this());
586 auto reloadPageTask = [thisWeakPtr, callback]() {
587 auto applyTask = thisWeakPtr.lock();
588 if (applyTask == nullptr) {
589 HILOG_ERROR("Apply task is nullptr.");
590 return;
591 }
592
593 if (applyTask->appMgr_ == nullptr) {
594 HILOG_ERROR("Appmgr is nullptr.");
595 applyTask->NotifyApplyStatus(QUICK_FIX_APPMGR_INVALID);
596 applyTask->RemoveSelf();
597 return;
598 }
599
600 auto ret = applyTask->appMgr_->NotifyHotReloadPage(applyTask->bundleName_, callback);
601 if (ret != 0) {
602 HILOG_ERROR("Notify app reload page failed.");
603 applyTask->NotifyApplyStatus(QUICK_FIX_NOTIFY_RELOAD_PAGE_FAILED);
604 applyTask->RemoveSelf();
605 }
606 };
607 if (eventHandler_ == nullptr || !eventHandler_->PostTask(reloadPageTask)) {
608 HILOG_ERROR("Post delete task failed.");
609 }
610 PostTimeOutTask();
611 }
612
RegAppStateObserver()613 void QuickFixManagerApplyTask::RegAppStateObserver()
614 {
615 HILOG_DEBUG("Register application state observer.");
616 if (appMgr_ == nullptr) {
617 HILOG_ERROR("Appmgr is nullptr.");
618 NotifyApplyStatus(QUICK_FIX_APPMGR_INVALID);
619 RemoveSelf();
620 return;
621 }
622
623 std::vector<std::string> bundleNameList;
624 bundleNameList.push_back(bundleName_);
625 sptr<AppExecFwk::IApplicationStateObserver> callback = new (std::nothrow) QuickFixMgrAppStateObserver(
626 shared_from_this());
627 if (callback ==nullptr) {
628 HILOG_ERROR("callback is nullptr.");
629 return;
630 }
631 auto ret = appMgr_->RegisterApplicationStateObserver(callback, bundleNameList);
632 if (ret != 0) {
633 HILOG_ERROR("Register application state observer failed.");
634 NotifyApplyStatus(QUICK_FIX_REGISTER_OBSERVER_FAILED);
635 RemoveSelf();
636 return;
637 }
638
639 appStateCallback_ = callback;
640 HILOG_DEBUG("Register application state observer succeed.");
641 }
642
UnregAppStateObserver()643 void QuickFixManagerApplyTask::UnregAppStateObserver()
644 {
645 HILOG_DEBUG("Unregister application state observer.");
646 if (appMgr_ == nullptr || appStateCallback_ == nullptr) {
647 HILOG_ERROR("Appmgr or callback is nullptr.");
648 return;
649 }
650
651 auto ret = appMgr_->UnregisterApplicationStateObserver(appStateCallback_);
652 if (ret != 0) {
653 HILOG_ERROR("Unregister application state observer failed.");
654 return;
655 }
656
657 HILOG_DEBUG("Unregister application state observer succeed.");
658 }
659
RemoveSelf()660 void QuickFixManagerApplyTask::RemoveSelf()
661 {
662 auto service = quickFixMgrService_.promote();
663 if (service) {
664 service->RemoveApplyTask(shared_from_this());
665 }
666 }
667 } // namespace AAFwk
668 } // namespace OHOS