1 /*
2 * Copyright (c) 2021 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_data_persistence_mgr.h"
17 #include "ability_util.h"
18 #include "directory_ex.h"
19 #include "hilog_wrapper.h"
20
21 namespace OHOS {
22 namespace AAFwk {
TaskDataPersistenceMgr()23 TaskDataPersistenceMgr::TaskDataPersistenceMgr()
24 {
25 HILOG_INFO("TaskDataPersistenceMgr instance is created");
26 }
27
~TaskDataPersistenceMgr()28 TaskDataPersistenceMgr::~TaskDataPersistenceMgr()
29 {
30 HILOG_INFO("TaskDataPersistenceMgr instance is destroyed");
31 }
32
Init(int userId)33 bool TaskDataPersistenceMgr::Init(int userId)
34 {
35 if (!handler_) {
36 handler_ = TaskHandlerWrap::GetFfrtHandler();
37 CHECK_POINTER_RETURN_BOOL(handler_);
38 }
39
40 std::lock_guard<ffrt::mutex> lock(mutex_);
41 if (missionDataStorageMgr_.find(userId) == missionDataStorageMgr_.end()) {
42 currentMissionDataStorage_ = std::make_shared<MissionDataStorage>(userId);
43 missionDataStorageMgr_.insert(std::make_pair(userId, currentMissionDataStorage_));
44 } else {
45 currentMissionDataStorage_ = missionDataStorageMgr_[userId];
46 }
47 currentUserId_ = userId;
48
49 CHECK_POINTER_RETURN_BOOL(currentMissionDataStorage_);
50 HILOG_INFO("Init success.");
51 return true;
52 }
53
LoadAllMissionInfo(std::list<InnerMissionInfo> & missionInfoList)54 bool TaskDataPersistenceMgr::LoadAllMissionInfo(std::list<InnerMissionInfo> &missionInfoList)
55 {
56 std::lock_guard<ffrt::mutex> lock(mutex_);
57 if (!currentMissionDataStorage_) {
58 HILOG_ERROR("currentMissionDataStorage_ is nullptr");
59 return false;
60 }
61
62 return currentMissionDataStorage_->LoadAllMissionInfo(missionInfoList);
63 }
64
SaveMissionInfo(const InnerMissionInfo & missionInfo)65 bool TaskDataPersistenceMgr::SaveMissionInfo(const InnerMissionInfo &missionInfo)
66 {
67 std::lock_guard<ffrt::mutex> lock(mutex_);
68 if (!handler_ || !currentMissionDataStorage_) {
69 HILOG_ERROR("handler_ or currentMissionDataStorage_ is nullptr");
70 return false;
71 }
72
73 std::weak_ptr<MissionDataStorage> weakPtr(currentMissionDataStorage_);
74 std::function<void()> SaveMissionInfoFunc = [weakPtr, missionInfo]() {
75 auto missionDataStorage = weakPtr.lock();
76 if (missionDataStorage) {
77 missionDataStorage->SaveMissionInfo(missionInfo);
78 }
79 };
80 handler_->SubmitTask(SaveMissionInfoFunc, SAVE_MISSION_INFO);
81 return true;
82 }
83
DeleteMissionInfo(int missionId)84 bool TaskDataPersistenceMgr::DeleteMissionInfo(int missionId)
85 {
86 std::lock_guard<ffrt::mutex> lock(mutex_);
87 if (!handler_ || !currentMissionDataStorage_) {
88 HILOG_ERROR("handler_ or currentMissionDataStorage_ is nullptr");
89 return false;
90 }
91
92 std::weak_ptr<MissionDataStorage> weakPtr(currentMissionDataStorage_);
93 std::function<void()> DeleteMissionInfoFunc = [weakPtr, missionId]() {
94 auto missionDataStorage = weakPtr.lock();
95 if (missionDataStorage) {
96 missionDataStorage->DeleteMissionInfo(missionId);
97 }
98 };
99 handler_->SubmitTask(DeleteMissionInfoFunc, DELETE_MISSION_INFO);
100 return true;
101 }
102
RemoveUserDir(int32_t userId)103 bool TaskDataPersistenceMgr::RemoveUserDir(int32_t userId)
104 {
105 std::lock_guard<ffrt::mutex> lock(mutex_);
106 if (currentUserId_ == userId) {
107 HILOG_ERROR("can not removed current user dir");
108 return false;
109 }
110 std::string userDir = std::string(TASK_DATA_FILE_BASE_PATH) + "/" + std::to_string(userId);
111 bool ret = OHOS::ForceRemoveDirectory(userDir);
112 if (!ret) {
113 HILOG_ERROR("remove user dir %{public}s failed.", userDir.c_str());
114 return false;
115 }
116 return true;
117 }
118
SaveMissionSnapshot(int missionId,const MissionSnapshot & snapshot)119 bool TaskDataPersistenceMgr::SaveMissionSnapshot(int missionId, const MissionSnapshot& snapshot)
120 {
121 std::lock_guard<ffrt::mutex> lock(mutex_);
122 if (!handler_ || !currentMissionDataStorage_) {
123 HILOG_ERROR("snapshot: handler_ or currentMissionDataStorage_ is nullptr");
124 return false;
125 }
126
127 std::weak_ptr<MissionDataStorage> weakPtr(currentMissionDataStorage_);
128 std::function<void()> SaveMissionSnapshotFunc = [weakPtr, missionId, snapshot]() {
129 auto missionDataStorage = weakPtr.lock();
130 if (missionDataStorage) {
131 missionDataStorage->SaveMissionSnapshot(missionId, snapshot);
132 }
133 };
134 handler_->SubmitTask(SaveMissionSnapshotFunc, SAVE_MISSION_SNAPSHOT);
135 return true;
136 }
137
138 #ifdef SUPPORT_GRAPHICS
GetSnapshot(int missionId) const139 std::shared_ptr<Media::PixelMap> TaskDataPersistenceMgr::GetSnapshot(int missionId) const
140 {
141 if (!currentMissionDataStorage_) {
142 HILOG_ERROR("snapshot: currentMissionDataStorage_ is nullptr");
143 return nullptr;
144 }
145 return currentMissionDataStorage_->GetSnapshot(missionId);
146 }
147 #endif
148
GetMissionSnapshot(int missionId,MissionSnapshot & snapshot,bool isLowResolution)149 bool TaskDataPersistenceMgr::GetMissionSnapshot(int missionId, MissionSnapshot& snapshot, bool isLowResolution)
150 {
151 std::lock_guard<ffrt::mutex> lock(mutex_);
152 if (!currentMissionDataStorage_) {
153 HILOG_ERROR("snapshot: currentMissionDataStorage_ is nullptr");
154 return false;
155 }
156 return currentMissionDataStorage_->GetMissionSnapshot(missionId, snapshot, isLowResolution);
157 }
158 } // namespace AAFwk
159 } // namespace OHOS
160