1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define MLOG_TAG "MedialibrarySubscribe"
16
17 #include "medialibrary_subscriber.h"
18
19 #include <memory>
20 #include "appexecfwk_errors.h"
21 #include "background_cloud_file_processor.h"
22 #include "background_task_mgr_helper.h"
23 #ifdef HAS_BATTERY_MANAGER_PART
24 #include "battery_srv_client.h"
25 #endif
26 #include "bundle_info.h"
27 #include "cloud_media_asset_manager.h"
28 #include "cloud_media_asset_types.h"
29 #include "cloud_sync_utils.h"
30 #include "cloud_upload_checker.h"
31 #include "common_event_manager.h"
32 #include "common_event_support.h"
33 #include "common_event_utils.h"
34 #include "dfx_cloud_manager.h"
35
36 #include "want.h"
37 #include "post_event_utils.h"
38 #ifdef HAS_POWER_MANAGER_PART
39 #include "power_mgr_client.h"
40 #endif
41 #ifdef HAS_THERMAL_MANAGER_PART
42 #include "thermal_mgr_client.h"
43 #endif
44
45 #include "medialibrary_album_fusion_utils.h"
46 #include "medialibrary_all_album_refresh_processor.h"
47 #include "medialibrary_bundle_manager.h"
48 #include "medialibrary_data_manager.h"
49 #include "medialibrary_errno.h"
50 #include "medialibrary_inotify.h"
51 #ifdef META_RECOVERY_SUPPORT
52 #include "medialibrary_meta_recovery.h"
53 #endif
54 #include "medialibrary_restore.h"
55 #include "medialibrary_subscriber_database_utils.h"
56 #include "media_file_utils.h"
57 #include "media_log.h"
58 #include "media_scanner_manager.h"
59 #include "application_context.h"
60 #include "ability_manager_client.h"
61 #include "resource_type.h"
62 #include "dfx_manager.h"
63 #include "medialibrary_unistore_manager.h"
64 #include "medialibrary_rdb_utils.h"
65 #include "medialibrary_type_const.h"
66 #include "moving_photo_processor.h"
67 #include "permission_utils.h"
68 #include "thumbnail_generate_worker_manager.h"
69 #include "userfilemgr_uri.h"
70 #include "common_timer_errors.h"
71 #include "parameters.h"
72 #ifdef HAS_WIFI_MANAGER_PART
73 #include "wifi_device.h"
74 #endif
75 #include "power_efficiency_manager.h"
76 #include "photo_album_lpath_operation.h"
77 #include "medialibrary_astc_stat.h"
78 #include "photo_mimetype_operation.h"
79 #include "photo_other_album_trans_operation.h"
80 #include "preferences.h"
81 #include "preferences_helper.h"
82 #include "background_cloud_file_processor.h"
83 #ifdef MEDIALIBRARY_FEATURE_CLOUD_ENHANCEMENT
84 #include "enhancement_manager.h"
85 #include "cloud_enhancement_checker.h"
86 #endif
87
88 using namespace OHOS::AAFwk;
89
90 namespace OHOS {
91 namespace Media {
92 // The task can be performed when the battery level reaches the value
93 const int32_t PROPER_DEVICE_BATTERY_CAPACITY = 50;
94 const int32_t PROPER_DEVICE_BATTERY_CAPACITY_THUMBNAIL = 20;
95
96 const int TIME_START_RELEASE_TEMPERATURE_LIMIT = 1;
97 const int TIME_STOP_RELEASE_TEMPERATURE_LIMIT = 6;
98
99 // The task can be performed only when the temperature of the device is lower than the value
100 const int32_t PROPER_DEVICE_TEMPERATURE_LEVEL_37 = 1;
101 const int32_t PROPER_DEVICE_TEMPERATURE_LEVEL_40 = 2;
102 const int32_t PROPER_DEVICE_TEMPERATURE_LEVEL_43 = 3;
103
104 // WIFI should be available in this state
105 const int32_t WIFI_STATE_CONNECTED = 4;
106 const int32_t DELAY_TASK_TIME = 30000;
107 const int32_t COMMON_EVENT_KEY_GET_DEFAULT_PARAM = -1;
108 const int32_t MEGA_BYTE = 1024 * 1024;
109 const int32_t MAX_FILE_SIZE_MB = 10240;
110 const std::string COMMON_EVENT_KEY_BATTERY_CAPACITY = "soc";
111 const std::string COMMON_EVENT_KEY_DEVICE_TEMPERATURE = "0";
112 static const std::string TASK_PROGRESS_XML = "/data/storage/el2/base/preferences/task_progress.xml";
113 static const std::string NO_UPDATE_DIRTY = "no_update_dirty";
114 static const std::string NO_DELETE_DIRTY_HDC_DATA = "no_delete_dirty_hdc_data";
115
116 // The network should be available in this state
117 const int32_t NET_CONN_STATE_CONNECTED = 3;
118 // The net bearer type is in net_all_capabilities.h
119 const int32_t BEARER_CELLULAR = 0;
120 const int32_t THUMB_ASTC_ENOUGH = 20000;
121 bool MedialibrarySubscriber::isCellularNetConnected_ = false;
122 bool MedialibrarySubscriber::isWifiConnected_ = false;
123 bool MedialibrarySubscriber::currentStatus_ = false;
124 // BetaVersion will upload the DB, and the true uploadDBFlag indicates that uploading is enabled.
125 const std::string KEY_HIVIEW_VERSION_TYPE = "const.logsystem.versiontype";
126 std::atomic<bool> uploadDBFlag(true);
127 int64_t g_lastTime = MediaFileUtils::UTCTimeMilliSeconds();
128 const int32_t HALF_HOUR_MS = 1800000;
129
130 const std::vector<std::string> MedialibrarySubscriber::events_ = {
131 EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING,
132 EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING,
133 EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF,
134 EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON,
135 EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED,
136 EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED,
137 EventFwk::CommonEventSupport::COMMON_EVENT_THERMAL_LEVEL_CHANGED,
138 EventFwk::CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE,
139 EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE,
140 EventFwk::CommonEventSupport::COMMON_EVENT_TIME_TICK,
141 EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT
142 };
143
144 const std::map<std::string, StatusEventType> BACKGROUND_OPERATION_STATUS_MAP = {
145 {EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING, StatusEventType::CHARGING},
146 {EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING, StatusEventType::DISCHARGING},
147 {EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF, StatusEventType::SCREEN_OFF},
148 {EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON, StatusEventType::SCREEN_ON},
149 {EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED, StatusEventType::BATTERY_CHANGED},
150 {EventFwk::CommonEventSupport::COMMON_EVENT_THERMAL_LEVEL_CHANGED, StatusEventType::THERMAL_LEVEL_CHANGED},
151 {EventFwk::CommonEventSupport::COMMON_EVENT_TIME_TICK, StatusEventType::TIME_TICK},
152 };
153
GetNowLocalTime(std::tm & nowLocalTime)154 bool GetNowLocalTime(std::tm &nowLocalTime)
155 {
156 auto now = std::chrono::system_clock::now();
157 std::time_t nowTime = std::chrono::system_clock::to_time_t(now);
158 return localtime_r(&nowTime, &nowLocalTime) != nullptr;
159 }
160
MedialibrarySubscriber(const EventFwk::CommonEventSubscribeInfo & subscriberInfo)161 MedialibrarySubscriber::MedialibrarySubscriber(const EventFwk::CommonEventSubscribeInfo &subscriberInfo)
162 : EventFwk::CommonEventSubscriber(subscriberInfo)
163 {
164 #ifdef HAS_POWER_MANAGER_PART
165 auto& powerMgrClient = PowerMgr::PowerMgrClient::GetInstance();
166 isScreenOff_ = !powerMgrClient.IsScreenOn();
167 #endif
168 #ifdef HAS_BATTERY_MANAGER_PART
169 auto& batteryClient = PowerMgr::BatterySrvClient::GetInstance();
170 auto chargeState = batteryClient.GetChargingStatus();
171 isCharging_ = (chargeState == PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE) ||
172 (chargeState == PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
173 batteryCapacity_ = batteryClient.GetCapacity();
174 #endif
175 #ifdef HAS_THERMAL_MANAGER_PART
176 auto& thermalMgrClient = PowerMgr::ThermalMgrClient::GetInstance();
177 newTemperatureLevel_ = static_cast<int32_t>(thermalMgrClient.GetThermalLevel());
178 isDeviceTemperatureProper_ = newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_37;
179 #endif
180 #ifdef HAS_WIFI_MANAGER_PART
181 auto wifiDevicePtr = Wifi::WifiDevice::GetInstance(WIFI_DEVICE_ABILITY_ID);
182 if (wifiDevicePtr == nullptr) {
183 MEDIA_ERR_LOG("MedialibrarySubscriber wifiDevicePtr is null");
184 } else {
185 ErrCode ret = wifiDevicePtr->IsConnected(isWifiConnected_);
186 if (ret != Wifi::WIFI_OPT_SUCCESS) {
187 MEDIA_ERR_LOG("MedialibrarySubscriber Get-IsConnected-fail: -%{public}d", ret);
188 }
189 }
190 #endif
191 MediaLibraryAllAlbumRefreshProcessor::GetInstance()->OnCurrentStatusChanged(
192 isScreenOff_ && isCharging_ && batteryCapacity_ >= PROPER_DEVICE_BATTERY_CAPACITY
193 && isDeviceTemperatureProper_);
194 MEDIA_DEBUG_LOG("MedialibrarySubscriber current status:%{public}d, %{public}d, %{public}d, %{public}d, %{public}d",
195 isScreenOff_, isCharging_, batteryCapacity_, newTemperatureLevel_, isWifiConnected_);
196 }
197
198 MedialibrarySubscriber::~MedialibrarySubscriber() = default;
199
Subscribe(void)200 bool MedialibrarySubscriber::Subscribe(void)
201 {
202 EventFwk::MatchingSkills matchingSkills;
203 for (auto event : events_) {
204 matchingSkills.AddEvent(event);
205 }
206
207 MEDIA_INFO_LOG("Subscribe: add event.");
208 EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
209
210 std::shared_ptr<MedialibrarySubscriber> subscriber = std::make_shared<MedialibrarySubscriber>(subscribeInfo);
211 return EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber);
212 }
213
IsBetaVersion()214 static bool IsBetaVersion()
215 {
216 static const string versionType = system::GetParameter(KEY_HIVIEW_VERSION_TYPE, "unknown");
217 static bool isBetaVersion = versionType.find("beta") != std::string::npos;
218 return isBetaVersion;
219 }
220
IsLastHalfHourDb()221 static bool IsLastHalfHourDb()
222 {
223 int64_t curTime = MediaFileUtils::UTCTimeMilliSeconds();
224 if (curTime - g_lastTime >= HALF_HOUR_MS) {
225 g_lastTime = curTime;
226 return true;
227 }
228 return false;
229 }
230
UploadDBFile()231 static void UploadDBFile()
232 {
233 uploadDBFlag.store(false);
234 int64_t begin = MediaFileUtils::UTCTimeMilliSeconds();
235 static const std::string databaseDir = MEDIA_DB_DIR + "/rdb";
236 static const std::vector<std::string> dbFileName = { "/media_library.db",
237 "/media_library.db-shm",
238 "/media_library.db-wal" };
239 static const std::string destPath = "/data/storage/el2/log/logpack";
240 int64_t totalFileSize = 0;
241 for (auto &dbName : dbFileName) {
242 string dbPath = databaseDir + dbName;
243 struct stat statInfo {};
244 if (stat(dbPath.c_str(), &statInfo) != 0) {
245 continue;
246 }
247 totalFileSize += statInfo.st_size;
248 }
249 totalFileSize /= MEGA_BYTE; // Convert bytes to MB
250 if (totalFileSize > MAX_FILE_SIZE_MB) {
251 MEDIA_WARN_LOG("DB file over 10GB are not uploaded, totalFileSize is %{public}ld MB",
252 static_cast<long>(totalFileSize));
253 uploadDBFlag.store(true);
254 return ;
255 }
256 if (!MediaFileUtils::IsFileExists(destPath) && !MediaFileUtils::CreateDirectory(destPath)) {
257 MEDIA_ERR_LOG("Create dir failed, dir=%{private}s", destPath.c_str());
258 uploadDBFlag.store(true);
259 return ;
260 }
261 auto dataManager = MediaLibraryDataManager::GetInstance();
262 if (dataManager == nullptr) {
263 MEDIA_ERR_LOG("dataManager is nullptr");
264 uploadDBFlag.store(true);
265 return;
266 }
267 dataManager->UploadDBFileInner(totalFileSize);
268 int64_t end = MediaFileUtils::UTCTimeMilliSeconds();
269 MEDIA_INFO_LOG("Handle %{public}ld MB DBFile success, cost %{public}ld ms", static_cast<long>(totalFileSize),
270 static_cast<long>(end - begin));
271 uploadDBFlag.store(true);
272 }
273
CheckHalfDayMissions()274 void MedialibrarySubscriber::CheckHalfDayMissions()
275 {
276 if (isScreenOff_ && isCharging_) {
277 if (IsBetaVersion() && uploadDBFlag.load() && IsLastHalfHourDb()) {
278 MEDIA_INFO_LOG("Version is BetaVersion, UploadDBFile");
279 UploadDBFile();
280 }
281 DfxManager::GetInstance()->HandleHalfDayMissions();
282 MediaLibraryRestore::GetInstance().CheckBackup();
283 }
284 if (!isScreenOff_ || !isCharging_) {
285 MediaLibraryRestore::GetInstance().InterruptBackup();
286 }
287 #ifdef META_RECOVERY_SUPPORT
288 MediaLibraryMetaRecovery::GetInstance().StatisticSave();
289 #endif
290 }
291
UpdateCurrentStatus()292 void MedialibrarySubscriber::UpdateCurrentStatus()
293 {
294 std::lock_guard<std::mutex> lock(mutex_);
295 std::tm nowLocalTime;
296 bool newStatus = false;
297 bool isPowerSufficient = batteryCapacity_ >= PROPER_DEVICE_BATTERY_CAPACITY;
298 if (GetNowLocalTime(nowLocalTime) && nowLocalTime.tm_hour >= TIME_START_RELEASE_TEMPERATURE_LIMIT &&
299 nowLocalTime.tm_hour < TIME_STOP_RELEASE_TEMPERATURE_LIMIT) {
300 newStatus = isScreenOff_ && isCharging_ && isPowerSufficient &&
301 newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_43;
302 } else {
303 newStatus = isScreenOff_ && isCharging_ && isPowerSufficient &&
304 newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_37;
305 }
306
307 if (currentStatus_ == newStatus) {
308 return;
309 }
310
311 MEDIA_INFO_LOG("update status current:%{public}d, new:%{public}d, %{public}d, %{public}d, %{public}d, %{public}d",
312 currentStatus_, newStatus, isScreenOff_, isCharging_, isPowerSufficient, newTemperatureLevel_);
313 currentStatus_ = newStatus;
314 backgroundDelayTask_.EndBackgroundOperationThread();
315 if (currentStatus_) {
316 backgroundDelayTask_.SetOperationThread([this] { this->DoBackgroundOperation(); });
317 } else {
318 StopBackgroundOperation();
319 }
320 MediaLibraryAllAlbumRefreshProcessor::GetInstance()->OnCurrentStatusChanged(currentStatus_);
321 }
322
WalCheckPointAsync()323 void MedialibrarySubscriber::WalCheckPointAsync()
324 {
325 if (!isScreenOff_ || !isCharging_) {
326 return;
327 }
328 std::thread(MediaLibraryRdbStore::WalCheckPoint).detach();
329 }
330
UpdateBackgroundOperationStatus(const AAFwk::Want & want,const StatusEventType statusEventType)331 void MedialibrarySubscriber::UpdateBackgroundOperationStatus(
332 const AAFwk::Want &want, const StatusEventType statusEventType)
333 {
334 switch (statusEventType) {
335 case StatusEventType::SCREEN_OFF:
336 isScreenOff_ = true;
337 break;
338 case StatusEventType::SCREEN_ON:
339 isScreenOff_ = false;
340 break;
341 case StatusEventType::CHARGING:
342 isCharging_ = true;
343 break;
344 case StatusEventType::DISCHARGING:
345 isCharging_ = false;
346 break;
347 case StatusEventType::BATTERY_CHANGED:
348 batteryCapacity_ = want.GetIntParam(COMMON_EVENT_KEY_BATTERY_CAPACITY,
349 COMMON_EVENT_KEY_GET_DEFAULT_PARAM);
350 break;
351 case StatusEventType::THERMAL_LEVEL_CHANGED: {
352 newTemperatureLevel_ = want.GetIntParam(COMMON_EVENT_KEY_DEVICE_TEMPERATURE,
353 COMMON_EVENT_KEY_GET_DEFAULT_PARAM);
354 isDeviceTemperatureProper_ = newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_37;
355 break;
356 }
357 case StatusEventType::TIME_TICK:
358 break;
359 default:
360 MEDIA_WARN_LOG("StatusEventType:%{public}d is not invalid", statusEventType);
361 return;
362 }
363
364 UpdateCurrentStatus();
365 UpdateThumbnailBgGenerationStatus();
366 UpdateBackgroundTimer();
367 DealWithEventsAfterUpdateStatus(statusEventType);
368 }
369
UpdateCloudMediaAssetDownloadStatus(const AAFwk::Want & want,const StatusEventType statusEventType)370 void MedialibrarySubscriber::UpdateCloudMediaAssetDownloadStatus(const AAFwk::Want &want,
371 const StatusEventType statusEventType)
372 {
373 if (statusEventType != StatusEventType::THERMAL_LEVEL_CHANGED) {
374 return;
375 }
376 int32_t taskStatus = CloudMediaAssetManager::GetInstance().GetTaskStatus();
377 int32_t downloadType = CloudMediaAssetManager::GetInstance().GetDownloadType();
378 bool foregroundTemperature = want.GetIntParam(COMMON_EVENT_KEY_DEVICE_TEMPERATURE,
379 COMMON_EVENT_KEY_GET_DEFAULT_PARAM) <= PROPER_DEVICE_TEMPERATURE_LEVEL_43;
380 if (!foregroundTemperature && downloadType == static_cast<int32_t>(CloudMediaDownloadType::DOWNLOAD_FORCE)) {
381 CloudMediaAssetManager::GetInstance().PauseDownloadCloudAsset(CloudMediaTaskPauseCause::TEMPERATURE_LIMIT);
382 return;
383 }
384 if (foregroundTemperature && taskStatus == static_cast<int32_t>(CloudMediaAssetTaskStatus::PAUSED)) {
385 CloudMediaAssetManager::GetInstance().RecoverDownloadCloudAsset(
386 CloudMediaTaskRecoverCause::FOREGROUND_TEMPERATURE_PROPER);
387 }
388 }
389
IsCellularNetConnected()390 bool MedialibrarySubscriber::IsCellularNetConnected()
391 {
392 return isCellularNetConnected_;
393 }
394
IsWifiConnected()395 bool MedialibrarySubscriber::IsWifiConnected()
396 {
397 return isWifiConnected_;
398 }
399
IsCurrentStatusOn()400 bool MedialibrarySubscriber::IsCurrentStatusOn()
401 {
402 return currentStatus_;
403 }
404
UpdateCloudMediaAssetDownloadTaskStatus()405 void MedialibrarySubscriber::UpdateCloudMediaAssetDownloadTaskStatus()
406 {
407 if (!isCellularNetConnected_) {
408 MEDIA_INFO_LOG("CellularNet not connected.");
409 int32_t taskStatus = CloudMediaAssetManager::GetInstance().GetTaskStatus();
410 if (taskStatus == static_cast<int32_t>(CloudMediaAssetTaskStatus::PAUSED)) {
411 CloudMediaAssetManager::GetInstance().PauseDownloadCloudAsset(CloudMediaTaskPauseCause::NETWORK_FLOW_LIMIT);
412 }
413 return;
414 }
415 if (CloudSyncUtils::IsUnlimitedTrafficStatusOn()) {
416 CloudMediaAssetManager::GetInstance().RecoverDownloadCloudAsset(CloudMediaTaskRecoverCause::NETWORK_NORMAL);
417 } else if (!isWifiConnected_) {
418 CloudMediaAssetManager::GetInstance().PauseDownloadCloudAsset(CloudMediaTaskPauseCause::WIFI_UNAVAILABLE);
419 }
420 }
421
OnReceiveEvent(const EventFwk::CommonEventData & eventData)422 void MedialibrarySubscriber::OnReceiveEvent(const EventFwk::CommonEventData &eventData)
423 {
424 const AAFwk::Want &want = eventData.GetWant();
425 std::string action = want.GetAction();
426 if (action != EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED &&
427 action != EventFwk::CommonEventSupport::COMMON_EVENT_TIME_TICK) {
428 MEDIA_INFO_LOG("OnReceiveEvent action:%{public}s.", action.c_str());
429 }
430 if (action == EventFwk::CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE) {
431 isWifiConnected_ = eventData.GetCode() == WIFI_STATE_CONNECTED;
432 UpdateBackgroundTimer();
433 if (isWifiConnected_) {
434 CloudMediaAssetManager::GetInstance().RecoverDownloadCloudAsset(CloudMediaTaskRecoverCause::NETWORK_NORMAL);
435 }
436 } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE) {
437 int netType = want.GetIntParam("NetType", -1);
438 bool isNetConnected = eventData.GetCode() == NET_CONN_STATE_CONNECTED;
439 MEDIA_INFO_LOG("netType: %{public}d, isConnected: %{public}d.", netType, static_cast<int32_t>(isNetConnected));
440 isCellularNetConnected_ = netType == BEARER_CELLULAR ? isNetConnected : isCellularNetConnected_;
441 UpdateCloudMediaAssetDownloadTaskStatus();
442 } else if (BACKGROUND_OPERATION_STATUS_MAP.count(action) != 0) {
443 UpdateBackgroundOperationStatus(want, BACKGROUND_OPERATION_STATUS_MAP.at(action));
444 UpdateCloudMediaAssetDownloadStatus(want, BACKGROUND_OPERATION_STATUS_MAP.at(action));
445 } else if (action.compare(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED) == 0) {
446 string packageName = want.GetElement().GetBundleName();
447 RevertPendingByPackage(packageName);
448 MediaLibraryBundleManager::GetInstance()->Clear();
449 PermissionUtils::ClearBundleInfoInCache();
450 } else if (action == EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT) {
451 // when turn off gallery switch or quit account, clear the download lastest finished flag,
452 // so we can download lastest images for the subsequent login new account
453 BackgroundCloudFileProcessor::SetDownloadLatestFinished(false);
454 }
455
456 #ifdef MEDIALIBRARY_FEATURE_CLOUD_ENHANCEMENT
457 if (action == EventFwk::CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE ||
458 action == EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE) {
459 EnhancementManager::GetInstance().HandleNetChange(isWifiConnected_, isCellularNetConnected_);
460 }
461 #endif
462 }
463
GetNowTime()464 int64_t MedialibrarySubscriber::GetNowTime()
465 {
466 struct timespec t;
467 constexpr int64_t SEC_TO_MSEC = 1e3;
468 constexpr int64_t MSEC_TO_NSEC = 1e6;
469 clock_gettime(CLOCK_REALTIME, &t);
470 return t.tv_sec * SEC_TO_MSEC + t.tv_nsec / MSEC_TO_NSEC;
471 }
472
Init()473 void MedialibrarySubscriber::Init()
474 {
475 lockTime_ = GetNowTime();
476 agingCount_ = 0;
477 }
478
DeleteTemporaryPhotos()479 void DeleteTemporaryPhotos()
480 {
481 auto dataManager = MediaLibraryDataManager::GetInstance();
482 if (dataManager == nullptr) {
483 return;
484 }
485
486 string UriString = PAH_DISCARD_CAMERA_PHOTO;
487 MediaFileUtils::UriAppendKeyValue(UriString, URI_PARAM_API_VERSION, to_string(MEDIA_API_VERSION_V10));
488 Uri uri(UriString);
489 MediaLibraryCommand cmd(uri);
490 DataShare::DataShareValuesBucket valuesBucket;
491 valuesBucket.Put(PhotoColumn::PHOTO_IS_TEMP, true);
492 DataShare::DataSharePredicates predicates;
493
494 // 24H之前的数据
495 int64_t current = MediaFileUtils::UTCTimeMilliSeconds();
496 int64_t timeBefore24Hours = current - 24 * 60 * 60 * 1000;
497 string where = PhotoColumn::PHOTO_IS_TEMP + " = 1 AND (" + PhotoColumn::MEDIA_DATE_ADDED + " <= " +
498 to_string(timeBefore24Hours) + " OR " + MediaColumn::MEDIA_ID + " NOT IN (SELECT " + MediaColumn::MEDIA_ID +
499 " FROM (SELECT " + MediaColumn::MEDIA_ID + " FROM " + PhotoColumn::PHOTOS_TABLE + " WHERE " +
500 PhotoColumn::PHOTO_IS_TEMP + " = 1 " + "ORDER BY " + MediaColumn::MEDIA_ID +
501 " DESC LIMIT 50)) AND (select COUNT(1) from " + PhotoColumn::PHOTOS_TABLE +
502 " where " + PhotoColumn::PHOTO_IS_TEMP + " = 1) > 100) ";
503 predicates.SetWhereClause(where);
504
505 auto changedRows = dataManager->Update(cmd, valuesBucket, predicates);
506 CHECK_AND_RETURN_LOG(changedRows >= 0, "Failed to update property of asset, err: %{public}d", changedRows);
507 MEDIA_INFO_LOG("delete %{public}d temp files exceeding 24 hous or exceed maximum quantity.", changedRows);
508 }
509
DoAgingOperation()510 void MedialibrarySubscriber::DoAgingOperation()
511 {
512 auto dataManager = MediaLibraryDataManager::GetInstance();
513 CHECK_AND_RETURN_LOG(dataManager != nullptr, "dataManager is nullptr");
514
515 int32_t result = dataManager->DoAging();
516 CHECK_AND_PRINT_LOG(result == E_OK, "DoAging faild");
517
518 shared_ptr<int> trashCountPtr = make_shared<int>();
519 result = dataManager->DoTrashAging(trashCountPtr);
520 CHECK_AND_PRINT_LOG(result == E_OK, "DoTrashAging faild");
521
522 VariantMap map = {{KEY_COUNT, *trashCountPtr}};
523 PostEventUtils::GetInstance().PostStatProcess(StatType::AGING_STAT, map);
524 }
525
QueryBurstNeedUpdate(AsyncTaskData * data)526 static void QueryBurstNeedUpdate(AsyncTaskData *data)
527 {
528 auto dataManager = MediaLibraryDataManager::GetInstance();
529 CHECK_AND_RETURN_LOG(dataManager != nullptr, "dataManager is nullptr");
530
531 int32_t result = dataManager->UpdateBurstFromGallery();
532 CHECK_AND_PRINT_LOG(result == E_OK, "UpdateBurstFromGallery faild");
533 }
534
DoUpdateBurstFromGallery()535 static int32_t DoUpdateBurstFromGallery()
536 {
537 MEDIA_INFO_LOG("Begin DoUpdateBurstFromGallery");
538 auto asyncWorker = MediaLibraryAsyncWorker::GetInstance();
539 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_FAIL, "Failed to get async worker instance!");
540
541 shared_ptr<MediaLibraryAsyncTask> updateBurstTask =
542 make_shared<MediaLibraryAsyncTask>(QueryBurstNeedUpdate, nullptr);
543 CHECK_AND_RETURN_RET_LOG(updateBurstTask != nullptr, E_FAIL,
544 "Failed to create async task for updateBurstTask!");
545 asyncWorker->AddTask(updateBurstTask, false);
546 return E_SUCCESS;
547 }
548
UpdateDirtyForCloudClone(AsyncTaskData * data)549 static void UpdateDirtyForCloudClone(AsyncTaskData *data)
550 {
551 auto dataManager = MediaLibraryDataManager::GetInstance();
552 CHECK_AND_RETURN_LOG(dataManager != nullptr, "Failed to MediaLibraryDataManager instance!");
553
554 int32_t result = dataManager->UpdateDirtyForCloudClone();
555 CHECK_AND_PRINT_LOG(result == E_OK, "UpdateDirtyForCloudClone faild, result = %{public}d", result);
556 }
557
ClearDirtyHdcData(AsyncTaskData * data)558 static void ClearDirtyHdcData(AsyncTaskData *data)
559 {
560 auto dataManager = MediaLibraryDataManager::GetInstance();
561 CHECK_AND_RETURN_LOG(dataManager != nullptr, "Failed to MediaLibraryDataManager instance!");
562
563 int32_t result = dataManager->ClearDirtyHdcData();
564 CHECK_AND_PRINT_LOG(result == E_OK, "ClearDirtyHdcData faild, result = %{public}d", result);
565 }
566
567
DoUpdateDirtyForCloudClone()568 static int32_t DoUpdateDirtyForCloudClone()
569 {
570 auto asyncWorker = MediaLibraryAsyncWorker::GetInstance();
571 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_FAIL,
572 "Failed to get async worker instance!");
573 shared_ptr<MediaLibraryAsyncTask> updateDirtyForCloudTask =
574 make_shared<MediaLibraryAsyncTask>(UpdateDirtyForCloudClone, nullptr);
575 CHECK_AND_RETURN_RET_LOG(updateDirtyForCloudTask != nullptr, E_FAIL,
576 "Failed to create async task for updateDirtyForCloudTask !");
577 asyncWorker->AddTask(updateDirtyForCloudTask, false);
578 return E_SUCCESS;
579 }
580
DoClearDirtyHdcData()581 static int32_t DoClearDirtyHdcData()
582 {
583 auto asyncWorker = MediaLibraryAsyncWorker::GetInstance();
584 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_FAIL,
585 "Failed to get async worker instance!");
586 shared_ptr<MediaLibraryAsyncTask> clearDirtyHdcDataTask =
587 make_shared<MediaLibraryAsyncTask>(ClearDirtyHdcData, nullptr);
588 CHECK_AND_RETURN_RET_LOG(clearDirtyHdcDataTask != nullptr, E_FAIL,
589 "Failed to create async task for clearDirtyHdcDataTask !");
590 asyncWorker->AddTask(clearDirtyHdcDataTask, false);
591 return E_SUCCESS;
592 }
593
RecoverBackgroundDownloadCloudMediaAsset()594 static void RecoverBackgroundDownloadCloudMediaAsset()
595 {
596 if (!CloudMediaAssetManager::GetInstance().SetBgDownloadPermission(true)) {
597 return;
598 }
599 int32_t ret = CloudMediaAssetManager::GetInstance().RecoverDownloadCloudAsset(
600 CloudMediaTaskRecoverCause::BACKGROUND_TASK_AVAILABLE);
601 CHECK_AND_PRINT_LOG(ret == E_OK, "RecoverDownloadCloudAsset faild");
602 }
603
UpdateDateTakenWhenZero(AsyncTaskData * data)604 static void UpdateDateTakenWhenZero(AsyncTaskData *data)
605 {
606 auto dataManager = MediaLibraryDataManager::GetInstance();
607 CHECK_AND_RETURN_LOG(dataManager != nullptr, "Failed to MediaLibraryDataManager instance!");
608
609 int32_t result = dataManager->UpdateDateTakenWhenZero();
610 CHECK_AND_PRINT_LOG(result == E_OK, "UpdateDateTakenWhenZero faild, result = %{public}d", result);
611 }
612
DoUpdateDateTakenWhenZero()613 static int32_t DoUpdateDateTakenWhenZero()
614 {
615 MEDIA_DEBUG_LOG("Begin DoUpdateDateTakenWhenZero");
616 auto asyncWorker = MediaLibraryAsyncWorker::GetInstance();
617 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_FAIL,
618 "Failed to get async worker instance!");
619
620 shared_ptr<MediaLibraryAsyncTask> UpdateDateTakenWhenZeroTask =
621 make_shared<MediaLibraryAsyncTask>(UpdateDateTakenWhenZero, nullptr);
622 CHECK_AND_RETURN_RET_LOG(UpdateDateTakenWhenZeroTask != nullptr, E_FAIL,
623 "Failed to create async task for UpdateDateTakenWhenZeroTask !");
624 asyncWorker->AddTask(UpdateDateTakenWhenZeroTask, false);
625 return E_SUCCESS;
626 }
627
UpdateBurstCoverLevelFromGallery(AsyncTaskData * data)628 static void UpdateBurstCoverLevelFromGallery(AsyncTaskData *data)
629 {
630 auto dataManager = MediaLibraryDataManager::GetInstance();
631 CHECK_AND_RETURN_LOG(dataManager != nullptr, "dataManager is nullptr");
632
633 int32_t result = dataManager->UpdateBurstCoverLevelFromGallery();
634 CHECK_AND_PRINT_LOG(result == E_OK, "UpdateBurstCoverLevelFromGallery faild");
635 }
636
DoUpdateBurstCoverLevelFromGallery()637 static int32_t DoUpdateBurstCoverLevelFromGallery()
638 {
639 MEDIA_INFO_LOG("Begin DoUpdateBurstCoverLevelFromGallery");
640 auto asyncWorker = MediaLibraryAsyncWorker::GetInstance();
641 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_FAIL,
642 "Failed to get async worker instance!");
643
644 shared_ptr<MediaLibraryAsyncTask> updateBurstCoverLevelTask =
645 make_shared<MediaLibraryAsyncTask>(UpdateBurstCoverLevelFromGallery, nullptr);
646 CHECK_AND_RETURN_RET_LOG(updateBurstCoverLevelTask != nullptr, E_FAIL,
647 "Failed to create async task for updateBurstCoverLevelTask!");
648 asyncWorker->AddTask(updateBurstCoverLevelTask, false);
649 return E_SUCCESS;
650 }
651
UpdateDirtyForBeta(const shared_ptr<NativePreferences::Preferences> & prefs)652 static void UpdateDirtyForBeta(const shared_ptr<NativePreferences::Preferences>& prefs)
653 {
654 if (IsBetaVersion() && prefs != nullptr && (prefs->GetInt(NO_UPDATE_DIRTY, 0) != 1)) {
655 int32_t ret = DoUpdateDirtyForCloudClone();
656 CHECK_AND_PRINT_LOG(ret == E_OK, "DoUpdateDirtyForCloudClone failed");
657 }
658 return;
659 }
660
ClearDirtyHdcData(const shared_ptr<NativePreferences::Preferences> & prefs)661 static void ClearDirtyHdcData(const shared_ptr<NativePreferences::Preferences>& prefs)
662 {
663 if (prefs != nullptr && (prefs->GetInt(NO_DELETE_DIRTY_HDC_DATA, 0) != 1)) {
664 int32_t ret = DoClearDirtyHdcData();
665 CHECK_AND_PRINT_LOG(ret == E_OK, "DoUpdateDirtyForCloudClone failed");
666 }
667 return;
668 }
669
ClearDirtyData()670 static void ClearDirtyData()
671 {
672 int32_t errCode;
673 shared_ptr<NativePreferences::Preferences> prefs =
674 NativePreferences::PreferencesHelper::GetPreferences(TASK_PROGRESS_XML, errCode);
675 CHECK_AND_RETURN_LOG(prefs, "Get preferences error: %{public}d", errCode);
676 UpdateDirtyForBeta(prefs);
677 ClearDirtyHdcData(prefs);
678 return;
679 }
680
DoBackgroundOperation()681 void MedialibrarySubscriber::DoBackgroundOperation()
682 {
683 bool cond = (!backgroundDelayTask_.IsDelayTaskTimeOut() || !currentStatus_);
684 CHECK_AND_RETURN_LOG(!cond, "The conditions for DoBackgroundOperation are not met, will return.");
685 #ifdef META_RECOVERY_SUPPORT
686 // check metadata recovery state
687 MediaLibraryMetaRecovery::GetInstance().CheckRecoveryState();
688 #endif
689 // delete temporary photos
690 DeleteTemporaryPhotos();
691 // clear dirty data
692 ClearDirtyData();
693 BackgroundTaskMgr::EfficiencyResourceInfo resourceInfo = BackgroundTaskMgr::EfficiencyResourceInfo(
694 BackgroundTaskMgr::ResourceType::CPU, true, 0, "apply", true, true);
695 BackgroundTaskMgr::BackgroundTaskMgrHelper::ApplyEfficiencyResources(resourceInfo);
696 Init();
697 DoAgingOperation();
698 MediaLibraryRdbUtils::AnalyzePhotosData();
699 // update burst from gallery
700 int32_t ret = DoUpdateBurstFromGallery();
701 CHECK_AND_PRINT_LOG(ret == E_OK, "DoUpdateBurstFromGallery faild");
702 CloudUploadChecker::RepairNoOriginPhoto();
703
704 CloudUploadChecker::RepairNoDetailTime();
705 #ifdef MEDIALIBRARY_FEATURE_CLOUD_ENHANCEMENT
706 // add permission for cloud enhancement photo
707 CloudEnhancementChecker::AddPermissionForCloudEnhancement();
708 #endif
709 // migration highlight info to new path
710 if (MediaFileUtils::IsFileExists(ROOT_MEDIA_DIR + HIGHLIGHT_INFO_OLD)) {
711 MEDIA_INFO_LOG("Migration highlight info to new path");
712 bool retMigration = MediaFileUtils::CopyDirAndDelSrc(ROOT_MEDIA_DIR + HIGHLIGHT_INFO_OLD,
713 ROOT_MEDIA_DIR + HIGHLIGHT_INFO_NEW);
714 if (retMigration) {
715 bool retDelete = MediaFileUtils::DeleteDir(ROOT_MEDIA_DIR + HIGHLIGHT_INFO_OLD);
716 if (!retDelete) {
717 MEDIA_ERR_LOG("Delete old highlight path fail");
718 }
719 }
720 }
721 ret = DoUpdateDateTakenWhenZero();
722 if (ret != E_OK) {
723 MEDIA_ERR_LOG("DoUpdateDateTakenWhenZero faild");
724 }
725 ret = DoUpdateBurstCoverLevelFromGallery();
726 CHECK_AND_PRINT_LOG(ret == E_OK, "DoUpdateBurstCoverLevelFromGallery faild");
727 CloudMediaAssetManager::GetInstance().StartDeleteCloudMediaAssets();
728 // compat old-version moving photo
729 MovingPhotoProcessor::StartProcess();
730 MediaLibraryAlbumFusionUtils::CleanInvalidCloudAlbumAndData();
731 auto watch = MediaLibraryInotify::GetInstance();
732 if (watch != nullptr) {
733 watch->DoAging();
734 }
735 PhotoMimetypeOperation::UpdateInvalidMimeType();
736 }
737
PauseBackgroundDownloadCloudMedia()738 static void PauseBackgroundDownloadCloudMedia()
739 {
740 if (!CloudMediaAssetManager::GetInstance().SetBgDownloadPermission(false)) {
741 return;
742 }
743 int32_t taskStatus = static_cast<int32_t>(CloudMediaAssetTaskStatus::DOWNLOADING);
744 int32_t downloadType = static_cast<int32_t>(CloudMediaDownloadType::DOWNLOAD_GENTLE);
745 if (CloudMediaAssetManager::GetInstance().GetTaskStatus() == taskStatus &&
746 CloudMediaAssetManager::GetInstance().GetDownloadType() == downloadType) {
747 CloudMediaAssetManager::GetInstance().PauseDownloadCloudAsset(
748 CloudMediaTaskPauseCause::BACKGROUND_TASK_UNAVAILABLE);
749 }
750 }
751
StopBackgroundOperation()752 void MedialibrarySubscriber::StopBackgroundOperation()
753 {
754 #ifdef META_RECOVERY_SUPPORT
755 MediaLibraryMetaRecovery::GetInstance().InterruptRecovery();
756 #endif
757 MovingPhotoProcessor::StopProcess();
758 MediaLibraryDataManager::GetInstance()->InterruptBgworker();
759 PauseBackgroundDownloadCloudMedia();
760 PhotoAlbumLPathOperation::GetInstance().Stop();
761 PhotoOtherAlbumTransOperation::GetInstance().Stop();
762 CloudMediaAssetManager::GetInstance().StopDeleteCloudMediaAssets();
763 }
764
UpdateThumbnailBgGenerationStatus()765 void MedialibrarySubscriber::UpdateThumbnailBgGenerationStatus()
766 {
767 std::lock_guard<std::mutex> lock(mutex_);
768 bool isPowerSufficientForThumbnail = batteryCapacity_ >= PROPER_DEVICE_BATTERY_CAPACITY_THUMBNAIL;
769 bool newStatus = false;
770 if (isCharging_) {
771 newStatus = isScreenOff_ && isPowerSufficientForThumbnail &&
772 newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_43;
773 } else if (isScreenOff_ && newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_37 &&
774 batteryCapacity_ >= PROPER_DEVICE_BATTERY_CAPACITY) {
775 int32_t thumbAstcCount = 0;
776 int32_t thumbTotalCount = 0;
777 MedialibrarySubscriberDatabaseUtils::QueryThumbAstc(thumbAstcCount);
778 MedialibrarySubscriberDatabaseUtils::QueryThumbTotal(thumbTotalCount);
779 bool isThumbAstcEnough = thumbAstcCount > THUMB_ASTC_ENOUGH || thumbAstcCount == thumbTotalCount;
780 newStatus = !isThumbAstcEnough;
781 CHECK_AND_PRINT_LOG(isThumbAstcEnough,
782 "ThumbnailBg generate status: isThumbAstcEnough:%{public}d,"
783 " thumbAstcCount:%{public}d, thumbTotalCount:%{public}d",
784 isThumbAstcEnough, thumbAstcCount, thumbTotalCount);
785 }
786
787 if (thumbnailBgGenerationStatus_ == newStatus) {
788 return;
789 }
790 MEDIA_INFO_LOG("update status thumbnailBg:%{public}d, new:%{public}d, "
791 "%{public}d, %{public}d, %{public}d, %{public}d",
792 thumbnailBgGenerationStatus_, newStatus, isScreenOff_,
793 isCharging_, batteryCapacity_, newTemperatureLevel_);
794 thumbnailBgGenerationStatus_ = newStatus;
795
796 thumbnailBgDelayTask_.EndBackgroundOperationThread();
797 if (thumbnailBgGenerationStatus_) {
798 thumbnailBgDelayTask_.SetOperationThread([this] { this->DoThumbnailBgOperation(); });
799 } else {
800 MediaLibraryAstcStat::GetInstance().GetInterruptInfo(isScreenOff_, isCharging_,
801 isPowerSufficientForThumbnail,
802 newTemperatureLevel_ <= PROPER_DEVICE_TEMPERATURE_LEVEL_40);
803 StopThumbnailBgOperation();
804 }
805 }
806
DoThumbnailBgOperation()807 void MedialibrarySubscriber::DoThumbnailBgOperation()
808 {
809 bool cond = (!thumbnailBgDelayTask_.IsDelayTaskTimeOut() || !thumbnailBgGenerationStatus_);
810 CHECK_AND_RETURN_LOG(!cond, "The conditions for DoThumbnailBgOperation are not met, will return.");
811
812 auto dataManager = MediaLibraryDataManager::GetInstance();
813 CHECK_AND_RETURN_LOG(dataManager != nullptr, "dataManager is nullptr");
814
815 auto result = dataManager->GenerateThumbnailBackground();
816 CHECK_AND_PRINT_LOG(result == E_OK, "GenerateThumbnailBackground faild");
817
818 result = dataManager->UpgradeThumbnailBackground(isWifiConnected_);
819 CHECK_AND_PRINT_LOG(result == E_OK, "UpgradeThumbnailBackground faild");
820
821 result = dataManager->GenerateHighlightThumbnailBackground();
822 CHECK_AND_PRINT_LOG(result == E_OK, "GenerateHighlightThumbnailBackground failed %{public}d", result);
823 }
824
StopThumbnailBgOperation()825 void MedialibrarySubscriber::StopThumbnailBgOperation()
826 {
827 MediaLibraryDataManager::GetInstance()->InterruptThumbnailBgWorker();
828 }
829
830 #ifdef MEDIALIBRARY_MTP_ENABLE
DoStartMtpService()831 void MedialibrarySubscriber::DoStartMtpService()
832 {
833 AAFwk::Want want;
834 want.SetElementName("com.ohos.medialibrary.medialibrarydata", "MtpService");
835 auto abilityContext = AbilityRuntime::Context::GetApplicationContext();
836 ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, abilityContext->GetToken(),
837 OHOS::AAFwk::DEFAULT_INVAL_VALUE);
838 MEDIA_INFO_LOG("MedialibrarySubscriber::DoStartMtpService. End calling StartAbility. ret=%{public}d", err);
839 }
840 #endif
841
RevertPendingByPackage(const std::string & bundleName)842 void MedialibrarySubscriber::RevertPendingByPackage(const std::string &bundleName)
843 {
844 MediaLibraryDataManager::GetInstance()->RevertPendingByPackage(bundleName);
845 }
846
UpdateBackgroundTimer()847 void MedialibrarySubscriber::UpdateBackgroundTimer()
848 {
849 std::lock_guard<std::mutex> lock(mutex_);
850 bool isPowerSufficient = batteryCapacity_ >= PROPER_DEVICE_BATTERY_CAPACITY;
851 bool newStatus = isScreenOff_ && isCharging_ && isPowerSufficient &&
852 isDeviceTemperatureProper_ && isWifiConnected_;
853 if (timerStatus_ == newStatus) {
854 return;
855 }
856
857 MEDIA_INFO_LOG("update timer status current:%{public}d, new:%{public}d, %{public}d, %{public}d, %{public}d, "
858 "%{public}d, %{public}d",
859 timerStatus_, newStatus, isScreenOff_, isCharging_, isPowerSufficient, isDeviceTemperatureProper_,
860 isWifiConnected_);
861
862 timerStatus_ = newStatus;
863 if (timerStatus_) {
864 BackgroundCloudFileProcessor::StartTimer();
865 } else {
866 BackgroundCloudFileProcessor::StopTimer();
867 }
868 }
869
DealWithEventsAfterUpdateStatus(const StatusEventType statusEventType)870 void MedialibrarySubscriber::DealWithEventsAfterUpdateStatus(const StatusEventType statusEventType)
871 {
872 std::lock_guard<std::mutex> lock(mutex_);
873 if (deviceTemperatureLevel_ != newTemperatureLevel_) {
874 deviceTemperatureLevel_ = newTemperatureLevel_;
875 ThumbnailService::GetInstance()->NotifyTempStatusForReady(deviceTemperatureLevel_);
876 }
877
878 CloudSyncDfxManager::GetInstance().RunDfx();
879 ThumbnailService::GetInstance()->UpdateCurrentStatusForTask(thumbnailBgGenerationStatus_);
880 ThumbnailGenerateWorkerManager::GetInstance().TryCloseThumbnailWorkerTimer();
881 PowerEfficiencyManager::SetSubscriberStatus(isCharging_, isScreenOff_);
882
883 if (statusEventType == StatusEventType::SCREEN_OFF || statusEventType == StatusEventType::CHARGING) {
884 WalCheckPointAsync();
885 CheckHalfDayMissions();
886 return;
887 }
888
889 if (statusEventType == StatusEventType::SCREEN_ON || statusEventType == StatusEventType::DISCHARGING) {
890 CheckHalfDayMissions();
891 return;
892 }
893
894 if (statusEventType == StatusEventType::THERMAL_LEVEL_CHANGED) {
895 MEDIA_INFO_LOG("Current temperature level is %{public}d", newTemperatureLevel_);
896 PowerEfficiencyManager::UpdateAlbumUpdateInterval(isDeviceTemperatureProper_);
897 }
898 }
899
IsDelayTaskTimeOut()900 bool MedialibrarySubscriber::DelayTask::IsDelayTaskTimeOut()
901 {
902 std::unique_lock<std::mutex> lock(this->lock);
903 return !cv.wait_for(lock, std::chrono::milliseconds(DELAY_TASK_TIME), [this]() {
904 return !isTaskWaiting;
905 });
906 }
907
EndBackgroundOperationThread()908 void MedialibrarySubscriber::DelayTask::EndBackgroundOperationThread()
909 {
910 {
911 std::unique_lock<std::mutex> lock(this->lock);
912 isTaskWaiting = false;
913 MEDIA_INFO_LOG("DelayTask %{public}s EndBackgroundOperationThread", taskName.c_str());
914 }
915 #ifdef META_RECOVERY_SUPPORT
916 MediaLibraryMetaRecovery::GetInstance().InterruptRecovery();
917 #endif
918 cv.notify_all();
919 if (!operationThread.joinable()) {
920 return;
921 }
922 operationThread.join();
923 }
924
SetOperationThread(std::function<void ()> operationTask)925 void MedialibrarySubscriber::DelayTask::SetOperationThread(std::function<void()> operationTask)
926 {
927 if (operationThread.joinable()) {
928 operationThread.join();
929 }
930 {
931 std::unique_lock<std::mutex> lock(this->lock);
932 isTaskWaiting = true;
933 }
934 this->operationThread = std::thread(operationTask);
935 }
936
QueryThumbAstc(int32_t & thumbAstcCount)937 int32_t MedialibrarySubscriberDatabaseUtils::QueryThumbAstc(int32_t& thumbAstcCount)
938 {
939 std::vector<std::string> columns = { "count(1) AS count" };
940 std::string queryColumn = "count";
941 NativeRdb::RdbPredicates astcPredicates(PhotoColumn::PHOTOS_TABLE);
942 astcPredicates.GreaterThanOrEqualTo(PhotoColumn::PHOTO_THUMBNAIL_READY,
943 static_cast<int32_t>(ThumbnailReady::GENERATE_THUMB_RETRY));
944 int32_t errCode = QueryInt(astcPredicates, columns, queryColumn, thumbAstcCount);
945 CHECK_AND_RETURN_RET_LOG(errCode == E_OK, errCode, "Query thumbAstcCount fail: %{public}d", errCode);
946 return E_OK;
947 }
948
QueryThumbTotal(int32_t & thumbTotalCount)949 int32_t MedialibrarySubscriberDatabaseUtils::QueryThumbTotal(int32_t& thumbTotalCount)
950 {
951 std::vector<std::string> columns = { "count(1) AS count" };
952 std::string queryColumn = "count";
953 NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
954 int32_t errCode = QueryInt(predicates, columns, queryColumn, thumbTotalCount);
955 CHECK_AND_RETURN_RET_LOG(errCode == E_OK, errCode, "Query thumbTotalCount fail: %{public}d", errCode);
956 return E_OK;
957 }
958
QueryInt(const NativeRdb::AbsRdbPredicates & predicates,const std::vector<std::string> & columns,const std::string & queryColumn,int32_t & value)959 int32_t MedialibrarySubscriberDatabaseUtils::QueryInt(const NativeRdb::AbsRdbPredicates &predicates,
960 const std::vector<std::string> &columns, const std::string &queryColumn, int32_t &value)
961 {
962 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
963 bool cond = (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK);
964 CHECK_AND_RETURN_RET(!cond, E_DB_FAIL);
965 value = GetInt32Val(queryColumn, resultSet);
966 return E_OK;
967 }
968 } // namespace Media
969 } // namespace OHOS
970