1 /*
2 * Copyright (c) 2022-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
16 #include "napi_pasteboard_common.h"
17 #include "pasteboard_hilog.h"
18 #include "pasteboard_napi.h"
19 using namespace OHOS::MiscServices;
20 using namespace OHOS::Media;
21
22 namespace OHOS {
23 namespace MiscServicesNapi {
24 constexpr size_t MAX_ARGS = 6;
25 constexpr size_t ARGC_TYPE_SET1 = 1;
26 constexpr size_t ARGC_TYPE_SET2 = 2;
CreateHtmlRecord(napi_env env,napi_value in)27 napi_value PasteboardNapi::CreateHtmlRecord(napi_env env, napi_value in)
28 {
29 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateHtmlRecord is called!");
30 std::string value;
31 bool ret = GetValue(env, in, value);
32 if (!ret) {
33 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
34 return nullptr;
35 }
36 napi_value instance = nullptr;
37 PasteDataRecordNapi::NewHtmlTextRecordInstance(env, value, instance);
38 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
39 return instance;
40 }
41
CreatePlainTextRecord(napi_env env,napi_value in)42 napi_value PasteboardNapi::CreatePlainTextRecord(napi_env env, napi_value in)
43 {
44 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreatePlainTextRecord is called!");
45 std::string value;
46 bool ret = GetValue(env, in, value);
47 if (!ret) {
48 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
49 return nullptr;
50 }
51 napi_value instance = nullptr;
52 PasteDataRecordNapi::NewPlainTextRecordInstance(env, value, instance);
53 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
54 return instance;
55 }
56
CreateUriRecord(napi_env env,napi_value in)57 napi_value PasteboardNapi::CreateUriRecord(napi_env env, napi_value in)
58 {
59 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateUriRecord is called!");
60 std::string value;
61 bool ret = GetValue(env, in, value);
62 if (!ret) {
63 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
64 return nullptr;
65 }
66 napi_value instance = nullptr;
67 PasteDataRecordNapi::NewUriRecordInstance(env, value, instance);
68 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
69 return instance;
70 }
71
CreatePixelMapRecord(napi_env env,napi_value in)72 napi_value PasteboardNapi::CreatePixelMapRecord(napi_env env, napi_value in)
73 {
74 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreatePixelMapRecord is called!");
75 std::shared_ptr<PixelMap> pixelMap = PixelMapNapi::GetPixelMap(env, in);
76 if (pixelMap == nullptr) {
77 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to get pixelMap!");
78 return nullptr;
79 }
80 napi_value instance = nullptr;
81 PasteDataRecordNapi::NewPixelMapRecordInstance(env, pixelMap, instance);
82 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
83 return instance;
84 }
85
CreateWantRecord(napi_env env,napi_value in)86 napi_value PasteboardNapi::CreateWantRecord(napi_env env, napi_value in)
87 {
88 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateWantRecord is called!");
89 AAFwk::Want want;
90 bool ret = OHOS::AppExecFwk::UnwrapWant(env, in, want);
91 if (!ret) {
92 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to unwrap want!");
93 return nullptr;
94 }
95 napi_value instance = nullptr;
96 PasteDataRecordNapi::NewWantRecordInstance(env, std::make_shared<AAFwk::Want>(want), instance);
97 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
98 return instance;
99 }
100
101 // common function of CreateHtmlData, CreatePlainTextData, CreateUriData
CreateDataCommon(napi_env env,napi_value in,std::string & str,napi_value & instance)102 PasteDataNapi *PasteboardNapi::CreateDataCommon(napi_env env, napi_value in, std::string &str, napi_value &instance)
103 {
104 bool ret = GetValue(env, in, str);
105 if (!ret) {
106 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "GetValue failed");
107 return nullptr;
108 }
109 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
110 PasteDataNapi *obj = nullptr;
111 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
112 if (status != napi_ok) {
113 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "napi_unwrap exec error: %{public}d", status);
114 return nullptr;
115 }
116 if (obj == nullptr) {
117 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "obj is null!");
118 return nullptr;
119 }
120 return obj;
121 }
122
CreateHtmlData(napi_env env,napi_value in)123 napi_value PasteboardNapi::CreateHtmlData(napi_env env, napi_value in)
124 {
125 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateHtmlData is called!");
126 std::string str;
127 napi_value instance = nullptr;
128 PasteDataNapi *obj = CreateDataCommon(env, in, str, instance);
129 if (obj == nullptr) {
130 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "obj is null!");
131 return nullptr;
132 }
133 obj->value_ = PasteboardClient::GetInstance()->CreateHtmlData(str);
134 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
135 return instance;
136 }
137
CreatePlainTextData(napi_env env,napi_value in)138 napi_value PasteboardNapi::CreatePlainTextData(napi_env env, napi_value in)
139 {
140 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreatePlainTextData is called!");
141 std::string str;
142 napi_value instance = nullptr;
143 PasteDataNapi *obj = CreateDataCommon(env, in, str, instance);
144 if (obj == nullptr) {
145 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "obj is null!");
146 return nullptr;
147 }
148 obj->value_ = PasteboardClient::GetInstance()->CreatePlainTextData(str);
149 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
150 return instance;
151 }
152
CreateUriData(napi_env env,napi_value in)153 napi_value PasteboardNapi::CreateUriData(napi_env env, napi_value in)
154 {
155 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateUriData is called!");
156 std::string str;
157 napi_value instance = nullptr;
158 PasteDataNapi *obj = CreateDataCommon(env, in, str, instance);
159 if (obj == nullptr) {
160 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "obj is null!");
161 return nullptr;
162 }
163 obj->value_ = PasteboardClient::GetInstance()->CreateUriData(OHOS::Uri(str));
164 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
165 return instance;
166 }
167
CreatePixelMapData(napi_env env,napi_value in)168 napi_value PasteboardNapi::CreatePixelMapData(napi_env env, napi_value in)
169 {
170 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreatePixelMapData is called!");
171 std::shared_ptr<PixelMap> pixelMap = PixelMapNapi::GetPixelMap(env, in);
172 if (pixelMap == nullptr) {
173 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to get pixelMap!");
174 return nullptr;
175 }
176 napi_value instance = nullptr;
177 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
178 PasteDataNapi *obj = nullptr;
179 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
180 if ((status != napi_ok) || (obj == nullptr)) {
181 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap Failed!");
182 return nullptr;
183 }
184 obj->value_ = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMap);
185 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
186 return instance;
187 }
188
CreateWantData(napi_env env,napi_value in)189 napi_value PasteboardNapi::CreateWantData(napi_env env, napi_value in)
190 {
191 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateWantData is called!");
192 AAFwk::Want want;
193 bool ret = OHOS::AppExecFwk::UnwrapWant(env, in, want);
194 if (!ret) {
195 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to unwrap want!");
196 return nullptr;
197 }
198 napi_value instance = nullptr;
199 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
200 PasteDataNapi *obj = nullptr;
201 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
202 if ((status != napi_ok) || (obj == nullptr)) {
203 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed!");
204 return nullptr;
205 }
206 obj->value_ = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<AAFwk::Want>(want));
207 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
208 return instance;
209 }
210
CreateMultiTypeData(napi_env env,std::shared_ptr<std::vector<std::pair<std::string,std::shared_ptr<EntryValue>>>> typeValueVector)211 napi_value PasteboardNapi::CreateMultiTypeData(napi_env env,
212 std::shared_ptr<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>> typeValueVector)
213 {
214 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateMultiTypeData is called!");
215 napi_value instance = nullptr;
216 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
217 PasteDataNapi *obj = nullptr;
218 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
219 if ((status != napi_ok) || (obj == nullptr)) {
220 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed!");
221 return nullptr;
222 }
223 if (typeValueVector == nullptr || typeValueVector->empty()) {
224 return nullptr;
225 }
226 std::shared_ptr<std::map<std::string, std::shared_ptr<EntryValue>>> typeValueMap =
227 std::make_shared<std::map<std::string, std::shared_ptr<EntryValue>>>();
228 for (const auto &item : *typeValueVector) {
229 typeValueMap->emplace(item.first, item.second);
230 }
231 obj->value_ = PasteboardClient::GetInstance()->CreateMultiTypeData(std::move(typeValueMap),
232 typeValueVector->begin()->first);
233 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
234 return instance;
235 }
236
CreateMultiTypeDelayData(napi_env env,std::vector<std::string> mimeTypes,std::shared_ptr<UDMF::EntryGetter> entryGetter)237 napi_value PasteboardNapi::CreateMultiTypeDelayData(napi_env env, std::vector<std::string> mimeTypes,
238 std::shared_ptr<UDMF::EntryGetter> entryGetter)
239 {
240 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateMultiTypeDelayData is called!");
241 napi_value instance = nullptr;
242 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
243 PasteDataNapi *obj = nullptr;
244 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
245 if ((status != napi_ok) || (obj == nullptr)) {
246 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed!");
247 return nullptr;
248 }
249 obj->value_ = PasteboardClient::GetInstance()->CreateMultiTypeDelayData(mimeTypes, entryGetter);
250 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
251 return instance;
252 }
253
JScreateHtmlTextRecord(napi_env env,napi_callback_info info)254 napi_value PasteboardNapi::JScreateHtmlTextRecord(napi_env env, napi_callback_info info)
255 {
256 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateHtmlTextRecord is called!");
257 size_t argc = MAX_ARGS;
258 napi_value argv[MAX_ARGS] = { 0 };
259 napi_value thisVar = nullptr;
260
261 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
262 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
263
264 return CreateHtmlRecord(env, argv[0]);
265 }
266
JScreateWantRecord(napi_env env,napi_callback_info info)267 napi_value PasteboardNapi::JScreateWantRecord(napi_env env, napi_callback_info info)
268 {
269 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateWantRecord is called!");
270 size_t argc = MAX_ARGS;
271 napi_value argv[MAX_ARGS] = { 0 };
272 napi_value thisVar = nullptr;
273
274 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
275 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
276 napi_valuetype valueType = napi_undefined;
277 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
278 NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
279
280 return CreateWantRecord(env, argv[0]);
281 }
282
JScreateShareOption(napi_env env,napi_callback_info info)283 napi_value PasteboardNapi::JScreateShareOption(napi_env env, napi_callback_info info)
284 {
285 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateShareOption is called!");
286
287 napi_value jsShareOption = nullptr;
288 napi_create_object(env, &jsShareOption);
289
290 napi_value jsInApp = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::InApp));
291 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "InApp", jsInApp));
292 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "INAPP", jsInApp));
293
294 napi_value jsLocalDevice = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::LocalDevice));
295 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "LocalDevice", jsLocalDevice));
296 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "LOCALDEVICE", jsLocalDevice));
297
298 napi_value jsCrossDevice = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::CrossDevice));
299 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "CrossDevice", jsCrossDevice));
300 NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "CROSSDEVICE", jsCrossDevice));
301
302 return jsShareOption;
303 }
304
JScreatePattern(napi_env env,napi_callback_info info)305 napi_value PasteboardNapi::JScreatePattern(napi_env env, napi_callback_info info)
306 {
307 napi_value jsPattern = nullptr;
308 napi_create_object(env, &jsPattern);
309
310 napi_value jsURL = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::URL));
311 NAPI_CALL(env, napi_set_named_property(env, jsPattern, "URL", jsURL));
312
313 napi_value jsNumber = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::NUMBER));
314 NAPI_CALL(env, napi_set_named_property(env, jsPattern, "NUMBER", jsNumber));
315
316 napi_value jsEmailAddress = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::EMAIL_ADDRESS));
317 NAPI_CALL(env, napi_set_named_property(env, jsPattern, "EMAIL_ADDRESS", jsEmailAddress));
318
319 return jsPattern;
320 }
321
JScreateFileConflictOptions(napi_env env,napi_callback_info info)322 napi_value PasteboardNapi::JScreateFileConflictOptions(napi_env env, napi_callback_info info)
323 {
324 napi_value jsFileConflictOptions = nullptr;
325 napi_create_object(env, &jsFileConflictOptions);
326
327 napi_value jsOVERWRITE = CreateNapiNumber(env, static_cast<uint32_t>(FileConflictOption::FILE_OVERWRITE));
328 NAPI_CALL(env, napi_set_named_property(env, jsFileConflictOptions, "OVERWRITE", jsOVERWRITE));
329
330 napi_value jsSKIP = CreateNapiNumber(env, static_cast<uint32_t>(FileConflictOption::FILE_SKIP));
331 NAPI_CALL(env, napi_set_named_property(env, jsFileConflictOptions, "SKIP", jsSKIP));
332
333 return jsFileConflictOptions;
334 }
335
JScreateProgressIndicator(napi_env env,napi_callback_info info)336 napi_value PasteboardNapi::JScreateProgressIndicator(napi_env env, napi_callback_info info)
337 {
338 napi_value jsProgressIndicator = nullptr;
339 napi_create_object(env, &jsProgressIndicator);
340
341 napi_value jsNONE = CreateNapiNumber(env, static_cast<uint32_t>(ProgressIndicator::NONE_PROGRESS_INDICATOR));
342 NAPI_CALL(env, napi_set_named_property(env, jsProgressIndicator, "NONE", jsNONE));
343
344 napi_value jsDEFAULT = CreateNapiNumber(env, static_cast<uint32_t>(ProgressIndicator::DEFAULT_PROGRESS_INDICATOR));
345 NAPI_CALL(env, napi_set_named_property(env, jsProgressIndicator, "DEFAULT", jsDEFAULT));
346
347 return jsProgressIndicator;
348 }
349
JScreatePlainTextRecord(napi_env env,napi_callback_info info)350 napi_value PasteboardNapi::JScreatePlainTextRecord(napi_env env, napi_callback_info info)
351 {
352 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePlainTextRecord is called!");
353 size_t argc = MAX_ARGS;
354 napi_value argv[MAX_ARGS] = { 0 };
355 napi_value thisVar = nullptr;
356
357 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
358 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
359
360 return CreatePlainTextRecord(env, argv[0]);
361 }
362
JScreatePixelMapRecord(napi_env env,napi_callback_info info)363 napi_value PasteboardNapi::JScreatePixelMapRecord(napi_env env, napi_callback_info info)
364 {
365 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePixelMapRecord is called!");
366 size_t argc = MAX_ARGS;
367 napi_value argv[MAX_ARGS] = { 0 };
368 napi_value thisVar = nullptr;
369
370 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
371 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
372
373 napi_valuetype valueType = napi_undefined;
374 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
375 NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
376
377 return CreatePixelMapRecord(env, argv[0]);
378 }
379
JScreateUriRecord(napi_env env,napi_callback_info info)380 napi_value PasteboardNapi::JScreateUriRecord(napi_env env, napi_callback_info info)
381 {
382 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateUriRecord is called!");
383 size_t argc = MAX_ARGS;
384 napi_value argv[MAX_ARGS] = { 0 };
385 napi_value thisVar = nullptr;
386
387 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
388 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
389
390 return CreateUriRecord(env, argv[0]);
391 }
392
JSCreateRecord(napi_env env,napi_callback_info info)393 napi_value PasteboardNapi::JSCreateRecord(napi_env env, napi_callback_info info)
394 {
395 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateRecord is called!");
396 size_t argc = MAX_ARGS;
397 napi_value argv[MAX_ARGS] = { 0 };
398 napi_value thisVar = nullptr;
399 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
400 napi_valuetype type = napi_undefined;
401 NAPI_CALL(env, napi_typeof(env, argv[0], &type));
402 if (!CheckExpression(env, argc >= ARGC_TYPE_SET2, JSErrorCode::INVALID_PARAMETERS,
403 "Parameter error. The number of arguments cannot be less than two.") ||
404 !CheckExpression(env, type == napi_object || type == napi_string, JSErrorCode::INVALID_PARAMETERS,
405 "Parameter error. the first param should be object or string.")) {
406 return nullptr;
407 }
408 if (type == napi_string) {
409 std::string mimeType;
410 if (!CheckArgs(env, argv, argc, mimeType)) {
411 return nullptr;
412 }
413 auto it = createRecordMap_.find(mimeType);
414 if (it != createRecordMap_.end()) {
415 return (it->second)(env, argv[1]);
416 }
417
418 void *data = nullptr;
419 size_t dataLen = 0;
420 NAPI_CALL(env, napi_get_arraybuffer_info(env, argv[1], &data, &dataLen));
421 std::vector<uint8_t> arrayBuf(reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen);
422 napi_value instance = nullptr;
423 PasteDataRecordNapi::NewKvRecordInstance(env, mimeType, arrayBuf, instance);
424 return instance;
425 } else {
426 napi_ref provider = nullptr;
427 std::vector<std::string> mimeTypes;
428 if (!CheckArgsArray(env, argv[0], mimeTypes) ||
429 !CheckArgsFunc(env, argv[1], provider)) {
430 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "CheckArgsArray or CheckArgsFunc failed!");
431 return nullptr;
432 }
433 napi_value instance = nullptr;
434 std::shared_ptr<PastedataRecordEntryGetterInstance> entryGetter =
435 std::make_shared<PastedataRecordEntryGetterInstance>(env, provider);
436 entryGetter->GetStub()->SetEntryGetterWrapper(entryGetter);
437 PasteDataRecordNapi::NewEntryGetterRecordInstance(mimeTypes, entryGetter, instance);
438 return instance;
439 }
440 }
441
JScreateHtmlData(napi_env env,napi_callback_info info)442 napi_value PasteboardNapi::JScreateHtmlData(napi_env env, napi_callback_info info)
443 {
444 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateHtmlData is called!");
445 size_t argc = MAX_ARGS;
446 napi_value argv[MAX_ARGS] = { 0 };
447 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
448 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
449
450 return CreateHtmlData(env, argv[0]);
451 }
452
JScreateWantData(napi_env env,napi_callback_info info)453 napi_value PasteboardNapi::JScreateWantData(napi_env env, napi_callback_info info)
454 {
455 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateWantData is called!");
456 size_t argc = MAX_ARGS;
457 napi_value argv[MAX_ARGS] = { 0 };
458 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
459 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
460 napi_valuetype valueType = napi_undefined;
461 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
462 NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
463
464 return CreateWantData(env, argv[0]);
465 }
466
JScreatePlainTextData(napi_env env,napi_callback_info info)467 napi_value PasteboardNapi::JScreatePlainTextData(napi_env env, napi_callback_info info)
468 {
469 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePlainTextData is called!");
470 size_t argc = MAX_ARGS;
471 napi_value argv[MAX_ARGS] = { 0 };
472 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
473 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
474
475 return CreatePlainTextData(env, argv[0]);
476 }
477
JScreatePixelMapData(napi_env env,napi_callback_info info)478 napi_value PasteboardNapi::JScreatePixelMapData(napi_env env, napi_callback_info info)
479 {
480 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePixelMapData is called!");
481 size_t argc = MAX_ARGS;
482 napi_value argv[MAX_ARGS] = { 0 };
483 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
484 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
485 napi_valuetype valueType = napi_undefined;
486 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
487 NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
488
489 return CreatePixelMapData(env, argv[0]);
490 }
491
JScreateUriData(napi_env env,napi_callback_info info)492 napi_value PasteboardNapi::JScreateUriData(napi_env env, napi_callback_info info)
493 {
494 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateUriData is called!");
495 size_t argc = MAX_ARGS;
496 napi_value argv[MAX_ARGS] = { 0 };
497 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
498 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
499
500 return CreateUriData(env, argv[0]);
501 }
502
JSCreateKvData(napi_env env,const std::string & mimeType,const std::vector<uint8_t> & arrayBuffer)503 napi_value PasteboardNapi::JSCreateKvData(
504 napi_env env, const std::string &mimeType, const std::vector<uint8_t> &arrayBuffer)
505 {
506 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateKvData is called!");
507
508 napi_value instance = nullptr;
509 NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
510 PasteDataNapi *obj = nullptr;
511 napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
512 if ((status != napi_ok) || (obj == nullptr)) {
513 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed!");
514 return nullptr;
515 }
516
517 obj->value_ = PasteboardClient::GetInstance()->CreateKvData(mimeType, arrayBuffer);
518 return instance;
519 }
520
JSCreateData(napi_env env,napi_callback_info info)521 napi_value PasteboardNapi::JSCreateData(napi_env env, napi_callback_info info)
522 {
523 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateData is called!");
524 size_t argc = MAX_ARGS;
525 napi_value argv[MAX_ARGS] = { 0 };
526 napi_value thisVar = nullptr;
527 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
528 std::string mimeType;
529 std::shared_ptr<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>> typeValueVector =
530 std::make_shared<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>>();
531 if (!CheckExpression(env, argc >= ARGC_TYPE_SET1, JSErrorCode::INVALID_PARAMETERS,
532 "Parameter error. The number of arguments cannot be less than one.")) {
533 return nullptr;
534 }
535 if (argc == ARGC_TYPE_SET1) {
536 if (!CheckArgsVector(env, argv[0], typeValueVector)) {
537 return nullptr;
538 }
539 return CreateMultiTypeData(env, typeValueVector);
540 }
541 bool isArray = false;
542 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
543 if (isArray) {
544 napi_ref provider = nullptr;
545 std::vector<std::string> mimeTypes;
546 if (!CheckArgsArray(env, argv[0], mimeTypes) || !CheckArgsFunc(env, argv[1], provider)) {
547 return nullptr;
548 }
549 std::shared_ptr<PastedataRecordEntryGetterInstance> entryGetter =
550 std::make_shared<PastedataRecordEntryGetterInstance>(env, provider);
551 entryGetter->GetStub()->SetEntryGetterWrapper(entryGetter);
552 return CreateMultiTypeDelayData(env, mimeTypes, entryGetter->GetStub());
553 }
554 if (!CheckArgs(env, argv, argc, mimeType)) {
555 PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "CheckArgs failed!");
556 return nullptr;
557 }
558 auto it = createDataMap_.find(mimeType);
559 if (it != createDataMap_.end()) {
560 return (it->second)(env, argv[1]);
561 }
562
563 void *data = nullptr;
564 size_t dataLen = 0;
565 NAPI_CALL(env, napi_get_arraybuffer_info(env, argv[1], &data, &dataLen));
566 std::vector<uint8_t> arrayBuf(reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen);
567 return JSCreateKvData(env, mimeType, arrayBuf);
568 }
569
JSgetSystemPasteboard(napi_env env,napi_callback_info info)570 napi_value PasteboardNapi::JSgetSystemPasteboard(napi_env env, napi_callback_info info)
571 {
572 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSgetSystemPasteboard is called!");
573 size_t argc = MAX_ARGS;
574 napi_value argv[MAX_ARGS] = { 0 };
575 napi_value thisVar = nullptr;
576
577 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
578 napi_value instance = nullptr;
579 napi_status status = SystemPasteboardNapi::NewInstance(env, instance); // 0 arguments
580 if (status != napi_ok) {
581 PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSgetSystemPasteboard create instance failed");
582 return NapiGetNull(env);
583 }
584
585 return instance;
586 }
587
PasteBoardInit(napi_env env,napi_value exports)588 napi_value PasteboardNapi::PasteBoardInit(napi_env env, napi_value exports)
589 {
590 napi_property_descriptor desc[] = { DECLARE_NAPI_FUNCTION("createHtmlData", JScreateHtmlData),
591 DECLARE_NAPI_FUNCTION("createWantData", JScreateWantData),
592 DECLARE_NAPI_FUNCTION("createPlainTextData", JScreatePlainTextData),
593 DECLARE_NAPI_FUNCTION("createPixelMapData", JScreatePixelMapData),
594 DECLARE_NAPI_FUNCTION("createUriData", JScreateUriData),
595 DECLARE_NAPI_FUNCTION("createData", JSCreateData),
596 DECLARE_NAPI_FUNCTION("createDelayData", JSCreateData),
597 DECLARE_NAPI_FUNCTION("createHtmlTextRecord", JScreateHtmlTextRecord),
598 DECLARE_NAPI_FUNCTION("createWantRecord", JScreateWantRecord),
599 DECLARE_NAPI_FUNCTION("createPlainTextRecord", JScreatePlainTextRecord),
600 DECLARE_NAPI_FUNCTION("createPixelMapRecord", JScreatePixelMapRecord),
601 DECLARE_NAPI_FUNCTION("createUriRecord", JScreateUriRecord),
602 DECLARE_NAPI_FUNCTION("createRecord", JSCreateRecord),
603 DECLARE_NAPI_FUNCTION("createDelayRecord", JSCreateRecord),
604 DECLARE_NAPI_FUNCTION("getSystemPasteboard", JSgetSystemPasteboard),
605 DECLARE_NAPI_GETTER("ShareOption", JScreateShareOption),
606 DECLARE_NAPI_GETTER("Pattern", JScreatePattern),
607 DECLARE_NAPI_GETTER("FileConflictOptions", JScreateFileConflictOptions),
608 DECLARE_NAPI_GETTER("ProgressIndicator", JScreateProgressIndicator),
609 DECLARE_NAPI_PROPERTY("MAX_RECORD_NUM", CreateNapiNumber(env, PasteData::MAX_RECORD_NUM)),
610 DECLARE_NAPI_PROPERTY("MIMETYPE_PIXELMAP", CreateNapiString(env, MIMETYPE_PIXELMAP)),
611 DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_HTML", CreateNapiString(env, MIMETYPE_TEXT_HTML)),
612 DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_WANT", CreateNapiString(env, MIMETYPE_TEXT_WANT)),
613 DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_PLAIN", CreateNapiString(env, MIMETYPE_TEXT_PLAIN)),
614 DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_URI", CreateNapiString(env, MIMETYPE_TEXT_URI)) };
615
616 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
617
618 return exports;
619 }
620
621 std::unordered_map<std::string, PasteboardNapi::FUNC> PasteboardNapi::createRecordMap_ = {
622 { "text/html", &PasteboardNapi::CreateHtmlRecord }, { "text/plain", &PasteboardNapi::CreatePlainTextRecord },
623 { "text/uri", &PasteboardNapi::CreateUriRecord }, { "pixelMap", &PasteboardNapi::CreatePixelMapRecord },
624 { "text/want", &PasteboardNapi::CreateWantRecord }
625 };
626
627 std::unordered_map<std::string, PasteboardNapi::FUNC> PasteboardNapi::createDataMap_ = {
628 { "text/html", &PasteboardNapi::CreateHtmlData }, { "text/plain", &PasteboardNapi::CreatePlainTextData },
629 { "text/uri", &PasteboardNapi::CreateUriData }, { "pixelMap", &PasteboardNapi::CreatePixelMapData },
630 { "text/want", &PasteboardNapi::CreateWantData }
631 };
632 } // namespace MiscServicesNapi
633 } // namespace OHOS