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
GetInstance()31 TaskStateManager &TaskStateManager::GetInstance()
32 {
33 static TaskStateManager instance;
34 return instance;
35 }
36
TaskStateManager()37 TaskStateManager::TaskStateManager() : queue_("unloadTask")
38 {
39 }
40
StartTask(string bundleName,TaskType task)41 void TaskStateManager::StartTask(string bundleName, TaskType task)
42 {
43 CancelUnloadTask();
44 std::lock_guard<std::mutex> lock(taskMapsMutex_);
45 auto iterator = taskMaps_.find(bundleName);
46 if (iterator == taskMaps_.end()) {
47 taskMaps_[bundleName] = static_cast<uint64_t>(task);
48 return;
49 }
50 auto taskState = iterator->second | static_cast<uint64_t>(task);
51 taskMaps_[bundleName] = taskState;
52 }
53
CompleteTask(string bundleName,TaskType task)54 void TaskStateManager::CompleteTask(string bundleName, TaskType task)
55 {
56 std::lock_guard<std::mutex> lock(taskMapsMutex_);
57 auto iterator = taskMaps_.find(bundleName);
58 if (iterator == taskMaps_.end()) {
59 LOGE("task is not started");
60 } else {
61 taskMaps_[bundleName] = iterator->second & ~static_cast<uint64_t>(task);
62 if (taskMaps_[bundleName] == 0) {
63 taskMaps_.erase(bundleName);
64 }
65 }
66 if (taskMaps_.empty()) {
67 DelayUnloadTask();
68 }
69 }
70
StartTask()71 void TaskStateManager::StartTask()
72 {
73 std::lock_guard<std::mutex> lock(taskMapsMutex_);
74 if (taskMaps_.empty()) {
75 DelayUnloadTask();
76 }
77 }
78
HasTask(const string bundleName,TaskType task)79 bool TaskStateManager::HasTask(const string bundleName, TaskType task)
80 {
81 std::lock_guard<std::mutex> lock(taskMapsMutex_);
82 auto iterator = taskMaps_.find(bundleName);
83 if (iterator != taskMaps_.end()) {
84 if (taskMaps_[bundleName] & static_cast<uint64_t>(task)) {
85 return true;
86 }
87 }
88 return false;
89 }
90
91
CancelUnloadTask()92 void TaskStateManager::CancelUnloadTask()
93 {
94 std::lock_guard<ffrt::mutex> lock(unloadTaskMutex_);
95 if (unloadTaskHandle_ == nullptr) {
96 return;
97 }
98 LOGD("cancel unload task");
99 queue_.cancel(unloadTaskHandle_);
100 unloadTaskHandle_ = nullptr;
101 }
102
DelayUnloadTask()103 void TaskStateManager::DelayUnloadTask()
104 {
105 const std::string temperatureSysparamSync = "persist.kernel.cloudsync.temperature_abnormal_sync";
106 const std::string temperatureSysparamThumb = "persist.kernel.cloudsync.temperature_abnormal_thumb";
107 string systemLoadSync = system::GetParameter(temperatureSysparamSync, "");
108 string systemLoadThumb = system::GetParameter(temperatureSysparamThumb, "");
109 if (systemLoadSync == "true" || systemLoadThumb == "true") {
110 LOGE("temperatureSysparam is true, don't stop");
111 CancelUnloadTask();
112 return;
113 }
114
115 LOGI("delay unload task begin");
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(DELAY_TIME);
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