• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021-2022 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 "FetchResultNapi"
16 
17 #include "fetch_file_result_napi.h"
18 
19 #include "album_napi.h"
20 #include "hitrace_meter.h"
21 #include "medialibrary_client_errno.h"
22 #include "medialibrary_napi_log.h"
23 #include "medialibrary_tracer.h"
24 #include "photo_album_napi.h"
25 #include "smart_album_napi.h"
26 
27 using OHOS::HiviewDFX::HiLog;
28 using OHOS::HiviewDFX::HiLogLabel;
29 using namespace std;
30 
31 namespace OHOS {
32 namespace Media {
33 thread_local napi_ref FetchFileResultNapi::sConstructor_ = nullptr;
34 thread_local napi_ref FetchFileResultNapi::userFileMgrConstructor_ = nullptr;
35 thread_local napi_ref FetchFileResultNapi::photoAccessHelperConstructor_ = nullptr;
36 
FetchFileResultNapi()37 FetchFileResultNapi::FetchFileResultNapi()
38     : env_(nullptr) {}
39 
~FetchFileResultNapi()40 FetchFileResultNapi::~FetchFileResultNapi()
41 {
42     propertyPtr = nullptr;
43 }
44 
FetchFileResultNapiDestructor(napi_env env,void * nativeObject,void * finalize_hint)45 void FetchFileResultNapi::FetchFileResultNapiDestructor(napi_env env, void *nativeObject, void *finalize_hint)
46 {
47     FetchFileResultNapi *fetchFileResultObj = reinterpret_cast<FetchFileResultNapi*>(nativeObject);
48     if (fetchFileResultObj != nullptr) {
49         delete fetchFileResultObj;
50         fetchFileResultObj = nullptr;
51     }
52 }
53 
Init(napi_env env,napi_value exports)54 napi_value FetchFileResultNapi::Init(napi_env env, napi_value exports)
55 {
56     napi_status status;
57     napi_value ctorObj;
58     int32_t refCount = 1;
59 
60     napi_property_descriptor fetch_file_result_props[] = {
61         DECLARE_NAPI_FUNCTION("getCount", JSGetCount),
62         DECLARE_NAPI_FUNCTION("isAfterLast", JSIsAfterLast),
63         DECLARE_NAPI_FUNCTION("getFirstObject", JSGetFirstObject),
64         DECLARE_NAPI_FUNCTION("getNextObject", JSGetNextObject),
65         DECLARE_NAPI_FUNCTION("getLastObject", JSGetLastObject),
66         DECLARE_NAPI_FUNCTION("getPositionObject", JSGetPositionObject),
67         DECLARE_NAPI_FUNCTION("getAllObject", JSGetAllObject),
68         DECLARE_NAPI_FUNCTION("close", JSClose)
69     };
70 
71     status = napi_define_class(env, FETCH_FILE_RESULT_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH,
72                                FetchFileResultNapiConstructor, nullptr,
73                                sizeof(fetch_file_result_props) / sizeof(fetch_file_result_props[PARAM0]),
74                                fetch_file_result_props, &ctorObj);
75     if (status == napi_ok) {
76         status = napi_create_reference(env, ctorObj, refCount, &sConstructor_);
77         if (status == napi_ok) {
78             status = napi_set_named_property(env, exports, FETCH_FILE_RESULT_CLASS_NAME.c_str(), ctorObj);
79             if (status == napi_ok) {
80                 return exports;
81             }
82         }
83     }
84     NAPI_DEBUG_LOG("Init success");
85     return nullptr;
86 }
87 
GetFetchResult(unique_ptr<FetchFileResultNapi> & obj)88 void FetchFileResultNapi::GetFetchResult(unique_ptr<FetchFileResultNapi> &obj)
89 {
90     switch (sFetchResType_) {
91         case FetchResType::TYPE_FILE: {
92             auto fileResult = make_shared<FetchResult<FileAsset>>(move(sFetchFileResult_->GetDataShareResultSet()));
93             obj->propertyPtr->fetchFileResult_ = fileResult;
94             obj->propertyPtr->fetchFileResult_->SetInfo(sFetchFileResult_);
95             break;
96         }
97         case FetchResType::TYPE_ALBUM: {
98             auto albumResult = make_shared<FetchResult<AlbumAsset>>(move(sFetchAlbumResult_->GetDataShareResultSet()));
99             obj->propertyPtr->fetchAlbumResult_ = albumResult;
100             obj->propertyPtr->fetchAlbumResult_->SetInfo(sFetchAlbumResult_);
101             break;
102         }
103         case FetchResType::TYPE_PHOTOALBUM: {
104             auto photoAlbumResult =
105                 make_shared<FetchResult<PhotoAlbum>>(move(sFetchPhotoAlbumResult_->GetDataShareResultSet()));
106             obj->propertyPtr->fetchPhotoAlbumResult_ = photoAlbumResult;
107             obj->propertyPtr->fetchPhotoAlbumResult_->SetInfo(sFetchPhotoAlbumResult_);
108             break;
109         }
110         case FetchResType::TYPE_SMARTALBUM: {
111             auto smartResult =
112                 make_shared<FetchResult<SmartAlbumAsset>>(move(sFetchSmartAlbumResult_->GetDataShareResultSet()));
113             obj->propertyPtr->fetchSmartAlbumResult_ = smartResult;
114             obj->propertyPtr->fetchSmartAlbumResult_->SetInfo(sFetchSmartAlbumResult_);
115             break;
116         }
117         default:
118             NAPI_ERR_LOG("unsupported FetchResType");
119             break;
120     }
121 }
122 
123 // Constructor callback
FetchFileResultNapiConstructor(napi_env env,napi_callback_info info)124 napi_value FetchFileResultNapi::FetchFileResultNapiConstructor(napi_env env, napi_callback_info info)
125 {
126     MediaLibraryTracer tracer;
127     tracer.Start("FetchFileResultNapiConstructor");
128 
129     napi_status status;
130     napi_value result = nullptr;
131     napi_value thisVar = nullptr;
132 
133     napi_get_undefined(env, &result);
134     GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
135     if (status != napi_ok || thisVar == nullptr) {
136         NAPI_ERR_LOG("Get Js obj failed, status: %{public}d, (thisVar == nullptr) = %{public}d",
137             status, (thisVar == nullptr));
138         return result;
139     }
140 
141     unique_ptr<FetchFileResultNapi> obj = make_unique<FetchFileResultNapi>();
142     if (obj == nullptr) {
143         NAPI_ERR_LOG("Get FetchFileResultNapi failed");
144         return result;
145     }
146     obj->env_ = env;
147     obj->propertyPtr = make_shared<FetchResultProperty>();
148     GetFetchResult(obj);
149     obj->propertyPtr->fetchResType_ = sFetchResType_;
150     status = napi_wrap(env, thisVar, reinterpret_cast<void *>(obj.get()),
151                        FetchFileResultNapi::FetchFileResultNapiDestructor, nullptr, nullptr);
152     if (status == napi_ok) {
153         obj.release();
154         return thisVar;
155     } else {
156         NAPI_ERR_LOG("Failure wrapping js to native napi, status: %{public}d", status);
157     }
158     return result;
159 }
160 
GetFetchResType()161 FetchResType FetchFileResultNapi::GetFetchResType()
162 {
163     return propertyPtr->fetchResType_;
164 }
165 
SolveConstructorRef(unique_ptr<FetchResult<FileAsset>> & fileResult,napi_ref & constructorRef)166 void FetchFileResultNapi::SolveConstructorRef(unique_ptr<FetchResult<FileAsset>> &fileResult,
167     napi_ref &constructorRef)
168 {
169     switch(fileResult->GetResultNapiType()) {
170         case ResultNapiType::TYPE_USERFILE_MGR: {
171             constructorRef = userFileMgrConstructor_;
172             break;
173         }
174         case ResultNapiType::TYPE_PHOTOACCESS_HELPER: {
175             constructorRef = photoAccessHelperConstructor_;
176             break;
177         }
178         default:
179             constructorRef = sConstructor_;
180             break;
181     }
182 }
183 
SolveConstructorRef(unique_ptr<FetchResult<AlbumAsset>> & fileResult,napi_ref & constructorRef)184 void FetchFileResultNapi::SolveConstructorRef(unique_ptr<FetchResult<AlbumAsset>> &fileResult,
185     napi_ref &constructorRef)
186 {
187     switch(fileResult->GetResultNapiType()) {
188         case ResultNapiType::TYPE_USERFILE_MGR: {
189             constructorRef = userFileMgrConstructor_;
190             break;
191         }
192         case ResultNapiType::TYPE_PHOTOACCESS_HELPER: {
193             constructorRef = photoAccessHelperConstructor_;
194             break;
195         }
196         default:
197             constructorRef = sConstructor_;
198             break;
199     }
200 }
201 
SolveConstructorRef(unique_ptr<FetchResult<SmartAlbumAsset>> & fileResult,napi_ref & constructorRef)202 void FetchFileResultNapi::SolveConstructorRef(unique_ptr<FetchResult<SmartAlbumAsset>> &fileResult,
203     napi_ref &constructorRef)
204 {
205     switch(fileResult->GetResultNapiType()) {
206         case ResultNapiType::TYPE_USERFILE_MGR: {
207             constructorRef = userFileMgrConstructor_;
208             break;
209         }
210         case ResultNapiType::TYPE_PHOTOACCESS_HELPER: {
211             constructorRef = photoAccessHelperConstructor_;
212             break;
213         }
214         default:
215             constructorRef = sConstructor_;
216             break;
217     }
218 }
219 
SolveConstructorRef(unique_ptr<FetchResult<PhotoAlbum>> & fileResult,napi_ref & constructorRef)220 void FetchFileResultNapi::SolveConstructorRef(unique_ptr<FetchResult<PhotoAlbum>> &fileResult,
221     napi_ref &constructorRef)
222 {
223     switch(fileResult->GetResultNapiType()) {
224         case ResultNapiType::TYPE_USERFILE_MGR: {
225             constructorRef = userFileMgrConstructor_;
226             break;
227         }
228         case ResultNapiType::TYPE_PHOTOACCESS_HELPER: {
229             constructorRef = photoAccessHelperConstructor_;
230             break;
231         }
232         default:
233             constructorRef = sConstructor_;
234             break;
235     }
236 }
237 
CreateFetchFileResult(napi_env env,unique_ptr<FetchResult<FileAsset>> fileResult)238 napi_value FetchFileResultNapi::CreateFetchFileResult(napi_env env, unique_ptr<FetchResult<FileAsset>> fileResult)
239 {
240     MediaLibraryTracer tracer;
241     tracer.Start("CreateFetchFileResult");
242     napi_value constructor;
243     napi_ref constructorRef;
244 
245     FetchFileResultNapi::SolveConstructorRef(fileResult, constructorRef);
246     NAPI_CALL(env, napi_get_reference_value(env, constructorRef, &constructor));
247     sFetchResType_ = fileResult->GetFetchResType();
248     sFetchFileResult_ = move(fileResult);
249     napi_value result = nullptr;
250     NAPI_CALL(env, napi_new_instance(env, constructor, 0, nullptr, &result));
251     sFetchFileResult_ = nullptr;
252     return result;
253 }
254 
CreateFetchFileResult(napi_env env,unique_ptr<FetchResult<AlbumAsset>> fileResult)255 napi_value FetchFileResultNapi::CreateFetchFileResult(napi_env env, unique_ptr<FetchResult<AlbumAsset>> fileResult)
256 {
257     MediaLibraryTracer tracer;
258     tracer.Start("CreateFetchFileResult");
259     napi_value constructor;
260     napi_ref constructorRef;
261     FetchFileResultNapi::SolveConstructorRef(fileResult, constructorRef);
262     NAPI_CALL(env, napi_get_reference_value(env, constructorRef, &constructor));
263     sFetchResType_ = fileResult->GetFetchResType();
264     sFetchAlbumResult_ = move(fileResult);
265     napi_value result = nullptr;
266     NAPI_CALL(env, napi_new_instance(env, constructor, 0, nullptr, &result));
267     sFetchAlbumResult_ = nullptr;
268     return result;
269 }
270 
CreateFetchFileResult(napi_env env,unique_ptr<FetchResult<PhotoAlbum>> fileResult)271 napi_value FetchFileResultNapi::CreateFetchFileResult(napi_env env, unique_ptr<FetchResult<PhotoAlbum>> fileResult)
272 {
273     MediaLibraryTracer tracer;
274     tracer.Start("CreateFetchFileResult");
275     napi_value constructor;
276     napi_ref constructorRef;
277     FetchFileResultNapi::SolveConstructorRef(fileResult, constructorRef);
278     NAPI_CALL(env, napi_get_reference_value(env, constructorRef, &constructor));
279     sFetchResType_ = fileResult->GetFetchResType();
280     sFetchPhotoAlbumResult_ = move(fileResult);
281     napi_value result = nullptr;
282     NAPI_CALL(env, napi_new_instance(env, constructor, 0, nullptr, &result));
283     sFetchPhotoAlbumResult_ = nullptr;
284     return result;
285 }
286 
CreateFetchFileResult(napi_env env,unique_ptr<FetchResult<SmartAlbumAsset>> fileResult)287 napi_value FetchFileResultNapi::CreateFetchFileResult(napi_env env, unique_ptr<FetchResult<SmartAlbumAsset>> fileResult)
288 {
289     MediaLibraryTracer tracer;
290     tracer.Start("CreateFetchFileResult");
291     napi_value constructor;
292     napi_ref constructorRef;
293     FetchFileResultNapi::SolveConstructorRef(fileResult, constructorRef);
294     NAPI_CALL(env, napi_get_reference_value(env, constructorRef, &constructor));
295     sFetchResType_ = fileResult->GetFetchResType();
296     sFetchSmartAlbumResult_ = move(fileResult);
297     napi_value result = nullptr;
298     NAPI_CALL(env, napi_new_instance(env, constructor, 0, nullptr, &result));
299     sFetchSmartAlbumResult_ = nullptr;
300     return result;
301 }
302 
GetFetchFileResult() const303 std::shared_ptr<FetchResult<FileAsset>> FetchFileResultNapi::GetFetchFileResult() const
304 {
305     return propertyPtr->fetchFileResult_;
306 }
307 
UserFileMgrInit(napi_env env,napi_value exports)308 napi_value FetchFileResultNapi::UserFileMgrInit(napi_env env, napi_value exports)
309 {
310     NapiClassInfo info = {
311         .name = UFM_FETCH_FILE_RESULT_CLASS_NAME,
312         .ref = &userFileMgrConstructor_,
313         .constructor = FetchFileResultNapiConstructor,
314         .props = {
315             DECLARE_NAPI_FUNCTION("getCount", JSGetCount),
316             DECLARE_NAPI_FUNCTION("isAfterLast", JSIsAfterLast),
317             DECLARE_NAPI_FUNCTION("getFirstObject", JSGetFirstObject),
318             DECLARE_NAPI_FUNCTION("getNextObject", JSGetNextObject),
319             DECLARE_NAPI_FUNCTION("getLastObject", JSGetLastObject),
320             DECLARE_NAPI_FUNCTION("getPositionObject", JSGetPositionObject),
321             DECLARE_NAPI_FUNCTION("getAllObject", JSGetAllObject),
322             DECLARE_NAPI_FUNCTION("close", JSClose)
323         }
324     };
325     MediaLibraryNapiUtils::NapiDefineClass(env, exports, info);
326     return exports;
327 }
328 
PhotoAccessHelperInit(napi_env env,napi_value exports)329 napi_value FetchFileResultNapi::PhotoAccessHelperInit(napi_env env, napi_value exports)
330 {
331     NapiClassInfo info = {
332         .name = PAH_FETCH_FILE_RESULT_CLASS_NAME,
333         .ref = &photoAccessHelperConstructor_,
334         .constructor = FetchFileResultNapiConstructor,
335         .props = {
336             DECLARE_NAPI_FUNCTION("getCount", JSGetCount),
337             DECLARE_NAPI_FUNCTION("isAfterLast", JSIsAfterLast),
338             DECLARE_NAPI_FUNCTION("getFirstObject", JSGetFirstObject),
339             DECLARE_NAPI_FUNCTION("getNextObject", JSGetNextObject),
340             DECLARE_NAPI_FUNCTION("getLastObject", JSGetLastObject),
341             DECLARE_NAPI_FUNCTION("getObjectByPosition", JSGetPositionObject),
342             DECLARE_NAPI_FUNCTION("getAllObjects", JSGetAllObject),
343             DECLARE_NAPI_FUNCTION("close", JSClose)
344         }
345     };
346     MediaLibraryNapiUtils::NapiDefineClass(env, exports, info);
347     return exports;
348 }
349 
CheckIfFFRNapiNotEmpty(FetchFileResultNapi * obj)350 static bool CheckIfFFRNapiNotEmpty(FetchFileResultNapi* obj)
351 {
352     if (obj == nullptr) {
353         NAPI_INFO_LOG("FetchFileResultNapi is nullptr");
354         return false;
355     }
356     if (obj->CheckIfPropertyPtrNull()) {
357         NAPI_INFO_LOG("PropertyPtr in FetchFileResultNapi is nullptr");
358         return false;
359     }
360     return true;
361 }
362 
JSGetCount(napi_env env,napi_callback_info info)363 napi_value FetchFileResultNapi::JSGetCount(napi_env env, napi_callback_info info)
364 {
365     napi_status status;
366     napi_value jsResult = nullptr;
367     FetchFileResultNapi* obj = nullptr;
368     int32_t count = 0;
369     napi_value thisVar = nullptr;
370 
371     MediaLibraryTracer tracer;
372     tracer.Start("JSGetCount");
373 
374     napi_get_undefined(env, &jsResult);
375     GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
376     if (status != napi_ok || thisVar == nullptr) {
377         NAPI_ERR_LOG("JSGetCount Invalid arguments!, status: %{public}d", status);
378         NAPI_ASSERT(env, false, "JSGetCount thisVar == nullptr");
379     }
380 
381     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
382     if ((status == napi_ok) && CheckIfFFRNapiNotEmpty(obj)) {
383         switch (obj->GetFetchResType()) {
384             case FetchResType::TYPE_FILE:
385                 count = obj->GetFetchFileResultObject()->GetCount();
386                 break;
387             case FetchResType::TYPE_ALBUM:
388                 count = obj->GetFetchAlbumResultObject()->GetCount();
389                 break;
390             case FetchResType::TYPE_PHOTOALBUM:
391                 count = obj->GetFetchPhotoAlbumResultObject()->GetCount();
392                 break;
393             case FetchResType::TYPE_SMARTALBUM:
394                 count = obj->GetFetchSmartAlbumResultObject()->GetCount();
395                 break;
396             default:
397                 NAPI_ERR_LOG("unsupported FetchResType");
398                 break;
399         }
400         if (count < 0) {
401             NapiError::ThrowError(env, JS_INNER_FAIL, "Failed to get count");
402             return nullptr;
403         }
404         napi_create_int32(env, count, &jsResult);
405     } else {
406         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID, "Failed to get native obj");
407         return nullptr;
408     }
409 
410     return jsResult;
411 }
412 
JSIsAfterLast(napi_env env,napi_callback_info info)413 napi_value FetchFileResultNapi::JSIsAfterLast(napi_env env, napi_callback_info info)
414 {
415     napi_status status;
416     napi_value jsResult = nullptr;
417     FetchFileResultNapi* obj = nullptr;
418     bool isAfterLast = false;
419     napi_value thisVar = nullptr;
420 
421     MediaLibraryTracer tracer;
422     tracer.Start("JSIsAfterLast");
423 
424     napi_get_undefined(env, &jsResult);
425     GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
426     if (status != napi_ok || thisVar == nullptr) {
427         NAPI_ERR_LOG("JSIsAfterLast Invalid arguments!, status: %{public}d", status);
428         NAPI_ASSERT(env, false, "JSIsAfterLast thisVar == nullptr");
429     }
430 
431     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
432     if ((status == napi_ok) && CheckIfFFRNapiNotEmpty(obj)) {
433         switch (obj->GetFetchResType()) {
434             case FetchResType::TYPE_FILE:
435                 isAfterLast = obj->GetFetchFileResultObject()->IsAtLastRow();
436                 break;
437             case FetchResType::TYPE_ALBUM:
438                 isAfterLast = obj->GetFetchAlbumResultObject()->IsAtLastRow();
439                 break;
440             case FetchResType::TYPE_PHOTOALBUM:
441                 isAfterLast = obj->GetFetchPhotoAlbumResultObject()->IsAtLastRow();
442                 break;
443             case FetchResType::TYPE_SMARTALBUM:
444                 isAfterLast = obj->GetFetchSmartAlbumResultObject()->IsAtLastRow();
445                 break;
446             default:
447                 NAPI_ERR_LOG("unsupported FetchResType");
448                 break;
449         }
450         napi_get_boolean(env, isAfterLast, &jsResult);
451     } else {
452         NAPI_ERR_LOG("JSIsAfterLast obj == nullptr, status: %{public}d", status);
453         NAPI_ASSERT(env, false, "JSIsAfterLast obj == nullptr");
454     }
455 
456     return jsResult;
457 }
458 
GetNapiResFromAsset(napi_env env,FetchFileResultAsyncContext * context,unique_ptr<JSAsyncContextOutput> & jsContext)459 static void GetNapiResFromAsset(napi_env env, FetchFileResultAsyncContext *context,
460     unique_ptr<JSAsyncContextOutput> &jsContext)
461 {
462     napi_value jsAsset;
463     switch (context->objectPtr->fetchResType_) {
464         case FetchResType::TYPE_FILE:
465             jsAsset = FileAssetNapi::CreateFileAsset(env, context->fileAsset);
466             break;
467         case FetchResType::TYPE_ALBUM:
468             jsAsset = AlbumNapi::CreateAlbumNapi(env, context->albumAsset);
469             break;
470         case FetchResType::TYPE_PHOTOALBUM:
471             jsAsset = PhotoAlbumNapi::CreatePhotoAlbumNapi(env, context->photoAlbum);
472             break;
473         case FetchResType::TYPE_SMARTALBUM:
474             jsAsset = SmartAlbumNapi::CreateSmartAlbumNapi(env, context->smartAlbumAsset);
475             break;
476         default:
477             NAPI_ERR_LOG("unsupported FetchResType");
478             break;
479     }
480 
481     if (jsAsset == nullptr) {
482         NAPI_ERR_LOG("Failed to get file asset napi object");
483         napi_get_undefined(env, &jsContext->data);
484         MediaLibraryNapiUtils::CreateNapiErrorObject(env, jsContext->error, ERR_MEM_ALLOCATION,
485             "Failed to create js object for FileAsset");
486     } else {
487         jsContext->data = jsAsset;
488         napi_get_undefined(env, &jsContext->error);
489         jsContext->status = true;
490     }
491 }
492 
GetPositionObjectCompleteCallback(napi_env env,napi_status status,FetchFileResultAsyncContext * context)493 static void GetPositionObjectCompleteCallback(napi_env env, napi_status status, FetchFileResultAsyncContext* context)
494 {
495     MediaLibraryTracer tracer;
496     tracer.Start("GetPositionObjectCompleteCallback");
497 
498     CHECK_NULL_PTR_RETURN_VOID(context, "Async context is null");
499 
500     unique_ptr<JSAsyncContextOutput> jsContext = make_unique<JSAsyncContextOutput>();
501     jsContext->status = false;
502 
503     GetNapiResFromAsset(env, context, jsContext);
504 
505     if (context->work != nullptr) {
506         MediaLibraryNapiUtils::InvokeJSAsyncMethod(env, context->deferred, context->callbackRef,
507                                                    context->work, *jsContext);
508     }
509 
510     delete context;
511 }
512 
JSGetFirstObject(napi_env env,napi_callback_info info)513 napi_value FetchFileResultNapi::JSGetFirstObject(napi_env env, napi_callback_info info)
514 {
515     napi_status status;
516     napi_value result = nullptr;
517     const int32_t refCount = 1;
518     napi_value resource = nullptr;
519     size_t argc = ARGS_ONE;
520     napi_value argv[ARGS_ONE] = {0};
521     napi_value thisVar = nullptr;
522 
523     GET_JS_ARGS(env, info, argc, argv, thisVar);
524     NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameter");
525     napi_get_undefined(env, &result);
526 
527     unique_ptr<FetchFileResultAsyncContext> asyncContext = make_unique<FetchFileResultAsyncContext>();
528     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&asyncContext->objectInfo));
529     if (status == napi_ok && CheckIfFFRNapiNotEmpty(asyncContext->objectInfo)) {
530         if (argc == ARGS_ONE) {
531             GET_JS_ASYNC_CB_REF(env, argv[PARAM0], refCount, asyncContext->callbackRef);
532         }
533 
534         NAPI_CREATE_PROMISE(env, asyncContext->callbackRef, asyncContext->deferred, result);
535         NAPI_CREATE_RESOURCE_NAME(env, resource, "JSGetFirstObject", asyncContext);
536 
537         asyncContext->objectPtr = asyncContext->objectInfo->propertyPtr;
538         CHECK_NULL_PTR_RETURN_UNDEFINED(env, asyncContext->objectPtr, result, "propertyPtr is nullptr");
539 
540         status = napi_create_async_work(
541             env, nullptr, resource, [](napi_env env, void *data) {
542                 auto context = static_cast<FetchFileResultAsyncContext*>(data);
543                 context->GetFirstAsset();
544             },
545             reinterpret_cast<napi_async_complete_callback>(GetPositionObjectCompleteCallback),
546             static_cast<void *>(asyncContext.get()), &asyncContext->work);
547         if (status != napi_ok) {
548             napi_get_undefined(env, &result);
549         } else {
550             napi_queue_async_work(env, asyncContext->work);
551             asyncContext.release();
552         }
553     } else {
554         NAPI_ERR_LOG("JSGetFirstObject obj == nullptr, status: %{public}d", status);
555         NAPI_ASSERT(env, false, "JSGetFirstObject obj == nullptr");
556     }
557 
558     return result;
559 }
560 
JSGetNextObject(napi_env env,napi_callback_info info)561 napi_value FetchFileResultNapi::JSGetNextObject(napi_env env, napi_callback_info info)
562 {
563     napi_status status;
564     napi_value result = nullptr;
565     const int32_t refCount = 1;
566     napi_value resource = nullptr;
567     size_t argc = ARGS_ONE;
568     napi_value argv[ARGS_ONE] = {0};
569     napi_value thisVar = nullptr;
570 
571     GET_JS_ARGS(env, info, argc, argv, thisVar);
572     NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameter");
573 
574     napi_get_undefined(env, &result);
575     unique_ptr<FetchFileResultAsyncContext> asyncContext = make_unique<FetchFileResultAsyncContext>();
576     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&asyncContext->objectInfo));
577     if (status == napi_ok && CheckIfFFRNapiNotEmpty(asyncContext->objectInfo)) {
578         if (argc == ARGS_ONE) {
579             GET_JS_ASYNC_CB_REF(env, argv[PARAM0], refCount, asyncContext->callbackRef);
580         }
581 
582         NAPI_CREATE_PROMISE(env, asyncContext->callbackRef, asyncContext->deferred, result);
583         NAPI_CREATE_RESOURCE_NAME(env, resource, "JSGetNextObject", asyncContext);
584 
585         asyncContext->objectPtr = asyncContext->objectInfo->propertyPtr;
586         CHECK_NULL_PTR_RETURN_UNDEFINED(env, asyncContext->objectPtr, result, "propertyPtr is nullptr");
587 
588         status = napi_create_async_work(
589             env, nullptr, resource, [](napi_env env, void *data) {
590                 auto context = static_cast<FetchFileResultAsyncContext*>(data);
591                 context->GetNextObject();
592             },
593             reinterpret_cast<napi_async_complete_callback>(GetPositionObjectCompleteCallback),
594             static_cast<void *>(asyncContext.get()), &asyncContext->work);
595         if (status != napi_ok) {
596             napi_get_undefined(env, &result);
597         } else {
598             napi_queue_async_work(env, asyncContext->work);
599             asyncContext.release();
600         }
601     } else {
602         NAPI_ERR_LOG("JSGetNextObject obj == nullptr, status: %{public}d", status);
603         NAPI_ASSERT(env, false, "JSGetNextObject obj == nullptr");
604     }
605 
606     return result;
607 }
608 
JSGetLastObject(napi_env env,napi_callback_info info)609 napi_value FetchFileResultNapi::JSGetLastObject(napi_env env, napi_callback_info info)
610 {
611     napi_status status;
612     napi_value result = nullptr;
613     const int32_t refCount = 1;
614     napi_value resource = nullptr;
615     size_t argc = ARGS_ONE;
616     napi_value argv[ARGS_ONE] = {0};
617     napi_value thisVar = nullptr;
618 
619     GET_JS_ARGS(env, info, argc, argv, thisVar);
620     NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameter");
621 
622     napi_get_undefined(env, &result);
623     unique_ptr<FetchFileResultAsyncContext> asyncContext = make_unique<FetchFileResultAsyncContext>();
624     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&asyncContext->objectInfo));
625     if (status == napi_ok && CheckIfFFRNapiNotEmpty(asyncContext->objectInfo)) {
626         if (argc == ARGS_ONE) {
627             GET_JS_ASYNC_CB_REF(env, argv[PARAM0], refCount, asyncContext->callbackRef);
628         }
629 
630         NAPI_CREATE_PROMISE(env, asyncContext->callbackRef, asyncContext->deferred, result);
631         NAPI_CREATE_RESOURCE_NAME(env, resource, "JSGetLastObject", asyncContext);
632 
633         asyncContext->objectPtr = asyncContext->objectInfo->propertyPtr;
634         CHECK_NULL_PTR_RETURN_UNDEFINED(env, asyncContext->objectPtr, result, "propertyPtr is nullptr");
635 
636         status = napi_create_async_work(
637             env, nullptr, resource, [](napi_env env, void *data) {
638                 auto context = static_cast<FetchFileResultAsyncContext*>(data);
639                 context->GetLastObject();
640             },
641             reinterpret_cast<napi_async_complete_callback>(GetPositionObjectCompleteCallback),
642             static_cast<void *>(asyncContext.get()), &asyncContext->work);
643         if (status != napi_ok) {
644             napi_get_undefined(env, &result);
645         } else {
646             napi_queue_async_work(env, asyncContext->work);
647             asyncContext.release();
648         }
649     } else {
650         NAPI_ERR_LOG("JSGetLastObject obj == nullptr, status: %{public}d", status);
651         NAPI_ASSERT(env, false, "JSGetLastObject obj == nullptr");
652     }
653 
654     return result;
655 }
656 
JSGetPositionObject(napi_env env,napi_callback_info info)657 napi_value FetchFileResultNapi::JSGetPositionObject(napi_env env, napi_callback_info info)
658 {
659     napi_status status;
660     napi_value result = nullptr;
661     const int32_t refCount = 1;
662     napi_valuetype type = napi_undefined;
663     napi_value resource = nullptr;
664     size_t argc = ARGS_TWO;
665     napi_value argv[ARGS_TWO] = {0};
666     napi_value thisVar = nullptr;
667 
668     MediaLibraryTracer tracer;
669     tracer.Start("JSGetPositionObject");
670 
671     GET_JS_ARGS(env, info, argc, argv, thisVar);
672     NAPI_ASSERT(env, (argc == ARGS_ONE || argc == ARGS_TWO), "requires 2 parameter maximum");
673 
674     napi_get_undefined(env, &result);
675     unique_ptr<FetchFileResultAsyncContext> asyncContext = make_unique<FetchFileResultAsyncContext>();
676     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&asyncContext->objectInfo));
677     if (status == napi_ok && CheckIfFFRNapiNotEmpty(asyncContext->objectInfo)) {
678         // Check the arguments and their types
679         napi_typeof(env, argv[PARAM0], &type);
680         if (type == napi_number) {
681             napi_get_value_int32(env, argv[PARAM0], &(asyncContext->position));
682         } else {
683             NAPI_ERR_LOG("Argument mismatch, type: %{public}d", type);
684             return result;
685         }
686 
687         if (argc == ARGS_TWO) {
688             GET_JS_ASYNC_CB_REF(env, argv[PARAM1], refCount, asyncContext->callbackRef);
689         }
690 
691         NAPI_CREATE_PROMISE(env, asyncContext->callbackRef, asyncContext->deferred, result);
692         NAPI_CREATE_RESOURCE_NAME(env, resource, "JSGetPositionObject", asyncContext);
693 
694         asyncContext->objectPtr = asyncContext->objectInfo->propertyPtr;
695         CHECK_NULL_PTR_RETURN_UNDEFINED(env, asyncContext->objectPtr, result, "propertyPtr is nullptr");
696 
697         status = napi_create_async_work(
698             env, nullptr, resource, [](napi_env env, void *data) {
699                 auto context = static_cast<FetchFileResultAsyncContext*>(data);
700                 context->GetObjectAtPosition();
701             },
702             reinterpret_cast<napi_async_complete_callback>(GetPositionObjectCompleteCallback),
703             static_cast<void *>(asyncContext.get()), &asyncContext->work);
704         if (status != napi_ok) {
705             napi_get_undefined(env, &result);
706         } else {
707             napi_queue_async_work(env, asyncContext->work);
708             asyncContext.release();
709         }
710     } else {
711         NAPI_ERR_LOG("JSGetPositionObject obj == nullptr, status: %{public}d", status);
712         NAPI_ASSERT(env, false, "JSGetPositionObject obj == nullptr");
713     }
714 
715     return result;
716 }
717 
GetAsset(napi_env env,vector<std::unique_ptr<FileAsset>> & array,int index)718 static napi_value GetAsset(napi_env env, vector<std::unique_ptr<FileAsset>> &array, int index)
719 {
720     return FileAssetNapi::CreateFileAsset(env, array[index]);
721 }
722 
GetAsset(napi_env env,vector<std::unique_ptr<AlbumAsset>> & array,int index)723 static napi_value GetAsset(napi_env env, vector<std::unique_ptr<AlbumAsset>> &array, int index)
724 {
725     return AlbumNapi::CreateAlbumNapi(env, array[index]);
726 }
727 
GetAsset(napi_env env,vector<std::unique_ptr<PhotoAlbum>> & array,int index)728 static napi_value GetAsset(napi_env env, vector<std::unique_ptr<PhotoAlbum>> &array, int index)
729 {
730     return PhotoAlbumNapi::CreatePhotoAlbumNapi(env, array[index]);
731 }
732 
GetAsset(napi_env env,vector<std::unique_ptr<SmartAlbumAsset>> & array,int index)733 static napi_value GetAsset(napi_env env, vector<std::unique_ptr<SmartAlbumAsset>> &array, int index)
734 {
735     return SmartAlbumNapi::CreateSmartAlbumNapi(env, array[index]);
736 }
737 
738 template<class T>
GetAssetFromArray(napi_env env,FetchFileResultAsyncContext * context,T & array,unique_ptr<JSAsyncContextOutput> & jsContext)739 static void GetAssetFromArray(napi_env env, FetchFileResultAsyncContext* context, T& array,
740     unique_ptr<JSAsyncContextOutput> &jsContext)
741 {
742     napi_value jsFileArray = nullptr;
743     napi_create_array_with_length(env, array.size(), &jsFileArray);
744     napi_value jsFileAsset = nullptr;
745     size_t i = 0;
746     for (i = 0; i < array.size(); i++) {
747         jsFileAsset = GetAsset(env, array, i);
748         if ((jsFileAsset == nullptr) || (napi_set_element(env, jsFileArray, i, jsFileAsset) != napi_ok)) {
749             NAPI_ERR_LOG("Failed to get file asset napi object");
750             napi_get_undefined(env, &jsContext->data);
751             MediaLibraryNapiUtils::CreateNapiErrorObject(env, jsContext->error, ERR_MEM_ALLOCATION,
752                 "Failed to create js object");
753             break;
754         }
755     }
756     if (i == array.size()) {
757         jsContext->data = jsFileArray;
758         napi_get_undefined(env, &jsContext->error);
759         jsContext->status = true;
760     }
761 }
762 
GetAllObjectCompleteCallback(napi_env env,napi_status status,FetchFileResultAsyncContext * context)763 static void GetAllObjectCompleteCallback(napi_env env, napi_status status, FetchFileResultAsyncContext* context)
764 {
765     MediaLibraryTracer tracer;
766     tracer.Start("GetAllObjectCompleteCallback");
767     CHECK_NULL_PTR_RETURN_VOID(context, "Async context is null");
768     unique_ptr<JSAsyncContextOutput> jsContext = make_unique<JSAsyncContextOutput>();
769     jsContext->status = false;
770 
771     switch (context->objectPtr->fetchResType_) {
772         case FetchResType::TYPE_FILE:
773             GetAssetFromArray(env, context, context->fileAssetArray, jsContext);
774             break;
775         case FetchResType::TYPE_ALBUM:
776             GetAssetFromArray(env, context, context->fileAlbumArray, jsContext);
777             break;
778         case FetchResType::TYPE_PHOTOALBUM:
779             GetAssetFromArray(env, context, context->filePhotoAlbumArray, jsContext);
780             break;
781         case FetchResType::TYPE_SMARTALBUM:
782             GetAssetFromArray(env, context, context->fileSmartAlbumArray, jsContext);
783             break;
784         default:
785             NAPI_ERR_LOG("unsupported FetchResType");
786             napi_get_undefined(env, &jsContext->data);
787             MediaLibraryNapiUtils::CreateNapiErrorObject(env, jsContext->error, ERR_INVALID_OUTPUT,
788                 "Failed to obtain fileAsset array from DB");
789     }
790 
791     if (context->work != nullptr) {
792         MediaLibraryNapiUtils::InvokeJSAsyncMethod(env, context->deferred, context->callbackRef,
793                                                    context->work, *jsContext);
794     }
795 
796     delete context;
797 }
798 
GetFetchFileResultObject()799 std::shared_ptr<FetchResult<FileAsset>> FetchFileResultNapi::GetFetchFileResultObject()
800 {
801     return propertyPtr->fetchFileResult_;
802 }
803 
GetFetchAlbumResultObject()804 std::shared_ptr<FetchResult<AlbumAsset>> FetchFileResultNapi::GetFetchAlbumResultObject()
805 {
806     return propertyPtr->fetchAlbumResult_;
807 }
808 
GetFetchPhotoAlbumResultObject()809 std::shared_ptr<FetchResult<PhotoAlbum>> FetchFileResultNapi::GetFetchPhotoAlbumResultObject()
810 {
811     return propertyPtr->fetchPhotoAlbumResult_;
812 }
813 
GetFetchSmartAlbumResultObject()814 std::shared_ptr<FetchResult<SmartAlbumAsset>> FetchFileResultNapi::GetFetchSmartAlbumResultObject()
815 {
816     return propertyPtr->fetchSmartAlbumResult_;
817 }
818 
GetAllObjectFromFetchResult(const FetchFileResultAsyncContext & asyncContext)819 void GetAllObjectFromFetchResult(const FetchFileResultAsyncContext &asyncContext)
820 {
821     MediaLibraryTracer tracer;
822     tracer.Start("GetAllObjectFromFetchResult");
823 
824     FetchFileResultAsyncContext *context = const_cast<FetchFileResultAsyncContext *>(&asyncContext);
825     context->GetAllObjectFromFetchResult();
826 }
827 
JSGetAllObject(napi_env env,napi_callback_info info)828 napi_value FetchFileResultNapi::JSGetAllObject(napi_env env, napi_callback_info info)
829 {
830     napi_status status;
831     napi_value result = nullptr;
832     const int32_t refCount = 1;
833     napi_value resource = nullptr;
834     size_t argc = ARGS_ONE;
835     napi_value argv[ARGS_ONE] = {0};
836     napi_value thisVar = nullptr;
837 
838     MediaLibraryTracer tracer;
839     tracer.Start("JSGetAllObject");
840 
841     GET_JS_ARGS(env, info, argc, argv, thisVar);
842     NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameter maximum");
843 
844     napi_get_undefined(env, &result);
845     unique_ptr<FetchFileResultAsyncContext> asyncContext = make_unique<FetchFileResultAsyncContext>();
846     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&asyncContext->objectInfo));
847     if (status == napi_ok && CheckIfFFRNapiNotEmpty(asyncContext->objectInfo)) {
848         if (argc == ARGS_ONE) {
849             GET_JS_ASYNC_CB_REF(env, argv[PARAM0], refCount, asyncContext->callbackRef);
850         }
851 
852         NAPI_CREATE_PROMISE(env, asyncContext->callbackRef, asyncContext->deferred, result);
853         NAPI_CREATE_RESOURCE_NAME(env, resource, "JSGetAllObject", asyncContext);
854 
855         asyncContext->objectPtr = asyncContext->objectInfo->propertyPtr;
856         CHECK_NULL_PTR_RETURN_UNDEFINED(env, asyncContext->objectPtr, result, "propertyPtr is nullptr");
857 
858         status = napi_create_async_work(
859             env, nullptr, resource, [](napi_env env, void *data) {
860                 auto context = static_cast<FetchFileResultAsyncContext*>(data);
861                 GetAllObjectFromFetchResult(*context);
862             },
863             reinterpret_cast<napi_async_complete_callback>(GetAllObjectCompleteCallback),
864             static_cast<void *>(asyncContext.get()), &asyncContext->work);
865         if (status != napi_ok) {
866             napi_get_undefined(env, &result);
867         } else {
868             napi_queue_async_work(env, asyncContext->work);
869             asyncContext.release();
870         }
871     } else {
872         NAPI_ERR_LOG("JSGetAllObject obj == nullptr, status: %{public}d", status);
873         NAPI_ASSERT(env, false, "JSGetAllObject obj == nullptr");
874     }
875 
876     return result;
877 }
878 
JSClose(napi_env env,napi_callback_info info)879 napi_value FetchFileResultNapi::JSClose(napi_env env, napi_callback_info info)
880 {
881     napi_status status;
882     napi_value jsResult = nullptr;
883     FetchFileResultNapi* obj = nullptr;
884     napi_value thisVar = nullptr;
885 
886     MediaLibraryTracer tracer;
887     tracer.Start("JSClose");
888 
889     napi_get_undefined(env, &jsResult);
890     GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
891     if (status != napi_ok || thisVar == nullptr) {
892         NAPI_ERR_LOG("Invalid arguments!, status: %{public}d", status);
893         return jsResult;
894     }
895     status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
896     if ((status == napi_ok) && (obj != nullptr)) {
897         obj->propertyPtr = nullptr;
898     }
899     status = napi_remove_wrap(env, thisVar, reinterpret_cast<void **>(&obj));
900     if ((status == napi_ok) && (obj != nullptr)) {
901         napi_create_int32(env, SUCCESS, &jsResult);
902     } else {
903         NAPI_INFO_LOG("JSClose obj == nullptr");
904     }
905 
906     NAPI_DEBUG_LOG("JSClose OUT!");
907     return jsResult;
908 }
909 
GetFirstAsset()910 void FetchFileResultAsyncContext::GetFirstAsset()
911 {
912     switch (objectPtr->fetchResType_) {
913         case FetchResType::TYPE_FILE: {
914             fileAsset = objectPtr->fetchFileResult_->GetFirstObject();
915             break;
916         }
917         case FetchResType::TYPE_ALBUM: {
918             albumAsset = objectPtr->fetchAlbumResult_->GetFirstObject();
919             break;
920         }
921         case FetchResType::TYPE_PHOTOALBUM: {
922             photoAlbum = objectPtr->fetchPhotoAlbumResult_->GetFirstObject();
923             break;
924         }
925         case FetchResType::TYPE_SMARTALBUM: {
926             smartAlbumAsset = objectPtr->fetchSmartAlbumResult_->GetFirstObject();
927             break;
928         }
929         default:
930             NAPI_ERR_LOG("unsupported FetchResType");
931             break;
932     }
933 }
934 
GetObjectAtPosition()935 void FetchFileResultAsyncContext::GetObjectAtPosition()
936 {
937     switch (objectPtr->fetchResType_) {
938         case FetchResType::TYPE_FILE: {
939             fileAsset = objectPtr->fetchFileResult_->GetObjectAtPosition(position);
940             break;
941         }
942         case FetchResType::TYPE_ALBUM: {
943             albumAsset = objectPtr->fetchAlbumResult_->GetObjectAtPosition(position);
944             break;
945         }
946         case FetchResType::TYPE_PHOTOALBUM: {
947             photoAlbum = objectPtr->fetchPhotoAlbumResult_->GetObjectAtPosition(position);
948             break;
949         }
950         case FetchResType::TYPE_SMARTALBUM: {
951             smartAlbumAsset = objectPtr->fetchSmartAlbumResult_->GetObjectAtPosition(position);
952             break;
953         }
954         default:
955             NAPI_ERR_LOG("unsupported FetchResType");
956             break;
957     }
958 }
959 
GetLastObject()960 void FetchFileResultAsyncContext::GetLastObject()
961 {
962     switch (objectPtr->fetchResType_) {
963         case FetchResType::TYPE_FILE: {
964             fileAsset = objectPtr->fetchFileResult_->GetLastObject();
965             break;
966         }
967         case FetchResType::TYPE_ALBUM: {
968             albumAsset = objectPtr->fetchAlbumResult_->GetLastObject();
969             break;
970         }
971         case FetchResType::TYPE_PHOTOALBUM: {
972             photoAlbum = objectPtr->fetchPhotoAlbumResult_->GetLastObject();
973             break;
974         }
975         case FetchResType::TYPE_SMARTALBUM: {
976             smartAlbumAsset = objectPtr->fetchSmartAlbumResult_->GetLastObject();
977             break;
978         }
979         default:
980             NAPI_ERR_LOG("unsupported FetchResType");
981             break;
982     }
983 }
984 
GetNextObject()985 void FetchFileResultAsyncContext::GetNextObject()
986 {
987     switch (objectPtr->fetchResType_) {
988         case FetchResType::TYPE_FILE: {
989             fileAsset = objectPtr->fetchFileResult_->GetNextObject();
990             break;
991         }
992         case FetchResType::TYPE_ALBUM: {
993             albumAsset = objectPtr->fetchAlbumResult_->GetNextObject();
994             break;
995         }
996         case FetchResType::TYPE_PHOTOALBUM: {
997             photoAlbum = objectPtr->fetchPhotoAlbumResult_->GetNextObject();
998             break;
999         }
1000         case FetchResType::TYPE_SMARTALBUM: {
1001             smartAlbumAsset = objectPtr->fetchSmartAlbumResult_->GetNextObject();
1002             break;
1003         }
1004         default:
1005             NAPI_ERR_LOG("unsupported FetchResType");
1006             break;
1007     }
1008 }
1009 
GetAllObjectFromFetchResult()1010 void FetchFileResultAsyncContext::GetAllObjectFromFetchResult()
1011 {
1012     switch (objectPtr->fetchResType_) {
1013         case FetchResType::TYPE_FILE: {
1014             auto fetchResult = objectPtr->fetchFileResult_;
1015             auto file = fetchResult->GetFirstObject();
1016             while (file != nullptr) {
1017                 fileAssetArray.push_back(move(file));
1018                 file = fetchResult->GetNextObject();
1019             }
1020             break;
1021         }
1022         case FetchResType::TYPE_ALBUM: {
1023             auto fetchResult = objectPtr->fetchAlbumResult_;
1024             auto album = fetchResult->GetFirstObject();
1025             while (album != nullptr) {
1026                 fileAlbumArray.push_back(move(album));
1027                 album = fetchResult->GetNextObject();
1028             }
1029             break;
1030         }
1031         case FetchResType::TYPE_PHOTOALBUM: {
1032             auto fetchResult = objectPtr->fetchPhotoAlbumResult_;
1033             auto photoAlbum = fetchResult->GetFirstObject();
1034             while (photoAlbum != nullptr) {
1035                 filePhotoAlbumArray.push_back(move(photoAlbum));
1036                 photoAlbum = fetchResult->GetNextObject();
1037             }
1038             break;
1039         }
1040         case FetchResType::TYPE_SMARTALBUM: {
1041             auto fetchResult = objectPtr->fetchSmartAlbumResult_;
1042             auto smartAlbum = fetchResult->GetFirstObject();
1043             while (smartAlbum != nullptr) {
1044                 fileSmartAlbumArray.push_back(move(smartAlbum));
1045                 smartAlbum = fetchResult->GetNextObject();
1046             }
1047             break;
1048         }
1049         default:
1050             NAPI_ERR_LOG("unsupported FetchResType");
1051             break;
1052     }
1053 }
1054 
CheckIfPropertyPtrNull()1055 bool FetchFileResultNapi::CheckIfPropertyPtrNull()
1056 {
1057     return propertyPtr == nullptr;
1058 }
1059 } // namespace Media
1060 } // namespace OHOS