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 "task_state_manager.h"
17
18 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20 #include "utils_log.h"
21
22 namespace OHOS {
23 namespace FileManagement {
24 namespace CloudSync {
25 using namespace std;
26
27 const string TASK_ID = "unload";
28 const int32_t DELAY_TIME = 180000;
29
GetInstance()30 TaskStateManager &TaskStateManager::GetInstance()
31 {
32 static TaskStateManager instance;
33 return instance;
34 }
35
TaskStateManager()36 TaskStateManager::TaskStateManager()
37 {
38 auto runner = AppExecFwk::EventRunner::Create(TASK_ID);
39 if (unloadHandler_ == nullptr) {
40 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
41 }
42 if (unloadHandler_ == nullptr) {
43 LOGE("init unload handler failed");
44 }
45 }
46
StartTask(string bundleName,TaskType task)47 void TaskStateManager::StartTask(string bundleName, TaskType task)
48 {
49 unloadHandler_->RemoveTask(TASK_ID);
50 std::lock_guard<std::mutex> lock(taskMapsMutex_);
51 auto iterator = taskMaps_.find(bundleName);
52 if (iterator == taskMaps_.end()) {
53 taskMaps_[bundleName] = static_cast<uint64_t>(task);
54 return;
55 }
56 auto taskState = iterator->second | static_cast<uint64_t>(task);
57 taskMaps_[bundleName] = taskState;
58 }
59
CompleteTask(string bundleName,TaskType task)60 void TaskStateManager::CompleteTask(string bundleName, TaskType task)
61 {
62 std::lock_guard<std::mutex> lock(taskMapsMutex_);
63 auto iterator = taskMaps_.find(bundleName);
64 if (iterator == taskMaps_.end()) {
65 LOGE("task is not started");
66 } else {
67 taskMaps_[bundleName] = iterator->second & ~static_cast<uint64_t>(task);
68 if (taskMaps_[bundleName] == 0) {
69 taskMaps_.erase(bundleName);
70 }
71 }
72 if (taskMaps_.empty()) {
73 DelayUnloadTask();
74 }
75 }
76
StartTask()77 void TaskStateManager::StartTask()
78 {
79 std::lock_guard<std::mutex> lock(taskMapsMutex_);
80 if (taskMaps_.empty()) {
81 DelayUnloadTask();
82 }
83 }
84
HasTask(const string bundleName,TaskType task)85 bool TaskStateManager::HasTask(const string bundleName, TaskType task)
86 {
87 std::lock_guard<std::mutex> lock(taskMapsMutex_);
88 auto iterator = taskMaps_.find(bundleName);
89 if (iterator != taskMaps_.end()) {
90 if (taskMaps_[bundleName] & static_cast<uint64_t>(task)) {
91 return true;
92 }
93 }
94 return false;
95 }
96
DelayUnloadTask()97 void TaskStateManager::DelayUnloadTask()
98 {
99 LOGI("delay unload task begin");
100 auto task = [this]() {
101 LOGI("do unload task");
102 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
103 if (samgrProxy == nullptr) {
104 LOGE("get samgr failed");
105 return;
106 }
107 int32_t ret = samgrProxy->UnloadSystemAbility(FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID);
108 if (ret != ERR_OK) {
109 LOGE("remove system ability failed");
110 return;
111 }
112 };
113 LOGI("delay unload task post task");
114 unloadHandler_->RemoveTask(TASK_ID);
115 unloadHandler_->PostTask(task, TASK_ID, DELAY_TIME);
116 }
117 } // namespace CloudSync
118 } // namespace FileManagement
119 } // namespace OHOS