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