1 /*
2 * Copyright (C) 2021-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 #define MLOG_TAG "FetchResult"
16
17 #include "fetch_result.h"
18 #include "album_asset.h"
19 #include "media_file_uri.h"
20 #include "media_log.h"
21 #include "media_file_utils.h"
22 #include "media_smart_album_column.h"
23 #include "medialibrary_tracer.h"
24 #include "photo_album_column.h"
25 #include "photo_asset_custom_record.h"
26 #include "custom_records_column.h"
27
28 using namespace std;
29
30 namespace OHOS {
31 namespace Media {
32 using ResultTypeMap = unordered_map<string, ResultSetDataType>;
33
GetResultTypeMap()34 static const ResultTypeMap &GetResultTypeMap()
35 {
36 static const ResultTypeMap RESULT_TYPE_MAP = {
37 { MEDIA_DATA_DB_ID, TYPE_INT32 },
38 { MEDIA_DATA_DB_NAME, TYPE_STRING },
39 { MEDIA_DATA_DB_RELATIVE_PATH, TYPE_STRING },
40 { MEDIA_DATA_DB_MEDIA_TYPE, TYPE_INT32 },
41 { MEDIA_DATA_DB_PARENT_ID, TYPE_INT32 },
42 { MEDIA_DATA_DB_SIZE, TYPE_INT64 },
43 { MEDIA_DATA_DB_DATE_ADDED, TYPE_INT64 },
44 { MEDIA_DATA_DB_DATE_MODIFIED, TYPE_INT64 },
45 { MEDIA_DATA_DB_DATE_TAKEN, TYPE_INT64 },
46 { MEDIA_DATA_DB_FILE_PATH, TYPE_STRING },
47 { MEDIA_DATA_DB_MIME_TYPE, TYPE_STRING },
48 { MEDIA_DATA_DB_TITLE, TYPE_STRING },
49 { MEDIA_DATA_DB_ARTIST, TYPE_STRING },
50 { MEDIA_DATA_DB_ALBUM, TYPE_STRING },
51 { MEDIA_DATA_DB_WIDTH, TYPE_INT32 },
52 { MEDIA_DATA_DB_HEIGHT, TYPE_INT32 },
53 { MEDIA_DATA_DB_DURATION, TYPE_INT32 },
54 { MEDIA_DATA_DB_ORIENTATION, TYPE_INT32 },
55 { MEDIA_DATA_DB_BUCKET_ID, TYPE_INT32 },
56 { MEDIA_DATA_DB_BUCKET_NAME, TYPE_STRING },
57 { MEDIA_DATA_DB_TIME_PENDING, TYPE_INT64 },
58 { MEDIA_DATA_DB_IS_FAV, TYPE_INT32 },
59 { MEDIA_DATA_DB_DATE_TRASHED, TYPE_INT64 },
60 { MEDIA_DATA_DB_SELF_ID, TYPE_STRING },
61 { MEDIA_DATA_DB_RECYCLE_PATH, TYPE_STRING },
62 { MEDIA_DATA_DB_IS_TRASH, TYPE_INT32 },
63 { MEDIA_DATA_DB_AUDIO_ALBUM, TYPE_STRING },
64 { MEDIA_DATA_DB_OWNER_PACKAGE, TYPE_STRING },
65 { MEDIA_DATA_DB_OWNER_APPID, TYPE_STRING },
66 { MediaColumn::MEDIA_PACKAGE_NAME, TYPE_STRING },
67 { MEDIA_DATA_DB_POSITION, TYPE_INT32 },
68 { MediaColumn::MEDIA_HIDDEN, TYPE_INT32 },
69 { MediaColumn::MEDIA_VIRTURL_PATH, TYPE_STRING },
70 { PhotoColumn::PHOTO_SUBTYPE, TYPE_INT32 },
71 { MEDIA_COLUMN_COUNT, TYPE_INT32 },
72 { PhotoColumn::CAMERA_SHOT_KEY, TYPE_STRING },
73 { PhotoColumn::PHOTO_ALL_EXIF, TYPE_STRING },
74 { PhotoColumn::PHOTO_USER_COMMENT, TYPE_STRING },
75 { PHOTO_INDEX, TYPE_INT32 },
76 { MEDIA_DATA_DB_COUNT, TYPE_INT32 },
77 { PhotoColumn::PHOTO_DATE_YEAR, TYPE_STRING },
78 { PhotoColumn::PHOTO_DATE_MONTH, TYPE_STRING },
79 { PhotoColumn::PHOTO_DATE_DAY, TYPE_STRING },
80 { PhotoColumn::PHOTO_SHOOTING_MODE, TYPE_STRING },
81 { PhotoColumn::PHOTO_SHOOTING_MODE_TAG, TYPE_STRING },
82 { PhotoColumn::PHOTO_LAST_VISIT_TIME, TYPE_INT64 },
83 { PhotoColumn::PHOTO_DYNAMIC_RANGE_TYPE, TYPE_INT32 },
84 { PhotoColumn::PHOTO_LCD_SIZE, TYPE_STRING },
85 { PhotoColumn::PHOTO_THUMB_SIZE, TYPE_STRING },
86 { PhotoColumn::MOVING_PHOTO_EFFECT_MODE, TYPE_INT32 },
87 { PhotoColumn::PHOTO_FRONT_CAMERA, TYPE_STRING },
88 { PhotoColumn::PHOTO_COVER_POSITION, TYPE_INT64 },
89 { PhotoColumn::PHOTO_ORIGINAL_SUBTYPE, TYPE_INT32 },
90 { PhotoColumn::PHOTO_BURST_COVER_LEVEL, TYPE_INT32 },
91 { PhotoColumn::PHOTO_BURST_KEY, TYPE_STRING },
92 { PhotoColumn::PHOTO_CE_AVAILABLE, TYPE_INT32 },
93 { PhotoColumn::PHOTO_THUMBNAIL_READY, TYPE_INT64 },
94 { PhotoColumn::PHOTO_DETAIL_TIME, TYPE_STRING },
95 { PhotoColumn::PHOTO_OWNER_ALBUM_ID, TYPE_INT32 },
96 { PhotoColumn::PHOTO_THUMBNAIL_VISIBLE, TYPE_INT32 },
97 { PhotoColumn::SUPPORTED_WATERMARK_TYPE, TYPE_INT32 },
98 { PhotoColumn::PHOTO_QUALITY, TYPE_INT32 },
99 { PhotoColumn::PHOTO_CLOUD_ID, TYPE_STRING },
100 { PhotoColumn::PHOTO_IS_AUTO, TYPE_INT32 },
101 { PhotoColumn::PHOTO_MEDIA_SUFFIX, TYPE_STRING },
102 { PhotoColumn::PHOTO_IS_RECENT_SHOW, TYPE_INT32 },
103 { MEDIA_SUM_SIZE, TYPE_INT64 },
104 { CustomRecordsColumns::FILE_ID, TYPE_INT32 },
105 { CustomRecordsColumns::BUNDLE_NAME, TYPE_STRING },
106 { CustomRecordsColumns::SHARE_COUNT, TYPE_INT32 },
107 { CustomRecordsColumns::LCD_JUMP_COUNT, TYPE_INT32 },
108 { PhotoColumn::PHOTO_EXIF_ROTATE, TYPE_INT32 },
109 };
110 return RESULT_TYPE_MAP;
111 }
112
113 template <class T>
FetchResult(const shared_ptr<DataShare::DataShareResultSet> & resultset)114 FetchResult<T>::FetchResult(const shared_ptr<DataShare::DataShareResultSet> &resultset)
115 {
116 resultset_ = resultset;
117 networkId_ = "";
118 resultNapiType_ = ResultNapiType::TYPE_NAPI_MAX;
119 if constexpr (std::is_same<T, FileAsset>::value) {
120 fetchResType_ = FetchResType::TYPE_FILE;
121 } else if constexpr (std::is_same<T, AlbumAsset>::value) {
122 fetchResType_ = FetchResType::TYPE_ALBUM;
123 } else if constexpr (std::is_same<T, PhotoAlbum>::value) {
124 fetchResType_ = FetchResType::TYPE_PHOTOALBUM;
125 } else if constexpr (std::is_same<T, SmartAlbumAsset>::value) {
126 fetchResType_ = FetchResType::TYPE_SMARTALBUM;
127 } else if constexpr (std::is_same<T, PhotoAssetCustomRecord>::value) {
128 fetchResType_ = FetchResType::TYPE_CUSTOMRECORD;
129 } else if constexpr (std::is_same<T, AlbumOrder>::value) {
130 fetchResType_ = FetchResType::TYPE_ALBUMORDER;
131 } else {
132 MEDIA_ERR_LOG("unsupported FetchResType");
133 fetchResType_ = FetchResType::TYPE_FILE;
134 }
135 GetCount();
136 }
137
138 template <class T>
139 // empty constructor napi
FetchResult()140 FetchResult<T>::FetchResult() : resultNapiType_(ResultNapiType::TYPE_NAPI_MAX), resultset_(nullptr)
141 {
142 }
143
144 template <class T>
~FetchResult()145 FetchResult<T>::~FetchResult()
146 {
147 resultset_.reset();
148 }
149
150 template <class T>
Close()151 void FetchResult<T>::Close()
152 {
153 if (resultset_ != nullptr) {
154 resultset_->Close();
155 resultset_ = nullptr;
156 }
157 }
158
159 template <class T>
GetCount()160 int32_t FetchResult<T>::GetCount()
161 {
162 int32_t count = 0;
163 bool cond = (resultset_ == nullptr || resultset_->GetRowCount(count) != NativeRdb::E_OK);
164 CHECK_AND_RETURN_RET(!cond, 0);
165 return count < 0 ? 0 : count;
166 }
167
168 template <class T>
SetInfo(const unique_ptr<FetchResult<T>> & fetch)169 void FetchResult<T>::SetInfo(const unique_ptr<FetchResult<T>> &fetch)
170 {
171 networkId_ = fetch->networkId_;
172 resultNapiType_ = fetch->resultNapiType_;
173 hiddenOnly_ = fetch->hiddenOnly_;
174 locationOnly_ = fetch->locationOnly_;
175 }
176
177 template <class T>
SetNetworkId(const string & networkId)178 void FetchResult<T>::SetNetworkId(const string &networkId)
179 {
180 networkId_ = networkId;
181 }
182
183 template<class T>
SetResultNapiType(const ResultNapiType napiType)184 void FetchResult<T>::SetResultNapiType(const ResultNapiType napiType)
185 {
186 resultNapiType_ = napiType;
187 }
188
189 template<class T>
SetFetchResType(const FetchResType resType)190 void FetchResult<T>::SetFetchResType(const FetchResType resType)
191 {
192 fetchResType_ = resType;
193 }
194
195 template<class T>
SetHiddenOnly(const bool hiddenOnly)196 void FetchResult<T>::SetHiddenOnly(const bool hiddenOnly)
197 {
198 hiddenOnly_ = hiddenOnly;
199 }
200
201 template<class T>
SetLocationOnly(const bool locationOnly)202 void FetchResult<T>::SetLocationOnly(const bool locationOnly)
203 {
204 locationOnly_ = locationOnly;
205 }
206
207 template<class T>
GetNetworkId() const208 const string& FetchResult<T>::GetNetworkId() const
209 {
210 return networkId_;
211 }
212
213 template<class T>
GetResultNapiType()214 ResultNapiType FetchResult<T>::GetResultNapiType()
215 {
216 return resultNapiType_;
217 }
218
219 template<class T>
GetDataShareResultSet()220 shared_ptr<DataShare::DataShareResultSet> &FetchResult<T>::GetDataShareResultSet()
221 {
222 return resultset_;
223 }
224
225 template<class T>
GetFetchResType()226 FetchResType FetchResult<T>::GetFetchResType()
227 {
228 return fetchResType_;
229 }
230
231 template<class T>
GetHiddenOnly() const232 bool FetchResult<T>::GetHiddenOnly() const
233 {
234 return hiddenOnly_;
235 }
236
237 template<class T>
GetLocationOnly() const238 bool FetchResult<T>::GetLocationOnly() const
239 {
240 return locationOnly_;
241 }
242
243 template<class T>
SetUserId(int32_t userId)244 void FetchResult<T>::SetUserId(int32_t userId)
245 {
246 userId_ = userId;
247 }
248
249 template<class T>
GetUserId()250 int32_t FetchResult<T>::GetUserId()
251 {
252 return userId_;
253 }
254
255 template <class T>
GetObjectAtPosition(int32_t index)256 unique_ptr<T> FetchResult<T>::GetObjectAtPosition(int32_t index)
257 {
258 CHECK_AND_RETURN_RET_LOG(resultset_ != nullptr, nullptr, "rs is null");
259 int32_t count = GetCount();
260 bool cond = ((index < 0) || (index > (count - 1)));
261 CHECK_AND_RETURN_RET_LOG(!cond, nullptr, "index not proper");
262 CHECK_AND_RETURN_RET_LOG(resultset_->GoToRow(index) == 0, nullptr, "failed to go to row at index pos");
263 return GetObject();
264 }
265
266 template <class T>
GetFirstObject()267 unique_ptr<T> FetchResult<T>::GetFirstObject()
268 {
269 if ((resultset_ == nullptr) || (resultset_->GoToFirstRow() != 0)) {
270 MEDIA_DEBUG_LOG("resultset is null|first row failed");
271 return nullptr;
272 }
273 return GetObject();
274 }
275
276 template <class T>
GetNextObject()277 unique_ptr<T> FetchResult<T>::GetNextObject()
278 {
279 if ((resultset_ == nullptr) || (resultset_->GoToNextRow() != 0)) {
280 MEDIA_DEBUG_LOG("resultset is null|go to next row failed");
281 return nullptr;
282 }
283
284 return GetObject();
285 }
286
287 template <class T>
GetLastObject()288 unique_ptr<T> FetchResult<T>::GetLastObject()
289 {
290 if ((resultset_ == nullptr) || (resultset_->GoToLastRow() != 0)) {
291 MEDIA_ERR_LOG("resultset is null|go to last row failed");
292 return nullptr;
293 }
294
295 return GetObject();
296 }
297
298 template <class T>
IsAtLastRow()299 bool FetchResult<T>::IsAtLastRow()
300 {
301 if (resultset_ == nullptr) {
302 MEDIA_ERR_LOG("resultset null");
303 return false;
304 }
305
306 bool retVal = false;
307 resultset_->IsAtLastRow(retVal);
308 return retVal;
309 }
310
ReturnDefaultOnError(string errMsg,ResultSetDataType dataType)311 variant<int32_t, int64_t, string, double> ReturnDefaultOnError(string errMsg, ResultSetDataType dataType)
312 {
313 if (dataType == TYPE_STRING) {
314 return "";
315 } else if (dataType == TYPE_INT64) {
316 return static_cast<int64_t>(0);
317 } else {
318 return 0;
319 }
320 }
321
322 template <class T>
GetRowValFromColumn(string columnName,ResultSetDataType dataType,shared_ptr<NativeRdb::ResultSet> & resultSet)323 variant<int32_t, int64_t, string, double> FetchResult<T>::GetRowValFromColumn(string columnName,
324 ResultSetDataType dataType, shared_ptr<NativeRdb::ResultSet> &resultSet)
325 {
326 if ((resultset_ == nullptr) && (resultSet == nullptr)) {
327 return ReturnDefaultOnError("Resultset is null", dataType);
328 }
329 int index;
330 int status;
331 if (resultSet) {
332 status = resultSet->GetColumnIndex(columnName, index);
333 } else {
334 status = resultset_->GetColumnIndex(columnName, index);
335 }
336 if (status != NativeRdb::E_OK) {
337 return ReturnDefaultOnError("failed to obtain the index", dataType);
338 }
339 return GetValByIndex(index, dataType, resultSet);
340 }
341
342 template <class T>
GetValByIndex(int32_t index,ResultSetDataType dataType,shared_ptr<NativeRdb::ResultSet> & resultSet)343 variant<int32_t, int64_t, string, double> FetchResult<T>::GetValByIndex(int32_t index, ResultSetDataType dataType,
344 shared_ptr<NativeRdb::ResultSet> &resultSet)
345 {
346 if ((resultset_ == nullptr) && (resultSet == nullptr)) {
347 return ReturnDefaultOnError("Resultset is null", dataType);
348 }
349
350 variant<int32_t, int64_t, string, double> cellValue;
351 int integerVal = 0;
352 string stringVal = "";
353 int64_t longVal = 0;
354 double doubleVal = 0.0;
355 switch (dataType) {
356 case TYPE_STRING:
357 if (resultSet) {
358 resultSet->GetString(index, stringVal);
359 } else {
360 resultset_->GetString(index, stringVal);
361 }
362 cellValue = move(stringVal);
363 break;
364 case TYPE_INT32:
365 if (resultSet) {
366 resultSet->GetInt(index, integerVal);
367 } else {
368 resultset_->GetInt(index, integerVal);
369 }
370 cellValue = integerVal;
371 break;
372 case TYPE_INT64:
373 if (resultSet) {
374 resultSet->GetLong(index, longVal);
375 } else {
376 resultset_->GetLong(index, longVal);
377 }
378 cellValue = longVal;
379 break;
380 case TYPE_DOUBLE:
381 if (resultSet) {
382 resultSet->GetDouble(index, doubleVal);
383 } else {
384 resultset_->GetDouble(index, doubleVal);
385 }
386 cellValue = doubleVal;
387 break;
388 default:
389 MEDIA_ERR_LOG("not match dataType %{public}d", dataType);
390 break;
391 }
392
393 return cellValue;
394 }
395
396 template<class T>
SetAssetUri(FileAsset * fileAsset)397 void FetchResult<T>::SetAssetUri(FileAsset *fileAsset)
398 {
399 string uri;
400 if (resultNapiType_ == ResultNapiType::TYPE_USERFILE_MGR ||
401 resultNapiType_ == ResultNapiType::TYPE_PHOTOACCESS_HELPER) {
402 string extrUri = MediaFileUtils::GetExtraUri(fileAsset->GetDisplayName(), fileAsset->GetPath(), false);
403 MediaFileUri fileUri(fileAsset->GetMediaType(), to_string(fileAsset->GetId()),
404 networkId_, MEDIA_API_VERSION_V10, extrUri);
405 uri = fileUri.ToString();
406 } else {
407 #ifdef MEDIALIBRARY_COMPATIBILITY
408 if (MediaFileUtils::IsFileTablePath(fileAsset->GetPath())) {
409 MediaFileUri fileUri(MediaType::MEDIA_TYPE_FILE, to_string(fileAsset->GetId()), networkId_);
410 uri = MediaFileUtils::GetVirtualUriFromRealUri(fileUri.ToString());
411 } else {
412 MediaFileUri fileUri(fileAsset->GetMediaType(), to_string(fileAsset->GetId()), networkId_);
413 uri = MediaFileUtils::GetVirtualUriFromRealUri(fileUri.ToString());
414 }
415 #else
416 MediaFileUri fileUri(fileAsset->GetMediaType(), to_string(fileAsset->GetId()), networkId_);
417 uri = fileUri.ToString();
418 #endif
419 }
420 #ifdef MEDIALIBRARY_COMPATIBILITY
421 fileAsset->SetAlbumId(0);
422 #endif
423 if (fileAsset->GetAlbumId() != DEFAULT_INT32) {
424 fileAsset->SetAlbumUri(MediaFileUri(MEDIA_TYPE_ALBUM, to_string(fileAsset->GetAlbumId()),
425 networkId_).ToString());
426 }
427 fileAsset->SetUri(move(uri));
428 }
429
430 template<class T>
SetFileAsset(FileAsset * fileAsset,shared_ptr<NativeRdb::ResultSet> & resultSet)431 void FetchResult<T>::SetFileAsset(FileAsset *fileAsset, shared_ptr<NativeRdb::ResultSet> &resultSet)
432 {
433 bool cond = ((resultset_ == nullptr) && (resultSet == nullptr));
434 CHECK_AND_RETURN_LOG(!cond, "SetFileAsset fail, result is nullptr");
435
436 vector<string> columnNames;
437 if (resultSet != nullptr) {
438 resultSet->GetAllColumnNames(columnNames);
439 } else {
440 resultset_->GetAllColumnNames(columnNames);
441 }
442 int32_t index = -1;
443 auto &map = fileAsset->GetMemberMap();
444 for (const auto &name : columnNames) {
445 index++;
446 if (GetResultTypeMap().count(name) == 0) {
447 continue;
448 }
449 auto memberType = GetResultTypeMap().at(name);
450 fileAsset->SetResultTypeMap(name, memberType);
451 if (name == MEDIA_DATA_DB_RELATIVE_PATH) {
452 map.emplace(move(name), MediaFileUtils::RemoveDocsFromRelativePath(
453 get<string>(GetValByIndex(index, memberType, resultSet))));
454 } else {
455 map.emplace(move(name), move(GetValByIndex(index, memberType, resultSet)));
456 }
457 }
458 fileAsset->SetResultNapiType(resultNapiType_);
459 if (!columnNames.empty() && columnNames[0].find("count(") != string::npos) {
460 int count = 1;
461 if (resultset_) {
462 resultset_->GetInt(0, count);
463 }
464 if (count == 0) {
465 MEDIA_INFO_LOG("query result count is 0");
466 }
467 fileAsset->SetCount(count);
468 }
469 SetAssetUri(fileAsset);
470 }
471
472 template<class T>
GetObjectFromResultSet(FileAsset * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)473 void FetchResult<T>::GetObjectFromResultSet(FileAsset *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
474 {
475 SetFileAsset(asset, resultSet);
476 }
477
478 template<class T>
GetObjectFromResultSet(AlbumAsset * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)479 void FetchResult<T>::GetObjectFromResultSet(AlbumAsset *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
480 {
481 SetAlbumAsset(asset, resultSet);
482 }
483
484 template<class T>
GetObjectFromResultSet(PhotoAlbum * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)485 void FetchResult<T>::GetObjectFromResultSet(PhotoAlbum *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
486 {
487 SetPhotoAlbum(asset, resultSet);
488 }
489
490 template<class T>
GetObjectFromResultSet(SmartAlbumAsset * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)491 void FetchResult<T>::GetObjectFromResultSet(SmartAlbumAsset *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
492 {
493 SetSmartAlbumAsset(asset, resultSet);
494 }
495
496 template<class T>
GetObjectFromResultSet(PhotoAssetCustomRecord * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)497 void FetchResult<T>::GetObjectFromResultSet(PhotoAssetCustomRecord *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
498 {
499 SetPhotoAssetCustomRecordAsset(asset, resultSet);
500 }
501
502 template<class T>
GetObjectFromResultSet(AlbumOrder * asset,shared_ptr<NativeRdb::ResultSet> & resultSet)503 void FetchResult<T>::GetObjectFromResultSet(AlbumOrder *asset, shared_ptr<NativeRdb::ResultSet> &resultSet)
504 {
505 SetAlbumOrder(asset, resultSet);
506 }
507
508 template<class T>
GetObject(shared_ptr<NativeRdb::ResultSet> & resultSet)509 unique_ptr<T> FetchResult<T>::GetObject(shared_ptr<NativeRdb::ResultSet> &resultSet)
510 {
511 unique_ptr<T> asset = make_unique<T>();
512 GetObjectFromResultSet(asset.get(), resultSet);
513 return asset;
514 }
515
516 template <class T>
GetObject()517 unique_ptr<T> FetchResult<T>::GetObject()
518 {
519 shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
520 return GetObject(resultSet);
521 }
522
523 template <class T>
GetObjectFromRdb(shared_ptr<NativeRdb::ResultSet> & resultSet,int idx)524 unique_ptr<T> FetchResult<T>::GetObjectFromRdb(shared_ptr<NativeRdb::ResultSet> &resultSet, int idx)
525 {
526 bool cond = ((resultSet == nullptr) || (resultSet->GoToFirstRow() != 0) || (resultSet->GoTo(idx)));
527 CHECK_AND_RETURN_RET_LOG(!cond, nullptr, "resultset is null|first row failed");
528 return GetObject(resultSet);
529 }
530
531 #ifdef MEDIALIBRARY_COMPATIBILITY
SetCompatAlbumName(AlbumAsset * albumData)532 static void SetCompatAlbumName(AlbumAsset *albumData)
533 {
534 string albumName;
535 switch (albumData->GetAlbumSubType()) {
536 case PhotoAlbumSubType::CAMERA:
537 albumName = CAMERA_ALBUM_NAME;
538 break;
539 case PhotoAlbumSubType::SCREENSHOT:
540 albumName = SCREEN_SHOT_ALBUM_NAME;
541 break;
542 default:
543 MEDIA_WARN_LOG("Ignore unsupported compat album type: %{public}d", albumData->GetAlbumSubType());
544 }
545 albumData->SetAlbumName(albumName);
546 }
547 #endif
548
549 template<class T>
SetAlbumAsset(AlbumAsset * albumData,shared_ptr<NativeRdb::ResultSet> & resultSet)550 void FetchResult<T>::SetAlbumAsset(AlbumAsset *albumData, shared_ptr<NativeRdb::ResultSet> &resultSet)
551 {
552 #ifdef MEDIALIBRARY_COMPATIBILITY
553 albumData->SetAlbumId(get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_ID, TYPE_INT32, resultSet)));
554 albumData->SetAlbumType(static_cast<PhotoAlbumType>(
555 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_TYPE, TYPE_INT32, resultSet))));
556 albumData->SetAlbumSubType(static_cast<PhotoAlbumSubType>(
557 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_SUBTYPE, TYPE_INT32, resultSet))));
558 SetCompatAlbumName(albumData);
559 #else
560 // Get album id index and value
561 albumData->SetAlbumId(get<int32_t>(GetRowValFromColumn(MEDIA_DATA_DB_BUCKET_ID, TYPE_INT32, resultSet)));
562 // Get album title index and value
563 albumData->SetAlbumName(get<string>(GetRowValFromColumn(MEDIA_DATA_DB_TITLE, TYPE_STRING, resultSet)));
564 #endif
565 // Get album asset count index and value
566 albumData->SetCount(get<int32_t>(GetRowValFromColumn(MEDIA_DATA_DB_COUNT, TYPE_INT32, resultSet)));
567 string albumUri;
568 if (resultNapiType_ == ResultNapiType::TYPE_USERFILE_MGR ||
569 resultNapiType_ == ResultNapiType::TYPE_PHOTOACCESS_HELPER) {
570 albumUri = PhotoAlbumColumns::ALBUM_URI_PREFIX + to_string(albumData->GetAlbumId());
571 } else {
572 albumUri = ML_FILE_URI_PREFIX + MEDIALIBRARY_TYPE_ALBUM_URI + "/" + to_string(albumData->GetAlbumId());
573 }
574 albumData->SetAlbumUri(albumUri);
575 // Get album relativePath index and value
576 albumData->SetAlbumRelativePath(MediaFileUtils::RemoveDocsFromRelativePath(
577 get<string>(GetRowValFromColumn(MEDIA_DATA_DB_RELATIVE_PATH, TYPE_STRING, resultSet))));
578 albumData->SetAlbumDateModified(get<int64_t>(GetRowValFromColumn(MEDIA_DATA_DB_DATE_MODIFIED,
579 TYPE_INT64, resultSet)));
580
581 albumData->SetResultNapiType(resultNapiType_);
582 }
583
584 template<class T>
SetPhotoAlbum(PhotoAlbum * photoAlbumData,shared_ptr<NativeRdb::ResultSet> & resultSet)585 void FetchResult<T>::SetPhotoAlbum(PhotoAlbum* photoAlbumData, shared_ptr<NativeRdb::ResultSet> &resultSet)
586 {
587 int32_t albumId = get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_ID, TYPE_INT32, resultSet));
588 photoAlbumData->SetAlbumId(albumId);
589 photoAlbumData->SetPhotoAlbumType(static_cast<PhotoAlbumType>(
590 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_TYPE, TYPE_INT32, resultSet))));
591 photoAlbumData->SetPhotoAlbumSubType(static_cast<PhotoAlbumSubType>(
592 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_SUBTYPE, TYPE_INT32, resultSet))));
593 photoAlbumData->SetLPath(get<string>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_LPATH, TYPE_STRING,
594 resultSet)));
595 photoAlbumData->SetAlbumName(get<string>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_NAME, TYPE_STRING,
596 resultSet)));
597 photoAlbumData->SetDateAdded(get<int64_t>(GetRowValFromColumn(
598 PhotoAlbumColumns::ALBUM_DATE_ADDED, TYPE_INT64, resultSet)));
599 photoAlbumData->SetDateModified(get<int64_t>(GetRowValFromColumn(
600 PhotoAlbumColumns::ALBUM_DATE_MODIFIED, TYPE_INT64, resultSet)));
601 photoAlbumData->SetResultNapiType(resultNapiType_);
602 photoAlbumData->SetHiddenOnly(hiddenOnly_);
603 photoAlbumData->SetCoverUriSource(get<int32_t>(GetRowValFromColumn(
604 PhotoAlbumColumns::COVER_URI_SOURCE, TYPE_INT32, resultSet)));
605
606 string countColumn = hiddenOnly_ ? PhotoAlbumColumns::HIDDEN_COUNT : PhotoAlbumColumns::ALBUM_COUNT;
607 string coverColumn = hiddenOnly_ ? PhotoAlbumColumns::HIDDEN_COVER : PhotoAlbumColumns::ALBUM_COVER_URI;
608 string albumUriPrefix;
609 if (photoAlbumData->GetPhotoAlbumType() == PhotoAlbumType::SMART) {
610 albumUriPrefix =
611 hiddenOnly_ ? PhotoAlbumColumns::HIDDEN_ALBUM_URI_PREFIX : PhotoAlbumColumns::ANALYSIS_ALBUM_URI_PREFIX;
612 } else {
613 albumUriPrefix =
614 hiddenOnly_ ? PhotoAlbumColumns::HIDDEN_ALBUM_URI_PREFIX : PhotoAlbumColumns::ALBUM_URI_PREFIX;
615 }
616 photoAlbumData->SetAlbumUri(albumUriPrefix + to_string(albumId));
617 photoAlbumData->SetCount(get<int32_t>(GetRowValFromColumn(countColumn, TYPE_INT32, resultSet)));
618 photoAlbumData->SetCoverUri(get<string>(GetRowValFromColumn(coverColumn, TYPE_STRING,
619 resultSet)));
620
621 // Albums of hidden types (except hidden album itself) don't support image count and video count,
622 // return -1 instead
623 int32_t imageCount = hiddenOnly_ ? -1 :
624 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_IMAGE_COUNT, TYPE_INT32, resultSet));
625 int32_t videoCount = hiddenOnly_ ? -1 :
626 get<int32_t>(GetRowValFromColumn(PhotoAlbumColumns::ALBUM_VIDEO_COUNT, TYPE_INT32, resultSet));
627 photoAlbumData->SetImageCount(imageCount);
628 photoAlbumData->SetVideoCount(videoCount);
629
630 // location album support latitude and longitude
631 double latitude = locationOnly_ ? get<double>(GetRowValFromColumn(
632 PhotoAlbumColumns::ALBUM_LATITUDE, TYPE_DOUBLE, resultSet)) : 0.0;
633
634 double longitude = locationOnly_ ? get<double>(GetRowValFromColumn(
635 PhotoAlbumColumns::ALBUM_LONGITUDE, TYPE_DOUBLE, resultSet)) : 0.0;
636
637 photoAlbumData->SetLatitude(latitude);
638 photoAlbumData->SetLongitude(longitude);
639 }
640
641 template<class T>
SetSmartAlbumAsset(SmartAlbumAsset * smartAlbumData,shared_ptr<NativeRdb::ResultSet> & resultSet)642 void FetchResult<T>::SetSmartAlbumAsset(SmartAlbumAsset* smartAlbumData, shared_ptr<NativeRdb::ResultSet> &resultSet)
643 {
644 smartAlbumData->SetAlbumId(get<int32_t>(GetRowValFromColumn(SMARTALBUM_DB_ID, TYPE_INT32, resultSet)));
645 smartAlbumData->SetAlbumName(get<string>(GetRowValFromColumn(SMARTALBUM_DB_NAME, TYPE_STRING, resultSet)));
646 smartAlbumData->SetAlbumCapacity(get<int32_t>(GetRowValFromColumn(SMARTALBUM_DB_CAPACITY, TYPE_INT32, resultSet)));
647 smartAlbumData->SetResultNapiType(resultNapiType_);
648 }
649
650 template<class T>
SetPhotoAssetCustomRecordAsset(PhotoAssetCustomRecord * customRecordData,shared_ptr<NativeRdb::ResultSet> & resultSet)651 void FetchResult<T>::SetPhotoAssetCustomRecordAsset(PhotoAssetCustomRecord* customRecordData,
652 shared_ptr<NativeRdb::ResultSet> &resultSet)
653 {
654 customRecordData->SetFileId(get<int32_t>(GetRowValFromColumn(CustomRecordsColumns::FILE_ID,
655 TYPE_INT32, resultSet)));
656 customRecordData->SetShareCount(get<int32_t>(GetRowValFromColumn(CustomRecordsColumns::SHARE_COUNT,
657 TYPE_INT32, resultSet)));
658 customRecordData->SetLcdJumpCount(get<int32_t>(GetRowValFromColumn(CustomRecordsColumns::LCD_JUMP_COUNT,
659 TYPE_INT32, resultSet)));
660 customRecordData->SetResultNapiType(resultNapiType_);
661 }
662
663 // LCOV_EXCL_START
664 template<class T>
SetAlbumOrder(AlbumOrder * albumOrderData,shared_ptr<NativeRdb::ResultSet> & resultSet)665 void FetchResult<T>::SetAlbumOrder(AlbumOrder* albumOrderData,
666 shared_ptr<NativeRdb::ResultSet> &resultSet)
667 {
668 bool cond = ((resultset_ == nullptr) && (resultSet == nullptr));
669 CHECK_AND_RETURN_LOG(!cond, "SetAlbumOrder fail, result is nullptr");
670
671 vector<string> columnNames;
672 if (resultSet != nullptr) {
673 resultSet->GetAllColumnNames(columnNames);
674 } else {
675 resultset_->GetAllColumnNames(columnNames);
676 }
677 for (const auto &name : columnNames) {
678 CHECK_AND_RETURN_LOG(!name.empty(), "SetAlbumOrder fail, name is empty");
679
680 if (name == PhotoAlbumColumns::ALBUM_ID) {
681 albumOrderData->SetAlbumId(get<int32_t>(GetRowValFromColumn(name, TYPE_INT32, resultSet)));
682 } else if (name == PhotoAlbumColumns::ALBUMS_ORDER || name == PhotoAlbumColumns::STYLE2_ALBUMS_ORDER) {
683 albumOrderData->SetAlbumOrder(get<int32_t>(GetRowValFromColumn(name, TYPE_INT32, resultSet)));
684 } else if (name == PhotoAlbumColumns::ORDER_SECTION || name == PhotoAlbumColumns::STYLE2_ORDER_SECTION) {
685 albumOrderData->SetOrderSection(get<int32_t>(GetRowValFromColumn(name, TYPE_INT32, resultSet)));
686 } else if (name == PhotoAlbumColumns::ORDER_TYPE || name == PhotoAlbumColumns::STYLE2_ORDER_TYPE) {
687 albumOrderData->SetOrderType(get<int32_t>(GetRowValFromColumn(name, TYPE_INT32, resultSet)));
688 } else if (name == PhotoAlbumColumns::ORDER_STATUS || name == PhotoAlbumColumns::STYLE2_ORDER_STATUS) {
689 albumOrderData->SetOrderStatus(get<int32_t>(GetRowValFromColumn(name, TYPE_INT32, resultSet)));
690 }
691 }
692 albumOrderData->SetResultNapiType(resultNapiType_);
693 }
694 // LCOV_EXCL_STOP
695 template class FetchResult<FileAsset>;
696 template class FetchResult<AlbumAsset>;
697 template class FetchResult<PhotoAlbum>;
698 template class FetchResult<SmartAlbumAsset>;
699 template class FetchResult<PhotoAssetCustomRecord>;
700 template class FetchResult<AlbumOrder>;
701 } // namespace Media
702 } // namespace OHOS
703