1 /*
2  * Copyright (C) 2021-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 #include <cstddef>
16 
17 #include "napi_common_want.h"
18 #include "pasteboard_common.h"
19 #include "pasteboard_hilog.h"
20 #include "pasteboard_js_err.h"
21 #include "pasteboard_napi.h"
22 #include "pastedata_napi.h"
23 #include "pastedata_record_napi.h"
24 using namespace OHOS::MiscServices;
25 using namespace OHOS::Media;
26 
27 namespace OHOS {
28 namespace MiscServicesNapi {
29 namespace {
30 constexpr int ARGC_TYPE_SET0 = 0;
31 constexpr int ARGC_TYPE_SET1 = 1;
32 constexpr int ARGC_TYPE_SET2 = 2;
33 const int32_t STR_MAX_SIZE = 256;
34 constexpr int32_t MIMETYPE_MAX_SIZE = 1024;
35 constexpr int32_t MAX_TEXT_LEN = 20 * 1024 * 1024;
36 constexpr size_t STR_TAIL_LENGTH = 1;
37 } // namespace
38 static thread_local napi_ref g_pasteData = nullptr;
39 
PasteDataNapi()40 PasteDataNapi::PasteDataNapi() : env_(nullptr)
41 {
42     value_ = std::make_shared<PasteData>();
43 }
44 
~PasteDataNapi()45 PasteDataNapi::~PasteDataNapi()
46 {
47 }
48 
AddHtmlRecord(napi_env env,napi_callback_info info)49 napi_value PasteDataNapi::AddHtmlRecord(napi_env env, napi_callback_info info)
50 {
51     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddHtmlRecord is called!");
52     size_t argc = 1;
53     napi_value argv[1] = { 0 };
54     napi_value thisVar = nullptr;
55 
56     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
57     NAPI_ASSERT(env, argc > ARGC_TYPE_SET0, "Wrong number of arguments");
58 
59     std::string str;
60     bool ret = GetValue(env, argv[0], str);
61     if (!ret) {
62         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
63         return nullptr;
64     }
65 
66     PasteDataNapi *obj = nullptr;
67     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
68     if ((status != napi_ok) || (obj == nullptr)) {
69         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddHtmlRecord object failed");
70         return nullptr;
71     }
72     obj->value_->AddHtmlRecord(str);
73     return nullptr;
74 }
75 
AddPixelMapRecord(napi_env env,napi_callback_info info)76 napi_value PasteDataNapi::AddPixelMapRecord(napi_env env, napi_callback_info info)
77 {
78     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddPixelMapRecord is called begin!");
79     size_t argc = ARGC_TYPE_SET1;
80     napi_value argv[ARGC_TYPE_SET1] = { 0 };
81     napi_value thisVar = nullptr;
82 
83     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
84     NAPI_ASSERT(env, argc > ARGC_TYPE_SET0, "Wrong number of arguments");
85 
86     napi_valuetype valueType = napi_undefined;
87     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
88     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
89 
90     std::shared_ptr<PixelMap> pixelMap = PixelMapNapi::GetPixelMap(env, argv[0]);
91     if (pixelMap == nullptr) {
92         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetPixelMap!");
93         return nullptr;
94     }
95 
96     PasteDataNapi *obj = nullptr;
97     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
98     if ((status != napi_ok) || (obj == nullptr)) {
99         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed");
100         return nullptr;
101     }
102     obj->value_->AddPixelMapRecord(pixelMap);
103     return nullptr;
104 }
105 
AddTextRecord(napi_env env,napi_callback_info info)106 napi_value PasteDataNapi::AddTextRecord(napi_env env, napi_callback_info info)
107 {
108     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddTextRecord is called!");
109     size_t argc = 1;
110     napi_value argv[1] = { 0 };
111     napi_value thisVar = nullptr;
112 
113     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
114     NAPI_ASSERT(env, argc > ARGC_TYPE_SET0, "Wrong number of arguments");
115 
116     std::string str;
117     bool ret = GetValue(env, argv[0], str);
118     if (!ret) {
119         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
120         return nullptr;
121     }
122 
123     PasteDataNapi *obj = nullptr;
124     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
125     if ((status != napi_ok) || (obj == nullptr)) {
126         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddTextRecord object failed");
127         return nullptr;
128     }
129     obj->value_->AddTextRecord(str);
130     return nullptr;
131 }
132 
AddUriRecord(napi_env env,napi_callback_info info)133 napi_value PasteDataNapi::AddUriRecord(napi_env env, napi_callback_info info)
134 {
135     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddUriRecord is called!");
136     size_t argc = 1;
137     napi_value argv[1] = { 0 };
138     napi_value thisVar = nullptr;
139 
140     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
141     NAPI_ASSERT(env, argc > ARGC_TYPE_SET0, "Wrong number of arguments");
142 
143     std::string str;
144     bool ret = GetValue(env, argv[0], str);
145     if (!ret) {
146         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
147         return nullptr;
148     }
149 
150     PasteDataNapi *obj = nullptr;
151     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
152     if ((status != napi_ok) || (obj == nullptr)) {
153         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddUriRecord object failed");
154         return nullptr;
155     }
156     obj->value_->AddUriRecord(OHOS::Uri(str));
157     return nullptr;
158 }
159 
GetPrimaryHtml(napi_env env,napi_callback_info info)160 napi_value PasteDataNapi::GetPrimaryHtml(napi_env env, napi_callback_info info)
161 {
162     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryHtml is called!");
163     size_t argc = 1;
164     napi_value argv[1] = { 0 };
165     napi_value thisVar = nullptr;
166 
167     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
168     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
169 
170     PasteDataNapi *obj = nullptr;
171     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
172     if ((status != napi_ok) || (obj == nullptr)) {
173         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryHtml object failed");
174         return nullptr;
175     }
176 
177     std::shared_ptr<std::string> p = obj->value_->GetPrimaryHtml();
178     if (p == nullptr) {
179         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryHtml failed");
180         return nullptr;
181     }
182 
183     napi_value result = nullptr;
184     napi_create_string_utf8(env, p->c_str(), NAPI_AUTO_LENGTH, &result);
185     return result;
186 }
187 
GetPrimaryPixelMap(napi_env env,napi_callback_info info)188 napi_value PasteDataNapi::GetPrimaryPixelMap(napi_env env, napi_callback_info info)
189 {
190     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryPixelMap is called!");
191     size_t argc = ARGC_TYPE_SET1;
192     napi_value argv[ARGC_TYPE_SET1] = { 0 };
193     napi_value thisVar = nullptr;
194 
195     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
196     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
197 
198     PasteDataNapi *obj = nullptr;
199     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
200     if ((status != napi_ok) || (obj == nullptr)) {
201         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "unwrap failed");
202         return nullptr;
203     }
204 
205     std::shared_ptr<PixelMap> pixelMap = obj->value_->GetPrimaryPixelMap();
206     if (!pixelMap) {
207         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "pixelMap is nullptr");
208         return nullptr;
209     }
210 
211     napi_value jsPixelMap = PixelMapNapi::CreatePixelMap(env, pixelMap);
212     return jsPixelMap;
213 }
214 
GetPrimaryText(napi_env env,napi_callback_info info)215 napi_value PasteDataNapi::GetPrimaryText(napi_env env, napi_callback_info info)
216 {
217     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryText is called!");
218     size_t argc = 1;
219     napi_value argv[1] = { 0 };
220     napi_value thisVar = nullptr;
221 
222     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
223     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
224 
225     PasteDataNapi *obj = nullptr;
226     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
227     if ((status != napi_ok) || (obj == nullptr)) {
228         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryText object failed");
229         return nullptr;
230     }
231 
232     std::shared_ptr<std::string> p = obj->value_->GetPrimaryText();
233     if (p == nullptr) {
234         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryText failed");
235         return nullptr;
236     }
237 
238     napi_value result = nullptr;
239     napi_create_string_utf8(env, p->c_str(), NAPI_AUTO_LENGTH, &result);
240     return result;
241 }
242 
GetPrimaryUri(napi_env env,napi_callback_info info)243 napi_value PasteDataNapi::GetPrimaryUri(napi_env env, napi_callback_info info)
244 {
245     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryUri is called!");
246     size_t argc = 1;
247     napi_value argv[1] = { 0 };
248     napi_value thisVar = nullptr;
249 
250     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
251     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
252 
253     PasteDataNapi *obj = nullptr;
254     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
255     if ((status != napi_ok) || (obj == nullptr)) {
256         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryUri object failed");
257         return nullptr;
258     }
259 
260     std::shared_ptr<OHOS::Uri> p = obj->value_->GetPrimaryUri();
261     if (p == nullptr) {
262         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryUri failed");
263         return nullptr;
264     }
265 
266     std::string text = p->ToString();
267     napi_value result = nullptr;
268     napi_create_string_utf8(env, text.c_str(), NAPI_AUTO_LENGTH, &result);
269     return result;
270 }
271 
HasMimeType(napi_env env,napi_callback_info info)272 napi_value PasteDataNapi::HasMimeType(napi_env env, napi_callback_info info)
273 {
274     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "HasMimeType is called!");
275     size_t argc = 1;
276     napi_value argv[1] = { 0 };
277     napi_value thisVar = nullptr;
278 
279     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
280     if ((!CheckExpression(env, argc > ARGC_TYPE_SET0, JSErrorCode::INVALID_PARAMETERS,
281         "Parameter error. The number of arguments must be greater than zero.")) ||
282         (!CheckArgsType(env, argv[0], napi_string, "Parameter error. The type of mimeType must be string."))) {
283         return nullptr;
284     }
285 
286     std::string mimeType;
287     if (!GetValue(env, argv[0], mimeType)) {
288         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
289         return nullptr;
290     }
291 
292     PasteDataNapi *obj = nullptr;
293     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
294     if ((status != napi_ok) || (obj == nullptr)) {
295         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddHtmlRecord object failed");
296         return nullptr;
297     }
298 
299     bool ret = obj->value_->HasMimeType(mimeType);
300     napi_value result = nullptr;
301     napi_get_boolean(env, ret, &result);
302     return result;
303 }
304 
HasType(napi_env env,napi_callback_info info)305 napi_value PasteDataNapi::HasType(napi_env env, napi_callback_info info)
306 {
307     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "HasType is called!");
308     return HasMimeType(env, info);
309 }
310 
RemoveAndGetRecordCommon(napi_env env,napi_callback_info info,uint32_t & index)311 PasteDataNapi *PasteDataNapi::RemoveAndGetRecordCommon(napi_env env, napi_callback_info info, uint32_t &index)
312 {
313     size_t argc = 1;
314     napi_value argv[1] = { 0 };
315     napi_value thisVar = nullptr;
316     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
317 
318     if ((!CheckExpression(env, argc > ARGC_TYPE_SET0, JSErrorCode::INVALID_PARAMETERS,
319         "Parameter error. The number of arguments must be greater than zero.")) ||
320         (!CheckArgsType(env, argv[0], napi_number, "Parameter error. The type of mimeType must be number."))) {
321         return nullptr;
322     }
323     PasteDataNapi *obj = nullptr;
324     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
325     if ((status != napi_ok) || (obj == nullptr)) {
326         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get RemoveRecord object failed");
327         return nullptr;
328     }
329     NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &index));
330     return obj;
331 }
332 
RemoveRecordAt(napi_env env,napi_callback_info info)333 napi_value PasteDataNapi::RemoveRecordAt(napi_env env, napi_callback_info info)
334 {
335     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "RemoveRecordAt is called!");
336     uint32_t index = 0;
337     PasteDataNapi *obj = RemoveAndGetRecordCommon(env, info, index);
338     if (obj == nullptr) {
339         return nullptr;
340     }
341     bool ret = obj->value_->RemoveRecordAt(index);
342     napi_value result = nullptr;
343     napi_get_boolean(env, ret, &result);
344     return result;
345 }
346 
RemoveRecord(napi_env env,napi_callback_info info)347 napi_value PasteDataNapi::RemoveRecord(napi_env env, napi_callback_info info)
348 {
349     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "RemoveRecord is called!");
350     uint32_t index = 0;
351     PasteDataNapi *obj = RemoveAndGetRecordCommon(env, info, index);
352     if (obj == nullptr || !CheckExpression(env, index < obj->value_->GetRecordCount(),
353         JSErrorCode::OUT_OF_RANGE, "index out of range.")) {
354         return nullptr;
355     }
356     obj->value_->RemoveRecordAt(index);
357     return nullptr;
358 }
359 
GetPrimaryMimeType(napi_env env,napi_callback_info info)360 napi_value PasteDataNapi::GetPrimaryMimeType(napi_env env, napi_callback_info info)
361 {
362     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryMimeType is called!");
363     size_t argc = 1;
364     napi_value argv[1] = { 0 };
365     napi_value thisVar = nullptr;
366 
367     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
368     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
369 
370     PasteDataNapi *obj = nullptr;
371     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
372     if ((status != napi_ok) || (obj == nullptr)) {
373         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryMimeType object failed");
374         return nullptr;
375     }
376     std::shared_ptr<std::string> mimeType = obj->value_->GetPrimaryMimeType();
377     if (mimeType == nullptr) {
378         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryMimeType failed");
379         return nullptr;
380     }
381     napi_value result = nullptr;
382     napi_create_string_utf8(env, mimeType->c_str(), NAPI_AUTO_LENGTH, &result);
383 
384     return result;
385 }
386 
GetRecordCount(napi_env env,napi_callback_info info)387 napi_value PasteDataNapi::GetRecordCount(napi_env env, napi_callback_info info)
388 {
389     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetRecordCount is called!");
390     size_t argc = 1;
391     napi_value argv[1] = { 0 };
392     napi_value thisVar = nullptr;
393 
394     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
395     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
396 
397     PasteDataNapi *obj = nullptr;
398     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
399     if ((status != napi_ok) || (obj == nullptr)) {
400         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetRecordCount object failed");
401         return nullptr;
402     }
403 
404     size_t count = obj->value_->GetRecordCount();
405     napi_value result = nullptr;
406     napi_create_int64(env, count, &result);
407 
408     return result;
409 }
410 
GetTag(napi_env env,napi_callback_info info)411 napi_value PasteDataNapi::GetTag(napi_env env, napi_callback_info info)
412 {
413     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetTag is called!");
414     size_t argc = 1;
415     napi_value argv[1] = { 0 };
416     napi_value thisVar = nullptr;
417 
418     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
419     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
420 
421     PasteDataNapi *obj = nullptr;
422     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
423     if ((status != napi_ok) || (obj == nullptr)) {
424         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetTag object failed");
425         return nullptr;
426     }
427     std::string tag = obj->value_->GetTag();
428     napi_value result = nullptr;
429     napi_create_string_utf8(env, tag.c_str(), NAPI_AUTO_LENGTH, &result);
430 
431     return result;
432 }
433 
GetMimeTypes(napi_env env,napi_callback_info info)434 napi_value PasteDataNapi::GetMimeTypes(napi_env env, napi_callback_info info)
435 {
436     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetMimeTypes is called!");
437     size_t argc = 1;
438     napi_value argv[1] = { 0 };
439     napi_value thisVar = nullptr;
440 
441     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
442     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
443 
444     PasteDataNapi *obj = nullptr;
445     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
446     if ((status != napi_ok) || (obj == nullptr)) {
447         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetMimeTypes object failed");
448         return nullptr;
449     }
450     std::vector<std::string> mimeTypes = obj->value_->GetMimeTypes();
451     if (mimeTypes.size() == 0) {
452         return nullptr;
453     }
454 
455     napi_value nMimeTypes = nullptr;
456     if (napi_create_array(env, &nMimeTypes) != napi_ok) {
457         return nullptr;
458     }
459     size_t index = 0;
460     napi_value value = nullptr;
461     for (auto type : mimeTypes) {
462         napi_create_string_utf8(env, type.c_str(), NAPI_AUTO_LENGTH, &value);
463         napi_set_element(env, nMimeTypes, index, value);
464         index++;
465     }
466     return nMimeTypes;
467 }
468 
AddRecord(napi_env env,napi_value * argv,size_t argc,PasteDataNapi * obj)469 void PasteDataNapi::AddRecord(napi_env env, napi_value *argv, size_t argc, PasteDataNapi *obj)
470 {
471     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddRecordV9!");
472     std::string mimeType;
473     if (!CheckArgs(env, argv, argc, mimeType)) {
474         return;
475     }
476     bool isArrayBuffer = false;
477     NAPI_CALL_RETURN_VOID(env, napi_is_arraybuffer(env, argv[1], &isArrayBuffer));
478     if (isArrayBuffer) {
479         void *data = nullptr;
480         size_t dataLen = 0;
481         NAPI_CALL_RETURN_VOID(env, napi_get_arraybuffer_info(env, argv[1], &data, &dataLen));
482         obj->value_->AddKvRecord(mimeType,
483             std::vector<uint8_t>(reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen));
484         return;
485     }
486     if (mimeType == MIMETYPE_PIXELMAP) {
487         std::shared_ptr<PixelMap> pixelMap = PixelMapNapi::GetPixelMap(env, argv[1]);
488         obj->value_->AddPixelMapRecord(pixelMap);
489         return;
490     } else if (mimeType == MIMETYPE_TEXT_WANT) {
491         OHOS::AAFwk::Want want;
492         AppExecFwk::UnwrapWant(env, argv[1], want);
493         obj->value_->AddWantRecord(std::make_shared<OHOS::AAFwk::Want>(want));
494         return;
495     }
496 
497     std::string str;
498     bool ret = GetValue(env, argv[1], str);
499     if (!ret) {
500         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to GetValue!");
501         return;
502     }
503     if (mimeType == MIMETYPE_TEXT_HTML) {
504         obj->value_->AddHtmlRecord(str);
505     } else if (mimeType == MIMETYPE_TEXT_PLAIN) {
506         obj->value_->AddTextRecord(str);
507     } else {
508         obj->value_->AddUriRecord(OHOS::Uri(str));
509     }
510 }
511 
SetStringProp(napi_env env,const std::string & propName,napi_value & propValueNapi,PasteDataRecord::Builder & builder)512 bool PasteDataNapi::SetStringProp(
513     napi_env env, const std::string &propName, napi_value &propValueNapi, PasteDataRecord::Builder &builder)
514 {
515     std::string propValue;
516     bool ret = GetValue(env, propValueNapi, propValue);
517     if (!ret) {
518         return false;
519     }
520     if ((propName == "mimeType") && (propValue.size() <= MIMETYPE_MAX_SIZE)) {
521         builder.SetMimeType(propValue);
522     } else if ((propName == "htmlText") && (propValue.size() <= MAX_TEXT_LEN)) {
523         builder.SetHtmlText(std::make_shared<std::string>(propValue));
524     } else if ((propName == "plainText") && (propValue.size() <= MAX_TEXT_LEN)) {
525         builder.SetPlainText(std::make_shared<std::string>(propValue));
526     } else if (propName == "uri") {
527         builder.SetUri(std::make_shared<OHOS::Uri>(Uri(propValue)));
528     } else {
529         return false;
530     }
531     return true;
532 }
533 
ParseRecord(napi_env env,napi_value & recordNapi)534 std::shared_ptr<MiscServices::PasteDataRecord> PasteDataNapi::ParseRecord(napi_env env, napi_value &recordNapi)
535 {
536     napi_value propNames = nullptr;
537     NAPI_CALL(env, napi_get_property_names(env, recordNapi, &propNames));
538     uint32_t propNameNums = 0;
539     NAPI_CALL(env, napi_get_array_length(env, propNames, &propNameNums));
540     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_JS_NAPI, "propNameNums = %{public}d", propNameNums);
541     PasteDataRecord::Builder builder("");
542     for (uint32_t i = 0; i < propNameNums; i++) {
543         napi_value propNameNapi = nullptr;
544         NAPI_CALL(env, napi_get_element(env, propNames, i, &propNameNapi));
545         size_t len = 0;
546         char str[STR_MAX_SIZE] = { 0 };
547         NAPI_CALL(env, napi_get_value_string_utf8(env, propNameNapi, str, STR_MAX_SIZE - STR_TAIL_LENGTH, &len));
548         napi_value propValueNapi = nullptr;
549         NAPI_CALL(env, napi_get_named_property(env, recordNapi, str, &propValueNapi));
550         std::string propName = str;
551         PASTEBOARD_HILOGI(PASTEBOARD_MODULE_JS_NAPI, "propName = %{public}s,", propName.c_str());
552 
553         if (propName == "mimeType" || propName == "htmlText" || propName == "plainText" || propName == "uri") {
554             if (!SetStringProp(env, propName, propValueNapi, builder)) {
555                 return nullptr;
556             }
557         } else if (propName == "want") {
558             AAFwk::Want want;
559             if (OHOS::AppExecFwk::UnwrapWant(env, propValueNapi, want) != true) {
560                 return nullptr;
561             }
562             builder.SetWant(std::make_shared<AAFwk::Want>(want));
563         } else if (propName == "pixelMap") {
564             std::shared_ptr<PixelMap> pixelMap = PixelMapNapi::GetPixelMap(env, propValueNapi);
565             if (pixelMap == nullptr) {
566                 return nullptr;
567             }
568             builder.SetPixelMap(pixelMap);
569         } else if (propName == "data") {
570             std::shared_ptr<MineCustomData> customData = PasteDataRecordNapi::GetNativeKvData(env, propValueNapi);
571             if (customData == nullptr) {
572                 return nullptr;
573             }
574             builder.SetCustomData(customData);
575         }
576     }
577     std::shared_ptr<PasteDataRecord> result = builder.Build();
578 
579     PasteDataRecordNapi *record = nullptr;
580     napi_unwrap(env, recordNapi, reinterpret_cast<void **>(&record));
581     if (record != nullptr && record->value_->GetEntryGetter() != nullptr) {
582         result->SetEntryGetter(record->value_->GetEntryGetter());
583         result->SetDelayRecordFlag(true);
584     }
585     if (record != nullptr && !record->value_->GetEntries().empty()) {
586         for (const auto& pasteDataEntry : record->value_->GetEntries()) {
587             result->AddEntry(pasteDataEntry->GetUtdId(), pasteDataEntry);
588         }
589     }
590 
591     return result;
592 }
593 
AddRecord(napi_env env,napi_value argv,PasteDataNapi * obj)594 void PasteDataNapi::AddRecord(napi_env env, napi_value argv, PasteDataNapi *obj)
595 {
596     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddPasteDataRecord!");
597 
598     napi_valuetype valueType = napi_undefined;
599     NAPI_CALL_RETURN_VOID(env, napi_typeof(env, argv, &valueType));
600     NAPI_ASSERT_RETURN_VOID(env, valueType == napi_object, "Wrong argument type. Object expected.");
601 
602     std::shared_ptr<PasteDataRecord> pasteDataRecord = ParseRecord(env, argv);
603     if (pasteDataRecord == nullptr) {
604         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "ParseRecord failed!");
605         return;
606     }
607     obj->value_->AddRecord(*pasteDataRecord);
608 }
609 
AddRecord(napi_env env,napi_callback_info info)610 napi_value PasteDataNapi::AddRecord(napi_env env, napi_callback_info info)
611 {
612     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddRecord is called!");
613     size_t argc = ARGC_TYPE_SET2;
614     napi_value argv[ARGC_TYPE_SET2] = { 0 };
615     napi_value thisVar = nullptr;
616     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
617     NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
618     PasteDataNapi *obj = nullptr;
619     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
620     if ((status != napi_ok) || (obj == nullptr)) {
621         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddRecord object failed");
622         return nullptr;
623     }
624 
625     if (argc == ARGC_TYPE_SET1) {
626         AddRecord(env, argv[0], obj);
627         return nullptr;
628     }
629     AddRecord(env, argv, argc, obj);
630     return nullptr;
631 }
632 
ReplaceRecordAt(napi_env env,napi_callback_info info)633 napi_value PasteDataNapi::ReplaceRecordAt(napi_env env, napi_callback_info info)
634 {
635     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "ReplaceRecordAt is called!");
636     size_t argc = ARGC_TYPE_SET2;
637     napi_value argv[ARGC_TYPE_SET2] = { 0 };
638     napi_value thisVar = nullptr;
639     napi_value result = nullptr;
640     napi_get_boolean(env, false, &result);
641 
642     NAPI_CALL_BASE(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL), result);
643     NAPI_ASSERT(env, argc > ARGC_TYPE_SET1, "Wrong number of arguments");
644     napi_valuetype valueType = napi_undefined;
645     NAPI_CALL_BASE(env, napi_typeof(env, argv[0], &valueType), result);
646     NAPI_ASSERT(env, valueType == napi_number, "Wrong argument type. number expected.");
647     NAPI_CALL_BASE(env, napi_typeof(env, argv[1], &valueType), result);
648     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
649 
650     PasteDataNapi *obj = nullptr;
651     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
652     if ((status != napi_ok) || (obj == nullptr)) {
653         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get ReplaceRecordAt object failed");
654         return result;
655     }
656 
657     std::shared_ptr<PasteDataRecord> pasteDataRecord = ParseRecord(env, argv[1]);
658     if (pasteDataRecord == nullptr) {
659         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "ParseRecord failed!");
660         return result;
661     }
662 
663     int64_t number = 0;
664     napi_get_value_int64(env, argv[0], &number);
665     bool ret = obj->value_->ReplaceRecordAt(number, pasteDataRecord);
666     napi_get_boolean(env, ret, &result);
667 
668     return result;
669 }
670 
ReplaceRecord(napi_env env,napi_callback_info info)671 napi_value PasteDataNapi::ReplaceRecord(napi_env env, napi_callback_info info)
672 {
673     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "ReplaceRecord is called!");
674     size_t argc = ARGC_TYPE_SET2;
675     napi_value argv[ARGC_TYPE_SET2] = { 0 };
676     napi_value thisVar = nullptr;
677     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
678     if (!CheckExpression(env, argc > ARGC_TYPE_SET1, JSErrorCode::INVALID_PARAMETERS,
679         "Parameter error. The number of arguments must be greater than one.") ||
680         !CheckArgsType(env, argv[0], napi_number, "The type of mimeType must be number.")) {
681         return nullptr;
682     }
683 
684     PasteDataNapi *obj = nullptr;
685     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
686     if ((status != napi_ok) || (obj == nullptr)) {
687         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get ReplaceRecord object failed");
688         return nullptr;
689     }
690     uint32_t index = 0;
691     NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &index));
692     if (!CheckExpression(env, index < obj->value_->GetRecordCount(),
693         JSErrorCode::OUT_OF_RANGE, "index out of range.")) {
694         return nullptr;
695     }
696 
697     if (!CheckArgsType(env, argv[1], napi_object, "The type of record must be PasteDataRecord.")) {
698         return nullptr;
699     }
700     std::shared_ptr<PasteDataRecord> pasteDataRecord = ParseRecord(env, argv[1]);
701     if (!CheckExpression(env, pasteDataRecord != nullptr, JSErrorCode::INVALID_PARAMETERS,
702         "Parameter error. The type of PasteDataRecord cannot be nullptr.")) {
703         return nullptr;
704     }
705     obj->value_->ReplaceRecordAt(index, pasteDataRecord);
706     return nullptr;
707 }
708 
AddWantRecord(napi_env env,napi_callback_info info)709 napi_value PasteDataNapi::AddWantRecord(napi_env env, napi_callback_info info)
710 {
711     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "AddWantRecord is called!");
712     size_t argc = 1;
713     napi_value argv[1] = { 0 };
714     napi_value thisVar = nullptr;
715 
716     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
717     NAPI_ASSERT(env, argc > ARGC_TYPE_SET0, "Wrong number of arguments");
718 
719     napi_valuetype valueType = napi_undefined;
720     NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
721     NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected.");
722     OHOS::AAFwk::Want want;
723     if (!OHOS::AppExecFwk::UnwrapWant(env, argv[0], want)) {
724         return nullptr;
725     }
726 
727     PasteDataNapi *obj = nullptr;
728     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
729     if ((status != napi_ok) || (obj == nullptr)) {
730         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get AddWantRecord object failed");
731         return nullptr;
732     }
733 
734     obj->value_->AddWantRecord(std::make_shared<OHOS::AAFwk::Want>(want));
735     return nullptr;
736 }
737 
GetPrimaryWant(napi_env env,napi_callback_info info)738 napi_value PasteDataNapi::GetPrimaryWant(napi_env env, napi_callback_info info)
739 {
740     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetPrimaryWant is called!");
741     size_t argc = 1;
742     napi_value argv[1] = { 0 };
743     napi_value thisVar = nullptr;
744 
745     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
746     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
747 
748     PasteDataNapi *obj = nullptr;
749     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
750     if ((status != napi_ok) || (obj == nullptr)) {
751         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetPrimaryWant object failed");
752         return nullptr;
753     }
754 
755     std::shared_ptr<OHOS::AAFwk::Want> want = obj->value_->GetPrimaryWant();
756     if (!want) {
757         return nullptr;
758     }
759     return OHOS::AppExecFwk::WrapWant(env, *want);
760 }
761 
SetNapiProperty(napi_env env,const PasteDataProperty & property,napi_value & nProperty)762 bool PasteDataNapi::SetNapiProperty(napi_env env, const PasteDataProperty &property, napi_value &nProperty)
763 {
764     napi_value value = nullptr;
765     napi_value arr = nullptr;
766     int count = 0;
767 
768     // additions : {[key: string]: object}
769     value = OHOS::AppExecFwk::WrapWantParams(env, property.additions);
770     napi_set_named_property(env, nProperty, "additions", value);
771 
772     // mimeTypes: Array<string>
773     napi_create_array(env, &arr);
774     for (auto vec : property.mimeTypes) {
775         napi_create_string_utf8(env, vec.c_str(), NAPI_AUTO_LENGTH, &value);
776         napi_set_element(env, arr, count, value);
777         count++;
778     }
779     napi_set_named_property(env, nProperty, "mimeTypes", arr);
780 
781     // tag: string
782     napi_create_string_utf8(env, property.tag.c_str(), NAPI_AUTO_LENGTH, &value);
783     napi_set_named_property(env, nProperty, "tag", value);
784 
785     // timestamp: number
786     napi_create_int64(env, property.timestamp, &value);
787     napi_set_named_property(env, nProperty, "timestamp", value);
788 
789     // localOnly: boolean
790     napi_get_boolean(env, property.localOnly, &value);
791     napi_set_named_property(env, nProperty, "localOnly", value);
792 
793     napi_create_int32(env, static_cast<int32_t>(property.shareOption), &value);
794     napi_set_named_property(env, nProperty, "shareOption", value);
795     return true;
796 }
797 
GetProperty(napi_env env,napi_callback_info info)798 napi_value PasteDataNapi::GetProperty(napi_env env, napi_callback_info info)
799 {
800     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetProperty is called!");
801     size_t argc = 1;
802     napi_value argv[1] = { 0 };
803     napi_value thisVar = nullptr;
804 
805     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
806     NAPI_ASSERT(env, argc >= ARGC_TYPE_SET0, "Wrong number of arguments");
807 
808     PasteDataNapi *obj = nullptr;
809     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
810     if ((status != napi_ok) || (obj == nullptr)) {
811         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Get GetProperty object failed");
812         return nullptr;
813     }
814     PasteDataProperty property = obj->value_->GetProperty();
815     napi_value nProperty = nullptr;
816     napi_create_object(env, &nProperty);
817     if (!SetNapiProperty(env, property, nProperty)) {
818         return nullptr;
819     }
820     return nProperty;
821 }
822 
GetRecordAt(napi_env env,napi_callback_info info)823 napi_value PasteDataNapi::GetRecordAt(napi_env env, napi_callback_info info)
824 {
825     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetRecordAt is called!");
826     uint32_t index = 0;
827     PasteDataNapi *obj = RemoveAndGetRecordCommon(env, info, index);
828     if (obj == nullptr) {
829         return nullptr;
830     }
831 
832     std::shared_ptr<PasteDataRecord> record = obj->value_->GetRecordAt(index);
833     napi_value instance = nullptr;
834     PasteDataRecordNapi::NewInstanceByRecord(env, instance, record);
835     return instance;
836 }
837 
GetRecord(napi_env env,napi_callback_info info)838 napi_value PasteDataNapi::GetRecord(napi_env env, napi_callback_info info)
839 {
840     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "GetRecord is called!");
841     uint32_t index = 0;
842     PasteDataNapi *obj = RemoveAndGetRecordCommon(env, info, index);
843     if (obj == nullptr || !CheckExpression(env, index < obj->value_->GetRecordCount(),
844         JSErrorCode::OUT_OF_RANGE, "index out of range.")) {
845         return nullptr;
846     }
847 
848     std::shared_ptr<PasteDataRecord> record = obj->value_->GetRecordAt(index);
849     napi_value instance = nullptr;
850     PasteDataRecordNapi::NewInstanceByRecord(env, instance, record);
851     return instance;
852 }
853 
SetProperty(napi_env env,napi_value in,PasteDataNapi * obj)854 void PasteDataNapi::SetProperty(napi_env env, napi_value in, PasteDataNapi *obj)
855 {
856     napi_value propertyNames = nullptr;
857     NAPI_CALL_RETURN_VOID(env, napi_get_property_names(env, in, &propertyNames));
858     uint32_t propertyNamesNum = 0;
859     NAPI_CALL_RETURN_VOID(env, napi_get_array_length(env, propertyNames, &propertyNamesNum));
860     bool localOnlyValue = false;
861     int32_t shareOptionValue = ShareOption::CrossDevice;
862     for (uint32_t i = 0; i < propertyNamesNum; i++) {
863         napi_value propertyNameNapi = nullptr;
864         NAPI_CALL_RETURN_VOID(env, napi_get_element(env, propertyNames, i, &propertyNameNapi));
865         size_t len = 0;
866         char str[STR_MAX_SIZE] = { 0 };
867         NAPI_CALL_RETURN_VOID(env, napi_get_value_string_utf8(env, propertyNameNapi, str, STR_MAX_SIZE, &len));
868         std::string propertyName = str;
869         napi_value propertyNameValueNapi = nullptr;
870         NAPI_CALL_RETURN_VOID(env, napi_get_named_property(env, in, str, &propertyNameValueNapi));
871         if (propertyName == "localOnly") {
872             NAPI_CALL_RETURN_VOID(env, napi_get_value_bool(env, propertyNameValueNapi, &localOnlyValue));
873             PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "localOnlyValue = %{public}d", localOnlyValue);
874         }
875         if (propertyName == "shareOption") {
876             NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, propertyNameValueNapi, &shareOptionValue));
877             PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "shareOptionValue = %{public}d", shareOptionValue);
878         }
879         if (propertyName == "tag") {
880             char tagValue[STR_MAX_SIZE] = { 0 };
881             size_t tagValueLen = 0;
882             NAPI_CALL_RETURN_VOID(env,
883                 napi_get_value_string_utf8(env, propertyNameValueNapi, tagValue, STR_MAX_SIZE, &tagValueLen));
884             PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "tagValue = %{public}s", tagValue);
885             std::string tagValueStr = tagValue;
886             obj->value_->SetTag(tagValueStr);
887         }
888         if (propertyName == "additions") {
889             AAFwk::WantParams additions;
890             bool ret = OHOS::AppExecFwk::UnwrapWantParams(env, propertyNameValueNapi, additions);
891             PASTEBOARD_HILOGD(PASTEBOARD_MODULE_CLIENT, "additions ret = %{public}d", ret);
892             obj->value_->SetAdditions(additions);
893         }
894     }
895     localOnlyValue = shareOptionValue == ShareOption::CrossDevice ? false : true;
896     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_CLIENT, "localOnly final Value = %{public}d", localOnlyValue);
897     obj->value_->SetLocalOnly(localOnlyValue);
898     obj->value_->SetShareOption(static_cast<ShareOption>(shareOptionValue));
899 }
900 
IsProperty(napi_env env,napi_value in)901 bool PasteDataNapi::IsProperty(napi_env env, napi_value in)
902 {
903     napi_valuetype valueType = napi_undefined;
904     NAPI_CALL_BASE(env, napi_typeof(env, in, &valueType), false);
905     if (valueType != napi_object) {
906         return false;
907     }
908     napi_value propertyNames = nullptr;
909     NAPI_CALL_BASE(env, napi_get_property_names(env, in, &propertyNames), false);
910     uint32_t propertyNamesNum = 0;
911     NAPI_CALL_BASE(env, napi_get_array_length(env, propertyNames, &propertyNamesNum), false);
912     bool hasProperty = false;
913     const char *key[] = { "additions", "mimeTypes", "tag", "timestamp", "localOnly", "shareOption" };
914     const napi_valuetype type[] = { napi_object, napi_object, napi_string, napi_number, napi_boolean, napi_number };
915     napi_value propertyValue = nullptr;
916     for (uint32_t i = 0; i < propertyNamesNum; i++) {
917         NAPI_CALL_BASE(env, napi_has_named_property(env, in, key[i], &hasProperty), false);
918         if (!hasProperty) {
919             return false;
920         }
921         NAPI_CALL_BASE(env, napi_get_named_property(env, in, key[i], &propertyValue), false);
922         if (i == ARGC_TYPE_SET1) {
923             bool isArray = false;
924             NAPI_CALL_BASE(env, napi_is_array(env, propertyValue, &isArray), false);
925             if (!isArray) {
926                 return false;
927             }
928             continue;
929         }
930         NAPI_CALL_BASE(env, napi_typeof(env, propertyValue, &valueType), false);
931         if (valueType != type[i]) {
932             return false;
933         }
934     }
935     return true;
936 }
937 
SetProperty(napi_env env,napi_callback_info info)938 napi_value PasteDataNapi::SetProperty(napi_env env, napi_callback_info info)
939 {
940     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "SetProperty is called!");
941     size_t argc = ARGC_TYPE_SET1;
942     napi_value argv[ARGC_TYPE_SET1] = { 0 };
943     napi_value thisVar = nullptr;
944 
945     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
946     if (!CheckExpression(env, argc > ARGC_TYPE_SET0, JSErrorCode::INVALID_PARAMETERS,
947         "Parameter error. The number of arguments must be greater than zero.") ||
948         !CheckExpression(env, IsProperty(env, argv[0]), JSErrorCode::INVALID_PARAMETERS,
949         "Parameter error. The type of property must be PasteDataProperty.")) {
950         return nullptr;
951     }
952 
953     PasteDataNapi *obj = nullptr;
954     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
955     if ((status != napi_ok) || (obj == nullptr)) {
956         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "napi_unwrap failed");
957         return nullptr;
958     }
959     SetProperty(env, argv[0], obj);
960     return nullptr;
961 }
962 
PasteDataInit(napi_env env,napi_value exports)963 napi_value PasteDataNapi::PasteDataInit(napi_env env, napi_value exports)
964 {
965     napi_status status = napi_ok;
966     napi_property_descriptor descriptors[] = { DECLARE_NAPI_FUNCTION("addHtmlRecord", AddHtmlRecord),
967         DECLARE_NAPI_FUNCTION("addWantRecord", AddWantRecord), DECLARE_NAPI_FUNCTION("addRecord", AddRecord),
968         DECLARE_NAPI_FUNCTION("addTextRecord", AddTextRecord), DECLARE_NAPI_FUNCTION("addUriRecord", AddUriRecord),
969         DECLARE_NAPI_FUNCTION("addPixelMapRecord", AddPixelMapRecord),
970         DECLARE_NAPI_FUNCTION("getMimeTypes", GetMimeTypes), DECLARE_NAPI_FUNCTION("getPrimaryHtml", GetPrimaryHtml),
971         DECLARE_NAPI_FUNCTION("getPrimaryWant", GetPrimaryWant),
972         DECLARE_NAPI_FUNCTION("getPrimaryMimeType", GetPrimaryMimeType),
973         DECLARE_NAPI_FUNCTION("getPrimaryText", GetPrimaryText), DECLARE_NAPI_FUNCTION("getPrimaryUri", GetPrimaryUri),
974         DECLARE_NAPI_FUNCTION("getPrimaryPixelMap", GetPrimaryPixelMap),
975         DECLARE_NAPI_FUNCTION("getProperty", GetProperty), DECLARE_NAPI_FUNCTION("getRecordAt", GetRecordAt),
976         DECLARE_NAPI_FUNCTION("getRecord", GetRecord), DECLARE_NAPI_FUNCTION("getRecordCount", GetRecordCount),
977         DECLARE_NAPI_FUNCTION("getTag", GetTag), DECLARE_NAPI_FUNCTION("hasMimeType", HasMimeType),
978         DECLARE_NAPI_FUNCTION("hasType", HasType), DECLARE_NAPI_FUNCTION("removeRecordAt", RemoveRecordAt),
979         DECLARE_NAPI_FUNCTION("removeRecord", RemoveRecord), DECLARE_NAPI_FUNCTION("replaceRecordAt", ReplaceRecordAt),
980         DECLARE_NAPI_FUNCTION("replaceRecord", ReplaceRecord), DECLARE_NAPI_FUNCTION("setProperty", SetProperty),
981         DECLARE_NAPI_FUNCTION("pasteStart", PasteStart), DECLARE_NAPI_FUNCTION("pasteComplete", PasteComplete)};
982 
983     napi_value constructor;
984     napi_define_class(env, "PasteData", NAPI_AUTO_LENGTH, New, nullptr,
985         sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &constructor);
986     if (status != napi_ok) {
987         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "Failed to define class at Init");
988         return nullptr;
989     }
990 
991     status = napi_create_reference(env, constructor, 1, &g_pasteData);
992     if (status != napi_ok) {
993         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "PasteDataNapi Init create reference failed");
994         return nullptr;
995     }
996     napi_set_named_property(env, exports, "PasteData", constructor);
997     return exports;
998 }
999 
Destructor(napi_env env,void * nativeObject,void * finalize_hint)1000 void PasteDataNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint)
1001 {
1002     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "Destructor");
1003     PasteDataNapi *obj = static_cast<PasteDataNapi *>(nativeObject);
1004     delete obj;
1005 }
1006 
New(napi_env env,napi_callback_info info)1007 napi_value PasteDataNapi::New(napi_env env, napi_callback_info info)
1008 {
1009     size_t argc = ARGC_TYPE_SET1;
1010     napi_value argv[1] = { 0 };
1011     napi_value thisVar = nullptr;
1012     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1013 
1014     // get native object
1015     PasteDataNapi *obj = new PasteDataNapi();
1016     obj->env_ = env;
1017     ASSERT_CALL(env, napi_wrap(env, thisVar, obj, PasteDataNapi::Destructor,
1018                        nullptr, // finalize_hint
1019                        nullptr), obj);
1020     return thisVar;
1021 }
1022 
NewInstance(napi_env env,napi_value & instance)1023 napi_status PasteDataNapi::NewInstance(napi_env env, napi_value &instance)
1024 {
1025     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "enter");
1026     napi_status status;
1027     napi_value constructor;
1028     status = napi_get_reference_value(env, g_pasteData, &constructor);
1029     if (status != napi_ok) {
1030         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "get reference failed");
1031         return status;
1032     }
1033 
1034     status = napi_new_instance(env, constructor, 0, nullptr, &instance);
1035     if (status != napi_ok) {
1036         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "new instance failed");
1037         return status;
1038     }
1039     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "new instance ok");
1040     return napi_ok;
1041 }
1042 
IsPasteData(napi_env env,napi_value in)1043 bool PasteDataNapi::IsPasteData(napi_env env, napi_value in)
1044 {
1045     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "enter");
1046     napi_valuetype type = napi_undefined;
1047     NAPI_CALL_BASE(env, napi_typeof(env, in, &type), false);
1048     if (type != napi_object) {
1049         return false;
1050     }
1051     napi_value constructor;
1052     bool isPasteData = false;
1053     NAPI_CALL_BASE(env, napi_get_reference_value(env, g_pasteData, &constructor), false);
1054     NAPI_CALL_BASE(env, napi_instanceof(env, in, constructor, &isPasteData), false);
1055     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_JS_NAPI, "isPasteData is [%{public}d]", isPasteData);
1056     return isPasteData;
1057 }
1058 
PasteStart(napi_env env,napi_callback_info info)1059 napi_value PasteDataNapi::PasteStart(napi_env env, napi_callback_info info)
1060 {
1061     napi_value thisVar = nullptr;
1062     PasteDataNapi *obj = nullptr;
1063     size_t argc = 1;
1064     napi_value argv[1] = { 0 };
1065     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1066     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
1067     if ((status != napi_ok) || (obj == nullptr) || (obj->value_ == nullptr)) {
1068         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "napi_unwrap failed");
1069         return nullptr;
1070     }
1071     std::string pasteId = obj->value_->GetPasteId();
1072     PasteboardClient::GetInstance()->PasteStart(pasteId);
1073     return nullptr;
1074 }
1075 
PasteComplete(napi_env env,napi_callback_info info)1076 napi_value PasteDataNapi::PasteComplete(napi_env env, napi_callback_info info)
1077 {
1078     napi_value thisVar = nullptr;
1079     PasteDataNapi *obj = nullptr;
1080     size_t argc = 1;
1081     napi_value argv[1] = { 0 };
1082     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1083     napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&obj));
1084     if ((status != napi_ok) || (obj == nullptr) || (obj->value_ == nullptr)) {
1085         PASTEBOARD_HILOGE(PASTEBOARD_MODULE_JS_NAPI, "napi_unwrap failed");
1086         return nullptr;
1087     }
1088     std::string deviceId = obj->value_->GetDeviceId();
1089     std::string pasteId = obj->value_->GetPasteId();
1090     PasteboardClient::GetInstance()->PasteComplete(deviceId, pasteId);
1091     return nullptr;
1092 }
1093 } // namespace MiscServicesNapi
1094 } // namespace OHOS
1095