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 #define MLOG_TAG "Thumbnail"
16
17 #include "thumbnail_aging_helper.h"
18
19 #include "medialibrary_errno.h"
20 #include "media_log.h"
21 #include "thumbnail_const.h"
22
23 using namespace std;
24 using namespace OHOS::DistributedKv;
25 using namespace OHOS::NativeRdb;
26
27 namespace OHOS {
28 namespace Media {
AgingLcd(AsyncTaskData * data)29 static void AgingLcd(AsyncTaskData *data)
30 {
31 if (data == nullptr) {
32 return;
33 }
34 AgingAsyncTaskData* taskData = static_cast<AgingAsyncTaskData*>(data);
35 int32_t err = ThumbnailAgingHelper::ClearLcdFromFileTable(taskData->opts);
36 if (err != E_OK) {
37 MEDIA_ERR_LOG("Failed to ClearLcdFormFileTable %{public}d", err);
38 }
39 }
40
41 #ifdef DISTRIBUTED
AgingDistributeLcd(AsyncTaskData * data)42 static void AgingDistributeLcd(AsyncTaskData* data)
43 {
44 if (data == nullptr) {
45 return;
46 }
47 AgingAsyncTaskData* taskData = static_cast<AgingAsyncTaskData*>(data);
48 int32_t err = ThumbnailAgingHelper::ClearRemoteLcdFromFileTable(taskData->opts);
49 if (err != E_OK) {
50 MEDIA_ERR_LOG("Failed to ClearRemoteLcdFormFileTable %{public}d", err);
51 }
52 }
53 #endif
54
55 #ifdef DISTRIBUTED
ClearThumbnailRecordTask(AsyncTaskData * data)56 static void ClearThumbnailRecordTask(AsyncTaskData* data)
57 {
58 if (data == nullptr) {
59 return;
60 }
61 AgingAsyncTaskData* taskData = static_cast<AgingAsyncTaskData*>(data);
62 int32_t err = ThumbnailAgingHelper::ClearKeyAndRecordFromMap(taskData->opts);
63 if (err != E_OK) {
64 MEDIA_ERR_LOG("Failed to ClearKeyAndRecordFromMap %{public}d", err);
65 }
66 }
67 #endif
68
AgingLcdBatch(ThumbRdbOpt & opts)69 int32_t ThumbnailAgingHelper::AgingLcdBatch(ThumbRdbOpt &opts)
70 {
71 MEDIA_INFO_LOG("IN %{public}s", opts.table.c_str());
72 if (opts.store == nullptr) {
73 return E_HAS_DB_ERROR;
74 }
75
76 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
77 if (asyncWorker == nullptr) {
78 return E_ERR;
79 }
80 AgingAsyncTaskData* taskData = new (std::nothrow)AgingAsyncTaskData();
81 if (taskData == nullptr) {
82 return E_ERR;
83 }
84 taskData->opts = opts;
85 shared_ptr<MediaLibraryAsyncTask> agingAsyncTask = make_shared<MediaLibraryAsyncTask>(AgingLcd, taskData);
86 if (agingAsyncTask != nullptr) {
87 asyncWorker->AddTask(agingAsyncTask, false);
88 }
89 return E_OK;
90 }
91
ClearLcdFromFileTable(ThumbRdbOpt & opts)92 int32_t ThumbnailAgingHelper::ClearLcdFromFileTable(ThumbRdbOpt &opts)
93 {
94 int lcdCount = 0;
95 int32_t err = GetLcdCount(opts, lcdCount);
96 if (err != E_OK) {
97 MEDIA_ERR_LOG("Failed to GetLcdCount %{public}d", err);
98 return err;
99 }
100 MEDIA_DEBUG_LOG("lcdCount %{public}d", lcdCount);
101 if (lcdCount <= THUMBNAIL_LCD_AGING_THRESHOLD) {
102 MEDIA_INFO_LOG("Not need aging Lcd. lcdCount: %{lcdCount}d", lcdCount);
103 return E_OK;
104 }
105 vector<ThumbnailData> infos;
106 err = GetAgingLcdData(opts, lcdCount - THUMBNAIL_LCD_AGING_THRESHOLD, infos);
107 if ((err != E_OK) || infos.empty()) {
108 MEDIA_ERR_LOG("Failed to GetAgingLcdData %{public}d", err);
109 return err;
110 }
111
112 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
113 if (asyncWorker == nullptr) {
114 return E_ERR;
115 }
116 for (uint32_t i = 0; i < infos.size(); i++) {
117 opts.row = infos[i].id;
118 if (ThumbnailUtils::DeleteThumbFile(infos[i], ThumbnailType::LCD)) {
119 ThumbnailUtils::CleanThumbnailInfo(opts, false, true);
120 }
121 }
122
123 return E_OK;
124 }
125
126 #ifdef DISTRIBUTED
AgingDistributeLcdBatch(ThumbRdbOpt & opts)127 int32_t ThumbnailAgingHelper::AgingDistributeLcdBatch(ThumbRdbOpt &opts)
128 {
129 if (opts.store == nullptr) {
130 MEDIA_ERR_LOG("opts.store is not init");
131 return E_ERR;
132 }
133
134 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
135 if (asyncWorker == nullptr) {
136 return E_ERR;
137 }
138 AgingAsyncTaskData* taskData = new AgingAsyncTaskData();
139 if (taskData == nullptr) {
140 return E_ERR;
141 }
142 taskData->opts = opts;
143 shared_ptr<MediaLibraryAsyncTask> agingAsyncTask = make_shared<MediaLibraryAsyncTask>(AgingDistributeLcd, taskData);
144 if (agingAsyncTask != nullptr) {
145 asyncWorker->AddTask(agingAsyncTask, false);
146 }
147 return E_OK;
148 }
149
ClearRemoteLcdFromFileTable(ThumbRdbOpt & opts)150 int32_t ThumbnailAgingHelper::ClearRemoteLcdFromFileTable(ThumbRdbOpt &opts)
151 {
152 int lcdCount = 0;
153 int32_t err = GetDistributeLcdCount(opts, lcdCount);
154 if (err != E_OK) {
155 MEDIA_ERR_LOG("Failed to GetDistributeLcdCount %{public}d", err);
156 return err;
157 }
158 MEDIA_DEBUG_LOG("GetDistributeLcdCount %{public}d", lcdCount);
159 if (lcdCount <= THUMBNAIL_LCD_AGING_THRESHOLD) {
160 MEDIA_INFO_LOG("Not need aging Lcd. GetDistributeLcdCount: %{lcdCount}d", lcdCount);
161 return E_OK;
162 }
163 vector<ThumbnailData> infos;
164 err = GetAgingDistributeLcdData(opts, lcdCount - THUMBNAIL_LCD_GENERATE_THRESHOLD, infos);
165 if ((err != E_OK) || infos.empty()) {
166 MEDIA_ERR_LOG("Failed to GetAgingDistributeLcdData %{public}d", err);
167 return err;
168 }
169
170 for (uint32_t i = 0; i < infos.size(); i++) {
171 opts.row = infos[i].id;
172 ThumbnailUtils::DeleteDistributeLcdData(opts, infos[i]);
173 }
174
175 return E_OK;
176 }
177 #endif
178
GetLcdCount(ThumbRdbOpt & opts,int & outLcdCount)179 int32_t ThumbnailAgingHelper::GetLcdCount(ThumbRdbOpt &opts, int &outLcdCount)
180 {
181 int32_t err = E_ERR;
182 if (!ThumbnailUtils::QueryLcdCount(opts, outLcdCount, err)) {
183 MEDIA_ERR_LOG("Failed to QueryLcdCount %{public}d", err);
184 return err;
185 }
186 return E_OK;
187 }
188 #ifdef DISTRIBUTED
GetDistributeLcdCount(ThumbRdbOpt & opts,int & outLcdCount)189 int32_t ThumbnailAgingHelper::GetDistributeLcdCount(ThumbRdbOpt &opts, int &outLcdCount)
190 {
191 int32_t err = E_ERR;
192 if (!ThumbnailUtils::QueryDistributeLcdCount(opts, outLcdCount, err)) {
193 MEDIA_ERR_LOG("Failed to QueryLcdCount %{public}d", err);
194 return err;
195 }
196 return E_OK;
197 }
198 #endif
199
GetAgingLcdData(ThumbRdbOpt & opts,int lcdLimit,vector<ThumbnailData> & outDatas)200 int32_t ThumbnailAgingHelper::GetAgingLcdData(ThumbRdbOpt &opts, int lcdLimit, vector<ThumbnailData> &outDatas)
201 {
202 int32_t err = E_ERR;
203 if (!ThumbnailUtils::QueryAgingLcdInfos(opts, lcdLimit, outDatas, err)) {
204 MEDIA_ERR_LOG("Failed to QueryAgingLcdInfos %{public}d", err);
205 return err;
206 }
207 return E_OK;
208 }
209
210 #ifdef DISTRIBUTED
GetAgingDistributeLcdData(ThumbRdbOpt & opts,int lcdLimit,vector<ThumbnailData> & outDatas)211 int32_t ThumbnailAgingHelper::GetAgingDistributeLcdData(ThumbRdbOpt &opts,
212 int lcdLimit, vector<ThumbnailData> &outDatas)
213 {
214 int32_t err = E_ERR;
215 if (!ThumbnailUtils::QueryAgingDistributeLcdInfos(opts, lcdLimit, outDatas, err)) {
216 MEDIA_ERR_LOG("Failed to QueryAgingLcdInfos %{public}d", err);
217 return err;
218 }
219 return E_OK;
220 }
221
InvalidateDistributeBatch(ThumbRdbOpt & opts)222 int32_t ThumbnailAgingHelper::InvalidateDistributeBatch(ThumbRdbOpt &opts)
223 {
224 if (opts.store == nullptr) {
225 MEDIA_ERR_LOG("opts.store is not init");
226 return E_ERR;
227 }
228
229 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
230 if (asyncWorker == nullptr) {
231 return E_ERR;
232 }
233 AgingAsyncTaskData* taskData = new (std::nothrow)AgingAsyncTaskData();
234 if (taskData == nullptr) {
235 return E_ERR;
236 }
237 taskData->opts = opts;
238 shared_ptr<MediaLibraryAsyncTask> agingAsyncTask = make_shared<MediaLibraryAsyncTask>(
239 ClearThumbnailRecordTask, taskData);
240 if (agingAsyncTask != nullptr) {
241 asyncWorker->AddTask(agingAsyncTask, true);
242 }
243 return E_OK;
244 }
245
ClearKeyAndRecordFromMap(ThumbRdbOpt & opts)246 int32_t ThumbnailAgingHelper::ClearKeyAndRecordFromMap(ThumbRdbOpt &opts)
247 {
248 int32_t err = E_ERR;
249 vector<ThumbnailData> infos;
250 if (!ThumbnailUtils::QueryDeviceThumbnailRecords(opts, infos, err)) {
251 MEDIA_ERR_LOG("Failed to QueryDeviceThumbnailRecords %{public}d", err);
252 return err;
253 }
254
255 for (uint32_t i = 0; i < infos.size(); i++) {
256 opts.row = infos[i].id;
257 if (ThumbnailUtils::DeleteOriginImage(opts)) {
258 ThumbnailUtils::DeleteDistributeThumbnailInfo(opts);
259 }
260 }
261 return E_OK;
262 }
263 #endif
264 } // namespace Media
265 } // namespace OHOS
266