1 /*
2  * Copyright (C) 2024 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 "SendablePhotoAlbumNapi"
16 
17 #include "sendable_photo_album_napi.h"
18 
19 #include <nlohmann/json.hpp>
20 
21 #include "media_file_utils.h"
22 #include "photo_album_napi.h"
23 #include "medialibrary_client_errno.h"
24 #include "medialibrary_napi_log.h"
25 #include "medialibrary_napi_utils.h"
26 #include "medialibrary_tracer.h"
27 #include "photo_map_column.h"
28 #include "result_set_utils.h"
29 #include "sendable_photo_access_helper_napi.h"
30 #include "sendable_medialibrary_napi_utils.h"
31 #include "sendable_fetch_file_result_napi.h"
32 #include "sendable_file_asset_napi.h"
33 #include "userfile_client.h"
34 
35 using namespace std;
36 using namespace OHOS::DataShare;
37 
38 namespace OHOS::Media {
39 thread_local PhotoAlbum *SendablePhotoAlbumNapi::pAlbumData_ = nullptr;
40 thread_local napi_ref SendablePhotoAlbumNapi::photoAccessConstructor_ = nullptr;
41 static const string PHOTO_ALBUM_CLASS = "UserFileMgrPhotoAlbum";
42 static const string PHOTOACCESS_PHOTO_ALBUM_CLASS = "PhotoAccessPhotoAlbum";
43 static const string COUNT_GROUP_BY = "count(*) AS count";
44 
45 using CompleteCallback = napi_async_complete_callback;
46 
SendablePhotoAlbumNapi()47 SendablePhotoAlbumNapi::SendablePhotoAlbumNapi() : env_(nullptr) {}
48 
49 SendablePhotoAlbumNapi::~SendablePhotoAlbumNapi() = default;
50 
51 
PhotoAccessInit(napi_env env,napi_value exports)52 napi_value SendablePhotoAlbumNapi::PhotoAccessInit(napi_env env, napi_value exports)
53 {
54     napi_value ctorObj;
55     napi_property_descriptor props[] = {
56         DECLARE_NAPI_GETTER_SETTER("albumName", JSPhotoAccessGetAlbumName, JSPhotoAccessSetAlbumName),
57         DECLARE_NAPI_GETTER("albumUri", JSPhotoAccessGetAlbumUri),
58         DECLARE_NAPI_GETTER("count", JSPhotoAccessGetAlbumCount),
59         DECLARE_NAPI_GETTER("imageCount", JSPhotoAccessGetAlbumImageCount),
60         DECLARE_NAPI_GETTER("videoCount", JSPhotoAccessGetAlbumVideoCount),
61         DECLARE_NAPI_GETTER("albumType", JSGetPhotoAlbumType),
62         DECLARE_NAPI_GETTER("albumSubtype", JSGetPhotoAlbumSubType),
63         DECLARE_NAPI_GETTER("coverUri", JSGetCoverUri),
64         DECLARE_NAPI_FUNCTION("commitModify", PhotoAccessHelperCommitModify),
65         DECLARE_NAPI_FUNCTION("getAssets", JSPhotoAccessGetPhotoAssets),
66         DECLARE_NAPI_FUNCTION("convertToPhotoAlbum", ConvertToPhotoAlbum),
67         DECLARE_NAPI_FUNCTION("getFaceId", PhotoAccessHelperGetFaceId),
68         DECLARE_NAPI_FUNCTION("getSharedPhotoAssets", JSPhotoAccessGetSharedPhotoAssets),
69     };
70     napi_define_sendable_class(env, PHOTOACCESS_PHOTO_ALBUM_CLASS.c_str(), NAPI_AUTO_LENGTH,
71                                PhotoAlbumNapiConstructor, nullptr, sizeof(props) / sizeof(props[0]), props,
72                                nullptr, &ctorObj);
73     NAPI_CALL(env, napi_create_reference(env, ctorObj, NAPI_INIT_REF_COUNT, &photoAccessConstructor_));
74     NAPI_CALL(env, napi_set_named_property(env, exports, PHOTOACCESS_PHOTO_ALBUM_CLASS.c_str(), ctorObj));
75     return exports;
76 }
77 
CreatePhotoAlbumNapi(napi_env env,unique_ptr<PhotoAlbum> & albumData)78 napi_value SendablePhotoAlbumNapi::CreatePhotoAlbumNapi(napi_env env, unique_ptr<PhotoAlbum> &albumData)
79 {
80     if (albumData == nullptr) {
81         return nullptr;
82     }
83 
84     if (photoAccessConstructor_ == nullptr) {
85         napi_value exports = nullptr;
86         napi_create_object(env, &exports);
87         SendablePhotoAlbumNapi::PhotoAccessInit(env, exports);
88     }
89 
90     napi_value constructor;
91     napi_ref constructorRef = photoAccessConstructor_;
92 
93     CHECK_ARGS(env, napi_get_reference_value(env, constructorRef, &constructor), JS_INNER_FAIL);
94 
95     napi_value result = nullptr;
96     pAlbumData_ = albumData.release();
97     CHECK_ARGS(env, napi_new_instance(env, constructor, 0, nullptr, &result), JS_INNER_FAIL);
98     pAlbumData_ = nullptr;
99     return result;
100 }
101 
CreatePhotoAlbumNapi(napi_env env,shared_ptr<PhotoAlbum> & albumData)102 napi_value SendablePhotoAlbumNapi::CreatePhotoAlbumNapi(napi_env env, shared_ptr<PhotoAlbum>& albumData)
103 {
104     if (albumData == nullptr || albumData->GetResultNapiType() != ResultNapiType::TYPE_PHOTOACCESS_HELPER) {
105         NAPI_ERR_LOG("Unsupported photo album data");
106         return nullptr;
107     }
108 
109     if (photoAccessConstructor_ == nullptr) {
110         napi_value exports = nullptr;
111         napi_create_object(env, &exports);
112         SendablePhotoAlbumNapi::PhotoAccessInit(env, exports);
113     }
114 
115     napi_value constructor = nullptr;
116     napi_value result = nullptr;
117     CHECK_ARGS(env, napi_get_reference_value(env, photoAccessConstructor_, &constructor), JS_INNER_FAIL);
118     CHECK_ARGS(env, napi_new_instance(env, constructor, 0, nullptr, &result), JS_INNER_FAIL);
119     CHECK_COND(env, result != nullptr, JS_INNER_FAIL);
120 
121     SendablePhotoAlbumNapi* photoAlbumNapi = nullptr;
122     CHECK_ARGS(env, napi_unwrap_sendable(env, result, reinterpret_cast<void**>(&photoAlbumNapi)), JS_INNER_FAIL);
123     CHECK_COND(env, photoAlbumNapi != nullptr, JS_INNER_FAIL);
124     photoAlbumNapi->photoAlbumPtr = albumData;
125     return result;
126 }
127 
GetAlbumId() const128 int32_t SendablePhotoAlbumNapi::GetAlbumId() const
129 {
130     return photoAlbumPtr->GetAlbumId();
131 }
132 
GetCount() const133 int32_t SendablePhotoAlbumNapi::GetCount() const
134 {
135     return photoAlbumPtr->GetCount();
136 }
137 
SetCount(int32_t count)138 void SendablePhotoAlbumNapi::SetCount(int32_t count)
139 {
140     return photoAlbumPtr->SetCount(count);
141 }
142 
GetImageCount() const143 int32_t SendablePhotoAlbumNapi::GetImageCount() const
144 {
145     return photoAlbumPtr->GetImageCount();
146 }
147 
SetImageCount(int32_t count)148 void SendablePhotoAlbumNapi::SetImageCount(int32_t count)
149 {
150     return photoAlbumPtr->SetImageCount(count);
151 }
152 
GetVideoCount() const153 int32_t SendablePhotoAlbumNapi::GetVideoCount() const
154 {
155     return photoAlbumPtr->GetVideoCount();
156 }
157 
SetVideoCount(int32_t count)158 void SendablePhotoAlbumNapi::SetVideoCount(int32_t count)
159 {
160     return photoAlbumPtr->SetVideoCount(count);
161 }
162 
GetAlbumUri() const163 const string& SendablePhotoAlbumNapi::GetAlbumUri() const
164 {
165     return photoAlbumPtr->GetAlbumUri();
166 }
167 
GetCoverUri() const168 const string& SendablePhotoAlbumNapi::GetCoverUri() const
169 {
170     return photoAlbumPtr->GetCoverUri();
171 }
172 
GetDateModified() const173 int64_t SendablePhotoAlbumNapi::GetDateModified() const
174 {
175     return photoAlbumPtr->GetDateModified();
176 }
177 
GetAlbumName() const178 const string& SendablePhotoAlbumNapi::GetAlbumName() const
179 {
180     return photoAlbumPtr->GetAlbumName();
181 }
182 
GetPhotoAlbumType() const183 PhotoAlbumType SendablePhotoAlbumNapi::GetPhotoAlbumType() const
184 {
185     return photoAlbumPtr->GetPhotoAlbumType();
186 }
187 
GetPhotoAlbumSubType() const188 PhotoAlbumSubType SendablePhotoAlbumNapi::GetPhotoAlbumSubType() const
189 {
190     return photoAlbumPtr->GetPhotoAlbumSubType();
191 }
192 
GetLatitude() const193 double SendablePhotoAlbumNapi::GetLatitude() const
194 {
195     return photoAlbumPtr->GetLatitude();
196 }
197 
GetLongitude() const198 double SendablePhotoAlbumNapi::GetLongitude() const
199 {
200     return photoAlbumPtr->GetLongitude();
201 }
202 
GetPhotoAlbumInstance() const203 shared_ptr<PhotoAlbum> SendablePhotoAlbumNapi::GetPhotoAlbumInstance() const
204 {
205     return photoAlbumPtr;
206 }
207 
GetHiddenOnly() const208 bool SendablePhotoAlbumNapi::GetHiddenOnly() const
209 {
210     return photoAlbumPtr->GetHiddenOnly();
211 }
212 
SetHiddenOnly(const bool hiddenOnly_)213 void SendablePhotoAlbumNapi::SetHiddenOnly(const bool hiddenOnly_)
214 {
215     return photoAlbumPtr->SetHiddenOnly(hiddenOnly_);
216 }
217 
SetPhotoAlbumNapiProperties()218 void SendablePhotoAlbumNapi::SetPhotoAlbumNapiProperties()
219 {
220     photoAlbumPtr = shared_ptr<PhotoAlbum>(pAlbumData_);
221 }
222 
223 // Constructor callback
PhotoAlbumNapiConstructor(napi_env env,napi_callback_info info)224 napi_value SendablePhotoAlbumNapi::PhotoAlbumNapiConstructor(napi_env env, napi_callback_info info)
225 {
226     napi_value result = nullptr;
227     CHECK_ARGS(env, napi_get_undefined(env, &result), JS_INNER_FAIL);
228 
229     napi_value thisVar = nullptr;
230     CHECK_ARGS(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr), JS_INNER_FAIL);
231     if (thisVar == nullptr) {
232         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
233         return result;
234     }
235 
236     unique_ptr<SendablePhotoAlbumNapi> obj = make_unique<SendablePhotoAlbumNapi>();
237     obj->env_ = env;
238     if (pAlbumData_ != nullptr) {
239         obj->SetPhotoAlbumNapiProperties();
240     }
241     CHECK_ARGS(env, napi_wrap_sendable(env, thisVar, reinterpret_cast<void *>(obj.get()),
242         SendablePhotoAlbumNapi::PhotoAlbumNapiDestructor, nullptr), JS_INNER_FAIL);
243     obj.release();
244     return thisVar;
245 }
246 
PhotoAlbumNapiDestructor(napi_env env,void * nativeObject,void * finalizeHint)247 void SendablePhotoAlbumNapi::PhotoAlbumNapiDestructor(napi_env env, void *nativeObject, void *finalizeHint)
248 {
249     auto *album = reinterpret_cast<SendablePhotoAlbumNapi*>(nativeObject);
250     if (album != nullptr) {
251         delete album;
252         album = nullptr;
253     }
254 }
255 
UnwrapPhotoAlbumObject(napi_env env,napi_callback_info info,SendablePhotoAlbumNapi ** obj)256 napi_value UnwrapPhotoAlbumObject(napi_env env, napi_callback_info info, SendablePhotoAlbumNapi** obj)
257 {
258     napi_value result = nullptr;
259     CHECK_ARGS(env, napi_get_undefined(env, &result), JS_INNER_FAIL);
260 
261     napi_value thisVar = nullptr;
262     CHECK_ARGS(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr), JS_INNER_FAIL);
263     if (thisVar == nullptr) {
264         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
265         return result;
266     }
267 
268     CHECK_ARGS(env, napi_unwrap_sendable(env, thisVar, reinterpret_cast<void **>(obj)), JS_INNER_FAIL);
269     if (obj == nullptr) {
270         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
271         return result;
272     }
273 
274     CHECK_ARGS(env, napi_get_boolean(env, true, &result), JS_INNER_FAIL);
275     return result;
276 }
277 
JSPhotoAccessGetAlbumName(napi_env env,napi_callback_info info)278 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetAlbumName(napi_env env, napi_callback_info info)
279 {
280     SendablePhotoAlbumNapi *obj = nullptr;
281     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
282 
283     napi_value jsResult = nullptr;
284     CHECK_ARGS(env, napi_create_string_utf8(env, obj->GetAlbumName().c_str(), NAPI_AUTO_LENGTH, &jsResult),
285         JS_INNER_FAIL);
286     return jsResult;
287 }
288 
JSPhotoAccessGetAlbumUri(napi_env env,napi_callback_info info)289 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetAlbumUri(napi_env env, napi_callback_info info)
290 {
291     SendablePhotoAlbumNapi *obj = nullptr;
292     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
293 
294     napi_value jsResult = nullptr;
295     CHECK_ARGS(env, napi_create_string_utf8(env, obj->GetAlbumUri().c_str(), NAPI_AUTO_LENGTH, &jsResult),
296         JS_INNER_FAIL);
297     return jsResult;
298 }
299 
JSPhotoAccessGetAlbumCount(napi_env env,napi_callback_info info)300 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetAlbumCount(napi_env env, napi_callback_info info)
301 {
302     SendablePhotoAlbumNapi *obj = nullptr;
303     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
304 
305     napi_value jsResult = nullptr;
306     CHECK_ARGS(env, napi_create_int32(env, obj->GetCount(), &jsResult), JS_INNER_FAIL);
307     return jsResult;
308 }
309 
JSPhotoAccessGetAlbumImageCount(napi_env env,napi_callback_info info)310 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetAlbumImageCount(napi_env env, napi_callback_info info)
311 {
312     SendablePhotoAlbumNapi *obj = nullptr;
313     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
314 
315     napi_value jsResult = nullptr;
316     CHECK_ARGS(env, napi_create_int32(env, obj->GetImageCount(), &jsResult), JS_INNER_FAIL);
317     return jsResult;
318 }
319 
JSPhotoAccessGetAlbumVideoCount(napi_env env,napi_callback_info info)320 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetAlbumVideoCount(napi_env env, napi_callback_info info)
321 {
322     SendablePhotoAlbumNapi *obj = nullptr;
323     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
324 
325     napi_value jsResult = nullptr;
326     CHECK_ARGS(env, napi_create_int32(env, obj->GetVideoCount(), &jsResult), JS_INNER_FAIL);
327     return jsResult;
328 }
329 
JSGetPhotoAlbumType(napi_env env,napi_callback_info info)330 napi_value SendablePhotoAlbumNapi::JSGetPhotoAlbumType(napi_env env, napi_callback_info info)
331 {
332     SendablePhotoAlbumNapi *obj = nullptr;
333     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
334 
335     napi_value jsResult = nullptr;
336     CHECK_ARGS(env, napi_create_int32(env, obj->GetPhotoAlbumType(), &jsResult), JS_INNER_FAIL);
337     return jsResult;
338 }
339 
JSGetPhotoAlbumSubType(napi_env env,napi_callback_info info)340 napi_value SendablePhotoAlbumNapi::JSGetPhotoAlbumSubType(napi_env env, napi_callback_info info)
341 {
342     SendablePhotoAlbumNapi *obj = nullptr;
343     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
344 
345     napi_value jsResult = nullptr;
346     CHECK_ARGS(env, napi_create_int32(env, obj->GetPhotoAlbumSubType(), &jsResult), JS_INNER_FAIL);
347     return jsResult;
348 }
349 
JSGetCoverUri(napi_env env,napi_callback_info info)350 napi_value SendablePhotoAlbumNapi::JSGetCoverUri(napi_env env, napi_callback_info info)
351 {
352     SendablePhotoAlbumNapi *obj = nullptr;
353     CHECK_NULLPTR_RET(UnwrapPhotoAlbumObject(env, info, &obj));
354 
355     napi_value jsResult = nullptr;
356     CHECK_ARGS(env, napi_create_string_utf8(env, obj->GetCoverUri().c_str(), NAPI_AUTO_LENGTH, &jsResult),
357         JS_INNER_FAIL);
358     return jsResult;
359 }
360 
GetStringArg(napi_env env,napi_callback_info info,SendablePhotoAlbumNapi ** obj,string & output)361 napi_value GetStringArg(napi_env env, napi_callback_info info, SendablePhotoAlbumNapi **obj, string &output)
362 {
363     size_t argc = ARGS_ONE;
364     napi_value argv[ARGS_ONE];
365     napi_value thisVar = nullptr;
366     CHECK_ARGS(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr), JS_INNER_FAIL);
367     CHECK_COND(env, argc == ARGS_ONE, JS_ERR_PARAMETER_INVALID);
368 
369     napi_value result = nullptr;
370     CHECK_ARGS(env, napi_get_undefined(env, &result), JS_INNER_FAIL);
371     napi_valuetype valueType = napi_undefined;
372     if ((thisVar == nullptr) || (napi_typeof(env, argv[PARAM0], &valueType) != napi_ok) || (valueType != napi_string)) {
373         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
374         return result;
375     }
376 
377     size_t res = 0;
378     char buffer[FILENAME_MAX];
379     CHECK_ARGS(env, napi_get_value_string_utf8(env, argv[PARAM0], buffer, FILENAME_MAX, &res), JS_INNER_FAIL);
380     output = string(buffer);
381 
382     CHECK_ARGS(env, napi_unwrap_sendable(env, thisVar, reinterpret_cast<void **>(obj)), JS_INNER_FAIL);
383     if (obj == nullptr) {
384         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
385         return result;
386     }
387 
388     CHECK_ARGS(env, napi_get_boolean(env, true, &result), JS_INNER_FAIL);
389     return result;
390 }
391 
GetPredicatesByAlbumTypes(const shared_ptr<PhotoAlbum> & photoAlbum,DataSharePredicates & predicates,const bool hiddenOnly)392 static int32_t GetPredicatesByAlbumTypes(const shared_ptr<PhotoAlbum> &photoAlbum,
393     DataSharePredicates &predicates, const bool hiddenOnly)
394 {
395     auto albumId = photoAlbum->GetAlbumId();
396     auto subType = photoAlbum->GetPhotoAlbumSubType();
397     bool isLocationAlbum = subType == PhotoAlbumSubType::GEOGRAPHY_LOCATION;
398     if (albumId <= 0 && !isLocationAlbum) {
399         return E_INVALID_ARGUMENTS;
400     }
401     auto type = photoAlbum->GetPhotoAlbumType();
402     if ((!PhotoAlbum::CheckPhotoAlbumType(type)) || (!PhotoAlbum::CheckPhotoAlbumSubType(subType))) {
403         return E_INVALID_ARGUMENTS;
404     }
405 
406     if (type == PhotoAlbumType::SMART && subType == PhotoAlbumSubType::PORTRAIT) {
407         return SendableMediaLibraryNapiUtils::GetPortraitAlbumPredicates(photoAlbum->GetAlbumId(), predicates);
408     }
409 
410     if (PhotoAlbum::IsUserPhotoAlbum(type, subType)) {
411         return SendableMediaLibraryNapiUtils::GetUserAlbumPredicates(photoAlbum->GetAlbumId(), predicates, hiddenOnly);
412     }
413 
414     if (PhotoAlbum::IsSourceAlbum(type, subType)) {
415         return SendableMediaLibraryNapiUtils::GetSourceAlbumPredicates(photoAlbum->GetAlbumId(),
416             predicates, hiddenOnly);
417     }
418 
419     if (type == PhotoAlbumType::SMART) {
420         if (isLocationAlbum) {
421             return SendableMediaLibraryNapiUtils::GetAllLocationPredicates(predicates);
422         }
423         auto albumName = photoAlbum->GetAlbumName();
424         if (SendableMediaLibraryNapiUtils::IsFeaturedSinglePortraitAlbum(albumName, predicates)) {
425             return SendableMediaLibraryNapiUtils::GetFeaturedSinglePortraitAlbumPredicates(
426                 photoAlbum->GetAlbumId(), predicates);
427         }
428         return SendableMediaLibraryNapiUtils::GetAnalysisAlbumPredicates(photoAlbum->GetAlbumId(), predicates);
429     }
430 
431     if ((type != PhotoAlbumType::SYSTEM) || (subType == PhotoAlbumSubType::USER_GENERIC) ||
432         (subType == PhotoAlbumSubType::ANY)) {
433         return E_INVALID_ARGUMENTS;
434     }
435     return SendableMediaLibraryNapiUtils::GetSystemAlbumPredicates(subType, predicates, hiddenOnly);
436 }
437 
ParseArgsGetPhotoAssets(napi_env env,napi_callback_info info,unique_ptr<SendablePhotoAlbumNapiAsyncContext> & context)438 static napi_value ParseArgsGetPhotoAssets(napi_env env, napi_callback_info info,
439     unique_ptr<SendablePhotoAlbumNapiAsyncContext> &context)
440 {
441     constexpr size_t minArgs = ARGS_ONE;
442     constexpr size_t maxArgs = ARGS_TWO;
443     CHECK_ARGS(env, SendableMediaLibraryNapiUtils::AsyncContextSetObjectInfo(env, info, context, minArgs, maxArgs),
444         JS_ERR_PARAMETER_INVALID);
445 
446     /* Parse the first argument */
447     CHECK_ARGS(env, SendableMediaLibraryNapiUtils::GetFetchOption(env, context->argv[PARAM0], ASSET_FETCH_OPT, context),
448         JS_INNER_FAIL);
449 
450     auto photoAlbum = context->objectInfo->GetPhotoAlbumInstance();
451     auto ret = GetPredicatesByAlbumTypes(photoAlbum, context->predicates, photoAlbum->GetHiddenOnly());
452     if (ret != E_SUCCESS) {
453         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
454         return nullptr;
455     }
456     CHECK_NULLPTR_RET(SendableMediaLibraryNapiUtils::AddDefaultAssetColumns(env, context->fetchColumn,
457         PhotoColumn::IsPhotoColumn, NapiAssetType::TYPE_PHOTO));
458     if (photoAlbum->GetHiddenOnly() || photoAlbum->GetPhotoAlbumSubType() == PhotoAlbumSubType::HIDDEN) {
459         if (!SendableMediaLibraryNapiUtils::IsSystemApp()) {
460             NapiError::ThrowError(env, E_CHECK_SYSTEMAPP_FAIL, "This interface can be called only by system apps");
461             return nullptr;
462         }
463         // sort by hidden time desc if is hidden asset
464         context->predicates.IndexedBy(PhotoColumn::PHOTO_HIDDEN_TIME_INDEX);
465     }
466 
467     napi_value result = nullptr;
468     CHECK_ARGS(env, napi_get_boolean(env, true, &result), JS_INNER_FAIL);
469     return result;
470 }
471 
ConvertColumnsForPortrait(SendablePhotoAlbumNapiAsyncContext * context)472 void ConvertColumnsForPortrait(SendablePhotoAlbumNapiAsyncContext *context)
473 {
474     if (context == nullptr) {
475         return;
476     }
477     auto photoAlbum = context->objectInfo->GetPhotoAlbumInstance();
478     if (photoAlbum != nullptr && photoAlbum->GetPhotoAlbumSubType() == PhotoAlbumSubType::PORTRAIT) {
479         for (size_t i = 0; i < context->fetchColumn.size(); i++) {
480             context->fetchColumn[i] = PhotoColumn::PHOTOS_TABLE + "." + context->fetchColumn[i];
481         }
482     }
483 }
484 
ConvertColumnsForFeaturedSinglePortrait(SendablePhotoAlbumNapiAsyncContext * context)485 void ConvertColumnsForFeaturedSinglePortrait(SendablePhotoAlbumNapiAsyncContext *context)
486 {
487     if (context == nullptr) {
488         return;
489     }
490 
491     auto photoAlbum = context->objectInfo->GetPhotoAlbumInstance();
492     int portraitAlbumId = 0;
493     if (photoAlbum->GetPhotoAlbumSubType() != PhotoAlbumSubType::CLASSIFY ||
494         photoAlbum->GetAlbumName().compare(to_string(portraitAlbumId)) != 0) {
495         return;
496     }
497 
498     for (size_t i = 0; i < context->fetchColumn.size(); i++) {
499         context->fetchColumn[i] = PhotoColumn::PHOTOS_TABLE + "." + context->fetchColumn[i];
500     }
501 }
502 
JSPhotoAccessGetPhotoAssetsExecute(napi_env env,void * data)503 static void JSPhotoAccessGetPhotoAssetsExecute(napi_env env, void *data)
504 {
505     MediaLibraryTracer tracer;
506     tracer.Start("JSPhotoAccessGetPhotoAssetsExecute");
507 
508     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext *>(data);
509     Uri uri(PAH_QUERY_PHOTO_MAP);
510     ConvertColumnsForPortrait(context);
511     ConvertColumnsForFeaturedSinglePortrait(context);
512     int32_t errCode = 0;
513     auto resultSet = UserFileClient::Query(uri, context->predicates, context->fetchColumn, errCode);
514     if (resultSet == nullptr) {
515         context->SaveError(E_HAS_DB_ERROR);
516         return;
517     }
518     context->fetchResult = make_unique<FetchResult<FileAsset>>(move(resultSet));
519     context->fetchResult->SetResultNapiType(ResultNapiType::TYPE_PHOTOACCESS_HELPER);
520 }
521 
GetPhotoMapQueryResult(napi_env env,SendablePhotoAlbumNapiAsyncContext * context,unique_ptr<SendableJSAsyncContextOutput> & jsContext)522 static void GetPhotoMapQueryResult(napi_env env, SendablePhotoAlbumNapiAsyncContext *context,
523     unique_ptr<SendableJSAsyncContextOutput> &jsContext)
524 {
525     napi_value fetchRes = SendableFetchFileResultNapi::CreateFetchFileResult(env, move(context->fetchResult));
526     if (fetchRes == nullptr) {
527         SendableMediaLibraryNapiUtils::CreateNapiErrorObject(env, jsContext->error, ERR_MEM_ALLOCATION,
528             "Failed to create js object for FetchFileResult");
529         return;
530     }
531     jsContext->data = fetchRes;
532     jsContext->status = true;
533 }
534 
JSGetPhotoAssetsCallbackComplete(napi_env env,napi_status status,void * data)535 static void JSGetPhotoAssetsCallbackComplete(napi_env env, napi_status status, void *data)
536 {
537     MediaLibraryTracer tracer;
538     tracer.Start("JSGetPhotoAssetsCallbackComplete");
539 
540     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext *>(data);
541 
542     unique_ptr<SendableJSAsyncContextOutput> jsContext = make_unique<SendableJSAsyncContextOutput>();
543     jsContext->status = false;
544 
545     CHECK_ARGS_RET_VOID(env, napi_get_undefined(env, &jsContext->data), JS_INNER_FAIL);
546     CHECK_ARGS_RET_VOID(env, napi_get_undefined(env, &jsContext->error), JS_INNER_FAIL);
547     if (context->fetchResult != nullptr) {
548         GetPhotoMapQueryResult(env, context, jsContext);
549     } else {
550         NAPI_ERR_LOG("No fetch file result found!");
551         SendableMediaLibraryNapiUtils::CreateNapiErrorObject(env, jsContext->error, ERR_INVALID_OUTPUT,
552             "Failed to get fetchFileResult from DB");
553     }
554 
555     tracer.Finish();
556     if (context->work != nullptr) {
557         SendableMediaLibraryNapiUtils::InvokeJSAsyncMethod(env, context->deferred, context->callbackRef,
558             context->work, *jsContext);
559     }
560     delete context;
561 }
562 
JSPhotoAccessGetPhotoAssets(napi_env env,napi_callback_info info)563 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetPhotoAssets(napi_env env, napi_callback_info info)
564 {
565     unique_ptr<SendablePhotoAlbumNapiAsyncContext> asyncContext = make_unique<SendablePhotoAlbumNapiAsyncContext>();
566     CHECK_NULLPTR_RET(ParseArgsGetPhotoAssets(env, info, asyncContext));
567 
568     return SendableMediaLibraryNapiUtils::NapiCreateAsyncWork(env, asyncContext, "JSGetPhotoAssets",
569         JSPhotoAccessGetPhotoAssetsExecute, JSGetPhotoAssetsCallbackComplete);
570 }
571 
JSPhotoAccessSetAlbumName(napi_env env,napi_callback_info info)572 napi_value SendablePhotoAlbumNapi::JSPhotoAccessSetAlbumName(napi_env env, napi_callback_info info)
573 {
574     SendablePhotoAlbumNapi *obj = nullptr;
575     string albumName;
576     CHECK_NULLPTR_RET(GetStringArg(env, info, &obj, albumName));
577     obj->photoAlbumPtr->SetAlbumName(albumName);
578 
579     napi_value result = nullptr;
580     CHECK_ARGS(env, napi_get_undefined(env, &result), JS_INNER_FAIL);
581     return result;
582 }
583 
ParseArgsCommitModify(napi_env env,napi_callback_info info,unique_ptr<SendablePhotoAlbumNapiAsyncContext> & context)584 static napi_value ParseArgsCommitModify(napi_env env, napi_callback_info info,
585     unique_ptr<SendablePhotoAlbumNapiAsyncContext> &context)
586 {
587     constexpr size_t minArgs = ARGS_ZERO;
588     constexpr size_t maxArgs = ARGS_ONE;
589     CHECK_ARGS(env, SendableMediaLibraryNapiUtils::AsyncContextSetObjectInfo(env, info, context, minArgs, maxArgs),
590         JS_ERR_PARAMETER_INVALID);
591 
592     auto photoAlbum = context->objectInfo->GetPhotoAlbumInstance();
593     if (photoAlbum == nullptr) {
594         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
595         return nullptr;
596     }
597     if (!PhotoAlbum::IsUserPhotoAlbum(photoAlbum->GetPhotoAlbumType(), photoAlbum->GetPhotoAlbumSubType())) {
598         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
599         return nullptr;
600     }
601 
602     if (MediaFileUtils::CheckAlbumName(photoAlbum->GetAlbumName()) < 0) {
603         NapiError::ThrowError(env, JS_ERR_PARAMETER_INVALID);
604         return nullptr;
605     }
606     context->predicates.EqualTo(PhotoAlbumColumns::ALBUM_ID, to_string(photoAlbum->GetAlbumId()));
607     context->valuesBucket.Put(PhotoAlbumColumns::ALBUM_NAME, photoAlbum->GetAlbumName());
608     context->valuesBucket.Put(PhotoAlbumColumns::ALBUM_COVER_URI, photoAlbum->GetCoverUri());
609 
610     napi_value result = nullptr;
611     CHECK_ARGS(env, napi_get_boolean(env, true, &result), JS_INNER_FAIL);
612     return result;
613 }
614 
JSCommitModifyExecute(napi_env env,void * data)615 static void JSCommitModifyExecute(napi_env env, void *data)
616 {
617     MediaLibraryTracer tracer;
618     tracer.Start("JSCommitModifyExecute");
619 
620     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext*>(data);
621     string commitModifyUri = (context->resultNapiType == ResultNapiType::TYPE_USERFILE_MGR) ?
622         UFM_UPDATE_PHOTO_ALBUM : PAH_UPDATE_PHOTO_ALBUM;
623     Uri uri(commitModifyUri);
624     int changedRows = UserFileClient::Update(uri, context->predicates, context->valuesBucket);
625     context->SaveError(changedRows);
626     context->changedRows = changedRows;
627 }
628 
JSCommitModifyCompleteCallback(napi_env env,napi_status status,void * data)629 static void JSCommitModifyCompleteCallback(napi_env env, napi_status status, void *data)
630 {
631     MediaLibraryTracer tracer;
632     tracer.Start("JSCommitModifyCompleteCallback");
633 
634     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext*>(data);
635     auto jsContext = make_unique<SendableJSAsyncContextOutput>();
636     jsContext->status = false;
637     CHECK_ARGS_RET_VOID(env, napi_get_undefined(env, &jsContext->data), JS_INNER_FAIL);
638     if (context->error == ERR_DEFAULT) {
639         CHECK_ARGS_RET_VOID(env, napi_get_undefined(env, &jsContext->error), JS_INNER_FAIL);
640         jsContext->status = true;
641     } else {
642         context->HandleError(env, jsContext->error);
643     }
644 
645     tracer.Finish();
646     if (context->work != nullptr) {
647         SendableMediaLibraryNapiUtils::InvokeJSAsyncMethod(env, context->deferred, context->callbackRef,
648             context->work, *jsContext);
649     }
650     delete context;
651 }
652 
PhotoAccessHelperCommitModify(napi_env env,napi_callback_info info)653 napi_value SendablePhotoAlbumNapi::PhotoAccessHelperCommitModify(napi_env env, napi_callback_info info)
654 {
655     auto asyncContext = make_unique<SendablePhotoAlbumNapiAsyncContext>();
656     CHECK_NULLPTR_RET(ParseArgsCommitModify(env, info, asyncContext));
657     asyncContext->resultNapiType = ResultNapiType::TYPE_PHOTOACCESS_HELPER;
658 
659     return SendableMediaLibraryNapiUtils::NapiCreateAsyncWork(env, asyncContext, "JSCommitModify",
660         JSCommitModifyExecute, JSCommitModifyCompleteCallback);
661 }
662 
ConvertToPhotoAlbum(napi_env env,napi_callback_info info)663 napi_value SendablePhotoAlbumNapi::ConvertToPhotoAlbum(napi_env env, napi_callback_info info)
664 {
665     if (photoAccessConstructor_ == nullptr) {
666         napi_value exports = nullptr;
667         napi_create_object(env, &exports);
668         SendablePhotoAlbumNapi::PhotoAccessInit(env, exports);
669         PhotoAlbumNapi::PhotoAccessInit(env, exports);
670     }
671 
672     napi_value result = nullptr;
673     napi_status status;
674     napi_value thisVar = nullptr;
675 
676     napi_get_undefined(env, &result);
677     GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
678     if (status != napi_ok || thisVar == nullptr) {
679         NAPI_ERR_LOG("ConvertToPhotoAlbum Invalid arguments! status: %{public}d", status);
680         return result;
681     }
682 
683     SendablePhotoAlbumNapi *obj = nullptr;
684     status = napi_unwrap_sendable(env, thisVar, reinterpret_cast<void **>(&obj));
685     if ((status != napi_ok) && (obj == nullptr)) {
686         NapiError::ThrowError(env, E_CHECK_SYSTEMAPP_FAIL, "ConvertToPhotoAlbum napi unwrap sendable failed");
687         return nullptr;
688     }
689 
690     auto photoAlbum = obj->GetPhotoAlbumInstance();
691     CHECK_COND(env, photoAlbum != nullptr, JS_INNER_FAIL);
692     if (photoAlbum->GetAlbumId() > 0) {
693         return PhotoAlbumNapi::CreatePhotoAlbumNapi(env, photoAlbum);
694     }
695 
696     // PhotoAlbum object has not been actually created, return null.
697     napi_value nullValue;
698     napi_get_null(env, &nullValue);
699     return nullValue;
700 }
701 
JSPhotoAccessGetSharedPhotoAssets(napi_env env,napi_callback_info info)702 napi_value SendablePhotoAlbumNapi::JSPhotoAccessGetSharedPhotoAssets(napi_env env, napi_callback_info info)
703 {
704     MediaLibraryTracer tracer;
705     tracer.Start("JSPhotoAccessGetSharedPhotoAssets");
706     unique_ptr<SendablePhotoAlbumNapiAsyncContext> asyncContext =
707         make_unique<SendablePhotoAlbumNapiAsyncContext>();
708     CHECK_NULLPTR_RET(ParseArgsGetPhotoAssets(env, info, asyncContext));
709 
710     SendablePhotoAlbumNapiAsyncContext* context =
711         static_cast<SendablePhotoAlbumNapiAsyncContext*>((asyncContext.get()));
712 
713     Uri uri(PAH_QUERY_PHOTO_MAP);
714     ConvertColumnsForPortrait(context);
715     ConvertColumnsForFeaturedSinglePortrait(context);
716     shared_ptr<NativeRdb::ResultSet> resultSet = UserFileClient::QueryRdb(uri,
717         context->predicates, context->fetchColumn);
718     CHECK_NULLPTR_RET(resultSet);
719 
720     napi_value jsFileArray = 0;
721     napi_create_array(env, &jsFileArray);
722 
723     int count = 0;
724     int err = resultSet->GoToFirstRow();
725     if (err != napi_ok) {
726         NAPI_ERR_LOG("Failed GoToFirstRow %{public}d", err);
727         return jsFileArray;
728     }
729     do {
730         napi_value item = SendableMediaLibraryNapiUtils::GetNextRowObject(env, resultSet);
731         napi_set_element(env, jsFileArray, count++, item);
732     } while (!resultSet->GoToNextRow());
733     resultSet->Close();
734     return jsFileArray;
735 }
736 
PhotoAccessHelperGetFaceIdExec(napi_env env,void * data)737 static void PhotoAccessHelperGetFaceIdExec(napi_env env, void *data)
738 {
739     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext *>(data);
740     CHECK_NULL_PTR_RETURN_VOID(context, "Async context is null");
741 
742     auto *objectInfo = context->objectInfo;
743     CHECK_NULL_PTR_RETURN_VOID(objectInfo, "objectInfo is null");
744 
745     auto photoAlbumInstance = objectInfo->GetPhotoAlbumInstance();
746     CHECK_NULL_PTR_RETURN_VOID(photoAlbumInstance, "photoAlbumInstance is null");
747 
748     PhotoAlbumSubType albumSubType = photoAlbumInstance->GetPhotoAlbumSubType();
749     if (albumSubType != PhotoAlbumSubType::PORTRAIT && albumSubType != PhotoAlbumSubType::GROUP_PHOTO) {
750         NAPI_WARN_LOG("albumSubType: %{public}d, not support getFaceId", albumSubType);
751         return;
752     }
753 
754     Uri uri(PAH_QUERY_ANA_PHOTO_ALBUM);
755     DataShare::DataSharePredicates predicates;
756     predicates.EqualTo(PhotoAlbumColumns::ALBUM_ID, objectInfo->GetAlbumId());
757     vector<string> fetchColumn = { GROUP_TAG };
758     int errCode = 0;
759 
760     auto resultSet = UserFileClient::Query(uri, predicates, fetchColumn, errCode);
761     if (resultSet == nullptr || resultSet->GoToFirstRow() != 0) {
762         if (errCode == E_PERMISSION_DENIED) {
763             context->error = OHOS_PERMISSION_DENIED_CODE;
764         } else {
765             context->SaveError(E_FAIL);
766         }
767         NAPI_ERR_LOG("get face id failed, errCode is %{public}d", errCode);
768         return;
769     }
770 
771     context->faceTag = GetStringVal(GROUP_TAG, resultSet);
772 }
773 
GetFaceIdCompleteCallback(napi_env env,napi_status status,void * data)774 static void GetFaceIdCompleteCallback(napi_env env, napi_status status, void *data)
775 {
776     auto *context = static_cast<SendablePhotoAlbumNapiAsyncContext *>(data);
777     CHECK_NULL_PTR_RETURN_VOID(context, "Async context is null");
778     auto jsContext = make_unique<SendableJSAsyncContextOutput>();
779     jsContext->status = false;
780 
781     CHECK_ARGS_RET_VOID(env, napi_get_undefined(env, &jsContext->data), JS_INNER_FAIL);
782     if (context->error != ERR_DEFAULT) {
783         context->HandleError(env, jsContext->error);
784     } else {
785         CHECK_ARGS_RET_VOID(env,
786             napi_create_string_utf8(env, context->faceTag.c_str(), NAPI_AUTO_LENGTH, &jsContext->data), JS_INNER_FAIL);
787         jsContext->status = true;
788     }
789 
790     if (context->work != nullptr) {
791         SendableMediaLibraryNapiUtils::InvokeJSAsyncMethod(env, context->deferred, context->callbackRef, context->work,
792             *jsContext);
793     }
794     delete context;
795 }
796 
PhotoAccessHelperGetFaceId(napi_env env,napi_callback_info info)797 napi_value SendablePhotoAlbumNapi::PhotoAccessHelperGetFaceId(napi_env env, napi_callback_info info)
798 {
799     if (!SendableMediaLibraryNapiUtils::IsSystemApp()) {
800         NapiError::ThrowError(env, E_CHECK_SYSTEMAPP_FAIL, "Only system apps can get the Face ID of the album");
801         return nullptr;
802     }
803 
804     auto asyncContext = make_unique<SendablePhotoAlbumNapiAsyncContext>();
805 
806     CHECK_ARGS(env, SendableMediaLibraryNapiUtils::AsyncContextSetObjectInfo(env, info, asyncContext, 0, 0),
807         JS_ERR_PARAMETER_INVALID);
808 
809     return SendableMediaLibraryNapiUtils::NapiCreateAsyncWork(env, asyncContext, "JSAnalysisAlbumGetFaceId",
810         PhotoAccessHelperGetFaceIdExec, GetFaceIdCompleteCallback);
811 }
812 } // namespace OHOS::Media
813