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