1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "napi_webview_controller.h"
17 
18 #include <arpa/inet.h>
19 #include <cctype>
20 #include <climits>
21 #include <cstdint>
22 #include <regex>
23 #include <securec.h>
24 #include <unistd.h>
25 #include <uv.h>
26 
27 #include "application_context.h"
28 #include "business_error.h"
29 #include "napi_parse_utils.h"
30 #include "native_engine/native_engine.h"
31 #include "nweb.h"
32 #include "nweb_adapter_helper.h"
33 #include "nweb_helper.h"
34 #include "nweb_init_params.h"
35 #include "nweb_log.h"
36 #include "ohos_adapter_helper.h"
37 #include "parameters.h"
38 #include "pixel_map.h"
39 #include "pixel_map_napi.h"
40 #include "web_errors.h"
41 #include "webview_javascript_execute_callback.h"
42 #include "webview_createpdf_execute_callback.h"
43 
44 #include "web_download_delegate.h"
45 #include "web_download_manager.h"
46 #include "arkweb_scheme_handler.h"
47 #include "web_scheme_handler_request.h"
48 
49 namespace OHOS {
50 namespace NWeb {
51 using namespace NWebError;
52 using NWebError::NO_ERROR;
53 
54 namespace {
55 constexpr uint32_t URL_MAXIMUM = 2048;
56 constexpr uint32_t SOCKET_MAXIMUM = 6;
57 constexpr char URL_REGEXPR[] = "^http(s)?:\\/\\/.+";
58 constexpr size_t MAX_RESOURCES_COUNT = 30;
59 constexpr size_t MAX_RESOURCE_SIZE = 10 * 1024 * 1024;
60 constexpr size_t MAX_URL_TRUST_LIST_STR_LEN = 10 * 1024 * 1024; // 10M
61 constexpr size_t BFCACHE_DEFAULT_SIZE = 1;
62 constexpr size_t BFCACHE_DEFAULT_TIMETOLIVE = 600;
63 constexpr double A4_WIDTH = 8.27;
64 constexpr double A4_HEIGHT = 11.69;
65 constexpr double SCALE_MIN = 0.1;
66 constexpr double SCALE_MAX = 2.0;
67 constexpr double HALF = 2.0;
68 constexpr double TEN_MILLIMETER_TO_INCH = 0.39;
69 using WebPrintWriteResultCallback = std::function<void(std::string, uint32_t)>;
70 
ParsePrepareUrl(napi_env env,napi_value urlObj,std::string & url)71 bool ParsePrepareUrl(napi_env env, napi_value urlObj, std::string& url)
72 {
73     napi_valuetype valueType = napi_null;
74     napi_typeof(env, urlObj, &valueType);
75 
76     if (valueType == napi_string) {
77         NapiParseUtils::ParseString(env, urlObj, url);
78         if (url.size() > URL_MAXIMUM) {
79             WVLOG_E("The URL exceeds the maximum length of %{public}d", URL_MAXIMUM);
80             return false;
81         }
82 
83         if (!regex_match(url, std::regex(URL_REGEXPR, std::regex_constants::icase))) {
84             WVLOG_E("ParsePrepareUrl error");
85             return false;
86         }
87 
88         return true;
89     }
90 
91     WVLOG_E("Unable to parse type from url object.");
92     return false;
93 }
94 
ParseIP(napi_env env,napi_value urlObj,std::string & ip)95 bool ParseIP(napi_env env, napi_value urlObj, std::string& ip)
96 {
97     napi_valuetype valueType = napi_null;
98     napi_typeof(env, urlObj, &valueType);
99 
100     if (valueType == napi_string) {
101         NapiParseUtils::ParseString(env, urlObj, ip);
102         if (ip == "") {
103             WVLOG_E("The IP is null");
104             return false;
105         }
106 
107         unsigned char buf[sizeof(struct in6_addr)];
108         if ((inet_pton(AF_INET, ip.c_str(), buf) == 1) || (inet_pton(AF_INET6, ip.c_str(), buf) == 1)) {
109             return true;
110         }
111         WVLOG_E("IP error.");
112         return false;
113     }
114 
115     WVLOG_E("Unable to parse type from ip object.");
116     return false;
117 }
118 
GetArrayValueType(napi_env env,napi_value array,bool & isDouble)119 napi_valuetype GetArrayValueType(napi_env env, napi_value array, bool& isDouble)
120 {
121     uint32_t arrayLength = 0;
122     napi_get_array_length(env, array, &arrayLength);
123     napi_valuetype valueTypeFirst = napi_undefined;
124     napi_valuetype valueTypeCur = napi_undefined;
125     for (uint32_t i = 0; i < arrayLength; ++i) {
126         napi_value obj = nullptr;
127         napi_get_element(env, array, i, &obj);
128         napi_typeof(env, obj, &valueTypeCur);
129         if (i == 0) {
130             valueTypeFirst = valueTypeCur;
131         }
132         if (valueTypeCur != napi_string && valueTypeCur != napi_number && valueTypeCur != napi_boolean) {
133             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
134             return napi_undefined;
135         }
136         if (valueTypeCur != valueTypeFirst) {
137             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
138             return napi_undefined;
139         }
140         if (valueTypeFirst == napi_number) {
141             int32_t elementInt32 = 0;
142             double elementDouble = 0.0;
143             bool isReadValue32 = napi_get_value_int32(env, obj, &elementInt32) == napi_ok;
144             bool isReadDouble = napi_get_value_double(env, obj, &elementDouble) == napi_ok;
145             constexpr double MINIMAL_ERROR = 0.000001;
146             if (isReadValue32 && isReadDouble) {
147                 isDouble = abs(elementDouble - elementInt32 * 1.0) > MINIMAL_ERROR;
148             } else if (isReadDouble) {
149                 isDouble = true;
150             }
151         }
152     }
153     return valueTypeFirst;
154 }
155 
SetArrayHandlerBoolean(napi_env env,napi_value array,WebMessageExt * webMessageExt)156 void SetArrayHandlerBoolean(napi_env env, napi_value array, WebMessageExt* webMessageExt)
157 {
158     std::vector<bool> outValue;
159     if (!NapiParseUtils::ParseBooleanArray(env, array, outValue)) {
160         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
161         return;
162     }
163     webMessageExt->SetBooleanArray(outValue);
164 }
165 
SetArrayHandlerString(napi_env env,napi_value array,WebMessageExt * webMessageExt)166 void SetArrayHandlerString(napi_env env, napi_value array, WebMessageExt* webMessageExt)
167 {
168     std::vector<std::string> outValue;
169     if (!NapiParseUtils::ParseStringArray(env, array, outValue)) {
170         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
171         return;
172     }
173     webMessageExt->SetStringArray(outValue);
174 }
175 
SetArrayHandlerInteger(napi_env env,napi_value array,WebMessageExt * webMessageExt)176 void SetArrayHandlerInteger(napi_env env, napi_value array, WebMessageExt* webMessageExt)
177 {
178     std::vector<int64_t> outValue;
179     if (!NapiParseUtils::ParseInt64Array(env, array, outValue)) {
180         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
181         return;
182     }
183     webMessageExt->SetInt64Array(outValue);
184 }
185 
SetArrayHandlerDouble(napi_env env,napi_value array,WebMessageExt * webMessageExt)186 void SetArrayHandlerDouble(napi_env env, napi_value array, WebMessageExt* webMessageExt)
187 {
188     std::vector<double> outValue;
189     if (!NapiParseUtils::ParseDoubleArray(env, array, outValue)) {
190         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
191         return;
192     }
193     webMessageExt->SetDoubleArray(outValue);
194 }
195 
GetWebviewController(napi_env env,napi_callback_info info)196 WebviewController* GetWebviewController(napi_env env, napi_callback_info info)
197 {
198     napi_value thisVar = nullptr;
199     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
200 
201     WebviewController *webviewController = nullptr;
202     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
203     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
204         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
205         return nullptr;
206     }
207     return webviewController;
208 }
209 
ParsePrepareRequestMethod(napi_env env,napi_value methodObj,std::string & method)210 bool ParsePrepareRequestMethod(napi_env env, napi_value methodObj, std::string& method)
211 {
212     napi_valuetype valueType = napi_null;
213     napi_typeof(env, methodObj, &valueType);
214 
215     if (valueType == napi_string) {
216         NapiParseUtils::ParseString(env, methodObj, method);
217         if (method != "POST") {
218             WVLOG_E("The method %{public}s is not supported.", method.c_str());
219             return false;
220         }
221         return true;
222     }
223 
224     WVLOG_E("Unable to parse type from method object.");
225     return false;
226 }
227 
ParseHttpHeaders(napi_env env,napi_value headersArray,std::map<std::string,std::string> * headers)228 bool ParseHttpHeaders(napi_env env, napi_value headersArray, std::map<std::string, std::string>* headers)
229 {
230     bool isArray = false;
231     napi_is_array(env, headersArray, &isArray);
232     if (isArray) {
233         uint32_t arrayLength = INTEGER_ZERO;
234         napi_get_array_length(env, headersArray, &arrayLength);
235         for (uint32_t i = 0; i < arrayLength; ++i) {
236             std::string key;
237             std::string value;
238             napi_value obj = nullptr;
239             napi_value keyObj = nullptr;
240             napi_value valueObj = nullptr;
241             napi_get_element(env, headersArray, i, &obj);
242             if (napi_get_named_property(env, obj, "headerKey", &keyObj) != napi_ok) {
243                 continue;
244             }
245             if (napi_get_named_property(env, obj, "headerValue", &valueObj) != napi_ok) {
246                 continue;
247             }
248             if (!NapiParseUtils::ParseString(env, keyObj, key) || !NapiParseUtils::ParseString(env, valueObj, value)) {
249                 WVLOG_E("Unable to parse string from headers array object.");
250                 return false;
251             }
252             if (key.empty()) {
253                 WVLOG_E("Key from headers is empty.");
254                 return false;
255             }
256             (*headers)[key] = value;
257         }
258     } else {
259         WVLOG_E("Unable to parse type from headers array object.");
260         return false;
261     }
262     return true;
263 }
264 
CheckCacheKey(napi_env env,const std::string & cacheKey)265 bool CheckCacheKey(napi_env env, const std::string& cacheKey)
266 {
267     for (char c : cacheKey) {
268         if (!isalnum(c)) {
269             WVLOG_E("BusinessError: 401. The character of 'cacheKey' must be number or letters.");
270             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
271             return false;
272         }
273     }
274     return true;
275 }
276 
ParseCacheKeyList(napi_env env,napi_value cacheKeyArray,std::vector<std::string> * cacheKeyList)277 bool ParseCacheKeyList(napi_env env, napi_value cacheKeyArray, std::vector<std::string>* cacheKeyList)
278 {
279     bool isArray = false;
280     napi_is_array(env, cacheKeyArray, &isArray);
281     if (!isArray) {
282         WVLOG_E("Unable to parse type from CacheKey array object.");
283         return false;
284     }
285     uint32_t arrayLength = INTEGER_ZERO;
286     napi_get_array_length(env, cacheKeyArray, &arrayLength);
287     if (arrayLength == 0) {
288         WVLOG_E("cacheKey array length is invalid");
289         return false;
290     }
291     for (uint32_t i = 0; i < arrayLength; ++i) {
292         napi_value cacheKeyItem = nullptr;
293         napi_get_element(env, cacheKeyArray, i, &cacheKeyItem);
294         std::string cacheKeyStr;
295         if (!NapiParseUtils::ParseString(env, cacheKeyItem, cacheKeyStr)) {
296             WVLOG_E("Unable to parse string from cacheKey array object.");
297             return false;
298         }
299         if (cacheKeyStr.empty()) {
300             WVLOG_E("Cache Key is empty.");
301             return false;
302         }
303         for (char c : cacheKeyStr) {
304             if (!isalnum(c)) {
305                 WVLOG_E("Cache Key is invalid.");
306                 return false;
307             }
308         }
309         cacheKeyList->emplace_back(cacheKeyStr);
310     }
311     return true;
312 }
313 
ParsePrefetchArgs(napi_env env,napi_value preArgs)314 std::shared_ptr<NWebEnginePrefetchArgs> ParsePrefetchArgs(napi_env env, napi_value preArgs)
315 {
316     napi_value urlObj = nullptr;
317     std::string url;
318     napi_get_named_property(env, preArgs, "url", &urlObj);
319     if (!ParsePrepareUrl(env, urlObj, url)) {
320         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
321         return nullptr;
322     }
323 
324     napi_value methodObj = nullptr;
325     std::string method;
326     napi_get_named_property(env, preArgs, "method", &methodObj);
327     if (!ParsePrepareRequestMethod(env, methodObj, method)) {
328         WVLOG_E("BusinessError: 401. The type of 'method' must be string 'POST'.");
329         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
330         return nullptr;
331     }
332 
333     napi_value formDataObj = nullptr;
334     std::string formData;
335     napi_get_named_property(env, preArgs, "formData", &formDataObj);
336     if (!NapiParseUtils::ParseString(env, formDataObj, formData)) {
337         WVLOG_E("BusinessError: 401. The type of 'formData' must be string.");
338         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
339         return nullptr;
340     }
341     std::shared_ptr<NWebEnginePrefetchArgs> prefetchArgs = std::make_shared<NWebEnginePrefetchArgsImpl>(
342         url, method, formData);
343     return prefetchArgs;
344 }
345 
ParsePDFMarginConfigArgs(napi_env env,napi_value preArgs,double width,double height)346 PDFMarginConfig ParsePDFMarginConfigArgs(napi_env env, napi_value preArgs, double width, double height)
347 {
348     napi_value marginTopObj = nullptr;
349     double marginTop = TEN_MILLIMETER_TO_INCH;
350     napi_get_named_property(env, preArgs, "marginTop", &marginTopObj);
351     if (!NapiParseUtils::ParseDouble(env, marginTopObj, marginTop)) {
352         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
353             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "marginTop", "number"));
354         return PDFMarginConfig();
355     }
356     marginTop = (marginTop >= height / HALF || marginTop <= 0.0) ? 0.0 : marginTop;
357 
358     napi_value marginBottomObj = nullptr;
359     double marginBottom = TEN_MILLIMETER_TO_INCH;
360     napi_get_named_property(env, preArgs, "marginBottom", &marginBottomObj);
361     if (!NapiParseUtils::ParseDouble(env, marginBottomObj, marginBottom)) {
362         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
363             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "marginBottom", "number"));
364         return PDFMarginConfig();
365     }
366     marginBottom = (marginBottom >= height / HALF || marginBottom <= 0.0) ? 0.0 : marginBottom;
367 
368     napi_value marginRightObj = nullptr;
369     double marginRight = TEN_MILLIMETER_TO_INCH;
370     napi_get_named_property(env, preArgs, "marginRight", &marginRightObj);
371     if (!NapiParseUtils::ParseDouble(env, marginRightObj, marginRight)) {
372         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
373             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "marginRight", "number"));
374         return PDFMarginConfig();
375     }
376     marginRight = (marginRight >= width / HALF || marginRight <= 0.0) ? 0.0 : marginRight;
377 
378     napi_value marginLeftObj = nullptr;
379     double marginLeft = TEN_MILLIMETER_TO_INCH;
380     napi_get_named_property(env, preArgs, "marginLeft", &marginLeftObj);
381     if (!NapiParseUtils::ParseDouble(env, marginLeftObj, marginLeft)) {
382         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
383             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "marginLeft", "number"));
384         return PDFMarginConfig();
385     }
386     marginLeft = (marginLeft >= width / HALF || marginLeft <= 0.0) ? 0.0 : marginLeft;
387 
388     return { marginTop, marginBottom, marginRight, marginLeft };
389 }
390 
ParsePDFConfigArgs(napi_env env,napi_value preArgs)391 std::shared_ptr<NWebPDFConfigArgs> ParsePDFConfigArgs(napi_env env, napi_value preArgs)
392 {
393     napi_value widthObj = nullptr;
394     double width = A4_WIDTH;
395     napi_get_named_property(env, preArgs, "width", &widthObj);
396     if (!NapiParseUtils::ParseDouble(env, widthObj, width)) {
397         BusinessError::ThrowErrorByErrcode(
398             env, PARAM_CHECK_ERROR, NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "width", "number"));
399         return nullptr;
400     }
401 
402     napi_value heightObj = nullptr;
403     double height = A4_HEIGHT;
404     napi_get_named_property(env, preArgs, "height", &heightObj);
405     if (!NapiParseUtils::ParseDouble(env, heightObj, height)) {
406         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
407             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "height", "number"));
408         return nullptr;
409     }
410 
411     napi_value scaleObj = nullptr;
412     double scale = 1.0;
413     napi_get_named_property(env, preArgs, "scale", &scaleObj);
414     NapiParseUtils::ParseDouble(env, scaleObj, scale);
415     scale = scale > SCALE_MAX ? SCALE_MAX : scale < SCALE_MIN ? SCALE_MIN : scale;
416 
417     auto margin = ParsePDFMarginConfigArgs(env, preArgs, width, height);
418 
419     napi_value shouldPrintBackgroundObj = nullptr;
420     bool shouldPrintBackground = false;
421     napi_get_named_property(env, preArgs, "shouldPrintBackground", &shouldPrintBackgroundObj);
422     NapiParseUtils::ParseBoolean(env, shouldPrintBackgroundObj, shouldPrintBackground);
423 
424     std::shared_ptr<NWebPDFConfigArgs> pdfConfig = std::make_shared<NWebPDFConfigArgsImpl>(
425         width, height, scale, margin.top, margin.bottom, margin.right, margin.left, shouldPrintBackground);
426     return pdfConfig;
427 }
428 
JsErrorCallback(napi_env env,napi_ref jsCallback,int32_t err)429 void JsErrorCallback(napi_env env, napi_ref jsCallback, int32_t err)
430 {
431     napi_value jsError = nullptr;
432     napi_value jsResult = nullptr;
433 
434     jsError = BusinessError::CreateError(env, err);
435     napi_get_undefined(env, &jsResult);
436     napi_value args[INTEGER_TWO] = {jsError, jsResult};
437 
438     napi_value callback = nullptr;
439     napi_value callbackResult = nullptr;
440     napi_get_reference_value(env, jsCallback, &callback);
441     napi_call_function(env, nullptr, callback, INTEGER_TWO, args, &callbackResult);
442     napi_delete_reference(env, jsCallback);
443 }
444 
ParseRegisterJavaScriptProxyParam(napi_env env,size_t argc,napi_value * argv,RegisterJavaScriptProxyParam * param)445 bool ParseRegisterJavaScriptProxyParam(napi_env env, size_t argc, napi_value* argv,
446     RegisterJavaScriptProxyParam* param)
447 {
448     std::string objName;
449     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], objName)) {
450         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
451             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "name", "string"));
452         return false;
453     }
454     std::vector<std::string> methodList;
455     if (!NapiParseUtils::ParseStringArray(env, argv[INTEGER_TWO], methodList)) {
456         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
457             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "methodList", "array"));
458         return false;
459     }
460     std::vector<std::string> asyncMethodList;
461     if (argc == INTEGER_FOUR && !NapiParseUtils::ParseStringArray(env, argv[INTEGER_THREE], asyncMethodList)) {
462         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
463         return false;
464     }
465     std::string permission;
466     if (argc == INTEGER_FIVE && !NapiParseUtils::ParseString(env, argv[INTEGER_FOUR], permission)) {
467         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
468             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "permission", "string"));
469         return false;
470     }
471     param->env = env;
472     param->obj = argv[INTEGER_ZERO];
473     param->objName = objName;
474     param->syncMethodList = methodList;
475     param->asyncMethodList = asyncMethodList;
476     param->permission = permission;
477     return true;
478 }
479 
RemoveDownloadDelegateRef(napi_env env,napi_value thisVar)480 napi_value RemoveDownloadDelegateRef(napi_env env, napi_value thisVar)
481 {
482     WebviewController *webviewController = nullptr;
483     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
484     if (webviewController == nullptr || !webviewController->IsInit()) {
485         WVLOG_E("create message port failed, napi unwrap webviewController failed");
486         return nullptr;
487     }
488 
489     WebDownloadManager::RemoveDownloadDelegateRef(webviewController->GetWebId());
490     return nullptr;
491 }
492 } // namespace
493 
494 int32_t NapiWebviewController::maxFdNum_ = -1;
495 std::atomic<int32_t> NapiWebviewController::usedFd_ {0};
496 std::atomic<bool> g_inWebPageSnapshot {false};
497 
498 thread_local napi_ref g_classWebMsgPort;
499 thread_local napi_ref g_historyListRef;
500 thread_local napi_ref g_webMsgExtClassRef;
501 thread_local napi_ref g_webPrintDocClassRef;
Init(napi_env env,napi_value exports)502 napi_value NapiWebviewController::Init(napi_env env, napi_value exports)
503 {
504     napi_property_descriptor properties[] = {
505         DECLARE_NAPI_STATIC_FUNCTION("initializeWebEngine", NapiWebviewController::InitializeWebEngine),
506         DECLARE_NAPI_STATIC_FUNCTION("setHttpDns", NapiWebviewController::SetHttpDns),
507         DECLARE_NAPI_STATIC_FUNCTION("setWebDebuggingAccess", NapiWebviewController::SetWebDebuggingAccess),
508         DECLARE_NAPI_STATIC_FUNCTION("setServiceWorkerWebSchemeHandler",
509                                      NapiWebviewController::SetServiceWorkerWebSchemeHandler),
510         DECLARE_NAPI_STATIC_FUNCTION("clearServiceWorkerWebSchemeHandler",
511                                      NapiWebviewController::ClearServiceWorkerWebSchemeHandler),
512         DECLARE_NAPI_FUNCTION("getWebDebuggingAccess", NapiWebviewController::InnerGetWebDebuggingAccess),
513         DECLARE_NAPI_FUNCTION("setWebId", NapiWebviewController::SetWebId),
514         DECLARE_NAPI_FUNCTION("jsProxy", NapiWebviewController::InnerJsProxy),
515         DECLARE_NAPI_FUNCTION("getCustomeSchemeCmdLine", NapiWebviewController::InnerGetCustomeSchemeCmdLine),
516         DECLARE_NAPI_FUNCTION("accessForward", NapiWebviewController::AccessForward),
517         DECLARE_NAPI_FUNCTION("accessBackward", NapiWebviewController::AccessBackward),
518         DECLARE_NAPI_FUNCTION("accessStep", NapiWebviewController::AccessStep),
519         DECLARE_NAPI_FUNCTION("clearHistory", NapiWebviewController::ClearHistory),
520         DECLARE_NAPI_FUNCTION("forward", NapiWebviewController::Forward),
521         DECLARE_NAPI_FUNCTION("backward", NapiWebviewController::Backward),
522         DECLARE_NAPI_FUNCTION("onActive", NapiWebviewController::OnActive),
523         DECLARE_NAPI_FUNCTION("onInactive", NapiWebviewController::OnInactive),
524         DECLARE_NAPI_FUNCTION("refresh", NapiWebviewController::Refresh),
525         DECLARE_NAPI_FUNCTION("zoomIn", NapiWebviewController::ZoomIn),
526         DECLARE_NAPI_FUNCTION("zoomOut", NapiWebviewController::ZoomOut),
527         DECLARE_NAPI_FUNCTION("getWebId", NapiWebviewController::GetWebId),
528         DECLARE_NAPI_FUNCTION("getUserAgent", NapiWebviewController::GetUserAgent),
529         DECLARE_NAPI_FUNCTION("getCustomUserAgent", NapiWebviewController::GetCustomUserAgent),
530         DECLARE_NAPI_FUNCTION("setCustomUserAgent", NapiWebviewController::SetCustomUserAgent),
531         DECLARE_NAPI_FUNCTION("getTitle", NapiWebviewController::GetTitle),
532         DECLARE_NAPI_FUNCTION("getPageHeight", NapiWebviewController::GetPageHeight),
533         DECLARE_NAPI_FUNCTION("backOrForward", NapiWebviewController::BackOrForward),
534         DECLARE_NAPI_FUNCTION("storeWebArchive", NapiWebviewController::StoreWebArchive),
535         DECLARE_NAPI_FUNCTION("createWebMessagePorts", NapiWebviewController::CreateWebMessagePorts),
536         DECLARE_NAPI_FUNCTION("postMessage", NapiWebviewController::PostMessage),
537         DECLARE_NAPI_FUNCTION("getHitTestValue", NapiWebviewController::GetHitTestValue),
538         DECLARE_NAPI_FUNCTION("requestFocus", NapiWebviewController::RequestFocus),
539         DECLARE_NAPI_FUNCTION("loadUrl", NapiWebviewController::LoadUrl),
540         DECLARE_NAPI_FUNCTION("postUrl", NapiWebviewController::PostUrl),
541         DECLARE_NAPI_FUNCTION("loadData", NapiWebviewController::LoadData),
542         DECLARE_NAPI_FUNCTION("getHitTest", NapiWebviewController::GetHitTest),
543         DECLARE_NAPI_FUNCTION("clearMatches", NapiWebviewController::ClearMatches),
544         DECLARE_NAPI_FUNCTION("searchNext", NapiWebviewController::SearchNext),
545         DECLARE_NAPI_FUNCTION("searchAllAsync", NapiWebviewController::SearchAllAsync),
546         DECLARE_NAPI_FUNCTION("clearSslCache", NapiWebviewController::ClearSslCache),
547         DECLARE_NAPI_FUNCTION("clearClientAuthenticationCache", NapiWebviewController::ClearClientAuthenticationCache),
548         DECLARE_NAPI_FUNCTION("stop", NapiWebviewController::Stop),
549         DECLARE_NAPI_FUNCTION("zoom", NapiWebviewController::Zoom),
550         DECLARE_NAPI_FUNCTION("registerJavaScriptProxy", NapiWebviewController::RegisterJavaScriptProxy),
551         DECLARE_NAPI_FUNCTION("innerCompleteWindowNew", NapiWebviewController::InnerCompleteWindowNew),
552         DECLARE_NAPI_FUNCTION("deleteJavaScriptRegister", NapiWebviewController::DeleteJavaScriptRegister),
553         DECLARE_NAPI_FUNCTION("runJavaScript", NapiWebviewController::RunJavaScript),
554         DECLARE_NAPI_FUNCTION("runJavaScriptExt", NapiWebviewController::RunJavaScriptExt),
555         DECLARE_NAPI_FUNCTION("createPdf", NapiWebviewController::RunCreatePDFExt),
556         DECLARE_NAPI_FUNCTION("getUrl", NapiWebviewController::GetUrl),
557         DECLARE_NAPI_FUNCTION("terminateRenderProcess", NapiWebviewController::TerminateRenderProcess),
558         DECLARE_NAPI_FUNCTION("getOriginalUrl", NapiWebviewController::GetOriginalUrl),
559         DECLARE_NAPI_FUNCTION("setNetworkAvailable", NapiWebviewController::SetNetworkAvailable),
560         DECLARE_NAPI_FUNCTION("innerGetWebId", NapiWebviewController::InnerGetWebId),
561         DECLARE_NAPI_FUNCTION("hasImage", NapiWebviewController::HasImage),
562         DECLARE_NAPI_FUNCTION("removeCache", NapiWebviewController::RemoveCache),
563         DECLARE_NAPI_FUNCTION("getFavicon", NapiWebviewController::GetFavicon),
564         DECLARE_NAPI_FUNCTION("getBackForwardEntries", NapiWebviewController::getBackForwardEntries),
565         DECLARE_NAPI_FUNCTION("serializeWebState", NapiWebviewController::SerializeWebState),
566         DECLARE_NAPI_FUNCTION("restoreWebState", NapiWebviewController::RestoreWebState),
567         DECLARE_NAPI_FUNCTION("pageDown", NapiWebviewController::ScrollPageDown),
568         DECLARE_NAPI_FUNCTION("pageUp", NapiWebviewController::ScrollPageUp),
569         DECLARE_NAPI_FUNCTION("scrollTo", NapiWebviewController::ScrollTo),
570         DECLARE_NAPI_FUNCTION("scrollBy", NapiWebviewController::ScrollBy),
571         DECLARE_NAPI_FUNCTION("slideScroll", NapiWebviewController::SlideScroll),
572         DECLARE_NAPI_FUNCTION("setScrollable", NapiWebviewController::SetScrollable),
573         DECLARE_NAPI_FUNCTION("getScrollable", NapiWebviewController::GetScrollable),
574         DECLARE_NAPI_STATIC_FUNCTION("customizeSchemes", NapiWebviewController::CustomizeSchemes),
575         DECLARE_NAPI_FUNCTION("innerSetHapPath", NapiWebviewController::InnerSetHapPath),
576         DECLARE_NAPI_FUNCTION("innerGetCertificate", NapiWebviewController::InnerGetCertificate),
577         DECLARE_NAPI_FUNCTION("setAudioMuted", NapiWebviewController::SetAudioMuted),
578         DECLARE_NAPI_FUNCTION("innerGetThisVar", NapiWebviewController::InnerGetThisVar),
579         DECLARE_NAPI_FUNCTION("prefetchPage", NapiWebviewController::PrefetchPage),
580         DECLARE_NAPI_FUNCTION("setDownloadDelegate", NapiWebviewController::SetDownloadDelegate),
581         DECLARE_NAPI_FUNCTION("startDownload", NapiWebviewController::StartDownload),
582         DECLARE_NAPI_STATIC_FUNCTION("prepareForPageLoad", NapiWebviewController::PrepareForPageLoad),
583         DECLARE_NAPI_FUNCTION("createWebPrintDocumentAdapter", NapiWebviewController::CreateWebPrintDocumentAdapter),
584         DECLARE_NAPI_STATIC_FUNCTION("setConnectionTimeout", NapiWebviewController::SetConnectionTimeout),
585         DECLARE_NAPI_FUNCTION("enableSafeBrowsing", NapiWebviewController::EnableSafeBrowsing),
586         DECLARE_NAPI_FUNCTION("isSafeBrowsingEnabled", NapiWebviewController::IsSafeBrowsingEnabled),
587         DECLARE_NAPI_FUNCTION("getSecurityLevel", NapiWebviewController::GetSecurityLevel),
588         DECLARE_NAPI_FUNCTION("isIncognitoMode", NapiWebviewController::IsIncognitoMode),
589         DECLARE_NAPI_FUNCTION("setPrintBackground", NapiWebviewController::SetPrintBackground),
590         DECLARE_NAPI_FUNCTION("getPrintBackground", NapiWebviewController::GetPrintBackground),
591         DECLARE_NAPI_FUNCTION("setWebSchemeHandler", NapiWebviewController::SetWebSchemeHandler),
592         DECLARE_NAPI_FUNCTION("clearWebSchemeHandler", NapiWebviewController::ClearWebSchemeHandler),
593         DECLARE_NAPI_FUNCTION("enableIntelligentTrackingPrevention",
594             NapiWebviewController::EnableIntelligentTrackingPrevention),
595         DECLARE_NAPI_FUNCTION("isIntelligentTrackingPreventionEnabled",
596             NapiWebviewController::IsIntelligentTrackingPreventionEnabled),
597         DECLARE_NAPI_STATIC_FUNCTION("addIntelligentTrackingPreventionBypassingList",
598             NapiWebviewController::AddIntelligentTrackingPreventionBypassingList),
599         DECLARE_NAPI_STATIC_FUNCTION("removeIntelligentTrackingPreventionBypassingList",
600             NapiWebviewController::RemoveIntelligentTrackingPreventionBypassingList),
601         DECLARE_NAPI_STATIC_FUNCTION("clearIntelligentTrackingPreventionBypassingList",
602             NapiWebviewController::ClearIntelligentTrackingPreventionBypassingList),
603         DECLARE_NAPI_FUNCTION("getLastJavascriptProxyCallingFrameUrl",
604             NapiWebviewController::GetLastJavascriptProxyCallingFrameUrl),
605         DECLARE_NAPI_STATIC_FUNCTION("getDefaultUserAgent", NapiWebviewController::GetDefaultUserAgent),
606         DECLARE_NAPI_STATIC_FUNCTION("pauseAllTimers", NapiWebviewController::PauseAllTimers),
607         DECLARE_NAPI_STATIC_FUNCTION("resumeAllTimers", NapiWebviewController::ResumeAllTimers),
608         DECLARE_NAPI_FUNCTION("startCamera", NapiWebviewController::StartCamera),
609         DECLARE_NAPI_FUNCTION("stopCamera", NapiWebviewController::StopCamera),
610         DECLARE_NAPI_FUNCTION("closeCamera", NapiWebviewController::CloseCamera),
611         DECLARE_NAPI_FUNCTION("closeAllMediaPresentations", NapiWebviewController::CloseAllMediaPresentations),
612         DECLARE_NAPI_FUNCTION("stopAllMedia", NapiWebviewController::StopAllMedia),
613         DECLARE_NAPI_FUNCTION("resumeAllMedia", NapiWebviewController::ResumeAllMedia),
614         DECLARE_NAPI_FUNCTION("pauseAllMedia", NapiWebviewController::PauseAllMedia),
615         DECLARE_NAPI_FUNCTION("getMediaPlaybackState", NapiWebviewController::GetMediaPlaybackState),
616         DECLARE_NAPI_FUNCTION("onCreateNativeMediaPlayer", NapiWebviewController::OnCreateNativeMediaPlayer),
617         DECLARE_NAPI_STATIC_FUNCTION("prefetchResource", NapiWebviewController::PrefetchResource),
618         DECLARE_NAPI_STATIC_FUNCTION("clearPrefetchedResource", NapiWebviewController::ClearPrefetchedResource),
619         DECLARE_NAPI_STATIC_FUNCTION("setRenderProcessMode", NapiWebviewController::SetRenderProcessMode),
620         DECLARE_NAPI_STATIC_FUNCTION("getRenderProcessMode", NapiWebviewController::GetRenderProcessMode),
621         DECLARE_NAPI_FUNCTION("precompileJavaScript", NapiWebviewController::PrecompileJavaScript),
622         DECLARE_NAPI_FUNCTION("injectOfflineResources", NapiWebviewController::InjectOfflineResources),
623         DECLARE_NAPI_STATIC_FUNCTION("setHostIP", NapiWebviewController::SetHostIP),
624         DECLARE_NAPI_STATIC_FUNCTION("clearHostIP", NapiWebviewController::ClearHostIP),
625         DECLARE_NAPI_STATIC_FUNCTION("warmupServiceWorker", NapiWebviewController::WarmupServiceWorker),
626         DECLARE_NAPI_FUNCTION("getSurfaceId", NapiWebviewController::GetSurfaceId),
627         DECLARE_NAPI_STATIC_FUNCTION("enableWholeWebPageDrawing", NapiWebviewController::EnableWholeWebPageDrawing),
628         DECLARE_NAPI_FUNCTION("enableAdsBlock", NapiWebviewController::EnableAdsBlock),
629         DECLARE_NAPI_FUNCTION("isAdsBlockEnabled", NapiWebviewController::IsAdsBlockEnabled),
630         DECLARE_NAPI_FUNCTION("isAdsBlockEnabledForCurPage", NapiWebviewController::IsAdsBlockEnabledForCurPage),
631         DECLARE_NAPI_FUNCTION("webPageSnapshot", NapiWebviewController::WebPageSnapshot),
632         DECLARE_NAPI_FUNCTION("setUrlTrustList", NapiWebviewController::SetUrlTrustList),
633         DECLARE_NAPI_FUNCTION("setPathAllowingUniversalAccess",
634             NapiWebviewController::SetPathAllowingUniversalAccess),
635         DECLARE_NAPI_STATIC_FUNCTION("enableBackForwardCache", NapiWebviewController::EnableBackForwardCache),
636         DECLARE_NAPI_FUNCTION("setBackForwardCacheOptions", NapiWebviewController::SetBackForwardCacheOptions),
637         DECLARE_NAPI_FUNCTION("scrollByWithResult", NapiWebviewController::ScrollByWithResult),
638         DECLARE_NAPI_FUNCTION("updateInstanceId", NapiWebviewController::UpdateInstanceId),
639         DECLARE_NAPI_FUNCTION("getScrollOffset",
640             NapiWebviewController::GetScrollOffset),
641         DECLARE_NAPI_STATIC_FUNCTION("trimMemoryByPressureLevel",
642             NapiWebviewController::TrimMemoryByPressureLevel),
643     };
644     napi_value constructor = nullptr;
645     napi_define_class(env, WEBVIEW_CONTROLLER_CLASS_NAME.c_str(), WEBVIEW_CONTROLLER_CLASS_NAME.length(),
646         NapiWebviewController::JsConstructor, nullptr, sizeof(properties) / sizeof(properties[0]),
647         properties, &constructor);
648     NAPI_ASSERT(env, constructor != nullptr, "define js class WebviewController failed");
649     napi_status status = napi_set_named_property(env, exports, "WebviewController", constructor);
650     NAPI_ASSERT(env, status == napi_ok, "set property WebviewController failed");
651 
652     napi_value webMsgTypeEnum = nullptr;
653     napi_property_descriptor webMsgTypeProperties[] = {
654         DECLARE_NAPI_STATIC_PROPERTY("NOT_SUPPORT", NapiParseUtils::ToInt32Value(env,
655             static_cast<int32_t>(WebMessageType::NOTSUPPORT))),
656         DECLARE_NAPI_STATIC_PROPERTY("STRING", NapiParseUtils::ToInt32Value(env,
657             static_cast<int32_t>(WebMessageType::STRING))),
658         DECLARE_NAPI_STATIC_PROPERTY("NUMBER", NapiParseUtils::ToInt32Value(env,
659             static_cast<int32_t>(WebMessageType::NUMBER))),
660         DECLARE_NAPI_STATIC_PROPERTY("BOOLEAN", NapiParseUtils::ToInt32Value(env,
661             static_cast<int32_t>(WebMessageType::BOOLEAN))),
662         DECLARE_NAPI_STATIC_PROPERTY("ARRAY_BUFFER", NapiParseUtils::ToInt32Value(env,
663             static_cast<int32_t>(WebMessageType::ARRAYBUFFER))),
664         DECLARE_NAPI_STATIC_PROPERTY("ARRAY", NapiParseUtils::ToInt32Value(env,
665             static_cast<int32_t>(WebMessageType::ARRAY))),
666         DECLARE_NAPI_STATIC_PROPERTY("ERROR", NapiParseUtils::ToInt32Value(env,
667             static_cast<int32_t>(WebMessageType::ERROR)))
668     };
669     napi_define_class(env, WEB_PORT_MSG_ENUM_NAME.c_str(), WEB_PORT_MSG_ENUM_NAME.length(),
670         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(webMsgTypeProperties) /
671         sizeof(webMsgTypeProperties[0]), webMsgTypeProperties, &webMsgTypeEnum);
672     napi_set_named_property(env, exports, WEB_PORT_MSG_ENUM_NAME.c_str(), webMsgTypeEnum);
673 
674     napi_value webMsgExtClass = nullptr;
675     napi_property_descriptor webMsgExtClsProperties[] = {
676         DECLARE_NAPI_FUNCTION("getType", NapiWebMessageExt::GetType),
677         DECLARE_NAPI_FUNCTION("getString", NapiWebMessageExt::GetString),
678         DECLARE_NAPI_FUNCTION("getNumber", NapiWebMessageExt::GetNumber),
679         DECLARE_NAPI_FUNCTION("getBoolean", NapiWebMessageExt::GetBoolean),
680         DECLARE_NAPI_FUNCTION("getArrayBuffer", NapiWebMessageExt::GetArrayBuffer),
681         DECLARE_NAPI_FUNCTION("getArray", NapiWebMessageExt::GetArray),
682         DECLARE_NAPI_FUNCTION("getError", NapiWebMessageExt::GetError),
683         DECLARE_NAPI_FUNCTION("setType", NapiWebMessageExt::SetType),
684         DECLARE_NAPI_FUNCTION("setString", NapiWebMessageExt::SetString),
685         DECLARE_NAPI_FUNCTION("setNumber", NapiWebMessageExt::SetNumber),
686         DECLARE_NAPI_FUNCTION("setBoolean", NapiWebMessageExt::SetBoolean),
687         DECLARE_NAPI_FUNCTION("setArrayBuffer", NapiWebMessageExt::SetArrayBuffer),
688         DECLARE_NAPI_FUNCTION("setArray", NapiWebMessageExt::SetArray),
689         DECLARE_NAPI_FUNCTION("setError", NapiWebMessageExt::SetError)
690     };
691     napi_define_class(env, WEB_EXT_MSG_CLASS_NAME.c_str(), WEB_EXT_MSG_CLASS_NAME.length(),
692         NapiWebMessageExt::JsConstructor, nullptr, sizeof(webMsgExtClsProperties) / sizeof(webMsgExtClsProperties[0]),
693         webMsgExtClsProperties, &webMsgExtClass);
694     napi_create_reference(env, webMsgExtClass, 1, &g_webMsgExtClassRef);
695     napi_set_named_property(env, exports, WEB_EXT_MSG_CLASS_NAME.c_str(), webMsgExtClass);
696 
697     napi_value securityLevelEnum = nullptr;
698     napi_property_descriptor securityLevelProperties[] = {
699         DECLARE_NAPI_STATIC_PROPERTY("NONE", NapiParseUtils::ToInt32Value(env,
700             static_cast<int32_t>(SecurityLevel::NONE))),
701         DECLARE_NAPI_STATIC_PROPERTY("SECURE", NapiParseUtils::ToInt32Value(env,
702             static_cast<int32_t>(SecurityLevel::SECURE))),
703         DECLARE_NAPI_STATIC_PROPERTY("WARNING", NapiParseUtils::ToInt32Value(env,
704             static_cast<int32_t>(SecurityLevel::WARNING))),
705         DECLARE_NAPI_STATIC_PROPERTY("DANGEROUS", NapiParseUtils::ToInt32Value(env,
706             static_cast<int32_t>(SecurityLevel::DANGEROUS)))
707     };
708     napi_define_class(env, WEB_SECURITY_LEVEL_ENUM_NAME.c_str(), WEB_SECURITY_LEVEL_ENUM_NAME.length(),
709         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(securityLevelProperties) /
710         sizeof(securityLevelProperties[0]), securityLevelProperties, &securityLevelEnum);
711     napi_set_named_property(env, exports, WEB_SECURITY_LEVEL_ENUM_NAME.c_str(), securityLevelEnum);
712 
713     napi_value msgPortCons = nullptr;
714     napi_property_descriptor msgPortProperties[] = {
715         DECLARE_NAPI_FUNCTION("close", NapiWebMessagePort::Close),
716         DECLARE_NAPI_FUNCTION("postMessageEvent", NapiWebMessagePort::PostMessageEvent),
717         DECLARE_NAPI_FUNCTION("onMessageEvent", NapiWebMessagePort::OnMessageEvent),
718         DECLARE_NAPI_FUNCTION("postMessageEventExt", NapiWebMessagePort::PostMessageEventExt),
719         DECLARE_NAPI_FUNCTION("onMessageEventExt", NapiWebMessagePort::OnMessageEventExt)
720     };
721     NAPI_CALL(env, napi_define_class(env, WEB_MESSAGE_PORT_CLASS_NAME.c_str(), WEB_MESSAGE_PORT_CLASS_NAME.length(),
722         NapiWebMessagePort::JsConstructor, nullptr, sizeof(msgPortProperties) / sizeof(msgPortProperties[0]),
723         msgPortProperties, &msgPortCons));
724     NAPI_CALL(env, napi_create_reference(env, msgPortCons, 1, &g_classWebMsgPort));
725     NAPI_CALL(env, napi_set_named_property(env, exports, WEB_MESSAGE_PORT_CLASS_NAME.c_str(), msgPortCons));
726 
727     napi_value hitTestTypeEnum = nullptr;
728     napi_property_descriptor hitTestTypeProperties[] = {
729         DECLARE_NAPI_STATIC_PROPERTY("EditText", NapiParseUtils::ToInt32Value(env,
730             static_cast<int32_t>(WebHitTestType::EDIT))),
731         DECLARE_NAPI_STATIC_PROPERTY("Email", NapiParseUtils::ToInt32Value(env,
732             static_cast<int32_t>(WebHitTestType::EMAIL))),
733         DECLARE_NAPI_STATIC_PROPERTY("HttpAnchor", NapiParseUtils::ToInt32Value(env,
734             static_cast<int32_t>(WebHitTestType::HTTP))),
735         DECLARE_NAPI_STATIC_PROPERTY("HttpAnchorImg", NapiParseUtils::ToInt32Value(env,
736             static_cast<int32_t>(WebHitTestType::HTTP_IMG))),
737         DECLARE_NAPI_STATIC_PROPERTY("Img", NapiParseUtils::ToInt32Value(env,
738             static_cast<int32_t>(WebHitTestType::IMG))),
739         DECLARE_NAPI_STATIC_PROPERTY("Map", NapiParseUtils::ToInt32Value(env,
740             static_cast<int32_t>(WebHitTestType::MAP))),
741         DECLARE_NAPI_STATIC_PROPERTY("Phone", NapiParseUtils::ToInt32Value(env,
742             static_cast<int32_t>(WebHitTestType::PHONE))),
743         DECLARE_NAPI_STATIC_PROPERTY("Unknown", NapiParseUtils::ToInt32Value(env,
744             static_cast<int32_t>(WebHitTestType::UNKNOWN))),
745     };
746     napi_define_class(env, WEB_HITTESTTYPE_V9_ENUM_NAME.c_str(), WEB_HITTESTTYPE_V9_ENUM_NAME.length(),
747         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(hitTestTypeProperties) /
748         sizeof(hitTestTypeProperties[0]), hitTestTypeProperties, &hitTestTypeEnum);
749     napi_set_named_property(env, exports, WEB_HITTESTTYPE_V9_ENUM_NAME.c_str(), hitTestTypeEnum);
750 
751     napi_define_class(env, WEB_HITTESTTYPE_ENUM_NAME.c_str(), WEB_HITTESTTYPE_ENUM_NAME.length(),
752         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(hitTestTypeProperties) /
753         sizeof(hitTestTypeProperties[0]), hitTestTypeProperties, &hitTestTypeEnum);
754     napi_set_named_property(env, exports, WEB_HITTESTTYPE_ENUM_NAME.c_str(), hitTestTypeEnum);
755 
756     napi_value secureDnsModeEnum = nullptr;
757     napi_property_descriptor secureDnsModeProperties[] = {
758         DECLARE_NAPI_STATIC_PROPERTY("Off", NapiParseUtils::ToInt32Value(env,
759             static_cast<int32_t>(SecureDnsModeType::OFF))),
760         DECLARE_NAPI_STATIC_PROPERTY("Auto", NapiParseUtils::ToInt32Value(env,
761             static_cast<int32_t>(SecureDnsModeType::AUTO))),
762         DECLARE_NAPI_STATIC_PROPERTY("SecureOnly", NapiParseUtils::ToInt32Value(env,
763             static_cast<int32_t>(SecureDnsModeType::SECURE_ONLY))),
764         DECLARE_NAPI_STATIC_PROPERTY("OFF", NapiParseUtils::ToInt32Value(env,
765             static_cast<int32_t>(SecureDnsModeType::OFF))),
766         DECLARE_NAPI_STATIC_PROPERTY("AUTO", NapiParseUtils::ToInt32Value(env,
767             static_cast<int32_t>(SecureDnsModeType::AUTO))),
768         DECLARE_NAPI_STATIC_PROPERTY("SECURE_ONLY", NapiParseUtils::ToInt32Value(env,
769             static_cast<int32_t>(SecureDnsModeType::SECURE_ONLY))),
770     };
771     napi_define_class(env, WEB_SECURE_DNS_MODE_ENUM_NAME.c_str(), WEB_SECURE_DNS_MODE_ENUM_NAME.length(),
772         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(secureDnsModeProperties) /
773         sizeof(secureDnsModeProperties[0]), secureDnsModeProperties, &secureDnsModeEnum);
774     napi_set_named_property(env, exports, WEB_SECURE_DNS_MODE_ENUM_NAME.c_str(), secureDnsModeEnum);
775 
776     napi_value historyList = nullptr;
777     napi_property_descriptor historyListProperties[] = {
778         DECLARE_NAPI_FUNCTION("getItemAtIndex", NapiWebHistoryList::GetItem)
779     };
780     napi_define_class(env, WEB_HISTORY_LIST_CLASS_NAME.c_str(), WEB_HISTORY_LIST_CLASS_NAME.length(),
781         NapiWebHistoryList::JsConstructor, nullptr, sizeof(historyListProperties) / sizeof(historyListProperties[0]),
782         historyListProperties, &historyList);
783     napi_create_reference(env, historyList, 1, &g_historyListRef);
784     napi_set_named_property(env, exports, WEB_HISTORY_LIST_CLASS_NAME.c_str(), historyList);
785 
786     napi_value webPrintDoc = nullptr;
787     napi_property_descriptor WebPrintDocumentClass[] = {
788         DECLARE_NAPI_FUNCTION("onStartLayoutWrite", NapiWebPrintDocument::OnStartLayoutWrite),
789         DECLARE_NAPI_FUNCTION("onJobStateChanged", NapiWebPrintDocument::OnJobStateChanged),
790     };
791     napi_define_class(env, WEB_PRINT_DOCUMENT_CLASS_NAME.c_str(), WEB_PRINT_DOCUMENT_CLASS_NAME.length(),
792         NapiWebPrintDocument::JsConstructor, nullptr,
793         sizeof(WebPrintDocumentClass) / sizeof(WebPrintDocumentClass[0]),
794         WebPrintDocumentClass, &webPrintDoc);
795     napi_create_reference(env, webPrintDoc, 1, &g_webPrintDocClassRef);
796     napi_set_named_property(env, exports, WEB_PRINT_DOCUMENT_CLASS_NAME.c_str(), webPrintDoc);
797 
798     napi_value renderProcessModeEnum = nullptr;
799     napi_property_descriptor renderProcessModeProperties[] = {
800         DECLARE_NAPI_STATIC_PROPERTY("SINGLE", NapiParseUtils::ToInt32Value(env,
801             static_cast<int32_t>(RenderProcessMode::SINGLE_MODE))),
802         DECLARE_NAPI_STATIC_PROPERTY("MULTIPLE", NapiParseUtils::ToInt32Value(env,
803             static_cast<int32_t>(RenderProcessMode::MULTIPLE_MODE))),
804     };
805     napi_define_class(env, WEB_RENDER_PROCESS_MODE_ENUM_NAME.c_str(), WEB_RENDER_PROCESS_MODE_ENUM_NAME.length(),
806         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(renderProcessModeProperties) /
807         sizeof(renderProcessModeProperties[0]), renderProcessModeProperties, &renderProcessModeEnum);
808     napi_set_named_property(env, exports, WEB_RENDER_PROCESS_MODE_ENUM_NAME.c_str(), renderProcessModeEnum);
809 
810     napi_value offlineResourceTypeEnum = nullptr;
811     napi_property_descriptor offlineResourceTypeProperties[] = {
812         DECLARE_NAPI_STATIC_PROPERTY("IMAGE", NapiParseUtils::ToInt32Value(env,
813             static_cast<int32_t>(OfflineResourceType::IMAGE))),
814         DECLARE_NAPI_STATIC_PROPERTY("CSS", NapiParseUtils::ToInt32Value(env,
815             static_cast<int32_t>(OfflineResourceType::CSS))),
816         DECLARE_NAPI_STATIC_PROPERTY("CLASSIC_JS", NapiParseUtils::ToInt32Value(env,
817             static_cast<int32_t>(OfflineResourceType::CLASSIC_JS))),
818         DECLARE_NAPI_STATIC_PROPERTY("MODULE_JS", NapiParseUtils::ToInt32Value(env,
819             static_cast<int32_t>(OfflineResourceType::MODULE_JS))),
820     };
821     napi_define_class(env, OFFLINE_RESOURCE_TYPE_ENUM_NAME.c_str(), OFFLINE_RESOURCE_TYPE_ENUM_NAME.length(),
822         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(offlineResourceTypeProperties) /
823         sizeof(offlineResourceTypeProperties[0]), offlineResourceTypeProperties, &offlineResourceTypeEnum);
824     napi_set_named_property(env, exports, OFFLINE_RESOURCE_TYPE_ENUM_NAME.c_str(), offlineResourceTypeEnum);
825 
826     napi_value scrollTypeEnum = nullptr;
827     napi_property_descriptor scrollTypeProperties[] = {
828         DECLARE_NAPI_STATIC_PROPERTY("EVENT", NapiParseUtils::ToInt32Value(env,
829             static_cast<int32_t>(ScrollType::EVENT))),
830     };
831     napi_define_class(env, WEB_SCROLL_TYPE_ENUM_NAME.c_str(), WEB_SCROLL_TYPE_ENUM_NAME.length(),
832         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(scrollTypeProperties) /
833         sizeof(scrollTypeProperties[0]), scrollTypeProperties, &scrollTypeEnum);
834     napi_set_named_property(env, exports, WEB_SCROLL_TYPE_ENUM_NAME.c_str(), scrollTypeEnum);
835 
836     napi_value pressureLevelEnum = nullptr;
837     napi_property_descriptor pressureLevelProperties[] = {
838         DECLARE_NAPI_STATIC_PROPERTY("MEMORY_PRESSURE_LEVEL_MODERATE", NapiParseUtils::ToInt32Value(env,
839             static_cast<int32_t>(PressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE))),
840         DECLARE_NAPI_STATIC_PROPERTY("MEMORY_PRESSURE_LEVEL_CRITICAL", NapiParseUtils::ToInt32Value(env,
841             static_cast<int32_t>(PressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL))),
842     };
843     napi_define_class(env, WEB_PRESSURE_LEVEL_ENUM_NAME.c_str(), WEB_PRESSURE_LEVEL_ENUM_NAME.length(),
844         NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(pressureLevelProperties) /
845         sizeof(pressureLevelProperties[0]), pressureLevelProperties, &pressureLevelEnum);
846     napi_set_named_property(env, exports, WEB_PRESSURE_LEVEL_ENUM_NAME.c_str(), pressureLevelEnum);
847 
848     WebviewJavaScriptExecuteCallback::InitJSExcute(env, exports);
849     WebviewCreatePDFExecuteCallback::InitJSExcute(env, exports);
850     return exports;
851 }
852 
JsConstructor(napi_env env,napi_callback_info info)853 napi_value NapiWebviewController::JsConstructor(napi_env env, napi_callback_info info)
854 {
855     WVLOG_I("NapiWebviewController::JsConstructor start");
856     napi_value thisVar = nullptr;
857 
858     size_t argc = INTEGER_ONE;
859     napi_value argv[INTEGER_ONE] = { 0 };
860     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
861 
862     WebviewController *webviewController;
863     std::string webTag;
864     if (argc == 1) {
865         NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], webTag);
866         if (webTag.empty()) {
867             WVLOG_E("native webTag is empty");
868             return nullptr;
869         }
870         webviewController = new (std::nothrow) WebviewController(webTag);
871         WVLOG_I("new webview controller webname:%{public}s", webTag.c_str());
872     } else {
873         webTag = WebviewController::GenerateWebTag();
874         webviewController = new (std::nothrow) WebviewController(webTag);
875     }
876     WebviewController::webTagSet_.insert(webTag);
877 
878     if (webviewController == nullptr) {
879         WVLOG_E("new webview controller failed");
880         return nullptr;
881     }
882     napi_status status = napi_wrap(
883         env, thisVar, webviewController,
884         [](napi_env env, void *data, void *hint) {
885             WebviewController *webviewController = static_cast<WebviewController *>(data);
886             delete webviewController;
887         },
888         nullptr, nullptr);
889     if (status != napi_ok) {
890         WVLOG_E("Wrap native webviewController failed.");
891         delete webviewController;
892         webviewController = nullptr;
893         return nullptr;
894     }
895     return thisVar;
896 }
897 
InitializeWebEngine(napi_env env,napi_callback_info info)898 napi_value NapiWebviewController::InitializeWebEngine(napi_env env, napi_callback_info info)
899 {
900     WVLOG_D("InitializeWebEngine invoked.");
901 
902     // obtain bundle path
903     std::shared_ptr<AbilityRuntime::ApplicationContext> ctx =
904         AbilityRuntime::ApplicationContext::GetApplicationContext();
905     if (!ctx) {
906         WVLOG_E("Failed to init web engine due to nil application context.");
907         return nullptr;
908     }
909 
910     // load so
911     const std::string& bundlePath = ctx->GetBundleCodeDir();
912     NWebHelper::Instance().SetBundlePath(bundlePath);
913     if (!NWebHelper::Instance().InitAndRun(true)) {
914         WVLOG_E("Failed to init web engine due to NWebHelper failure.");
915         return nullptr;
916     }
917 
918     napi_value result = nullptr;
919     NAPI_CALL(env, napi_get_undefined(env, &result));
920     WVLOG_I("NWebHelper initialized, init web engine done, bundle_path: %{public}s", bundlePath.c_str());
921     return result;
922 }
923 
SetHttpDns(napi_env env,napi_callback_info info)924 napi_value NapiWebviewController::SetHttpDns(napi_env env, napi_callback_info info)
925 {
926     napi_value thisVar = nullptr;
927     napi_value result = nullptr;
928     size_t argc = INTEGER_TWO;
929     napi_value argv[INTEGER_TWO] = { 0 };
930     int dohMode;
931     std::string dohConfig;
932 
933     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
934     if (argc != INTEGER_TWO) {
935         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
936             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "two"));
937         return result;
938     }
939 
940     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], dohMode)) {
941         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
942             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "secureDnsMode", "SecureDnsMode"));
943         return result;
944     }
945 
946     if (dohMode < static_cast<int>(SecureDnsModeType::OFF) ||
947         dohMode > static_cast<int>(SecureDnsModeType::SECURE_ONLY)) {
948         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
949             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "secureDnsMode"));
950         return result;
951     }
952 
953     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], dohConfig)) {
954         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
955             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "secureDnsConfig", "string"));
956         return result;
957     }
958 
959     if (dohConfig.rfind("https", 0) != 0 && dohConfig.rfind("HTTPS", 0) != 0) {
960         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
961             "BusinessError 401: Parameter error. Parameter secureDnsConfig must start with 'http' or 'https'.");
962         return result;
963     }
964 
965     std::shared_ptr<NWebDOHConfigImpl> config = std::make_shared<NWebDOHConfigImpl>();
966     config->SetMode(dohMode);
967     config->SetConfig(dohConfig);
968     WVLOG_I("set http dns mode:%{public}d doh_config:%{public}s", dohMode, dohConfig.c_str());
969 
970     NWebHelper::Instance().SetHttpDns(config);
971 
972     NAPI_CALL(env, napi_get_undefined(env, &result));
973     return result;
974 }
975 
SetWebDebuggingAccess(napi_env env,napi_callback_info info)976 napi_value NapiWebviewController::SetWebDebuggingAccess(napi_env env, napi_callback_info info)
977 {
978     WVLOG_D("SetWebDebuggingAccess start");
979     napi_value result = nullptr;
980     if (OHOS::system::GetBoolParameter("web.debug.devtools", false)) {
981         return result;
982     }
983     napi_value thisVar = nullptr;
984     size_t argc = INTEGER_ONE;
985     napi_value argv[INTEGER_ONE] = {0};
986 
987     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
988     if (argc != INTEGER_ONE) {
989         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
990             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
991         return result;
992     }
993 
994     bool webDebuggingAccess = false;
995     if (!NapiParseUtils::ParseBoolean(env, argv[0], webDebuggingAccess)) {
996         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
997             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "webDebuggingAccess", "boolean"));
998         return result;
999     }
1000     WebviewController::webDebuggingAccess_ = webDebuggingAccess;
1001 
1002     NAPI_CALL(env, napi_get_undefined(env, &result));
1003     return result;
1004 }
1005 
EnableSafeBrowsing(napi_env env,napi_callback_info info)1006 napi_value NapiWebviewController::EnableSafeBrowsing(napi_env env, napi_callback_info info)
1007 {
1008     WVLOG_D("EnableSafeBrowsing start");
1009     napi_value result = nullptr;
1010     napi_value thisVar = nullptr;
1011     size_t argc = INTEGER_ONE;
1012     napi_value argv[INTEGER_ONE] = {0};
1013 
1014     NAPI_CALL(env, napi_get_undefined(env, &result));
1015     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1016     if (argc != INTEGER_ONE) {
1017         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1018             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1019         return result;
1020     }
1021 
1022     bool safeBrowsingEnable = false;
1023     if (!NapiParseUtils::ParseBoolean(env, argv[0], safeBrowsingEnable)) {
1024         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1025             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "enable", "boolean"));
1026         return result;
1027     }
1028 
1029     WebviewController *controller = nullptr;
1030     napi_unwrap(env, thisVar, (void **)&controller);
1031     if (!controller || !controller->IsInit()) {
1032         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
1033         return result;
1034     }
1035     controller->EnableSafeBrowsing(safeBrowsingEnable);
1036     return result;
1037 }
1038 
IsSafeBrowsingEnabled(napi_env env,napi_callback_info info)1039 napi_value NapiWebviewController::IsSafeBrowsingEnabled(napi_env env, napi_callback_info info)
1040 {
1041     WVLOG_D("IsSafeBrowsingEnabled start");
1042     napi_value result = nullptr;
1043     WebviewController *webviewController = GetWebviewController(env, info);
1044     if (!webviewController) {
1045         return nullptr;
1046     }
1047 
1048     bool isSafeBrowsingEnabled = webviewController->IsSafeBrowsingEnabled();
1049     NAPI_CALL(env, napi_get_boolean(env, isSafeBrowsingEnabled, &result));
1050     return result;
1051 }
1052 
InnerGetWebDebuggingAccess(napi_env env,napi_callback_info info)1053 napi_value NapiWebviewController::InnerGetWebDebuggingAccess(napi_env env, napi_callback_info info)
1054 {
1055     WVLOG_D("InnerGetWebDebuggingAccess start");
1056     bool webDebuggingAccess = WebviewController::webDebuggingAccess_;
1057     napi_value result = nullptr;
1058     napi_get_boolean(env, webDebuggingAccess, &result);
1059     return result;
1060 }
1061 
InnerGetThisVar(napi_env env,napi_callback_info info)1062 napi_value NapiWebviewController::InnerGetThisVar(napi_env env, napi_callback_info info)
1063 {
1064     WVLOG_D("InnerGetThisVar start");
1065     napi_value thisVar = nullptr;
1066     napi_value result = nullptr;
1067     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1068     WebviewController *webviewController = nullptr;
1069     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
1070     if ((!webviewController) || (status != napi_ok)) {
1071         WVLOG_E("webviewController is nullptr.");
1072         napi_create_int64(env, 0, &result);
1073     } else {
1074         napi_create_int64(env, reinterpret_cast<int64_t>(webviewController), &result);
1075     }
1076     return result;
1077 }
1078 
SetWebId(napi_env env,napi_callback_info info)1079 napi_value NapiWebviewController::SetWebId(napi_env env, napi_callback_info info)
1080 {
1081     napi_value thisVar = nullptr;
1082     size_t argc = INTEGER_ONE;
1083     napi_value argv[INTEGER_ONE];
1084     void* data = nullptr;
1085     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1086 
1087     int32_t webId = -1;
1088     if (!NapiParseUtils::ParseInt32(env, argv[0], webId)) {
1089         WVLOG_E("Parse web id failed.");
1090         return nullptr;
1091     }
1092     WebviewController *webviewController = nullptr;
1093     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
1094     if ((!webviewController) || (status != napi_ok)) {
1095         WVLOG_E("webviewController is nullptr.");
1096         return nullptr;
1097     }
1098     webviewController->SetWebId(webId);
1099     return thisVar;
1100 }
1101 
InnerSetHapPath(napi_env env,napi_callback_info info)1102 napi_value NapiWebviewController::InnerSetHapPath(napi_env env, napi_callback_info info)
1103 {
1104     napi_value result = nullptr;
1105     NAPI_CALL(env, napi_get_undefined(env, &result));
1106     napi_value thisVar = nullptr;
1107     size_t argc = INTEGER_ONE;
1108     napi_value argv[INTEGER_ONE];
1109     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1110     if (argc != INTEGER_ONE) {
1111         WVLOG_E("Failed to run InnerSetHapPath beacuse of wrong Param number.");
1112         return result;
1113     }
1114     std::string hapPath;
1115     if (!NapiParseUtils::ParseString(env, argv[0], hapPath)) {
1116         WVLOG_E("Parse hap path failed.");
1117         return result;
1118     }
1119     WebviewController *webviewController = nullptr;
1120     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
1121     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
1122         WVLOG_E("Wrap webviewController failed. WebviewController must be associated with a Web component.");
1123         return result;
1124     }
1125     webviewController->InnerSetHapPath(hapPath);
1126     return result;
1127 }
1128 
InnerJsProxy(napi_env env,napi_callback_info info)1129 napi_value NapiWebviewController::InnerJsProxy(napi_env env, napi_callback_info info)
1130 {
1131     napi_value thisVar = nullptr;
1132     napi_value result = nullptr;
1133     size_t argc = INTEGER_FIVE;
1134     napi_value argv[INTEGER_FIVE] = { 0 };
1135     napi_get_undefined(env, &result);
1136     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1137     if (argc != INTEGER_FIVE) {
1138         WVLOG_E("Failed to run InnerJsProxy beacuse of wrong Param number.");
1139         return result;
1140     }
1141     napi_valuetype valueType = napi_undefined;
1142     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
1143     if (valueType != napi_object) {
1144         WVLOG_E("Failed to run InnerJsProxy beacuse of wrong Param type.");
1145         return result;
1146     }
1147     std::string objName;
1148     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], objName)) {
1149         WVLOG_E("Failed to run InnerJsProxy beacuse of wrong object name.");
1150         return result;
1151     }
1152     std::vector<std::string> methodList;
1153     bool hasSyncMethod = NapiParseUtils::ParseStringArray(env, argv[INTEGER_TWO], methodList);
1154     std::vector<std::string> asyncMethodList;
1155     bool hasAsyncMethod = NapiParseUtils::ParseStringArray(env, argv[INTEGER_THREE], asyncMethodList);
1156     if (!hasSyncMethod && !hasAsyncMethod) {
1157         WVLOG_E("Failed to run InnerJsProxy beacuse of empty method lists.");
1158         return result;
1159     }
1160     std::string permission = "";
1161     NapiParseUtils::ParseString(env, argv[INTEGER_FOUR], permission);
1162     WebviewController* controller = nullptr;
1163     napi_unwrap(env, thisVar, (void **)&controller);
1164     if (!controller || !controller->IsInit()) {
1165         WVLOG_E("Failed to run InnerJsProxy. The WebviewController must be associted with a Web component.");
1166         return result;
1167     }
1168     controller->SetNWebJavaScriptResultCallBack();
1169     RegisterJavaScriptProxyParam param;
1170     param.env = env;
1171     param.obj = argv[INTEGER_ZERO];
1172     param.objName = objName;
1173     param.syncMethodList = methodList;
1174     param.asyncMethodList = asyncMethodList;
1175     param.permission = permission;
1176     controller->RegisterJavaScriptProxy(param);
1177     return result;
1178 }
1179 
InnerGetCustomeSchemeCmdLine(napi_env env,napi_callback_info info)1180 napi_value NapiWebviewController::InnerGetCustomeSchemeCmdLine(napi_env env, napi_callback_info info)
1181 {
1182     WebviewController::existNweb_ = true;
1183     napi_value result = nullptr;
1184     const std::string& cmdLine = WebviewController::customeSchemeCmdLine_;
1185     napi_create_string_utf8(env, cmdLine.c_str(), cmdLine.length(), &result);
1186     return result;
1187 }
1188 
AccessForward(napi_env env,napi_callback_info info)1189 napi_value NapiWebviewController::AccessForward(napi_env env, napi_callback_info info)
1190 {
1191     napi_value result = nullptr;
1192     WebviewController *webviewController = GetWebviewController(env, info);
1193     if (!webviewController) {
1194         return nullptr;
1195     }
1196 
1197     bool access = webviewController->AccessForward();
1198     NAPI_CALL(env, napi_get_boolean(env, access, &result));
1199     return result;
1200 }
1201 
AccessBackward(napi_env env,napi_callback_info info)1202 napi_value NapiWebviewController::AccessBackward(napi_env env, napi_callback_info info)
1203 {
1204     napi_value result = nullptr;
1205     WebviewController *webviewController = GetWebviewController(env, info);
1206     if (!webviewController) {
1207         return nullptr;
1208     }
1209 
1210     bool access = webviewController->AccessBackward();
1211     NAPI_CALL(env, napi_get_boolean(env, access, &result));
1212     return result;
1213 }
1214 
Forward(napi_env env,napi_callback_info info)1215 napi_value NapiWebviewController::Forward(napi_env env, napi_callback_info info)
1216 {
1217     napi_value result = nullptr;
1218     WebviewController *webviewController = GetWebviewController(env, info);
1219     if (!webviewController) {
1220         return nullptr;
1221     }
1222 
1223     webviewController->Forward();
1224     NAPI_CALL(env, napi_get_undefined(env, &result));
1225     return result;
1226 }
1227 
Backward(napi_env env,napi_callback_info info)1228 napi_value NapiWebviewController::Backward(napi_env env, napi_callback_info info)
1229 {
1230     napi_value result = nullptr;
1231     WebviewController *webviewController = GetWebviewController(env, info);
1232     if (!webviewController) {
1233         return nullptr;
1234     }
1235 
1236     webviewController->Backward();
1237     NAPI_CALL(env, napi_get_undefined(env, &result));
1238     return result;
1239 }
1240 
AccessStep(napi_env env,napi_callback_info info)1241 napi_value NapiWebviewController::AccessStep(napi_env env, napi_callback_info info)
1242 {
1243     napi_value thisVar = nullptr;
1244     napi_value result = nullptr;
1245     size_t argc = INTEGER_ONE;
1246     napi_value argv[INTEGER_ONE];
1247     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1248     if (argc != INTEGER_ONE) {
1249         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1250             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1251         return nullptr;
1252     }
1253 
1254     int32_t step = INTEGER_ZERO;
1255     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], step)) {
1256         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1257             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "step", "number"));
1258         return nullptr;
1259     }
1260 
1261     WebviewController *webviewController = nullptr;
1262     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
1263     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
1264         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
1265         return nullptr;
1266     }
1267 
1268     bool access = webviewController->AccessStep(step);
1269     NAPI_CALL(env, napi_get_boolean(env, access, &result));
1270     return result;
1271 }
1272 
ClearHistory(napi_env env,napi_callback_info info)1273 napi_value NapiWebviewController::ClearHistory(napi_env env, napi_callback_info info)
1274 {
1275     napi_value result = nullptr;
1276     WebviewController *webviewController = GetWebviewController(env, info);
1277     if (!webviewController) {
1278         return nullptr;
1279     }
1280 
1281     webviewController->ClearHistory();
1282     NAPI_CALL(env, napi_get_undefined(env, &result));
1283     return result;
1284 }
1285 
OnActive(napi_env env,napi_callback_info info)1286 napi_value NapiWebviewController::OnActive(napi_env env, napi_callback_info info)
1287 {
1288     napi_value result = nullptr;
1289     WebviewController *webviewController = GetWebviewController(env, info);
1290     if (!webviewController) {
1291         WVLOG_E("NapiWebviewController::OnActive get controller failed");
1292         return nullptr;
1293     }
1294 
1295     webviewController->OnActive();
1296     WVLOG_I("The web component has been successfully activated");
1297     NAPI_CALL(env, napi_get_undefined(env, &result));
1298     return result;
1299 }
1300 
OnInactive(napi_env env,napi_callback_info info)1301 napi_value NapiWebviewController::OnInactive(napi_env env, napi_callback_info info)
1302 {
1303     napi_value result = nullptr;
1304     WebviewController *webviewController = GetWebviewController(env, info);
1305     if (!webviewController) {
1306         WVLOG_E("NapiWebviewController::OnInactive get controller failed");
1307         return nullptr;
1308     }
1309 
1310     webviewController->OnInactive();
1311     WVLOG_I("The web component has been successfully inactivated");
1312     NAPI_CALL(env, napi_get_undefined(env, &result));
1313     return result;
1314 }
1315 
Refresh(napi_env env,napi_callback_info info)1316 napi_value NapiWebviewController::Refresh(napi_env env, napi_callback_info info)
1317 {
1318     napi_value result = nullptr;
1319     WebviewController *webviewController = GetWebviewController(env, info);
1320     if (!webviewController) {
1321         return nullptr;
1322     }
1323 
1324     webviewController->Refresh();
1325     NAPI_CALL(env, napi_get_undefined(env, &result));
1326     return result;
1327 }
1328 
1329 
JsConstructor(napi_env env,napi_callback_info info)1330 napi_value NapiWebMessageExt::JsConstructor(napi_env env, napi_callback_info info)
1331 {
1332     WVLOG_D("NapiWebMessageExt::JsConstructor");
1333     napi_value thisVar = nullptr;
1334     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1335 
1336     auto webMsg = std::make_shared<OHOS::NWeb::NWebMessage>(NWebValue::Type::NONE);
1337     WebMessageExt *webMessageExt = new (std::nothrow) WebMessageExt(webMsg);
1338     if (webMessageExt == nullptr) {
1339         WVLOG_E("new msg port failed");
1340         return nullptr;
1341     }
1342     NAPI_CALL(env, napi_wrap(env, thisVar, webMessageExt,
1343         [](napi_env env, void *data, void *hint) {
1344             WebMessageExt *webMessageExt = static_cast<WebMessageExt *>(data);
1345             if (webMessageExt) {
1346                 delete webMessageExt;
1347             }
1348         },
1349         nullptr, nullptr));
1350     return thisVar;
1351 }
1352 
GetType(napi_env env,napi_callback_info info)1353 napi_value NapiWebMessageExt::GetType(napi_env env, napi_callback_info info)
1354 {
1355     WVLOG_D("NapiWebMessageExt::GetType start");
1356     napi_value thisVar = nullptr;
1357     napi_value result = nullptr;
1358     napi_status status = napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1359     if (status != napi_status::napi_ok) {
1360         WVLOG_E("napi_get_cb_info status not ok");
1361         return result;
1362     }
1363 
1364     if (thisVar == nullptr) {
1365         WVLOG_E("napi_get_cb_info thisVar is nullptr");
1366         return result;
1367     }
1368 
1369     WebMessageExt *webMessageExt = nullptr;
1370     status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1371     if ((!webMessageExt) || (status != napi_ok)) {
1372         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
1373         return nullptr;
1374     }
1375 
1376     int32_t type = webMessageExt->GetType();
1377     status = napi_create_int32(env, type, &result);
1378     if (status != napi_status::napi_ok) {
1379         WVLOG_E("napi_create_int32 failed.");
1380         return result;
1381     }
1382     return result;
1383 }
1384 
GetString(napi_env env,napi_callback_info info)1385 napi_value NapiWebMessageExt::GetString(napi_env env, napi_callback_info info)
1386 {
1387     WVLOG_D(" GetString webJsMessageExt start");
1388     napi_value thisVar = nullptr;
1389     napi_value result = nullptr;
1390     size_t argc = INTEGER_ONE;
1391     napi_value argv[INTEGER_ONE] = { 0 };
1392 
1393     WebMessageExt *webJsMessageExt = nullptr;
1394     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1395     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1396     if (webJsMessageExt == nullptr) {
1397         WVLOG_E("unwrap webJsMessageExt failed.");
1398         return result;
1399     }
1400 
1401     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::STRING)) {
1402         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1403         return nullptr;
1404     }
1405 
1406     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1407     return result;
1408 }
1409 
GetNumber(napi_env env,napi_callback_info info)1410 napi_value NapiWebMessageExt::GetNumber(napi_env env, napi_callback_info info)
1411 {
1412     WVLOG_D("GetNumber webJsMessageExt start");
1413     napi_value thisVar = nullptr;
1414     napi_value result = nullptr;
1415     size_t argc = INTEGER_ONE;
1416     napi_value argv[INTEGER_ONE] = { 0 };
1417 
1418     WebMessageExt *webJsMessageExt = nullptr;
1419     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1420     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1421     if (webJsMessageExt == nullptr) {
1422         WVLOG_E("unwrap webJsMessageExt failed.");
1423         return result;
1424     }
1425 
1426     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::NUMBER)) {
1427         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1428         WVLOG_E("GetNumber webJsMessageExt failed,not match");
1429         return nullptr;
1430     }
1431 
1432     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1433     return result;
1434 }
1435 
GetBoolean(napi_env env,napi_callback_info info)1436 napi_value NapiWebMessageExt::GetBoolean(napi_env env, napi_callback_info info)
1437 {
1438     napi_value thisVar = nullptr;
1439     napi_value result = nullptr;
1440     size_t argc = INTEGER_ONE;
1441     napi_value argv[INTEGER_ONE] = { 0 };
1442 
1443     WebMessageExt *webJsMessageExt = nullptr;
1444     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1445     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1446     if (webJsMessageExt == nullptr) {
1447         WVLOG_E("unwrap webJsMessageExt failed.");
1448         return result;
1449     }
1450 
1451     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::BOOLEAN)) {
1452         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1453         return nullptr;
1454     }
1455 
1456     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1457     return result;
1458 }
1459 
GetArrayBuffer(napi_env env,napi_callback_info info)1460 napi_value NapiWebMessageExt::GetArrayBuffer(napi_env env, napi_callback_info info)
1461 {
1462     napi_value thisVar = nullptr;
1463     napi_value result = nullptr;
1464     size_t argc = INTEGER_ONE;
1465     napi_value argv[INTEGER_ONE] = { 0 };
1466 
1467     WebMessageExt *webJsMessageExt = nullptr;
1468     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1469     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1470     if (webJsMessageExt == nullptr) {
1471         WVLOG_E("unwrap webJsMessageExt failed.");
1472         return result;
1473     }
1474 
1475     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::ARRAYBUFFER)) {
1476         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1477         return nullptr;
1478     }
1479     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1480     return result;
1481 }
1482 
GetArray(napi_env env,napi_callback_info info)1483 napi_value NapiWebMessageExt::GetArray(napi_env env, napi_callback_info info)
1484 {
1485     napi_value thisVar = nullptr;
1486     napi_value result = nullptr;
1487     size_t argc = INTEGER_ONE;
1488     napi_value argv[INTEGER_ONE] = { 0 };
1489 
1490     WebMessageExt *webJsMessageExt = nullptr;
1491     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1492     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1493     if (webJsMessageExt == nullptr) {
1494         WVLOG_E("unwrap webJsMessageExt failed.");
1495         return result;
1496     }
1497 
1498     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::ARRAY)) {
1499         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1500         return nullptr;
1501     }
1502 
1503     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1504     return result;
1505 }
1506 
GetError(napi_env env,napi_callback_info info)1507 napi_value NapiWebMessageExt::GetError(napi_env env, napi_callback_info info)
1508 {
1509     napi_value thisVar = nullptr;
1510     napi_value result = nullptr;
1511     size_t argc = INTEGER_ONE;
1512     napi_value argv[INTEGER_ONE] = { 0 };
1513 
1514     WebMessageExt *webJsMessageExt = nullptr;
1515     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1516     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webJsMessageExt));
1517     if (webJsMessageExt == nullptr) {
1518         WVLOG_E("unwrap webJsMessageExt failed.");
1519         return result;
1520     }
1521 
1522     if (webJsMessageExt->GetType() != static_cast<int32_t>(WebMessageType::ERROR)) {
1523         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1524         return nullptr;
1525     }
1526 
1527     NapiParseUtils::ConvertNWebToNapiValue(env, webJsMessageExt->GetData(), result);
1528     return result;
1529 }
1530 
SetType(napi_env env,napi_callback_info info)1531 napi_value NapiWebMessageExt::SetType(napi_env env, napi_callback_info info)
1532 {
1533     WVLOG_D("NapiWebMessageExt::SetType");
1534     napi_value thisVar = nullptr;
1535     napi_value result = nullptr;
1536     size_t argc = INTEGER_ONE;
1537     napi_value argv[INTEGER_ONE] = { 0 };
1538     int type = -1;
1539     napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1540     if (status != napi_ok) {
1541         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1542             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "type"));
1543         WVLOG_E("NapiWebMessageExt::SetType napi_get_cb_info failed");
1544         return result;
1545     }
1546     if (thisVar == nullptr) {
1547         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1548             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NOT_NULL, "type"));
1549         WVLOG_E("NapiWebMessageExt::SetType thisVar is null");
1550         return result;
1551     }
1552     if (argc != INTEGER_ONE) {
1553         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1554             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1555         return result;
1556     }
1557     if (!NapiParseUtils::ParseInt32(env, argv[0], type)) {
1558         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR, ParamCheckErrorMsgTemplate::TYPE_ALL_INT);
1559         return result;
1560     }
1561     if (type <= static_cast<int>(WebMessageType::NOTSUPPORT) || type > static_cast<int>(WebMessageType::ERROR)) {
1562         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1563         return result;
1564     }
1565     WebMessageExt *webMessageExt = nullptr;
1566     status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1567     if (status != napi_ok) {
1568         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1569             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "type"));
1570         WVLOG_E("NapiWebMessageExt::SetType napi_unwrap failed");
1571         return result;
1572     }
1573     if (!webMessageExt) {
1574         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1575             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NOT_NULL, "type"));
1576         WVLOG_E("NapiWebMessageExt::SetType webMessageExt is null");
1577         return result;
1578     }
1579     webMessageExt->SetType(type);
1580     return result;
1581 }
1582 
SetString(napi_env env,napi_callback_info info)1583 napi_value NapiWebMessageExt::SetString(napi_env env, napi_callback_info info)
1584 {
1585     WVLOG_D("NapiWebMessageExt::SetString start");
1586     napi_value thisVar = nullptr;
1587     napi_value result = nullptr;
1588     size_t argc = INTEGER_ONE;
1589     napi_value argv[INTEGER_ONE] = { 0 };
1590     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1591     if (argc != INTEGER_ONE) {
1592         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1593             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1594         return result;
1595     }
1596 
1597     std::string value;
1598     if (!NapiParseUtils::ParseString(env, argv[0], value)) {
1599         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1600             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "string"));
1601         return result;
1602     }
1603     WebMessageExt *webMessageExt = nullptr;
1604     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1605     if ((!webMessageExt) || (status != napi_ok)) {
1606         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1607             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1608         return result;
1609     }
1610 
1611     int32_t type = webMessageExt->GetType();
1612     if (type != static_cast<int32_t>(WebMessageType::STRING)) {
1613         WVLOG_E("web message SetString error type:%{public}d", type);
1614         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1615         return result;
1616     }
1617     webMessageExt->SetString(value);
1618     return result;
1619 }
1620 
SetNumber(napi_env env,napi_callback_info info)1621 napi_value NapiWebMessageExt::SetNumber(napi_env env, napi_callback_info info)
1622 {
1623     WVLOG_D("NapiWebMessageExt::SetNumber start");
1624     napi_value thisVar = nullptr;
1625     napi_value result = nullptr;
1626     size_t argc = INTEGER_ONE;
1627     napi_value argv[INTEGER_ONE] = { 0 };
1628     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1629     if (argc != INTEGER_ONE) {
1630         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1631             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1632         return result;
1633     }
1634 
1635     double value = 0;
1636     if (!NapiParseUtils::ParseDouble(env, argv[0], value)) {
1637         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1638             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "number"));
1639         return result;
1640     }
1641 
1642     WebMessageExt *webMessageExt = nullptr;
1643     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1644     if ((!webMessageExt) || (status != napi_ok)) {
1645         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1646             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1647         return result;
1648     }
1649 
1650     int32_t type = webMessageExt->GetType();
1651     if (type != static_cast<int32_t>(WebMessageType::NUMBER)) {
1652         WVLOG_E("web message SetNumber error type:%{public}d", type);
1653         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1654         return result;
1655     }
1656     webMessageExt->SetNumber(value);
1657     return result;
1658 }
1659 
SetBoolean(napi_env env,napi_callback_info info)1660 napi_value NapiWebMessageExt::SetBoolean(napi_env env, napi_callback_info info)
1661 {
1662     WVLOG_D("NapiWebMessageExt::SetBoolean start");
1663     napi_value thisVar = nullptr;
1664     napi_value result = nullptr;
1665     size_t argc = INTEGER_ONE;
1666     napi_value argv[INTEGER_ONE] = { 0 };
1667     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1668     if (argc != INTEGER_ONE) {
1669         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1670             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1671         return result;
1672     }
1673 
1674     bool value = 0;
1675     if (!NapiParseUtils::ParseBoolean(env, argv[0], value)) {
1676         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1677             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "boolean"));
1678         return result;
1679     }
1680 
1681     WebMessageExt *webMessageExt = nullptr;
1682     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1683     if ((!webMessageExt) || (status != napi_ok)) {
1684         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1685             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1686         return result;
1687     }
1688 
1689     int32_t type = webMessageExt->GetType();
1690     if (type != static_cast<int32_t>(WebMessageType::BOOLEAN)) {
1691         WVLOG_E("web message SetBoolean error type:%{public}d", type);
1692         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1693         return result;
1694     }
1695     webMessageExt->SetBoolean(value);
1696     return result;
1697 }
1698 
SetArrayBuffer(napi_env env,napi_callback_info info)1699 napi_value NapiWebMessageExt::SetArrayBuffer(napi_env env, napi_callback_info info)
1700 {
1701     WVLOG_D("NapiWebMessageExt::SetArrayBuffer start");
1702     napi_value thisVar = nullptr;
1703     napi_value result = nullptr;
1704     size_t argc = INTEGER_ONE;
1705     napi_value argv[INTEGER_ONE] = { 0 };
1706     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1707     if (argc != INTEGER_ONE) {
1708         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1709             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1710         return result;
1711     }
1712 
1713     bool isArrayBuffer = false;
1714     NAPI_CALL(env, napi_is_arraybuffer(env, argv[INTEGER_ZERO], &isArrayBuffer));
1715     if (!isArrayBuffer) {
1716         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1717             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "arrayBuffer"));
1718         return result;
1719     }
1720 
1721     uint8_t *arrBuf = nullptr;
1722     size_t byteLength = 0;
1723     napi_get_arraybuffer_info(env, argv[INTEGER_ZERO], (void**)&arrBuf, &byteLength);
1724     std::vector<uint8_t> vecData(arrBuf, arrBuf + byteLength);
1725     WebMessageExt *webMessageExt = nullptr;
1726     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1727     if ((!webMessageExt) || (status != napi_ok)) {
1728         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1729             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1730         return result;
1731     }
1732 
1733     int32_t type = webMessageExt->GetType();
1734     if (type != static_cast<int32_t>(WebMessageType::ARRAYBUFFER)) {
1735         WVLOG_E("web message SetArrayBuffer error type:%{public}d", type);
1736         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1737         return result;
1738     }
1739     webMessageExt->SetArrayBuffer(vecData);
1740     return result;
1741 }
1742 
SetArray(napi_env env,napi_callback_info info)1743 napi_value NapiWebMessageExt::SetArray(napi_env env, napi_callback_info info)
1744 {
1745     WVLOG_D("NapiWebMessageExt::SetArray start");
1746     napi_value thisVar = nullptr;
1747     napi_value result = nullptr;
1748     size_t argc = INTEGER_ONE;
1749     napi_value argv[INTEGER_ONE] = { 0 };
1750     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1751     if (argc != INTEGER_ONE) {
1752         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1753             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1754         return result;
1755     }
1756     bool isArray = false;
1757     NAPI_CALL(env, napi_is_array(env, argv[INTEGER_ZERO], &isArray));
1758     if (!isArray) {
1759         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1760             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "array"));
1761         return result;
1762     }
1763     WebMessageExt *webMessageExt = nullptr;
1764     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1765     if ((!webMessageExt) || (status != napi_ok)) {
1766         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1767             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1768         return result;
1769     }
1770     int32_t type = webMessageExt->GetType();
1771     if (type != static_cast<int32_t>(WebMessageType::ARRAY)) {
1772         WVLOG_E("web message SetArray error type:%{public}d", type);
1773         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1774         return result;
1775     }
1776     bool isDouble = false;
1777     napi_valuetype valueType = GetArrayValueType(env, argv[INTEGER_ZERO], isDouble);
1778     if (valueType == napi_undefined) {
1779         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1780             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "number"));
1781         return result;
1782     }
1783     using SetArrayHandler = std::function<void(napi_env, napi_value, WebMessageExt*)>;
1784     const std::unordered_map<napi_valuetype, SetArrayHandler> functionMap = {
1785         { napi_boolean, SetArrayHandlerBoolean },
1786         { napi_string, SetArrayHandlerString },
1787         { napi_number, [isDouble](napi_env env, napi_value array, WebMessageExt* msgExt) {
1788             isDouble ? SetArrayHandlerDouble(env, array, msgExt)
1789                      : SetArrayHandlerInteger(env, array, msgExt);
1790         } }
1791     };
1792     auto it = functionMap.find(valueType);
1793     if (it != functionMap.end()) {
1794         it->second(env, argv[INTEGER_ZERO], webMessageExt);
1795     }
1796     return result;
1797 }
1798 
SetError(napi_env env,napi_callback_info info)1799 napi_value NapiWebMessageExt::SetError(napi_env env, napi_callback_info info)
1800 {
1801     WVLOG_D("NapiWebMessageExt::SetError start");
1802     napi_value thisVar = nullptr;
1803     napi_value result = nullptr;
1804     size_t argc = INTEGER_ONE;
1805     napi_value argv[INTEGER_ONE] = { 0 };
1806     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1807     if (argc != INTEGER_ONE) {
1808         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1809             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1810         return result;
1811     }
1812 
1813     bool isError = false;
1814     NAPI_CALL(env, napi_is_error(env, argv[INTEGER_ZERO], &isError));
1815     if (!isError) {
1816         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1817             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "message", "error"));
1818         return result;
1819     }
1820 
1821     napi_value nameObj = 0;
1822     napi_get_named_property(env, argv[INTEGER_ZERO], "name", &nameObj);
1823     std::string nameVal;
1824     if (!NapiParseUtils::ParseString(env, nameObj, nameVal)) {
1825         return result;
1826     }
1827 
1828     napi_value msgObj = 0;
1829     napi_get_named_property(env, argv[INTEGER_ZERO], "message", &msgObj);
1830     std::string msgVal;
1831     if (!NapiParseUtils::ParseString(env, msgObj, msgVal)) {
1832         return result;
1833     }
1834 
1835     WebMessageExt *webMessageExt = nullptr;
1836     napi_status status = napi_unwrap(env, thisVar, (void **)&webMessageExt);
1837     if ((!webMessageExt) || (status != napi_ok)) {
1838         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1839             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
1840         return result;
1841     }
1842 
1843     int32_t type = webMessageExt->GetType();
1844     if (type != static_cast<int32_t>(WebMessageType::ERROR)) {
1845         WVLOG_E("web message SetError error type:%{public}d", type);
1846         BusinessError::ThrowErrorByErrcode(env, TYPE_NOT_MATCH_WITCH_VALUE);
1847         return result;
1848     }
1849     webMessageExt->SetError(nameVal, msgVal);
1850     return result;
1851 }
1852 
CreateWebMessagePorts(napi_env env,napi_callback_info info)1853 napi_value NapiWebviewController::CreateWebMessagePorts(napi_env env, napi_callback_info info)
1854 {
1855     WVLOG_D("create web message port");
1856     napi_value thisVar = nullptr;
1857     napi_value result = nullptr;
1858     size_t argc = INTEGER_ONE;
1859     napi_value argv[INTEGER_ONE] = { 0 };
1860     bool isExtentionType = false;
1861     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1862     if (argc != INTEGER_ZERO && argc != INTEGER_ONE) {
1863         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1864             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "zero", "one"));
1865         return result;
1866     }
1867 
1868     if (argc == INTEGER_ONE) {
1869         if (!NapiParseUtils::ParseBoolean(env, argv[0], isExtentionType)) {
1870             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1871                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "isExtentionType", "boolean"));
1872             return result;
1873         }
1874     }
1875 
1876     WebviewController *webviewController = nullptr;
1877     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
1878     if (webviewController == nullptr || !webviewController->IsInit()) {
1879         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
1880         WVLOG_E("create message port failed, napi unwrap webviewController failed");
1881         return nullptr;
1882     }
1883     int32_t nwebId = webviewController->GetWebId();
1884     std::vector<std::string> ports = webviewController->CreateWebMessagePorts();
1885     if (ports.size() != INTEGER_TWO) {
1886         WVLOG_E("create web message port failed");
1887         return result;
1888     }
1889     napi_value msgPortcons = nullptr;
1890     NAPI_CALL(env, napi_get_reference_value(env, g_classWebMsgPort, &msgPortcons));
1891     napi_create_array(env, &result);
1892     napi_value consParam[INTEGER_TWO][INTEGER_THREE] = {{0}};
1893     for (uint32_t i = 0; i < INTEGER_TWO; i++) {
1894         napi_value msgPortObj = nullptr;
1895         NAPI_CALL(env, napi_create_int32(env, nwebId, &consParam[i][INTEGER_ZERO]));
1896         NAPI_CALL(env, napi_create_string_utf8(env, ports[i].c_str(), ports[i].length(), &consParam[i][INTEGER_ONE]));
1897         NAPI_CALL(env, napi_get_boolean(env, isExtentionType, &consParam[i][INTEGER_TWO]));
1898         NAPI_CALL(env, napi_new_instance(env, msgPortcons, INTEGER_THREE, consParam[i], &msgPortObj));
1899         napi_value jsExtention;
1900         napi_get_boolean(env, isExtentionType, &jsExtention);
1901         napi_set_named_property(env, msgPortObj, "isExtentionType", jsExtention);
1902 
1903         napi_set_element(env, result, i, msgPortObj);
1904     }
1905 
1906     return result;
1907 }
1908 
GetSendPorts(napi_env env,napi_value argv,std::vector<std::string> & sendPorts)1909 bool GetSendPorts(napi_env env, napi_value argv, std::vector<std::string>& sendPorts)
1910 {
1911     uint32_t arrayLen = 0;
1912     napi_get_array_length(env, argv, &arrayLen);
1913     if (arrayLen == 0) {
1914         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
1915         return false;
1916     }
1917 
1918     napi_valuetype valueType = napi_undefined;
1919     for (uint32_t i = 0; i < arrayLen; i++) {
1920         napi_value portItem = nullptr;
1921         napi_get_element(env, argv, i, &portItem);
1922         napi_typeof(env, portItem, &valueType);
1923         if (valueType != napi_object) {
1924             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
1925             return false;
1926         }
1927         WebMessagePort *msgPort = nullptr;
1928         napi_status status = napi_unwrap(env, portItem, (void **)&msgPort);
1929         if ((!msgPort) || (status != napi_ok)) {
1930             WVLOG_E("post port to html failed, napi unwrap msg port fail");
1931             return false;
1932         }
1933         std::string portHandle = msgPort->GetPortHandle();
1934         sendPorts.emplace_back(portHandle);
1935     }
1936     return true;
1937 }
1938 
PostMessage(napi_env env,napi_callback_info info)1939 napi_value NapiWebviewController::PostMessage(napi_env env, napi_callback_info info)
1940 {
1941     WVLOG_D("post message port");
1942     napi_value thisVar = nullptr;
1943     napi_value result = nullptr;
1944     size_t argc = INTEGER_THREE;
1945     napi_value argv[INTEGER_THREE];
1946     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
1947     if (argc != INTEGER_THREE) {
1948         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1949             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "three"));
1950         return result;
1951     }
1952 
1953     std::string portName;
1954     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], portName)) {
1955         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1956             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "name", "string"));
1957         return result;
1958     }
1959 
1960     bool isArray = false;
1961     NAPI_CALL(env, napi_is_array(env, argv[INTEGER_ONE], &isArray));
1962     if (!isArray) {
1963         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1964             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "ports", "array"));
1965         return result;
1966     }
1967     std::vector<std::string> sendPorts;
1968     if (!GetSendPorts(env, argv[INTEGER_ONE], sendPorts)) {
1969         WVLOG_E("post port to html failed, getSendPorts fail");
1970         return result;
1971     }
1972 
1973     std::string urlStr;
1974     if (!NapiParseUtils::ParseString(env, argv[INTEGER_TWO], urlStr)) {
1975         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1976             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "uri", "string"));
1977         return result;
1978     }
1979 
1980     WebviewController *webviewController = nullptr;
1981     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
1982     if (webviewController == nullptr || !webviewController->IsInit()) {
1983         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
1984         WVLOG_E("post port to html failed, napi unwrap webviewController failed");
1985         return nullptr;
1986     }
1987 
1988     webviewController->PostWebMessage(portName, sendPorts, urlStr);
1989     NAPI_CALL(env, napi_get_undefined(env, &result));
1990 
1991     return result;
1992 }
1993 
JsConstructor(napi_env env,napi_callback_info info)1994 napi_value NapiWebMessagePort::JsConstructor(napi_env env, napi_callback_info info)
1995 {
1996     WVLOG_D("web message port construct");
1997     napi_value thisVar = nullptr;
1998     size_t argc = INTEGER_THREE;
1999     napi_value argv[INTEGER_THREE] = {0};
2000     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2001 
2002     int32_t webId = -1;
2003     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], webId)) {
2004         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
2005         return nullptr;
2006     }
2007 
2008     std::string portHandle;
2009     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], portHandle)) {
2010         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
2011         return nullptr;
2012     }
2013 
2014     bool isExtentionType = false;
2015     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_TWO], isExtentionType)) {
2016         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
2017         return nullptr;
2018     }
2019 
2020     WebMessagePort *msgPort = new (std::nothrow) WebMessagePort(webId, portHandle, isExtentionType);
2021     if (msgPort == nullptr) {
2022         WVLOG_E("new msg port failed");
2023         return nullptr;
2024     }
2025     NAPI_CALL(env, napi_wrap(env, thisVar, msgPort,
2026         [](napi_env env, void *data, void *hint) {
2027             WebMessagePort *msgPort = static_cast<WebMessagePort *>(data);
2028             delete msgPort;
2029         },
2030         nullptr, nullptr));
2031     return thisVar;
2032 }
2033 
Close(napi_env env,napi_callback_info info)2034 napi_value NapiWebMessagePort::Close(napi_env env, napi_callback_info info)
2035 {
2036     WVLOG_D("close message port");
2037     napi_value thisVar = nullptr;
2038     napi_value result = nullptr;
2039     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr));
2040 
2041     WebMessagePort *msgPort = nullptr;
2042     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&msgPort));
2043     if (msgPort == nullptr) {
2044         WVLOG_E("close message port failed, napi unwrap msg port failed");
2045         return nullptr;
2046     }
2047     ErrCode ret = msgPort->ClosePort();
2048     if (ret != NO_ERROR) {
2049         BusinessError::ThrowErrorByErrcode(env, ret);
2050         return result;
2051     }
2052     NAPI_CALL(env, napi_get_undefined(env, &result));
2053 
2054     return result;
2055 }
2056 
PostMessageEventMsgHandler(napi_env env,napi_value argv,napi_valuetype valueType,bool isArrayBuffer,std::shared_ptr<NWebMessage> webMsg)2057 bool PostMessageEventMsgHandler(napi_env env, napi_value argv, napi_valuetype valueType, bool isArrayBuffer,
2058     std::shared_ptr<NWebMessage> webMsg)
2059 {
2060     if (valueType == napi_string) {
2061         size_t bufferSize = 0;
2062         napi_get_value_string_utf8(env, argv, nullptr, 0, &bufferSize);
2063         if (bufferSize > UINT_MAX) {
2064             WVLOG_E("String length is too long");
2065             return false;
2066         }
2067         char* stringValue = new (std::nothrow) char[bufferSize + 1];
2068         if (stringValue == nullptr) {
2069             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
2070             return false;
2071         }
2072         size_t jsStringLength = 0;
2073         napi_get_value_string_utf8(env, argv, stringValue, bufferSize + 1, &jsStringLength);
2074         std::string message(stringValue);
2075         delete [] stringValue;
2076         stringValue = nullptr;
2077 
2078         webMsg->SetType(NWebValue::Type::STRING);
2079         webMsg->SetString(message);
2080     } else if (isArrayBuffer) {
2081         uint8_t *arrBuf = nullptr;
2082         size_t byteLength = 0;
2083         napi_get_arraybuffer_info(env, argv, (void**)&arrBuf, &byteLength);
2084         std::vector<uint8_t> vecData(arrBuf, arrBuf + byteLength);
2085         webMsg->SetType(NWebValue::Type::BINARY);
2086         webMsg->SetBinary(vecData);
2087     }
2088     return true;
2089 }
2090 
PostMessageEvent(napi_env env,napi_callback_info info)2091 napi_value NapiWebMessagePort::PostMessageEvent(napi_env env, napi_callback_info info)
2092 {
2093     WVLOG_D("message port post message");
2094     napi_value thisVar = nullptr;
2095     napi_value result = nullptr;
2096     size_t argc = INTEGER_ONE;
2097     napi_value argv[INTEGER_ONE];
2098     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
2099     if (argc != INTEGER_ONE) {
2100         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2101             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2102         return result;
2103     }
2104     napi_valuetype valueType = napi_undefined;
2105     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
2106 
2107     bool isArrayBuffer = false;
2108     NAPI_CALL(env, napi_is_arraybuffer(env, argv[INTEGER_ZERO], &isArrayBuffer));
2109     if (valueType != napi_string && !isArrayBuffer) {
2110         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2111             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
2112         return result;
2113     }
2114 
2115     auto webMsg = std::make_shared<OHOS::NWeb::NWebMessage>(NWebValue::Type::NONE);
2116     if (!PostMessageEventMsgHandler(env, argv[INTEGER_ZERO], valueType, isArrayBuffer, webMsg)) {
2117         WVLOG_E("post message failed, PostMessageEventMsgHandler failed");
2118         return result;
2119     }
2120 
2121     WebMessagePort *msgPort = nullptr;
2122     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&msgPort));
2123     if (msgPort == nullptr) {
2124         WVLOG_E("post message failed, napi unwrap msg port failed");
2125         return nullptr;
2126     }
2127     ErrCode ret = msgPort->PostPortMessage(webMsg);
2128     if (ret != NO_ERROR) {
2129         BusinessError::ThrowErrorByErrcode(env, ret);
2130         return result;
2131     }
2132     NAPI_CALL(env, napi_get_undefined(env, &result));
2133 
2134     return result;
2135 }
2136 
PostMessageEventExt(napi_env env,napi_callback_info info)2137 napi_value NapiWebMessagePort::PostMessageEventExt(napi_env env, napi_callback_info info)
2138 {
2139     WVLOG_D("message PostMessageEventExt start");
2140     napi_value thisVar = nullptr;
2141     napi_value result = nullptr;
2142     size_t argc = INTEGER_ONE;
2143     napi_value argv[INTEGER_ONE];
2144     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
2145     if (argc != INTEGER_ONE) {
2146         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2147             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2148         return result;
2149     }
2150     napi_valuetype valueType = napi_undefined;
2151     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
2152     if (valueType != napi_object) {
2153         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2154             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
2155         return result;
2156     }
2157 
2158     WebMessageExt *webMessageExt = nullptr;
2159     NAPI_CALL(env, napi_unwrap(env, argv[INTEGER_ZERO], (void **)&webMessageExt));
2160     if (webMessageExt == nullptr) {
2161         WVLOG_E("post message failed, napi unwrap msg port failed");
2162         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2163             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NOT_NULL, "message"));
2164         return nullptr;
2165     }
2166 
2167     WebMessagePort *msgPort = nullptr;
2168     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&msgPort));
2169     if (msgPort == nullptr) {
2170         WVLOG_E("post message failed, napi unwrap msg port failed");
2171         return nullptr;
2172     }
2173 
2174     if (!msgPort->IsExtentionType()) {
2175         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2176             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "message"));
2177         return result;
2178     }
2179 
2180     ErrCode ret = msgPort->PostPortMessage(webMessageExt->GetData());
2181     if (ret != NO_ERROR) {
2182         BusinessError::ThrowErrorByErrcode(env, ret);
2183         return result;
2184     }
2185     NAPI_CALL(env, napi_get_undefined(env, &result));
2186 
2187     return result;
2188 }
2189 
2190 
OnMessageEventExt(napi_env env,napi_callback_info info)2191 napi_value NapiWebMessagePort::OnMessageEventExt(napi_env env, napi_callback_info info)
2192 {
2193     WVLOG_D("message port set OnMessageEventExt callback");
2194     napi_value thisVar = nullptr;
2195     napi_value result = nullptr;
2196     size_t argc = INTEGER_ONE;
2197     napi_value argv[INTEGER_ONE];
2198     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
2199     if (argc != INTEGER_ONE) {
2200         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2201             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2202         return result;
2203     }
2204     napi_valuetype valueType = napi_undefined;
2205     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
2206     if (valueType != napi_function) {
2207         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2208             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
2209         return result;
2210     }
2211 
2212     napi_ref onMsgEventFunc = nullptr;
2213     NAPI_CALL(env, napi_create_reference(env, argv[INTEGER_ZERO], INTEGER_ONE, &onMsgEventFunc));
2214 
2215     auto callbackImpl = std::make_shared<NWebValueCallbackImpl>(env, onMsgEventFunc, true);
2216 
2217     WebMessagePort *msgPort = nullptr;
2218     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&msgPort));
2219     if (msgPort == nullptr) {
2220         WVLOG_E("set message event callback failed, napi unwrap msg port failed");
2221         napi_delete_reference(env, onMsgEventFunc);
2222         return nullptr;
2223     }
2224     ErrCode ret = msgPort->SetPortMessageCallback(callbackImpl);
2225     if (ret != NO_ERROR) {
2226         BusinessError::ThrowErrorByErrcode(env, ret);
2227     }
2228     NAPI_CALL(env, napi_get_undefined(env, &result));
2229     return result;
2230 }
2231 
UvWebMsgOnReceiveCbDataHandler(NapiWebMessagePort::WebMsgPortParam * data,napi_value & result)2232 bool UvWebMsgOnReceiveCbDataHandler(NapiWebMessagePort::WebMsgPortParam *data, napi_value& result)
2233 {
2234     if (data->extention_) {
2235         napi_value webMsgExt = nullptr;
2236         napi_status status = napi_get_reference_value(data->env_, g_webMsgExtClassRef, &webMsgExt);
2237         if (status != napi_status::napi_ok) {
2238             WVLOG_E("napi_get_reference_value failed.");
2239             return false;
2240         }
2241         status = napi_new_instance(data->env_, webMsgExt, 0, NULL, &result);
2242         if (status != napi_status::napi_ok) {
2243             WVLOG_E("napi_new_instance failed.");
2244             return false;
2245         }
2246 
2247         WebMessageExt *webMessageExt = new (std::nothrow) WebMessageExt(data->msg_);
2248         if (webMessageExt == nullptr) {
2249             WVLOG_E("new WebMessageExt failed.");
2250             return false;
2251         }
2252 
2253         status = napi_wrap(data->env_, result, webMessageExt,
2254             [](napi_env env, void *data, void *hint) {
2255                 WebMessageExt *webMessageExt = static_cast<WebMessageExt *>(data);
2256                 delete webMessageExt;
2257             },
2258             nullptr, nullptr);
2259         if (status != napi_status::napi_ok) {
2260             WVLOG_E("napi_wrap failed.");
2261             return false;
2262         }
2263     } else {
2264         NapiParseUtils::ConvertNWebToNapiValue(data->env_, data->msg_, result);
2265     }
2266     return true;
2267 }
2268 
UvWebMessageOnReceiveValueCallback(uv_work_t * work,int status)2269 void NWebValueCallbackImpl::UvWebMessageOnReceiveValueCallback(uv_work_t *work, int status)
2270 {
2271     if (work == nullptr) {
2272         WVLOG_E("uv work is null");
2273         return;
2274     }
2275     NapiWebMessagePort::WebMsgPortParam *data = reinterpret_cast<NapiWebMessagePort::WebMsgPortParam*>(work->data);
2276     if (data == nullptr) {
2277         WVLOG_E("WebMsgPortParam is null");
2278         delete work;
2279         work = nullptr;
2280         return;
2281     }
2282     napi_handle_scope scope = nullptr;
2283     napi_open_handle_scope(data->env_, &scope);
2284     if (scope == nullptr) {
2285         delete work;
2286         work = nullptr;
2287         return;
2288     }
2289     napi_value result[INTEGER_ONE] = {0};
2290     if (!UvWebMsgOnReceiveCbDataHandler(data, result[INTEGER_ZERO])) {
2291         delete work;
2292         work = nullptr;
2293         napi_close_handle_scope(data->env_, scope);
2294         return;
2295     }
2296 
2297     napi_value onMsgEventFunc = nullptr;
2298     napi_get_reference_value(data->env_, data->callback_, &onMsgEventFunc);
2299     napi_value placeHodler = nullptr;
2300     napi_call_function(data->env_, nullptr, onMsgEventFunc, INTEGER_ONE, &result[INTEGER_ZERO], &placeHodler);
2301 
2302     std::unique_lock<std::mutex> lock(data->mutex_);
2303     data->ready_ = true;
2304     data->condition_.notify_all();
2305     napi_close_handle_scope(data->env_, scope);
2306 }
2307 
InvokeWebMessageCallback(NapiWebMessagePort::WebMsgPortParam * data)2308 static void InvokeWebMessageCallback(NapiWebMessagePort::WebMsgPortParam *data)
2309 {
2310     napi_handle_scope scope = nullptr;
2311     napi_open_handle_scope(data->env_, &scope);
2312     if (scope == nullptr) {
2313         WVLOG_E("scope is null");
2314         return;
2315     }
2316     napi_value result[INTEGER_ONE] = {0};
2317     if (!UvWebMsgOnReceiveCbDataHandler(data, result[INTEGER_ZERO])) {
2318         WVLOG_E("get result failed");
2319         napi_close_handle_scope(data->env_, scope);
2320         return;
2321     }
2322 
2323     napi_value onMsgEventFunc = nullptr;
2324     napi_get_reference_value(data->env_, data->callback_, &onMsgEventFunc);
2325     napi_value placeHodler = nullptr;
2326     napi_call_function(data->env_, nullptr, onMsgEventFunc, INTEGER_ONE, &result[INTEGER_ZERO], &placeHodler);
2327 
2328     napi_close_handle_scope(data->env_, scope);
2329 }
2330 
OnReceiveValue(std::shared_ptr<NWebMessage> result)2331 void NWebValueCallbackImpl::OnReceiveValue(std::shared_ptr<NWebMessage> result)
2332 {
2333     WVLOG_D("message port received msg");
2334     uv_loop_s *loop = nullptr;
2335     uv_work_t *work = nullptr;
2336     napi_get_uv_event_loop(env_, &loop);
2337     auto engine = reinterpret_cast<NativeEngine*>(env_);
2338     if (loop == nullptr) {
2339         WVLOG_E("get uv event loop failed");
2340         return;
2341     }
2342     work = new (std::nothrow) uv_work_t;
2343     if (work == nullptr) {
2344         WVLOG_E("new uv work failed");
2345         return;
2346     }
2347     NapiWebMessagePort::WebMsgPortParam *param = new (std::nothrow) NapiWebMessagePort::WebMsgPortParam();
2348     if (param == nullptr) {
2349         WVLOG_E("new WebMsgPortParam failed");
2350         delete work;
2351         return;
2352     }
2353     param->env_ = env_;
2354     param->callback_ = callback_;
2355     param->msg_ = result;
2356     param->extention_ = extention_;
2357     if (pthread_self() == engine->GetTid()) {
2358         InvokeWebMessageCallback(param);
2359     } else {
2360         work->data = reinterpret_cast<void*>(param);
2361         uv_queue_work_with_qos(
2362             loop, work, [](uv_work_t* work) {}, UvWebMessageOnReceiveValueCallback, uv_qos_user_initiated);
2363 
2364         {
2365             std::unique_lock<std::mutex> lock(param->mutex_);
2366             param->condition_.wait(lock, [&param] { return param->ready_; });
2367         }
2368     }
2369 
2370     if (param != nullptr) {
2371         delete param;
2372         param = nullptr;
2373     }
2374     if (work != nullptr) {
2375         delete work;
2376         work = nullptr;
2377     }
2378 }
2379 
UvNWebValueCallbackImplThreadWoker(uv_work_t * work,int status)2380 void UvNWebValueCallbackImplThreadWoker(uv_work_t *work, int status)
2381 {
2382     if (work == nullptr) {
2383         WVLOG_E("uv work is null");
2384         return;
2385     }
2386     NapiWebMessagePort::WebMsgPortParam *data = reinterpret_cast<NapiWebMessagePort::WebMsgPortParam*>(work->data);
2387     if (data == nullptr) {
2388         WVLOG_E("WebMsgPortParam is null");
2389         delete work;
2390         return;
2391     }
2392 
2393     napi_delete_reference(data->env_, data->callback_);
2394     delete data;
2395     data = nullptr;
2396     delete work;
2397     work = nullptr;
2398 }
2399 
~NWebValueCallbackImpl()2400 NWebValueCallbackImpl::~NWebValueCallbackImpl()
2401 {
2402     WVLOG_D("~NWebValueCallbackImpl");
2403     uv_loop_s *loop = nullptr;
2404     uv_work_t *work = nullptr;
2405     napi_get_uv_event_loop(env_, &loop);
2406     if (loop == nullptr) {
2407         WVLOG_E("get uv event loop failed");
2408         return;
2409     }
2410     work = new (std::nothrow) uv_work_t;
2411     if (work == nullptr) {
2412         WVLOG_E("new uv work failed");
2413         return;
2414     }
2415     NapiWebMessagePort::WebMsgPortParam *param = new (std::nothrow) NapiWebMessagePort::WebMsgPortParam();
2416     if (param == nullptr) {
2417         WVLOG_E("new WebMsgPortParam failed");
2418         delete work;
2419         return;
2420     }
2421     param->env_ = env_;
2422     param->callback_ = callback_;
2423     work->data = reinterpret_cast<void*>(param);
2424     int ret = uv_queue_work_with_qos(
2425         loop, work, [](uv_work_t *work) {}, UvNWebValueCallbackImplThreadWoker, uv_qos_user_initiated);
2426     if (ret != 0) {
2427         if (param != nullptr) {
2428             delete param;
2429             param = nullptr;
2430         }
2431         if (work != nullptr) {
2432             delete work;
2433             work = nullptr;
2434         }
2435     }
2436 }
2437 
OnMessageEvent(napi_env env,napi_callback_info info)2438 napi_value NapiWebMessagePort::OnMessageEvent(napi_env env, napi_callback_info info)
2439 {
2440     WVLOG_D("message port set OnMessageEvent callback");
2441     napi_value thisVar = nullptr;
2442     napi_value result = nullptr;
2443     size_t argc = INTEGER_ONE;
2444     napi_value argv[INTEGER_ONE];
2445     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
2446     if (argc != INTEGER_ONE) {
2447         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2448             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2449         return result;
2450     }
2451     napi_valuetype valueType = napi_undefined;
2452     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
2453     if (valueType != napi_function) {
2454         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2455             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
2456         return result;
2457     }
2458 
2459     napi_ref onMsgEventFunc = nullptr;
2460     NAPI_CALL(env, napi_create_reference(env, argv[INTEGER_ZERO], INTEGER_ONE, &onMsgEventFunc));
2461 
2462     auto callbackImpl = std::make_shared<NWebValueCallbackImpl>(env, onMsgEventFunc, false);
2463 
2464     WebMessagePort *msgPort = nullptr;
2465     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&msgPort));
2466     if (msgPort == nullptr) {
2467         WVLOG_E("set message event callback failed, napi unwrap msg port failed");
2468         return nullptr;
2469     }
2470     ErrCode ret = msgPort->SetPortMessageCallback(callbackImpl);
2471     if (ret != NO_ERROR) {
2472         BusinessError::ThrowErrorByErrcode(env, ret);
2473     }
2474     NAPI_CALL(env, napi_get_undefined(env, &result));
2475     return result;
2476 }
2477 
ZoomIn(napi_env env,napi_callback_info info)2478 napi_value NapiWebviewController::ZoomIn(napi_env env, napi_callback_info info)
2479 {
2480     napi_value result = nullptr;
2481     WebviewController *webviewController = GetWebviewController(env, info);
2482     if (!webviewController) {
2483         return nullptr;
2484     }
2485 
2486     ErrCode ret = webviewController->ZoomIn();
2487     if (ret != NO_ERROR) {
2488         if (ret == NWEB_ERROR) {
2489             WVLOG_E("ZoomIn failed.");
2490             return nullptr;
2491         }
2492         BusinessError::ThrowErrorByErrcode(env, ret);
2493     }
2494 
2495     NAPI_CALL(env, napi_get_undefined(env, &result));
2496     return result;
2497 }
2498 
ZoomOut(napi_env env,napi_callback_info info)2499 napi_value NapiWebviewController::ZoomOut(napi_env env, napi_callback_info info)
2500 {
2501     napi_value result = nullptr;
2502     WebviewController *webviewController = GetWebviewController(env, info);
2503     if (!webviewController) {
2504         return nullptr;
2505     }
2506 
2507     ErrCode ret = webviewController->ZoomOut();
2508     if (ret != NO_ERROR) {
2509         if (ret == NWEB_ERROR) {
2510             WVLOG_E("ZoomOut failed.");
2511             return nullptr;
2512         }
2513         BusinessError::ThrowErrorByErrcode(env, ret);
2514     }
2515 
2516     NAPI_CALL(env, napi_get_undefined(env, &result));
2517     return result;
2518 }
2519 
GetWebId(napi_env env,napi_callback_info info)2520 napi_value NapiWebviewController::GetWebId(napi_env env, napi_callback_info info)
2521 {
2522     napi_value result = nullptr;
2523     WebviewController *webviewController = GetWebviewController(env, info);
2524     if (!webviewController) {
2525         return nullptr;
2526     }
2527 
2528     int32_t webId = webviewController->GetWebId();
2529     napi_create_int32(env, webId, &result);
2530 
2531     return result;
2532 }
2533 
GetUserAgent(napi_env env,napi_callback_info info)2534 napi_value NapiWebviewController::GetUserAgent(napi_env env, napi_callback_info info)
2535 {
2536     napi_value result = nullptr;
2537     WebviewController *webviewController = GetWebviewController(env, info);
2538     if (!webviewController) {
2539         return nullptr;
2540     }
2541 
2542     std::string userAgent = "";
2543     userAgent = webviewController->GetUserAgent();
2544     napi_create_string_utf8(env, userAgent.c_str(), userAgent.length(), &result);
2545 
2546     return result;
2547 }
2548 
GetCustomUserAgent(napi_env env,napi_callback_info info)2549 napi_value NapiWebviewController::GetCustomUserAgent(napi_env env, napi_callback_info info)
2550 {
2551     napi_value thisVar = nullptr;
2552     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
2553 
2554     WebviewController *webviewController = nullptr;
2555     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2556     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2557         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2558         return nullptr;
2559     }
2560 
2561     napi_value result = nullptr;
2562     std::string userAgent = webviewController->GetCustomUserAgent();
2563     napi_create_string_utf8(env, userAgent.c_str(), userAgent.length(), &result);
2564     return result;
2565 }
2566 
SetCustomUserAgent(napi_env env,napi_callback_info info)2567 napi_value NapiWebviewController::SetCustomUserAgent(napi_env env, napi_callback_info info)
2568 {
2569     napi_value thisVar = nullptr;
2570     napi_value result = nullptr;
2571     size_t argc = INTEGER_ONE;
2572     napi_value argv[INTEGER_ONE];
2573     NAPI_CALL(env, napi_get_undefined(env, &result));
2574 
2575     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2576     if (argc != INTEGER_ONE) {
2577         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2578             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2579         return result;
2580     }
2581 
2582     std::string userAgent;
2583     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], userAgent)) {
2584         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2585             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "userAgent", "string"));
2586         return result;
2587     }
2588 
2589     WebviewController *webviewController = nullptr;
2590     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2591     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2592         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2593         return result;
2594     }
2595     ErrCode ret = webviewController->SetCustomUserAgent(userAgent);
2596     if (ret != NO_ERROR) {
2597         BusinessError::ThrowErrorByErrcode(env, ret);
2598     }
2599     return result;
2600 }
2601 
GetTitle(napi_env env,napi_callback_info info)2602 napi_value NapiWebviewController::GetTitle(napi_env env, napi_callback_info info)
2603 {
2604     napi_value result = nullptr;
2605     WebviewController *webviewController = GetWebviewController(env, info);
2606     if (!webviewController) {
2607         return nullptr;
2608     }
2609 
2610     std::string title = "";
2611     title = webviewController->GetTitle();
2612     napi_create_string_utf8(env, title.c_str(), title.length(), &result);
2613 
2614     return result;
2615 }
2616 
GetPageHeight(napi_env env,napi_callback_info info)2617 napi_value NapiWebviewController::GetPageHeight(napi_env env, napi_callback_info info)
2618 {
2619     napi_value result = nullptr;
2620     WebviewController *webviewController = GetWebviewController(env, info);
2621     if (!webviewController) {
2622         return nullptr;
2623     }
2624 
2625     int32_t pageHeight = webviewController->GetPageHeight();
2626     napi_create_int32(env, pageHeight, &result);
2627 
2628     return result;
2629 }
2630 
BackOrForward(napi_env env,napi_callback_info info)2631 napi_value NapiWebviewController::BackOrForward(napi_env env, napi_callback_info info)
2632 {
2633     napi_value thisVar = nullptr;
2634     napi_value result = nullptr;
2635     size_t argc = INTEGER_ONE;
2636     napi_value argv[INTEGER_ONE] = {0};
2637     void* data = nullptr;
2638     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2639 
2640     if (argc != INTEGER_ONE) {
2641         WVLOG_E("Requires 1 parameters.");
2642         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2643             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
2644         return nullptr;
2645     }
2646 
2647     int32_t step = -1;
2648     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], step)) {
2649         WVLOG_E("Parameter is not integer number type.");
2650         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2651             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "step", "number"));
2652         return nullptr;
2653     }
2654 
2655     WebviewController *webviewController = nullptr;
2656     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2657     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2658         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2659         return nullptr;
2660     }
2661 
2662     ErrCode ret = webviewController->BackOrForward(step);
2663     if (ret != NO_ERROR) {
2664         BusinessError::ThrowErrorByErrcode(env, ret);
2665     }
2666 
2667     NAPI_CALL(env, napi_get_undefined(env, &result));
2668     return result;
2669 }
2670 
StoreWebArchive(napi_env env,napi_callback_info info)2671 napi_value NapiWebviewController::StoreWebArchive(napi_env env, napi_callback_info info)
2672 {
2673     napi_value thisVar = nullptr;
2674     napi_value result = nullptr;
2675     size_t argc = INTEGER_ONE;
2676     size_t argcPromise = INTEGER_TWO;
2677     size_t argcCallback = INTEGER_THREE;
2678     napi_value argv[INTEGER_THREE] = { 0 };
2679 
2680     napi_get_undefined(env, &result);
2681     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2682 
2683     if (argc != argcPromise && argc != argcCallback) {
2684         BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
2685             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "two", "three"));
2686         return result;
2687     }
2688     std::string baseName;
2689     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], baseName)) {
2690         BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
2691             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "baseName", "string"));
2692         return result;
2693     }
2694 
2695     if (baseName.empty()) {
2696         BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
2697             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NOT_NULL, "baseName"));
2698         return result;
2699     }
2700 
2701     bool autoName = false;
2702     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2703     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ONE], autoName)) {
2704         BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
2705             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "autoName", "boolean"));
2706         return result;
2707     }
2708 
2709     if (argc == argcCallback) {
2710         napi_valuetype valueType = napi_null;
2711         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2712         napi_typeof(env, argv[argcCallback - 1], &valueType);
2713         if (valueType != napi_function) {
2714             BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
2715                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
2716             return result;
2717         }
2718     }
2719     return StoreWebArchiveInternal(env, info, baseName, autoName);
2720 }
2721 
StoreWebArchiveInternal(napi_env env,napi_callback_info info,const std::string & baseName,bool autoName)2722 napi_value NapiWebviewController::StoreWebArchiveInternal(napi_env env, napi_callback_info info,
2723     const std::string &baseName, bool autoName)
2724 {
2725     napi_value thisVar = nullptr;
2726     size_t argc = INTEGER_ONE;
2727     size_t argcPromise = INTEGER_TWO;
2728     size_t argcCallback = INTEGER_THREE;
2729     napi_value argv[INTEGER_THREE] = {0};
2730 
2731     napi_value result = nullptr;
2732     napi_get_undefined(env, &result);
2733     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2734 
2735     WebviewController *webviewController = nullptr;
2736     napi_unwrap(env, thisVar, (void **)&webviewController);
2737 
2738     if (!webviewController || !webviewController->IsInit()) {
2739         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2740         return result;
2741     }
2742 
2743     if (argc == argcCallback) {
2744         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2745         napi_ref jsCallback = nullptr;
2746         napi_create_reference(env, argv[argcCallback - 1], 1, &jsCallback);
2747 
2748         if (jsCallback) {
2749             webviewController->StoreWebArchiveCallback(baseName, autoName, env, std::move(jsCallback));
2750         }
2751         return result;
2752     } else if (argc == argcPromise) {
2753         napi_deferred deferred = nullptr;
2754         napi_value promise = nullptr;
2755         napi_create_promise(env, &deferred, &promise);
2756         if (promise && deferred) {
2757             webviewController->StoreWebArchivePromise(baseName, autoName, env, deferred);
2758         }
2759         return promise;
2760     }
2761     return result;
2762 }
2763 
GetHitTestValue(napi_env env,napi_callback_info info)2764 napi_value NapiWebviewController::GetHitTestValue(napi_env env, napi_callback_info info)
2765 {
2766     napi_value result = nullptr;
2767     WebviewController *webviewController = GetWebviewController(env, info);
2768     if (!webviewController) {
2769         return nullptr;
2770     }
2771 
2772     std::shared_ptr<HitTestResult> nwebResult = webviewController->GetHitTestValue();
2773 
2774     napi_create_object(env, &result);
2775 
2776     napi_value type;
2777     if (nwebResult) {
2778         napi_create_uint32(env, nwebResult->GetType(), &type);
2779     } else {
2780         napi_create_uint32(env, HitTestResult::UNKNOWN_TYPE, &type);
2781     }
2782     napi_set_named_property(env, result, "type", type);
2783 
2784     napi_value extra;
2785     if (nwebResult) {
2786         napi_create_string_utf8(env, nwebResult->GetExtra().c_str(), NAPI_AUTO_LENGTH, &extra);
2787     } else {
2788         napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &extra);
2789     }
2790     napi_set_named_property(env, result, "extra", extra);
2791 
2792     return result;
2793 }
2794 
RequestFocus(napi_env env,napi_callback_info info)2795 napi_value NapiWebviewController::RequestFocus(napi_env env, napi_callback_info info)
2796 {
2797     napi_value result = nullptr;
2798     WebviewController *webviewController = GetWebviewController(env, info);
2799     if (!webviewController) {
2800         return nullptr;
2801     }
2802 
2803     webviewController->RequestFocus();
2804     NAPI_CALL(env, napi_get_undefined(env, &result));
2805     return result;
2806 }
2807 
PostUrl(napi_env env,napi_callback_info info)2808 napi_value NapiWebviewController::PostUrl(napi_env env, napi_callback_info info)
2809 {
2810     WVLOG_D("NapiWebMessageExt::PostUrl start");
2811     napi_value thisVar = nullptr;
2812     napi_value result = nullptr;
2813     size_t argc = INTEGER_TWO;
2814     napi_value argv[INTEGER_TWO] = { 0 };
2815     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2816     if (argc != INTEGER_TWO) {
2817         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2818             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "two"));
2819         return result;
2820     }
2821 
2822     WebviewController *webviewController = nullptr;
2823     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2824     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2825         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2826         return nullptr;
2827     }
2828 
2829     std::string url;
2830     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], url)) {
2831         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2832             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "url", "string"));
2833         return result;
2834     }
2835 
2836     bool isArrayBuffer = false;
2837     NAPI_CALL(env, napi_is_arraybuffer(env, argv[INTEGER_ONE], &isArrayBuffer));
2838     if (!isArrayBuffer) {
2839         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2840             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "postData", "array"));
2841         return result;
2842     }
2843 
2844     char *arrBuf = nullptr;
2845     size_t byteLength = 0;
2846     napi_get_arraybuffer_info(env, argv[INTEGER_ONE], (void **)&arrBuf, &byteLength);
2847 
2848     std::vector<char> postData(arrBuf, arrBuf + byteLength);
2849     ErrCode ret = webviewController->PostUrl(url, postData);
2850     if (ret != NO_ERROR) {
2851         if (ret == NWEB_ERROR) {
2852             WVLOG_E("PostData failed");
2853             return result;
2854         }
2855         BusinessError::ThrowErrorByErrcode(env, ret);
2856         return result;
2857     }
2858     NAPI_CALL(env, napi_get_undefined(env, &result));
2859     return result;
2860 }
2861 
LoadUrl(napi_env env,napi_callback_info info)2862 napi_value NapiWebviewController::LoadUrl(napi_env env, napi_callback_info info)
2863 {
2864     napi_value thisVar = nullptr;
2865     napi_value result = nullptr;
2866     size_t argc = INTEGER_TWO;
2867     napi_value argv[INTEGER_TWO];
2868     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2869     if ((argc != INTEGER_ONE) && (argc != INTEGER_TWO)) {
2870         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2871             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "one", "two"));
2872         return nullptr;
2873     }
2874     WebviewController *webviewController = nullptr;
2875     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2876     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2877         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2878         return nullptr;
2879     }
2880     napi_valuetype webSrcType;
2881     napi_typeof(env, argv[INTEGER_ZERO], &webSrcType);
2882     if (webSrcType != napi_string && webSrcType != napi_object) {
2883         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2884             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_TYPE_INVALID, "url"));
2885         return nullptr;
2886     }
2887     std::string webSrc;
2888     if (!webviewController->ParseUrl(env, argv[INTEGER_ZERO], webSrc)) {
2889         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
2890         return nullptr;
2891     }
2892     if (argc == INTEGER_ONE) {
2893         ErrCode ret = webviewController->LoadUrl(webSrc);
2894         if (ret != NO_ERROR) {
2895             if (ret == NWEB_ERROR) {
2896                 return nullptr;
2897             }
2898             BusinessError::ThrowErrorByErrcode(env, ret);
2899             return nullptr;
2900         }
2901         NAPI_CALL(env, napi_get_undefined(env, &result));
2902         return result;
2903     }
2904     return LoadUrlWithHttpHeaders(env, info, webSrc, argv, webviewController);
2905 }
2906 
LoadUrlWithHttpHeaders(napi_env env,napi_callback_info info,const std::string & url,const napi_value * argv,WebviewController * webviewController)2907 napi_value NapiWebviewController::LoadUrlWithHttpHeaders(napi_env env, napi_callback_info info, const std::string& url,
2908     const napi_value* argv, WebviewController* webviewController)
2909 {
2910     napi_value result = nullptr;
2911     std::map<std::string, std::string> httpHeaders;
2912     napi_value array = argv[INTEGER_ONE];
2913     bool isArray = false;
2914     napi_is_array(env, array, &isArray);
2915     if (isArray) {
2916         uint32_t arrayLength = INTEGER_ZERO;
2917         napi_get_array_length(env, array, &arrayLength);
2918         for (uint32_t i = 0; i < arrayLength; ++i) {
2919             std::string key;
2920             std::string value;
2921             napi_value obj = nullptr;
2922             napi_value keyObj = nullptr;
2923             napi_value valueObj = nullptr;
2924             napi_get_element(env, array, i, &obj);
2925             if (napi_get_named_property(env, obj, "headerKey", &keyObj) != napi_ok) {
2926                 continue;
2927             }
2928             if (napi_get_named_property(env, obj, "headerValue", &valueObj) != napi_ok) {
2929                 continue;
2930             }
2931             NapiParseUtils::ParseString(env, keyObj, key);
2932             NapiParseUtils::ParseString(env, valueObj, value);
2933             httpHeaders[key] = value;
2934         }
2935     } else {
2936         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
2937         return nullptr;
2938     }
2939 
2940     ErrCode ret = webviewController->LoadUrl(url, httpHeaders);
2941     if (ret != NO_ERROR) {
2942         if (ret == NWEB_ERROR) {
2943             WVLOG_E("LoadUrl failed.");
2944             return nullptr;
2945         }
2946         BusinessError::ThrowErrorByErrcode(env, ret);
2947         return nullptr;
2948     }
2949     NAPI_CALL(env, napi_get_undefined(env, &result));
2950     return result;
2951 }
2952 
LoadData(napi_env env,napi_callback_info info)2953 napi_value NapiWebviewController::LoadData(napi_env env, napi_callback_info info)
2954 {
2955     napi_value thisVar = nullptr;
2956     napi_value result = nullptr;
2957     size_t argc = INTEGER_FIVE;
2958     napi_value argv[INTEGER_FIVE];
2959     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
2960     if ((argc != INTEGER_THREE) && (argc != INTEGER_FOUR) &&
2961         (argc != INTEGER_FIVE)) {
2962         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
2963             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "three", "four"));
2964         return nullptr;
2965     }
2966     WebviewController *webviewController = nullptr;
2967     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
2968     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
2969         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
2970         return nullptr;
2971     }
2972     std::string data;
2973     std::string mimeType;
2974     std::string encoding;
2975     std::string baseUrl;
2976     std::string historyUrl;
2977     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], data) ||
2978         !NapiParseUtils::ParseString(env, argv[INTEGER_ONE], mimeType) ||
2979         !NapiParseUtils::ParseString(env, argv[INTEGER_TWO], encoding)) {
2980         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR, ParamCheckErrorMsgTemplate::TYPE_ALL_STRING);
2981         return nullptr;
2982     }
2983     if ((argc >= INTEGER_FOUR) && !NapiParseUtils::ParseString(env, argv[INTEGER_THREE], baseUrl)) {
2984         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR, ParamCheckErrorMsgTemplate::TYPE_ALL_STRING);
2985         return nullptr;
2986     }
2987     if ((argc == INTEGER_FIVE) && !NapiParseUtils::ParseString(env, argv[INTEGER_FOUR], historyUrl)) {
2988         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR, ParamCheckErrorMsgTemplate::TYPE_ALL_STRING);
2989         return nullptr;
2990     }
2991     ErrCode ret = webviewController->LoadData(data, mimeType, encoding, baseUrl, historyUrl);
2992     if (ret != NO_ERROR) {
2993         if (ret == NWEB_ERROR) {
2994             WVLOG_E("LoadData failed.");
2995             return nullptr;
2996         }
2997         BusinessError::ThrowErrorByErrcode(env, ret);
2998         return nullptr;
2999     }
3000     NAPI_CALL(env, napi_get_undefined(env, &result));
3001     return result;
3002 }
3003 
GetHitTest(napi_env env,napi_callback_info info)3004 napi_value NapiWebviewController::GetHitTest(napi_env env, napi_callback_info info)
3005 {
3006     napi_value result = nullptr;
3007     WebviewController *webviewController = GetWebviewController(env, info);
3008     if (!webviewController) {
3009         return nullptr;
3010     }
3011 
3012     int32_t type = webviewController->GetHitTest();
3013     napi_create_int32(env, type, &result);
3014     return result;
3015 }
3016 
ClearMatches(napi_env env,napi_callback_info info)3017 napi_value NapiWebviewController::ClearMatches(napi_env env, napi_callback_info info)
3018 {
3019     napi_value thisVar = nullptr;
3020     napi_value result = nullptr;
3021 
3022     NAPI_CALL(env, napi_get_undefined(env, &result));
3023     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3024 
3025     WebviewController *controller = nullptr;
3026     napi_unwrap(env, thisVar, (void **)&controller);
3027     if (!controller || !controller->IsInit()) {
3028         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3029         return result;
3030     }
3031     controller->ClearMatches();
3032     return result;
3033 }
3034 
SearchNext(napi_env env,napi_callback_info info)3035 napi_value NapiWebviewController::SearchNext(napi_env env, napi_callback_info info)
3036 {
3037     napi_value thisVar = nullptr;
3038     napi_value result = nullptr;
3039     size_t argc = INTEGER_ONE;
3040     napi_value argv[INTEGER_ONE] = { 0 };
3041 
3042     NAPI_CALL(env, napi_get_undefined(env, &result));
3043     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3044     if (argc != INTEGER_ONE) {
3045         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3046             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3047         return result;
3048     }
3049     bool forward;
3050     if (!NapiParseUtils::ParseBoolean(env, argv[0], forward)) {
3051         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3052             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "forward", "boolean"));
3053         return result;
3054     }
3055 
3056     WebviewController *controller = nullptr;
3057     napi_unwrap(env, thisVar, (void **)&controller);
3058     if (!controller || !controller->IsInit()) {
3059         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3060         return result;
3061     }
3062     controller->SearchNext(forward);
3063     return result;
3064 }
3065 
SearchAllAsync(napi_env env,napi_callback_info info)3066 napi_value NapiWebviewController::SearchAllAsync(napi_env env, napi_callback_info info)
3067 {
3068     napi_value thisVar = nullptr;
3069     napi_value result = nullptr;
3070     size_t argc = INTEGER_ONE;
3071     napi_value argv[INTEGER_ONE] = { 0 };
3072 
3073     NAPI_CALL(env, napi_get_undefined(env, &result));
3074     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3075     if (argc != INTEGER_ONE) {
3076         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3077             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3078         return result;
3079     }
3080     std::string searchString;
3081     if (!NapiParseUtils::ParseString(env, argv[0], searchString)) {
3082         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3083             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "searchString", "number"));
3084         return result;
3085     }
3086 
3087     WebviewController *controller = nullptr;
3088     napi_unwrap(env, thisVar, (void **)&controller);
3089     if (!controller || !controller->IsInit()) {
3090         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3091         return result;
3092     }
3093     controller->SearchAllAsync(searchString);
3094     return result;
3095 }
3096 
ClearSslCache(napi_env env,napi_callback_info info)3097 napi_value NapiWebviewController::ClearSslCache(napi_env env, napi_callback_info info)
3098 {
3099     napi_value thisVar = nullptr;
3100     napi_value result = nullptr;
3101 
3102     NAPI_CALL(env, napi_get_undefined(env, &result));
3103     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3104 
3105     WebviewController *controller = nullptr;
3106     napi_unwrap(env, thisVar, (void **)&controller);
3107     if (!controller || !controller->IsInit()) {
3108         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3109         return result;
3110     }
3111     controller->ClearSslCache();
3112     return result;
3113 }
3114 
ClearClientAuthenticationCache(napi_env env,napi_callback_info info)3115 napi_value NapiWebviewController::ClearClientAuthenticationCache(napi_env env, napi_callback_info info)
3116 {
3117     napi_value thisVar = nullptr;
3118     napi_value result = nullptr;
3119 
3120     NAPI_CALL(env, napi_get_undefined(env, &result));
3121     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3122 
3123     WebviewController *controller = nullptr;
3124     napi_unwrap(env, thisVar, (void **)&controller);
3125     if (!controller || !controller->IsInit()) {
3126         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3127         return result;
3128     }
3129     controller->ClearClientAuthenticationCache();
3130 
3131     return result;
3132 }
3133 
Stop(napi_env env,napi_callback_info info)3134 napi_value NapiWebviewController::Stop(napi_env env, napi_callback_info info)
3135 {
3136     napi_value thisVar = nullptr;
3137     napi_value result = nullptr;
3138     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3139 
3140     WebviewController *controller = nullptr;
3141     napi_unwrap(env, thisVar, (void **)&controller);
3142     if (!controller || !controller->IsInit()) {
3143         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3144         return result;
3145     }
3146     controller->Stop();
3147 
3148     NAPI_CALL(env, napi_get_undefined(env, &result));
3149     return result;
3150 }
3151 
Zoom(napi_env env,napi_callback_info info)3152 napi_value NapiWebviewController::Zoom(napi_env env, napi_callback_info info)
3153 {
3154     napi_value thisVar = nullptr;
3155     napi_value result = nullptr;
3156     size_t argc = INTEGER_ONE;
3157     napi_value argv[INTEGER_ONE] = { 0 };
3158 
3159     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3160     if (argc != INTEGER_ONE) {
3161         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3162             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3163         return result;
3164     }
3165     float factor = 0.0;
3166     if (!NapiParseUtils::ParseFloat(env, argv[0], factor)) {
3167         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3168             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "factor", "number"));
3169         return result;
3170     }
3171 
3172     WebviewController *controller = nullptr;
3173     napi_unwrap(env, thisVar, (void **)&controller);
3174     if (!controller || !controller->IsInit()) {
3175         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3176         return result;
3177     }
3178 
3179     ErrCode ret = controller->Zoom(factor);
3180     if (ret != NO_ERROR) {
3181         if (ret == NWEB_ERROR) {
3182             WVLOG_E("Zoom failed.");
3183             return result;
3184         }
3185         BusinessError::ThrowErrorByErrcode(env, ret);
3186     }
3187 
3188     NAPI_CALL(env, napi_get_undefined(env, &result));
3189     return result;
3190 }
3191 
InnerCompleteWindowNew(napi_env env,napi_callback_info info)3192 napi_value NapiWebviewController::InnerCompleteWindowNew(napi_env env, napi_callback_info info)
3193 {
3194     napi_value thisVar = nullptr;
3195     size_t argc = INTEGER_ONE;
3196     napi_value argv[INTEGER_ONE];
3197     void* data = nullptr;
3198     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
3199 
3200     int32_t parentNwebId = -1;
3201     if (!NapiParseUtils::ParseInt32(env, argv[0], parentNwebId) || parentNwebId == -1) {
3202         WVLOG_E("Parse parent nweb id failed.");
3203         return nullptr;
3204     }
3205     WebviewController* webviewController = nullptr;
3206     napi_status status = napi_unwrap(env, thisVar, (void**)&webviewController);
3207     if ((!webviewController) || (status != napi_ok)) {
3208         WVLOG_E("webviewController is nullptr.");
3209         return nullptr;
3210     }
3211     webviewController->InnerCompleteWindowNew(parentNwebId);
3212     return thisVar;
3213 }
3214 
RegisterJavaScriptProxy(napi_env env,napi_callback_info info)3215 napi_value NapiWebviewController::RegisterJavaScriptProxy(napi_env env, napi_callback_info info)
3216 {
3217     napi_value thisVar = nullptr;
3218     napi_value result = nullptr;
3219     size_t argc = INTEGER_FIVE;
3220     napi_value argv[INTEGER_FIVE] = { 0 };
3221     napi_get_undefined(env, &result);
3222     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3223     if (argc != INTEGER_THREE && argc != INTEGER_FOUR && argc != INTEGER_FIVE) {
3224         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3225             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_THREE, "three", "four", "five"));
3226         return result;
3227     }
3228     napi_valuetype valueType = napi_undefined;
3229     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
3230     if (valueType != napi_object) {
3231         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3232             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "object", "object"));
3233         return result;
3234     }
3235     RegisterJavaScriptProxyParam param;
3236     if (!ParseRegisterJavaScriptProxyParam(env, argc, argv, &param)) {
3237         return result;
3238     }
3239     WebviewController* controller = nullptr;
3240     napi_unwrap(env, thisVar, (void **)&controller);
3241     if (!controller || !controller->IsInit()) {
3242         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3243         return result;
3244     }
3245     controller->SetNWebJavaScriptResultCallBack();
3246     controller->RegisterJavaScriptProxy(param);
3247     return result;
3248 }
3249 
DeleteJavaScriptRegister(napi_env env,napi_callback_info info)3250 napi_value NapiWebviewController::DeleteJavaScriptRegister(napi_env env, napi_callback_info info)
3251 {
3252     napi_value thisVar = nullptr;
3253     napi_value result = nullptr;
3254     size_t argc = INTEGER_ONE;
3255     napi_value argv[INTEGER_ONE] = { 0 };
3256 
3257     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3258     if (argc != INTEGER_ONE) {
3259         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3260             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3261         return result;
3262     }
3263 
3264     std::string objName;
3265     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], objName)) {
3266         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3267             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "name", "string"));
3268         return result;
3269     }
3270 
3271     WebviewController *controller = nullptr;
3272     napi_unwrap(env, thisVar, (void **)&controller);
3273     if (!controller || !controller->IsInit()) {
3274         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3275         return result;
3276     }
3277     ErrCode ret = controller->DeleteJavaScriptRegister(objName, {});
3278     if (ret != NO_ERROR) {
3279         BusinessError::ThrowErrorByErrcode(env, ret);
3280         return result;
3281     }
3282 
3283     NAPI_CALL(env, napi_get_undefined(env, &result));
3284     return result;
3285 }
3286 
RunJavaScript(napi_env env,napi_callback_info info)3287 napi_value NapiWebviewController::RunJavaScript(napi_env env, napi_callback_info info)
3288 {
3289     return RunJS(env, info, false);
3290 }
3291 
RunJavaScriptExt(napi_env env,napi_callback_info info)3292 napi_value NapiWebviewController::RunJavaScriptExt(napi_env env, napi_callback_info info)
3293 {
3294     return RunJS(env, info, true);
3295 }
3296 
RunJS(napi_env env,napi_callback_info info,bool extention)3297 napi_value NapiWebviewController::RunJS(napi_env env, napi_callback_info info, bool extention)
3298 {
3299     napi_value thisVar = nullptr;
3300     napi_value result = nullptr;
3301     size_t argc = INTEGER_ONE;
3302     size_t argcPromise = INTEGER_ONE;
3303     size_t argcCallback = INTEGER_TWO;
3304     napi_value argv[INTEGER_TWO] = { 0 };
3305 
3306     napi_get_undefined(env, &result);
3307     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3308 
3309     if (argc != argcPromise && argc != argcCallback) {
3310         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3311             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "two"));
3312         return result;
3313     }
3314 
3315     if (argc == argcCallback) {
3316         napi_valuetype valueType = napi_null;
3317         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3318         napi_typeof(env, argv[argcCallback - 1], &valueType);
3319         if (valueType != napi_function) {
3320             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3321                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
3322             return result;
3323         }
3324     }
3325 
3326     if (maxFdNum_ == -1) {
3327         maxFdNum_ =
3328             std::atoi(NWebAdapterHelper::Instance().ParsePerfConfig("flowBufferConfig", "maxFdNumber").c_str());
3329     }
3330 
3331     if (usedFd_.load() < maxFdNum_) {
3332         return RunJavaScriptInternalExt(env, info, extention);
3333     }
3334 
3335     std::string script;
3336     napi_valuetype valueType = napi_undefined;
3337     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
3338     bool parseResult = (valueType == napi_string) ? NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], script) :
3339         NapiParseUtils::ParseArrayBuffer(env, argv[INTEGER_ZERO], script);
3340     if (!parseResult) {
3341         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3342             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "script", "string"));
3343         return result;
3344     }
3345     return RunJavaScriptInternal(env, info, script, extention);
3346 }
3347 
RunCreatePDFExt(napi_env env,napi_callback_info info)3348 napi_value NapiWebviewController::RunCreatePDFExt(napi_env env, napi_callback_info info)
3349 {
3350     napi_value thisVar = nullptr;
3351     napi_value result = nullptr;
3352     size_t argc = INTEGER_ONE;
3353     size_t argcPromise = INTEGER_ONE;
3354     size_t argcCallback = INTEGER_TWO;
3355     napi_value argv[INTEGER_TWO] = { 0 };
3356 
3357     napi_get_undefined(env, &result);
3358     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3359 
3360     WebviewController* webviewController = nullptr;
3361     napi_unwrap(env, thisVar, (void**)&webviewController);
3362 
3363     if (!webviewController || !webviewController->IsInit()) {
3364         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3365         return result;
3366     }
3367 
3368     std::shared_ptr<NWebPDFConfigArgs> pdfConfig = ParsePDFConfigArgs(env, argv[INTEGER_ZERO]);
3369     if (pdfConfig == nullptr) {
3370         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
3371         return nullptr;
3372     }
3373 
3374     if (argc == argcCallback) {
3375         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3376         napi_ref jsCallback = nullptr;
3377         napi_create_reference(env, argv[argcCallback - 1], 1, &jsCallback);
3378 
3379         if (jsCallback) {
3380             webviewController->CreatePDFCallbackExt(env, pdfConfig, std::move(jsCallback));
3381         }
3382         return result;
3383     } else if (argc == argcPromise) {
3384         napi_deferred deferred = nullptr;
3385         napi_value promise = nullptr;
3386         napi_create_promise(env, &deferred, &promise);
3387         if (promise && deferred) {
3388             webviewController->CreatePDFPromiseExt(env, pdfConfig, deferred);
3389         }
3390         return promise;
3391     }
3392     return result;
3393 }
3394 
RunJavaScriptInternal(napi_env env,napi_callback_info info,const std::string & script,bool extention)3395 napi_value NapiWebviewController::RunJavaScriptInternal(napi_env env, napi_callback_info info,
3396     const std::string &script, bool extention)
3397 {
3398     napi_value thisVar = nullptr;
3399     size_t argc = INTEGER_ONE;
3400     size_t argcPromise = INTEGER_ONE;
3401     size_t argcCallback = INTEGER_TWO;
3402     napi_value argv[INTEGER_TWO] = {0};
3403 
3404     napi_value result = nullptr;
3405     napi_get_undefined(env, &result);
3406     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3407 
3408     WebviewController *webviewController = nullptr;
3409     napi_unwrap(env, thisVar, (void **)&webviewController);
3410 
3411     if (!webviewController || !webviewController->IsInit()) {
3412         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3413         return result;
3414     }
3415 
3416     if (argc == argcCallback) {
3417         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3418         napi_ref jsCallback = nullptr;
3419         napi_create_reference(env, argv[argcCallback - 1], 1, &jsCallback);
3420 
3421         if (jsCallback) {
3422             webviewController->RunJavaScriptCallback(script, env, std::move(jsCallback), extention);
3423         }
3424         return result;
3425     } else if (argc == argcPromise) {
3426         napi_deferred deferred = nullptr;
3427         napi_value promise = nullptr;
3428         napi_create_promise(env, &deferred, &promise);
3429         if (promise && deferred) {
3430             webviewController->RunJavaScriptPromise(script, env, deferred, extention);
3431         }
3432         return promise;
3433     }
3434     return result;
3435 }
3436 
ConstructFlowbuf(napi_env env,napi_value argv,int & fd,size_t & scriptLength)3437 ErrCode NapiWebviewController::ConstructFlowbuf(napi_env env, napi_value argv, int& fd, size_t& scriptLength)
3438 {
3439     auto flowbufferAdapter = OhosAdapterHelper::GetInstance().CreateFlowbufferAdapter();
3440     if (!flowbufferAdapter) {
3441         return NWebError::NEW_OOM;
3442     }
3443     flowbufferAdapter->StartPerformanceBoost();
3444 
3445     napi_valuetype valueType = napi_undefined;
3446     napi_typeof(env, argv, &valueType);
3447 
3448     ErrCode constructResult = (valueType == napi_string) ?
3449         NapiParseUtils::ConstructStringFlowbuf(env, argv, fd, scriptLength) :
3450         NapiParseUtils::ConstructArrayBufFlowbuf(env, argv, fd, scriptLength);
3451     return constructResult;
3452 }
3453 
RunJSBackToOriginal(napi_env env,napi_callback_info info,bool extention,napi_value argv,napi_value result)3454 napi_value NapiWebviewController::RunJSBackToOriginal(napi_env env, napi_callback_info info,
3455     bool extention, napi_value argv, napi_value result)
3456 {
3457     std::string script;
3458     napi_valuetype valueType = napi_undefined;
3459     napi_typeof(env, argv, &valueType);
3460     bool parseResult = (valueType == napi_string) ? NapiParseUtils::ParseString(env, argv, script) :
3461         NapiParseUtils::ParseArrayBuffer(env, argv, script);
3462     if (!parseResult) {
3463         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
3464         return result;
3465     }
3466     return RunJavaScriptInternal(env, info, script, extention);
3467 }
3468 
RunJavaScriptInternalExt(napi_env env,napi_callback_info info,bool extention)3469 napi_value NapiWebviewController::RunJavaScriptInternalExt(napi_env env, napi_callback_info info, bool extention)
3470 {
3471     napi_value thisVar = nullptr;
3472     napi_value result = nullptr;
3473     size_t argc = INTEGER_ONE;
3474     size_t argcPromise = INTEGER_ONE;
3475     size_t argcCallback = INTEGER_TWO;
3476     napi_value argv[INTEGER_TWO] = {0};
3477 
3478     napi_get_undefined(env, &result);
3479     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3480 
3481     int fd;
3482     size_t scriptLength;
3483     ErrCode constructResult = ConstructFlowbuf(env, argv[INTEGER_ZERO], fd, scriptLength);
3484     if (constructResult != NO_ERROR) {
3485         return RunJSBackToOriginal(env, info, extention, argv[INTEGER_ZERO], result);
3486     }
3487     usedFd_++;
3488 
3489     WebviewController *webviewController = nullptr;
3490     napi_unwrap(env, thisVar, (void **)&webviewController);
3491 
3492     if (!webviewController || !webviewController->IsInit()) {
3493         close(fd);
3494         usedFd_--;
3495         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3496         return result;
3497     }
3498 
3499     if (argc == argcCallback) {
3500         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3501         napi_ref jsCallback = nullptr;
3502         napi_create_reference(env, argv[argcCallback - 1], 1, &jsCallback);
3503 
3504         if (jsCallback) {
3505             // RunJavaScriptCallbackExt will close fd after IPC
3506             webviewController->RunJavaScriptCallbackExt(fd, scriptLength, env, std::move(jsCallback), extention);
3507         }
3508         usedFd_--;
3509         return result;
3510     } else if (argc == argcPromise) {
3511         napi_deferred deferred = nullptr;
3512         napi_value promise = nullptr;
3513         napi_create_promise(env, &deferred, &promise);
3514         if (promise && deferred) {
3515             // RunJavaScriptCallbackExt will close fd after IPC
3516             webviewController->RunJavaScriptPromiseExt(fd, scriptLength, env, deferred, extention);
3517         }
3518         usedFd_--;
3519         return promise;
3520     }
3521     close(fd);
3522     usedFd_--;
3523     return result;
3524 }
3525 
GetUrl(napi_env env,napi_callback_info info)3526 napi_value NapiWebviewController::GetUrl(napi_env env, napi_callback_info info)
3527 {
3528     napi_value result = nullptr;
3529     WebviewController *webviewController = GetWebviewController(env, info);
3530     if (!webviewController) {
3531         return nullptr;
3532     }
3533 
3534     std::string url = "";
3535     url = webviewController->GetUrl();
3536     napi_create_string_utf8(env, url.c_str(), url.length(), &result);
3537 
3538     return result;
3539 }
3540 
GetOriginalUrl(napi_env env,napi_callback_info info)3541 napi_value NapiWebviewController::GetOriginalUrl(napi_env env, napi_callback_info info)
3542 {
3543     napi_value result = nullptr;
3544     WebviewController *webviewController = GetWebviewController(env, info);
3545     if (!webviewController) {
3546         return nullptr;
3547     }
3548 
3549     std::string url = "";
3550     url = webviewController->GetOriginalUrl();
3551     napi_create_string_utf8(env, url.c_str(), url.length(), &result);
3552     return result;
3553 }
3554 
TerminateRenderProcess(napi_env env,napi_callback_info info)3555 napi_value NapiWebviewController::TerminateRenderProcess(napi_env env, napi_callback_info info)
3556 {
3557     napi_value result = nullptr;
3558     WebviewController *webviewController = GetWebviewController(env, info);
3559     if (!webviewController) {
3560         return nullptr;
3561     }
3562     bool ret = false;
3563     ret = webviewController->TerminateRenderProcess();
3564     NAPI_CALL(env, napi_get_boolean(env, ret, &result));
3565     return result;
3566 }
3567 
SetNetworkAvailable(napi_env env,napi_callback_info info)3568 napi_value NapiWebviewController::SetNetworkAvailable(napi_env env, napi_callback_info info)
3569 {
3570     napi_value thisVar = nullptr;
3571     napi_value result = nullptr;
3572     size_t argc = INTEGER_ONE;
3573     napi_value argv[INTEGER_ONE] = { 0 };
3574     bool enable;
3575 
3576     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3577     if (argc != INTEGER_ONE) {
3578         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3579             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3580         return result;
3581     }
3582 
3583     if (!NapiParseUtils::ParseBoolean(env, argv[0], enable)) {
3584         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3585             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "enable", "booleane"));
3586         return result;
3587     }
3588 
3589     WebviewController *webviewController = nullptr;
3590     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
3591     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
3592         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3593         return nullptr;
3594     }
3595     webviewController->PutNetworkAvailable(enable);
3596     return result;
3597 }
3598 
InnerGetWebId(napi_env env,napi_callback_info info)3599 napi_value NapiWebviewController::InnerGetWebId(napi_env env, napi_callback_info info)
3600 {
3601     napi_value thisVar = nullptr;
3602     napi_value result = nullptr;
3603     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3604 
3605     WebviewController *webviewController = nullptr;
3606     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
3607     int32_t webId = -1;
3608     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
3609         WVLOG_E("Init error. The WebviewController must be associated with a Web component.");
3610         napi_create_int32(env, webId, &result);
3611         return result;
3612     }
3613 
3614     webId = webviewController->GetWebId();
3615     napi_create_int32(env, webId, &result);
3616 
3617     return result;
3618 }
3619 
HasImage(napi_env env,napi_callback_info info)3620 napi_value NapiWebviewController::HasImage(napi_env env, napi_callback_info info)
3621 {
3622     napi_value thisVar = nullptr;
3623     napi_value result = nullptr;
3624     size_t argc = INTEGER_ONE;
3625     size_t argcPromiseParaNum = INTEGER_ZERO;
3626     size_t argcCallbackParaNum = INTEGER_ONE;
3627     napi_value argv[INTEGER_ONE] = { 0 };
3628 
3629     napi_get_undefined(env, &result);
3630     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3631 
3632     if (argc != argcPromiseParaNum && argc != argcCallbackParaNum) {
3633         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
3634             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "zero", "one"));
3635         return result;
3636     }
3637 
3638     if (argc == argcCallbackParaNum) {
3639         napi_valuetype valueType = napi_null;
3640         napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3641         napi_typeof(env, argv[argcCallbackParaNum - 1], &valueType);
3642         if (valueType != napi_function) {
3643             NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
3644                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
3645             return result;
3646         }
3647     }
3648     return HasImageInternal(env, info);
3649 }
3650 
HasImageInternal(napi_env env,napi_callback_info info)3651 napi_value NapiWebviewController::HasImageInternal(napi_env env, napi_callback_info info)
3652 {
3653     napi_value thisVar = nullptr;
3654     size_t argc = INTEGER_ONE;
3655     size_t argcPromiseParaNum = INTEGER_ZERO;
3656     size_t argcCallbackParaNum = INTEGER_ONE;
3657     napi_value argv[INTEGER_ONE] = { 0 };
3658 
3659     napi_value result = nullptr;
3660     napi_get_undefined(env, &result);
3661     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3662 
3663     WebviewController *webviewController = nullptr;
3664     napi_unwrap(env, thisVar, (void **)&webviewController);
3665 
3666     if (!webviewController || !webviewController->IsInit()) {
3667         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3668         return result;
3669     }
3670 
3671     if (argc == argcCallbackParaNum) {
3672         napi_ref jsCallback = nullptr;
3673         napi_create_reference(env, argv[argcCallbackParaNum - 1], 1, &jsCallback);
3674 
3675         if (jsCallback) {
3676             ErrCode ret = webviewController->HasImagesCallback(env, std::move(jsCallback));
3677             if (ret == NWEB_ERROR) {
3678                 return nullptr;
3679             } else if (ret != NO_ERROR) {
3680                 BusinessError::ThrowErrorByErrcode(env, ret);
3681                 return nullptr;
3682             }
3683         }
3684         return result;
3685     } else if (argc == argcPromiseParaNum) {
3686         napi_deferred deferred = nullptr;
3687         napi_value promise = nullptr;
3688         napi_create_promise(env, &deferred, &promise);
3689         if (promise && deferred) {
3690             ErrCode ret = webviewController->HasImagesPromise(env, deferred);
3691             if (ret == NWEB_ERROR) {
3692                 return nullptr;
3693             } else if (ret != NO_ERROR) {
3694                 BusinessError::ThrowErrorByErrcode(env, ret);
3695                 return nullptr;
3696             }
3697         }
3698         return promise;
3699     }
3700     return result;
3701 }
3702 
RemoveCache(napi_env env,napi_callback_info info)3703 napi_value NapiWebviewController::RemoveCache(napi_env env, napi_callback_info info)
3704 {
3705     napi_value thisVar = nullptr;
3706     napi_value result = nullptr;
3707     size_t argc = INTEGER_ONE;
3708     napi_value argv[INTEGER_ONE] = { 0 };
3709     bool includeDiskFiles;
3710 
3711     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
3712     if (argc != INTEGER_ONE) {
3713         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3714             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3715         return result;
3716     }
3717 
3718     if (!NapiParseUtils::ParseBoolean(env, argv[0], includeDiskFiles)) {
3719         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3720             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "clearRom", "boolean"));
3721         return result;
3722     }
3723 
3724     WebviewController *webviewController = nullptr;
3725     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
3726     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
3727         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3728         return nullptr;
3729     }
3730     webviewController->RemoveCache(includeDiskFiles);
3731     return result;
3732 }
3733 
IsIncognitoMode(napi_env env,napi_callback_info info)3734 napi_value NapiWebviewController::IsIncognitoMode(napi_env env, napi_callback_info info)
3735 {
3736     napi_value result = nullptr;
3737     WebviewController *webviewController = GetWebviewController(env, info);
3738     if (!webviewController) {
3739         return nullptr;
3740     }
3741 
3742     bool incognitoMode = false;
3743     incognitoMode = webviewController->IsIncognitoMode();
3744     NAPI_CALL(env, napi_get_boolean(env, incognitoMode, &result));
3745     return result;
3746 }
3747 
JsConstructor(napi_env env,napi_callback_info info)3748 napi_value NapiWebHistoryList::JsConstructor(napi_env env, napi_callback_info info)
3749 {
3750     napi_value thisVar = nullptr;
3751     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3752     return thisVar;
3753 }
3754 
getColorType(ImageColorType colorType)3755 Media::PixelFormat getColorType(ImageColorType colorType)
3756 {
3757     Media::PixelFormat pixelFormat_;
3758     switch (colorType) {
3759         case ImageColorType::COLOR_TYPE_UNKNOWN:
3760             pixelFormat_ = Media::PixelFormat::UNKNOWN;
3761             break;
3762         case ImageColorType::COLOR_TYPE_RGBA_8888:
3763             pixelFormat_ = Media::PixelFormat::RGBA_8888;
3764             break;
3765         case ImageColorType::COLOR_TYPE_BGRA_8888:
3766             pixelFormat_ = Media::PixelFormat::BGRA_8888;
3767             break;
3768         default:
3769             pixelFormat_ = Media::PixelFormat::UNKNOWN;
3770             break;
3771     }
3772     return pixelFormat_;
3773 }
3774 
getAlphaType(ImageAlphaType alphaType)3775 Media::AlphaType getAlphaType(ImageAlphaType alphaType)
3776 {
3777     Media::AlphaType alphaType_;
3778     switch (alphaType) {
3779         case ImageAlphaType::ALPHA_TYPE_UNKNOWN:
3780             alphaType_ = Media::AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN;
3781             break;
3782         case ImageAlphaType::ALPHA_TYPE_OPAQUE:
3783             alphaType_ = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
3784             break;
3785         case ImageAlphaType::ALPHA_TYPE_PREMULTIPLIED:
3786             alphaType_ = Media::AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
3787             break;
3788         case ImageAlphaType::ALPHA_TYPE_POSTMULTIPLIED:
3789             alphaType_ = Media::AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL;
3790             break;
3791         default:
3792             alphaType_ = Media::AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN;
3793             break;
3794     }
3795     return alphaType_;
3796 }
3797 
GetFavicon(napi_env env,std::shared_ptr<NWebHistoryItem> item)3798 napi_value NapiWebHistoryList::GetFavicon(napi_env env, std::shared_ptr<NWebHistoryItem> item)
3799 {
3800     napi_value result = nullptr;
3801     void *data = nullptr;
3802     int32_t width = 0;
3803     int32_t height = 0;
3804     ImageColorType colorType = ImageColorType::COLOR_TYPE_UNKNOWN;
3805     ImageAlphaType alphaType = ImageAlphaType::ALPHA_TYPE_UNKNOWN;
3806     bool isGetFavicon = item->GetFavicon(&data, width, height, colorType, alphaType);
3807     napi_get_null(env, &result);
3808 
3809     if (!isGetFavicon) {
3810         return result;
3811     }
3812 
3813     Media::InitializationOptions opt;
3814     opt.size.width = width;
3815     opt.size.height = height;
3816     opt.pixelFormat = getColorType(colorType);
3817     opt.alphaType = getAlphaType(alphaType);
3818     opt.editable = true;
3819     auto pixelMap = Media::PixelMap::Create(opt);
3820     if (pixelMap == nullptr) {
3821         return result;
3822     }
3823     uint64_t stride = static_cast<uint64_t>(width) << 2;
3824     uint64_t bufferSize = stride * static_cast<uint64_t>(height);
3825     pixelMap->WritePixels(static_cast<const uint8_t *>(data), bufferSize);
3826     std::shared_ptr<Media::PixelMap> pixelMapToJs(pixelMap.release());
3827     napi_value jsPixelMap = OHOS::Media::PixelMapNapi::CreatePixelMap(env, pixelMapToJs);
3828     return jsPixelMap;
3829 }
3830 
GetItem(napi_env env,napi_callback_info info)3831 napi_value NapiWebHistoryList::GetItem(napi_env env, napi_callback_info info)
3832 {
3833     napi_value thisVar = nullptr;
3834     napi_value result = nullptr;
3835     size_t argc = INTEGER_ONE;
3836     napi_value argv[INTEGER_ONE] = { 0 };
3837     int32_t index;
3838     WebHistoryList *historyList = nullptr;
3839 
3840     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
3841     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&historyList));
3842     if (historyList == nullptr) {
3843         WVLOG_E("unwrap historyList failed.");
3844         return result;
3845     }
3846     if (argc != INTEGER_ONE) {
3847         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3848             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
3849         return result;
3850     }
3851     if (!NapiParseUtils::ParseInt32(env, argv[0], index)) {
3852         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3853             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NOT_NULL_TWO, "index", "int"));
3854         return result;
3855     }
3856     if (index >= historyList->GetListSize() || index < 0) {
3857         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
3858             "BusinessError 401: Parameter error. The value of index must be greater than or equal to 0");
3859         return result;
3860     }
3861 
3862     std::shared_ptr<NWebHistoryItem> item = historyList->GetItem(index);
3863     if (!item) {
3864         return result;
3865     }
3866 
3867     napi_create_object(env, &result);
3868     std::string historyUrl = item->GetHistoryUrl();
3869     std::string historyRawUrl = item->GetHistoryRawUrl();
3870     std::string title = item->GetHistoryTitle();
3871 
3872     napi_value js_historyUrl;
3873     napi_create_string_utf8(env, historyUrl.c_str(), historyUrl.length(), &js_historyUrl);
3874     napi_set_named_property(env, result, "historyUrl", js_historyUrl);
3875 
3876     napi_value js_historyRawUrl;
3877     napi_create_string_utf8(env, historyRawUrl.c_str(), historyRawUrl.length(), &js_historyRawUrl);
3878     napi_set_named_property(env, result, "historyRawUrl", js_historyRawUrl);
3879 
3880     napi_value js_title;
3881     napi_create_string_utf8(env, title.c_str(), title.length(), &js_title);
3882     napi_set_named_property(env, result, "title", js_title);
3883 
3884     napi_value js_icon = GetFavicon(env, item);
3885     napi_set_named_property(env, result, "icon", js_icon);
3886     return result;
3887 }
3888 
getBackForwardEntries(napi_env env,napi_callback_info info)3889 napi_value NapiWebviewController::getBackForwardEntries(napi_env env, napi_callback_info info)
3890 {
3891     napi_value thisVar = nullptr;
3892     napi_value result = nullptr;
3893     WebviewController *webviewController = nullptr;
3894 
3895     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr));
3896     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
3897     if (webviewController == nullptr || !webviewController->IsInit()) {
3898         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3899         return nullptr;
3900     }
3901 
3902     std::shared_ptr<NWebHistoryList> list = webviewController->GetHistoryList();
3903     if (!list) {
3904         return result;
3905     }
3906 
3907     int32_t currentIndex = list->GetCurrentIndex();
3908     int32_t size = list->GetListSize();
3909 
3910     napi_value historyList = nullptr;
3911     NAPI_CALL(env, napi_get_reference_value(env, g_historyListRef, &historyList));
3912     NAPI_CALL(env, napi_new_instance(env, historyList, 0, NULL, &result));
3913 
3914     napi_value js_currentIndex;
3915     napi_create_int32(env, currentIndex, &js_currentIndex);
3916     napi_set_named_property(env, result, "currentIndex", js_currentIndex);
3917 
3918     napi_value js_size;
3919     napi_create_int32(env, size, &js_size);
3920     napi_set_named_property(env, result, "size", js_size);
3921 
3922     WebHistoryList *webHistoryList = new (std::nothrow) WebHistoryList(list);
3923     if (webHistoryList == nullptr) {
3924         return result;
3925     }
3926 
3927     NAPI_CALL(env, napi_wrap(env, result, webHistoryList,
3928         [](napi_env env, void *data, void *hint) {
3929             WebHistoryList *webHistoryList = static_cast<WebHistoryList *>(data);
3930             delete webHistoryList;
3931         },
3932         nullptr, nullptr));
3933 
3934     return result;
3935 }
3936 
GetFavicon(napi_env env,napi_callback_info info)3937 napi_value NapiWebviewController::GetFavicon(napi_env env, napi_callback_info info)
3938 {
3939     napi_value thisVar = nullptr;
3940     napi_value result = nullptr;
3941     napi_get_null(env, &result);
3942     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3943 
3944     WebviewController *webviewController = nullptr;
3945     napi_unwrap(env, thisVar, (void **)&webviewController);
3946 
3947     if (!webviewController || !webviewController->IsInit()) {
3948         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3949         return result;
3950     }
3951 
3952     const void *data = nullptr;
3953     size_t width = 0;
3954     size_t height = 0;
3955     ImageColorType colorType = ImageColorType::COLOR_TYPE_UNKNOWN;
3956     ImageAlphaType alphaType = ImageAlphaType::ALPHA_TYPE_UNKNOWN;
3957     bool isGetFavicon = webviewController->GetFavicon(&data, width, height, colorType, alphaType);
3958     if (!isGetFavicon) {
3959         return result;
3960     }
3961 
3962     Media::InitializationOptions opt;
3963     opt.size.width = static_cast<int32_t>(width);
3964     opt.size.height = static_cast<int32_t>(height);
3965     opt.pixelFormat = getColorType(colorType);
3966     opt.alphaType = getAlphaType(alphaType);
3967     opt.editable = true;
3968     auto pixelMap = Media::PixelMap::Create(opt);
3969     if (pixelMap == nullptr) {
3970         return result;
3971     }
3972     uint64_t stride = static_cast<uint64_t>(width) << 2;
3973     uint64_t bufferSize = stride * static_cast<uint64_t>(height);
3974     pixelMap->WritePixels(static_cast<const uint8_t *>(data), bufferSize);
3975     std::shared_ptr<Media::PixelMap> pixelMapToJs(pixelMap.release());
3976     napi_value jsPixelMap = OHOS::Media::PixelMapNapi::CreatePixelMap(env, pixelMapToJs);
3977     return jsPixelMap;
3978 }
3979 
SerializeWebState(napi_env env,napi_callback_info info)3980 napi_value NapiWebviewController::SerializeWebState(napi_env env, napi_callback_info info)
3981 {
3982     napi_value thisVar = nullptr;
3983     napi_value result = nullptr;
3984     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
3985     napi_get_null(env, &result);
3986 
3987     WebviewController *webviewController = nullptr;
3988     napi_unwrap(env, thisVar, (void **)&webviewController);
3989     if (!webviewController || !webviewController->IsInit()) {
3990         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
3991         return result;
3992     }
3993 
3994     void *data = nullptr;
3995     napi_value buffer = nullptr;
3996     auto webState = webviewController->SerializeWebState();
3997 
3998     NAPI_CALL(env, napi_create_arraybuffer(env, webState.size(), &data, &buffer));
3999     int retCode = memcpy_s(data, webState.size(), webState.data(), webState.size());
4000     if (retCode != 0) {
4001         return result;
4002     }
4003     NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, webState.size(), buffer, 0, &result));
4004     return result;
4005 }
4006 
RestoreWebState(napi_env env,napi_callback_info info)4007 napi_value NapiWebviewController::RestoreWebState(napi_env env, napi_callback_info info)
4008 {
4009     napi_value thisVar = nullptr;
4010     napi_value result = nullptr;
4011     size_t argc = INTEGER_ONE;
4012     napi_value argv[INTEGER_ONE] = { 0 };
4013     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
4014     napi_get_null(env, &result);
4015 
4016     WebviewController *webviewController = nullptr;
4017     napi_unwrap(env, thisVar, (void **)&webviewController);
4018     if (!webviewController || !webviewController->IsInit()) {
4019         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4020         return result;
4021     }
4022 
4023     bool isTypedArray = false;
4024     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4025     if (argc != INTEGER_ONE) {
4026         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4027             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4028         return result;
4029     }
4030     NAPI_CALL(env, napi_is_typedarray(env, argv[0], &isTypedArray));
4031     if (!isTypedArray) {
4032         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4033             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "state", "uint8Array"));
4034         return result;
4035     }
4036 
4037     napi_typedarray_type type;
4038     size_t length = 0;
4039     napi_value buffer = nullptr;
4040     size_t offset = 0;
4041     NAPI_CALL(env, napi_get_typedarray_info(env, argv[0], &type, &length, nullptr, &buffer, &offset));
4042     if (type != napi_uint8_array) {
4043         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4044             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "state", "uint8Array"));
4045         return result;
4046     }
4047     uint8_t *data = nullptr;
4048     size_t total = 0;
4049     NAPI_CALL(env, napi_get_arraybuffer_info(env, buffer, reinterpret_cast<void **>(&data), &total));
4050     length = std::min<size_t>(length, total - offset);
4051     std::vector<uint8_t> state(length);
4052     int retCode = memcpy_s(state.data(), state.size(), &data[offset], length);
4053     if (retCode != 0) {
4054         return result;
4055     }
4056     webviewController->RestoreWebState(state);
4057     return result;
4058 }
4059 
ScrollPageDown(napi_env env,napi_callback_info info)4060 napi_value NapiWebviewController::ScrollPageDown(napi_env env, napi_callback_info info)
4061 {
4062     napi_value thisVar = nullptr;
4063     napi_value result = nullptr;
4064     size_t argc = INTEGER_ONE;
4065     napi_value argv[INTEGER_ONE] = { 0 };
4066     bool bottom;
4067 
4068     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4069     if (argc != INTEGER_ONE) {
4070         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4071             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4072         return result;
4073     }
4074 
4075     if (!NapiParseUtils::ParseBoolean(env, argv[0], bottom)) {
4076         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4077             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "bottom", "booleane"));
4078         return result;
4079     }
4080 
4081     WebviewController *webviewController = nullptr;
4082     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4083     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4084         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4085         return nullptr;
4086     }
4087     webviewController->ScrollPageDown(bottom);
4088     return result;
4089 }
4090 
ScrollPageUp(napi_env env,napi_callback_info info)4091 napi_value NapiWebviewController::ScrollPageUp(napi_env env, napi_callback_info info)
4092 {
4093     napi_value thisVar = nullptr;
4094     napi_value result = nullptr;
4095     size_t argc = INTEGER_ONE;
4096     napi_value argv[INTEGER_ONE] = { 0 };
4097     bool top;
4098 
4099     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4100     if (argc != INTEGER_ONE) {
4101         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4102             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4103         return result;
4104     }
4105 
4106     if (!NapiParseUtils::ParseBoolean(env, argv[0], top)) {
4107         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4108             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "top", "booleane"));
4109         return result;
4110     }
4111 
4112     WebviewController *webviewController = nullptr;
4113     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4114     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4115         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4116         return nullptr;
4117     }
4118     webviewController->ScrollPageUp(top);
4119     return result;
4120 }
4121 
CheckSchemeName(const std::string & schemeName)4122 bool CheckSchemeName(const std::string& schemeName)
4123 {
4124     if (schemeName.empty() || schemeName.size() > MAX_CUSTOM_SCHEME_NAME_LENGTH) {
4125         WVLOG_E("Invalid scheme name length");
4126         return false;
4127     }
4128     for (auto it = schemeName.begin(); it != schemeName.end(); it++) {
4129         char chr = *it;
4130         if (!((chr >= 'a' && chr <= 'z') || (chr >= '0' && chr <= '9') ||
4131             (chr == '.') || (chr == '+') || (chr == '-'))) {
4132             WVLOG_E("invalid character %{public}c", chr);
4133             return false;
4134         }
4135     }
4136     return true;
4137 }
4138 
SetCustomizeSchemeOption(Scheme & scheme)4139 void SetCustomizeSchemeOption(Scheme& scheme)
4140 {
4141     std::map<int, std::function<bool(const Scheme&)>> schemeProperties = {
4142         {0, [](const Scheme& scheme) { return scheme.isStandard; }},
4143         {1, [](const Scheme& scheme) { return scheme.isLocal; }},
4144         {2, [](const Scheme& scheme) { return scheme.isDisplayIsolated; }},
4145         {3, [](const Scheme& scheme) { return scheme.isSecure; }},
4146         {4, [](const Scheme& scheme) { return scheme.isSupportCORS; }},
4147         {5, [](const Scheme& scheme) { return scheme.isCspBypassing; }},
4148         {6, [](const Scheme& scheme) { return scheme.isSupportFetch; }},
4149         {7, [](const Scheme& scheme) { return scheme.isCodeCacheSupported; }}
4150     };
4151 
4152     for (const auto& property : schemeProperties) {
4153         if (property.second(scheme)) {
4154             scheme.option += 1 << property.first;
4155         }
4156     }
4157 }
4158 
SetCustomizeScheme(napi_env env,napi_value obj,Scheme & scheme)4159 bool SetCustomizeScheme(napi_env env, napi_value obj, Scheme& scheme)
4160 {
4161     std::map<std::string, std::function<void(Scheme&, bool)>> schemeBooleanProperties = {
4162         {"isSupportCORS", [](Scheme& scheme, bool value) { scheme.isSupportCORS = value; }},
4163         {"isSupportFetch", [](Scheme& scheme, bool value) { scheme.isSupportFetch = value; }},
4164         {"isStandard", [](Scheme& scheme, bool value) { scheme.isStandard = value; }},
4165         {"isLocal", [](Scheme& scheme, bool value) { scheme.isLocal = value; }},
4166         {"isDisplayIsolated", [](Scheme& scheme, bool value) { scheme.isDisplayIsolated = value; }},
4167         {"isSecure", [](Scheme& scheme, bool value) { scheme.isSecure = value; }},
4168         {"isCspBypassing", [](Scheme& scheme, bool value) { scheme.isCspBypassing = value; }},
4169         {"isCodeCacheSupported", [](Scheme& scheme, bool value) { scheme.isCodeCacheSupported = value; }}
4170     };
4171 
4172     for (const auto& property : schemeBooleanProperties) {
4173         napi_value propertyObj = nullptr;
4174         napi_get_named_property(env, obj, property.first.c_str(), &propertyObj);
4175         bool schemeProperty = false;
4176         if (!NapiParseUtils::ParseBoolean(env, propertyObj, schemeProperty)) {
4177             if (property.first == "isSupportCORS" || property.first == "isSupportFetch") {
4178                 return false;
4179             }
4180         }
4181         property.second(scheme, schemeProperty);
4182     }
4183 
4184     napi_value schemeNameObj = nullptr;
4185     if (napi_get_named_property(env, obj, "schemeName", &schemeNameObj) != napi_ok) {
4186         return false;
4187     }
4188     if (!NapiParseUtils::ParseString(env, schemeNameObj, scheme.name)) {
4189         return false;
4190     }
4191 
4192     if (!CheckSchemeName(scheme.name)) {
4193         return false;
4194     }
4195 
4196     SetCustomizeSchemeOption(scheme);
4197     return true;
4198 }
4199 
CustomizeSchemesArrayDataHandler(napi_env env,napi_value array)4200 int32_t CustomizeSchemesArrayDataHandler(napi_env env, napi_value array)
4201 {
4202     uint32_t arrayLength = 0;
4203     napi_get_array_length(env, array, &arrayLength);
4204     if (arrayLength > MAX_CUSTOM_SCHEME_SIZE) {
4205         return PARAM_CHECK_ERROR;
4206     }
4207     std::vector<Scheme> schemeVector;
4208     for (uint32_t i = 0; i < arrayLength; ++i) {
4209         napi_value obj = nullptr;
4210         napi_get_element(env, array, i, &obj);
4211         Scheme scheme;
4212         bool result = SetCustomizeScheme(env, obj, scheme);
4213         if (!result) {
4214             return PARAM_CHECK_ERROR;
4215         }
4216         schemeVector.push_back(scheme);
4217     }
4218     int32_t registerResult;
4219     for (auto it = schemeVector.begin(); it != schemeVector.end(); ++it) {
4220         registerResult = OH_ArkWeb_RegisterCustomSchemes(it->name.c_str(), it->option);
4221         if (registerResult != NO_ERROR) {
4222             return registerResult;
4223         }
4224     }
4225     return NO_ERROR;
4226 }
4227 
CustomizeSchemes(napi_env env,napi_callback_info info)4228 napi_value NapiWebviewController::CustomizeSchemes(napi_env env, napi_callback_info info)
4229 {
4230     if (WebviewController::existNweb_) {
4231         WVLOG_E("There exist web component which has been already created.");
4232     }
4233 
4234     napi_value result = nullptr;
4235     napi_value thisVar = nullptr;
4236     size_t argc = INTEGER_ONE;
4237     napi_value argv[INTEGER_ONE];
4238     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4239     if (argc != INTEGER_ONE) {
4240         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4241             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4242         return nullptr;
4243     }
4244     napi_value array = argv[INTEGER_ZERO];
4245     bool isArray = false;
4246     napi_is_array(env, array, &isArray);
4247     if (!isArray) {
4248         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4249             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "schemes", "array"));
4250         return nullptr;
4251     }
4252     int32_t registerResult = CustomizeSchemesArrayDataHandler(env, array);
4253     if (registerResult == NO_ERROR) {
4254         NAPI_CALL(env, napi_get_undefined(env, &result));
4255         return result;
4256     }
4257     if (registerResult == PARAM_CHECK_ERROR) {
4258         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4259             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "schemeName", "string"));
4260         return nullptr;
4261     }
4262     BusinessError::ThrowErrorByErrcode(env, REGISTER_CUSTOM_SCHEME_FAILED);
4263     return nullptr;
4264 }
4265 
ScrollTo(napi_env env,napi_callback_info info)4266 napi_value NapiWebviewController::ScrollTo(napi_env env, napi_callback_info info)
4267 {
4268     napi_value thisVar = nullptr;
4269     napi_value result = nullptr;
4270     size_t argc = INTEGER_THREE;
4271     napi_value argv[INTEGER_THREE] = { 0 };
4272     float x;
4273     float y;
4274     int32_t duration;
4275 
4276     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4277     if (argc != INTEGER_TWO && argc != INTEGER_THREE) {
4278         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4279             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "two", "three"));
4280         return result;
4281     }
4282 
4283     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ZERO], x)) {
4284         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4285             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "x", "number"));
4286         return result;
4287     }
4288 
4289     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ONE], y)) {
4290         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4291             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "y", "number"));
4292         return result;
4293     }
4294 
4295     if (argc == INTEGER_THREE) {
4296         if(!NapiParseUtils::ParseInt32(env, argv[INTEGER_TWO], duration)) {
4297             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4298                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "duration", "number"));
4299             return result;
4300         }
4301     }
4302 
4303     WebviewController *webviewController = nullptr;
4304     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4305     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4306         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4307         return nullptr;
4308     }
4309     if(argc == INTEGER_THREE) {
4310         webviewController->ScrollToWithAnime(x, y, duration);
4311     } else {
4312         webviewController->ScrollTo(x, y);
4313     }
4314     return result;
4315 }
4316 
ScrollBy(napi_env env,napi_callback_info info)4317 napi_value NapiWebviewController::ScrollBy(napi_env env, napi_callback_info info)
4318 {
4319     napi_value thisVar = nullptr;
4320     napi_value result = nullptr;
4321     size_t argc = INTEGER_THREE;
4322     napi_value argv[INTEGER_THREE] = { 0 };
4323     float deltaX;
4324     float deltaY;
4325     int32_t duration = 0;
4326 
4327     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4328     if (argc != INTEGER_TWO && argc != INTEGER_THREE) {
4329         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4330             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "two", "three"));
4331         return result;
4332     }
4333 
4334     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ZERO], deltaX)) {
4335         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4336             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "deltaX", "number"));
4337         return result;
4338     }
4339 
4340     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ONE], deltaY)) {
4341         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4342             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "deltaY", "number"));
4343         return result;
4344     }
4345 
4346     if (argc == INTEGER_THREE) {
4347         if(!NapiParseUtils::ParseInt32(env, argv[INTEGER_TWO], duration)) {
4348             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4349                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "duration", "number"));
4350             return result;
4351         }
4352     }
4353 
4354     WebviewController *webviewController = nullptr;
4355     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4356     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4357         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4358         return nullptr;
4359     }
4360     if(argc == INTEGER_THREE) {
4361         webviewController->ScrollByWithAnime(deltaX, deltaY, duration);
4362     } else {
4363         webviewController->ScrollBy(deltaX, deltaY);
4364     }
4365     return result;
4366 }
4367 
SlideScroll(napi_env env,napi_callback_info info)4368 napi_value NapiWebviewController::SlideScroll(napi_env env, napi_callback_info info)
4369 {
4370     napi_value thisVar = nullptr;
4371     napi_value result = nullptr;
4372     size_t argc = INTEGER_TWO;
4373     napi_value argv[INTEGER_TWO] = { 0 };
4374     float vx;
4375     float vy;
4376 
4377     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4378     if (argc != INTEGER_TWO) {
4379         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4380             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "two"));
4381         return result;
4382     }
4383 
4384     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ZERO], vx)) {
4385         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4386             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "vx", "number"));
4387         return result;
4388     }
4389 
4390     if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ONE], vy)) {
4391         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4392             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "vy", "number"));
4393         return result;
4394     }
4395 
4396     WebviewController *webviewController = nullptr;
4397     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4398     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4399         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4400         return nullptr;
4401     }
4402     webviewController->SlideScroll(vx, vy);
4403     return result;
4404 }
4405 
SetScrollable(napi_env env,napi_callback_info info)4406 napi_value NapiWebviewController::SetScrollable(napi_env env, napi_callback_info info)
4407 {
4408     napi_value thisVar = nullptr;
4409     napi_value result = nullptr;
4410     size_t argc = INTEGER_TWO;
4411     size_t argcForOld = INTEGER_ONE;
4412     napi_value argv[INTEGER_TWO] = { 0 };
4413 
4414     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4415     if (argc != INTEGER_TWO && argc != argcForOld) {
4416         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
4417             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "one", "two"));
4418         return result;
4419     }
4420     bool isEnableScroll;
4421     if (!NapiParseUtils::ParseBoolean(env, argv[0], isEnableScroll)) {
4422         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4423             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "enable", "boolean"));
4424         return result;
4425     }
4426 
4427     int32_t scrollType = -1;
4428     if (argc == INTEGER_TWO) {
4429         if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ONE], scrollType) || scrollType < 0 ||
4430             scrollType >= INTEGER_ONE) {
4431             WVLOG_E("BusinessError: 401. The character of 'scrollType' must be int32.");
4432             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4433             return result;
4434         }
4435     }
4436 
4437     WebviewController* webviewController = nullptr;
4438     napi_status status = napi_unwrap(env, thisVar, (void**)&webviewController);
4439     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4440         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4441         return nullptr;
4442     }
4443     webviewController->SetScrollable(isEnableScroll, scrollType);
4444     return result;
4445 }
4446 
GetScrollable(napi_env env,napi_callback_info info)4447 napi_value NapiWebviewController::GetScrollable(napi_env env, napi_callback_info info)
4448 {
4449     napi_value result = nullptr;
4450     WebviewController *webviewController = GetWebviewController(env, info);
4451     if (!webviewController) {
4452         return nullptr;
4453     }
4454 
4455     bool isScrollable = webviewController->GetScrollable();
4456     NAPI_CALL(env, napi_get_boolean(env, isScrollable, &result));
4457     return result;
4458 }
4459 
InnerGetCertificate(napi_env env,napi_callback_info info)4460 napi_value NapiWebviewController::InnerGetCertificate(napi_env env, napi_callback_info info)
4461 {
4462     napi_value thisVar = nullptr;
4463     napi_value result = nullptr;
4464     napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
4465     napi_create_array(env, &result);
4466 
4467     WebviewController *webviewController = nullptr;
4468     napi_unwrap(env, thisVar, (void **)&webviewController);
4469     if (!webviewController || !webviewController->IsInit()) {
4470         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4471         return result;
4472     }
4473 
4474     std::vector<std::string> certChainDerData;
4475     bool ans = webviewController->GetCertChainDerData(certChainDerData);
4476     if (!ans) {
4477         WVLOG_E("get cert chain data failed");
4478         return result;
4479     }
4480 
4481     for (uint8_t i = 0; i < certChainDerData.size(); i++) {
4482         if (i == UINT8_MAX) {
4483             WVLOG_E("error, cert chain data array reach max");
4484             break;
4485         }
4486         void *data = nullptr;
4487         napi_value buffer = nullptr;
4488         napi_value item = nullptr;
4489         NAPI_CALL(env, napi_create_arraybuffer(env, certChainDerData[i].size(), &data, &buffer));
4490         int retCode = memcpy_s(data, certChainDerData[i].size(),
4491                                certChainDerData[i].data(), certChainDerData[i].size());
4492         if (retCode != 0) {
4493             WVLOG_E("memcpy_s cert data failed, index = %{public}u,", i);
4494             continue;
4495         }
4496         NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, certChainDerData[i].size(), buffer, 0, &item));
4497         NAPI_CALL(env, napi_set_element(env, result, i, item));
4498     }
4499     return result;
4500 }
4501 
SetAudioMuted(napi_env env,napi_callback_info info)4502 napi_value NapiWebviewController::SetAudioMuted(napi_env env, napi_callback_info info)
4503 {
4504     WVLOG_D("SetAudioMuted invoked");
4505 
4506     napi_value result = nullptr;
4507     NAPI_CALL(env, napi_get_undefined(env, &result));
4508 
4509     napi_value thisVar = nullptr;
4510     size_t argc = INTEGER_ONE;
4511     napi_value argv[INTEGER_ONE] = { 0 };
4512     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4513     if (argc != INTEGER_ONE) {
4514         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4515             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4516         return result;
4517     }
4518 
4519     bool muted = false;
4520     if (!NapiParseUtils::ParseBoolean(env, argv[0], muted)) {
4521         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4522             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "mute", "boolean"));
4523         return result;
4524     }
4525 
4526     WebviewController* webviewController = nullptr;
4527     napi_status status = napi_unwrap(env, thisVar, (void**)&webviewController);
4528     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4529         WVLOG_E("SetAudioMuted failed due to no associated Web component");
4530         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4531         return result;
4532     }
4533 
4534     ErrCode ret = webviewController->SetAudioMuted(muted);
4535     if (ret != NO_ERROR) {
4536         WVLOG_E("SetAudioMuted failed, error code: %{public}d", ret);
4537         BusinessError::ThrowErrorByErrcode(env, ret);
4538         return result;
4539     }
4540 
4541     WVLOG_I("SetAudioMuted: %{public}s", (muted ? "true" : "false"));
4542     return result;
4543 }
4544 
PrefetchPage(napi_env env,napi_callback_info info)4545 napi_value NapiWebviewController::PrefetchPage(napi_env env, napi_callback_info info)
4546 {
4547     napi_value thisVar = nullptr;
4548     napi_value result = nullptr;
4549     size_t argc = INTEGER_TWO;
4550     napi_value argv[INTEGER_TWO];
4551     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4552     WebviewController *webviewController = nullptr;
4553     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4554     if ((argc != INTEGER_ONE) && (argc != INTEGER_TWO)) {
4555         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4556         return nullptr;
4557     }
4558     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4559         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4560         return nullptr;
4561     }
4562     std::string url;
4563     if (!ParsePrepareUrl(env, argv[INTEGER_ZERO], url)) {
4564         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
4565         return nullptr;
4566     }
4567     std::map<std::string, std::string> additionalHttpHeaders;
4568     if (argc == INTEGER_ONE) {
4569         ErrCode ret = webviewController->PrefetchPage(url, additionalHttpHeaders);
4570         if (ret != NO_ERROR) {
4571             WVLOG_E("PrefetchPage failed, error code: %{public}d", ret);
4572             BusinessError::ThrowErrorByErrcode(env, ret);
4573             return nullptr;
4574         }
4575         NAPI_CALL(env, napi_get_undefined(env, &result));
4576         return result;
4577     }
4578     return PrefetchPageWithHttpHeaders(env, info, url, argv, webviewController);
4579 }
4580 
PrefetchPageWithHttpHeaders(napi_env env,napi_callback_info info,std::string & url,const napi_value * argv,WebviewController * webviewController)4581 napi_value NapiWebviewController::PrefetchPageWithHttpHeaders(napi_env env, napi_callback_info info, std::string& url,
4582     const napi_value* argv, WebviewController* webviewController)
4583 {
4584     napi_value result = nullptr;
4585     std::map<std::string, std::string> additionalHttpHeaders;
4586     napi_value array = argv[INTEGER_ONE];
4587     bool isArray = false;
4588     napi_is_array(env, array, &isArray);
4589     if (isArray) {
4590         uint32_t arrayLength = INTEGER_ZERO;
4591         napi_get_array_length(env, array, &arrayLength);
4592         for (uint32_t i = 0; i < arrayLength; ++i) {
4593             std::string key;
4594             std::string value;
4595             napi_value obj = nullptr;
4596             napi_value keyObj = nullptr;
4597             napi_value valueObj = nullptr;
4598             napi_get_element(env, array, i, &obj);
4599             if (napi_get_named_property(env, obj, "headerKey", &keyObj) != napi_ok) {
4600                 continue;
4601             }
4602             if (napi_get_named_property(env, obj, "headerValue", &valueObj) != napi_ok) {
4603                 continue;
4604             }
4605             NapiParseUtils::ParseString(env, keyObj, key);
4606             NapiParseUtils::ParseString(env, valueObj, value);
4607             additionalHttpHeaders[key] = value;
4608         }
4609     } else {
4610         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4611         return nullptr;
4612     }
4613 
4614     ErrCode ret = webviewController->PrefetchPage(url, additionalHttpHeaders);
4615     if (ret != NO_ERROR) {
4616         WVLOG_E("PrefetchPage failed, error code: %{public}d", ret);
4617         BusinessError::ThrowErrorByErrcode(env, ret);
4618         return nullptr;
4619     }
4620     NAPI_CALL(env, napi_get_undefined(env, &result));
4621     return result;
4622 }
4623 
GetLastJavascriptProxyCallingFrameUrl(napi_env env,napi_callback_info info)4624 napi_value NapiWebviewController::GetLastJavascriptProxyCallingFrameUrl(napi_env env, napi_callback_info info)
4625 {
4626     napi_value result = nullptr;
4627     WebviewController *webviewController = GetWebviewController(env, info);
4628     if (!webviewController) {
4629         return nullptr;
4630     }
4631 
4632     std::string lastCallingFrameUrl = webviewController->GetLastJavascriptProxyCallingFrameUrl();
4633     napi_create_string_utf8(env, lastCallingFrameUrl.c_str(), lastCallingFrameUrl.length(), &result);
4634     return result;
4635 }
4636 
PrepareForPageLoad(napi_env env,napi_callback_info info)4637 napi_value NapiWebviewController::PrepareForPageLoad(napi_env env, napi_callback_info info)
4638 {
4639     napi_value thisVar = nullptr;
4640     napi_value result = nullptr;
4641     size_t argc = INTEGER_THREE;
4642     napi_value argv[INTEGER_THREE] = { 0 };
4643     napi_get_undefined(env, &result);
4644     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4645     if (argc != INTEGER_THREE) {
4646         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4647         return nullptr;
4648     }
4649 
4650     std::string url;
4651     if (!ParsePrepareUrl(env, argv[INTEGER_ZERO], url)) {
4652         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
4653         return nullptr;
4654     }
4655 
4656     bool preconnectable = false;
4657     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ONE], preconnectable)) {
4658         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4659         return nullptr;
4660     }
4661 
4662     int32_t numSockets = 0;
4663     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_TWO], numSockets)) {
4664         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4665         return nullptr;
4666     }
4667     if (numSockets <= 0 || static_cast<uint32_t>(numSockets) > SOCKET_MAXIMUM) {
4668         BusinessError::ThrowErrorByErrcode(env, INVALID_SOCKET_NUMBER);
4669         return nullptr;
4670     }
4671 
4672     NWebHelper::Instance().PrepareForPageLoad(url, preconnectable, numSockets);
4673     NAPI_CALL(env, napi_get_undefined(env, &result));
4674     return result;
4675 }
4676 
PrefetchResource(napi_env env,napi_callback_info info)4677 napi_value NapiWebviewController::PrefetchResource(napi_env env, napi_callback_info info)
4678 {
4679     napi_value thisVar = nullptr;
4680     napi_value result = nullptr;
4681     size_t argc = INTEGER_FOUR;
4682     napi_value argv[INTEGER_FOUR] = { 0 };
4683     napi_get_undefined(env, &result);
4684     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4685     if (argc > INTEGER_FOUR || argc < INTEGER_ONE) {
4686         WVLOG_E("BusinessError: 401. Arg count must between 1 and 4.");
4687         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4688         return nullptr;
4689     }
4690 
4691     std::shared_ptr<NWebEnginePrefetchArgs> prefetchArgs = ParsePrefetchArgs(env, argv[INTEGER_ZERO]);
4692     if (prefetchArgs == nullptr) {
4693         return nullptr;
4694     }
4695 
4696     std::map<std::string, std::string> additionalHttpHeaders;
4697     if (argc >= INTEGER_TWO && !ParseHttpHeaders(env, argv[INTEGER_ONE], &additionalHttpHeaders)) {
4698         WVLOG_E("BusinessError: 401. The type of 'additionalHttpHeaders' must be Array of 'WebHeader'.");
4699         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4700         return nullptr;
4701     }
4702 
4703     std::string cacheKey;
4704     if ((argc >= INTEGER_THREE) && !NapiParseUtils::ParseString(env, argv[INTEGER_TWO], cacheKey)) {
4705         WVLOG_E("BusinessError: 401.The type of 'cacheKey' must be string.");
4706         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4707         return nullptr;
4708     }
4709 
4710     if (cacheKey.empty()) {
4711         cacheKey = prefetchArgs->GetUrl();
4712     } else {
4713         if (!CheckCacheKey(env, cacheKey)) {
4714             return nullptr;
4715         }
4716     }
4717 
4718     int32_t cacheValidTime = 0;
4719     if (argc >= INTEGER_FOUR) {
4720         if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_THREE], cacheValidTime) || cacheValidTime <= 0 ||
4721             cacheValidTime > INT_MAX) {
4722             WVLOG_E("BusinessError: 401. The character of 'cacheValidTime' must be int32.");
4723             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4724             return nullptr;
4725         }
4726     }
4727 
4728     NAPI_CALL(env, napi_get_undefined(env, &result));
4729     NWebHelper::Instance().PrefetchResource(prefetchArgs, additionalHttpHeaders, cacheKey, cacheValidTime);
4730     return result;
4731 }
4732 
CloseAllMediaPresentations(napi_env env,napi_callback_info info)4733 napi_value NapiWebviewController::CloseAllMediaPresentations(napi_env env, napi_callback_info info)
4734 {
4735     napi_value result = nullptr;
4736     WebviewController* webviewController = GetWebviewController(env, info);
4737     if (!webviewController) {
4738         return result;
4739     }
4740 
4741     webviewController->CloseAllMediaPresentations();
4742     NAPI_CALL(env, napi_get_undefined(env, &result));
4743     return result;
4744 }
4745 
StopAllMedia(napi_env env,napi_callback_info info)4746 napi_value NapiWebviewController::StopAllMedia(napi_env env, napi_callback_info info)
4747 {
4748     napi_value result = nullptr;
4749     WebviewController* webviewController = GetWebviewController(env, info);
4750     if (!webviewController) {
4751         return result;
4752     }
4753 
4754     webviewController->StopAllMedia();
4755     NAPI_CALL(env, napi_get_undefined(env, &result));
4756     return result;
4757 }
4758 
ResumeAllMedia(napi_env env,napi_callback_info info)4759 napi_value NapiWebviewController::ResumeAllMedia(napi_env env, napi_callback_info info)
4760 {
4761     napi_value result = nullptr;
4762     WebviewController* webviewController = GetWebviewController(env, info);
4763     if (!webviewController) {
4764         return result;
4765     }
4766 
4767     webviewController->ResumeAllMedia();
4768     NAPI_CALL(env, napi_get_undefined(env, &result));
4769     return result;
4770 }
4771 
PauseAllMedia(napi_env env,napi_callback_info info)4772 napi_value NapiWebviewController::PauseAllMedia(napi_env env, napi_callback_info info)
4773 {
4774     napi_value result = nullptr;
4775     WebviewController* webviewController = GetWebviewController(env, info);
4776     if (!webviewController) {
4777         return result;
4778     }
4779 
4780     webviewController->PauseAllMedia();
4781     NAPI_CALL(env, napi_get_undefined(env, &result));
4782     return result;
4783 }
4784 
GetMediaPlaybackState(napi_env env,napi_callback_info info)4785 napi_value NapiWebviewController::GetMediaPlaybackState(napi_env env, napi_callback_info info)
4786 {
4787     napi_value result = nullptr;
4788     WebviewController* webviewController = GetWebviewController(env, info);
4789     if (!webviewController) {
4790         return result;
4791     }
4792 
4793     int32_t mediaPlaybackState = webviewController->GetMediaPlaybackState();
4794     napi_create_int32(env, mediaPlaybackState, &result);
4795     return result;
4796 }
4797 
ClearPrefetchedResource(napi_env env,napi_callback_info info)4798 napi_value NapiWebviewController::ClearPrefetchedResource(napi_env env, napi_callback_info info)
4799 {
4800     napi_value thisVar = nullptr;
4801     napi_value result = nullptr;
4802     size_t argc = INTEGER_ONE;
4803     napi_value argv[INTEGER_ONE] = { 0 };
4804     napi_get_undefined(env, &result);
4805     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4806     if (argc != INTEGER_ONE) {
4807         WVLOG_E("BusinessError: 401. Arg count must be 1.");
4808         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4809         return nullptr;
4810     }
4811 
4812     std::vector<std::string> cacheKeyList;
4813     if (!ParseCacheKeyList(env, argv[INTEGER_ZERO], &cacheKeyList)) {
4814         WVLOG_E("BusinessError: 401. The type of 'cacheKeyList' must be Array of string.");
4815         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4816         return nullptr;
4817     }
4818 
4819     NAPI_CALL(env, napi_get_undefined(env, &result));
4820     NWebHelper::Instance().ClearPrefetchedResource(cacheKeyList);
4821     return result;
4822 }
4823 
CreateWebPrintDocumentAdapter(napi_env env,napi_callback_info info)4824 napi_value NapiWebviewController::CreateWebPrintDocumentAdapter(napi_env env, napi_callback_info info)
4825 {
4826     WVLOG_I("Create web print document adapter.");
4827     napi_value thisVar = nullptr;
4828     napi_value result = nullptr;
4829     size_t argc = INTEGER_ONE;
4830     napi_value argv[INTEGER_ONE];
4831     NAPI_CALL(env, napi_get_undefined(env, &result));
4832     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
4833     if (argc != INTEGER_ONE) {
4834         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4835             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
4836         return result;
4837     }
4838 
4839     std::string jobName;
4840     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], jobName)) {
4841         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
4842             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "jopName", "string"));
4843         return result;
4844     }
4845 
4846     WebviewController *webviewController = nullptr;
4847     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
4848     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
4849         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
4850         return result;
4851     }
4852     void* webPrintDocument = webviewController->CreateWebPrintDocumentAdapter(jobName);
4853     if (!webPrintDocument) {
4854         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4855         return result;
4856     }
4857 
4858     napi_value webPrintDoc = nullptr;
4859     NAPI_CALL(env, napi_get_reference_value(env, g_webPrintDocClassRef, &webPrintDoc));
4860     napi_value consParam[INTEGER_ONE] = {0};
4861     NAPI_CALL(env, napi_create_bigint_uint64(env, reinterpret_cast<uint64_t>(webPrintDocument),
4862                                              &consParam[INTEGER_ZERO]));
4863     napi_value proxy = nullptr;
4864     status = napi_new_instance(env, webPrintDoc, INTEGER_ONE, &consParam[INTEGER_ZERO], &proxy);
4865     if (status!= napi_ok) {
4866         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
4867         return result;
4868     }
4869     return proxy;
4870 }
4871 
GetSecurityLevel(napi_env env,napi_callback_info info)4872 napi_value NapiWebviewController::GetSecurityLevel(napi_env env, napi_callback_info info)
4873 {
4874     napi_value result = nullptr;
4875     WebviewController *webviewController = GetWebviewController(env, info);
4876     if (!webviewController) {
4877         return result;
4878     }
4879 
4880     int32_t securityLevel = webviewController->GetSecurityLevel();
4881     napi_create_int32(env, securityLevel, &result);
4882     return result;
4883 }
4884 
ParsePrintRangeAdapter(napi_env env,napi_value pageRange,PrintAttributesAdapter & printAttr)4885 void ParsePrintRangeAdapter(napi_env env, napi_value pageRange, PrintAttributesAdapter& printAttr)
4886 {
4887     if (!pageRange) {
4888         WVLOG_E("ParsePrintRangeAdapter failed.");
4889         return;
4890     }
4891     napi_value startPage = nullptr;
4892     napi_value endPage = nullptr;
4893     napi_value pages = nullptr;
4894     napi_get_named_property(env, pageRange, "startPage", &startPage);
4895     napi_get_named_property(env, pageRange, "endPage", &endPage);
4896     if (startPage) {
4897         NapiParseUtils::ParseUint32(env, startPage, printAttr.pageRange.startPage);
4898     }
4899     if (endPage) {
4900         NapiParseUtils::ParseUint32(env, endPage, printAttr.pageRange.endPage);
4901     }
4902     napi_get_named_property(env, pageRange, "pages", &pages);
4903     uint32_t pageArrayLength = 0;
4904     napi_get_array_length(env, pages, &pageArrayLength);
4905     for (uint32_t i = 0; i < pageArrayLength; ++i) {
4906         napi_value pagesNumObj = nullptr;
4907         napi_get_element(env, pages, i, &pagesNumObj);
4908         uint32_t pagesNum;
4909         NapiParseUtils::ParseUint32(env, pagesNumObj, pagesNum);
4910         printAttr.pageRange.pages.push_back(pagesNum);
4911     }
4912 }
4913 
ParsePrintPageSizeAdapter(napi_env env,napi_value pageSize,PrintAttributesAdapter & printAttr)4914 void ParsePrintPageSizeAdapter(napi_env env, napi_value pageSize, PrintAttributesAdapter& printAttr)
4915 {
4916     if (!pageSize) {
4917         WVLOG_E("ParsePrintPageSizeAdapter failed.");
4918         return;
4919     }
4920     napi_value id = nullptr;
4921     napi_value name = nullptr;
4922     napi_value width = nullptr;
4923     napi_value height = nullptr;
4924     napi_get_named_property(env, pageSize, "id", &id);
4925     napi_get_named_property(env, pageSize, "name", &name);
4926     napi_get_named_property(env, pageSize, "width", &width);
4927     napi_get_named_property(env, pageSize, "height", &height);
4928     if (width) {
4929         NapiParseUtils::ParseUint32(env, width, printAttr.pageSize.width);
4930     }
4931     if (height) {
4932         NapiParseUtils::ParseUint32(env, height, printAttr.pageSize.height);
4933     }
4934 }
4935 
ParsePrintMarginAdapter(napi_env env,napi_value margin,PrintAttributesAdapter & printAttr)4936 void ParsePrintMarginAdapter(napi_env env, napi_value margin, PrintAttributesAdapter& printAttr)
4937 {
4938     if (!margin) {
4939         WVLOG_E("ParsePrintMarginAdapter failed.");
4940         return;
4941     }
4942     napi_value top = nullptr;
4943     napi_value bottom = nullptr;
4944     napi_value left = nullptr;
4945     napi_value right = nullptr;
4946     napi_get_named_property(env, margin, "top", &top);
4947     napi_get_named_property(env, margin, "bottom", &bottom);
4948     napi_get_named_property(env, margin, "left", &left);
4949     napi_get_named_property(env, margin, "right", &right);
4950     if (top) {
4951         NapiParseUtils::ParseUint32(env, top, printAttr.margin.top);
4952     }
4953     if (bottom) {
4954         NapiParseUtils::ParseUint32(env, bottom, printAttr.margin.bottom);
4955     }
4956     if (left) {
4957         NapiParseUtils::ParseUint32(env, left, printAttr.margin.left);
4958     }
4959     if (right) {
4960         NapiParseUtils::ParseUint32(env, right, printAttr.margin.right);
4961     }
4962 }
4963 
ParseWebPrintWriteResultCallback(napi_env env,napi_value argv)4964 WebPrintWriteResultCallback ParseWebPrintWriteResultCallback(napi_env env, napi_value argv)
4965 {
4966     if (!argv) {
4967         WVLOG_E("ParseWebPrintWriteResultCallback failed.");
4968         return nullptr;
4969     }
4970     napi_ref jsCallback = nullptr;
4971     napi_create_reference(env, argv, 1, &jsCallback);
4972     if (jsCallback) {
4973         WebPrintWriteResultCallback callbackImpl =
4974             [env, jCallback = std::move(jsCallback)](std::string jobId, uint32_t state) {
4975             if (!env) {
4976                 return;
4977             }
4978             napi_handle_scope scope = nullptr;
4979             napi_open_handle_scope(env, &scope);
4980             if (scope == nullptr) {
4981                 return;
4982             }
4983             napi_value setResult[INTEGER_TWO] = {0};
4984             napi_create_string_utf8(env, jobId.c_str(), NAPI_AUTO_LENGTH, &setResult[INTEGER_ZERO]);
4985             napi_create_uint32(env, state, &setResult[INTEGER_ONE]);
4986             napi_value args[INTEGER_TWO] = {setResult[INTEGER_ZERO], setResult[INTEGER_ONE]};
4987             napi_value callback = nullptr;
4988             napi_get_reference_value(env, jCallback, &callback);
4989             napi_value callbackResult = nullptr;
4990             napi_call_function(env, nullptr, callback, INTEGER_TWO, args, &callbackResult);
4991             napi_delete_reference(env, jCallback);
4992             napi_close_handle_scope(env, scope);
4993         };
4994         return callbackImpl;
4995     }
4996     return nullptr;
4997 }
4998 
ParseWebPrintAttrParams(napi_env env,napi_value obj,PrintAttributesAdapter & printAttr)4999 bool ParseWebPrintAttrParams(napi_env env, napi_value obj, PrintAttributesAdapter& printAttr)
5000 {
5001     if (!obj) {
5002         WVLOG_E("ParseWebPrintAttrParams failed.");
5003         return false;
5004     }
5005     napi_value copyNumber = nullptr;
5006     napi_value pageRange = nullptr;
5007     napi_value isSequential = nullptr;
5008     napi_value pageSize = nullptr;
5009     napi_value isLandscape = nullptr;
5010     napi_value colorMode = nullptr;
5011     napi_value duplexMode = nullptr;
5012     napi_value margin = nullptr;
5013     napi_value option = nullptr;
5014     napi_get_named_property(env, obj, "copyNumber", &copyNumber);
5015     napi_get_named_property(env, obj, "pageRange", &pageRange);
5016     napi_get_named_property(env, obj, "isSequential", &isSequential);
5017     napi_get_named_property(env, obj, "pageSize", &pageSize);
5018     napi_get_named_property(env, obj, "isLandscape", &isLandscape);
5019     napi_get_named_property(env, obj, "colorMode", &colorMode);
5020     napi_get_named_property(env, obj, "duplexMode", &duplexMode);
5021     napi_get_named_property(env, obj, "margin", &margin);
5022     napi_get_named_property(env, obj, "option", &option);
5023     if (copyNumber) {
5024         NapiParseUtils::ParseUint32(env, copyNumber, printAttr.copyNumber);
5025     }
5026     if (isSequential) {
5027         NapiParseUtils::ParseBoolean(env, isSequential, printAttr.isSequential);
5028     }
5029     if (isLandscape) {
5030         NapiParseUtils::ParseBoolean(env, isLandscape,  printAttr.isLandscape);
5031     }
5032     if (colorMode) {
5033         NapiParseUtils::ParseUint32(env, colorMode, printAttr.colorMode);
5034     }
5035     if (duplexMode) {
5036         NapiParseUtils::ParseUint32(env, duplexMode, printAttr.duplexMode);
5037     }
5038     if (option) {
5039         NapiParseUtils::ParseString(env, option, printAttr.option);
5040     }
5041     ParsePrintRangeAdapter(env, pageRange, printAttr);
5042     ParsePrintPageSizeAdapter(env, pageSize, printAttr);
5043     ParsePrintMarginAdapter(env, margin, printAttr);
5044     return true;
5045 }
5046 
OnStartLayoutWrite(napi_env env,napi_callback_info info)5047 napi_value NapiWebPrintDocument::OnStartLayoutWrite(napi_env env, napi_callback_info info)
5048 {
5049     WVLOG_I("On Start Layout Write.");
5050     napi_value thisVar = nullptr;
5051     napi_value result = nullptr;
5052     size_t argc = INTEGER_FIVE;
5053     napi_value argv[INTEGER_FIVE] = { 0 };
5054     WebPrintDocument *webPrintDocument = nullptr;
5055 
5056     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
5057     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webPrintDocument));
5058     if (webPrintDocument == nullptr) {
5059         WVLOG_E("unwrap webPrintDocument failed.");
5060         return result;
5061     }
5062 
5063     std::string jobId;
5064     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], jobId)) {
5065         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5066         return result;
5067     }
5068 
5069     int32_t fd;
5070     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_THREE], fd)) {
5071         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5072         return result;
5073     }
5074     PrintAttributesAdapter oldPrintAttr;
5075     PrintAttributesAdapter newPrintAttr;
5076     bool ret = false;
5077     ret = ParseWebPrintAttrParams(env, argv[INTEGER_ONE], oldPrintAttr);
5078     if (!ret) {
5079         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5080         return result;
5081     }
5082     ret = ParseWebPrintAttrParams(env, argv[INTEGER_TWO], newPrintAttr);
5083     if (!ret) {
5084         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5085         return result;
5086     }
5087     WebPrintWriteResultCallback writeResultCallback = nullptr;
5088     writeResultCallback = ParseWebPrintWriteResultCallback(env, argv[INTEGER_FOUR]);
5089     webPrintDocument->OnStartLayoutWrite(jobId, oldPrintAttr, newPrintAttr, fd, writeResultCallback);
5090     return result;
5091 }
5092 
OnJobStateChanged(napi_env env,napi_callback_info info)5093 napi_value NapiWebPrintDocument::OnJobStateChanged(napi_env env, napi_callback_info info)
5094 {
5095     WVLOG_I("On Job State Changed.");
5096     napi_value thisVar = nullptr;
5097     napi_value result = nullptr;
5098     size_t argc = INTEGER_TWO;
5099     napi_value argv[INTEGER_TWO];
5100     NAPI_CALL(env, napi_get_undefined(env, &result));
5101 
5102     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5103     WebPrintDocument *webPrintDocument = nullptr;
5104     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webPrintDocument));
5105     if (webPrintDocument == nullptr) {
5106         WVLOG_E("unwrap webPrintDocument failed.");
5107         return result;
5108     }
5109     if (argc != INTEGER_TWO) {
5110         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5111         return result;
5112     }
5113 
5114     std::string jobId;
5115     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], jobId)) {
5116         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5117         return result;
5118     }
5119 
5120     int32_t state;
5121     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ONE], state)) {
5122         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5123         return result;
5124     }
5125     webPrintDocument->OnJobStateChanged(jobId, state);
5126     return result;
5127 }
5128 
JsConstructor(napi_env env,napi_callback_info info)5129 napi_value NapiWebPrintDocument::JsConstructor(napi_env env, napi_callback_info info)
5130 {
5131     napi_value thisVar = nullptr;
5132     size_t argc = INTEGER_ONE;
5133     napi_value argv[INTEGER_ONE];
5134     uint64_t addrWebPrintDoc = 0;
5135     bool loseLess = true;
5136     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5137 
5138     if (!NapiParseUtils::ParseUint64(env, argv[INTEGER_ZERO], addrWebPrintDoc, &loseLess)) {
5139         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5140         return nullptr;
5141     }
5142     void *webPrintDocPtr = reinterpret_cast<void *>(addrWebPrintDoc);
5143     WebPrintDocument *webPrintDoc = new (std::nothrow) WebPrintDocument(webPrintDocPtr);
5144     if (webPrintDoc == nullptr) {
5145         WVLOG_E("new web print failed");
5146         return nullptr;
5147     }
5148     NAPI_CALL(env, napi_wrap(env, thisVar, webPrintDoc,
5149         [](napi_env env, void *data, void *hint) {
5150             WebPrintDocument *webPrintDocument = static_cast<WebPrintDocument *>(data);
5151             delete webPrintDocument;
5152         },
5153         nullptr, nullptr));
5154     return thisVar;
5155 }
5156 
SetDownloadDelegate(napi_env env,napi_callback_info info)5157 napi_value NapiWebviewController::SetDownloadDelegate(napi_env env, napi_callback_info info)
5158 {
5159     WVLOG_D("WebDownloader::JS_SetDownloadDelegate");
5160     NWebHelper::Instance().LoadNWebSDK();
5161 
5162     size_t argc = 1;
5163     napi_value argv[1] = {0};
5164     napi_value thisVar = nullptr;
5165     void* data = nullptr;
5166     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
5167 
5168     WebDownloadDelegate* delegate = nullptr;
5169     napi_value obj = argv[0];
5170     napi_unwrap(env, obj, (void**)&delegate);
5171     if (!delegate) {
5172         WVLOG_E("[DOWNLOAD] WebDownloader::JS_SetDownloadDelegate delegate is null");
5173         (void)RemoveDownloadDelegateRef(env, thisVar);
5174         return nullptr;
5175     }
5176     napi_create_reference(env, obj, 1, &delegate->delegate_);
5177 
5178     WebviewController *webviewController = nullptr;
5179     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
5180     if (webviewController == nullptr || !webviewController->IsInit()) {
5181         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
5182         WVLOG_E("create message port failed, napi unwrap webviewController failed");
5183         return nullptr;
5184     }
5185     int32_t nwebId = webviewController->GetWebId();
5186     WebDownloadManager::AddDownloadDelegateForWeb(nwebId, delegate);
5187     return nullptr;
5188 }
5189 
StartDownload(napi_env env,napi_callback_info info)5190 napi_value NapiWebviewController::StartDownload(napi_env env, napi_callback_info info)
5191 {
5192     WVLOG_D("[DOWNLOAD] NapiWebviewController::StartDownload");
5193     size_t argc = 1;
5194     napi_value argv[1] = {0};
5195     napi_value thisVar = nullptr;
5196     void* data = nullptr;
5197     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
5198 
5199     WebviewController *webviewController = nullptr;
5200     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
5201     if (webviewController == nullptr || !webviewController->IsInit()) {
5202         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
5203         WVLOG_E("create message port failed, napi unwrap webviewController failed");
5204         return nullptr;
5205     }
5206 
5207     std::string url;
5208     if (!ParsePrepareUrl(env, argv[INTEGER_ZERO], url)) {
5209         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
5210         return nullptr;
5211     }
5212     int32_t nwebId = webviewController->GetWebId();
5213     NWebHelper::Instance().LoadNWebSDK();
5214     WebDownloader_StartDownload(nwebId, url.c_str());
5215     return nullptr;
5216 }
5217 
SetConnectionTimeout(napi_env env,napi_callback_info info)5218 napi_value NapiWebviewController::SetConnectionTimeout(napi_env env, napi_callback_info info)
5219 {
5220     napi_value result = nullptr;
5221     size_t argc = INTEGER_ONE;
5222     napi_value argv[INTEGER_ONE] = { nullptr };
5223     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
5224     if (argc != INTEGER_ONE) {
5225         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5226             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
5227         return result;
5228     }
5229 
5230     int32_t timeout = 0;
5231     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], timeout) || (timeout <= 0)) {
5232         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5233             "BusinessError: 401. Parameter error. The type of 'timeout' must be int and must be positive integer.");
5234         return result;
5235     }
5236 
5237     NWebHelper::Instance().SetConnectionTimeout(timeout);
5238     NAPI_CALL(env, napi_get_undefined(env, &result));
5239     return result;
5240 }
5241 
SetPrintBackground(napi_env env,napi_callback_info info)5242 napi_value NapiWebviewController::SetPrintBackground(napi_env env, napi_callback_info info)
5243 {
5244     napi_value result = nullptr;
5245     napi_value thisVar = nullptr;
5246     size_t argc = INTEGER_ONE;
5247     napi_value argv[INTEGER_ONE] = { 0 };
5248 
5249     NAPI_CALL(env, napi_get_undefined(env, &result));
5250     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5251     if (argc != INTEGER_ONE) {
5252         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5253             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
5254         return result;
5255     }
5256 
5257     bool printBackgroundEnabled = false;
5258     if (!NapiParseUtils::ParseBoolean(env, argv[0], printBackgroundEnabled)) {
5259         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5260             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "enable", "boolean"));
5261         return result;
5262     }
5263 
5264     WebviewController *webviewController = GetWebviewController(env, info);
5265     if (!webviewController) {
5266         return result;
5267     }
5268     webviewController->SetPrintBackground(printBackgroundEnabled);
5269     return result;
5270 }
5271 
GetPrintBackground(napi_env env,napi_callback_info info)5272 napi_value NapiWebviewController::GetPrintBackground(napi_env env, napi_callback_info info)
5273 {
5274     napi_value result = nullptr;
5275     WebviewController *webviewController = GetWebviewController(env, info);
5276 
5277     if (!webviewController) {
5278         return result;
5279     }
5280 
5281     bool printBackgroundEnabled = webviewController->GetPrintBackground();
5282     NAPI_CALL(env, napi_get_boolean(env, printBackgroundEnabled, &result));
5283     return result;
5284 }
5285 
SetWebSchemeHandler(napi_env env,napi_callback_info info)5286 napi_value NapiWebviewController::SetWebSchemeHandler(napi_env env, napi_callback_info info)
5287 {
5288     size_t argc = 2;
5289     napi_value argv[2] = {0};
5290     napi_value thisVar = nullptr;
5291     void* data = nullptr;
5292     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
5293 
5294     WebviewController *webviewController = nullptr;
5295     NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&webviewController));
5296     if (webviewController == nullptr || !webviewController->IsInit()) {
5297         BusinessError::ThrowErrorByErrcode(env, INIT_ERROR);
5298         WVLOG_E("create message port failed, napi unwrap webviewController failed");
5299         return nullptr;
5300     }
5301 
5302     std::string scheme = "";
5303     if (!NapiParseUtils::ParseString(env, argv[0], scheme)) {
5304         WVLOG_E("NapiWebviewController::SetWebSchemeHandler parse scheme failed");
5305         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5306             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "scheme", "string"));
5307         return nullptr;
5308     }
5309 
5310     WebSchemeHandler* handler = nullptr;
5311     napi_value obj = argv[1];
5312     napi_unwrap(env, obj, (void**)&handler);
5313     if (!handler) {
5314         WVLOG_E("NapiWebviewController::SetWebSchemeHandler handler is null");
5315         return nullptr;
5316     }
5317     napi_create_reference(env, obj, 1, &handler->delegate_);
5318 
5319     if (!webviewController->SetWebSchemeHandler(scheme.c_str(), handler)) {
5320         WVLOG_E("NapiWebviewController::SetWebSchemeHandler failed");
5321     }
5322     return nullptr;
5323 }
5324 
ClearWebSchemeHandler(napi_env env,napi_callback_info info)5325 napi_value NapiWebviewController::ClearWebSchemeHandler(napi_env env, napi_callback_info info)
5326 {
5327     napi_value result = nullptr;
5328     WebviewController *webviewController = GetWebviewController(env, info);
5329     if (!webviewController) {
5330         return nullptr;
5331     }
5332 
5333     int32_t ret = webviewController->ClearWebSchemeHandler();
5334     if (ret != 0) {
5335         WVLOG_E("NapiWebviewController::ClearWebSchemeHandler failed");
5336     }
5337     NAPI_CALL(env, napi_get_undefined(env, &result));
5338     return result;
5339 }
5340 
SetServiceWorkerWebSchemeHandler(napi_env env,napi_callback_info info)5341 napi_value NapiWebviewController::SetServiceWorkerWebSchemeHandler(
5342     napi_env env, napi_callback_info info)
5343 {
5344     size_t argc = 2;
5345     napi_value argv[2] = {0};
5346     napi_value thisVar = nullptr;
5347     void* data = nullptr;
5348     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
5349 
5350     std::string scheme = "";
5351     if (!NapiParseUtils::ParseString(env, argv[0], scheme)) {
5352         WVLOG_E("NapiWebviewController::SetWebSchemeHandler parse scheme failed");
5353         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5354             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "scheme", "string"));
5355         return nullptr;
5356     }
5357 
5358     WebSchemeHandler* handler = nullptr;
5359     napi_value obj = argv[1];
5360     napi_unwrap(env, obj, (void**)&handler);
5361     if (!handler) {
5362         WVLOG_E("NapiWebviewController::SetServiceWorkerWebSchemeHandler handler is null");
5363         return nullptr;
5364     }
5365     napi_create_reference(env, obj, 1, &handler->delegate_);
5366 
5367     if (!WebviewController::SetWebServiveWorkerSchemeHandler(
5368         scheme.c_str(), handler)) {
5369         WVLOG_E("NapiWebviewController::SetWebSchemeHandler failed");
5370     }
5371     return nullptr;
5372 }
5373 
ClearServiceWorkerWebSchemeHandler(napi_env env,napi_callback_info info)5374 napi_value NapiWebviewController::ClearServiceWorkerWebSchemeHandler(
5375     napi_env env, napi_callback_info info)
5376 {
5377     int32_t ret = WebviewController::ClearWebServiceWorkerSchemeHandler();
5378     if (ret != 0) {
5379         WVLOG_E("ClearServiceWorkerWebSchemeHandler ret=%{public}d", ret);
5380         return nullptr;
5381     }
5382     return nullptr;
5383 }
5384 
EnableIntelligentTrackingPrevention(napi_env env,napi_callback_info info)5385 napi_value NapiWebviewController::EnableIntelligentTrackingPrevention(
5386     napi_env env, napi_callback_info info)
5387 {
5388     WVLOG_I("enable/disable intelligent tracking prevention.");
5389     napi_value result = nullptr;
5390     napi_value thisVar = nullptr;
5391     size_t argc = INTEGER_ONE;
5392     napi_value argv[INTEGER_ONE] = { 0 };
5393 
5394     NAPI_CALL(env, napi_get_undefined(env, &result));
5395     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5396     if (argc != INTEGER_ONE) {
5397         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5398             "BusinessError 401: Parameter error. The number of params must be one.");
5399         return result;
5400     }
5401 
5402     bool enabled = false;
5403     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ZERO], enabled)) {
5404         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5405             "BusinessError 401: Parameter error. The type of 'enable' must be boolean.");
5406         return result;
5407     }
5408 
5409     WebviewController *webviewController = GetWebviewController(env, info);
5410     if (!webviewController) {
5411         WVLOG_E("EnableIntelligentTrackingPrevention failed for webviewController failed");
5412         return result;
5413     }
5414     webviewController->EnableIntelligentTrackingPrevention(enabled);
5415     return result;
5416 }
5417 
IsIntelligentTrackingPreventionEnabled(napi_env env,napi_callback_info info)5418 napi_value NapiWebviewController::IsIntelligentTrackingPreventionEnabled(
5419     napi_env env, napi_callback_info info)
5420 {
5421     WVLOG_I("get intelligent tracking prevention enabled value.");
5422     napi_value result = nullptr;
5423     WebviewController *webviewController = GetWebviewController(env, info);
5424 
5425     if (!webviewController) {
5426         WVLOG_E("IsIntelligentTrackingPreventionEnabled failed for webviewController failed");
5427         return result;
5428     }
5429 
5430     bool enabled = webviewController->
5431         IsIntelligentTrackingPreventionEnabled();
5432     NAPI_CALL(env, napi_get_boolean(env, enabled, &result));
5433     return result;
5434 }
5435 
GetHostList(napi_env env,napi_value array,std::vector<std::string> & hosts)5436 bool GetHostList(napi_env env, napi_value array, std::vector<std::string>& hosts)
5437 {
5438     uint32_t arrayLen = 0;
5439     napi_get_array_length(env, array, &arrayLen);
5440     if (arrayLen == 0) {
5441         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5442             "BusinessError 401: Parameter error. The array length must be greater than 0.");
5443         return false;
5444     }
5445 
5446     for (uint32_t i = 0; i < arrayLen; i++) {
5447         napi_value hostItem = nullptr;
5448         napi_get_element(env, array, i, &hostItem);
5449 
5450         size_t hostLen = 0;
5451         napi_get_value_string_utf8(env, hostItem, nullptr, 0, &hostLen);
5452         if (hostLen == 0 || hostLen > UINT_MAX) {
5453             WVLOG_E("hostitem length is invalid");
5454             return false;
5455         }
5456 
5457         char host[hostLen + 1];
5458         int retCode = memset_s(host, sizeof(host), 0, hostLen + 1);
5459         if (retCode < 0) {
5460             WVLOG_E("memset_s failed, retCode=%{public}d", retCode);
5461             return false;
5462         }
5463         napi_get_value_string_utf8(env, hostItem, host, sizeof(host), &hostLen);
5464         std::string hostStr(host);
5465         hosts.emplace_back(hostStr);
5466     }
5467     return true;
5468 }
5469 
AddIntelligentTrackingPreventionBypassingList(napi_env env,napi_callback_info info)5470 napi_value NapiWebviewController::AddIntelligentTrackingPreventionBypassingList(
5471     napi_env env, napi_callback_info info)
5472 {
5473     WVLOG_I("Add intelligent tracking prevention bypassing list.");
5474     napi_value result = nullptr;
5475     napi_value thisVar = nullptr;
5476     size_t argc = INTEGER_ONE;
5477     napi_value argv[INTEGER_ONE] = { 0 };
5478     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5479     if (argc != INTEGER_ONE) {
5480         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5481             "BusinessError 401: Parameter error. The number of params must be one.");
5482         return result;
5483     }
5484 
5485     bool isArray = false;
5486     NAPI_CALL(env, napi_is_array(env, argv[INTEGER_ZERO], &isArray));
5487     if (!isArray) {
5488         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5489             "BusinessError 401: Parameter error. The type of 'hostList' must be string array.");
5490         return result;
5491     }
5492 
5493     std::vector<std::string> hosts;
5494     if (!GetHostList(env, argv[INTEGER_ZERO], hosts)) {
5495         WVLOG_E("get host list failed, GetHostList fail");
5496         return result;
5497     }
5498 
5499     NWebHelper::Instance().AddIntelligentTrackingPreventionBypassingList(hosts);
5500     NAPI_CALL(env, napi_get_undefined(env, &result));
5501     return result;
5502 }
5503 
RemoveIntelligentTrackingPreventionBypassingList(napi_env env,napi_callback_info info)5504 napi_value NapiWebviewController::RemoveIntelligentTrackingPreventionBypassingList(
5505     napi_env env, napi_callback_info info)
5506 {
5507     WVLOG_I("Remove intelligent tracking prevention bypassing list.");
5508     napi_value result = nullptr;
5509     napi_value thisVar = nullptr;
5510     size_t argc = INTEGER_ONE;
5511     napi_value argv[INTEGER_ONE] = { 0 };
5512     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5513     if (argc != INTEGER_ONE) {
5514         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5515             "BusinessError 401: Parameter error. The number of params must be one.");
5516         return result;
5517     }
5518 
5519     bool isArray = false;
5520     NAPI_CALL(env, napi_is_array(env, argv[INTEGER_ZERO], &isArray));
5521     if (!isArray) {
5522         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5523             "BusinessError 401: Parameter error. The type of 'hostList' must be string array.");
5524         return result;
5525     }
5526 
5527     std::vector<std::string> hosts;
5528     if (!GetHostList(env, argv[INTEGER_ZERO], hosts)) {
5529         WVLOG_E("get host list failed, GetHostList fail");
5530         return result;
5531     }
5532 
5533     NWebHelper::Instance().RemoveIntelligentTrackingPreventionBypassingList(hosts);
5534     NAPI_CALL(env, napi_get_undefined(env, &result));
5535     return result;
5536 }
5537 
ClearIntelligentTrackingPreventionBypassingList(napi_env env,napi_callback_info info)5538 napi_value NapiWebviewController::ClearIntelligentTrackingPreventionBypassingList(
5539     napi_env env, napi_callback_info info)
5540 {
5541     napi_value result = nullptr;
5542     WVLOG_I("Clear intelligent tracking prevention bypassing list.");
5543     NWebHelper::Instance().ClearIntelligentTrackingPreventionBypassingList();
5544     NAPI_CALL(env, napi_get_undefined(env, &result));
5545     return result;
5546 }
5547 
GetDefaultUserAgent(napi_env env,napi_callback_info info)5548 napi_value NapiWebviewController::GetDefaultUserAgent(napi_env env, napi_callback_info info)
5549 {
5550     WVLOG_I("Get the default user agent.");
5551     napi_value result = nullptr;
5552 
5553     std::string userAgent = NWebHelper::Instance().GetDefaultUserAgent();
5554     NAPI_CALL(env, napi_create_string_utf8(env, userAgent.c_str(), userAgent.length(), &result));
5555     return result;
5556 }
5557 
PauseAllTimers(napi_env env,napi_callback_info info)5558 napi_value NapiWebviewController::PauseAllTimers(napi_env env, napi_callback_info info)
5559 {
5560     napi_value result = nullptr;
5561     NWebHelper::Instance().PauseAllTimers();
5562     NAPI_CALL(env, napi_get_undefined(env, &result));
5563     return result;
5564 }
5565 
ResumeAllTimers(napi_env env,napi_callback_info info)5566 napi_value NapiWebviewController::ResumeAllTimers(napi_env env, napi_callback_info info)
5567 {
5568     napi_value result = nullptr;
5569     NWebHelper::Instance().ResumeAllTimers();
5570     NAPI_CALL(env, napi_get_undefined(env, &result));
5571     return result;
5572 }
5573 
StartCamera(napi_env env,napi_callback_info info)5574 napi_value NapiWebviewController::StartCamera(napi_env env, napi_callback_info info)
5575 {
5576     napi_value result = nullptr;
5577     NAPI_CALL(env, napi_get_undefined(env, &result));
5578     WebviewController* webviewController = GetWebviewController(env, info);
5579     if (!webviewController) {
5580         return result;
5581     }
5582     webviewController->StartCamera();
5583 
5584     return result;
5585 }
5586 
StopCamera(napi_env env,napi_callback_info info)5587 napi_value NapiWebviewController::StopCamera(napi_env env, napi_callback_info info)
5588 {
5589     napi_value result = nullptr;
5590     NAPI_CALL(env, napi_get_undefined(env, &result));
5591     WebviewController* webviewController = GetWebviewController(env, info);
5592     if (!webviewController) {
5593         return result;
5594     }
5595     webviewController->StopCamera();
5596 
5597     return result;
5598 }
5599 
CloseCamera(napi_env env,napi_callback_info info)5600 napi_value NapiWebviewController::CloseCamera(napi_env env, napi_callback_info info)
5601 {
5602     napi_value result = nullptr;
5603     NAPI_CALL(env, napi_get_undefined(env, &result));
5604     WebviewController* webviewController = GetWebviewController(env, info);
5605     if (!webviewController) {
5606         return result;
5607     }
5608     webviewController->CloseCamera();
5609 
5610     return result;
5611 }
5612 
OnCreateNativeMediaPlayer(napi_env env,napi_callback_info info)5613 napi_value NapiWebviewController::OnCreateNativeMediaPlayer(napi_env env, napi_callback_info info)
5614 {
5615     WVLOG_D("put on_create_native_media_player callback");
5616 
5617     size_t argc = INTEGER_ONE;
5618     napi_value value = nullptr;
5619     napi_value argv[INTEGER_ONE];
5620     napi_get_cb_info(env, info, &argc, argv, &value, nullptr);
5621     if (argc != INTEGER_ONE) {
5622         WVLOG_E("arg count %{public}zu is not equal to 1", argc);
5623         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5624         return nullptr;
5625     }
5626 
5627     napi_valuetype valueType = napi_undefined;
5628     napi_typeof(env, argv[INTEGER_ZERO], &valueType);
5629     if (valueType != napi_function) {
5630         WVLOG_E("arg type is invalid");
5631         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5632         return nullptr;
5633     }
5634 
5635     napi_ref callback = nullptr;
5636     napi_create_reference(env, argv[INTEGER_ZERO], INTEGER_ONE, &callback);
5637     if (!callback) {
5638         WVLOG_E("failed to create reference for callback");
5639         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5640         return nullptr;
5641     }
5642 
5643     WebviewController* webviewController = GetWebviewController(env, info);
5644     if (!webviewController || !webviewController->IsInit()) {
5645         WVLOG_E("webview controller is null or not init");
5646         napi_delete_reference(env, callback);
5647         return nullptr;
5648     }
5649 
5650     webviewController->OnCreateNativeMediaPlayer(env, std::move(callback));
5651     return nullptr;
5652 }
5653 
SetRenderProcessMode(napi_env env,napi_callback_info info)5654 napi_value NapiWebviewController::SetRenderProcessMode(
5655     napi_env env, napi_callback_info info)
5656 {
5657     WVLOG_I("set render process mode.");
5658     napi_value result = nullptr;
5659     napi_value thisVar = nullptr;
5660     size_t argc = INTEGER_ONE;
5661     napi_value argv[INTEGER_ONE] = { 0 };
5662 
5663     NAPI_CALL(env, napi_get_undefined(env, &result));
5664     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5665     if (argc != INTEGER_ONE) {
5666         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5667             "BusinessError 401: Parameter error. The number of params must be one.");
5668         return result;
5669     }
5670 
5671     int32_t mode = 0;
5672     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], mode)) {
5673         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5674             "BusinessError 401: Parameter error. The type of 'mode' must be int.");
5675         return result;
5676     }
5677 
5678     NWebHelper::Instance().SetRenderProcessMode(
5679         static_cast<RenderProcessMode>(mode));
5680 
5681     return result;
5682 }
5683 
GetRenderProcessMode(napi_env env,napi_callback_info info)5684 napi_value NapiWebviewController::GetRenderProcessMode(
5685     napi_env env, napi_callback_info info)
5686 {
5687     WVLOG_I("get render mode.");
5688     napi_value result = nullptr;
5689 
5690     int32_t mode = static_cast<int32_t>(NWebHelper::Instance().GetRenderProcessMode());
5691     NAPI_CALL(env, napi_create_int32(env, mode, &result));
5692     return result;
5693 }
5694 
PrecompileJavaScript(napi_env env,napi_callback_info info)5695 napi_value NapiWebviewController::PrecompileJavaScript(napi_env env, napi_callback_info info)
5696 {
5697     napi_value thisVar = nullptr;
5698     napi_value result = nullptr;
5699     size_t argc = INTEGER_THREE;
5700     napi_value argv[INTEGER_THREE] = {0};
5701     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5702     if (argc != INTEGER_THREE) {
5703         WVLOG_E("BusinessError: 401. Args count of 'PrecompileJavaScript' must be 3.");
5704         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5705         return result;
5706     }
5707 
5708     WebviewController* webviewController = GetWebviewController(env, info);
5709     if (!webviewController) {
5710         WVLOG_E("PrecompileJavaScript: init webview controller error.");
5711         return result;
5712     }
5713 
5714     std::string url;
5715     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], url) || url.empty()) {
5716         WVLOG_E("BusinessError: 401. The type of 'url' must be string.");
5717         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5718         return result;
5719     }
5720 
5721     std::string script;
5722     bool parseResult = webviewController->ParseScriptContent(env, argv[INTEGER_ONE], script);
5723     if (!parseResult) {
5724         WVLOG_E("BusinessError: 401. The type of 'script' must be string or Uint8Array.");
5725         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5726         return result;
5727     }
5728 
5729     auto cacheOptions = webviewController->ParseCacheOptions(env, argv[INTEGER_TWO]);
5730 
5731     napi_deferred deferred = nullptr;
5732     napi_value promise = nullptr;
5733     napi_create_promise(env, &deferred, &promise);
5734     if (promise && deferred) {
5735         webviewController->PrecompileJavaScriptPromise(env, deferred, url, script, cacheOptions);
5736         return promise;
5737     }
5738 
5739     return promise;
5740 }
5741 
EnableBackForwardCache(napi_env env,napi_callback_info info)5742 napi_value NapiWebviewController::EnableBackForwardCache(napi_env env, napi_callback_info info)
5743 {
5744     napi_value thisVar = nullptr;
5745     napi_value result = nullptr;
5746     size_t argc = INTEGER_ONE;
5747     napi_value argv[INTEGER_ONE] = { 0 };
5748     napi_get_undefined(env, &result);
5749     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5750     if (argc != INTEGER_ONE) {
5751         WVLOG_E("EnalbeBackForwardCache: wrong number of params.");
5752         NWebHelper::Instance().EnableBackForwardCache(false, false);
5753         NAPI_CALL(env, napi_get_undefined(env, &result));
5754         return result;
5755     }
5756 
5757     bool nativeEmbed = false;
5758     bool mediaTakeOver = false;
5759     napi_value embedObj = nullptr;
5760     napi_value mediaObj = nullptr;
5761     if (napi_get_named_property(env, argv[INTEGER_ZERO], "nativeEmbed", &embedObj) == napi_ok) {
5762         if (!NapiParseUtils::ParseBoolean(env, embedObj, nativeEmbed)) {
5763             nativeEmbed = false;
5764         }
5765     }
5766 
5767     if (napi_get_named_property(env, argv[INTEGER_ZERO], "mediaTakeOver", &mediaObj) == napi_ok) {
5768         if (!NapiParseUtils::ParseBoolean(env, mediaObj, mediaTakeOver)) {
5769             mediaTakeOver = false;
5770         }
5771     }
5772 
5773     NWebHelper::Instance().EnableBackForwardCache(nativeEmbed, mediaTakeOver);
5774     NAPI_CALL(env, napi_get_undefined(env, &result));
5775     return result;
5776 }
5777 
SetBackForwardCacheOptions(napi_env env,napi_callback_info info)5778 napi_value NapiWebviewController::SetBackForwardCacheOptions(napi_env env, napi_callback_info info)
5779 {
5780     napi_value thisVar = nullptr;
5781     napi_value result = nullptr;
5782     size_t argc = INTEGER_ONE;
5783     napi_value argv[INTEGER_ONE] = { 0 };
5784     napi_get_undefined(env, &result);
5785     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5786     WebviewController* webviewController = GetWebviewController(env, info);
5787     if (!webviewController) {
5788         WVLOG_E("SetBackForwardCacheOptions: Init webview controller error.");
5789         return result;
5790     }
5791 
5792     if (argc != INTEGER_ONE) {
5793         WVLOG_E("SetBackForwardCacheOptions: wrong number of params.");
5794         webviewController->SetBackForwardCacheOptions(
5795             BFCACHE_DEFAULT_SIZE, BFCACHE_DEFAULT_TIMETOLIVE);
5796         NAPI_CALL(env, napi_get_undefined(env, &result));
5797         return result;
5798     }
5799 
5800     int32_t size = BFCACHE_DEFAULT_SIZE;
5801     int32_t timeToLive = BFCACHE_DEFAULT_TIMETOLIVE;
5802     napi_value sizeObj = nullptr;
5803     napi_value timeToLiveObj = nullptr;
5804     if (napi_get_named_property(env, argv[INTEGER_ZERO], "size", &sizeObj) == napi_ok) {
5805         if (!NapiParseUtils::ParseInt32(env, sizeObj, size)) {
5806             size = BFCACHE_DEFAULT_SIZE;
5807         }
5808     }
5809 
5810     if (napi_get_named_property(env, argv[INTEGER_ZERO], "timeToLive", &timeToLiveObj) == napi_ok) {
5811         if (!NapiParseUtils::ParseInt32(env, timeToLiveObj, timeToLive)) {
5812             timeToLive = BFCACHE_DEFAULT_TIMETOLIVE;
5813         }
5814     }
5815 
5816     webviewController->SetBackForwardCacheOptions(size, timeToLive);
5817     NAPI_CALL(env, napi_get_undefined(env, &result));
5818     return result;
5819 }
5820 
InjectOfflineResources(napi_env env,napi_callback_info info)5821 napi_value NapiWebviewController::InjectOfflineResources(napi_env env, napi_callback_info info)
5822 {
5823     napi_value thisVar = nullptr;
5824     napi_value result = nullptr;
5825     size_t argc = INTEGER_ONE;
5826     napi_value argv[INTEGER_ONE] = {0};
5827     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5828     if (argc != INTEGER_ONE) {
5829         WVLOG_E("BusinessError: 401. Args count of 'InjectOfflineResource' must be 1.");
5830         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5831         return result;
5832     }
5833 
5834     napi_value resourcesList = argv[INTEGER_ZERO];
5835     bool isArray = false;
5836     napi_is_array(env, resourcesList, &isArray);
5837     if (!isArray) {
5838         WVLOG_E("BusinessError: 401. The type of 'resourceMaps' must be Array");
5839         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5840         return result;
5841     }
5842 
5843     AddResourcesToMemoryCache(env, info, resourcesList);
5844     return result;
5845 }
5846 
AddResourcesToMemoryCache(napi_env env,napi_callback_info info,napi_value & resourcesList)5847 void NapiWebviewController::AddResourcesToMemoryCache(napi_env env,
5848                                                       napi_callback_info info,
5849                                                       napi_value& resourcesList)
5850 {
5851     uint32_t resourcesCount = 0;
5852     napi_get_array_length(env, resourcesList, &resourcesCount);
5853 
5854     if (resourcesCount > MAX_RESOURCES_COUNT || resourcesCount == 0) {
5855         WVLOG_E("BusinessError: 401. The size of 'resourceMaps' must less than %{public}zu and not 0",
5856             MAX_RESOURCES_COUNT);
5857         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5858         return;
5859     }
5860 
5861     for (uint32_t i = 0 ; i < resourcesCount ; i++) {
5862         napi_value urlListObj = nullptr;
5863         napi_value resourceObj = nullptr;
5864         napi_value headersObj = nullptr;
5865         napi_value typeObj = nullptr;
5866         napi_value obj = nullptr;
5867 
5868         napi_create_array(env, &headersObj);
5869         napi_create_array(env, &urlListObj);
5870 
5871         napi_get_element(env, resourcesList, i, &obj);
5872         if ((napi_get_named_property(env, obj, "urlList", &urlListObj) != napi_ok) ||
5873             (napi_get_named_property(env, obj, "resource", &resourceObj) != napi_ok) ||
5874             (napi_get_named_property(env, obj, "responseHeaders", &headersObj) != napi_ok) ||
5875             (napi_get_named_property(env, obj, "type", &typeObj) != napi_ok)) {
5876             WVLOG_E("InjectOfflineResources: parse params from resource map failed.");
5877             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5878             continue;
5879         }
5880 
5881         OfflineResourceValue resourceValue;
5882         resourceValue.urlList = urlListObj;
5883         resourceValue.resource = resourceObj;
5884         resourceValue.responseHeaders = headersObj;
5885         resourceValue.type = typeObj;
5886         AddResourceItemToMemoryCache(env, info, resourceValue);
5887     }
5888 }
5889 
AddResourceItemToMemoryCache(napi_env env,napi_callback_info info,OfflineResourceValue resourceValue)5890 void NapiWebviewController::AddResourceItemToMemoryCache(napi_env env,
5891                                                          napi_callback_info info,
5892                                                          OfflineResourceValue resourceValue)
5893 {
5894     WebviewController* webviewController = GetWebviewController(env, info);
5895     if (!webviewController) {
5896         WVLOG_E("InjectOfflineResource: init webview controller error.");
5897         return;
5898     }
5899 
5900     std::vector<std::string> urlList;
5901     ParseURLResult result = webviewController->ParseURLList(env, resourceValue.urlList, urlList);
5902     if (result != ParseURLResult::OK) {
5903         auto errCode = result == ParseURLResult::FAILED ? PARAM_CHECK_ERROR : INVALID_URL;
5904         if (errCode == PARAM_CHECK_ERROR) {
5905             WVLOG_E("BusinessError: 401. The type of 'urlList' must be Array of string.");
5906         }
5907         BusinessError::ThrowErrorByErrcode(env, errCode);
5908         return;
5909     }
5910 
5911     std::vector<uint8_t> resource = webviewController->ParseUint8Array(env, resourceValue.resource);
5912     if (resource.empty() || resource.size() > MAX_RESOURCE_SIZE) {
5913         WVLOG_E("BusinessError: 401. The type of 'resource' must be Uint8Array. "
5914             "'resource' size must less than %{public}zu and must not be empty.", MAX_RESOURCE_SIZE);
5915         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5916         return;
5917     }
5918 
5919     std::map<std::string, std::string> responseHeaders;
5920     if (!webviewController->ParseResponseHeaders(env, resourceValue.responseHeaders, responseHeaders)) {
5921         WVLOG_E("BusinessError: 401. The type of 'responseHeaders' must be Array of 'WebHeader'.");
5922         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5923         return;
5924     }
5925 
5926     uint32_t type = 0;
5927     if (!NapiParseUtils::ParseUint32(env, resourceValue.type, type)) {
5928         WVLOG_E("BusinessError: 401. The type of 'type' must be one kind of 'OfflineResourceType'.");
5929         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
5930         return;
5931     }
5932 
5933     webviewController->InjectOfflineResource(urlList, resource, responseHeaders, type);
5934 }
5935 
SetHostIP(napi_env env,napi_callback_info info)5936 napi_value NapiWebviewController::SetHostIP(napi_env env, napi_callback_info info)
5937 {
5938     napi_value thisVar = nullptr;
5939     napi_value result = nullptr;
5940     size_t argc = INTEGER_THREE;
5941     napi_value argv[INTEGER_THREE] = { 0 };
5942     std::string hostName;
5943     std::string address;
5944     int32_t aliveTime = INTEGER_ZERO;
5945 
5946     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5947     if (argc != INTEGER_THREE) {
5948         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5949             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "three"));
5950         return result;
5951     }
5952 
5953     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], hostName) ||
5954         !NapiParseUtils::ParseString(env, argv[INTEGER_ONE], address) ||
5955         !NapiParseUtils::ParseInt32(env, argv[INTEGER_TWO], aliveTime)) {
5956         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR, ParamCheckErrorMsgTemplate::PARAM_TYEPS_ERROR);
5957         return result;
5958     }
5959 
5960     if (!ParseIP(env, argv[INTEGER_ONE], address)) {
5961         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5962             "BusinessError 401: IP address error.");
5963         return result;
5964     }
5965 
5966     NWebHelper::Instance().SetHostIP(hostName, address, aliveTime);
5967     NAPI_CALL(env, napi_get_undefined(env, &result));
5968 
5969     return result;
5970 }
5971 
ClearHostIP(napi_env env,napi_callback_info info)5972 napi_value NapiWebviewController::ClearHostIP(napi_env env, napi_callback_info info)
5973 {
5974     napi_value thisVar = nullptr;
5975     napi_value result = nullptr;
5976     size_t argc = INTEGER_ONE;
5977     napi_value argv[INTEGER_ONE] = { 0 };
5978     std::string hostName;
5979 
5980     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
5981     if (argc != INTEGER_ONE) {
5982         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5983             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
5984         return result;
5985     }
5986 
5987     if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], hostName)) {
5988         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
5989             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "hostName", "string"));
5990         return result;
5991     }
5992 
5993     NWebHelper::Instance().ClearHostIP(hostName);
5994     NAPI_CALL(env, napi_get_undefined(env, &result));
5995     return result;
5996 }
5997 
WarmupServiceWorker(napi_env env,napi_callback_info info)5998 napi_value NapiWebviewController::WarmupServiceWorker(napi_env env, napi_callback_info info)
5999 {
6000     napi_value thisVar = nullptr;
6001     napi_value result = nullptr;
6002     size_t argc = INTEGER_ONE;
6003     napi_value argv[INTEGER_ONE] = { 0 };
6004     napi_get_undefined(env, &result);
6005     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6006     if (argc != INTEGER_ONE) {
6007         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6008         return result;
6009     }
6010 
6011     std::string url;
6012     if (!ParsePrepareUrl(env, argv[INTEGER_ZERO], url)) {
6013         BusinessError::ThrowErrorByErrcode(env, INVALID_URL);
6014         return result;
6015     }
6016 
6017     NWebHelper::Instance().WarmupServiceWorker(url);
6018     return result;
6019 }
6020 
GetSurfaceId(napi_env env,napi_callback_info info)6021 napi_value NapiWebviewController::GetSurfaceId(napi_env env, napi_callback_info info)
6022 {
6023     napi_value result = nullptr;
6024     WebviewController *webviewController = GetWebviewController(env, info);
6025     if (!webviewController) {
6026         return nullptr;
6027     }
6028 
6029     std::string surfaceId = webviewController->GetSurfaceId();
6030     napi_create_string_utf8(env, surfaceId.c_str(), surfaceId.length(), &result);
6031     return result;
6032 }
6033 
EnableWholeWebPageDrawing(napi_env env,napi_callback_info info)6034 napi_value NapiWebviewController::EnableWholeWebPageDrawing(napi_env env, napi_callback_info info)
6035 {
6036     napi_value result = nullptr;
6037     NWebHelper::Instance().SetWholeWebDrawing();
6038     NAPI_CALL(env, napi_get_undefined(env, &result));
6039     return result;
6040 }
6041 
EnableAdsBlock(napi_env env,napi_callback_info info)6042 napi_value NapiWebviewController::EnableAdsBlock(
6043     napi_env env, napi_callback_info info)
6044 {
6045     napi_value result = nullptr;
6046     napi_value thisVar = nullptr;
6047     size_t argc = INTEGER_ONE;
6048     napi_value argv[INTEGER_ONE] = { 0 };
6049 
6050     NAPI_CALL(env, napi_get_undefined(env, &result));
6051     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6052     if (argc != INTEGER_ONE) {
6053         WVLOG_E("EnableAdsBlock: args count is not allowed.");
6054         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6055             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
6056         return result;
6057     }
6058 
6059     bool enabled = false;
6060     if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_ZERO], enabled)) {
6061         WVLOG_E("EnableAdsBlock: the given enabled is not allowed.");
6062         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6063             "BusinessError 401: Parameter error. The type of 'enable' must be boolean.");
6064         return result;
6065     }
6066 
6067     WebviewController *webviewController = GetWebviewController(env, info);
6068     if (!webviewController) {
6069         WVLOG_E("EnableAdsBlock: init webview controller error.");
6070         return result;
6071     }
6072 
6073     WVLOG_I("EnableAdsBlock: %{public}s", (enabled ? "true" : "false"));
6074     webviewController->EnableAdsBlock(enabled);
6075     return result;
6076 }
6077 
IsAdsBlockEnabled(napi_env env,napi_callback_info info)6078 napi_value NapiWebviewController::IsAdsBlockEnabled(napi_env env, napi_callback_info info)
6079 {
6080     napi_value result = nullptr;
6081     WebviewController *webviewController = GetWebviewController(env, info);
6082     if (!webviewController) {
6083         return nullptr;
6084     }
6085 
6086     bool isAdsBlockEnabled = webviewController->IsAdsBlockEnabled();
6087     NAPI_CALL(env, napi_get_boolean(env, isAdsBlockEnabled, &result));
6088     return result;
6089 }
6090 
IsAdsBlockEnabledForCurPage(napi_env env,napi_callback_info info)6091 napi_value NapiWebviewController::IsAdsBlockEnabledForCurPage(napi_env env, napi_callback_info info)
6092 {
6093     napi_value result = nullptr;
6094     WebviewController *webviewController = GetWebviewController(env, info);
6095     if (!webviewController) {
6096         return nullptr;
6097     }
6098 
6099     bool isAdsBlockEnabledForCurPage = webviewController->IsAdsBlockEnabledForCurPage();
6100     NAPI_CALL(env, napi_get_boolean(env, isAdsBlockEnabledForCurPage, &result));
6101     return result;
6102 }
6103 
CreateWebPageSnapshotResultCallback(napi_env env,napi_ref jsCallback,bool check,int32_t inputWidth,int32_t inputHeight)6104 WebSnapshotCallback CreateWebPageSnapshotResultCallback(
6105     napi_env env, napi_ref jsCallback, bool check, int32_t inputWidth, int32_t inputHeight)
6106 {
6107     return
6108         [env, jCallback = std::move(jsCallback), check, inputWidth, inputHeight](
6109             const char *returnId, bool returnStatus, float radio, void *returnData,
6110             int returnWidth, int returnHeight) {
6111             WVLOG_I("WebPageSnapshot return napi callback");
6112             napi_value jsResult = nullptr;
6113             napi_create_object(env, &jsResult);
6114 
6115             napi_value jsPixelMap = nullptr;
6116             Media::InitializationOptions opt;
6117             opt.size.width = static_cast<int32_t>(returnWidth);
6118             opt.size.height = static_cast<int32_t>(returnHeight);
6119             opt.pixelFormat = Media::PixelFormat::RGBA_8888;
6120             opt.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
6121             opt.editable = true;
6122             auto pixelMap = Media::PixelMap::Create(opt);
6123             if (pixelMap != nullptr) {
6124                 uint64_t stride = static_cast<uint64_t>(returnWidth) << 2;
6125                 uint64_t bufferSize = stride * static_cast<uint64_t>(returnHeight);
6126                 pixelMap->WritePixels(static_cast<const uint8_t *>(returnData), bufferSize);
6127                 std::shared_ptr<Media::PixelMap> pixelMapToJs(pixelMap.release());
6128                 jsPixelMap = OHOS::Media::PixelMapNapi::CreatePixelMap(env, pixelMapToJs);
6129             } else {
6130                 WVLOG_E("WebPageSnapshot create pixel map error");
6131             }
6132             napi_set_named_property(env, jsResult, "imagePixelMap", jsPixelMap);
6133 
6134             int returnJsWidth = 0;
6135             int returnJsHeight = 0;
6136             if (radio > 0) {
6137                 returnJsWidth = returnWidth / radio;
6138                 returnJsHeight = returnHeight / radio;
6139             }
6140             if (check) {
6141                 if (std::abs(returnJsWidth - inputWidth) < INTEGER_THREE) {
6142                     returnJsWidth = inputWidth;
6143                 }
6144 
6145                 if (std::abs(returnJsHeight - inputHeight) < INTEGER_THREE) {
6146                     returnJsHeight = inputHeight;
6147                 }
6148             }
6149             napi_value jsSizeObj = nullptr;
6150             napi_create_object(env, &jsSizeObj);
6151             napi_value jsSize[2] = {0};
6152             napi_create_int32(env, returnJsWidth, &jsSize[0]);
6153             napi_create_int32(env, returnJsHeight, &jsSize[1]);
6154             napi_set_named_property(env, jsSizeObj, "width", jsSize[0]);
6155             napi_set_named_property(env, jsSizeObj, "height", jsSize[1]);
6156             napi_set_named_property(env, jsResult, "size", jsSizeObj);
6157 
6158             napi_value jsId = nullptr;
6159             napi_create_string_utf8(env, returnId, strlen(returnId), &jsId);
6160             napi_set_named_property(env, jsResult, "id", jsId);
6161 
6162             napi_value jsStatus = nullptr;
6163             napi_get_boolean(env, returnStatus, &jsStatus);
6164             napi_set_named_property(env, jsResult, "status", jsStatus);
6165 
6166             napi_value jsError = nullptr;
6167             napi_get_undefined(env, &jsError);
6168             napi_value args[INTEGER_TWO] = {jsError, jsResult};
6169 
6170             napi_value callback = nullptr;
6171             napi_value callbackResult = nullptr;
6172             napi_get_reference_value(env, jCallback, &callback);
6173 
6174             napi_call_function(env, nullptr, callback, INTEGER_TWO, args, &callbackResult);
6175             napi_delete_reference(env, jCallback);
6176             g_inWebPageSnapshot = false;
6177         };
6178 }
6179 
WebPageSnapshot(napi_env env,napi_callback_info info)6180 napi_value NapiWebviewController::WebPageSnapshot(napi_env env, napi_callback_info info)
6181 {
6182     napi_value thisVar = nullptr;
6183     napi_value result = nullptr;
6184     size_t argc = INTEGER_TWO;
6185     napi_value argv[INTEGER_TWO] = {0};
6186 
6187     napi_get_undefined(env, &result);
6188     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6189 
6190     if (argc != INTEGER_TWO) {
6191         WVLOG_E("WebPageSnapshot: args count is not allowed.");
6192         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6193         return result;
6194     }
6195 
6196     napi_ref callback = nullptr;
6197     napi_create_reference(env, argv[INTEGER_ONE], INTEGER_ONE, &callback);
6198     if (!callback) {
6199         WVLOG_E("WebPageSnapshot failed to create reference for callback");
6200         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6201         return result;
6202     }
6203 
6204     WebviewController *webviewController = GetWebviewController(env, info);
6205     if (!webviewController) {
6206         WVLOG_E("WebPageSnapshot init webview controller error.");
6207         napi_delete_reference(env, callback);
6208         return result;
6209     }
6210 
6211     if (g_inWebPageSnapshot) {
6212         JsErrorCallback(env, std::move(callback), FUNCTION_NOT_ENABLE);
6213         return result;
6214     }
6215     g_inWebPageSnapshot = true;
6216 
6217     napi_value snapshotId = nullptr;
6218     napi_value snapshotSize = nullptr;
6219     napi_value snapshotSizeWidth = nullptr;
6220     napi_value snapshotSizeHeight = nullptr;
6221 
6222     std::string nativeSnapshotId = "";
6223     int32_t nativeSnapshotSizeWidth = 0;
6224     int32_t nativeSnapshotSizeHeight = 0;
6225     PixelUnit nativeSnapshotSizeWidthType = PixelUnit::NONE;
6226     PixelUnit nativeSnapshotSizeHeightType = PixelUnit::NONE;
6227     PixelUnit nativeSnapshotSizeType = PixelUnit::NONE;
6228 
6229     if (napi_get_named_property(env, argv[INTEGER_ZERO], "id", &snapshotId) == napi_ok) {
6230         NapiParseUtils::ParseString(env, snapshotId, nativeSnapshotId);
6231     }
6232 
6233     if (napi_get_named_property(env, argv[INTEGER_ZERO], "size", &snapshotSize) == napi_ok) {
6234         if (napi_get_named_property(env, snapshotSize, "width", &snapshotSizeWidth) == napi_ok) {
6235             if (!webviewController->ParseJsLengthToInt(env, snapshotSizeWidth,
6236                                                        nativeSnapshotSizeWidthType,
6237                                                        nativeSnapshotSizeWidth)) {
6238                 JsErrorCallback(env, std::move(callback), PARAM_CHECK_ERROR);
6239                 g_inWebPageSnapshot = false;
6240                 return result;
6241             }
6242         }
6243         if (napi_get_named_property(env, snapshotSize, "height", &snapshotSizeHeight) == napi_ok) {
6244             if (!webviewController->ParseJsLengthToInt(env, snapshotSizeHeight,
6245                                                        nativeSnapshotSizeHeightType,
6246                                                        nativeSnapshotSizeHeight)) {
6247                 JsErrorCallback(env, std::move(callback), PARAM_CHECK_ERROR);
6248                 g_inWebPageSnapshot = false;
6249                 return result;
6250             }
6251         }
6252     }
6253 
6254     if (nativeSnapshotSizeWidthType != PixelUnit::NONE && nativeSnapshotSizeHeightType != PixelUnit::NONE &&
6255         nativeSnapshotSizeWidthType != nativeSnapshotSizeHeightType) {
6256         WVLOG_E("WebPageSnapshot input different pixel unit");
6257         JsErrorCallback(env, std::move(callback), PARAM_CHECK_ERROR);
6258         g_inWebPageSnapshot = false;
6259         return result;
6260     }
6261 
6262     if (nativeSnapshotSizeWidthType != PixelUnit::NONE) {
6263         nativeSnapshotSizeType = nativeSnapshotSizeWidthType;
6264     }
6265     if (nativeSnapshotSizeHeightType != PixelUnit::NONE) {
6266         nativeSnapshotSizeType = nativeSnapshotSizeHeightType;
6267     }
6268     if (nativeSnapshotSizeWidth < 0 || nativeSnapshotSizeHeight < 0) {
6269         WVLOG_E("WebPageSnapshot input pixel length less than 0");
6270         JsErrorCallback(env, std::move(callback), PARAM_CHECK_ERROR);
6271         g_inWebPageSnapshot = false;
6272         return result;
6273     }
6274     bool pixelCheck = false;
6275     if (nativeSnapshotSizeType == PixelUnit::VP) {
6276         pixelCheck = true;
6277     }
6278     WVLOG_I("WebPageSnapshot pixel type :%{public}d", static_cast<int>(nativeSnapshotSizeType));
6279 
6280     auto resultCallback = CreateWebPageSnapshotResultCallback(
6281         env, std::move(callback), pixelCheck, nativeSnapshotSizeWidth, nativeSnapshotSizeHeight);
6282 
6283     ErrCode ret = webviewController->WebPageSnapshot(nativeSnapshotId.c_str(),
6284         nativeSnapshotSizeType,
6285         nativeSnapshotSizeWidth,
6286         nativeSnapshotSizeHeight,
6287         std::move(resultCallback));
6288     if (ret != NO_ERROR) {
6289         g_inWebPageSnapshot = false;
6290         BusinessError::ThrowErrorByErrcode(env, ret);
6291     }
6292     return result;
6293 }
6294 
SetUrlTrustList(napi_env env,napi_callback_info info)6295 napi_value NapiWebviewController::SetUrlTrustList(napi_env env, napi_callback_info info)
6296 {
6297     WVLOG_D("SetUrlTrustList invoked");
6298 
6299     napi_value result = nullptr;
6300     NAPI_CALL(env, napi_get_undefined(env, &result));
6301 
6302     napi_value thisVar = nullptr;
6303     size_t argc = INTEGER_ONE;
6304     napi_value argv[INTEGER_ONE] = { 0 };
6305     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6306     if (argc != INTEGER_ONE) {
6307         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6308             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
6309         return result;
6310     }
6311 
6312     std::string urlTrustList;
6313     if (!NapiParseUtils::ParseString(env, argv[0], urlTrustList)) {
6314         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6315             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "urlTrustList", "string"));
6316         return result;
6317     }
6318     if (urlTrustList.size() > MAX_URL_TRUST_LIST_STR_LEN) {
6319         WVLOG_E("url trust list len is too large.");
6320         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6321         return result;
6322     }
6323 
6324     WebviewController* webviewController = GetWebviewController(env, info);
6325     if (!webviewController) {
6326         WVLOG_E("webview controller is null or not init");
6327         return result;
6328     }
6329 
6330     std::string detailMsg;
6331     ErrCode ret = webviewController->SetUrlTrustList(urlTrustList, detailMsg);
6332     if (ret != NO_ERROR) {
6333         WVLOG_E("SetUrlTrustList failed, error code: %{public}d", ret);
6334         BusinessError::ThrowErrorByErrcode(env, ret,
6335             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_DETAIL_ERROR_MSG, detailMsg.c_str()));
6336         return result;
6337     }
6338     return result;
6339 }
6340 
UpdateInstanceId(napi_env env,napi_callback_info info)6341 napi_value NapiWebviewController::UpdateInstanceId(napi_env env, napi_callback_info info)
6342 {
6343     WVLOG_D("Instance changed");
6344     napi_value result = nullptr;
6345     napi_value thisVar = nullptr;
6346     size_t argc = INTEGER_ONE;
6347     napi_value argv[INTEGER_ONE] = { 0 };
6348 
6349     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6350     if (argc != INTEGER_ONE) {
6351         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6352         return result;
6353     }
6354 
6355     int32_t newId = 0;
6356     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], newId)) {
6357         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
6358         return result;
6359     }
6360 
6361     WebviewController *webviewController = nullptr;
6362     napi_status status = napi_unwrap(env, thisVar, (void **)&webviewController);
6363     if ((!webviewController) || (status != napi_ok) || !webviewController->IsInit()) {
6364         return result;
6365     }
6366 
6367     webviewController->UpdateInstanceId(newId);
6368 
6369     NAPI_CALL(env, napi_get_undefined(env, &result));
6370     return result;
6371 }
6372 
SetPathAllowingUniversalAccess(napi_env env,napi_callback_info info)6373 napi_value NapiWebviewController::SetPathAllowingUniversalAccess(
6374     napi_env env, napi_callback_info info)
6375 {
6376     napi_value result = nullptr;
6377     napi_value thisVar = nullptr;
6378     size_t argc = INTEGER_ONE;
6379     napi_value argv[INTEGER_ONE] = { 0 };
6380     NAPI_CALL(env, napi_get_undefined(env, &result));
6381     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6382     WebviewController *webviewController = GetWebviewController(env, info);
6383     if (!webviewController) {
6384         WVLOG_E("SetPathAllowingUniversalAccess init webview controller error.");
6385         return result;
6386     }
6387     bool isArray = false;
6388     NAPI_CALL(env, napi_is_array(env, argv[INTEGER_ZERO], &isArray));
6389     if (!isArray) {
6390         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6391             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "pathList", "Array<string>"));
6392         return result;
6393     }
6394     std::vector<std::string> pathList;
6395     uint32_t pathCount = 0;
6396     NAPI_CALL(env, napi_get_array_length(env, argv[INTEGER_ZERO], &pathCount));
6397     for (uint32_t i = 0 ; i < pathCount ; i++) {
6398         napi_value pathItem = nullptr;
6399         napi_get_element(env, argv[INTEGER_ZERO], i, &pathItem);
6400         std::string path;
6401         if (!NapiParseUtils::ParseString(env, pathItem, path)) {
6402             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6403                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "pathList", "Array<string>"));
6404             return result;
6405         }
6406         if (path.empty()) {
6407             BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6408                 NWebError::FormatString("BusinessError 401: Parameter error. Path: '%s' is invalid", path.c_str()));
6409             return result;
6410         }
6411         pathList.emplace_back(path);
6412     }
6413     std::string errorPath;
6414     webviewController->SetPathAllowingUniversalAccess(pathList, errorPath);
6415     if (!errorPath.empty()) {
6416         WVLOG_E("%{public}s is invalid.", errorPath.c_str());
6417         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6418             NWebError::FormatString("BusinessError 401: Parameter error. Path: '%s' is invalid", errorPath.c_str()));
6419     }
6420     return result;
6421 }
6422 
ScrollByWithResult(napi_env env,napi_callback_info info)6423 napi_value NapiWebviewController::ScrollByWithResult(napi_env env, napi_callback_info info)
6424 {
6425    napi_value thisVar = nullptr;
6426    napi_value result = nullptr;
6427    size_t argc = INTEGER_TWO;
6428    napi_value argv[INTEGER_TWO] = { 0 };
6429    float deltaX;
6430    float deltaY;
6431 
6432    napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6433    if (argc != INTEGER_TWO) {
6434        BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6435            NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "two"));
6436        return result;
6437    }
6438 
6439    if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ZERO], deltaX)) {
6440        BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6441            NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "deltaX", "number"));
6442        return result;
6443    }
6444 
6445    if (!NapiParseUtils::ParseFloat(env, argv[INTEGER_ONE], deltaY)) {
6446        BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6447            NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "deltaY", "number"));
6448        return result;
6449    }
6450 
6451    WebviewController *webviewController = GetWebviewController(env, info);
6452    if (!webviewController) {
6453        return nullptr;
6454    }
6455 
6456    bool scrollByWithResult = webviewController->ScrollByWithResult(deltaX, deltaY);
6457    NAPI_CALL(env, napi_get_boolean(env, scrollByWithResult, &result));
6458    return result;
6459 }
6460 
GetScrollOffset(napi_env env,napi_callback_info info)6461 napi_value NapiWebviewController::GetScrollOffset(napi_env env,
6462     napi_callback_info info)
6463 {
6464     napi_value result = nullptr;
6465     napi_value horizontal;
6466     napi_value vertical;
6467     float offsetX = 0;
6468     float offsetY = 0;
6469 
6470     WebviewController* webviewController = GetWebviewController(env, info);
6471     if (!webviewController) {
6472         return nullptr;
6473     }
6474 
6475     webviewController->GetScrollOffset(&offsetX, &offsetY);
6476 
6477     napi_create_object(env, &result);
6478     napi_create_double(env, static_cast<double>(offsetX), &horizontal);
6479     napi_create_double(env, static_cast<double>(offsetY), &vertical);
6480     napi_set_named_property(env, result, "x", horizontal);
6481     napi_set_named_property(env, result, "y", vertical);
6482     return result;
6483 }
6484 
TrimMemoryByPressureLevel(napi_env env,napi_callback_info info)6485 napi_value NapiWebviewController::TrimMemoryByPressureLevel(napi_env env,
6486     napi_callback_info info)
6487 {
6488     napi_value thisVar = nullptr;
6489     napi_value result = nullptr;
6490     size_t argc = INTEGER_ONE;
6491     napi_value argv[INTEGER_ONE] = { 0 };
6492     int32_t memoryLevel;
6493     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
6494     if (argc != INTEGER_ONE) {
6495         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6496             NWebError::FormatString(
6497                 ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
6498         return result;
6499     }
6500 
6501     if (!NapiParseUtils::ParseInt32(env, argv[INTEGER_ZERO], memoryLevel)) {
6502         BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
6503             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR,
6504                                     "PressureLevel", "number"));
6505         return result;
6506     }
6507 
6508     memoryLevel = memoryLevel == 1 ? 0 : memoryLevel;
6509     NWebHelper::Instance().TrimMemoryByPressureLevel(memoryLevel);
6510     NAPI_CALL(env, napi_get_undefined(env, &result));
6511     return result;
6512 }
6513 } // namespace NWeb
6514 } // namespace OHOS
6515