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