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 "gallery_download_file_stat.h"
19 #include "iservice_registry.h"
20 #include "parameters.h"
21 #include "system_ability_definition.h"
22 #include "utils_log.h"
23
24 namespace OHOS {
25 namespace FileManagement {
26 namespace CloudSync {
27 using namespace std;
28
29 const int32_t DELAY_TIME = 90000; // ms
30 const int32_t SYSTEM_LOAD_DELAY_TIME = 600000; // ms
31
GetInstance()32 TaskStateManager &TaskStateManager::GetInstance()
33 {
34 static TaskStateManager instance;
35 return instance;
36 }
37
TaskStateManager()38 TaskStateManager::TaskStateManager() : queue_("unloadTask")
39 {
40 }
41
StartTask(string bundleName,TaskType task)42 void TaskStateManager::StartTask(string bundleName, TaskType task)
43 {
44 CancelUnloadTask();
45 std::lock_guard<std::mutex> lock(taskMapsMutex_);
46 auto iterator = taskMaps_.find(bundleName);
47 if (iterator == taskMaps_.end()) {
48 taskMaps_[bundleName] = static_cast<uint64_t>(task);
49 return;
50 }
51 auto taskState = iterator->second | static_cast<uint64_t>(task);
52 taskMaps_[bundleName] = taskState;
53 }
54
CompleteTask(string bundleName,TaskType task)55 void TaskStateManager::CompleteTask(string bundleName, TaskType task)
56 {
57 std::lock_guard<std::mutex> lock(taskMapsMutex_);
58 auto iterator = taskMaps_.find(bundleName);
59 if (iterator == taskMaps_.end()) {
60 LOGE("task is not started");
61 } else {
62 taskMaps_[bundleName] = iterator->second & ~static_cast<uint64_t>(task);
63 if (taskMaps_[bundleName] == 0) {
64 taskMaps_.erase(bundleName);
65 }
66 }
67 if (taskMaps_.empty()) {
68 DelayUnloadTask();
69 }
70 }
71
StartTask()72 void TaskStateManager::StartTask()
73 {
74 std::lock_guard<std::mutex> lock(taskMapsMutex_);
75 if (taskMaps_.empty()) {
76 DelayUnloadTask();
77 }
78 }
79
HasTask(const string bundleName,TaskType task)80 bool TaskStateManager::HasTask(const string bundleName, TaskType task)
81 {
82 std::lock_guard<std::mutex> lock(taskMapsMutex_);
83 auto iterator = taskMaps_.find(bundleName);
84 if (iterator != taskMaps_.end()) {
85 if (taskMaps_[bundleName] & static_cast<uint64_t>(task)) {
86 return true;
87 }
88 }
89 return false;
90 }
91
92
CancelUnloadTask()93 void TaskStateManager::CancelUnloadTask()
94 {
95 std::lock_guard<ffrt::mutex> lock(unloadTaskMutex_);
96 if (unloadTaskHandle_ == nullptr) {
97 return;
98 }
99 LOGD("cancel unload task");
100 queue_.cancel(unloadTaskHandle_);
101 unloadTaskHandle_ = nullptr;
102 }
103
DelayUnloadTask()104 void TaskStateManager::DelayUnloadTask()
105 {
106 const std::string temperatureSysparamSync = "persist.kernel.cloudsync.temperature_abnormal_sync";
107 const std::string temperatureSysparamThumb = "persist.kernel.cloudsync.temperature_abnormal_thumb";
108 string systemLoadSync = system::GetParameter(temperatureSysparamSync, "");
109 string systemLoadThumb = system::GetParameter(temperatureSysparamThumb, "");
110 LOGI("delay unload task begin");
111 auto delayTime = DELAY_TIME;
112 if (systemLoadSync == "true" || systemLoadThumb == "true") {
113 LOGE("temperatureSysparam is true, unload task in 10 minutes");
114 delayTime = SYSTEM_LOAD_DELAY_TIME;
115 }
116 auto task = [this]() {
117 LOGI("do unload task");
118 {
119 std::lock_guard<ffrt::mutex> lock(unloadTaskMutex_);
120 unloadTaskHandle_ = nullptr;
121 }
122
123 /* for big data statistics */
124 CloudFile::GalleryDownloadFileStat::GetInstance().OutputToFile();
125
126 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
127 if (samgrProxy == nullptr) {
128 LOGE("get samgr failed");
129 return;
130 }
131 system::SetParameter(CLOUD_FILE_SERVICE_SA_STATUS_FLAG, CLOUD_FILE_SERVICE_SA_END);
132 int32_t ret = samgrProxy->UnloadSystemAbility(FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID);
133 if (ret != ERR_OK) {
134 LOGE("remove system ability failed");
135 return;
136 }
137 };
138
139 CancelUnloadTask();
140 std::lock_guard<ffrt::mutex> lock(unloadTaskMutex_);
141 std::chrono::milliseconds ms(delayTime);
142 auto us = std::chrono::duration_cast<std::chrono::microseconds>(ms);
143 unloadTaskHandle_ = queue_.submit_h(task, ffrt::task_attr().delay(us.count()));
144 }
145 } // namespace CloudSync
146 } // namespace FileManagement
147 } // namespace OHOS