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::vector<std::pair<std::string,std::shared_ptr<EntryValue>>>> typeValueVector)206 napi_value PasteboardNapi::CreateMultiTypeData(napi_env env,
207     std::shared_ptr<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>> typeValueVector)
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     if (typeValueVector == nullptr || typeValueVector->empty()) {
218         return nullptr;
219     }
220     std::shared_ptr<std::map<std::string, std::shared_ptr<EntryValue>>> typeValueMap =
221             std::make_shared<std::map<std::string, std::shared_ptr<EntryValue>>>();
222     for (const auto &item : *typeValueVector) {
223         typeValueMap->emplace(item.first, item.second);
224     }
225     obj->value_ = PasteboardClient::GetInstance()->CreateMultiTypeData(std::move(typeValueMap),
226         typeValueVector->begin()->first);
227     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
228     return instance;
229 }
230 
CreateMultiTypeDelayData(napi_env env,std::vector<std::string> mimeTypes,std::shared_ptr<UDMF::EntryGetter> entryGetter)231 napi_value PasteboardNapi::CreateMultiTypeDelayData(napi_env env, std::vector<std::string> mimeTypes,
232     std::shared_ptr<UDMF::EntryGetter> entryGetter)
233 {
234     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "CreateMultiTypeDelayData is called!");
235     napi_value instance = nullptr;
236     NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
237     PasteDataNapi *obj = nullptr;
238     napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
239     if ((status != napi_ok) || (obj == nullptr)) {
240         return nullptr;
241     }
242     obj->value_ = PasteboardClient::GetInstance()->CreateMultiTypeDelayData(mimeTypes, entryGetter);
243     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "end.");
244     return instance;
245 }
246 
JScreateHtmlTextRecord(napi_env env,napi_callback_info info)247 napi_value PasteboardNapi::JScreateHtmlTextRecord(napi_env env, napi_callback_info info)
248 {
249     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateHtmlTextRecord is called!");
250     size_t argc = MAX_ARGS;
251     napi_value argv[MAX_ARGS] = { 0 };
252     napi_value thisVar = nullptr;
253 
254     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
255     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
256 
257     return CreateHtmlRecord(env, argv[0]);
258 }
259 
JScreateWantRecord(napi_env env,napi_callback_info info)260 napi_value PasteboardNapi::JScreateWantRecord(napi_env env, napi_callback_info info)
261 {
262     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateWantRecord is called!");
263     size_t argc = MAX_ARGS;
264     napi_value argv[MAX_ARGS] = { 0 };
265     napi_value thisVar = nullptr;
266 
267     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
268     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
269     napi_valuetype valueType = napi_undefined;
270     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
271     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
272 
273     return CreateWantRecord(env, argv[0]);
274 }
275 
JScreateShareOption(napi_env env,napi_callback_info info)276 napi_value PasteboardNapi::JScreateShareOption(napi_env env, napi_callback_info info)
277 {
278     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateShareOption is called!");
279 
280     napi_value jsShareOption = nullptr;
281     napi_create_object(env, &jsShareOption);
282 
283     napi_value jsInApp = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::InApp));
284     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "InApp", jsInApp));
285     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "INAPP", jsInApp));
286 
287     napi_value jsLocalDevice = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::LocalDevice));
288     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "LocalDevice", jsLocalDevice));
289     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "LOCALDEVICE", jsLocalDevice));
290 
291     napi_value jsCrossDevice = CreateNapiNumber(env, static_cast<int32_t>(ShareOption::CrossDevice));
292     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "CrossDevice", jsCrossDevice));
293     NAPI_CALL(env, napi_set_named_property(env, jsShareOption, "CROSSDEVICE", jsCrossDevice));
294 
295     return jsShareOption;
296 }
297 
JScreatePattern(napi_env env,napi_callback_info info)298 napi_value PasteboardNapi::JScreatePattern(napi_env env, napi_callback_info info)
299 {
300     napi_value jsPattern = nullptr;
301     napi_create_object(env, &jsPattern);
302 
303     napi_value jsURL = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::URL));
304     NAPI_CALL(env, napi_set_named_property(env, jsPattern, "URL", jsURL));
305 
306     napi_value jsNumber = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::Number));
307     NAPI_CALL(env, napi_set_named_property(env, jsPattern, "NUMBER", jsNumber));
308 
309     napi_value jsEmailAddress = CreateNapiNumber(env, static_cast<uint32_t>(Pattern::EmailAddress));
310     NAPI_CALL(env, napi_set_named_property(env, jsPattern, "EMAIL_ADDRESS", jsEmailAddress));
311 
312     return jsPattern;
313 }
314 
JScreatePlainTextRecord(napi_env env,napi_callback_info info)315 napi_value PasteboardNapi::JScreatePlainTextRecord(napi_env env, napi_callback_info info)
316 {
317     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePlainTextRecord is called!");
318     size_t argc = MAX_ARGS;
319     napi_value argv[MAX_ARGS] = { 0 };
320     napi_value thisVar = nullptr;
321 
322     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
323     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
324 
325     return CreatePlainTextRecord(env, argv[0]);
326 }
327 
JScreatePixelMapRecord(napi_env env,napi_callback_info info)328 napi_value PasteboardNapi::JScreatePixelMapRecord(napi_env env, napi_callback_info info)
329 {
330     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePixelMapRecord is called!");
331     size_t argc = MAX_ARGS;
332     napi_value argv[MAX_ARGS] = { 0 };
333     napi_value thisVar = nullptr;
334 
335     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
336     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
337 
338     napi_valuetype valueType = napi_undefined;
339     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
340     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
341 
342     return CreatePixelMapRecord(env, argv[0]);
343 }
344 
JScreateUriRecord(napi_env env,napi_callback_info info)345 napi_value PasteboardNapi::JScreateUriRecord(napi_env env, napi_callback_info info)
346 {
347     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateUriRecord is called!");
348     size_t argc = MAX_ARGS;
349     napi_value argv[MAX_ARGS] = { 0 };
350     napi_value thisVar = nullptr;
351 
352     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
353     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
354 
355     return CreateUriRecord(env, argv[0]);
356 }
357 
JSCreateRecord(napi_env env,napi_callback_info info)358 napi_value PasteboardNapi::JSCreateRecord(napi_env env, napi_callback_info info)
359 {
360     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateRecord is called!");
361     size_t argc = MAX_ARGS;
362     napi_value argv[MAX_ARGS] = { 0 };
363     napi_value thisVar = nullptr;
364     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
365     napi_valuetype type = napi_undefined;
366     NAPI_CALL(env, napi_typeof(env, argv[0], &type));
367     if (!CheckExpression(env, argc >= ARGC_TYPE_SET2, JSErrorCode::INVALID_PARAMETERS,
368         "Parameter error. The number of arguments cannot be less than two.") ||
369         !CheckExpression(env, type == napi_object || type == napi_string, JSErrorCode::INVALID_PARAMETERS,
370         "Parameter error. the first param should be object or string.")) {
371         return nullptr;
372     }
373     if (type == napi_string) {
374         std::string mimeType;
375         if (!CheckArgs(env, argv, argc, mimeType)) {
376             return nullptr;
377         }
378         auto it = createRecordMap_.find(mimeType);
379         if (it != createRecordMap_.end()) {
380             return (it->second)(env, argv[1]);
381         }
382 
383         void *data = nullptr;
384         size_t dataLen = 0;
385         NAPI_CALL(env, napi_get_arraybuffer_info(env, argv[1], &data, &dataLen));
386         std::vector<uint8_t> arrayBuf(reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen);
387         napi_value instance = nullptr;
388         PasteDataRecordNapi::NewKvRecordInstance(env, mimeType, arrayBuf, instance);
389         return instance;
390     } else {
391         napi_ref provider = nullptr;
392         std::vector<std::string> mimeTypes;
393         if (!CheckArgsArray(env, argv[0], mimeTypes) ||
394             !CheckArgsFunc(env, argv[1], provider)) {
395             return nullptr;
396         }
397         napi_value instance = nullptr;
398         std::shared_ptr<PastedataRecordEntryGetterInstance> entryGetter =
399             std::make_shared<PastedataRecordEntryGetterInstance>(env, provider);
400         entryGetter->GetStub()->SetEntryGetterWrapper(entryGetter);
401         PasteDataRecordNapi::NewEntryGetterRecordInstance(mimeTypes, entryGetter, instance);
402         return instance;
403     }
404 }
405 
JScreateHtmlData(napi_env env,napi_callback_info info)406 napi_value PasteboardNapi::JScreateHtmlData(napi_env env, napi_callback_info info)
407 {
408     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateHtmlData is called!");
409     size_t argc = MAX_ARGS;
410     napi_value argv[MAX_ARGS] = { 0 };
411     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
412     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
413 
414     return CreateHtmlData(env, argv[0]);
415 }
416 
JScreateWantData(napi_env env,napi_callback_info info)417 napi_value PasteboardNapi::JScreateWantData(napi_env env, napi_callback_info info)
418 {
419     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateWantData is called!");
420     size_t argc = MAX_ARGS;
421     napi_value argv[MAX_ARGS] = { 0 };
422     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
423     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
424     napi_valuetype valueType = napi_undefined;
425     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
426     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
427 
428     return CreateWantData(env, argv[0]);
429 }
430 
JScreatePlainTextData(napi_env env,napi_callback_info info)431 napi_value PasteboardNapi::JScreatePlainTextData(napi_env env, napi_callback_info info)
432 {
433     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePlainTextData is called!");
434     size_t argc = MAX_ARGS;
435     napi_value argv[MAX_ARGS] = { 0 };
436     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
437     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
438 
439     return CreatePlainTextData(env, argv[0]);
440 }
441 
JScreatePixelMapData(napi_env env,napi_callback_info info)442 napi_value PasteboardNapi::JScreatePixelMapData(napi_env env, napi_callback_info info)
443 {
444     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreatePixelMapData 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     napi_valuetype valueType = napi_undefined;
450     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
451     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
452 
453     return CreatePixelMapData(env, argv[0]);
454 }
455 
JScreateUriData(napi_env env,napi_callback_info info)456 napi_value PasteboardNapi::JScreateUriData(napi_env env, napi_callback_info info)
457 {
458     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JScreateUriData is called!");
459     size_t argc = MAX_ARGS;
460     napi_value argv[MAX_ARGS] = { 0 };
461     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
462     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
463 
464     return CreateUriData(env, argv[0]);
465 }
466 
JSCreateKvData(napi_env env,const std::string & mimeType,const std::vector<uint8_t> & arrayBuffer)467 napi_value PasteboardNapi::JSCreateKvData(
468     napi_env env, const std::string &mimeType, const std::vector<uint8_t> &arrayBuffer)
469 {
470     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateKvData is called!");
471 
472     napi_value instance = nullptr;
473     NAPI_CALL(env, PasteDataNapi::NewInstance(env, instance));
474     PasteDataNapi *obj = nullptr;
475     napi_status status = napi_unwrap(env, instance, reinterpret_cast<void **>(&obj));
476     if ((status != napi_ok) || (obj == nullptr)) {
477         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed!");
478         return nullptr;
479     }
480 
481     obj->value_ = PasteboardClient::GetInstance()->CreateKvData(mimeType, arrayBuffer);
482     return instance;
483 }
484 
JSCreateData(napi_env env,napi_callback_info info)485 napi_value PasteboardNapi::JSCreateData(napi_env env, napi_callback_info info)
486 {
487     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSCreateData is called!");
488     size_t argc = MAX_ARGS;
489     napi_value argv[MAX_ARGS] = { 0 };
490     napi_value thisVar = nullptr;
491     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
492     std::string mimeType;
493     std::shared_ptr<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>> typeValueVector =
494         std::make_shared<std::vector<std::pair<std::string, std::shared_ptr<EntryValue>>>>();
495     if (!CheckExpression(env, argc >= ARGC_TYPE_SET1, JSErrorCode::INVALID_PARAMETERS,
496         "Parameter error. The number of arguments cannot be less than one.")) {
497         return nullptr;
498     }
499     if (argc == ARGC_TYPE_SET1) {
500         if (!CheckArgsVector(env, argv[0], typeValueVector)) {
501             return nullptr;
502         }
503         return CreateMultiTypeData(env, typeValueVector);
504     }
505     bool isArray = false;
506     NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
507     if (isArray) {
508         napi_ref provider = nullptr;
509         std::vector<std::string> mimeTypes;
510         if (!CheckArgsArray(env, argv[0], mimeTypes) || !CheckArgsFunc(env, argv[1], provider)) {
511             return nullptr;
512         }
513         std::shared_ptr<PastedataRecordEntryGetterInstance> entryGetter =
514             std::make_shared<PastedataRecordEntryGetterInstance>(env, provider);
515         entryGetter->GetStub()->SetEntryGetterWrapper(entryGetter);
516         return CreateMultiTypeDelayData(env, mimeTypes, entryGetter->GetStub());
517     }
518     if (!CheckArgs(env, argv, argc, mimeType)) {
519         return nullptr;
520     }
521     auto it = createDataMap_.find(mimeType);
522     if (it != createDataMap_.end()) {
523         return (it->second)(env, argv[1]);
524     }
525 
526     void *data = nullptr;
527     size_t dataLen = 0;
528     NAPI_CALL(env, napi_get_arraybuffer_info(env, argv[1], &data, &dataLen));
529     std::vector<uint8_t> arrayBuf(reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen);
530     return JSCreateKvData(env, mimeType, arrayBuf);
531 }
532 
JSgetSystemPasteboard(napi_env env,napi_callback_info info)533 napi_value PasteboardNapi::JSgetSystemPasteboard(napi_env env, napi_callback_info info)
534 {
535     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSgetSystemPasteboard is called!");
536     size_t argc = MAX_ARGS;
537     napi_value argv[MAX_ARGS] = { 0 };
538     napi_value thisVar = nullptr;
539 
540     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
541     napi_value instance = nullptr;
542     napi_status status = SystemPasteboardNapi::NewInstance(env, instance); // 0 arguments
543     if (status != napi_ok) {
544         PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "JSgetSystemPasteboard create instance failed");
545         return NapiGetNull(env);
546     }
547 
548     return instance;
549 }
550 
PasteBoardInit(napi_env env,napi_value exports)551 napi_value PasteboardNapi::PasteBoardInit(napi_env env, napi_value exports)
552 {
553     napi_property_descriptor desc[] = { DECLARE_NAPI_FUNCTION("createHtmlData", JScreateHtmlData),
554         DECLARE_NAPI_FUNCTION("createWantData", JScreateWantData),
555         DECLARE_NAPI_FUNCTION("createPlainTextData", JScreatePlainTextData),
556         DECLARE_NAPI_FUNCTION("createPixelMapData", JScreatePixelMapData),
557         DECLARE_NAPI_FUNCTION("createUriData", JScreateUriData),
558         DECLARE_NAPI_FUNCTION("createData", JSCreateData),
559         DECLARE_NAPI_FUNCTION("createDelayData", JSCreateData),
560         DECLARE_NAPI_FUNCTION("createHtmlTextRecord", JScreateHtmlTextRecord),
561         DECLARE_NAPI_FUNCTION("createWantRecord", JScreateWantRecord),
562         DECLARE_NAPI_FUNCTION("createPlainTextRecord", JScreatePlainTextRecord),
563         DECLARE_NAPI_FUNCTION("createPixelMapRecord", JScreatePixelMapRecord),
564         DECLARE_NAPI_FUNCTION("createUriRecord", JScreateUriRecord),
565         DECLARE_NAPI_FUNCTION("createRecord", JSCreateRecord),
566         DECLARE_NAPI_FUNCTION("createDelayRecord", JSCreateRecord),
567         DECLARE_NAPI_FUNCTION("getSystemPasteboard", JSgetSystemPasteboard),
568         DECLARE_NAPI_GETTER("ShareOption", JScreateShareOption),
569         DECLARE_NAPI_GETTER("Pattern", JScreatePattern),
570         DECLARE_NAPI_PROPERTY("MAX_RECORD_NUM", CreateNapiNumber(env, PasteData::MAX_RECORD_NUM)),
571         DECLARE_NAPI_PROPERTY("MIMETYPE_PIXELMAP", CreateNapiString(env, MIMETYPE_PIXELMAP)),
572         DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_HTML", CreateNapiString(env, MIMETYPE_TEXT_HTML)),
573         DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_WANT", CreateNapiString(env, MIMETYPE_TEXT_WANT)),
574         DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_PLAIN", CreateNapiString(env, MIMETYPE_TEXT_PLAIN)),
575         DECLARE_NAPI_PROPERTY("MIMETYPE_TEXT_URI", CreateNapiString(env, MIMETYPE_TEXT_URI)) };
576 
577     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
578 
579     return exports;
580 }
581 
582 std::unordered_map<std::string, PasteboardNapi::FUNC> PasteboardNapi::createRecordMap_ = {
583     { "text/html", &PasteboardNapi::CreateHtmlRecord }, { "text/plain", &PasteboardNapi::CreatePlainTextRecord },
584     { "text/uri", &PasteboardNapi::CreateUriRecord }, { "pixelMap", &PasteboardNapi::CreatePixelMapRecord },
585     { "text/want", &PasteboardNapi::CreateWantRecord }
586 };
587 
588 std::unordered_map<std::string, PasteboardNapi::FUNC> PasteboardNapi::createDataMap_ = {
589     { "text/html", &PasteboardNapi::CreateHtmlData }, { "text/plain", &PasteboardNapi::CreatePlainTextData },
590     { "text/uri", &PasteboardNapi::CreateUriData }, { "pixelMap", &PasteboardNapi::CreatePixelMapData },
591     { "text/want", &PasteboardNapi::CreateWantData }
592 };
593 } // namespace MiscServicesNapi
594 } // namespace OHOS