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 #include "medialibrary_subscriber.h"
37
38 using namespace std;
39 using namespace OHOS::DataShare;
40 using namespace OHOS::NativeRdb;
41 using namespace OHOS::RdbDataShareAdapter;
42 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
43 using namespace OHOS::MediaEnhance;
44 #endif
45 namespace OHOS {
46 namespace Media {
47 using json = nlohmann::json;
48 static const string FILE_TPYE = "fileType";
49 static const string IS_HDR_VIVID = "isHdrVivid";
50 static const string HAS_WATER_MARK_INFO = "hasCloudWaterMark";
51 static const string CLOUD_WATER_MARK_INFO = "cloudWaterMarkInfo";
52 static const int32_t NO = 0;
53 static const int32_t YES = 1;
54 static const string JPEG_STR = "image/jpeg";
55 static const string HEIF_STR = "image/heic";
56 static const string JPEG_TYPE = "JPEG";
57 static const string HEIF_TYPE = "HEIF";
58 static const unordered_map<string, string> CLOUD_ENHANCEMENT_MIME_TYPE_MAP = {
59 { JPEG_STR, JPEG_TYPE },
60 { HEIF_STR, HEIF_TYPE },
61 };
62 static const int32_t GROUP_QUERY_SIZE = 1000;
63 mutex EnhancementManager::mutex_;
64
EnhancementManager()65 EnhancementManager::EnhancementManager()
66 {
67 threadManager_ = make_shared<EnhancementThreadManager>();
68 }
69
~EnhancementManager()70 EnhancementManager::~EnhancementManager()
71 {
72 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
73 Uri autoOptionUri(SETTINGS_DATASHARE_AUTO_OPTION_URI);
74 Uri waterMarknUri(SETTINGS_DATASHARE_WATER_MARK_URI);
75 SettingsMonitor::UnregisterSettingsObserver(autoOptionUri, photosAutoOptionObserver_);
76 SettingsMonitor::UnregisterSettingsObserver(waterMarknUri, photosWaterMarkObserver_);
77 photosAutoOptionObserver_ = nullptr;
78 photosWaterMarkObserver_ = nullptr;
79 #endif
80 }
81
GetInstance()82 EnhancementManager& EnhancementManager::GetInstance()
83 {
84 static EnhancementManager instance;
85 return instance;
86 }
87
LoadService()88 bool EnhancementManager::LoadService()
89 {
90 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
91 if (enhancementService_ == nullptr) {
92 unique_lock<mutex> lock(mutex_);
93 if (enhancementService_ == nullptr) {
94 enhancementService_ = make_shared<EnhancementServiceAdapter>();
95 }
96 }
97 if (enhancementService_ == nullptr) {
98 return false;
99 }
100 return true;
101 #else
102 return false;
103 #endif
104 }
105
CheckResultSet(shared_ptr<NativeRdb::ResultSet> & resultSet)106 static int32_t CheckResultSet(shared_ptr<NativeRdb::ResultSet> &resultSet)
107 {
108 if (resultSet == nullptr) {
109 MEDIA_ERR_LOG("resultset is nullptr");
110 return E_FAIL;
111 }
112 int32_t count = 0;
113 auto ret = resultSet->GetRowCount(count);
114 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "Failed to get resultset row count, ret: %{public}d", ret);
115 if (count <= 0) {
116 MEDIA_INFO_LOG("Failed to get count, count: %{public}d", count);
117 return E_FAIL;
118 }
119 return E_OK;
120 }
121
GenerateCancelAllUpdatePredicates(int32_t fileId,NativeRdb::RdbPredicates & updatePredicates)122 static void GenerateCancelAllUpdatePredicates(int32_t fileId,
123 NativeRdb::RdbPredicates &updatePredicates)
124 {
125 updatePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
126 updatePredicates.And();
127 updatePredicates.BeginWrap();
128 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
129 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
130 updatePredicates.Or();
131 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
132 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
133 updatePredicates.EndWrap();
134 }
135
136 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
FillBundleWithWaterMarkInfo(MediaEnhanceBundleHandle * mediaEnhanceBundle,const string & mimeType,int32_t dynamicRangeType,const bool hasCloudWaterMark)137 static void FillBundleWithWaterMarkInfo(MediaEnhanceBundleHandle* mediaEnhanceBundle,
138 const string &mimeType, int32_t dynamicRangeType, const bool hasCloudWaterMark)
139 {
140 string filePath = CLOUD_ENHANCEMENT_WATER_MARK_DIR + "/" + "cloud_watermark_param.json";
141 string metaDataStr;
142 CHECK_AND_RETURN_LOG(MediaFileUtils::ReadStrFromFile(filePath, metaDataStr),
143 "Failed to read meta data from: %{public}s", filePath.c_str());
144 if (!json::accept(metaDataStr)) {
145 MEDIA_WARN_LOG("Failed to verify the meataData format, metaData is: %{private}s",
146 metaDataStr.c_str());
147 return;
148 }
149 json metaData;
150 json jsonObject = json::parse(metaDataStr);
151 CHECK_AND_RETURN_WARN_LOG(CLOUD_ENHANCEMENT_MIME_TYPE_MAP.count(mimeType) != 0,
152 "Failed to verify the mimeType, mimeType is: %{public}s", mimeType.c_str());
153 metaData[FILE_TPYE] = CLOUD_ENHANCEMENT_MIME_TYPE_MAP.at(mimeType);
154 metaData[IS_HDR_VIVID] = to_string(dynamicRangeType);
155 metaData[HAS_WATER_MARK_INFO] = hasCloudWaterMark ? to_string(YES) : to_string(NO);
156 for (auto& item : jsonObject[CLOUD_WATER_MARK_INFO].items()) {
157 item.value() = to_string(item.value().get<int>());
158 }
159 metaData[CLOUD_WATER_MARK_INFO] = jsonObject[CLOUD_WATER_MARK_INFO];
160 string metaDataJson = metaData.dump();
161 MEDIA_INFO_LOG("meta data json: %{public}s", metaDataJson.c_str());
162 EnhancementManager::GetInstance().enhancementService_->PutString(mediaEnhanceBundle,
163 MediaEnhance_Bundle_Key::METADATA, metaDataJson.c_str()); // meta data
164 }
165
ShouldAddTask(bool isAuto,int32_t photoIsAuto,int32_t ceAvailable,const string & photoId)166 static bool ShouldAddTask(bool isAuto, int32_t photoIsAuto, int32_t ceAvailable, const string &photoId)
167 {
168 if (isAuto && (photoIsAuto != static_cast<int32_t>(CloudEnhancementIsAutoType::AUTO))) {
169 MEDIA_INFO_LOG("photoId: %{public}s doesn't support auto enhancement", photoId.c_str());
170 return false;
171 } else if (ceAvailable == static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO)) {
172 MEDIA_INFO_LOG("changing auto enhance to preview or manual enhance");
173 } else if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT) &&
174 ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY)) {
175 MEDIA_INFO_LOG("cloud enhancement task in db not support, photoId: %{public}s", photoId.c_str());
176 return false;
177 } else if (EnhancementTaskManager::InProcessingTask(photoId)) {
178 MEDIA_INFO_LOG("cloud enhancement task in cache is processing, photoId: %{public}s", photoId.c_str());
179 return false;
180 }
181 if (!EnhancementManager::GetInstance().LoadService()) {
182 return false;
183 }
184 return true;
185 }
186 #endif
187
InitCloudEnhancementAsync(AsyncTaskData * data)188 static void InitCloudEnhancementAsync(AsyncTaskData *data)
189 {
190 EnhancementManager::GetInstance().Init();
191 }
192
InitAsync()193 bool EnhancementManager::InitAsync()
194 {
195 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
196 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, false, "can not get async worker");
197 shared_ptr<MediaLibraryAsyncTask> asyncTask = make_shared<MediaLibraryAsyncTask>(InitCloudEnhancementAsync,
198 nullptr);
199 CHECK_AND_RETURN_RET_LOG(asyncTask != nullptr, false, "InitCloudEnhancementAsync create task fail");
200 MEDIA_INFO_LOG("InitCloudEnhancementAsync add task success");
201 asyncWorker->AddTask(asyncTask, false);
202 return true;
203 }
204
Init()205 bool EnhancementManager::Init()
206 {
207 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
208 // restart
209 CHECK_AND_RETURN_RET_LOG(LoadService(), false, "load enhancement service error");
210 ResetProcessingAutoToSupport();
211 InitPhotosSettingsMonitor();
212 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
213 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_MIME_TYPE, PhotoColumn::PHOTO_ID,
214 PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK };
215 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
216 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
217 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(servicePredicates, columns);
218 if (CheckResultSet(resultSet) != E_OK) {
219 MEDIA_INFO_LOG("Init query no processing task");
220 return false;
221 }
222 while (resultSet->GoToNextRow() == E_OK) {
223 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
224 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
225 string mimeType = GetStringVal(MediaColumn::MEDIA_MIME_TYPE, resultSet);
226 int32_t dynamicRangeType = GetInt32Val(PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, resultSet);
227 int32_t hasCloudWatermark = GetInt32Val(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, resultSet);
228 MEDIA_INFO_LOG("restart and submit: fileId: %{public}d, photoId: %{public}s", fileId, photoId.c_str());
229 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
230 if (mediaEnhanceBundle == nullptr) {
231 continue;
232 }
233 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
234 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
235 FillBundleWithWaterMarkInfo(mediaEnhanceBundle, mimeType, dynamicRangeType,
236 hasCloudWatermark == YES ? true : false);
237 if (enhancementService_->AddTask(photoId, mediaEnhanceBundle) != E_OK) {
238 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
239 enhancementService_->DestroyBundle(mediaEnhanceBundle);
240 continue;
241 }
242 enhancementService_->DestroyBundle(mediaEnhanceBundle);
243 EnhancementTaskManager::AddEnhancementTask(fileId, photoId, TYPE_MANUAL_ENHANCEMENT);
244 }
245 #else
246 MEDIA_ERR_LOG("not supply cloud enhancement service");
247 #endif
248 return true;
249 }
250
InitPhotosSettingsMonitor()251 void EnhancementManager::InitPhotosSettingsMonitor()
252 {
253 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
254 Uri autoOptionUri(SETTINGS_DATASHARE_AUTO_OPTION_URI);
255 Uri waterMarknUri(SETTINGS_DATASHARE_WATER_MARK_URI);
256 photosAutoOptionObserver_ = std::make_unique<PhotosAutoOptionObserver>().release();
257 photosWaterMarkObserver_ = std::make_unique<PhotosWaterMarkObserver>().release();
258 SettingsMonitor::RegisterSettingsObserver(autoOptionUri, photosAutoOptionObserver_);
259 SettingsMonitor::RegisterSettingsObserver(waterMarknUri, photosWaterMarkObserver_);
260 isWifiConnected_ = MedialibrarySubscriber::IsWifiConnected();
261 isCellularNetConnected_ = MedialibrarySubscriber::IsCellularNetConnected();
262 shouldAddWaterMark_ = SettingsMonitor::QueryPhotosWaterMark();
263 photosAutoOption_ = SettingsMonitor::QueryPhotosAutoOption();
264 HandleAutoAddOperation(true);
265 #else
266 MEDIA_ERR_LOG("not supply cloud enhancement service");
267 #endif
268 }
269
CancelTasksInternal(const vector<string> & fileIds,vector<string> & photoIds,CloudEnhancementAvailableType type)270 void EnhancementManager::CancelTasksInternal(const vector<string> &fileIds, vector<string> &photoIds,
271 CloudEnhancementAvailableType type)
272 {
273 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
274 for (const string& id : fileIds) {
275 int32_t fileId = stoi(id);
276 string photoId = EnhancementTaskManager::QueryPhotoIdByFileId(fileId);
277 if (photoId.empty()) {
278 MEDIA_INFO_LOG("task in cache not processing, file_id: %{public}d", fileId);
279 continue;
280 }
281 if (!LoadService() || enhancementService_->CancelTask(photoId) != E_OK) {
282 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
283 continue;
284 }
285 int32_t taskType = EnhancementTaskManager::QueryTaskTypeByPhotoId(photoId);
286 if (type == CloudEnhancementAvailableType::EDIT) {
287 CloudEnhancementGetCount::GetInstance().Report("EditCancellationType", photoId, taskType);
288 } else if (type == CloudEnhancementAvailableType::TRASH) {
289 CloudEnhancementGetCount::GetInstance().Report("DeleteCancellationType", photoId, taskType);
290 }
291 EnhancementTaskManager::RemoveEnhancementTask(photoId);
292 photoIds.emplace_back(photoId);
293 MEDIA_INFO_LOG("cancel task successful, photo_id: %{public}s", photoId.c_str());
294 }
295 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
296 updatePredicates.In(MediaColumn::MEDIA_ID, fileIds);
297 updatePredicates.And();
298 updatePredicates.BeginWrap();
299 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
300 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
301 updatePredicates.Or();
302 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
303 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
304 updatePredicates.Or();
305 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
306 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
307 updatePredicates.Or();
308 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
309 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
310 updatePredicates.EndWrap();
311 ValuesBucket rdbValues;
312 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(type));
313 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
314 CHECK_AND_RETURN_LOG(ret == E_OK, "update ce_available failed, type: %{public}d, failed count: %{public}zu",
315 static_cast<int32_t>(type), photoIds.size());
316 MEDIA_INFO_LOG("type: %{public}d, success count: %{public}zu", static_cast<int32_t>(type), photoIds.size());
317 #else
318 MEDIA_ERR_LOG("not supply cloud enhancement service");
319 #endif
320 }
321
RemoveTasksInternal(const vector<string> & fileIds,vector<string> & photoIds)322 void EnhancementManager::RemoveTasksInternal(const vector<string> &fileIds, vector<string> &photoIds)
323 {
324 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
325 int32_t totalFiles = static_cast<int32_t>(fileIds.size());
326 int32_t groupNum = (totalFiles + GROUP_QUERY_SIZE - 1) / GROUP_QUERY_SIZE;
327 for (int32_t i = 0; i < groupNum; i++) {
328 int32_t startIndex = i * GROUP_QUERY_SIZE;
329 int32_t endIndex = min(startIndex + GROUP_QUERY_SIZE, totalFiles);
330 vector<string> currentFileIds(fileIds.begin() + startIndex, fileIds.begin() + endIndex);
331 MEDIA_INFO_LOG("current startIndex: %{public}d, endIndex: %{public}d, size: %{public}zu",
332 startIndex, endIndex, currentFileIds.size());
333 if (currentFileIds.empty()) {
334 continue;
335 }
336 RdbPredicates queryPredicates(PhotoColumn::PHOTOS_TABLE);
337 vector<string> columns = { PhotoColumn::PHOTO_ID };
338 queryPredicates.In(MediaColumn::MEDIA_ID, currentFileIds);
339 queryPredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
340 static_cast<int32_t>(CloudEnhancementAvailableType::TRASH));
341 shared_ptr<NativeRdb::ResultSet> resultSet = MediaLibraryRdbStore::QueryWithFilter(queryPredicates, columns);
342 CHECK_AND_RETURN_LOG(CheckResultSet(resultSet) == E_OK, "result set is invalid");
343 while (resultSet->GoToNextRow() == E_OK) {
344 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
345 if (!LoadService() || enhancementService_->RemoveTask(photoId) != E_OK) {
346 MEDIA_ERR_LOG("enhancment service error, photo_id: %{public}s", photoId.c_str());
347 continue;
348 }
349 photoIds.emplace_back(photoId);
350 MEDIA_INFO_LOG("remove task successful, photo_id: %{public}s", photoId.c_str());
351 }
352 resultSet->Close();
353 }
354 #else
355 MEDIA_ERR_LOG("not supply cloud enhancement service");
356 #endif
357 }
358
RevertEditUpdateInternal(int32_t fileId)359 bool EnhancementManager::RevertEditUpdateInternal(int32_t fileId)
360 {
361 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
362 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
363 updatePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
364 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
365 static_cast<int32_t>(CloudEnhancementAvailableType::EDIT));
366 ValuesBucket rdbValues;
367 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
368 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
369 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
370 if (ret != E_OK) {
371 MEDIA_ERR_LOG("update ce_available error, file_id: %{public}d", fileId);
372 return false;
373 }
374 MEDIA_INFO_LOG("revert edit update successful, file_id: %{public}d", fileId);
375 #else
376 MEDIA_ERR_LOG("not supply cloud enhancement service");
377 #endif
378 return true;
379 }
380
RecoverTrashUpdateInternal(const vector<string> & fildIds)381 bool EnhancementManager::RecoverTrashUpdateInternal(const vector<string> &fildIds)
382 {
383 MediaLibraryTracer tracer;
384 tracer.Start("EnhancementManager::RecoverTrashUpdateInternal");
385 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
386 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
387 updatePredicates.In(MediaColumn::MEDIA_ID, fildIds);
388 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
389 static_cast<int32_t>(CloudEnhancementAvailableType::TRASH));
390 ValuesBucket rdbValues;
391 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
392 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
393 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
394 if (ret != E_OK) {
395 MEDIA_ERR_LOG("update ce_available error");
396 return false;
397 }
398 MEDIA_INFO_LOG("revocer trash update successful");
399 #else
400 MEDIA_ERR_LOG("not supply cloud enhancement service");
401 #endif
402 return true;
403 }
404
HandleEnhancementUpdateOperation(MediaLibraryCommand & cmd)405 int32_t EnhancementManager::HandleEnhancementUpdateOperation(MediaLibraryCommand &cmd)
406 {
407 switch (cmd.GetOprnType()) {
408 case OperationType::ENHANCEMENT_ADD: {
409 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
410 string hasCloudWatermark = cmd.GetQuerySetParam(MEDIA_OPERN_KEYWORD);
411 int triggerMode = std::atoi(cmd.GetQuerySetParam(MEDIA_TRIGGER_MODE_KEYWORD).c_str());
412 MEDIA_INFO_LOG("the triggerMode is %{public}d", triggerMode);
413 if (hasCloudWatermark.compare(to_string(YES)) == 0) {
414 return HandleAddOperation(cmd, true, triggerMode);
415 } else {
416 return HandleAddOperation(cmd, false, triggerMode);
417 }
418 #else
419 return E_ERR;
420 #endif
421 }
422 case OperationType::ENHANCEMENT_PRIORITIZE: {
423 return HandlePrioritizeOperation(cmd);
424 }
425 case OperationType::ENHANCEMENT_CANCEL: {
426 return HandleCancelOperation(cmd);
427 }
428 case OperationType::ENHANCEMENT_CANCEL_ALL: {
429 return HandleCancelAllOperation();
430 }
431 case OperationType::ENHANCEMENT_SYNC: {
432 return HandleSyncOperation();
433 }
434 default:
435 MEDIA_ERR_LOG("Unknown OprnType");
436 return E_ERR;
437 }
438 return E_OK;
439 }
440
HandleEnhancementQueryOperation(MediaLibraryCommand & cmd,const vector<string> & columns)441 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleEnhancementQueryOperation(MediaLibraryCommand &cmd,
442 const vector<string> &columns)
443 {
444 switch (cmd.GetOprnType()) {
445 case OperationType::ENHANCEMENT_QUERY:
446 // query database
447 return HandleQueryOperation(cmd, columns);
448 case OperationType::ENHANCEMENT_GET_PAIR:
449 return HandleGetPairOperation(cmd);
450 default:
451 break;
452 }
453 return nullptr;
454 }
455
456 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
AddServiceTask(MediaEnhanceBundleHandle * mediaEnhanceBundle,int32_t fileId,const string & photoId,const bool hasCloudWatermark,const bool isAuto)457 int32_t EnhancementManager::AddServiceTask(MediaEnhanceBundleHandle* mediaEnhanceBundle, int32_t fileId,
458 const string &photoId, const bool hasCloudWatermark, const bool isAuto)
459 {
460 EnhancementTaskManager::AddEnhancementTask(fileId, photoId,
461 (isAuto ? TYPE_AUTO_ENHANCEMENT_FOREGROUND : TYPE_MANUAL_ENHANCEMENT));
462 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
463 servicePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
464 GenerateAddServicePredicates(isAuto, servicePredicates);
465 ValuesBucket rdbValues;
466 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
467 isAuto ? static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO) :
468 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
469 rdbValues.PutInt(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, hasCloudWatermark ? YES : NO);
470 int32_t errCode = EnhancementDatabaseOperations::Update(rdbValues, servicePredicates);
471 if (errCode != E_OK) {
472 EnhancementTaskManager::RemoveEnhancementTask(photoId);
473 enhancementService_->DestroyBundle(mediaEnhanceBundle);
474 return E_ERR;
475 }
476 if (enhancementService_->AddTask(photoId, mediaEnhanceBundle) != E_OK) {
477 MEDIA_ERR_LOG("enhancment service error, photoId: %{public}s", photoId.c_str());
478 enhancementService_->DestroyBundle(mediaEnhanceBundle);
479 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
480 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
481 predicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
482 isAuto ? static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO) :
483 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
484 ValuesBucket values;
485 values.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
486 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
487 EnhancementDatabaseOperations::Update(values, predicates);
488 EnhancementTaskManager::RemoveEnhancementTask(photoId);
489 return E_ERR;
490 }
491 enhancementService_->DestroyBundle(mediaEnhanceBundle);
492 return E_OK;
493 }
494
GenerateAddServicePredicates(bool isAuto,RdbPredicates & servicePredicates)495 void EnhancementManager::GenerateAddServicePredicates(bool isAuto, RdbPredicates &servicePredicates)
496 {
497 if (isAuto) {
498 MEDIA_INFO_LOG("GenerateAddServicePredicates isAuto %{public}s", isAuto ? "true" : "false");
499 servicePredicates.And();
500 servicePredicates.EqualTo(PhotoColumn::PHOTO_IS_AUTO, static_cast<int32_t>(CloudEnhancementIsAutoType::AUTO));
501 }
502 servicePredicates.And();
503 servicePredicates.BeginWrap();
504 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
505 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
506 servicePredicates.Or();
507 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
508 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
509 servicePredicates.Or();
510 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
511 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
512 servicePredicates.EndWrap();
513 }
514
GenerateAddAutoServicePredicates(RdbPredicates & servicePredicates)515 void EnhancementManager::GenerateAddAutoServicePredicates(RdbPredicates &servicePredicates)
516 {
517 servicePredicates.EqualTo(PhotoColumn::PHOTO_IS_AUTO, static_cast<int32_t>(CloudEnhancementIsAutoType::AUTO));
518 servicePredicates.And();
519 servicePredicates.BeginWrap();
520 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
521 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
522 servicePredicates.Or();
523 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
524 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
525 servicePredicates.EndWrap();
526 servicePredicates.And();
527 servicePredicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, "0");
528 servicePredicates.And();
529 servicePredicates.EqualTo(PhotoColumn::PHOTO_EDIT_TIME, "0");
530 }
531
GenerateCancelOperationPredicates(int32_t fileId,RdbPredicates & servicePredicates)532 void EnhancementManager::GenerateCancelOperationPredicates(int32_t fileId, RdbPredicates &servicePredicates)
533 {
534 servicePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
535 servicePredicates.And();
536 servicePredicates.BeginWrap();
537 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
538 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
539 servicePredicates.Or();
540 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
541 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL));
542 servicePredicates.EndWrap();
543 }
544
HandleAddOperation(MediaLibraryCommand & cmd,const bool hasCloudWatermark,int triggerMode)545 int32_t EnhancementManager::HandleAddOperation(MediaLibraryCommand &cmd, const bool hasCloudWatermark, int triggerMode)
546 {
547 if (!IsAddOperationEnabled(triggerMode)) {
548 MEDIA_INFO_LOG("HandleAddOperation failed, conditions not met");
549 return E_ERR;
550 }
551 unordered_map<int32_t, string> fileId2Uri;
552 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_MIME_TYPE, PhotoColumn::PHOTO_IS_AUTO,
553 PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
554 auto resultSet = EnhancementDatabaseOperations::BatchQuery(cmd, columns, fileId2Uri);
555 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
556 int32_t errCode = E_OK;
557 while (resultSet->GoToNextRow() == E_OK) {
558 auto isAuto = triggerMode == static_cast<int>(CloudEnhancementTriggerModeType::TRIGGER_AUTO);
559 int32_t photoIsAuto = GetInt32Val(PhotoColumn::PHOTO_IS_AUTO, resultSet);
560 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
561 string mimeType = GetStringVal(MediaColumn::MEDIA_MIME_TYPE, resultSet);
562 int32_t dynamicRangeType = GetInt32Val(PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, resultSet);
563 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
564 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
565 MEDIA_INFO_LOG("HandleAddOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
566 fileId, photoId.c_str(), ceAvailable);
567 if (!ShouldAddTask(isAuto, photoIsAuto, ceAvailable, photoId)) {
568 errCode = E_ERR;
569 continue;
570 }
571 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
572 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
573 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
574 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_MODE, triggerMode);
575 FillBundleWithWaterMarkInfo(mediaEnhanceBundle, mimeType, dynamicRangeType, hasCloudWatermark);
576 errCode = AddServiceTask(mediaEnhanceBundle, fileId, photoId, hasCloudWatermark, isAuto);
577 if (errCode != E_OK) {
578 continue;
579 }
580 auto watch = MediaLibraryNotify::GetInstance();
581 if (watch != nullptr) {
582 watch->Notify(fileId2Uri[fileId], NotifyType::NOTIFY_UPDATE);
583 }
584 }
585 return errCode;
586 }
587
IsAddOperationEnabled(int32_t triggerMode)588 bool EnhancementManager::IsAddOperationEnabled(int32_t triggerMode)
589 {
590 if (triggerMode == static_cast<int>(CloudEnhancementTriggerModeType::TRIGGER_MANUAL)) {
591 MEDIA_INFO_LOG("manual enhancement task always enabled");
592 return true;
593 }
594 MEDIA_INFO_LOG("triggerMode: %{public}d, photos option: %{public}s, WiFi: %{public}s, CellularNet: %{public}s",
595 triggerMode, photosAutoOption_.c_str(), isWifiConnected_ ? "true" : "false",
596 isCellularNetConnected_ ? "true" : "false");
597 if (triggerMode == static_cast<int>(CloudEnhancementTriggerModeType::TRIGGER_AUTO)) {
598 bool cond = ((photosAutoOption_ == PHOTO_OPTION_CLOSE) || (!isWifiConnected_ && !isCellularNetConnected_));
599 CHECK_AND_RETURN_RET(!cond, false);
600 CHECK_AND_RETURN_RET(photosAutoOption_ != PHOTO_OPTION_WLAN_AND_NETWORK, true);
601 CHECK_AND_RETURN_RET(photosAutoOption_ != PHOTO_OPTION_WLAN_ONLY, isWifiConnected_);
602 }
603 return false;
604 }
605
HandleAutoAddOperation(bool isReboot)606 int32_t EnhancementManager::HandleAutoAddOperation(bool isReboot)
607 {
608 MEDIA_INFO_LOG("HandleAutoAddOperation");
609 if (!IsAutoTaskEnabled()) {
610 return E_ERR;
611 }
612 int32_t errCode = E_OK;
613 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
614 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_MIME_TYPE,
615 PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
616 GenerateAddAutoServicePredicates(servicePredicates);
617 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(servicePredicates, columns);
618 if (CheckResultSet(resultSet) != E_OK) {
619 MEDIA_INFO_LOG("no auto photo");
620 return E_ERR;
621 }
622 while (resultSet->GoToNextRow() == E_OK) {
623 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
624 string mimeType = GetStringVal(MediaColumn::MEDIA_MIME_TYPE, resultSet);
625 int32_t dynamicRangeType = GetInt32Val(PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, resultSet);
626 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
627 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
628 MEDIA_INFO_LOG("fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
629 fileId, photoId.c_str(), ceAvailable);
630 if (!isReboot && EnhancementTaskManager::InProcessingTask(photoId)) {
631 MEDIA_INFO_LOG("cloud enhancement task in cache is processing, photoId: %{public}s", photoId.c_str());
632 errCode = E_ERR;
633 continue;
634 }
635 if (!LoadService()) {
636 continue;
637 }
638 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
639 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
640 MediaEnhance_Trigger_Type::TRIGGER_LOW_LEVEL);
641 FillBundleWithWaterMarkInfo(mediaEnhanceBundle, mimeType, dynamicRangeType, shouldAddWaterMark_);
642 errCode = AddAutoServiceTask(mediaEnhanceBundle, fileId, photoId);
643 if (errCode != E_OK) {
644 continue;
645 }
646 }
647 return errCode;
648 }
649
AddAutoServiceTask(MediaEnhanceBundleHandle * mediaEnhanceBundle,int32_t fileId,const string & photoId)650 int32_t EnhancementManager::AddAutoServiceTask(MediaEnhanceBundleHandle* mediaEnhanceBundle, int32_t fileId,
651 const string &photoId)
652 {
653 MEDIA_INFO_LOG("adding auto enhancement service task");
654 EnhancementTaskManager::AddEnhancementTask(fileId, photoId, TYPE_AUTO_ENHANCEMENT_BACKGROUND);
655 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
656 servicePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
657 servicePredicates.And();
658 servicePredicates.EqualTo(PhotoColumn::PHOTO_IS_AUTO, static_cast<int32_t>(CloudEnhancementIsAutoType::AUTO));
659 servicePredicates.And();
660 servicePredicates.BeginWrap();
661 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
662 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
663 servicePredicates.Or();
664 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
665 static_cast<int32_t>(CloudEnhancementAvailableType::FAILED_RETRY));
666 servicePredicates.EndWrap();
667 ValuesBucket rdbValues;
668 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
669 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
670 rdbValues.PutInt(PhotoColumn::PHOTO_HAS_CLOUD_WATERMARK, shouldAddWaterMark_ ? YES : NO);
671
672 int32_t errCode = EnhancementDatabaseOperations::Update(rdbValues, servicePredicates);
673 if (errCode != E_OK) {
674 EnhancementTaskManager::RemoveEnhancementTask(photoId);
675 enhancementService_->DestroyBundle(mediaEnhanceBundle);
676 return E_ERR;
677 }
678 if (enhancementService_->AddTask(photoId, mediaEnhanceBundle) != E_OK) {
679 MEDIA_ERR_LOG("auto enhancment service error, photoId: %{public}s", photoId.c_str());
680 enhancementService_->DestroyBundle(mediaEnhanceBundle);
681 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
682 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
683 predicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
684 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
685 ValuesBucket values;
686 values.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
687 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
688 EnhancementDatabaseOperations::Update(values, predicates);
689 EnhancementTaskManager::RemoveEnhancementTask(photoId);
690 return E_ERR;
691 }
692 enhancementService_->DestroyBundle(mediaEnhanceBundle);
693 return E_OK;
694 }
695
IsAutoTaskEnabled()696 bool EnhancementManager::IsAutoTaskEnabled()
697 {
698 MEDIA_INFO_LOG("camera state: %{public}s, photos option: %{public}s, WiFi: %{public}s, CellularNet: %{public}s",
699 isCameraIdle_ ? "true" : "false", photosAutoOption_.c_str(), isWifiConnected_ ? "true" : "false",
700 isCellularNetConnected_ ? "true" : "false");
701
702 if (!isCameraIdle_ || (photosAutoOption_ == PHOTO_OPTION_CLOSE) ||
703 (!isWifiConnected_ && !isCellularNetConnected_)) {
704 MEDIA_INFO_LOG("auto task basic conditions not met");
705 return false;
706 }
707
708 if (photosAutoOption_ == PHOTO_OPTION_WLAN_AND_NETWORK) {
709 return true;
710 }
711
712 if (photosAutoOption_ == PHOTO_OPTION_WLAN_ONLY) {
713 return isWifiConnected_;
714 }
715 return false;
716 }
717
HandleCancelAllAutoOperation()718 int32_t EnhancementManager::HandleCancelAllAutoOperation()
719 {
720 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
721 vector<string> columns = { MediaColumn::MEDIA_ID, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
722 servicePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
723 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
724 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(servicePredicates, columns);
725 if (CheckResultSet(resultSet) != E_OK) {
726 MEDIA_INFO_LOG("no auto processing photo");
727 return E_ERR;
728 }
729 while (resultSet->GoToNextRow() == E_OK) {
730 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
731 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
732 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
733 MEDIA_INFO_LOG("HandleCancelAllAutoOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
734 fileId, photoId.c_str(), ceAvailable);
735 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO)) {
736 MEDIA_INFO_LOG("auto cloud enhancement task in db not processing, photoId: %{public}s",
737 photoId.c_str());
738 continue;
739 }
740 if (!EnhancementTaskManager::InProcessingTask(photoId)) {
741 MEDIA_INFO_LOG("auto task in cache not processing, photoId: %{public}s",
742 photoId.c_str());
743 continue;
744 }
745 if (!LoadService() || enhancementService_->CancelTask(photoId) != E_OK) {
746 MEDIA_ERR_LOG("cancel auto task error, photo_id: %{public}s", photoId.c_str());
747 continue;
748 }
749 EnhancementTaskManager::RemoveEnhancementTask(photoId);
750 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
751 updatePredicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
752 updatePredicates.And();
753 updatePredicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
754 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
755 ValuesBucket rdbValues;
756 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
757 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
758 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
759 if (ret != E_OK) {
760 MEDIA_ERR_LOG("update ce_available failed");
761 continue;
762 }
763 CloudEnhancementGetCount::GetInstance().RemoveStartTime(photoId);
764 }
765 return E_OK;
766 }
767
ResetProcessingAutoToSupport()768 void EnhancementManager::ResetProcessingAutoToSupport()
769 {
770 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
771 predicates.EqualTo(PhotoColumn::PHOTO_CE_AVAILABLE,
772 static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO));
773 ValuesBucket values;
774 values.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE,
775 static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
776 EnhancementDatabaseOperations::Update(values, predicates);
777 }
778 #endif
779
HandlePrioritizeOperation(MediaLibraryCommand & cmd)780 int32_t EnhancementManager::HandlePrioritizeOperation(MediaLibraryCommand &cmd)
781 {
782 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
783 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
784 vector<string> columns = {
785 MediaColumn::MEDIA_ID,
786 PhotoColumn::PHOTO_ID,
787 PhotoColumn::PHOTO_CE_AVAILABLE
788 };
789 auto resultSet = EnhancementDatabaseOperations::Query(cmd, servicePredicates, columns);
790 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
791 resultSet->GoToNextRow();
792 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
793 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
794 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
795 resultSet->Close();
796 MEDIA_INFO_LOG("HandlePrioritizeOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
797 fileId, photoId.c_str(), ceAvailable);
798 if ((ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL)) &&
799 (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO))) {
800 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s",
801 photoId.c_str());
802 return E_ERR;
803 }
804 if (!EnhancementTaskManager::InProcessingTask(photoId) ||
805 EnhancementTaskManager::GetTaskRequestCount(photoId) != 0) {
806 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s",
807 photoId.c_str());
808 return E_ERR;
809 }
810 CHECK_AND_RETURN_RET_LOG(LoadService(), E_ERR, "load enhancement service error");
811 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
812 if (mediaEnhanceBundle == nullptr) {
813 return E_ERR;
814 }
815 enhancementService_->PutInt(mediaEnhanceBundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE,
816 MediaEnhance_Trigger_Type::TRIGGER_HIGH_LEVEL);
817 int32_t ret = enhancementService_->AddTask(photoId, mediaEnhanceBundle);
818 enhancementService_->DestroyBundle(mediaEnhanceBundle);
819 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "enhancment service error, photoId: %{public}s", photoId.c_str());
820 return ret;
821 #else
822 MEDIA_ERR_LOG("not supply cloud enhancement service");
823 return E_ERR;
824 #endif
825 }
826
HandleCancelOperation(MediaLibraryCommand & cmd)827 int32_t EnhancementManager::HandleCancelOperation(MediaLibraryCommand &cmd)
828 {
829 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
830 unordered_map<int32_t, string> fileId2Uri;
831 vector<string> columns = { MediaColumn::MEDIA_ID, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
832 auto resultSet = EnhancementDatabaseOperations::BatchQuery(cmd, columns, fileId2Uri);
833 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
834 while (resultSet->GoToNextRow() == E_OK) {
835 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
836 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
837 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
838 MEDIA_INFO_LOG("HandleCancelOperation fileId: %{public}d, photoId: %{public}s, ceAvailable: %{public}d",
839 fileId, photoId.c_str(), ceAvailable);
840 if ((ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL)) &&
841 (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO))) {
842 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s",
843 photoId.c_str());
844 continue;
845 }
846 if (!EnhancementTaskManager::InProcessingTask(photoId)) {
847 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s",
848 photoId.c_str());
849 continue;
850 }
851 if (!LoadService() || enhancementService_->CancelTask(photoId) != E_OK) {
852 MEDIA_ERR_LOG("enhancment service error, photoId: %{public}s", photoId.c_str());
853 continue;
854 }
855 EnhancementTaskManager::RemoveEnhancementTask(photoId);
856 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
857 GenerateCancelOperationPredicates(fileId, servicePredicates);
858 ValuesBucket rdbValues;
859 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
860 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, servicePredicates);
861 if (ret != E_OK) {
862 MEDIA_ERR_LOG("update ce_available error, photoId: %{public}s", photoId.c_str());
863 continue;
864 }
865 CloudEnhancementGetCount::GetInstance().RemoveStartTime(photoId);
866 auto watch = MediaLibraryNotify::GetInstance();
867 if (watch != nullptr) {
868 watch->Notify(fileId2Uri[fileId], NotifyType::NOTIFY_UPDATE);
869 }
870 }
871 return E_OK;
872 #else
873 return E_ERR;
874 #endif
875 }
876
HandleCancelAllOperation()877 int32_t EnhancementManager::HandleCancelAllOperation()
878 {
879 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
880 CHECK_AND_RETURN_RET_LOG(LoadService(), E_ERR, "Load Service Error");
881 int32_t ret = enhancementService_->CancelAllTasks();
882 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "cancel all tasks failed: enhancment service error");
883 vector<string> taskIds;
884 EnhancementTaskManager::RemoveAllEnhancementTask(taskIds);
885 CHECK_AND_RETURN_RET_LOG(!taskIds.empty(), E_OK, "cloud enhancement tasks in cache are not processing");
886 RdbPredicates queryPredicates(PhotoColumn::PHOTOS_TABLE);
887 queryPredicates.In(PhotoColumn::PHOTO_ID, taskIds);
888 vector<string> columns = { MediaColumn::MEDIA_ID, MediaColumn::MEDIA_FILE_PATH,
889 MediaColumn::MEDIA_NAME, PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_CE_AVAILABLE };
890 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(queryPredicates, columns);
891 CHECK_AND_RETURN_RET_LOG(CheckResultSet(resultSet) == E_OK, E_ERR, "result set invalid");
892 while (resultSet->GoToNextRow() == E_OK) {
893 int32_t fileId = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
894 string filePath = GetStringVal(MediaColumn::MEDIA_FILE_PATH, resultSet);
895 string displayName = GetStringVal(MediaColumn::MEDIA_NAME, resultSet);
896 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
897 int32_t ceAvailable = GetInt32Val(PhotoColumn::PHOTO_CE_AVAILABLE, resultSet);
898 if (ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_MANUAL)
899 && ceAvailable != static_cast<int32_t>(CloudEnhancementAvailableType::PROCESSING_AUTO)) {
900 MEDIA_INFO_LOG("cloud enhancement task in db not processing, photoId: %{public}s", photoId.c_str());
901 continue;
902 }
903 string uri = MediaFileUtils::GetUriByExtrConditions(PhotoColumn::PHOTO_URI_PREFIX, to_string(fileId),
904 MediaFileUtils::GetExtraUri(displayName, filePath));
905 RdbPredicates updatePredicates(PhotoColumn::PHOTOS_TABLE);
906 GenerateCancelAllUpdatePredicates(fileId, updatePredicates);
907 ValuesBucket rdbValues;
908 rdbValues.PutInt(PhotoColumn::PHOTO_CE_AVAILABLE, static_cast<int32_t>(CloudEnhancementAvailableType::SUPPORT));
909 int32_t ret = EnhancementDatabaseOperations::Update(rdbValues, updatePredicates);
910 if (ret != E_OK) {
911 MEDIA_ERR_LOG("update ce_available error, photoId: %{public}s", photoId.c_str());
912 continue;
913 }
914 CloudEnhancementGetCount::GetInstance().RemoveStartTime(photoId);
915 auto watch = MediaLibraryNotify::GetInstance();
916 if (watch != nullptr) {
917 watch->Notify(uri, NotifyType::NOTIFY_UPDATE);
918 }
919 }
920 return E_OK;
921 #else
922 MEDIA_ERR_LOG("not supply cloud enhancement service");
923 return E_ERR;
924 #endif
925 }
926
HandlePauseAllOperation()927 int32_t EnhancementManager::HandlePauseAllOperation()
928 {
929 MEDIA_INFO_LOG("EnhancementManager::HandlePauseAllOperation");
930 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
931 bool isServiceExist = ((enhancementService_ != nullptr) && enhancementService_->IsConnected());
932 CHECK_AND_RETURN_RET_LOG(isServiceExist, E_ERR, "enhancementService not connected");
933 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
934 int32_t ret = enhancementService_->PauseAllTasks(mediaEnhanceBundle);
935 enhancementService_->DestroyBundle(mediaEnhanceBundle);
936 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "pause all tasks failed: enhancment service error");
937 return E_OK;
938 #else
939 MEDIA_ERR_LOG("not supply cloud enhancement service");
940 return E_ERR;
941 #endif
942 }
943
HandleResumeAllOperation()944 int32_t EnhancementManager::HandleResumeAllOperation()
945 {
946 MEDIA_INFO_LOG("EnhancementManager::HandleResumeAllOperation");
947 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
948 bool isServiceExist = ((enhancementService_ != nullptr) && enhancementService_->IsConnected());
949 CHECK_AND_RETURN_RET_LOG(isServiceExist, E_ERR, "enhancementService not connected");
950 MediaEnhanceBundleHandle* mediaEnhanceBundle = enhancementService_->CreateBundle();
951 int32_t ret = enhancementService_->ResumeAllTasks(mediaEnhanceBundle);
952 enhancementService_->DestroyBundle(mediaEnhanceBundle);
953 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "resume all tasks failed: enhancment service error");
954 return E_OK;
955 #else
956 MEDIA_ERR_LOG("not supply cloud enhancement service");
957 return E_ERR;
958 #endif
959 }
960
HandleSyncOperation()961 int32_t EnhancementManager::HandleSyncOperation()
962 {
963 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
964 MEDIA_INFO_LOG("photos start, begin to sync photos cloud enhancement available");
965 vector<string> taskIdList;
966 bool cond = (!LoadService() || enhancementService_->GetPendingTasks(taskIdList) != E_OK);
967 CHECK_AND_RETURN_RET_LOG(!cond, E_ERR, "sync tasks failed: enhancment service error");
968
969 CHECK_AND_RETURN_RET_LOG(!taskIdList.empty(), E_OK, "no pending tasks from cloud enhancement service");
970 MEDIA_INFO_LOG("enhancement pending tasks count from cloud enhancement: %{public}zu", taskIdList.size());
971
972 auto ret = EnhancementDatabaseOperations::QueryAndUpdatePhotos(taskIdList);
973 CHECK_AND_RETURN_RET_LOG(ret == E_OK, ret, "sync tasks failed, query and update photos error");
974
975 MEDIA_INFO_LOG("sync photos cloud enhancement available done");
976 return E_OK;
977 #else
978 MEDIA_ERR_LOG("not supply cloud enhancement service");
979 return E_ERR;
980 #endif
981 }
982
HandleQueryOperation(MediaLibraryCommand & cmd,const vector<string> & columns)983 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleQueryOperation(MediaLibraryCommand &cmd,
984 const vector<string> &columns)
985 {
986 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
987 RdbPredicates servicePredicates(PhotoColumn::PHOTOS_TABLE);
988 auto resultSet = EnhancementDatabaseOperations::Query(cmd, servicePredicates, columns);
989 if (CheckResultSet(resultSet) != E_OK) {
990 return nullptr;
991 }
992 resultSet->GoToNextRow();
993 string photoId = GetStringVal(PhotoColumn::PHOTO_ID, resultSet);
994 if (!EnhancementTaskManager::InProcessingTask(photoId)) {
995 MEDIA_INFO_LOG("cloud enhancement task in cache not processing, photoId: %{public}s", photoId.c_str());
996 }
997
998 return resultSet;
999 #else
1000 MEDIA_ERR_LOG("not supply cloud enhancement service");
1001 return nullptr;
1002 #endif
1003 }
1004
HandleGetPairOperation(MediaLibraryCommand & cmd)1005 shared_ptr<NativeRdb::ResultSet> EnhancementManager::HandleGetPairOperation(MediaLibraryCommand &cmd)
1006 {
1007 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
1008 MEDIA_INFO_LOG("HandleGetPairOperation success");
1009 auto resultSet = EnhancementDatabaseOperations::GetPair(cmd);
1010 if (CheckResultSet(resultSet) != E_OK) {
1011 MEDIA_INFO_LOG("Failed to get resultSet from HandleGetPairOperation");
1012 return nullptr;
1013 }
1014 return resultSet;
1015 #else
1016 MEDIA_ERR_LOG("not supply cloud enhancement service");
1017 return nullptr;
1018 #endif
1019 }
1020
HandleStateChangedOperation(const bool isCameraIdle)1021 int32_t EnhancementManager::HandleStateChangedOperation(const bool isCameraIdle)
1022 {
1023 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
1024 CHECK_AND_RETURN_RET(isCameraIdle_ != isCameraIdle, E_OK);
1025 isCameraIdle_ = isCameraIdle;
1026 if (isCameraIdle_) {
1027 HandleResumeAllOperation();
1028 HandleAutoAddOperation();
1029 } else {
1030 HandlePauseAllOperation();
1031 }
1032 return E_OK;
1033 #else
1034 MEDIA_ERR_LOG("not supply cloud enhancement service");
1035 return E_ERR;
1036 #endif
1037 }
1038
HandleNetChange(const bool isWifiConnected,const bool isCellularNetConnected)1039 int32_t EnhancementManager::HandleNetChange(const bool isWifiConnected, const bool isCellularNetConnected)
1040 {
1041 bool isWifiStateChanged = (isWifiConnected_ != isWifiConnected);
1042 bool isCellularStateChanged = (isCellularNetConnected_ != isCellularNetConnected);
1043 if (!isWifiStateChanged && !isCellularStateChanged) {
1044 MEDIA_INFO_LOG("HandleNetChange net not changed");
1045 return E_OK;
1046 }
1047 MEDIA_INFO_LOG("HandleNetChange, IsWifiConnected: %{public}d, IsCellularNetConnected: %{public}d",
1048 isWifiConnected, isCellularNetConnected);
1049
1050 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
1051 if (!IsAutoTaskEnabled()) {
1052 isWifiConnected_ = isWifiConnected;
1053 isCellularNetConnected_ = isCellularNetConnected;
1054 return HandleAutoAddOperation();
1055 }
1056 isWifiConnected_ = isWifiConnected;
1057 isCellularNetConnected_ = isCellularNetConnected;
1058 return E_OK;
1059 #else
1060 MEDIA_ERR_LOG("not supply cloud enhancement service");
1061 return E_ERR;
1062 #endif
1063 }
1064
HandlePhotosAutoOptionChange(const std::string & photosAutoOption)1065 int32_t EnhancementManager::HandlePhotosAutoOptionChange(const std::string &photosAutoOption)
1066 {
1067 if (photosAutoOption_ == photosAutoOption) {
1068 MEDIA_INFO_LOG("HandlePhotosAutoOptionChange option not changed");
1069 return E_OK;
1070 }
1071 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
1072 if (photosAutoOption == PHOTO_OPTION_CLOSE) {
1073 MEDIA_INFO_LOG("photos option turn to close");
1074 photosAutoOption_ = photosAutoOption;
1075 return HandleCancelAllAutoOperation();
1076 } else if (!IsAutoTaskEnabled()) {
1077 photosAutoOption_ = photosAutoOption;
1078 return HandleAutoAddOperation();
1079 }
1080 photosAutoOption_ = photosAutoOption;
1081 return E_OK;
1082 #else
1083 MEDIA_ERR_LOG("not supply cloud enhancement service");
1084 return E_ERR;
1085 #endif
1086 }
1087
HandlePhotosWaterMarkChange(const bool shouldAddWaterMark)1088 void EnhancementManager::HandlePhotosWaterMarkChange(const bool shouldAddWaterMark)
1089 {
1090 MEDIA_INFO_LOG("HandlePhotosWaterMarkChange shouldAddWaterMark is %{public}d", shouldAddWaterMark);
1091 if (shouldAddWaterMark_ == shouldAddWaterMark) {
1092 return;
1093 }
1094 shouldAddWaterMark_ = shouldAddWaterMark;
1095 }
1096 } // namespace Media
1097 } // namespace OHOS