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