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