1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define LOG_TAG "UnifiedDataChannelNapi"
16 #include "unified_data_channel_napi.h"
17
18 #include "async_task_params.h"
19 #include "napi_data_utils.h"
20 #include "unified_data_napi.h"
21
22 namespace OHOS {
23 namespace UDMF {
24 using namespace OHOS::AppExecFwk;
UnifiedDataChannelInit(napi_env env,napi_value exports)25 napi_value UnifiedDataChannelNapi::UnifiedDataChannelInit(napi_env env, napi_value exports)
26 {
27 LOG_DEBUG(UDMF_KITS_NAPI, "UnifiedDataChannelNapi");
28 napi_value intention = CreateIntention(env);
29 napi_property_descriptor desc[] = {
30 DECLARE_NAPI_PROPERTY("Intention", intention),
31 DECLARE_NAPI_FUNCTION("insertData", InsertData),
32 DECLARE_NAPI_FUNCTION("updateData", UpdateData),
33 DECLARE_NAPI_FUNCTION("queryData", QueryData),
34 DECLARE_NAPI_FUNCTION("deleteData", DeleteData),
35 DECLARE_NAPI_FUNCTION("convertRecordsToEntries", ConvertRecordsToEntries),
36 DECLARE_NAPI_GETTER("ShareOptions", CreateShareOptions),
37 DECLARE_NAPI_FUNCTION("setAppShareOptions", SetAppShareOptions),
38 DECLARE_NAPI_FUNCTION("removeAppShareOptions", RemoveAppShareOptions),
39 DECLARE_NAPI_GETTER("FileConflictOptions", CreateFileConflictOptions),
40 DECLARE_NAPI_GETTER("ProgressIndicator", CreateProgressIndicator),
41 DECLARE_NAPI_GETTER("ListenerStatus", CreateListenerStatus),
42 };
43
44 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
45 return exports;
46 }
47
CreateIntention(napi_env env)48 napi_value UnifiedDataChannelNapi::CreateIntention(napi_env env)
49 {
50 napi_value intention = nullptr;
51 napi_create_object(env, &intention);
52 if (intention == nullptr) {
53 LOG_ERROR(UDMF_KITS_NAPI, "create intention failed!");
54 return nullptr;
55 }
56 SetNamedProperty(env, intention, JS_UD_INTENTION_NAME_MAP.at(UD_INTENTION_DATA_HUB),
57 UD_INTENTION_MAP.at(UD_INTENTION_DATA_HUB));
58 SetNamedProperty(env, intention, JS_UD_INTENTION_NAME_MAP.at(UD_INTENTION_DRAG),
59 UD_SYSTEM_INTENTION_MAP.at(UD_INTENTION_DRAG));
60 napi_object_freeze(env, intention);
61 return intention;
62 }
63
SetNamedProperty(napi_env env,napi_value & obj,const std::string & name,const std::string & value)64 napi_status UnifiedDataChannelNapi::SetNamedProperty(napi_env env, napi_value &obj, const std::string &name,
65 const std::string &value)
66 {
67 napi_value property = nullptr;
68 napi_status status = NapiDataUtils::SetValue(env, value, property);
69 ASSERT(status == napi_ok, "string to napi_value failed!", status);
70 status = napi_set_named_property(env, obj, name.c_str(), property);
71 ASSERT(status == napi_ok, "napi_set_named_property failed!", status);
72 return status;
73 }
74
InsertData(napi_env env,napi_callback_info info)75 napi_value UnifiedDataChannelNapi::InsertData(napi_env env, napi_callback_info info)
76 {
77 LOG_DEBUG(UDMF_KITS_NAPI, "InsertData is called!");
78 struct InsertContext : public ContextBase {
79 std::string key;
80 Intention intention;
81 std::shared_ptr<UnifiedData> unifiedData;
82 };
83 std::string intention;
84 UnifiedDataNapi *unifiedDataNapi = nullptr;
85 auto ctxt = std::make_shared<InsertContext>();
86 auto input = [env, ctxt, &intention, &unifiedDataNapi](size_t argc, napi_value *argv) {
87 // require 2 arguments <options, unifiedData>
88 ASSERT_BUSINESS_ERR(ctxt, argc >= 2,
89 E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
90 ctxt->status = GetNamedProperty(env, argv[0], "intention", intention);
91 ASSERT_BUSINESS_ERR(ctxt, UnifiedDataUtils::GetIntentionByString(intention) != UD_INTENTION_DRAG,
92 E_INVALID_PARAMETERS, "Parameter error: The intention parameter is invalid");
93 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok && UnifiedDataUtils::IsPersist(intention),
94 E_INVALID_PARAMETERS, "Parameter error: parameter options intention type must correspond to Intention");
95 ctxt->status = napi_unwrap(env, argv[1], reinterpret_cast<void **>(&unifiedDataNapi));
96 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
97 "Parameter error: parameter data type must be UnifiedData");
98 };
99 ctxt->GetCbInfo(env, info, input);
100 ASSERT_NULL(!ctxt->isThrowError, "Insert Exit");
101 ctxt->unifiedData = unifiedDataNapi->value_;
102 ctxt->intention = UnifiedDataUtils::GetIntentionByString(intention);
103 auto execute = [ctxt]() {
104 CustomOption option = { .intention = ctxt->intention };
105 auto status = UdmfClient::GetInstance().SetData(option, *(ctxt->unifiedData), ctxt->key);
106 ASSERT_WITH_ERRCODE(ctxt, status == E_OK, status, "InsertData failed!");
107 };
108
109 auto output = [env, ctxt](napi_value &result) {
110 ctxt->status = NapiDataUtils::SetValue(env, ctxt->key, result);
111 ASSERT_WITH_ERRCODE(ctxt, ctxt->status == napi_ok, E_ERROR, "output failed!");
112 };
113 return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute, output);
114 }
115
UpdateData(napi_env env,napi_callback_info info)116 napi_value UnifiedDataChannelNapi::UpdateData(napi_env env, napi_callback_info info)
117 {
118 LOG_DEBUG(UDMF_KITS_NAPI, "UpdateData is called!");
119 struct UpdateContext : public ContextBase {
120 std::string key;
121 std::shared_ptr<UnifiedData> unifiedData;
122 };
123 std::string key;
124 UnifiedDataNapi *unifiedDataNapi = nullptr;
125 auto ctxt = std::make_shared<UpdateContext>();
126 auto input = [env, ctxt, &unifiedDataNapi](size_t argc, napi_value *argv) {
127 // require 2 arguments <options, unifiedData>
128 ASSERT_BUSINESS_ERR(ctxt, argc >= 2,
129 E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
130 ctxt->status = GetNamedProperty(env, argv[0], "key", ctxt->key);
131 UnifiedKey key(ctxt->key);
132 ASSERT_BUSINESS_ERR(ctxt,
133 ctxt->status == napi_ok && key.IsValid() && UnifiedDataUtils::IsPersist(key.intention),
134 E_INVALID_PARAMETERS, "Parameter error: parameter options intention type must correspond to Intention");
135 ctxt->status = napi_unwrap(env, argv[1], reinterpret_cast<void **>(&unifiedDataNapi));
136 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
137 "Parameter error: parameter data type must be UnifiedData");
138 };
139 ctxt->GetCbInfo(env, info, input);
140 ASSERT_NULL(!ctxt->isThrowError, "Update Exit");
141 ctxt->unifiedData = unifiedDataNapi->value_;
142 auto execute = [ctxt]() {
143 QueryOption option = { .key = ctxt->key };
144 auto status = UdmfClient::GetInstance().UpdateData(option, *(ctxt->unifiedData));
145 if (status == E_INVALID_PARAMETERS) {
146 ASSERT_WITH_ERRCODE(ctxt, status == E_OK, E_INVALID_PARAMETERS, "UpdateData failed");
147 }
148 };
149 return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute);
150 }
151
QueryData(napi_env env,napi_callback_info info)152 napi_value UnifiedDataChannelNapi::QueryData(napi_env env, napi_callback_info info)
153 {
154 LOG_DEBUG(UDMF_KITS_NAPI, "QueryData is called!");
155 struct QueryContext : public ContextBase {
156 std::string key;
157 Intention intention;
158 std::vector<UnifiedData> unifiedDataSet;
159 };
160 std::string intention;
161 auto ctxt = std::make_shared<QueryContext>();
162 auto input = [env, ctxt, &intention](size_t argc, napi_value *argv) {
163 // require 1 arguments <options>
164 ASSERT_BUSINESS_ERR(ctxt, argc >= 1,
165 E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
166 napi_status keyStatus;
167 napi_status intentionStatus;
168 auto options = argv[0];
169 keyStatus = GetNamedProperty(env, options, "key", ctxt->key);
170 intentionStatus = GetNamedProperty(env, options, "intention", intention);
171 ASSERT_BUSINESS_ERR(ctxt, UnifiedDataUtils::GetIntentionByString(intention) != UD_INTENTION_DRAG,
172 E_INVALID_PARAMETERS, "Parameter error: The intention parameter is invalid");
173 UnifiedKey key(ctxt->key);
174 ASSERT_BUSINESS_ERR(ctxt, (keyStatus == napi_ok || intentionStatus == napi_ok) &&
175 UnifiedDataUtils::IsValidOptions(key, intention),
176 E_INVALID_PARAMETERS, "Parameter error: parameter options intention type must correspond to Intention");
177 };
178 ctxt->GetCbInfo(env, info, input);
179 ASSERT_NULL(!ctxt->isThrowError, "Query Exit");
180 ctxt->intention = UnifiedDataUtils::GetIntentionByString(intention);
181 auto execute = [env, ctxt]() {
182 QueryOption option = {
183 .key = ctxt->key,
184 .intention = ctxt->intention,
185 };
186 auto status = UdmfClient::GetInstance().GetBatchData(option, ctxt->unifiedDataSet);
187 LOG_DEBUG(UDMF_SERVICE, "GetBatchData : status = %{public}d!", status);
188 ASSERT_WITH_ERRCODE(ctxt, status == E_OK, status, "QueryData failed!");
189 };
190 auto output = [env, ctxt](napi_value &result) {
191 ctxt->status = ConvertUnifiedDataSetToNapi(env, ctxt->unifiedDataSet, result);
192 ASSERT_WITH_ERRCODE(ctxt, ctxt->status == napi_ok, E_ERROR, "ConvertUnifiedDataSetToNapi failed!");
193 };
194 return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute, output);
195 }
196
DeleteData(napi_env env,napi_callback_info info)197 napi_value UnifiedDataChannelNapi::DeleteData(napi_env env, napi_callback_info info)
198 {
199 LOG_DEBUG(UDMF_KITS_NAPI, "DeleteData is called!");
200 struct DeleteContext : public ContextBase {
201 std::string key;
202 Intention intention;
203 std::vector<UnifiedData> unifiedDataSet;
204 };
205 std::string intention;
206 auto ctxt = std::make_shared<DeleteContext>();
207 auto input = [env, ctxt, &intention](size_t argc, napi_value *argv) {
208 // require 1 arguments <options>
209 ASSERT_BUSINESS_ERR(ctxt, argc >= 1,
210 E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
211 napi_status keyStatus;
212 napi_status intentionStatus;
213 napi_value options = argv[0];
214 keyStatus = GetNamedProperty(env, options, "key", ctxt->key);
215 intentionStatus = GetNamedProperty(env, options, "intention", intention);
216 ASSERT_BUSINESS_ERR(ctxt, intention.empty() ||
217 UnifiedDataUtils::GetIntentionByString(intention) == UD_INTENTION_DATA_HUB,
218 E_INVALID_PARAMETERS, "Parameter error: The intention parameter is invalid");
219 UnifiedKey key(ctxt->key);
220 ASSERT_BUSINESS_ERR(ctxt,
221 (keyStatus == napi_ok || intentionStatus == napi_ok) &&
222 UnifiedDataUtils::IsValidOptions(key, intention),
223 E_INVALID_PARAMETERS, "Parameter error: parameter options intention type must correspond to Intention");
224 };
225 ctxt->GetCbInfo(env, info, input);
226 ASSERT_NULL(!ctxt->isThrowError, "Delete Exit");
227 ctxt->intention = UnifiedDataUtils::GetIntentionByString(intention);
228 auto execute = [env, ctxt]() {
229 QueryOption option = {
230 .key = ctxt->key,
231 .intention = ctxt->intention,
232 };
233 auto status = UdmfClient::GetInstance().DeleteData(option, ctxt->unifiedDataSet);
234 ASSERT_WITH_ERRCODE(ctxt, status == E_OK, status, "DeleteData failed!");
235 };
236
237 auto output = [env, ctxt](napi_value &result) {
238 ctxt->status = ConvertUnifiedDataSetToNapi(env, ctxt->unifiedDataSet, result);
239 ASSERT_WITH_ERRCODE(ctxt, ctxt->status == napi_ok, E_ERROR, "ConvertUnifiedDataSetToNapi failed!");
240 };
241 return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute, output);
242 }
243
ConvertRecordsToEntries(napi_env env,napi_callback_info info)244 napi_value UnifiedDataChannelNapi::ConvertRecordsToEntries(napi_env env, napi_callback_info info)
245 {
246 LOG_DEBUG(UDMF_KITS_NAPI, "ConvertRecordsToEntries is called!");
247 struct ConvertContext : public ContextBase {
248 std::shared_ptr<UnifiedData> unifiedData;
249 };
250 UnifiedDataNapi *unifiedDataNapi = nullptr;
251 auto ctxt = std::make_shared<ConvertContext>();
252 auto input = [env, ctxt, &unifiedDataNapi](size_t argc, napi_value *argv) {
253 ASSERT_BUSINESS_ERR(ctxt, argc == 1,
254 E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
255 ctxt->status = napi_unwrap(env, argv[0], reinterpret_cast<void **>(&unifiedDataNapi));
256 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
257 "Parameter error: parameter data type must be UnifiedData");
258 };
259 ctxt->GetCbInfo(env, info, input);
260 ASSERT_NULL(!ctxt->isThrowError, "ConvertRecordsToEntries Exit");
261 ctxt->unifiedData = unifiedDataNapi->value_;
262 ctxt->unifiedData->ConvertRecordsToEntries();
263 return nullptr;
264 }
265
GetNamedProperty(napi_env env,napi_value & obj,const std::string & key,std::string & value)266 napi_status UnifiedDataChannelNapi::GetNamedProperty(napi_env env, napi_value &obj, const std::string &key,
267 std::string &value)
268 {
269 bool hasKey = false;
270 napi_status status = napi_has_named_property(env, obj, key.c_str(), &hasKey);
271 if (status != napi_ok) {
272 LOG_ERROR(UDMF_KITS_NAPI, "napi_has_named_property failed, name = %{public}s", key.c_str());
273 return napi_generic_failure;
274 }
275 if (!hasKey) {
276 LOG_ERROR(UDMF_KITS_NAPI, "The property name is non-existent, name: %{public}s", key.c_str());
277 return napi_generic_failure;
278 }
279 napi_value napiValue = nullptr;
280 status = napi_get_named_property(env, obj, key.c_str(), &napiValue);
281 if (status != napi_ok || napiValue == nullptr) {
282 LOG_ERROR(UDMF_KITS_NAPI, "napi_get_named_property failed, name = %{public}s", key.c_str());
283 return napi_generic_failure;
284 }
285 if (NapiDataUtils::IsNull(env, napiValue)) {
286 LOG_ERROR(UDMF_KITS_NAPI, "The property value is null, name = %{public}s", key.c_str());
287 return napi_generic_failure;
288 }
289 status = NapiDataUtils::GetValue(env, napiValue, value);
290 if (status != napi_ok) {
291 LOG_ERROR(UDMF_KITS_NAPI, "NapiDataUtils::GetValue failed, name = %{public}s", key.c_str());
292 return status;
293 }
294 LOG_DEBUG(UDMF_KITS_NAPI, "Param parse successful, Options.%{public}s = %{public}s", key.c_str(), value.c_str());
295 return status;
296 }
297
CreateShareOptions(napi_env env,napi_callback_info info)298 napi_value UnifiedDataChannelNapi::CreateShareOptions(napi_env env, napi_callback_info info)
299 {
300 napi_value jsShareOptions = nullptr;
301 napi_create_object(env, &jsShareOptions);
302
303 napi_value jsInApp;
304 NapiDataUtils::SetValue(env, static_cast<int32_t>(ShareOptions::IN_APP), jsInApp);
305 NAPI_CALL(env, napi_set_named_property(env, jsShareOptions, "IN_APP", jsInApp));
306
307 napi_value jsCrossDevice;
308 NapiDataUtils::SetValue(env, static_cast<int32_t>(ShareOptions::CROSS_APP), jsCrossDevice);
309 NAPI_CALL(env, napi_set_named_property(env, jsShareOptions, "CROSS_APP", jsCrossDevice));
310 return jsShareOptions;
311 }
312
SetAppShareOptions(napi_env env,napi_callback_info info)313 napi_value UnifiedDataChannelNapi::SetAppShareOptions(napi_env env, napi_callback_info info)
314 {
315 LOG_DEBUG(UDMF_KITS_NAPI, "SetAppShareOption is called!");
316 std::string intention;
317 int32_t shareOptionValue = ShareOptions::CROSS_APP;
318 auto ctxt = std::make_shared<ContextBase>();
319 auto input = [env, ctxt, &intention, &shareOptionValue](size_t argc, napi_value* argv) {
320 LOG_DEBUG(UDMF_KITS_NAPI, "set appShareOption, argc = %{public}zu !", argc);
321 // required 2 arguments : intention, shareOption
322 ASSERT_BUSINESS_ERR(ctxt, argc > 1,
323 Status::E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
324 ctxt->status = NapiDataUtils::GetValue(env, argv[0], intention);
325 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
326 "Parameter error:The parameter intention must be within the scope of the Intention enumeration.");
327 ctxt->status = NapiDataUtils::GetValue(env, argv[1], shareOptionValue);
328 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
329 "Parameter error:The parameter shareOption must be within the scope of the ShareOptions enumeration.");
330 };
331 ctxt->GetCbInfoSync(env, info, input);
332 ASSERT_NULL(!ctxt->isThrowError, "SetAppShareOption Exit");
333 auto status = E_OK;
334 ASSERT_ERR(ctxt->env, intention == "Drag",
335 E_INVALID_PARAMETERS, "Parameter error: The intention parameter is invalid!");
336 ASSERT_ERR(ctxt->env, (shareOptionValue >= IN_APP && shareOptionValue < SHARE_OPTIONS_BUTT),
337 E_INVALID_PARAMETERS, "Parameter error: The shareOptions parameter is invalid!");
338 std::transform(intention.begin(), intention.end(), intention.begin(), ::tolower); // js : Drag --> drag
339 status = UdmfClient::GetInstance().SetAppShareOption(intention, static_cast<ShareOptions>(shareOptionValue));
340 ASSERT_BUSINESS_ERR_VOID(ctxt, !(status == E_SETTINGS_EXISTED), E_SETTINGS_EXISTED, "Settings already exist!");
341 ASSERT_BUSINESS_ERR_VOID(ctxt, status != E_NO_PERMISSION, E_NO_PERMISSION, "Permission denied!");
342 ASSERT_ERR(ctxt->env, status == E_OK, status, "invalid arguments!");
343 return nullptr;
344 }
345
RemoveAppShareOptions(napi_env env,napi_callback_info info)346 napi_value UnifiedDataChannelNapi::RemoveAppShareOptions(napi_env env, napi_callback_info info)
347 {
348 LOG_DEBUG(UDMF_KITS_NAPI, "RemoveAppShareOption is called!");
349 std::string intention;
350 auto ctxt = std::make_shared<ContextBase>();
351 auto input = [env, ctxt, &intention](size_t argc, napi_value* argv) {
352 LOG_DEBUG(UDMF_KITS_NAPI, "RemoveAppShareOption, argc = %{public}zu !", argc);
353 // required 2 arguments : typeId
354 ASSERT_BUSINESS_ERR(ctxt, argc > 0,
355 Status::E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
356 ctxt->status = NapiDataUtils::GetValue(env, argv[0], intention);
357 ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
358 "Parameter error:The parameter intention must be within the scope of the Intention enumeration.");
359 };
360 ctxt->GetCbInfoSync(env, info, input);
361 ASSERT_NULL(!ctxt->isThrowError, "RemoveAppShareOption Exit");
362 ASSERT_ERR(ctxt->env, intention == "Drag",
363 E_INVALID_PARAMETERS, "Parameter error: The intention parameter is invalid!");
364 std::transform(intention.begin(), intention.end(), intention.begin(), ::tolower); // js : Drag --> drag
365 auto status = E_OK;
366 status = UdmfClient::GetInstance().RemoveAppShareOption(intention);
367 ASSERT_BUSINESS_ERR_VOID(ctxt, status != E_NO_PERMISSION, E_NO_PERMISSION, "Permission denied!");
368 ASSERT_ERR(ctxt->env, status == E_OK, status, "invalid arguments!");
369 return nullptr;
370 }
371
ConvertUnifiedDataSetToNapi(napi_env env,const std::vector<UnifiedData> & dataSet,napi_value & output)372 napi_status UnifiedDataChannelNapi::ConvertUnifiedDataSetToNapi(
373 napi_env env, const std::vector<UnifiedData> &dataSet, napi_value &output)
374 {
375 auto status = napi_create_array_with_length(env, dataSet.size(), &output);
376 if (status != napi_ok) {
377 LOG_ERROR(UDMF_KITS_NAPI, "napi_create_array_with_length failed!");
378 return napi_generic_failure;
379 }
380 int index = 0;
381 for (const UnifiedData &data : dataSet) {
382 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
383 unifiedData->SetRecords(data.GetRecords());
384 unifiedData->SetProperties(data.GetProperties());
385 napi_value dataNapi = nullptr;
386 UnifiedDataNapi::NewInstance(env, unifiedData, dataNapi);
387 status = napi_set_element(env, output, index++, dataNapi);
388 if (status != napi_ok) {
389 LOG_ERROR(UDMF_KITS_NAPI, "napi_set_element failed!");
390 return napi_generic_failure;
391 }
392 }
393 return napi_ok;
394 }
395
CreateFileConflictOptions(napi_env env,napi_callback_info info)396 napi_value UnifiedDataChannelNapi::CreateFileConflictOptions(napi_env env, napi_callback_info info)
397 {
398 napi_value jsFileOptions = nullptr;
399 napi_create_object(env, &jsFileOptions);
400
401 napi_value jsOverWrite;
402 NapiDataUtils::SetValue(env, static_cast<int32_t>(FileConflictOptions::OVERWRITE), jsOverWrite);
403 NAPI_CALL(env, napi_set_named_property(env, jsFileOptions, "OVERWRITE", jsOverWrite));
404
405 napi_value jsSkip;
406 NapiDataUtils::SetValue(env, static_cast<int32_t>(FileConflictOptions::SKIP), jsSkip);
407 NAPI_CALL(env, napi_set_named_property(env, jsFileOptions, "SKIP", jsSkip));
408 return jsFileOptions;
409 }
410
CreateProgressIndicator(napi_env env,napi_callback_info info)411 napi_value UnifiedDataChannelNapi::CreateProgressIndicator(napi_env env, napi_callback_info info)
412 {
413 napi_value jsProgressIndicator = nullptr;
414 napi_create_object(env, &jsProgressIndicator);
415
416 napi_value jsNone;
417 NapiDataUtils::SetValue(env, static_cast<int32_t>(ProgressIndicator::NONE), jsNone);
418 NAPI_CALL(env, napi_set_named_property(env, jsProgressIndicator, "NONE", jsNone));
419
420 napi_value jsDefault;
421 NapiDataUtils::SetValue(env, static_cast<int32_t>(ProgressIndicator::DEFAULT), jsDefault);
422 NAPI_CALL(env, napi_set_named_property(env, jsProgressIndicator, "DEFAULT", jsDefault));
423 return jsProgressIndicator;
424 }
425
CreateListenerStatus(napi_env env,napi_callback_info info)426 napi_value UnifiedDataChannelNapi::CreateListenerStatus(napi_env env, napi_callback_info info)
427 {
428 napi_value jsListenerStatus = nullptr;
429 napi_create_object(env, &jsListenerStatus);
430
431 napi_value jsFinished;
432 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::FINISHED), jsFinished);
433 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "FINISHED", jsFinished));
434
435 napi_value jsProcessing;
436 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::PROCESSING), jsProcessing);
437 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "PROCESSING", jsProcessing));
438
439 napi_value jsInnerError;
440 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::INNER_ERROR), jsInnerError);
441 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "INNER_ERROR", jsInnerError));
442
443 napi_value jsInvalidPara;
444 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::INVALID_PARAMETERS), jsInvalidPara);
445 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "INVALID_PARAMETERS", jsInvalidPara));
446
447 napi_value jsSyncFail;
448 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::SYNC_FAILED), jsSyncFail);
449 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "SYNC_FAILED", jsSyncFail));
450
451 napi_value jsCopyFail;
452 NapiDataUtils::SetValue(env, static_cast<int32_t>(ListenerStatus::COPY_FILE_FAILED), jsCopyFail);
453 NAPI_CALL(env, napi_set_named_property(env, jsListenerStatus, "COPY_FILE_FAILED", jsCopyFail));
454 return jsListenerStatus;
455 }
456 } // namespace UDMF
457 } // namespace OHOS