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 #include "napi_data_ability_helper_utils.h"
16
17 #include "napi_common_ability.h"
18 #include "data_ability_result.h"
19 #include "hilog_tag_wrapper.h"
20 #include "napi_data_ability_observer.h"
21 #include "napi_data_ability_predicates.h"
22 #include "napi_rdb_predicates.h"
23 #include "napi_result_set.h"
24
25 using namespace OHOS::AAFwk;
26 using namespace OHOS::AppExecFwk;
27
28 namespace OHOS {
29 namespace AppExecFwk {
30
InsertAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperInsertCB * insertCB)31 napi_value InsertAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperInsertCB *insertCB)
32 {
33 TAG_LOGI(AAFwkTag::FA, "called");
34 if (args == nullptr || insertCB == nullptr) {
35 TAG_LOGE(AAFwkTag::FA, "null param");
36 return nullptr;
37 }
38 napi_value resourceName = nullptr;
39 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
40
41 napi_valuetype valuetype = napi_undefined;
42 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
43 if (valuetype == napi_function) {
44 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &insertCB->cbBase.cbInfo.callback));
45 }
46
47 NAPI_CALL(env,
48 napi_create_async_work(env,
49 nullptr,
50 resourceName,
51 InsertExecuteCB,
52 InsertAsyncCompleteCB,
53 static_cast<void *>(insertCB),
54 &insertCB->cbBase.asyncWork));
55 NAPI_CALL(env, napi_queue_async_work_with_qos(env, insertCB->cbBase.asyncWork, napi_qos_user_initiated));
56 napi_value result = nullptr;
57 NAPI_CALL(env, napi_get_null(env, &result));
58 TAG_LOGI(AAFwkTag::FA, "end");
59 return result;
60 }
61
InsertPromise(napi_env env,DAHelperInsertCB * insertCB)62 napi_value InsertPromise(napi_env env, DAHelperInsertCB *insertCB)
63 {
64 TAG_LOGI(AAFwkTag::FA, "called");
65 if (insertCB == nullptr) {
66 TAG_LOGE(AAFwkTag::FA, "null param");
67 return nullptr;
68 }
69 napi_value resourceName;
70 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
71 napi_deferred deferred;
72 napi_value promise = nullptr;
73 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
74 insertCB->cbBase.deferred = deferred;
75
76 NAPI_CALL(env,
77 napi_create_async_work(env,
78 nullptr,
79 resourceName,
80 InsertExecuteCB,
81 InsertPromiseCompleteCB,
82 static_cast<void *>(insertCB),
83 &insertCB->cbBase.asyncWork));
84 NAPI_CALL(env, napi_queue_async_work_with_qos(env, insertCB->cbBase.asyncWork, napi_qos_user_initiated));
85 TAG_LOGI(AAFwkTag::FA, "end");
86 return promise;
87 }
88
InsertExecuteCB(napi_env env,void * data)89 void InsertExecuteCB(napi_env env, void *data)
90 {
91 TAG_LOGI(AAFwkTag::FA, "called");
92 DAHelperInsertCB *insertCB = static_cast<DAHelperInsertCB *>(data);
93 if (insertCB == nullptr) {
94 TAG_LOGW(AAFwkTag::FA, "null insertCB");
95 return;
96 }
97 auto dataAbilityHelper = insertCB->dataAbilityHelper;
98 if (dataAbilityHelper != nullptr) {
99 insertCB->execResult = INVALID_PARAMETER;
100 if (!insertCB->uri.empty()) {
101 OHOS::Uri uri(insertCB->uri);
102 insertCB->result = dataAbilityHelper->Insert(uri, insertCB->valueBucket);
103 insertCB->execResult = NO_ERROR;
104 }
105 } else {
106 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
107 }
108 TAG_LOGI(AAFwkTag::FA, "end");
109 }
110
InsertAsyncCompleteCB(napi_env env,napi_status status,void * data)111 void InsertAsyncCompleteCB(napi_env env, napi_status status, void *data)
112 {
113 TAG_LOGI(AAFwkTag::FA, "called");
114 DAHelperInsertCB *insertCB = static_cast<DAHelperInsertCB *>(data);
115 napi_value callback = nullptr;
116 napi_value undefined = nullptr;
117 napi_value result[ARGS_TWO] = {nullptr};
118 napi_value callResult = nullptr;
119 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
120 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, insertCB->cbBase.cbInfo.callback, &callback));
121
122 result[PARAM0] = GetCallbackErrorValue(env, insertCB->execResult);
123 napi_create_int32(env, insertCB->result, &result[PARAM1]);
124 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
125
126 if (insertCB->cbBase.cbInfo.callback != nullptr) {
127 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, insertCB->cbBase.cbInfo.callback));
128 }
129 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, insertCB->cbBase.asyncWork));
130 delete insertCB;
131 insertCB = nullptr;
132 TAG_LOGI(AAFwkTag::FA, "end");
133 }
134
InsertPromiseCompleteCB(napi_env env,napi_status status,void * data)135 void InsertPromiseCompleteCB(napi_env env, napi_status status, void *data)
136 {
137 TAG_LOGI(AAFwkTag::FA, "called");
138 DAHelperInsertCB *insertCB = static_cast<DAHelperInsertCB *>(data);
139 napi_value result = nullptr;
140 napi_create_int32(env, insertCB->result, &result);
141 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, insertCB->cbBase.deferred, result));
142 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, insertCB->cbBase.asyncWork));
143 delete insertCB;
144 insertCB = nullptr;
145 TAG_LOGI(AAFwkTag::FA, "end");
146 }
147
NotifyChangeAsync(napi_env env,napi_value * args,size_t argcAsync,const size_t argcPromise,DAHelperNotifyChangeCB * notifyChangeCB)148 napi_value NotifyChangeAsync(
149 napi_env env, napi_value *args, size_t argcAsync, const size_t argcPromise, DAHelperNotifyChangeCB *notifyChangeCB)
150 {
151 TAG_LOGI(AAFwkTag::FA, "called");
152 if (args == nullptr || notifyChangeCB == nullptr) {
153 TAG_LOGE(AAFwkTag::FA, "null param");
154 return nullptr;
155 }
156 napi_value resourceName = nullptr;
157 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
158
159 napi_valuetype valuetype = napi_undefined;
160 NAPI_CALL(env, napi_typeof(env, args[argcPromise], &valuetype));
161 if (valuetype == napi_function) {
162 NAPI_CALL(env, napi_create_reference(env, args[argcPromise], 1, ¬ifyChangeCB->cbBase.cbInfo.callback));
163 }
164
165 NAPI_CALL(env,
166 napi_create_async_work(env,
167 nullptr,
168 resourceName,
169 NotifyChangeExecuteCB,
170 NotifyChangeAsyncCompleteCB,
171 static_cast<void *>(notifyChangeCB),
172 ¬ifyChangeCB->cbBase.asyncWork));
173 NAPI_CALL(env, napi_queue_async_work(env, notifyChangeCB->cbBase.asyncWork));
174 napi_value result = nullptr;
175 NAPI_CALL(env, napi_get_null(env, &result));
176 return result;
177 }
178
NotifyChangePromise(napi_env env,DAHelperNotifyChangeCB * notifyChangeCB)179 napi_value NotifyChangePromise(napi_env env, DAHelperNotifyChangeCB *notifyChangeCB)
180 {
181 TAG_LOGI(AAFwkTag::FA, "called");
182 if (notifyChangeCB == nullptr) {
183 TAG_LOGE(AAFwkTag::FA, "null param");
184 return nullptr;
185 }
186 napi_value resourceName;
187 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
188 napi_deferred deferred;
189 napi_value promise = nullptr;
190 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
191 notifyChangeCB->cbBase.deferred = deferred;
192
193 NAPI_CALL(env,
194 napi_create_async_work(env,
195 nullptr,
196 resourceName,
197 NotifyChangeExecuteCB,
198 NotifyChangePromiseCompleteCB,
199 static_cast<void *>(notifyChangeCB),
200 ¬ifyChangeCB->cbBase.asyncWork));
201 NAPI_CALL(env, napi_queue_async_work(env, notifyChangeCB->cbBase.asyncWork));
202 return promise;
203 }
204
NotifyChangeExecuteCB(napi_env env,void * data)205 void NotifyChangeExecuteCB(napi_env env, void *data)
206 {
207 TAG_LOGI(AAFwkTag::FA, "called");
208 DAHelperNotifyChangeCB *notifyChangeCB = static_cast<DAHelperNotifyChangeCB *>(data);
209 auto dataAbilityHelper = notifyChangeCB->dataAbilityHelper;
210 if (dataAbilityHelper != nullptr) {
211 notifyChangeCB->execResult = INVALID_PARAMETER;
212 if (!notifyChangeCB->uri.empty()) {
213 OHOS::Uri uri(notifyChangeCB->uri);
214 dataAbilityHelper->NotifyChange(uri);
215 notifyChangeCB->execResult = NO_ERROR;
216 } else {
217 TAG_LOGE(AAFwkTag::FA, "empty uri");
218 }
219 }
220 }
221
NotifyChangeAsyncCompleteCB(napi_env env,napi_status status,void * data)222 void NotifyChangeAsyncCompleteCB(napi_env env, napi_status status, void *data)
223 {
224 TAG_LOGI(AAFwkTag::FA, "called");
225 DAHelperNotifyChangeCB *notifyChangeCB = static_cast<DAHelperNotifyChangeCB *>(data);
226 napi_value callback = nullptr;
227 napi_value undefined = nullptr;
228 napi_value result[ARGS_TWO] = {nullptr};
229 napi_value callResult = nullptr;
230 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
231 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, notifyChangeCB->cbBase.cbInfo.callback, &callback));
232
233 if (!IsTypeForNapiValue(env, callback, napi_function)) {
234 delete notifyChangeCB;
235 notifyChangeCB = nullptr;
236 TAG_LOGI(AAFwkTag::FA, "invalid callback");
237 return;
238 }
239
240 result[PARAM0] = GetCallbackErrorValue(env, notifyChangeCB->execResult);
241 result[PARAM1] = WrapVoidToJS(env);
242 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
243
244 if (notifyChangeCB->cbBase.cbInfo.callback != nullptr) {
245 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, notifyChangeCB->cbBase.cbInfo.callback));
246 }
247 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, notifyChangeCB->cbBase.asyncWork));
248 delete notifyChangeCB;
249 notifyChangeCB = nullptr;
250 }
251
NotifyChangePromiseCompleteCB(napi_env env,napi_status status,void * data)252 void NotifyChangePromiseCompleteCB(napi_env env, napi_status status, void *data)
253 {
254 TAG_LOGI(AAFwkTag::FA, "called");
255 DAHelperNotifyChangeCB *notifyChangeCB = static_cast<DAHelperNotifyChangeCB *>(data);
256 napi_value result = nullptr;
257 napi_create_int32(env, 0, &result);
258 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, notifyChangeCB->cbBase.deferred, result));
259 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, notifyChangeCB->cbBase.asyncWork));
260 delete notifyChangeCB;
261 notifyChangeCB = nullptr;
262 }
263
GetTypeAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperGetTypeCB * gettypeCB)264 napi_value GetTypeAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperGetTypeCB *gettypeCB)
265 {
266 TAG_LOGI(AAFwkTag::FA, "called");
267 if (args == nullptr || gettypeCB == nullptr) {
268 TAG_LOGE(AAFwkTag::FA, "null param");
269 return nullptr;
270 }
271 napi_value resourceName = nullptr;
272 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
273
274 napi_valuetype valuetype = napi_undefined;
275 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
276 if (valuetype == napi_function) {
277 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &gettypeCB->cbBase.cbInfo.callback));
278 }
279
280 NAPI_CALL(env,
281 napi_create_async_work(env,
282 nullptr,
283 resourceName,
284 GetTypeExecuteCB,
285 GetTypeAsyncCompleteCB,
286 static_cast<void *>(gettypeCB),
287 &gettypeCB->cbBase.asyncWork));
288 NAPI_CALL(env, napi_queue_async_work_with_qos(env, gettypeCB->cbBase.asyncWork, napi_qos_user_initiated));
289 napi_value result = nullptr;
290 NAPI_CALL(env, napi_get_null(env, &result));
291 TAG_LOGI(AAFwkTag::FA, "end");
292 return result;
293 }
294
GetTypePromise(napi_env env,DAHelperGetTypeCB * gettypeCB)295 napi_value GetTypePromise(napi_env env, DAHelperGetTypeCB *gettypeCB)
296 {
297 TAG_LOGI(AAFwkTag::FA, "called");
298 if (gettypeCB == nullptr) {
299 TAG_LOGE(AAFwkTag::FA, "null param");
300 return nullptr;
301 }
302 napi_value resourceName;
303 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
304 napi_deferred deferred;
305 napi_value promise = nullptr;
306 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
307 gettypeCB->cbBase.deferred = deferred;
308
309 NAPI_CALL(env,
310 napi_create_async_work(env,
311 nullptr,
312 resourceName,
313 GetTypeExecuteCB,
314 GetTypePromiseCompleteCB,
315 static_cast<void *>(gettypeCB),
316 &gettypeCB->cbBase.asyncWork));
317 NAPI_CALL(env, napi_queue_async_work_with_qos(env, gettypeCB->cbBase.asyncWork, napi_qos_user_initiated));
318 TAG_LOGI(AAFwkTag::FA, "end");
319 return promise;
320 }
321
GetTypeExecuteCB(napi_env env,void * data)322 void GetTypeExecuteCB(napi_env env, void *data)
323 {
324 TAG_LOGI(AAFwkTag::FA, "called");
325 DAHelperGetTypeCB *gettypeCB = static_cast<DAHelperGetTypeCB *>(data);
326 auto dataAbilityHelper = gettypeCB->dataAbilityHelper;
327 if (dataAbilityHelper != nullptr) {
328 gettypeCB->execResult = INVALID_PARAMETER;
329 if (!gettypeCB->uri.empty()) {
330 OHOS::Uri uri(gettypeCB->uri);
331 gettypeCB->result = dataAbilityHelper->GetType(uri);
332 gettypeCB->execResult = NO_ERROR;
333 } else {
334 TAG_LOGE(AAFwkTag::FA, "empty uri");
335 }
336 } else {
337 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
338 }
339 TAG_LOGI(AAFwkTag::FA, "end");
340 }
341
GetTypeAsyncCompleteCB(napi_env env,napi_status status,void * data)342 void GetTypeAsyncCompleteCB(napi_env env, napi_status status, void *data)
343 {
344 TAG_LOGI(AAFwkTag::FA, "called");
345 DAHelperGetTypeCB *gettypeCB = static_cast<DAHelperGetTypeCB *>(data);
346 napi_value callback = nullptr;
347 napi_value undefined = nullptr;
348 napi_value result[ARGS_TWO] = {nullptr};
349 napi_value callResult = nullptr;
350 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
351 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, gettypeCB->cbBase.cbInfo.callback, &callback));
352
353 result[PARAM0] = GetCallbackErrorValue(env, gettypeCB->execResult);
354 napi_create_string_utf8(env, gettypeCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]);
355
356 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
357
358 if (gettypeCB->cbBase.cbInfo.callback != nullptr) {
359 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, gettypeCB->cbBase.cbInfo.callback));
360 }
361 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, gettypeCB->cbBase.asyncWork));
362 delete gettypeCB;
363 gettypeCB = nullptr;
364 TAG_LOGI(AAFwkTag::FA, "end");
365 }
366
GetTypePromiseCompleteCB(napi_env env,napi_status status,void * data)367 void GetTypePromiseCompleteCB(napi_env env, napi_status status, void *data)
368 {
369 TAG_LOGI(AAFwkTag::FA, "called");
370 DAHelperGetTypeCB *gettypeCB = static_cast<DAHelperGetTypeCB *>(data);
371 napi_value result = nullptr;
372 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, gettypeCB->result.c_str(), NAPI_AUTO_LENGTH, &result));
373 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, gettypeCB->cbBase.deferred, result));
374 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, gettypeCB->cbBase.asyncWork));
375 delete gettypeCB;
376 gettypeCB = nullptr;
377 TAG_LOGI(AAFwkTag::FA, "end");
378 }
379
GetFileTypesAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperGetFileTypesCB * getfiletypesCB)380 napi_value GetFileTypesAsync(
381 napi_env env, napi_value *args, const size_t argCallback, DAHelperGetFileTypesCB *getfiletypesCB)
382 {
383 TAG_LOGI(AAFwkTag::FA, "called");
384 if (args == nullptr || getfiletypesCB == nullptr) {
385 TAG_LOGE(AAFwkTag::FA, "null param");
386 return nullptr;
387 }
388 napi_value resourceName = nullptr;
389 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
390
391 napi_valuetype valuetype = napi_undefined;
392 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
393 if (valuetype == napi_function) {
394 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &getfiletypesCB->cbBase.cbInfo.callback));
395 }
396
397 NAPI_CALL(env,
398 napi_create_async_work(env,
399 nullptr,
400 resourceName,
401 GetFileTypesExecuteCB,
402 GetFileTypesAsyncCompleteCB,
403 static_cast<void *>(getfiletypesCB),
404 &getfiletypesCB->cbBase.asyncWork));
405 NAPI_CALL(env, napi_queue_async_work_with_qos(env, getfiletypesCB->cbBase.asyncWork, napi_qos_user_initiated));
406 napi_value result = nullptr;
407 NAPI_CALL(env, napi_get_null(env, &result));
408 TAG_LOGI(AAFwkTag::FA, "end");
409 return result;
410 }
411
GetFileTypesPromise(napi_env env,DAHelperGetFileTypesCB * getfiletypesCB)412 napi_value GetFileTypesPromise(napi_env env, DAHelperGetFileTypesCB *getfiletypesCB)
413 {
414 TAG_LOGI(AAFwkTag::FA, "called");
415 if (getfiletypesCB == nullptr) {
416 TAG_LOGE(AAFwkTag::FA, "null param");
417 return nullptr;
418 }
419 napi_value resourceName;
420 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
421 napi_deferred deferred;
422 napi_value promise = nullptr;
423 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
424 getfiletypesCB->cbBase.deferred = deferred;
425
426 NAPI_CALL(env,
427 napi_create_async_work(env,
428 nullptr,
429 resourceName,
430 GetFileTypesExecuteCB,
431 GetFileTypesPromiseCompleteCB,
432 static_cast<void *>(getfiletypesCB),
433 &getfiletypesCB->cbBase.asyncWork));
434 NAPI_CALL(env, napi_queue_async_work_with_qos(env, getfiletypesCB->cbBase.asyncWork, napi_qos_user_initiated));
435 TAG_LOGI(AAFwkTag::FA, "end");
436 return promise;
437 }
438
GetFileTypesExecuteCB(napi_env env,void * data)439 void GetFileTypesExecuteCB(napi_env env, void *data)
440 {
441 TAG_LOGI(AAFwkTag::FA, "called");
442 DAHelperGetFileTypesCB *getfiletypesCB = static_cast<DAHelperGetFileTypesCB *>(data);
443 auto dataAbilityHelper = getfiletypesCB->dataAbilityHelper;
444 if (dataAbilityHelper != nullptr) {
445 getfiletypesCB->execResult = INVALID_PARAMETER;
446 if (!getfiletypesCB->uri.empty()) {
447 OHOS::Uri uri(getfiletypesCB->uri);
448 TAG_LOGI(AAFwkTag::FA, "uri:%{public}s", uri.ToString().c_str());
449 TAG_LOGI(
450 AAFwkTag::FA, "mimeTypeFilter:%{public}s", getfiletypesCB->mimeTypeFilter.c_str());
451 getfiletypesCB->result = dataAbilityHelper->GetFileTypes(uri, getfiletypesCB->mimeTypeFilter);
452 getfiletypesCB->execResult = NO_ERROR;
453 } else {
454 TAG_LOGI(AAFwkTag::FA, "empty uri");
455 }
456 } else {
457 TAG_LOGI(AAFwkTag::FA, "null dataAbilityHelper");
458 }
459 TAG_LOGI(AAFwkTag::FA, "end");
460 }
461
GetFileTypesAsyncCompleteCB(napi_env env,napi_status status,void * data)462 void GetFileTypesAsyncCompleteCB(napi_env env, napi_status status, void *data)
463 {
464 TAG_LOGI(AAFwkTag::FA, "called");
465 DAHelperGetFileTypesCB *getfiletypesCB = static_cast<DAHelperGetFileTypesCB *>(data);
466 napi_value callback = nullptr;
467 napi_value undefined = nullptr;
468 napi_value result[ARGS_TWO] = {nullptr};
469 napi_value callResult = nullptr;
470
471 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
472 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, getfiletypesCB->cbBase.cbInfo.callback, &callback));
473
474 result[PARAM0] = GetCallbackErrorValue(env, getfiletypesCB->execResult);
475 result[PARAM1] = WrapGetFileTypesCB(env, *getfiletypesCB);
476
477 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
478
479 if (getfiletypesCB->cbBase.cbInfo.callback != nullptr) {
480 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, getfiletypesCB->cbBase.cbInfo.callback));
481 }
482 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getfiletypesCB->cbBase.asyncWork));
483 delete getfiletypesCB;
484 getfiletypesCB = nullptr;
485 TAG_LOGI(AAFwkTag::FA, "end");
486 }
487
GetFileTypesPromiseCompleteCB(napi_env env,napi_status status,void * data)488 void GetFileTypesPromiseCompleteCB(napi_env env, napi_status status, void *data)
489 {
490 TAG_LOGI(AAFwkTag::FA, "called");
491 DAHelperGetFileTypesCB *getfiletypesCB = static_cast<DAHelperGetFileTypesCB *>(data);
492 napi_value result = nullptr;
493
494 result = WrapGetFileTypesCB(env, *getfiletypesCB);
495 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, getfiletypesCB->cbBase.deferred, result));
496 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getfiletypesCB->cbBase.asyncWork));
497 delete getfiletypesCB;
498 getfiletypesCB = nullptr;
499 TAG_LOGI(AAFwkTag::FA, "end");
500 }
501
WrapGetFileTypesCB(napi_env env,const DAHelperGetFileTypesCB & getfiletypesCB)502 napi_value WrapGetFileTypesCB(napi_env env, const DAHelperGetFileTypesCB &getfiletypesCB)
503 {
504 TAG_LOGI(AAFwkTag::FA, "result.size:%{public}zu", getfiletypesCB.result.size());
505 for (size_t i = 0; i < getfiletypesCB.result.size(); i++) {
506 TAG_LOGI(
507 AAFwkTag::FA, "result[%{public}zu]:%{public}s", i, getfiletypesCB.result.at(i).c_str());
508 }
509 napi_value proValue = nullptr;
510
511 napi_value jsArrayresult = nullptr;
512 NAPI_CALL(env, napi_create_array(env, &jsArrayresult));
513 for (size_t i = 0; i < getfiletypesCB.result.size(); i++) {
514 proValue = nullptr;
515 NAPI_CALL(env, napi_create_string_utf8(env, getfiletypesCB.result.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
516 NAPI_CALL(env, napi_set_element(env, jsArrayresult, i, proValue));
517 }
518 TAG_LOGI(AAFwkTag::FA, "end");
519 return jsArrayresult;
520 }
521
NormalizeUriAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperNormalizeUriCB * normalizeuriCB)522 napi_value NormalizeUriAsync(
523 napi_env env, napi_value *args, const size_t argCallback, DAHelperNormalizeUriCB *normalizeuriCB)
524 {
525 TAG_LOGI(AAFwkTag::FA, "called");
526 if (args == nullptr || normalizeuriCB == nullptr) {
527 TAG_LOGE(AAFwkTag::FA, "null param");
528 return nullptr;
529 }
530 napi_value resourceName = nullptr;
531 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
532
533 napi_valuetype valuetype = napi_undefined;
534 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
535 if (valuetype == napi_function) {
536 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &normalizeuriCB->cbBase.cbInfo.callback));
537 }
538
539 NAPI_CALL(env,
540 napi_create_async_work(env,
541 nullptr,
542 resourceName,
543 NormalizeUriExecuteCB,
544 NormalizeUriAsyncCompleteCB,
545 static_cast<void *>(normalizeuriCB),
546 &normalizeuriCB->cbBase.asyncWork));
547 NAPI_CALL(env, napi_queue_async_work_with_qos(env, normalizeuriCB->cbBase.asyncWork, napi_qos_user_initiated));
548 napi_value result = nullptr;
549 NAPI_CALL(env, napi_get_null(env, &result));
550 TAG_LOGI(AAFwkTag::FA, "end");
551 return result;
552 }
553
NormalizeUriPromise(napi_env env,DAHelperNormalizeUriCB * normalizeuriCB)554 napi_value NormalizeUriPromise(napi_env env, DAHelperNormalizeUriCB *normalizeuriCB)
555 {
556 TAG_LOGI(AAFwkTag::FA, "called");
557 if (normalizeuriCB == nullptr) {
558 TAG_LOGE(AAFwkTag::FA, "null param");
559 return nullptr;
560 }
561 napi_value resourceName;
562 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
563 napi_deferred deferred;
564 napi_value promise = nullptr;
565 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
566 normalizeuriCB->cbBase.deferred = deferred;
567
568 NAPI_CALL(env,
569 napi_create_async_work(env,
570 nullptr,
571 resourceName,
572 NormalizeUriExecuteCB,
573 NormalizeUriPromiseCompleteCB,
574 static_cast<void *>(normalizeuriCB),
575 &normalizeuriCB->cbBase.asyncWork));
576 NAPI_CALL(env, napi_queue_async_work_with_qos(env, normalizeuriCB->cbBase.asyncWork, napi_qos_user_initiated));
577 TAG_LOGI(AAFwkTag::FA, "end");
578 return promise;
579 }
580
NormalizeUriExecuteCB(napi_env env,void * data)581 void NormalizeUriExecuteCB(napi_env env, void *data)
582 {
583 TAG_LOGI(AAFwkTag::FA, "called");
584 DAHelperNormalizeUriCB *normalizeuriCB = static_cast<DAHelperNormalizeUriCB *>(data);
585 Uri uriValue(normalizeuriCB->uri);
586 auto dataAbilityHelper = normalizeuriCB->dataAbilityHelper;
587 if (dataAbilityHelper != nullptr) {
588 normalizeuriCB->execResult = INVALID_PARAMETER;
589 if (!normalizeuriCB->uri.empty()) {
590 OHOS::Uri uri(normalizeuriCB->uri);
591 uriValue = dataAbilityHelper->NormalizeUri(uri);
592 normalizeuriCB->result = uriValue.ToString();
593 normalizeuriCB->execResult = NO_ERROR;
594 }
595 } else {
596 TAG_LOGI(AAFwkTag::FA, "null dataAbilityHelper");
597 }
598 TAG_LOGI(AAFwkTag::FA, "end");
599 }
600
NormalizeUriAsyncCompleteCB(napi_env env,napi_status status,void * data)601 void NormalizeUriAsyncCompleteCB(napi_env env, napi_status status, void *data)
602 {
603 TAG_LOGI(AAFwkTag::FA, "called");
604 DAHelperNormalizeUriCB *normalizeuriCB = static_cast<DAHelperNormalizeUriCB *>(data);
605 napi_value callback = nullptr;
606 napi_value undefined = nullptr;
607 napi_value result[ARGS_TWO] = {nullptr};
608 napi_value callResult = nullptr;
609 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
610 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, normalizeuriCB->cbBase.cbInfo.callback, &callback));
611
612 result[PARAM0] = GetCallbackErrorValue(env, normalizeuriCB->execResult);
613 NAPI_CALL_RETURN_VOID(
614 env, napi_create_string_utf8(env, normalizeuriCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]));
615
616 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
617
618 if (normalizeuriCB->cbBase.cbInfo.callback != nullptr) {
619 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, normalizeuriCB->cbBase.cbInfo.callback));
620 }
621 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, normalizeuriCB->cbBase.asyncWork));
622 delete normalizeuriCB;
623 normalizeuriCB = nullptr;
624 TAG_LOGI(AAFwkTag::FA, "end");
625 }
626
NormalizeUriPromiseCompleteCB(napi_env env,napi_status status,void * data)627 void NormalizeUriPromiseCompleteCB(napi_env env, napi_status status, void *data)
628 {
629 TAG_LOGI(AAFwkTag::FA, "called");
630 DAHelperNormalizeUriCB *normalizeuriCB = static_cast<DAHelperNormalizeUriCB *>(data);
631 napi_value result = nullptr;
632 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, normalizeuriCB->result.c_str(), NAPI_AUTO_LENGTH, &result));
633 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, normalizeuriCB->cbBase.deferred, result));
634 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, normalizeuriCB->cbBase.asyncWork));
635 delete normalizeuriCB;
636 normalizeuriCB = nullptr;
637 TAG_LOGI(AAFwkTag::FA, "end");
638 }
639
DenormalizeUriAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperDenormalizeUriCB * denormalizeuriCB)640 napi_value DenormalizeUriAsync(
641 napi_env env, napi_value *args, const size_t argCallback, DAHelperDenormalizeUriCB *denormalizeuriCB)
642 {
643 TAG_LOGI(AAFwkTag::FA, "called");
644 if (args == nullptr || denormalizeuriCB == nullptr) {
645 TAG_LOGE(AAFwkTag::FA, "null param");
646 return nullptr;
647 }
648 napi_value resourceName = nullptr;
649 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
650
651 napi_valuetype valuetype = napi_undefined;
652 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
653 if (valuetype == napi_function) {
654 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &denormalizeuriCB->cbBase.cbInfo.callback));
655 }
656
657 NAPI_CALL(env,
658 napi_create_async_work(env,
659 nullptr,
660 resourceName,
661 DenormalizeUriExecuteCB,
662 DenormalizeUriAsyncCompleteCB,
663 static_cast<void *>(denormalizeuriCB),
664 &denormalizeuriCB->cbBase.asyncWork));
665 NAPI_CALL(env, napi_queue_async_work_with_qos(env, denormalizeuriCB->cbBase.asyncWork, napi_qos_user_initiated));
666 napi_value result = nullptr;
667 NAPI_CALL(env, napi_get_null(env, &result));
668 TAG_LOGI(AAFwkTag::FA, "end");
669 return result;
670 }
671
DenormalizeUriPromise(napi_env env,DAHelperDenormalizeUriCB * denormalizeuriCB)672 napi_value DenormalizeUriPromise(napi_env env, DAHelperDenormalizeUriCB *denormalizeuriCB)
673 {
674 TAG_LOGI(AAFwkTag::FA, "called");
675 if (denormalizeuriCB == nullptr) {
676 TAG_LOGE(AAFwkTag::FA, "null param");
677 return nullptr;
678 }
679 napi_value resourceName;
680 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
681 napi_deferred deferred;
682 napi_value promise = nullptr;
683 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
684 denormalizeuriCB->cbBase.deferred = deferred;
685
686 NAPI_CALL(env,
687 napi_create_async_work(env,
688 nullptr,
689 resourceName,
690 DenormalizeUriExecuteCB,
691 DenormalizeUriPromiseCompleteCB,
692 static_cast<void *>(denormalizeuriCB),
693 &denormalizeuriCB->cbBase.asyncWork));
694 NAPI_CALL(env, napi_queue_async_work_with_qos(env, denormalizeuriCB->cbBase.asyncWork, napi_qos_user_initiated));
695 TAG_LOGI(AAFwkTag::FA, "end");
696 return promise;
697 }
698
DenormalizeUriExecuteCB(napi_env env,void * data)699 void DenormalizeUriExecuteCB(napi_env env, void *data)
700 {
701 TAG_LOGI(AAFwkTag::FA, "called");
702 DAHelperDenormalizeUriCB *denormalizeuriCB = static_cast<DAHelperDenormalizeUriCB *>(data);
703 Uri uriValue(denormalizeuriCB->uri);
704 auto dataAbilityHelper = denormalizeuriCB->dataAbilityHelper;
705 if (dataAbilityHelper != nullptr) {
706 denormalizeuriCB->execResult = INVALID_PARAMETER;
707 if (!denormalizeuriCB->uri.empty()) {
708 OHOS::Uri uri(denormalizeuriCB->uri);
709 uriValue = dataAbilityHelper->DenormalizeUri(uri);
710 denormalizeuriCB->result = uriValue.ToString();
711 denormalizeuriCB->execResult = NO_ERROR;
712 } else {
713 TAG_LOGE(AAFwkTag::FA, "empty uri");
714 }
715 } else {
716 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
717 }
718 TAG_LOGI(AAFwkTag::FA, "end");
719 }
720
DenormalizeUriAsyncCompleteCB(napi_env env,napi_status status,void * data)721 void DenormalizeUriAsyncCompleteCB(napi_env env, napi_status status, void *data)
722 {
723 TAG_LOGI(AAFwkTag::FA, "called");
724 DAHelperDenormalizeUriCB *denormalizeuriCB = static_cast<DAHelperDenormalizeUriCB *>(data);
725 napi_value callback = nullptr;
726 napi_value undefined = nullptr;
727 napi_value result[ARGS_TWO] = {nullptr};
728 napi_value callResult = nullptr;
729 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
730 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, denormalizeuriCB->cbBase.cbInfo.callback, &callback));
731
732 result[PARAM0] = GetCallbackErrorValue(env, denormalizeuriCB->execResult);
733 NAPI_CALL_RETURN_VOID(
734 env, napi_create_string_utf8(env, denormalizeuriCB->result.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]));
735
736 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
737
738 if (denormalizeuriCB->cbBase.cbInfo.callback != nullptr) {
739 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, denormalizeuriCB->cbBase.cbInfo.callback));
740 }
741 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, denormalizeuriCB->cbBase.asyncWork));
742 delete denormalizeuriCB;
743 denormalizeuriCB = nullptr;
744 TAG_LOGI(AAFwkTag::FA, "end");
745 }
746
DenormalizeUriPromiseCompleteCB(napi_env env,napi_status status,void * data)747 void DenormalizeUriPromiseCompleteCB(napi_env env, napi_status status, void *data)
748 {
749 TAG_LOGI(AAFwkTag::FA, "called");
750 DAHelperDenormalizeUriCB *denormalizeuriCB = static_cast<DAHelperDenormalizeUriCB *>(data);
751 napi_value result = nullptr;
752 NAPI_CALL_RETURN_VOID(
753 env, napi_create_string_utf8(env, denormalizeuriCB->result.c_str(), NAPI_AUTO_LENGTH, &result));
754 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, denormalizeuriCB->cbBase.deferred, result));
755 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, denormalizeuriCB->cbBase.asyncWork));
756 delete denormalizeuriCB;
757 denormalizeuriCB = nullptr;
758 TAG_LOGI(AAFwkTag::FA, "end");
759 }
760
DeleteAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperDeleteCB * deleteCB)761 napi_value DeleteAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperDeleteCB *deleteCB)
762 {
763 TAG_LOGI(AAFwkTag::FA, "called");
764 if (args == nullptr || deleteCB == nullptr) {
765 TAG_LOGE(AAFwkTag::FA, "null param");
766 return nullptr;
767 }
768 napi_value resourceName = nullptr;
769 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
770
771 napi_valuetype valuetype = napi_undefined;
772 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
773 if (valuetype == napi_function) {
774 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &deleteCB->cbBase.cbInfo.callback));
775 }
776
777 NAPI_CALL(env,
778 napi_create_async_work(env,
779 nullptr,
780 resourceName,
781 DeleteExecuteCB,
782 DeleteAsyncCompleteCB,
783 static_cast<void *>(deleteCB),
784 &deleteCB->cbBase.asyncWork));
785 NAPI_CALL(env, napi_queue_async_work_with_qos(env, deleteCB->cbBase.asyncWork, napi_qos_user_initiated));
786 napi_value result = nullptr;
787 NAPI_CALL(env, napi_get_null(env, &result));
788 TAG_LOGI(AAFwkTag::FA, "end");
789 return result;
790 }
791
DeletePromise(napi_env env,DAHelperDeleteCB * deleteCB)792 napi_value DeletePromise(napi_env env, DAHelperDeleteCB *deleteCB)
793 {
794 TAG_LOGI(AAFwkTag::FA, "called");
795 if (deleteCB == nullptr) {
796 TAG_LOGE(AAFwkTag::FA, "null param");
797 return nullptr;
798 }
799 napi_value resourceName;
800 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
801 napi_deferred deferred;
802 napi_value promise = nullptr;
803 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
804 deleteCB->cbBase.deferred = deferred;
805
806 NAPI_CALL(env,
807 napi_create_async_work(env,
808 nullptr,
809 resourceName,
810 DeleteExecuteCB,
811 DeletePromiseCompleteCB,
812 static_cast<void *>(deleteCB),
813 &deleteCB->cbBase.asyncWork));
814 NAPI_CALL(env, napi_queue_async_work_with_qos(env, deleteCB->cbBase.asyncWork, napi_qos_user_initiated));
815 TAG_LOGI(AAFwkTag::FA, "end");
816 return promise;
817 }
818
DeleteExecuteCB(napi_env env,void * data)819 void DeleteExecuteCB(napi_env env, void *data)
820 {
821 TAG_LOGI(AAFwkTag::FA, "called");
822 DAHelperDeleteCB *deleteCB = static_cast<DAHelperDeleteCB *>(data);
823 auto dataAbilityHelper = deleteCB->dataAbilityHelper;
824 if (dataAbilityHelper != nullptr) {
825 deleteCB->execResult = INVALID_PARAMETER;
826 if (!deleteCB->uri.empty()) {
827 OHOS::Uri uri(deleteCB->uri);
828 deleteCB->result = dataAbilityHelper->Delete(uri, deleteCB->predicates);
829 deleteCB->execResult = NO_ERROR;
830 } else {
831 TAG_LOGE(AAFwkTag::FA, "empty uri");
832 }
833 } else {
834 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
835 }
836 TAG_LOGI(AAFwkTag::FA, "end");
837 }
838
DeleteAsyncCompleteCB(napi_env env,napi_status status,void * data)839 void DeleteAsyncCompleteCB(napi_env env, napi_status status, void *data)
840 {
841 TAG_LOGI(AAFwkTag::FA, "complete");
842 DAHelperDeleteCB *DeleteCB = static_cast<DAHelperDeleteCB *>(data);
843 napi_value callback = nullptr;
844 napi_value undefined = nullptr;
845 napi_value result[ARGS_TWO] = {nullptr};
846 napi_value callResult = nullptr;
847 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
848 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, DeleteCB->cbBase.cbInfo.callback, &callback));
849
850 result[PARAM0] = GetCallbackErrorValue(env, DeleteCB->execResult);
851 napi_create_int32(env, DeleteCB->result, &result[PARAM1]);
852 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
853
854 if (DeleteCB->cbBase.cbInfo.callback != nullptr) {
855 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, DeleteCB->cbBase.cbInfo.callback));
856 }
857 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, DeleteCB->cbBase.asyncWork));
858 delete DeleteCB;
859 DeleteCB = nullptr;
860 TAG_LOGI(AAFwkTag::FA, "end");
861 }
862
DeletePromiseCompleteCB(napi_env env,napi_status status,void * data)863 void DeletePromiseCompleteCB(napi_env env, napi_status status, void *data)
864 {
865 TAG_LOGI(AAFwkTag::FA, "called");
866 DAHelperDeleteCB *DeleteCB = static_cast<DAHelperDeleteCB *>(data);
867 napi_value result = nullptr;
868 napi_create_int32(env, DeleteCB->result, &result);
869 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, DeleteCB->cbBase.deferred, result));
870 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, DeleteCB->cbBase.asyncWork));
871 delete DeleteCB;
872 DeleteCB = nullptr;
873 TAG_LOGI(AAFwkTag::FA, "end");
874 }
875
UpdateAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperUpdateCB * updateCB)876 napi_value UpdateAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperUpdateCB *updateCB)
877 {
878 TAG_LOGI(AAFwkTag::FA, "called");
879 if (args == nullptr || updateCB == nullptr) {
880 TAG_LOGE(AAFwkTag::FA, "null param");
881 return nullptr;
882 }
883 napi_value resourceName = nullptr;
884 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
885
886 napi_valuetype valuetype = napi_undefined;
887 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
888 if (valuetype == napi_function) {
889 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &updateCB->cbBase.cbInfo.callback));
890 }
891
892 NAPI_CALL(env,
893 napi_create_async_work(env,
894 nullptr,
895 resourceName,
896 UpdateExecuteCB,
897 UpdateAsyncCompleteCB,
898 static_cast<void *>(updateCB),
899 &updateCB->cbBase.asyncWork));
900 NAPI_CALL(env, napi_queue_async_work_with_qos(env, updateCB->cbBase.asyncWork, napi_qos_user_initiated));
901 napi_value result = nullptr;
902 NAPI_CALL(env, napi_get_null(env, &result));
903 TAG_LOGI(AAFwkTag::FA, "end");
904 return result;
905 }
906
UpdatePromise(napi_env env,DAHelperUpdateCB * updateCB)907 napi_value UpdatePromise(napi_env env, DAHelperUpdateCB *updateCB)
908 {
909 TAG_LOGI(AAFwkTag::FA, "called");
910 if (updateCB == nullptr) {
911 TAG_LOGE(AAFwkTag::FA, "null param");
912 return nullptr;
913 }
914 napi_value resourceName;
915 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
916 napi_deferred deferred;
917 napi_value promise = nullptr;
918 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
919 updateCB->cbBase.deferred = deferred;
920
921 NAPI_CALL(env,
922 napi_create_async_work(env,
923 nullptr,
924 resourceName,
925 UpdateExecuteCB,
926 UpdatePromiseCompleteCB,
927 static_cast<void *>(updateCB),
928 &updateCB->cbBase.asyncWork));
929 NAPI_CALL(env, napi_queue_async_work_with_qos(env, updateCB->cbBase.asyncWork, napi_qos_user_initiated));
930 TAG_LOGI(AAFwkTag::FA, "end");
931 return promise;
932 }
933
UpdateExecuteCB(napi_env env,void * data)934 void UpdateExecuteCB(napi_env env, void *data)
935 {
936 TAG_LOGI(AAFwkTag::FA, "called");
937 DAHelperUpdateCB *updateCB = static_cast<DAHelperUpdateCB *>(data);
938 auto dataAbilityHelper = updateCB->dataAbilityHelper;
939 if (dataAbilityHelper != nullptr) {
940 updateCB->execResult = INVALID_PARAMETER;
941 if (!updateCB->uri.empty()) {
942 OHOS::Uri uri(updateCB->uri);
943 updateCB->result = dataAbilityHelper->Update(uri, updateCB->valueBucket, updateCB->predicates);
944 updateCB->execResult = NO_ERROR;
945 } else {
946 TAG_LOGE(AAFwkTag::FA, "empty uri");
947 }
948 } else {
949 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
950 }
951 TAG_LOGI(AAFwkTag::FA, "end");
952 }
953
UpdateAsyncCompleteCB(napi_env env,napi_status status,void * data)954 void UpdateAsyncCompleteCB(napi_env env, napi_status status, void *data)
955 {
956 TAG_LOGI(AAFwkTag::FA, "called");
957 DAHelperUpdateCB *updateCB = static_cast<DAHelperUpdateCB *>(data);
958 napi_value callback = nullptr;
959 napi_value undefined = nullptr;
960 napi_value result[ARGS_TWO] = {nullptr};
961 napi_value callResult = nullptr;
962 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
963 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, updateCB->cbBase.cbInfo.callback, &callback));
964
965 result[PARAM0] = GetCallbackErrorValue(env, updateCB->execResult);
966 napi_create_int32(env, updateCB->result, &result[PARAM1]);
967 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
968
969 if (updateCB->cbBase.cbInfo.callback != nullptr) {
970 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, updateCB->cbBase.cbInfo.callback));
971 }
972 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, updateCB->cbBase.asyncWork));
973 delete updateCB;
974 updateCB = nullptr;
975 TAG_LOGI(AAFwkTag::FA, "end");
976 }
977
UpdatePromiseCompleteCB(napi_env env,napi_status status,void * data)978 void UpdatePromiseCompleteCB(napi_env env, napi_status status, void *data)
979 {
980 TAG_LOGI(AAFwkTag::FA, "called");
981 DAHelperUpdateCB *updateCB = static_cast<DAHelperUpdateCB *>(data);
982 napi_value result = nullptr;
983 napi_create_int32(env, updateCB->result, &result);
984 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, updateCB->cbBase.deferred, result));
985 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, updateCB->cbBase.asyncWork));
986 delete updateCB;
987 updateCB = nullptr;
988 TAG_LOGI(AAFwkTag::FA, "end");
989 }
990
CallErrorAsyncCompleteCB(napi_env env,napi_status status,void * data)991 void CallErrorAsyncCompleteCB(napi_env env, napi_status status, void *data)
992 {
993 TAG_LOGI(AAFwkTag::FA, "called");
994 DAHelperErrorCB *errorCB = static_cast<DAHelperErrorCB *>(data);
995 if (errorCB != nullptr) {
996 napi_value callback = nullptr;
997 napi_value undefined = nullptr;
998 napi_value result[ARGS_TWO] = {nullptr};
999 napi_value callResult = nullptr;
1000 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1001 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, errorCB->cbBase.cbInfo.callback, &callback));
1002
1003 napi_create_int32(env, errorCB->execResult, &result[PARAM0]);
1004 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[0], &callResult));
1005
1006 if (errorCB->cbBase.cbInfo.callback != nullptr) {
1007 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, errorCB->cbBase.cbInfo.callback));
1008 }
1009 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, errorCB->cbBase.asyncWork));
1010 }
1011 delete errorCB;
1012 errorCB = nullptr;
1013 TAG_LOGI(AAFwkTag::FA, "end");
1014 }
1015
CallErrorPromiseCompleteCB(napi_env env,napi_status status,void * data)1016 void CallErrorPromiseCompleteCB(napi_env env, napi_status status, void *data)
1017 {
1018 TAG_LOGI(AAFwkTag::FA, "called");
1019 DAHelperErrorCB *errorCB = static_cast<DAHelperErrorCB *>(data);
1020 if (errorCB != nullptr) {
1021 napi_value result = nullptr;
1022 napi_create_int32(env, errorCB->execResult, &result);
1023 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, errorCB->cbBase.deferred, result));
1024 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, errorCB->cbBase.asyncWork));
1025 }
1026 delete errorCB;
1027 errorCB = nullptr;
1028 TAG_LOGI(AAFwkTag::FA, "end");
1029 }
1030
CallErrorExecuteCB(napi_env env,void * data)1031 void CallErrorExecuteCB(napi_env env, void *data)
1032 {
1033 TAG_LOGI(AAFwkTag::FA, "called");
1034 DAHelperErrorCB *errorCB = static_cast<DAHelperErrorCB *>(data);
1035 if (errorCB != nullptr) {
1036 errorCB->execResult = INVALID_PARAMETER;
1037 } else {
1038 TAG_LOGE(AAFwkTag::FA, "null errorCB");
1039 }
1040 TAG_LOGI(AAFwkTag::FA, "end");
1041 }
1042
CallErrorAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperErrorCB * errorCB)1043 napi_value CallErrorAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperErrorCB *errorCB)
1044 {
1045 TAG_LOGI(AAFwkTag::FA, "called");
1046 if (args == nullptr || errorCB == nullptr) {
1047 TAG_LOGE(AAFwkTag::FA, "null param");
1048 return nullptr;
1049 }
1050 napi_value resourceName = nullptr;
1051 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1052
1053 napi_valuetype valuetype = napi_undefined;
1054 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1055 if (valuetype == napi_function) {
1056 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &errorCB->cbBase.cbInfo.callback));
1057 }
1058
1059 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, CallErrorExecuteCB, CallErrorAsyncCompleteCB,
1060 static_cast<void *>(errorCB), &errorCB->cbBase.asyncWork));
1061 NAPI_CALL(env, napi_queue_async_work_with_qos(env, errorCB->cbBase.asyncWork, napi_qos_user_initiated));
1062 napi_value result = nullptr;
1063 NAPI_CALL(env, napi_get_null(env, &result));
1064 TAG_LOGI(AAFwkTag::FA, "end");
1065 return result;
1066 }
1067
CallErrorPromise(napi_env env,DAHelperErrorCB * errorCB)1068 napi_value CallErrorPromise(napi_env env, DAHelperErrorCB *errorCB)
1069 {
1070 TAG_LOGI(AAFwkTag::FA, "called");
1071 if (errorCB == nullptr) {
1072 TAG_LOGE(AAFwkTag::FA, "param is null");
1073 return nullptr;
1074 }
1075 napi_value resourceName;
1076 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1077 napi_deferred deferred;
1078 napi_value promise = nullptr;
1079 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1080 errorCB->cbBase.deferred = deferred;
1081
1082 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, CallErrorExecuteCB, CallErrorPromiseCompleteCB,
1083 static_cast<void *>(errorCB), &errorCB->cbBase.asyncWork));
1084 NAPI_CALL(env, napi_queue_async_work_with_qos(env, errorCB->cbBase.asyncWork, napi_qos_user_initiated));
1085 TAG_LOGI(AAFwkTag::FA, "end");
1086 return promise;
1087 }
1088
CallErrorWrap(napi_env env,napi_value thisVar,napi_callback_info info,napi_value * args,bool isPromise)1089 napi_value CallErrorWrap(napi_env env, napi_value thisVar, napi_callback_info info, napi_value *args, bool isPromise)
1090 {
1091 TAG_LOGI(AAFwkTag::FA, "called");
1092 DAHelperErrorCB *errorCB = new DAHelperErrorCB;
1093 errorCB->cbBase.cbInfo.env = env;
1094 errorCB->cbBase.asyncWork = nullptr;
1095 errorCB->cbBase.deferred = nullptr;
1096 errorCB->cbBase.ability = nullptr;
1097 napi_value ret = nullptr;
1098 if (!isPromise) {
1099 ret = CallErrorAsync(env, args, ARGS_FOUR, errorCB);
1100 } else {
1101 ret = CallErrorPromise(env, errorCB);
1102 }
1103 if (ret == nullptr) {
1104 TAG_LOGE(AAFwkTag::FA, "null ret");
1105 delete errorCB;
1106 errorCB = nullptr;
1107 ret = WrapVoidToJS(env);
1108 }
1109 TAG_LOGI(AAFwkTag::FA, "end");
1110 return ret;
1111 }
1112
CallExecuteCB(napi_env env,void * data)1113 void CallExecuteCB(napi_env env, void *data)
1114 {
1115 TAG_LOGI(AAFwkTag::FA, "called");
1116 DAHelperCallCB *callCB = static_cast<DAHelperCallCB *>(data);
1117 auto dataAbilityHelper = callCB->dataAbilityHelper;
1118 if (dataAbilityHelper != nullptr) {
1119 callCB->execResult = INVALID_PARAMETER;
1120 if (!callCB->uri.empty()) {
1121 OHOS::Uri uri(callCB->uri);
1122 callCB->result = dataAbilityHelper->Call(uri, callCB->method, callCB->arg, callCB->pacMap);
1123 callCB->execResult = NO_ERROR;
1124 }
1125 } else {
1126 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
1127 }
1128 TAG_LOGI(AAFwkTag::FA, "end");
1129 }
1130
ExcludeTag(const std::string & jsonString,const std::string & tagString)1131 static std::string ExcludeTag(const std::string& jsonString, const std::string& tagString)
1132 {
1133 TAG_LOGD(AAFwkTag::FA, "called");
1134 size_t pos = jsonString.find(tagString);
1135 if (pos == std::string::npos) {
1136 return jsonString;
1137 }
1138 std::string valueString = jsonString.substr(pos);
1139 pos = valueString.find(":");
1140 if (pos == std::string::npos) {
1141 return "";
1142 }
1143 size_t valuePos = pos + 1;
1144 while (valuePos < valueString.size()) {
1145 if (valueString.at(valuePos) != ' ' && valueString.at(valuePos) != '\t') {
1146 break;
1147 }
1148 valuePos++;
1149 }
1150 if (valuePos >= valueString.size()) {
1151 return "";
1152 }
1153 TAG_LOGD(AAFwkTag::FA, "end");
1154 valueString = valueString.substr(valuePos);
1155 return valueString.substr(0, valueString.size() - 1);
1156 }
1157
CallPacMapValue(napi_env env,std::shared_ptr<AppExecFwk::PacMap> result)1158 napi_value CallPacMapValue(napi_env env, std::shared_ptr<AppExecFwk::PacMap> result)
1159 {
1160 napi_value value = nullptr;
1161
1162 NAPI_CALL(env, napi_create_object(env, &value));
1163 napi_value napiResult = nullptr;
1164 if (result != nullptr) {
1165 std::string resultWithoutTag = ExcludeTag(result->ToString(), "pacmap");
1166 napi_create_string_utf8(env, resultWithoutTag.c_str(), NAPI_AUTO_LENGTH, &napiResult);
1167 NAPI_CALL(env, napi_set_named_property(env, value, "result", napiResult));
1168 } else {
1169 TAG_LOGE(AAFwkTag::FA, "null ret");
1170 }
1171 return value;
1172 }
1173
CallAsyncCompleteCB(napi_env env,napi_status status,void * data)1174 void CallAsyncCompleteCB(napi_env env, napi_status status, void *data)
1175 {
1176 TAG_LOGI(AAFwkTag::FA, "called");
1177 DAHelperCallCB *callCB = static_cast<DAHelperCallCB *>(data);
1178 napi_value callback = nullptr;
1179 napi_value undefined = nullptr;
1180 napi_value result[ARGS_TWO] = {nullptr};
1181 napi_value callResult = nullptr;
1182 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1183 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callCB->cbBase.cbInfo.callback, &callback));
1184
1185 result[PARAM0] = GetCallbackErrorValue(env, callCB->execResult);
1186 result[PARAM1] = CallPacMapValue(env, callCB->result);
1187 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1188
1189 if (callCB->cbBase.cbInfo.callback != nullptr) {
1190 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, callCB->cbBase.cbInfo.callback));
1191 }
1192 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, callCB->cbBase.asyncWork));
1193 delete callCB;
1194 callCB = nullptr;
1195 TAG_LOGI(AAFwkTag::FA, "end");
1196 }
1197
CallPromiseCompleteCB(napi_env env,napi_status status,void * data)1198 void CallPromiseCompleteCB(napi_env env, napi_status status, void *data)
1199 {
1200 TAG_LOGI(AAFwkTag::FA, "called");
1201 DAHelperCallCB *callCB = static_cast<DAHelperCallCB *>(data);
1202 napi_value result = nullptr;
1203 result = CallPacMapValue(env, callCB->result);
1204 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, callCB->cbBase.deferred, result));
1205 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, callCB->cbBase.asyncWork));
1206 delete callCB;
1207 callCB = nullptr;
1208 TAG_LOGI(AAFwkTag::FA, "end");
1209 }
1210
CallAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperCallCB * callCB)1211 napi_value CallAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperCallCB *callCB)
1212 {
1213 TAG_LOGI(AAFwkTag::FA, "called");
1214 if (args == nullptr || callCB == nullptr) {
1215 TAG_LOGE(AAFwkTag::FA, "null param");
1216 return nullptr;
1217 }
1218 napi_value resourceName = nullptr;
1219 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1220
1221 napi_valuetype valuetype = napi_undefined;
1222 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1223 if (valuetype == napi_function) {
1224 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &callCB->cbBase.cbInfo.callback));
1225 }
1226
1227 NAPI_CALL(env,
1228 napi_create_async_work(env,
1229 nullptr,
1230 resourceName,
1231 CallExecuteCB,
1232 CallAsyncCompleteCB,
1233 static_cast<void *>(callCB),
1234 &callCB->cbBase.asyncWork));
1235 NAPI_CALL(env, napi_queue_async_work(env, callCB->cbBase.asyncWork));
1236 napi_value result = nullptr;
1237 NAPI_CALL(env, napi_get_null(env, &result));
1238 TAG_LOGI(AAFwkTag::FA, "end");
1239 return result;
1240 }
1241
CallPromise(napi_env env,DAHelperCallCB * callCB)1242 napi_value CallPromise(napi_env env, DAHelperCallCB *callCB)
1243 {
1244 TAG_LOGI(AAFwkTag::FA, "called");
1245 if (callCB == nullptr) {
1246 TAG_LOGE(AAFwkTag::FA, "null param");
1247 return nullptr;
1248 }
1249 napi_value resourceName;
1250 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1251 napi_deferred deferred;
1252 napi_value promise = nullptr;
1253 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1254 callCB->cbBase.deferred = deferred;
1255
1256 NAPI_CALL(env,
1257 napi_create_async_work(env,
1258 nullptr,
1259 resourceName,
1260 CallExecuteCB,
1261 CallPromiseCompleteCB,
1262 static_cast<void *>(callCB),
1263 &callCB->cbBase.asyncWork));
1264 NAPI_CALL(env, napi_queue_async_work(env, callCB->cbBase.asyncWork));
1265 TAG_LOGI(AAFwkTag::FA, "end");
1266 return promise;
1267 }
1268
OpenFileAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperOpenFileCB * openFileCB)1269 napi_value OpenFileAsync(napi_env env, napi_value *args, const size_t argCallback, DAHelperOpenFileCB *openFileCB)
1270 {
1271 TAG_LOGI(AAFwkTag::FA, "called");
1272 if (args == nullptr || openFileCB == nullptr) {
1273 TAG_LOGE(AAFwkTag::FA, "null param");
1274 return nullptr;
1275 }
1276 napi_value resourceName = 0;
1277 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1278
1279 napi_valuetype valuetype = napi_undefined;
1280 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1281 if (valuetype == napi_function) {
1282 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &openFileCB->cbBase.cbInfo.callback));
1283 }
1284
1285 NAPI_CALL(env,
1286 napi_create_async_work(env,
1287 nullptr,
1288 resourceName,
1289 OpenFileExecuteCB,
1290 OpenFileAsyncCompleteCB,
1291 static_cast<void *>(openFileCB),
1292 &openFileCB->cbBase.asyncWork));
1293 NAPI_CALL(env, napi_queue_async_work_with_qos(env, openFileCB->cbBase.asyncWork, napi_qos_user_initiated));
1294 napi_value result = nullptr;
1295 NAPI_CALL(env, napi_get_null(env, &result));
1296 TAG_LOGI(AAFwkTag::FA, "end");
1297 return result;
1298 }
1299
OpenFilePromise(napi_env env,DAHelperOpenFileCB * openFileCB)1300 napi_value OpenFilePromise(napi_env env, DAHelperOpenFileCB *openFileCB)
1301 {
1302 TAG_LOGI(AAFwkTag::FA, "called");
1303 if (openFileCB == nullptr) {
1304 TAG_LOGE(AAFwkTag::FA, "null param");
1305 return nullptr;
1306 }
1307 napi_value resourceName;
1308 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1309 napi_deferred deferred;
1310 napi_value promise = nullptr;
1311 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1312 openFileCB->cbBase.deferred = deferred;
1313
1314 NAPI_CALL(env,
1315 napi_create_async_work(env,
1316 nullptr,
1317 resourceName,
1318 OpenFileExecuteCB,
1319 OpenFilePromiseCompleteCB,
1320 static_cast<void *>(openFileCB),
1321 &openFileCB->cbBase.asyncWork));
1322 NAPI_CALL(env, napi_queue_async_work_with_qos(env, openFileCB->cbBase.asyncWork, napi_qos_user_initiated));
1323 TAG_LOGI(AAFwkTag::FA, "end");
1324 return promise;
1325 }
1326
OpenFileExecuteCB(napi_env env,void * data)1327 void OpenFileExecuteCB(napi_env env, void *data)
1328 {
1329 TAG_LOGI(AAFwkTag::FA, "called");
1330 DAHelperOpenFileCB *OpenFileCB = static_cast<DAHelperOpenFileCB *>(data);
1331 auto dataAbilityHelper = OpenFileCB->dataAbilityHelper;
1332 if (dataAbilityHelper != nullptr) {
1333 OpenFileCB->execResult = INVALID_PARAMETER;
1334 if (!OpenFileCB->uri.empty()) {
1335 OHOS::Uri uri(OpenFileCB->uri);
1336 OpenFileCB->result = dataAbilityHelper->OpenFile(uri, OpenFileCB->mode);
1337 OpenFileCB->execResult = NO_ERROR;
1338 } else {
1339 TAG_LOGE(AAFwkTag::FA, "empty uri");
1340 }
1341 } else {
1342 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
1343 }
1344 TAG_LOGI(AAFwkTag::FA, "end");
1345 }
1346
OpenFileAsyncCompleteCB(napi_env env,napi_status status,void * data)1347 void OpenFileAsyncCompleteCB(napi_env env, napi_status status, void *data)
1348 {
1349 TAG_LOGI(AAFwkTag::FA, "called");
1350 DAHelperOpenFileCB *OpenFileCB = static_cast<DAHelperOpenFileCB *>(data);
1351 napi_value callback = nullptr;
1352 napi_value undefined = nullptr;
1353 napi_value result[ARGS_TWO] = {nullptr};
1354 napi_value callResult = nullptr;
1355 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1356 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, OpenFileCB->cbBase.cbInfo.callback, &callback));
1357
1358 result[PARAM0] = GetCallbackErrorValue(env, OpenFileCB->execResult);
1359 napi_create_int32(env, OpenFileCB->result, &result[PARAM1]);
1360 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1361
1362 if (OpenFileCB->cbBase.cbInfo.callback != nullptr) {
1363 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, OpenFileCB->cbBase.cbInfo.callback));
1364 }
1365 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, OpenFileCB->cbBase.asyncWork));
1366 delete OpenFileCB;
1367 OpenFileCB = nullptr;
1368 TAG_LOGI(AAFwkTag::FA, "end");
1369 }
1370
OpenFilePromiseCompleteCB(napi_env env,napi_status status,void * data)1371 void OpenFilePromiseCompleteCB(napi_env env, napi_status status, void *data)
1372 {
1373 TAG_LOGI(AAFwkTag::FA, "called");
1374 DAHelperOpenFileCB *OpenFileCB = static_cast<DAHelperOpenFileCB *>(data);
1375 napi_value result = nullptr;
1376 napi_create_int32(env, OpenFileCB->result, &result);
1377 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, OpenFileCB->cbBase.deferred, result));
1378 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, OpenFileCB->cbBase.asyncWork));
1379 delete OpenFileCB;
1380 OpenFileCB = nullptr;
1381 TAG_LOGI(AAFwkTag::FA, "end");
1382 }
1383
BatchInsertAsync(napi_env env,napi_value * args,const size_t argCallback,DAHelperBatchInsertCB * batchInsertCB)1384 napi_value BatchInsertAsync(
1385 napi_env env, napi_value *args, const size_t argCallback, DAHelperBatchInsertCB *batchInsertCB)
1386 {
1387 TAG_LOGI(AAFwkTag::FA, "called");
1388 if (args == nullptr || batchInsertCB == nullptr) {
1389 TAG_LOGE(AAFwkTag::FA, "null param");
1390 return nullptr;
1391 }
1392 napi_value resourceName = nullptr;
1393 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1394
1395 napi_valuetype valuetype = napi_undefined;
1396 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1397 if (valuetype == napi_function) {
1398 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &batchInsertCB->cbBase.cbInfo.callback));
1399 }
1400
1401 NAPI_CALL(env,
1402 napi_create_async_work(env,
1403 nullptr,
1404 resourceName,
1405 BatchInsertExecuteCB,
1406 BatchInsertAsyncCompleteCB,
1407 static_cast<void *>(batchInsertCB),
1408 &batchInsertCB->cbBase.asyncWork));
1409 NAPI_CALL(env, napi_queue_async_work(env, batchInsertCB->cbBase.asyncWork));
1410 napi_value result = nullptr;
1411 NAPI_CALL(env, napi_get_null(env, &result));
1412 TAG_LOGI(AAFwkTag::FA, "end");
1413 return result;
1414 }
1415
BatchInsertPromise(napi_env env,DAHelperBatchInsertCB * batchInsertCB)1416 napi_value BatchInsertPromise(napi_env env, DAHelperBatchInsertCB *batchInsertCB)
1417 {
1418 TAG_LOGI(AAFwkTag::FA, "called");
1419 if (batchInsertCB == nullptr) {
1420 TAG_LOGE(AAFwkTag::FA, "null param");
1421 return nullptr;
1422 }
1423 napi_value resourceName;
1424 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1425 napi_deferred deferred;
1426 napi_value promise = nullptr;
1427 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1428 batchInsertCB->cbBase.deferred = deferred;
1429
1430 NAPI_CALL(env,
1431 napi_create_async_work(env,
1432 nullptr,
1433 resourceName,
1434 BatchInsertExecuteCB,
1435 BatchInsertPromiseCompleteCB,
1436 static_cast<void *>(batchInsertCB),
1437 &batchInsertCB->cbBase.asyncWork));
1438 NAPI_CALL(env, napi_queue_async_work(env, batchInsertCB->cbBase.asyncWork));
1439 TAG_LOGI(AAFwkTag::FA, "end");
1440 return promise;
1441 }
1442
BatchInsertExecuteCB(napi_env env,void * data)1443 void BatchInsertExecuteCB(napi_env env, void *data)
1444 {
1445 TAG_LOGI(AAFwkTag::FA, "called");
1446 DAHelperBatchInsertCB *batchInsertCB = static_cast<DAHelperBatchInsertCB *>(data);
1447 auto dataAbilityHelper = batchInsertCB->dataAbilityHelper;
1448 if (dataAbilityHelper != nullptr) {
1449 batchInsertCB->execResult = INVALID_PARAMETER;
1450 if (!batchInsertCB->uri.empty()) {
1451 OHOS::Uri uri(batchInsertCB->uri);
1452 batchInsertCB->result = dataAbilityHelper->BatchInsert(uri, batchInsertCB->values);
1453 batchInsertCB->execResult = NO_ERROR;
1454 } else {
1455 TAG_LOGE(AAFwkTag::FA, "empty uri");
1456 }
1457 } else {
1458 TAG_LOGE(AAFwkTag::FA, "null dataAbilityHelper");
1459 }
1460 TAG_LOGI(AAFwkTag::FA, "end");
1461 }
1462
BatchInsertAsyncCompleteCB(napi_env env,napi_status status,void * data)1463 void BatchInsertAsyncCompleteCB(napi_env env, napi_status status, void *data)
1464 {
1465 TAG_LOGI(AAFwkTag::FA, "called");
1466 DAHelperBatchInsertCB *BatchInsertCB = static_cast<DAHelperBatchInsertCB *>(data);
1467 napi_value callback = nullptr;
1468 napi_value undefined = nullptr;
1469 napi_value result[ARGS_TWO] = {nullptr};
1470 napi_value callResult = nullptr;
1471 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1472 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, BatchInsertCB->cbBase.cbInfo.callback, &callback));
1473
1474 result[PARAM0] = GetCallbackErrorValue(env, BatchInsertCB->execResult);
1475 napi_create_int32(env, BatchInsertCB->result, &result[PARAM1]);
1476 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1477
1478 if (BatchInsertCB->cbBase.cbInfo.callback != nullptr) {
1479 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, BatchInsertCB->cbBase.cbInfo.callback));
1480 }
1481 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, BatchInsertCB->cbBase.asyncWork));
1482 delete BatchInsertCB;
1483 BatchInsertCB = nullptr;
1484 TAG_LOGI(AAFwkTag::FA, "end");
1485 }
1486
BatchInsertPromiseCompleteCB(napi_env env,napi_status status,void * data)1487 void BatchInsertPromiseCompleteCB(napi_env env, napi_status status, void *data)
1488 {
1489 TAG_LOGI(AAFwkTag::FA, "called");
1490 DAHelperBatchInsertCB *BatchInsertCB = static_cast<DAHelperBatchInsertCB *>(data);
1491 napi_value result = nullptr;
1492 napi_create_int32(env, BatchInsertCB->result, &result);
1493 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, BatchInsertCB->cbBase.deferred, result));
1494 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, BatchInsertCB->cbBase.asyncWork));
1495 delete BatchInsertCB;
1496 BatchInsertCB = nullptr;
1497 TAG_LOGI(AAFwkTag::FA, "end");
1498 }
1499
QuerySync(napi_env env,napi_value * args,const size_t argCallback,DAHelperQueryCB * queryCB)1500 napi_value QuerySync(napi_env env, napi_value *args, const size_t argCallback, DAHelperQueryCB *queryCB)
1501 {
1502 TAG_LOGD(AAFwkTag::FA, "called");
1503 if (args == nullptr || queryCB == nullptr) {
1504 TAG_LOGE(AAFwkTag::FA, "null param");
1505 return nullptr;
1506 }
1507
1508 napi_valuetype valuetype = napi_undefined;
1509 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1510 if (valuetype == napi_function) {
1511 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &queryCB->cbBase.cbInfo.callback));
1512 }
1513
1514 auto dataAbilityHelper = queryCB->dataAbilityHelper;
1515 if (dataAbilityHelper != nullptr) {
1516 queryCB->execResult = INVALID_PARAMETER;
1517 if (!queryCB->uri.empty()) {
1518 OHOS::Uri uri(queryCB->uri);
1519 auto resultset = dataAbilityHelper->Query(uri, queryCB->columns, queryCB->predicates);
1520 if (resultset != nullptr) {
1521 queryCB->result = resultset;
1522 queryCB->execResult = NO_ERROR;
1523 }
1524 }
1525 }
1526
1527 napi_value callback = nullptr;
1528 NAPI_CALL(env, napi_get_reference_value(env, queryCB->cbBase.cbInfo.callback, &callback));
1529 napi_value result[ARGS_TWO] = {nullptr};
1530 result[PARAM0] = GetCallbackErrorValue(env, queryCB->execResult);
1531 result[PARAM1] = WrapResultSet(env, queryCB->result);
1532 napi_value undefined = nullptr;
1533 NAPI_CALL(env, napi_get_undefined(env, &undefined));
1534 napi_value callResult = nullptr;
1535 NAPI_CALL(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1536
1537 if (queryCB->cbBase.cbInfo.callback != nullptr) {
1538 NAPI_CALL(env, napi_delete_reference(env, queryCB->cbBase.cbInfo.callback));
1539 }
1540 delete queryCB;
1541 queryCB = nullptr;
1542
1543 napi_value ret = nullptr;
1544 NAPI_CALL(env, napi_get_null(env, &ret));
1545 return ret;
1546 }
1547
QueryPromise(napi_env env,DAHelperQueryCB * queryCB)1548 napi_value QueryPromise(napi_env env, DAHelperQueryCB *queryCB)
1549 {
1550 TAG_LOGD(AAFwkTag::FA, "called");
1551 if (queryCB == nullptr) {
1552 TAG_LOGE(AAFwkTag::FA, "null queryCB");
1553 return nullptr;
1554 }
1555
1556 auto dataAbilityHelper = queryCB->dataAbilityHelper;
1557 if (dataAbilityHelper != nullptr) {
1558 if (!queryCB->uri.empty()) {
1559 OHOS::Uri uri(queryCB->uri);
1560 auto resultset = dataAbilityHelper->Query(uri, queryCB->columns, queryCB->predicates);
1561 if (resultset != nullptr) {
1562 queryCB->result = resultset;
1563 }
1564 }
1565 }
1566
1567 napi_deferred deferred;
1568 napi_value promise = nullptr;
1569 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1570 napi_value result = WrapResultSet(env, queryCB->result);
1571 NAPI_CALL(env, napi_resolve_deferred(env, deferred, result));
1572 delete queryCB;
1573 queryCB = nullptr;
1574
1575 return promise;
1576 }
1577
WrapResultSet(napi_env env,const std::shared_ptr<NativeRdb::AbsSharedResultSet> & resultSet)1578 napi_value WrapResultSet(napi_env env, const std::shared_ptr<NativeRdb::AbsSharedResultSet> &resultSet)
1579 {
1580 TAG_LOGD(AAFwkTag::FA, "called");
1581 if (resultSet == nullptr) {
1582 TAG_LOGE(AAFwkTag::FA, "null resultSet");
1583 return WrapVoidToJS(env);
1584 }
1585
1586 return RdbJsKit::ResultSetProxy::NewInstance(env, resultSet);
1587 }
1588
ExecuteBatchAsync(napi_env env,napi_value * args,size_t argcAsync,const size_t argcPromise,DAHelperExecuteBatchCB * executeBatchCB)1589 napi_value ExecuteBatchAsync(
1590 napi_env env, napi_value *args, size_t argcAsync, const size_t argcPromise, DAHelperExecuteBatchCB *executeBatchCB)
1591 {
1592 TAG_LOGI(AAFwkTag::FA, "called");
1593 if (args == nullptr || executeBatchCB == nullptr) {
1594 TAG_LOGE(AAFwkTag::FA, "null param");
1595 return nullptr;
1596 }
1597 napi_value resourceName = nullptr;
1598 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1599
1600 napi_valuetype valuetype = napi_undefined;
1601 NAPI_CALL(env, napi_typeof(env, args[argcPromise], &valuetype));
1602 if (valuetype == napi_function) {
1603 NAPI_CALL(env, napi_create_reference(env, args[argcPromise], 1, &executeBatchCB->cbBase.cbInfo.callback));
1604 }
1605
1606 NAPI_CALL(env,
1607 napi_create_async_work(env,
1608 nullptr,
1609 resourceName,
1610 ExecuteBatchExecuteCB,
1611 ExecuteBatchAsyncCompleteCB,
1612 static_cast<void *>(executeBatchCB),
1613 &executeBatchCB->cbBase.asyncWork));
1614 NAPI_CALL(env, napi_queue_async_work(env, executeBatchCB->cbBase.asyncWork));
1615 napi_value result = nullptr;
1616 NAPI_CALL(env, napi_get_null(env, &result));
1617 TAG_LOGI(AAFwkTag::FA, "end");
1618 return result;
1619 }
1620
ExecuteBatchPromise(napi_env env,DAHelperExecuteBatchCB * executeBatchCB)1621 napi_value ExecuteBatchPromise(napi_env env, DAHelperExecuteBatchCB *executeBatchCB)
1622 {
1623 TAG_LOGI(AAFwkTag::FA, "called");
1624 if (executeBatchCB == nullptr) {
1625 TAG_LOGE(AAFwkTag::FA, "null param");
1626 return nullptr;
1627 }
1628 napi_value resourceName;
1629 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1630 napi_deferred deferred;
1631 napi_value promise = nullptr;
1632 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1633 executeBatchCB->cbBase.deferred = deferred;
1634
1635 NAPI_CALL(env,
1636 napi_create_async_work(env,
1637 nullptr,
1638 resourceName,
1639 ExecuteBatchExecuteCB,
1640 ExecuteBatchPromiseCompleteCB,
1641 static_cast<void *>(executeBatchCB),
1642 &executeBatchCB->cbBase.asyncWork));
1643 NAPI_CALL(env, napi_queue_async_work(env, executeBatchCB->cbBase.asyncWork));
1644 TAG_LOGI(AAFwkTag::FA, "end");
1645 return promise;
1646 }
1647
ExecuteBatchExecuteCB(napi_env env,void * data)1648 void ExecuteBatchExecuteCB(napi_env env, void *data)
1649 {
1650 TAG_LOGI(AAFwkTag::FA, "called");
1651 DAHelperExecuteBatchCB *executeBatchCB = static_cast<DAHelperExecuteBatchCB *>(data);
1652 auto dataAbilityHelper = executeBatchCB->dataAbilityHelper;
1653 if (dataAbilityHelper != nullptr) {
1654 OHOS::Uri uri(executeBatchCB->uri);
1655 executeBatchCB->result = dataAbilityHelper->ExecuteBatch(uri, executeBatchCB->operations);
1656 TAG_LOGI(AAFwkTag::FA, "%{public}s, dataAbilityHelper is not nullptr. %{public}zu",
1657 __func__, executeBatchCB->result.size());
1658 }
1659 TAG_LOGI(AAFwkTag::FA, "end");
1660 }
1661
ExecuteBatchAsyncCompleteCB(napi_env env,napi_status status,void * data)1662 void ExecuteBatchAsyncCompleteCB(napi_env env, napi_status status, void *data)
1663 {
1664 TAG_LOGI(AAFwkTag::FA, "called");
1665 DAHelperExecuteBatchCB *executeBatchCB = static_cast<DAHelperExecuteBatchCB *>(data);
1666 napi_value callback = nullptr;
1667 napi_value undefined = nullptr;
1668 napi_value result[ARGS_TWO] = {nullptr};
1669 napi_value callResult = nullptr;
1670 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1671 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, executeBatchCB->cbBase.cbInfo.callback, &callback));
1672
1673 result[PARAM0] = GetCallbackErrorValue(env, NO_ERROR);
1674 napi_create_array(env, &result[PARAM1]);
1675 GetDataAbilityResultForResult(env, executeBatchCB->result, result[PARAM1]);
1676 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1677
1678 if (executeBatchCB->cbBase.cbInfo.callback != nullptr) {
1679 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, executeBatchCB->cbBase.cbInfo.callback));
1680 }
1681 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, executeBatchCB->cbBase.asyncWork));
1682 delete executeBatchCB;
1683 executeBatchCB = nullptr;
1684 TAG_LOGI(AAFwkTag::FA, "end");
1685 }
1686
ExecuteBatchPromiseCompleteCB(napi_env env,napi_status status,void * data)1687 void ExecuteBatchPromiseCompleteCB(napi_env env, napi_status status, void *data)
1688 {
1689 TAG_LOGI(AAFwkTag::FA, "called");
1690 DAHelperExecuteBatchCB *executeBatchCB = static_cast<DAHelperExecuteBatchCB *>(data);
1691 napi_value result = nullptr;
1692 napi_create_array(env, &result);
1693 GetDataAbilityResultForResult(env, executeBatchCB->result, result);
1694 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, executeBatchCB->cbBase.deferred, result));
1695 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, executeBatchCB->cbBase.asyncWork));
1696 delete executeBatchCB;
1697 executeBatchCB = nullptr;
1698 TAG_LOGI(AAFwkTag::FA, "end");
1699 }
1700
GetDataAbilityResultForResult(napi_env env,const std::vector<std::shared_ptr<DataAbilityResult>> & dataAbilityResult,napi_value result)1701 void GetDataAbilityResultForResult(
1702 napi_env env, const std::vector<std::shared_ptr<DataAbilityResult>> &dataAbilityResult, napi_value result)
1703 {
1704 TAG_LOGI(AAFwkTag::FA, "size:%{public}zu", dataAbilityResult.size());
1705 int32_t index = 0;
1706 std::vector<std::shared_ptr<DataAbilityResult>> entities = dataAbilityResult;
1707 for (const auto &item : entities) {
1708 napi_value objDataAbilityResult;
1709 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objDataAbilityResult));
1710
1711 napi_value uri;
1712 NAPI_CALL_RETURN_VOID(
1713 env, napi_create_string_utf8(env, item->GetUri().ToString().c_str(), NAPI_AUTO_LENGTH, &uri));
1714 TAG_LOGI(AAFwkTag::FA, "uri= [%{public}s]", item->GetUri().ToString().c_str());
1715 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objDataAbilityResult, "uri", uri));
1716
1717 napi_value count;
1718 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, item->GetCount(), &count));
1719 TAG_LOGI(AAFwkTag::FA, "count= [%{public}d]", item->GetCount());
1720 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objDataAbilityResult, "count", count));
1721
1722 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, objDataAbilityResult));
1723 index++;
1724 }
1725 TAG_LOGI(AAFwkTag::FA, "end");
1726 }
1727
GetDataAbilityHelper(napi_env env,napi_value thisVar,std::shared_ptr<DataAbilityHelper> & dataAbilityHelper)1728 void GetDataAbilityHelper(napi_env env, napi_value thisVar, std::shared_ptr<DataAbilityHelper>& dataAbilityHelper)
1729 {
1730 NAPIDataAbilityHelperWrapper* wrapper = nullptr;
1731 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&wrapper));
1732 if (wrapper != nullptr) {
1733 dataAbilityHelper = wrapper->GetDataAbilityHelper();
1734 }
1735 }
1736 } // AppExecFwk
1737 } // OHOS