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