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