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