1 /*
2 * Copyright (C) 2023 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 #include "photo_album_column.h"
17
18 #include <string>
19 #include "location_column.h"
20 #include "media_column.h"
21 #include "media_log.h"
22 #include "medialibrary_type_const.h"
23 #include "photo_map_column.h"
24 #include "vision_column.h"
25 #include "vision_face_tag_column.h"
26
27 namespace OHOS::Media {
28 using namespace std;
29 using namespace NativeRdb;
30
31 // PhotoAlbum table
32 const string PhotoAlbumColumns::TABLE = "PhotoAlbum";
33 const string PhotoAlbumColumns::ALBUM_ID = "album_id";
34 const string PhotoAlbumColumns::ALBUM_TYPE = "album_type";
35 const string PhotoAlbumColumns::ALBUM_SUBTYPE = "album_subtype";
36 const string PhotoAlbumColumns::ALBUM_NAME = "album_name";
37 const string PhotoAlbumColumns::ALBUM_COVER_URI = "cover_uri";
38 const string PhotoAlbumColumns::ALBUM_COUNT = "count";
39 const string PhotoAlbumColumns::ALBUM_DATE_MODIFIED = "date_modified";
40 const string PhotoAlbumColumns::ALBUM_DIRTY = "dirty";
41 const string PhotoAlbumColumns::ALBUM_CLOUD_ID = "cloud_id";
42 const string PhotoAlbumColumns::ALBUM_IMAGE_COUNT = "image_count";
43 const string PhotoAlbumColumns::ALBUM_VIDEO_COUNT = "video_count";
44 const string PhotoAlbumColumns::ALBUM_LATITUDE = "latitude";
45 const string PhotoAlbumColumns::ALBUM_LONGITUDE = "longitude";
46 const string PhotoAlbumColumns::ALBUM_BUNDLE_NAME = "bundle_name";
47 const string PhotoAlbumColumns::ALBUM_LOCAL_LANGUAGE = "local_language";
48 const string PhotoAlbumColumns::ALBUM_IS_LOCAL = "is_local";
49 const string PhotoAlbumColumns::ALBUM_DATE_ADDED = "date_added";
50 const string PhotoAlbumColumns::ALBUM_PRIORITY = "priority";
51 const string PhotoAlbumColumns::ALBUM_LPATH = "lpath";
52 const string PhotoAlbumColumns::ALBUM_CHECK_FLAG = "check_flag";
53
54 // For api9 compatibility
55 const string PhotoAlbumColumns::ALBUM_RELATIVE_PATH = "relative_path";
56
57 const string PhotoAlbumColumns::CONTAINS_HIDDEN = "contains_hidden";
58 const string PhotoAlbumColumns::HIDDEN_COUNT = "hidden_count";
59 const string PhotoAlbumColumns::HIDDEN_COVER = "hidden_cover";
60
61 // For sorting albums
62 const string PhotoAlbumColumns::ALBUM_ORDER = "album_order";
63 const string PhotoAlbumColumns::REFERENCE_ALBUM_ID = "reference_album_id";
64
65 // location album result
66 const std::string LOCATION_ALBUM_ID = MediaColumn::MEDIA_ID + " AS " + ALBUM_ID;
67 const std::string LOCATION_ALBUM_TYPE = std::to_string(PhotoAlbumType::SMART) + " AS " + ALBUM_TYPE;
68 const std::string LOCATION_ALBUM_SUBTYPE = std::to_string(PhotoAlbumSubType::GEOGRAPHY_LOCATION) +
69 " AS " + ALBUM_SUBTYPE;
70 const std::string LOCATION_COUNT = "COUNT(*) AS " + COUNT;
71 const std::string LOCATION_DATE_MODIFIED = "MAX(" + MediaColumn::MEDIA_DATE_ADDED + ") AS " + DATE_MODIFIED;
72 const std::string CITY_ALBUM_NAME = CITY_NAME + " AS " + ALBUM_NAME;
73 const std::string LOCATION_COVER_URI =
74 " (SELECT '" + PhotoColumn::PHOTO_URI_PREFIX + "'||" + MediaColumn::MEDIA_ID + "||" +
75 "(SELECT SUBSTR(" + MediaColumn::MEDIA_FILE_PATH +
76 ", (SELECT LENGTH(" + MediaColumn::MEDIA_FILE_PATH +
77 ") - INSTR(reverseStr, '/') + 1) , (SELECT (SELECT LENGTH(" +
78 MediaColumn::MEDIA_FILE_PATH + ") - INSTR(reverseStr, '.')) - (SELECT LENGTH(" +
79 MediaColumn::MEDIA_FILE_PATH + ") - INSTR(reverseStr, '/')))) from (select " +
80 " (WITH RECURSIVE reverse_string(str, revstr) AS ( SELECT " +
81 MediaColumn::MEDIA_FILE_PATH + ", '' UNION ALL SELECT SUBSTR(str, 1, LENGTH(str) - 1), " +
82 "revstr || SUBSTR(str, LENGTH(str), 1) FROM reverse_string WHERE LENGTH(str) > 1 ) " +
83 " SELECT revstr || str FROM reverse_string WHERE LENGTH(str) = 1) as reverseStr)) ||'/'||" +
84 MediaColumn::MEDIA_NAME + ") AS " + COVER_URI;
85
86 // default fetch columns
87 const set<string> PhotoAlbumColumns::DEFAULT_FETCH_COLUMNS = {
88 ALBUM_ID, ALBUM_TYPE, ALBUM_SUBTYPE, ALBUM_NAME, ALBUM_COVER_URI, ALBUM_COUNT, ALBUM_DATE_MODIFIED
89 };
90
91 // location default fetch columns
92 const vector<string> PhotoAlbumColumns::LOCATION_DEFAULT_FETCH_COLUMNS = {
93 LATITUDE, LONGITUDE, LOCATION_ALBUM_TYPE, LOCATION_ALBUM_SUBTYPE, LOCATION_COUNT,
94 LOCATION_DATE_MODIFIED, LOCATION_COVER_URI, LOCATION_ALBUM_ID
95 };
96
97 // city default fetch columns
98 const vector<string> PhotoAlbumColumns::CITY_DEFAULT_FETCH_COLUMNS = {
99 ALBUM_ID, ALBUM_TYPE, ALBUM_SUBTYPE, CITY_ALBUM_NAME, ALBUM_COVER_URI, ALBUM_COUNT, ALBUM_DATE_MODIFIED
100 };
101
102 const string PhotoAlbumColumns::ALBUM_URI_PREFIX = "file://media/PhotoAlbum/";
103 const string PhotoAlbumColumns::DEFAULT_PHOTO_ALBUM_URI = "file://media/PhotoAlbum";
104 const string PhotoAlbumColumns::HIDDEN_ALBUM_URI_PREFIX = "file://media/HiddenAlbum/";
105 const string PhotoAlbumColumns::DEFAULT_HIDDEN_ALBUM_URI = "file://media/HiddenAlbum";
106 const string PhotoAlbumColumns::ANALYSIS_ALBUM_URI_PREFIX = "file://media/AnalysisAlbum/";
107
108 const string PhotoAlbumColumns::ALBUM_CLOUD_URI_PREFIX = "file://cloudsync/PhotoAlbum/";
109
110 // Create tables
111 const string PhotoAlbumColumns::CREATE_TABLE = CreateTable() +
112 TABLE + " (" +
113 ALBUM_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
114 ALBUM_TYPE + " INT, " +
115 ALBUM_SUBTYPE + " INT, " +
116 ALBUM_NAME + " TEXT COLLATE NOCASE, " +
117 ALBUM_COVER_URI + " TEXT, " +
118 ALBUM_COUNT + " INT DEFAULT 0, " +
119 ALBUM_DATE_MODIFIED + " BIGINT DEFAULT 0, " +
120 ALBUM_DIRTY + " INT DEFAULT " + std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_NEW)) + ", " +
121 ALBUM_CLOUD_ID + " TEXT, " +
122 ALBUM_RELATIVE_PATH + " TEXT, " +
123 CONTAINS_HIDDEN + " INT DEFAULT 0, " +
124 HIDDEN_COUNT + " INT DEFAULT 0, " +
125 HIDDEN_COVER + " TEXT DEFAULT '', " +
126 ALBUM_ORDER + " INT," +
127 ALBUM_IMAGE_COUNT + " INT DEFAULT 0, " +
128 ALBUM_VIDEO_COUNT + " INT DEFAULT 0, " +
129 ALBUM_BUNDLE_NAME + " TEXT, " +
130 ALBUM_LOCAL_LANGUAGE + " TEXT, " +
131 ALBUM_IS_LOCAL + " INT, " +
132 ALBUM_DATE_ADDED + " BIGINT DEFAULT 0, " +
133 ALBUM_LPATH + " TEXT, " +
134 ALBUM_PRIORITY + " INT, " +
135 ALBUM_CHECK_FLAG + " INT DEFAULT 0)";
136
137 // Create indexes
138 const string PhotoAlbumColumns::INDEX_ALBUM_TYPES = CreateIndex() + "photo_album_types" + " ON " + TABLE +
139 " (" + ALBUM_TYPE + "," + ALBUM_SUBTYPE + ");";
140
141 // Create triggers
142 const std::string PhotoAlbumColumns::CREATE_ALBUM_INSERT_TRIGGER =
143 " CREATE TRIGGER IF NOT EXISTS album_insert_cloud_sync_trigger AFTER INSERT ON " + TABLE +
144 " BEGIN SELECT cloud_sync_func(); END;";
145
146 const std::string PhotoAlbumColumns::CREATE_ALBUM_DELETE_TRIGGER =
147 "CREATE TRIGGER IF NOT EXISTS album_delete_trigger AFTER UPDATE ON " + TABLE +
148 " FOR EACH ROW WHEN new." + ALBUM_DIRTY + " = " +
149 std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_DELETED)) +
150 " AND old." + ALBUM_DIRTY + " = " + std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_NEW)) +
151 " AND is_caller_self_func() = 'true' BEGIN DELETE FROM " + TABLE +
152 " WHERE " + ALBUM_ID + " = old." + ALBUM_ID + "; SELECT cloud_sync_func(); END;";
153
154 const std::string PhotoAlbumColumns::CREATE_ALBUM_MDIRTY_TRIGGER =
155 "CREATE TRIGGER IF NOT EXISTS album_modify_trigger AFTER UPDATE ON " + TABLE +
156 " FOR EACH ROW WHEN old." + ALBUM_DIRTY + " = " +
157 std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_SYNCED)) +
158 " AND old." + ALBUM_DIRTY + " = " + "new." + ALBUM_DIRTY +
159 " AND is_caller_self_func() = 'true'" +
160 " AND " + PhotoAlbumColumns::CheckUploadPhotoAlbumColumns() +
161 " BEGIN UPDATE " + TABLE + " SET dirty = " +
162 std::to_string(static_cast<int32_t>(DirtyTypes::TYPE_MDIRTY)) +
163 " WHERE " + ALBUM_ID + " = old." + ALBUM_ID + "; SELECT cloud_sync_func(); END;";
164
165
166 const std::string PhotoAlbumColumns::ALBUM_DELETE_ORDER_TRIGGER =
167 " CREATE TRIGGER IF NOT EXISTS update_order_trigger AFTER DELETE ON " + PhotoAlbumColumns::TABLE +
168 " FOR EACH ROW " +
169 " BEGIN " +
170 " UPDATE " + PhotoAlbumColumns::TABLE + " SET album_order = album_order - 1" +
171 " WHERE album_order > old.album_order; " +
172 " END";
173
174 const std::string PhotoAlbumColumns::ALBUM_INSERT_ORDER_TRIGGER =
175 " CREATE TRIGGER IF NOT EXISTS insert_order_trigger AFTER INSERT ON " + PhotoAlbumColumns::TABLE +
176 " BEGIN " +
177 " UPDATE " + PhotoAlbumColumns::TABLE + " SET album_order = (" +
178 " SELECT COALESCE(MAX(album_order), 0) + 1 FROM " + PhotoAlbumColumns::TABLE +
179 ") WHERE rowid = new.rowid;" +
180 " END";
181
IsPhotoAlbumColumn(const string & columnName)182 bool PhotoAlbumColumns::IsPhotoAlbumColumn(const string &columnName)
183 {
184 static const set<string> PHOTO_ALBUM_COLUMNS = {
185 PhotoAlbumColumns::ALBUM_ID, PhotoAlbumColumns::ALBUM_TYPE, PhotoAlbumColumns::ALBUM_SUBTYPE,
186 PhotoAlbumColumns::ALBUM_NAME, PhotoAlbumColumns::ALBUM_COVER_URI, PhotoAlbumColumns::ALBUM_COUNT,
187 PhotoAlbumColumns::ALBUM_RELATIVE_PATH, CONTAINS_HIDDEN, HIDDEN_COUNT, HIDDEN_COVER
188 };
189 return PHOTO_ALBUM_COLUMNS.find(columnName) != PHOTO_ALBUM_COLUMNS.end();
190 }
191
SetDefaultPredicatesCondition(RdbPredicates & predicates,const int32_t dateTrashed,const bool isHidden,const int32_t timePending,const bool isTemp)192 inline void SetDefaultPredicatesCondition(RdbPredicates &predicates, const int32_t dateTrashed,
193 const bool isHidden, const int32_t timePending, const bool isTemp)
194 {
195 predicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, to_string(dateTrashed));
196 predicates.EqualTo(MediaColumn::MEDIA_HIDDEN, to_string(isHidden));
197 predicates.EqualTo(MediaColumn::MEDIA_TIME_PENDING, to_string(timePending));
198 predicates.EqualTo(PhotoColumn::PHOTO_IS_TEMP, to_string(isTemp));
199 predicates.EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL,
200 to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)));
201 }
202
GetUserAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)203 void PhotoAlbumColumns::GetUserAlbumPredicates(const int32_t albumId, RdbPredicates &predicates, const bool hiddenState)
204 {
205 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
206 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
207 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
208 predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(albumId));
209 }
210
GetPortraitAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)211 void PhotoAlbumColumns::GetPortraitAlbumPredicates(const int32_t albumId, RdbPredicates &predicates,
212 const bool hiddenState)
213 {
214 string onClause = MediaColumn::MEDIA_ID + " = " + PhotoMap::ASSET_ID;
215 vector<string> clauses = { onClause };
216 predicates.InnerJoin(ANALYSIS_PHOTO_MAP_TABLE)->On(clauses);
217 onClause = ALBUM_ID + " = " + PhotoMap::ALBUM_ID;
218 clauses = { onClause };
219 predicates.InnerJoin(ANALYSIS_ALBUM_TABLE)->On(clauses);
220 string tempTable = "(SELECT " + GROUP_TAG + " FROM " + ANALYSIS_ALBUM_TABLE + " WHERE " + ALBUM_ID + " = " +
221 to_string(albumId) + ") ag";
222 onClause = "ag." + GROUP_TAG + " = " + ANALYSIS_ALBUM_TABLE + "." + GROUP_TAG;
223 clauses = { onClause };
224 predicates.InnerJoin(tempTable)->On(clauses);
225 SetDefaultPredicatesCondition(predicates, 0, 0, 0, false);
226 predicates.Distinct();
227 return;
228 }
229
GetAnalysisAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)230 void PhotoAlbumColumns::GetAnalysisAlbumPredicates(const int32_t albumId,
231 RdbPredicates &predicates, const bool hiddenState)
232 {
233 string onClause = MediaColumn::MEDIA_ID + " = " + PhotoMap::ASSET_ID;
234 predicates.InnerJoin(ANALYSIS_PHOTO_MAP_TABLE)->On({ onClause });
235 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
236 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
237 predicates.EqualTo(PhotoMap::ALBUM_ID, to_string(albumId));
238 }
239
GetFavoritePredicates(RdbPredicates & predicates,const bool hiddenState)240 static void GetFavoritePredicates(RdbPredicates &predicates, const bool hiddenState)
241 {
242 predicates.BeginWrap();
243 constexpr int32_t isFavorite = 1;
244 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
245 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
246 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
247 predicates.EqualTo(MediaColumn::MEDIA_IS_FAV, to_string(isFavorite));
248 predicates.EndWrap();
249 }
250
GetVideoPredicates(RdbPredicates & predicates,const bool hiddenState)251 static void GetVideoPredicates(RdbPredicates &predicates, const bool hiddenState)
252 {
253 predicates.BeginWrap();
254 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
255 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
256 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
257 predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_VIDEO));
258 predicates.EndWrap();
259 }
260
GetHiddenPredicates(RdbPredicates & predicates)261 static void GetHiddenPredicates(RdbPredicates &predicates)
262 {
263 predicates.BeginWrap();
264 constexpr int32_t isHidden = 1;
265 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
266 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
267 SetDefaultPredicatesCondition(predicates, 0, isHidden, 0, false);
268 predicates.EndWrap();
269 }
270
GetTrashPredicates(RdbPredicates & predicates)271 static void GetTrashPredicates(RdbPredicates &predicates)
272 {
273 predicates.BeginWrap();
274 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
275 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
276 predicates.GreaterThan(MediaColumn::MEDIA_DATE_TRASHED, to_string(0));
277 predicates.EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL,
278 to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)));
279 predicates.EndWrap();
280 }
281
GetScreenshotPredicates(RdbPredicates & predicates,const bool hiddenState)282 static void GetScreenshotPredicates(RdbPredicates &predicates, const bool hiddenState)
283 {
284 predicates.BeginWrap();
285 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
286 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
287 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
288 predicates.EqualTo(PhotoColumn::PHOTO_SUBTYPE, to_string(static_cast<int32_t>(PhotoSubType::SCREENSHOT)));
289 predicates.EndWrap();
290 }
291
GetCameraPredicates(RdbPredicates & predicates,const bool hiddenState)292 static void GetCameraPredicates(RdbPredicates &predicates, const bool hiddenState)
293 {
294 predicates.BeginWrap();
295 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
296 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
297 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
298 predicates.EqualTo(PhotoColumn::PHOTO_SUBTYPE, to_string(static_cast<int32_t>(PhotoSubType::CAMERA)));
299 predicates.EndWrap();
300 }
301
GetAllImagesPredicates(RdbPredicates & predicates,const bool hiddenState)302 static void GetAllImagesPredicates(RdbPredicates &predicates, const bool hiddenState)
303 {
304 predicates.BeginWrap();
305 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
306 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
307 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
308 predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_IMAGE));
309 predicates.EndWrap();
310 }
311
GetCloudEnhancementPredicates(RdbPredicates & predicates,const bool hiddenState)312 static void GetCloudEnhancementPredicates(RdbPredicates &predicates, const bool hiddenState)
313 {
314 predicates.BeginWrap();
315 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
316 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
317 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
318 predicates.EqualTo(PhotoColumn::PHOTO_STRONG_ASSOCIATION,
319 to_string(static_cast<int32_t>(StrongAssociationType::CLOUD_ENHANCEMENT)));
320 predicates.EqualTo(MediaColumn::MEDIA_TYPE, to_string(MEDIA_TYPE_IMAGE));
321 predicates.EndWrap();
322 }
323
GetSourceAlbumPredicates(const int32_t albumId,RdbPredicates & predicates,const bool hiddenState)324 void PhotoAlbumColumns::GetSourceAlbumPredicates(const int32_t albumId, RdbPredicates &predicates,
325 const bool hiddenState)
326 {
327 predicates.EqualTo(PhotoColumn::PHOTO_SYNC_STATUS, to_string(static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE)));
328 predicates.EqualTo(PhotoColumn::PHOTO_CLEAN_FLAG, to_string(static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN)));
329 SetDefaultPredicatesCondition(predicates, 0, hiddenState, 0, false);
330 predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(albumId));
331 }
332
GetSystemAlbumPredicates(const PhotoAlbumSubType subtype,RdbPredicates & predicates,const bool hiddenState)333 void PhotoAlbumColumns::GetSystemAlbumPredicates(const PhotoAlbumSubType subtype, RdbPredicates &predicates,
334 const bool hiddenState)
335 {
336 switch (subtype) {
337 case PhotoAlbumSubType::FAVORITE: {
338 return GetFavoritePredicates(predicates, hiddenState);
339 }
340 case PhotoAlbumSubType::VIDEO: {
341 return GetVideoPredicates(predicates, hiddenState);
342 }
343 case PhotoAlbumSubType::HIDDEN: {
344 return GetHiddenPredicates(predicates);
345 }
346 case PhotoAlbumSubType::TRASH: {
347 return GetTrashPredicates(predicates);
348 }
349 case PhotoAlbumSubType::SCREENSHOT: {
350 return GetScreenshotPredicates(predicates, hiddenState);
351 }
352 case PhotoAlbumSubType::CAMERA: {
353 return GetCameraPredicates(predicates, hiddenState);
354 }
355 case PhotoAlbumSubType::IMAGE: {
356 return GetAllImagesPredicates(predicates, hiddenState);
357 }
358 case PhotoAlbumSubType::CLOUD_ENHANCEMENT: {
359 return GetCloudEnhancementPredicates(predicates, hiddenState);
360 }
361 default: {
362 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(0));
363 MEDIA_ERR_LOG("Unsupported system album subtype: %{public}d", subtype);
364 return;
365 }
366 }
367 }
368
CheckUploadPhotoAlbumColumns()369 std::string PhotoAlbumColumns::CheckUploadPhotoAlbumColumns()
370 {
371 // Since date_modified has been checked in mdirty and fdirty, omit it here.
372 const std::vector<std::string> uploadPhotoAlbumColumns = {
373 ALBUM_NAME,
374 };
375
376 std::string result = "(";
377 size_t size = uploadPhotoAlbumColumns.size();
378 for (size_t i = 0; i < size; i++) {
379 std::string column = uploadPhotoAlbumColumns[i];
380 if (i != size - 1) {
381 result += "new." + column + " <> old." + column + " OR ";
382 } else {
383 result += "new." + column + " <> old." + column + ")";
384 }
385 }
386 return result;
387 }
388 } // namespace OHOS::Media
389