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