1 /*
2 * Copyright (C) 2024 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 #define MLOG_TAG "EnhancementManager"
17
18 #include "enhancement_manager.h"
19
20 #include "enhancement_task_manager.h"
21 #include "medialibrary_bundle_manager.h"
22 #include "medialibrary_command.h"
23 #include "medialibrary_errno.h"
24 #include "medialibrary_type_const.h"
25 #include "medialibrary_tracer.h"
26 #include "media_log.h"
27 #include "request_policy.h"
28 #include "result_set_utils.h"
29 #include "media_file_utils.h"
30 #include "media_file_uri.h"
31 #include "medialibrary_unistore_manager.h"
32 #include "medialibrary_rdb_transaction.h"
33 #include "medialibrary_notify.h"
34 #include "userfilemgr_uri.h"
35 #include "medialibrary_async_worker.h"
36
37 using namespace std;
38 using namespace OHOS::DataShare;
39 using namespace OHOS::NativeRdb;
40 using namespace OHOS::RdbDataShareAdapter;
41 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
42 using namespace OHOS::MediaEnhance;
43 #endif
44 namespace OHOS {
45 namespace Media {
46 using json = nlohmann::json;
47 static const string FILE_TPYE = "fileType";
48 static const string IS_HDR_VIVID = "isHdrVivid";
49 static const string HAS_WATER_MARK_INFO = "hasCloudWaterMark";
50 static const string CLOUD_WATER_MARK_INFO = "cloudWaterMarkInfo";
51 static const int32_t NO = 0;
52 static const int32_t YES = 1;
53 static const string JPEG_STR = "image/jpeg";
54 static const string HEIF_STR = "image/heic";
55 static const string JPEG_TYPE = "JPEG";
56 static const string HEIF_TYPE = "HEIF";
57 static const unordered_map<string, string> CLOUD_ENHANCEMENT_MIME_TYPE_MAP = {
58 { JPEG_STR, JPEG_TYPE },
59 { HEIF_STR, HEIF_TYPE },
60 };
61
EnhancementManager()62 EnhancementManager::EnhancementManager()
63 {
64 threadManager_ = make_shared<EnhancementThreadManager>();
65 }
66
~EnhancementManager()67 EnhancementManager::~EnhancementManager() {}
68
GetInstance()69 EnhancementManager& EnhancementManager::GetInstance()
70 {
71 static EnhancementManager instance;
72 return instance;
73 }
74
75
LoadService()76 bool EnhancementManager::LoadService()
77 {
78 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
79 if (enhancementService_ == nullptr) {
80 enhancementService_ = make_shared<EnhancementServiceAdapter>();
81 }
82 if (enhancementService_ == nullptr) {
83 return false;
84 }
85 return true;
86 #else
87 return false;
88 #endif
89 }
90
CheckResultSet(shared_ptr<NativeRdb::ResultSet> & resultSet)91 static int32_t CheckResultSet(shared_ptr<NativeRdb::ResultSet> &resultSet)
92 {
93 if (resultSet == nullptr) {
94 MEDIA_ERR_LOG("resultset is nullptr");
95 return E_FAIL;
96 }
97 int32_t count = 0;
98 auto ret = resultSet->GetRowCount(count);
99 if (ret != E_OK) {
100 MEDIA_ERR_LOG("Failed to get resultset row count, ret: %{public}d", ret);
101 return ret;
102 }
103 if (count <= 0) {
104 MEDIA_INFO_LOG("Failed to get count, count: %{public}d", count);
105 return E_FAIL;
106 }
107 return E_OK;
108 }
109
110 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
FillBundleWithWaterMarkInfo(MediaEnhanceBundleHandle * mediaEnhanceBundle,const string & mimeType,int32_t dynamicRangeType,const bool hasCloudWaterMark)111 static void FillBundleWithWaterMarkInfo(MediaEnhanceBundleHandle* mediaEnhanceBundle,
112 const string &mimeType, int32_t dynamicRangeType, const bool hasCloudWaterMark)
113 {
114 string filePath = CLOUD_ENHANCEMENT_WATER_MARK_DIR + "/" + "cloud_watermark_param.json";
115 string metaDataStr;
116 if (!MediaFileUtils::ReadStrFromFile(filePath, metaDataStr)) {
117 MEDIA_ERR_LOG("Failed to read meta data from: %{public}s", filePath.c_str());
118 return;
119 }
120 if (!json::accept(metaDataStr)) {
121 MEDIA_WARN_LOG("Failed to verify the meataData format, metaData is: %{private}s",
122 metaDataStr.c_str());
123 return;
124 }
125 json metaData;
126 json jsonObject = json::parse(metaDataStr);
127 if (CLOUD_ENHANCEMENT_MIME_TYPE_MAP.count(mimeType) == 0) {
128 MEDIA_WARN_LOG("Failed to verify the mimeType, mimeType is: %{public}s",
129 mimeType.c_str());
130 return;
131 }
132 metaData[FILE_TPYE] = CLOUD_ENHANCEMENT_MIME_TYPE_MAP.at(mimeType);
133 metaData[IS_HDR_VIVID] = to_string(dynamicRangeType);
134 metaData[HAS_WATER_MARK_INFO] = hasCloudWaterMark ? to_string(YES) : to_string(NO);
135 for (auto& item : jsonObject[CLOUD_WATER_MARK_INFO].items()) {
136 item.value() = to_string(item.value().get<int>());
137 }
138 metaData[CLOUD_WATER_MARK_INFO] = jsonObject[CLOUD_WATER_MARK_INFO];
139 string metaDataJson = metaData.dump();
140 MEDIA_INFO_LOG("meta data json: %{public}s", metaDataJson.c_str());
141 EnhancementManager::GetInstance().enhancementService_->PutString(mediaEnhanceBundle,
142 MediaEnhance_Bundle_Key::METADATA, metaDataJson.c_str()); // meta data
143 }
144 #endif
145
InitCloudEnhancementAsync(AsyncTaskData * data)146 static void InitCloudEnhancementAsync(AsyncTaskData *data)
147 {
148 EnhancementManager::GetInstance().Init();
149 }
150
InitAsync()151 bool EnhancementManager::InitAsync()
152 {
153 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
154 if (asyncWorker == nullptr) {
155 MEDIA_INFO_LOG("can not get async worker");
156 return false;
157 }
158
159 shared_ptr<MediaLibraryAsyncTask> asyncTask = make_shared<MediaLibraryAsyncTask>(InitCloudEnhancementAsync,
160 nullptr);
161 if (asyncTask == nullptr) {
162 MEDIA_ERR_LOG("InitCloudEnhancementAsync create task fail");
163 return false;
164 }
165 MEDIA_INFO_LOG("InitCloudEnhancementAsync add task success");
166 asyncWorker->AddTask(asyncTask, false);
167 return true;
168 }
169
Init()170 bool EnhancementManager::Init()
171 {
172 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
173 // restart
174 if (!LoadService()) {
175 MEDIA_ERR_LOG("load enhancement service error");
176 return false;
177 }
178 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
179 vector<string> columns = {
180 MediaColumn::MEDIA_ID, MediaColumn::MEDIA_MIME_TYPE, PhotoColumn::PHOTO_ID,
181 PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK,
182 };
183 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
184 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
185 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(servicePredicates, columns);
186 if (CheckResultSet(resultSet) != E_OK) {
187 MEDIA_INFO_LOG("Init query no processing task");
188 return false;
189 }
190 while (resultSet->GoToNextRow() == E_OK) {
191 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
192 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
193 string mimeType = GetStringVal(MediaColumn::MEDIA_MIME_TYPE, resultSet);
194 int32_t dynamicRangeType = GetInt32Val(PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, resultSet);
195 int32_t hasCloudWatermark = GetInt32Val(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, resultSet);
196 MEDIA_INFO_LOG("restart and submit: fileId: %{public}d, photoId: %{public}s", fileId, photoId.c_str());
197 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
198 if (mediaEnhanceBundle == nullptr) {
199 continue;
200 }
201 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
202 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
203 FillBundleWithWaterMarkInfo(mediaEnhanceBundle, mimeType, dynamicRangeType,
204 hasCloudWatermark == YES ? true : false);
205 if (enhancementService_->AddTask(photoId, mediaEnhanceBundle) != E_OK) {
206 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
207 enhancementService_->DestroyBundle(mediaEnhanceBundle);
208 continue;
209 }
210 enhancementService_->DestroyBundle(mediaEnhanceBundle);
211 EnhancementTaskManager::AddEnhancementTask(fileId, photoId);
212 }
213 #else
214 MEDIA_ERR_LOG("not supply cloud enhancement service");
215 #endif
216 return true;
217 }
218
CancelTasksInternal(const vector<string> & fileIds,vector<string> & photoIds,CloudEnhancementAvailableType type)219 void EnhancementManager::CancelTasksInternal(const vector<string> &fileIds, vector<string> &photoIds,
220 CloudEnhancementAvailableType type)
221 {
222 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
223 for (const string& id : fileIds) {
224 int32_t fileId = stoi(id);
225 string photoId = EnhancementTaskManager::QueryPhotoIdByFileId(fileId);
226 if (photoId.empty()) {
227 MEDIA_INFO_LOG("task in cache not processing, file_id: %{public}d", fileId);
228 continue;
229 }
230 if (!LoadService() || enhancementService_->CancelTask(photoId) != E_OK) {
231 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
232 continue;
233 }
234 EnhancementTaskManager::RemoveEnhancementTask(photoId);
235 photoIds.emplace_back(photoId);
236 MEDIA_INFO_LOG("cancel task successful, photo_id: %{public}s", photoId.c_str());
237 }
238 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
239 updatePredicates.In(MediaColumn::MEDIA_ID, fileIds);
240 updatePredicates.And();
241 updatePredicates.BeginWrap();
242 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
243 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
244 updatePredicates.Or();
245 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
246 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
247 updatePredicates.Or();
248 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
249 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
250 updatePredicates.EndWrap();
251 ValuesBucket rdbValues;
252 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(type));
253 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
254 if (ret != E_OK) {
255 MEDIA_ERR_LOG("update ce_available failed, type: %{public}d, failed count: %{public}zu",
256 static_cast<int32_t>(type), photoIds.size());
257 return;
258 }
259 MEDIA_INFO_LOG("cancel tasks successful, type: %{public}d, success count: %{public}zu",
260 static_cast<int32_t>(type), photoIds.size());
261 #else
262 MEDIA_ERR_LOG("not supply cloud enhancement service");
263 #endif
264 }
265
RemoveTasksInternal(const vector<string> & fileIds,vector<string> & photoIds)266 void EnhancementManager::RemoveTasksInternal(const vector<string> &fileIds, vector<string> &photoIds)
267 {
268 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
269 RdbPredicates queryPredicates(PhotoColumn::PHOTOS_TABLE);
270 vector<string> columns = { PhotoColumn::PHOTO_ID };
271 queryPredicates.In(MediaColumn::MEDIA_ID, fileIds);
272 queryPredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
273 static_cast<int32_t>(CloudEnhancementAvailableType::TRASH));
274 shared_ptr<ResultSet> resultSet = MediaLibraryRdbStore::QueryWithFilter(queryPredicates, columns);
275 CHECK_AND_RETURN_LOG(CheckResultSet(resultSet) == E_OK, "result set is invalid");
276 while (resultSet->GoToNextRow() == E_OK) {
277 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
278 if (!LoadService() || enhancementService_->RemoveTask(photoId) != E_OK) {
279 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
280 continue;
281 }
282 photoIds.emplace_back(photoId);
283 MEDIA_INFO_LOG("remove task successful, photo_id: %{public}s", photoId.c_str());
284 }
285 #else
286 MEDIA_ERR_LOG("not supply cloud enhancement service");
287 #endif
288 }
289
RevertEditUpdateInternal(int32_t fileId)290 bool EnhancementManager::RevertEditUpdateInternal(int32_t fileId)
291 {
292 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
293 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
294 updatePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
295 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
296 static_cast<int32_t>(CloudEnhancementAvailableType::EDIT));
297 ValuesBucket rdbValues;
298 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
299 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
300 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
301 if (ret != E_OK) {
302 MEDIA_ERR_LOG("update ce_available error, file_id: %{public}d", fileId);
303 return false;
304 }
305 MEDIA_INFO_LOG("revert edit update successful, file_id: %{public}d", fileId);
306 #else
307 MEDIA_ERR_LOG("not supply cloud enhancement service");
308 #endif
309 return true;
310 }
311
RecoverTrashUpdateInternal(const vector<string> & fildIds)312 bool EnhancementManager::RecoverTrashUpdateInternal(const vector<string> &fildIds)
313 {
314 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
315 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
316 updatePredicates.In(MediaColumn::MEDIA_ID, fildIds);
317 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
318 static_cast<int32_t>(CloudEnhancementAvailableType::TRASH));
319 ValuesBucket rdbValues;
320 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
321 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
322 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
323 if (ret != E_OK) {
324 MEDIA_ERR_LOG("update ce_available error");
325 return false;
326 }
327 MEDIA_INFO_LOG("revocer trash update successful");
328 #else
329 MEDIA_ERR_LOG("not supply cloud enhancement service");
330 #endif
331 return true;
332 }
333
HandleEnhancementUpdateOperation(MediaLibraryCommand & cmd)334 int32_t EnhancementManager::HandleEnhancementUpdateOperation(MediaLibraryCommand &cmd)
335 {
336 switch (cmd.GetOprnType()) {
337 case OperationType::ENHANCEMENT_ADD: {
338 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
339 string hasCloudWatermark = cmd.GetQuerySetParam(MEDIA_OPERN_KEYWORD);
340 if (hasCloudWatermark.compare(to_string(YES)) == 0) {
341 return HandleAddOperation(cmd, true);
342 } else {
343 return HandleAddOperation(cmd, false);
344 }
345 #else
346 return E_ERR;
347 #endif
348 }
349 case OperationType::ENHANCEMENT_PRIORITIZE: {
350 return HandlePrioritizeOperation(cmd);
351 }
352 case OperationType::ENHANCEMENT_CANCEL: {
353 return HandleCancelOperation(cmd);
354 }
355 case OperationType::ENHANCEMENT_CANCEL_ALL: {
356 return HandleCancelAllOperation();
357 }
358 case OperationType::ENHANCEMENT_SYNC: {
359 return HandleSyncOperation();
360 }
361 default:
362 MEDIA_ERR_LOG("Unknown OprnType");
363 return E_ERR;
364 }
365 return E_OK;
366 }
367
HandleEnhancementQueryOperation(MediaLibraryCommand & cmd,const vector<string> & columns)368 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleEnhancementQueryOperation(MediaLibraryCommand &cmd,
369 const vector<string> &columns)
370 {
371 switch (cmd.GetOprnType()) {
372 case OperationType::ENHANCEMENT_QUERY:
373 // query database
374 return HandleQueryOperation(cmd, columns);
375 case OperationType::ENHANCEMENT_GET_PAIR:
376 return HandleGetPairOperation(cmd);
377 default:
378 break;
379 }
380 return nullptr;
381 }
382
383 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
AddServiceTask(MediaEnhanceBundleHandle * mediaEnhanceBundle,int32_t fileId,const string & photoId,const bool hasCloudWatermark)384 int32_t EnhancementManager::AddServiceTask(MediaEnhanceBundleHandle* mediaEnhanceBundle, int32_t fileId,
385 const string &photoId, const bool hasCloudWatermark)
386 {
387 EnhancementTaskManager::AddEnhancementTask(fileId, photoId);
388 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
389 servicePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
390 servicePredicates.And();
391 servicePredicates.BeginWrap();
392 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
393 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
394 servicePredicates.Or();
395 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
396 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
397 servicePredicates.EndWrap();
398 ValuesBucket rdbValues;
399 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
400 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
401 if (hasCloudWatermark) {
402 rdbValues.PutInt(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, YES);
403 } else {
404 rdbValues.PutInt(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, NO);
405 }
406 int32_t errCode = EnhancementDatabaseOperations::Update(rdbValues, servicePredicates);
407 if (errCode != E_OK) {
408 EnhancementTaskManager::RemoveEnhancementTask(photoId);
409 return E_ERR;
410 }
411 if (enhancementService_->AddTask(photoId, mediaEnhanceBundle) != E_OK) {
412 MEDIA_ERR_LOG("enhancment service error, photoId: %{public}s", photoId.c_str());
413 enhancementService_->DestroyBundle(mediaEnhanceBundle);
414 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
415 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
416 predicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
417 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
418 ValuesBucket values;
419 values.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
420 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
421 EnhancementDatabaseOperations::Update(values, predicates);
422 EnhancementTaskManager::RemoveEnhancementTask(photoId);
423 return E_ERR;
424 }
425 enhancementService_->DestroyBundle(mediaEnhanceBundle);
426 return E_OK;
427 }
428
HandleAddOperation(MediaLibraryCommand & cmd,const bool hasCloudWatermark)429 int32_t EnhancementManager::HandleAddOperation(MediaLibraryCommand &cmd, const bool hasCloudWatermark)
430 {
431 unordered_map<int32_t, string> fileId2Uri;
432 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_MIME_TYPE,
433 PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE
434 };
435 auto resultSet = EnhancementDatabaseOperations::BatchQuery(cmd, columns, fileId2Uri);
436 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
437 int32_t errCode = E_OK;
438 while (resultSet->GoToNextRow() == E_OK) {
439 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
440 string mimeType = GetStringVal(MediaColumn::MEDIA_MIME_TYPE, resultSet);
441 int32_t dynamicRangeType = GetInt32Val(PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, resultSet);
442 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
443 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
444 MEDIA_INFO_LOG("HandleAddOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
445 fileId, photoId.c_str(), ceAvailable);
446 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT) &&
447 ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY)) {
448 MEDIA_INFO_LOG("cloud enhancement task in db not support, photoId: %{public}s",
449 photoId.c_str());
450 errCode = E_ERR;
451 continue;
452 }
453 if (EnhancementTaskManager::InProcessingTask(photoId)) {
454 MEDIA_INFO_LOG("cloud enhancement task in cache is processing, photoId: %{public}s", photoId.c_str());
455 errCode = E_ERR;
456 continue;
457 }
458 if (!LoadService()) {
459 continue;
460 }
461 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
462 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
463 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
464 FillBundleWithWaterMarkInfo(mediaEnhanceBundle, mimeType, dynamicRangeType, hasCloudWatermark);
465 errCode = AddServiceTask(mediaEnhanceBundle, fileId, photoId, hasCloudWatermark);
466 if (errCode != E_OK) {
467 continue;
468 }
469 auto watch = MediaLibraryNotify::GetInstance();
470 watch->Notify(fileId2Uri[fileId], NotifyType::NOTIFY_UPDATE);
471 }
472 return errCode;
473 }
474 #endif
475
HandlePrioritizeOperation(MediaLibraryCommand & cmd)476 int32_t EnhancementManager::HandlePrioritizeOperation(MediaLibraryCommand &cmd)
477 {
478 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
479 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
480 vector<string> columns = {
481 MediaColumn::MEDIA_ID,
482 PhotoColumn::PHOTO_ID,
483 PhotoColumn::PHOTO_CE_AVAILABLE
484 };
485 auto resultSet = EnhancementDatabaseOperations::Query(cmd, servicePredicates, columns);
486 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
487 resultSet->GoToNextRow();
488 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
489 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
490 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
491 resultSet->Close();
492 MEDIA_INFO_LOG("HandlePrioritizeOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
493 fileId, photoId.c_str(), ceAvailable);
494 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING)) {
495 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s",
496 photoId.c_str());
497 return E_ERR;
498 }
499 if (!EnhancementTaskManager::InProcessingTask(photoId) ||
500 EnhancementTaskManager::GetTaskRequestCount(photoId) != 0) {
501 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s",
502 photoId.c_str());
503 return E_ERR;
504 }
505 if (!LoadService()) {
506 MEDIA_ERR_LOG("load enhancement service error");
507 return E_ERR;
508 }
509 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
510 if (mediaEnhanceBundle == nullptr) {
511 return E_ERR;
512 }
513 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
514 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
515 int32_t ret = enhancementService_->AddTask(photoId, mediaEnhanceBundle);
516 enhancementService_->DestroyBundle(mediaEnhanceBundle);
517 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "enhancment service error, photoId: %{public}s", photoId.c_str());
518 return ret;
519 #else
520 MEDIA_ERR_LOG("not supply cloud enhancement service");
521 return E_ERR;
522 #endif
523 }
524
HandleCancelOperation(MediaLibraryCommand & cmd)525 int32_t EnhancementManager::HandleCancelOperation(MediaLibraryCommand &cmd)
526 {
527 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
528 unordered_map<int32_t, string> fileId2Uri;
529 vector<string> columns = { MediaColumn::MEDIA_ID, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
530 auto resultSet = EnhancementDatabaseOperations::BatchQuery(cmd, columns, fileId2Uri);
531 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
532 while (resultSet->GoToNextRow() == E_OK) {
533 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
534 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
535 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
536 MEDIA_INFO_LOG("HandleCancelOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
537 fileId, photoId.c_str(), ceAvailable);
538 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING)) {
539 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s",
540 photoId.c_str());
541 continue;
542 }
543 if (!EnhancementTaskManager::InProcessingTask(photoId)) {
544 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s",
545 photoId.c_str());
546 continue;
547 }
548 if (!LoadService() || enhancementService_->CancelTask(photoId) != E_OK) {
549 MEDIA_ERR_LOG("enhancment service error, photoId: %{public}s", photoId.c_str());
550 continue;
551 }
552 EnhancementTaskManager::RemoveEnhancementTask(photoId);
553 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
554 servicePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
555 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
556 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
557 ValuesBucket rdbValues;
558 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
559 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, servicePredicates);
560 if (ret != E_OK) {
561 MEDIA_ERR_LOG("update ce_available error, photoId: %{public}s", photoId.c_str());
562 continue;
563 }
564 CloudEnhancementGetCount::GetInstance().RemoveStartTime(photoId);
565 auto watch = MediaLibraryNotify::GetInstance();
566 watch->Notify(fileId2Uri[fileId], NotifyType::NOTIFY_UPDATE);
567 }
568 return E_OK;
569 #else
570 return E_ERR;
571 #endif
572 }
573
HandleCancelAllOperation()574 int32_t EnhancementManager::HandleCancelAllOperation()
575 {
576 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
577 CHECK_AND_RETURN_RET_LOG(LoadService(), E_ERR, "Load Service Error");
578 int32_t ret = enhancementService_->CancelAllTasks();
579 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "cancel all tasks failed: enhancment service error");
580 vector<string> taskIds;
581 EnhancementTaskManager::RemoveAllEnhancementTask(taskIds);
582 CHECK_AND_RETURN_RET_LOG(!taskIds.empty(), E_OK, "cloud enhancement tasks in cache are not processing");
583 RdbPredicates queryPredicates(PhotoColumn::PHOTOS_TABLE);
584 queryPredicates.In(PhotoColumn::PHOTO_ID, taskIds);
585 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_FILE_PATH,
586 MediaColumn::MEDIA_NAME, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE
587 };
588 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(queryPredicates, columns);
589 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
590 while (resultSet->GoToNextRow() == E_OK) {
591 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
592 string filePath = GetStringVal(MediaColumn::MEDIA_FILE_PATH, resultSet);
593 string displayName = GetStringVal(MediaColumn::MEDIA_NAME, resultSet);
594 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
595 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
596 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING)) {
597 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s",
598 photoId.c_str());
599 continue;
600 }
601 string uri = MediaFileUtils::GetUriByExtrConditions(PhotoColumn::PHOTO_URI_PREFIX, to_string(fileId),
602 MediaFileUtils::GetExtraUri(displayName, filePath));
603 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
604 updatePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
605 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
606 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING));
607 ValuesBucket rdbValues;
608 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
609 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
610 if (ret != E_OK) {
611 MEDIA_ERR_LOG("update ce_available error, photoId: %{public}s", photoId.c_str());
612 continue;
613 }
614 CloudEnhancementGetCount::GetInstance().RemoveStartTime(photoId);
615 auto watch = MediaLibraryNotify::GetInstance();
616 watch->Notify(uri, NotifyType::NOTIFY_UPDATE);
617 }
618 return E_OK;
619 #else
620 MEDIA_ERR_LOG("not supply cloud enhancement service");
621 return E_ERR;
622 #endif
623 }
624
HandleSyncOperation()625 int32_t EnhancementManager::HandleSyncOperation()
626 {
627 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
628 MEDIA_INFO_LOG("photos start, begin to sync photos cloud enhancement available");
629 vector<string> taskIdList;
630 if (!LoadService() || enhancementService_->GetPendingTasks(taskIdList) != E_OK) {
631 MEDIA_ERR_LOG("sync tasks failed: enhancment service error");
632 return E_ERR;
633 }
634 if (taskIdList.empty()) {
635 MEDIA_INFO_LOG("no pending tasks from cloud enhancement service");
636 return E_OK;
637 }
638 MEDIA_INFO_LOG("enhancement pending tasks count from cloud enhancement: %{public}zu",
639 taskIdList.size());
640 vector<string> columns = {
641 MediaColumn::MEDIA_ID
642 };
643
644 RdbPredicates updateNotSupportPredicates(PhotoColumn::PHOTOS_TABLE);
645 updateNotSupportPredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
646 static_cast<int32_t>(CloudEnhancementAvailableType::NOT_SUPPORT));
647 updateNotSupportPredicates.In(PhotoColumn::PHOTO_ID, taskIdList);
648 ValuesBucket updateNotSupportBucket;
649 updateNotSupportBucket.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
650 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
651 EnhancementDatabaseOperations::Update(updateNotSupportBucket, updateNotSupportPredicates);
652
653 RdbPredicates updateSupportPredicates(PhotoColumn::PHOTOS_TABLE);
654 updateSupportPredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
655 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
656 updateSupportPredicates.NotIn(PhotoColumn::PHOTO_ID, taskIdList);
657 ValuesBucket updateSupportBucket;
658 updateSupportBucket.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
659 static_cast<int32_t>(CloudEnhancementAvailableType::NOT_SUPPORT));
660 EnhancementDatabaseOperations::Update(updateSupportBucket, updateSupportPredicates);
661 MEDIA_INFO_LOG("sync photos cloud enhancement available done");
662 return E_OK;
663 #else
664 MEDIA_ERR_LOG("not supply cloud enhancement service");
665 return E_ERR;
666 #endif
667 }
668
HandleQueryOperation(MediaLibraryCommand & cmd,const vector<string> & columns)669 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleQueryOperation(MediaLibraryCommand &cmd,
670 const vector<string> &columns)
671 {
672 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
673 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
674 auto resultSet = EnhancementDatabaseOperations::Query(cmd, servicePredicates, columns);
675 if (CheckResultSet(resultSet) != E_OK) {
676 return nullptr;
677 }
678 resultSet->GoToNextRow();
679 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
680 if (!EnhancementTaskManager::InProcessingTask(photoId)) {
681 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s", photoId.c_str());
682 }
683
684 return resultSet;
685 #else
686 MEDIA_ERR_LOG("not supply cloud enhancement service");
687 return nullptr;
688 #endif
689 }
690
HandleGetPairOperation(MediaLibraryCommand & cmd)691 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleGetPairOperation(MediaLibraryCommand &cmd)
692 {
693 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
694 MEDIA_INFO_LOG("HandleGetPairOperation success");
695 auto resultSet = EnhancementDatabaseOperations::GetPair(cmd);
696 if (CheckResultSet(resultSet) != E_OK) {
697 MEDIA_INFO_LOG("Failed to get resultSet from HandleGetPairOperation");
698 return nullptr;
699 }
700 return resultSet;
701 #else
702 MEDIA_ERR_LOG("not supply cloud enhancement service");
703 return nullptr;
704 #endif
705 }
706 } // namespace Media
707 } // namespace OHOS