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