1 /*
2 * Copyright (c) 2025 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/native_api.h"
17 #include "web/arkweb_interface.h"
18 #include "web/arkweb_scheme_handler.h"
19 #include <cstdint>
20 #include <hilog/log.h>
21 #include <js_native_api_types.h>
22 #include <string>
23 #include <web/arkweb_error_code.h>
24 #include <web/arkweb_type.h>
25 #include <web/native_interface_arkweb.h>
26
27 #undef LOG_TAG
28 #define LOG_TAG "web_net"
29 #define ARGS_INDEX_ZERO 0
30 #define ARGS_INDEX_ONE 1
31 #define ARGS_INDEX_TWO 2
32 #define CASE_NUM_0 0
33 #define CASE_NUM_1 1
34 #define CASE_NUM_2 2
35 #define CASE_NUM_3 3
36 #define CASE_NUM_4 4
37 #define CASE_NUM_5 5
38 #define CASE_NUM_6 6
39 #define CASE_NUM_7 7
40 #define CASE_NUM_8 8
41 #define CASE_NUM_9 9
42 #define CASE_NUM_10 10
43 #define CASE_NUM_11 11
44 #define CASE_NUM_12 12
45 const int32_t MAX_WEB_NAME_SIZE = 32;
46
GetTestCase(napi_env & env,napi_callback_info & info,char * webName,int32_t & caseNum)47 static void GetTestCase(napi_env &env, napi_callback_info &info, char* webName, int32_t &caseNum)
48 {
49 size_t argc = 2;
50 napi_value args[ARGS_INDEX_TWO] = {nullptr};
51 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
52
53 // 获取第一个参数 webName
54 size_t webNameSize = 0;
55 napi_get_value_string_utf8(env, args[ARGS_INDEX_ZERO], nullptr, 0, &webNameSize);
56 if (webNameSize > MAX_WEB_NAME_SIZE) {
57 napi_throw_type_error(env, nullptr, "webName must less than 32");
58 return;
59 }
60 napi_get_value_string_utf8(env, args[ARGS_INDEX_ZERO], webName, webNameSize + 1, &webNameSize);
61 // 获取第二个参数 caseNum
62 napi_valuetype valuetype;
63 napi_typeof(env, args[ARGS_INDEX_ONE], &valuetype);
64 if (valuetype != napi_number) {
65 napi_throw_type_error(env, nullptr, "Argument must be a number");
66 return;
67 }
68 napi_get_value_int32(env, args[ARGS_INDEX_ONE], &caseNum);
69 return;
70 }
71
GetCaseNum(napi_env & env,napi_callback_info & info)72 static int32_t GetCaseNum(napi_env &env, napi_callback_info &info)
73 {
74 size_t argc = ARGS_INDEX_ONE;
75 napi_value args[ARGS_INDEX_ONE] = {nullptr};
76 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
77 // 获取第一个参数 caseNum
78 int32_t caseNum = -1;
79 napi_get_value_int32(env, args[ARGS_INDEX_ZERO], &caseNum);
80 return caseNum;
81 }
82
loadData(napi_env env,napi_callback_info info)83 static napi_value loadData(napi_env env, napi_callback_info info)
84 {
85 char webName[MAX_WEB_NAME_SIZE] = {0};
86 int32_t caseNum = -1;
87 GetTestCase(env, info, webName, caseNum);
88
89 ArkWeb_ErrorCode ret;
90
91 switch (caseNum) {
92 case CASE_NUM_0:
93 // ARKWEB_SUCCESS
94 ret = OH_NativeArkWeb_LoadData(webName, "/index", "text/html", "UTF-8", "www.baidu.com", "");
95 break;
96 case CASE_NUM_1:
97 ret = OH_NativeArkWeb_LoadData("new", "/index", "text/html", "UTF-8", "www.baidu.com", "");
98 break;
99 case CASE_NUM_2:
100 try {
101 ret = OH_NativeArkWeb_LoadData(webName, "", "text/html", "UTF-8", "www.baidu.com", "");
102 } catch (std::exception &err) {
103 OH_LOG_ERROR(LOG_APP, "loadData 2 error:%{public}s", err.what());
104 }
105 break;
106 case CASE_NUM_3:
107 try {
108 ret = OH_NativeArkWeb_LoadData(webName, "/index", "", "UTF-8", "www.baidu.com", "");
109 } catch (std::exception &err) {
110 OH_LOG_ERROR(LOG_APP, "loadData 3 error:%{public}s", err.what());
111 }
112 break;
113 case CASE_NUM_4:
114 try {
115 ret = OH_NativeArkWeb_LoadData(webName, "/index", "text/html", "", "www.baidu.com", "");
116 } catch (std::exception &err) {
117 OH_LOG_ERROR(LOG_APP, "loadData 4 error:%{public}s", err.what());
118 }
119 break;
120 case CASE_NUM_5:
121 try {
122 ret = OH_NativeArkWeb_LoadData(webName, "", "", nullptr, "www.baidu.com", "");
123 } catch (std::exception &err) {
124 OH_LOG_ERROR(LOG_APP, "loadData 5 error:%{public}s", err.what());
125 }
126 break;
127 default:
128 return nullptr;
129 }
130 napi_value result;
131 napi_create_int32(env, ret, &result);
132 return result;
133 }
134
GetBlanklessInfo(napi_env env,napi_callback_info info)135 static napi_value GetBlanklessInfo(napi_env env, napi_callback_info info)
136 {
137 OH_LOG_DEBUG(LOG_APP, "GetBlanklessInfo start..");
138 char webName[MAX_WEB_NAME_SIZE] = {0};
139 int32_t caseNum = -1;
140 GetTestCase(env, info, webName, caseNum);
141
142 ArkWeb_BlanklessInfo retInfo = {ARKWEB_BLANKLESS_SUCCESS, 0, 0};
143 switch (caseNum) {
144 case CASE_NUM_0:
145 retInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "0731");
146 break;
147 case CASE_NUM_1:
148 retInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "newkey");
149 break;
150 case CASE_NUM_2:
151 retInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "");
152 break;
153 case CASE_NUM_3:
154 try {
155 retInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "0731");
156 } catch (std::exception &err) {
157 OH_LOG_ERROR(LOG_APP, "nullptr error:%{public}s", err.what());
158 }
159 break;
160 default:
161 break;
162 }
163 napi_value result;
164 napi_create_int32(env, retInfo.errCode, &result);
165 OH_LOG_INFO(LOG_APP, "GetBlanklessInfo errcode = %{public}d, loadingTime = %{public}u, similarity = %{public}f",
166 retInfo.errCode, retInfo.loadingTime, retInfo.similarity);
167 return result;
168 }
169
SetBlanklessInfo(napi_env env,napi_callback_info info)170 static napi_value SetBlanklessInfo(napi_env env, napi_callback_info info)
171 {
172 OH_LOG_DEBUG(LOG_APP, "SetBlanklessInfo start..");
173 char webName[MAX_WEB_NAME_SIZE] = {0};
174 int32_t caseNum = -1;
175 GetTestCase(env, info, webName, caseNum);
176
177 ArkWeb_BlanklessErrorCode retInfo = ARKWEB_BLANKLESS_SUCCESS;
178 ArkWeb_BlanklessInfo blankInfo = {ARKWEB_BLANKLESS_SUCCESS, 0, 0};
179 try {
180 switch (caseNum) {
181 case CASE_NUM_0:
182 blankInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey("new", "xxxx");
183 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey("new", "xxxx", false);
184 break;
185 case CASE_NUM_1:
186 blankInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "0731");
187 if (blankInfo.errCode == ARKWEB_BLANKLESS_SUCCESS) {
188 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey(webName, "0731", false);
189 }
190 break;
191 case CASE_NUM_2:
192 blankInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "0731");
193 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey(webName, "xxxxx", false);
194 break;
195 case CASE_NUM_3:
196 blankInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "0731");
197 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey(webName, "0731", true);
198 break;
199 case CASE_NUM_4:
200 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "0731", false);
201 break;
202 case CASE_NUM_5:
203 blankInfo = OH_NativeArkWeb_GetBlanklessInfoWithKey(webName, "");
204 retInfo = OH_NativeArkWeb_SetBlanklessLoadingWithKey(webName, "", false);
205 break;
206 default:
207 break;
208 }
209 } catch (std::exception &err) {
210 OH_LOG_ERROR(LOG_APP, "SetBlanklessInfo error:%{public}s", err.what());
211 }
212
213 napi_value result;
214 napi_create_int32(env, retInfo, &result);
215 OH_LOG_INFO(LOG_APP, "SetBlanklessInfo errcode = %{public}d", retInfo);
216 return result;
217 }
218
JSCallBack(const char * webTag,const ArkWeb_JavaScriptBridgeData * data,void * userData)219 static void JSCallBack(const char *webTag, const ArkWeb_JavaScriptBridgeData *data, void *userData)
220 {
221 if (webTag == nullptr || data == nullptr || userData == nullptr) {
222 return;
223 }
224
225 if (data->buffer == nullptr) {
226 return;
227 }
228 if (data->size == 0) {
229 return;
230 }
231 return;
232 }
233
JSBridgeData(napi_env env,napi_callback_info info)234 static napi_value JSBridgeData(napi_env env, napi_callback_info info)
235 {
236 OH_LOG_DEBUG(LOG_APP, "JSBridageData start..");
237 int32_t caseNum = GetCaseNum(env, info);
238
239 ArkWeb_OnJavaScriptCallback callBack = JSCallBack;
240 const size_t dataLen = 10;
241 const uint8_t data[dataLen] = {0};
242 ArkWeb_JavaScriptBridgeData bridgeData;
243 bridgeData.buffer = data;
244 bridgeData.size = dataLen;
245 const size_t userDataLen = 100;
246 char userData[userDataLen] = {0};
247 switch (caseNum) {
248 case CASE_NUM_0:
249 callBack("0731", &bridgeData, static_cast<void *>(userData));
250 break;
251 case CASE_NUM_1:
252 callBack("0731", &bridgeData, nullptr);
253 break;
254 case CASE_NUM_2:
255 callBack("0731", nullptr, static_cast<void *>(userData));
256 break;
257 case CASE_NUM_3:
258 callBack(nullptr, &bridgeData, static_cast<void *>(userData));
259 break;
260 default:
261 break;
262 }
263 napi_value result;
264 napi_create_int32(env, 0, &result);
265 OH_LOG_DEBUG(LOG_APP, "JSBridageData end..");
266 return result;
267 }
268
JSProxyCallBack(const char * webTag,const ArkWeb_JavaScriptBridgeData * dataArray,size_t arraySize,void * userData)269 static void JSProxyCallBack(const char *webTag, const ArkWeb_JavaScriptBridgeData *dataArray, size_t arraySize,
270 void *userData)
271 {
272 if (webTag == nullptr || dataArray == nullptr || userData == nullptr) {
273 return;
274 }
275
276 if (arraySize == 0) {
277 return;
278 }
279 if (dataArray[0].size == 0) {
280 return;
281 }
282 return;
283 }
284
JSBridgeProxyData(napi_env env,napi_callback_info info)285 static napi_value JSBridgeProxyData(napi_env env, napi_callback_info info)
286 {
287 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData start..");
288 int32_t caseNum = GetCaseNum(env, info);
289
290 ArkWeb_OnJavaScriptProxyCallback callBack = JSProxyCallBack;
291 const size_t dataLen = 10;
292 ArkWeb_JavaScriptBridgeData bridgeData[dataLen];
293 const size_t userDataLen = 100;
294 char userData[userDataLen] = {0};
295 switch (caseNum) {
296 case CASE_NUM_0:
297 callBack("0731", bridgeData, dataLen, static_cast<void *>(userData));
298 break;
299 case CASE_NUM_1:
300 callBack("0731", bridgeData, 0, static_cast<void *>(userData));
301 break;
302 case CASE_NUM_2:
303 callBack("0731", nullptr, dataLen, static_cast<void *>(userData));
304 break;
305 case CASE_NUM_3:
306 callBack("0731", bridgeData, dataLen, nullptr);
307 break;
308 case CASE_NUM_4:
309 callBack(nullptr, bridgeData, dataLen, static_cast<void *>(userData));
310 break;
311 default:
312 break;
313 }
314 napi_value result;
315 napi_create_int32(env, 0, &result);
316 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData end..");
317 return result;
318 }
319
CreateMsg()320 static ArkWeb_WebMessagePtr CreateMsg()
321 {
322 static ArkWeb_WebMessagePtr pMsg = nullptr;
323 return pMsg;
324 }
325
DestroyMsg(ArkWeb_WebMessagePtr * webMessage)326 void DestroyMsg(ArkWeb_WebMessagePtr *webMessage)
327 {
328 if (webMessage == nullptr) {
329 return;
330 }
331 }
332
SetType(ArkWeb_WebMessagePtr webMessage,ArkWeb_WebMessageType type)333 static void SetType(ArkWeb_WebMessagePtr webMessage, ArkWeb_WebMessageType type)
334 {
335 if (webMessage == nullptr) {
336 return;
337 }
338 ArkWeb_WebMessageType onType = type;
339 if (onType >= ARKWEB_BUFFER) {
340 return;
341 }
342 }
343
GetType(ArkWeb_WebMessagePtr webMessage)344 static ArkWeb_WebMessageType GetType(ArkWeb_WebMessagePtr webMessage)
345 {
346 if (webMessage == nullptr) {
347 return ARKWEB_NONE;
348 }
349 return ARKWEB_STRING;
350 }
351
SetData(ArkWeb_WebMessagePtr webMessage,void * data,size_t dataLength)352 static void SetData(ArkWeb_WebMessagePtr webMessage, void *data, size_t dataLength)
353 {
354 if (webMessage == nullptr || data == nullptr) {
355 return;
356 }
357 if (dataLength > 0) {
358 return;
359 }
360 }
361
GetData(ArkWeb_WebMessagePtr webMessage,size_t * dataLength)362 static void *GetData(ArkWeb_WebMessagePtr webMessage, size_t *dataLength)
363 {
364 if (webMessage == nullptr || dataLength == nullptr) {
365 return nullptr;
366 }
367 if (*dataLength == 0) {
368 return nullptr;
369 }
370 return webMessage;
371 }
372
WebMsgType(napi_env env,napi_callback_info info)373 static napi_value WebMsgType(napi_env env, napi_callback_info info)
374 {
375 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData start..");
376 int32_t caseNum = GetCaseNum(env, info);
377
378 const size_t msgLen = 10;
379 static char msg[msgLen] = "test";
380 ArkWeb_WebMessagePtr pMsg = reinterpret_cast<ArkWeb_WebMessagePtr>(msg);
381 switch (caseNum) {
382 case CASE_NUM_0:
383 SetType(nullptr, ARKWEB_NONE);
384 break;
385 case CASE_NUM_1:
386 SetType(pMsg, ARKWEB_STRING);
387 break;
388 case CASE_NUM_2:
389 SetType(pMsg, ARKWEB_BUFFER);
390 break;
391 default:
392 break;
393 }
394 napi_value result;
395 napi_create_int32(env, 0, &result);
396 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData end..");
397 return result;
398 }
399
WebMsgAPI(napi_env env,napi_callback_info info)400 static napi_value WebMsgAPI(napi_env env, napi_callback_info info)
401 {
402 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData start..");
403 int32_t caseNum = GetCaseNum(env, info);
404
405 ArkWeb_WebMessageAPI api = {0};
406 switch (caseNum) {
407 case CASE_NUM_0:
408 api.size = sizeof(ArkWeb_WebMessageAPI);
409 break;
410 case CASE_NUM_1:
411 api.createWebMessage = CreateMsg;
412 break;
413 case CASE_NUM_2:
414 api.destroyWebMessage = DestroyMsg;
415 break;
416 case CASE_NUM_3:
417 api.setType = SetType;
418 break;
419 case CASE_NUM_4:
420 api.getType = GetType;
421 break;
422 case CASE_NUM_5:
423 api.setData = SetData;
424 break;
425 case CASE_NUM_6:
426 api.getData = GetData;
427 break;
428 default:
429 break;
430 }
431 napi_value result;
432 napi_create_int32(env, 0, &result);
433 OH_LOG_DEBUG(LOG_APP, "JSBridgeProxyData end..");
434 return result;
435 }
436
createJSValue(ArkWeb_JavaScriptValueType type,void * data,size_t len)437 static ArkWeb_JavaScriptValuePtr createJSValue(ArkWeb_JavaScriptValueType type, void *data, size_t len)
438 {
439 if (data == nullptr || len == 0) {
440 return nullptr;
441 }
442 if (type == ARKWEB_JAVASCRIPT_NONE) {
443 return nullptr;
444 }
445
446 return static_cast<ArkWeb_JavaScriptValuePtr>(data);
447 }
448
WebJSValueAPI(napi_env env,napi_callback_info info)449 static napi_value WebJSValueAPI(napi_env env, napi_callback_info info)
450 {
451 OH_LOG_DEBUG(LOG_APP, "WebJSValueAPI start..");
452 int32_t caseNum = GetCaseNum(env, info);
453
454 ArkWeb_JavaScriptValueAPI api = {0};
455 switch (caseNum) {
456 case CASE_NUM_0:
457 api.size = sizeof(ArkWeb_JavaScriptValueAPI);
458 break;
459 case CASE_NUM_1:
460 api.createJavaScriptValue = createJSValue;
461 break;
462 default:
463 break;
464 }
465 napi_value result;
466 napi_create_int32(env, 0, &result);
467 OH_LOG_DEBUG(LOG_APP, "WebJSValueAPI end..");
468 return result;
469 }
470
WebJSValueType(napi_env env,napi_callback_info info)471 static napi_value WebJSValueType(napi_env env, napi_callback_info info)
472 {
473 OH_LOG_DEBUG(LOG_APP, "WebJSValueType start..");
474 int32_t caseNum = GetCaseNum(env, info);
475 ArkWeb_JavaScriptValuePtr jsValue = nullptr;
476 char test[] = "test";
477 switch (caseNum) {
478 case CASE_NUM_0:
479 jsValue = createJSValue(ARKWEB_JAVASCRIPT_NONE, nullptr, 0);
480 break;
481 case CASE_NUM_1:
482 jsValue = createJSValue(ARKWEB_JAVASCRIPT_STRING, static_cast<void *>(test), sizeof(test));
483 break;
484 case CASE_NUM_2:
485 jsValue = createJSValue(ARKWEB_JAVASCRIPT_BOOL, static_cast<void *>(test), sizeof(test));
486 break;
487 default:
488 break;
489 }
490 napi_value result;
491 napi_create_int32(env, 0, &result);
492 OH_LOG_DEBUG(LOG_APP, "WebJSValueType end..");
493 return result;
494 }
495
RunJavaScript(const char * webTag,const ArkWeb_JavaScriptObject * javascriptObject)496 static void RunJavaScript(const char* webTag, const ArkWeb_JavaScriptObject* javascriptObject)
497 {
498 if (webTag == nullptr) {
499 return;
500 }
501 if (javascriptObject == nullptr) {
502 return;
503 }
504 }
505
WebJSObject(napi_env env,napi_callback_info info)506 static napi_value WebJSObject(napi_env env, napi_callback_info info)
507 {
508 OH_LOG_DEBUG(LOG_APP, "JSObject start..");
509 int32_t caseNum = GetCaseNum(env, info);
510
511 const uint32_t len = 10;
512 const uint8_t script[len] = {0};
513 char test[] = "test";
514 ArkWeb_JavaScriptObject jsObject = {0};
515 switch (caseNum) {
516 case CASE_NUM_0:
517 jsObject.size = sizeof(script);
518 break;
519 case CASE_NUM_1:
520 jsObject.buffer = script;
521 break;
522 case CASE_NUM_2:
523 jsObject.callback = JSCallBack;
524 break;
525 case CASE_NUM_3:
526 jsObject.userData = static_cast<void*>(test);
527 break;
528 default:
529 break;
530 }
531 napi_value result;
532 napi_create_int32(env, 0, &result);
533 OH_LOG_DEBUG(LOG_APP, "JSObject end..");
534 return result;
535 }
536
WebControllerAPI(napi_env env,napi_callback_info info)537 static napi_value WebControllerAPI(napi_env env, napi_callback_info info)
538 {
539 OH_LOG_DEBUG(LOG_APP, "WebControllerAPI start..");
540 int32_t caseNum = GetCaseNum(env, info);
541
542 ArkWeb_ControllerAPI ctrlApi = {0};
543 switch (caseNum) {
544 case CASE_NUM_0:
545 ctrlApi.size = sizeof(ArkWeb_ControllerAPI);
546 break;
547 case CASE_NUM_1:
548 case CASE_NUM_2:
549 case CASE_NUM_3:
550 case CASE_NUM_4:
551 case CASE_NUM_5:
552 case CASE_NUM_6:
553 case CASE_NUM_7:
554 case CASE_NUM_8:
555 case CASE_NUM_9:
556 case CASE_NUM_10:
557 case CASE_NUM_11:
558 ctrlApi.runJavaScript = RunJavaScript;
559 ctrlApi.registerJavaScriptProxy = nullptr;
560 ctrlApi.deleteJavaScriptRegister = nullptr;
561 ctrlApi.refresh = nullptr;
562 ctrlApi.registerAsyncJavaScriptProxy = nullptr;
563 ctrlApi.createWebMessagePorts = nullptr;
564 ctrlApi.destroyWebMessagePorts = nullptr;
565 ctrlApi.postWebMessage = nullptr;
566 ctrlApi.getLastJavascriptProxyCallingFrameUrl = nullptr;
567 ctrlApi.registerJavaScriptProxyEx = nullptr;
568 ctrlApi.registerAsyncJavaScriptProxyEx = nullptr;
569 break;
570 default:
571 break;
572 }
573 napi_value result;
574 napi_create_int32(env, 0, &result);
575 OH_LOG_DEBUG(LOG_APP, "WebControllerAPI end..");
576 return result;
577 }
578
WebStructProxyMethod(napi_env env,napi_callback_info info)579 static napi_value WebStructProxyMethod(napi_env env, napi_callback_info info)
580 {
581 OH_LOG_DEBUG(LOG_APP, "WebStructProxyMethod start..");
582 int32_t caseNum = GetCaseNum(env, info);
583
584 ArkWeb_ProxyMethod proxyMethod = {0};
585 char data[] = "test for user data";
586 switch (caseNum) {
587 case CASE_NUM_0:
588 proxyMethod.methodName = "test";
589 break;
590 case CASE_NUM_1:
591 proxyMethod.callback = JSProxyCallBack;
592 break;
593 case CASE_NUM_2:
594 proxyMethod.userData = static_cast<void*>(data);
595 break;
596 default:
597 break;
598 }
599 napi_value result;
600 napi_create_int32(env, 0, &result);
601 OH_LOG_DEBUG(LOG_APP, "WebStructProxyMethod end..");
602 return result;
603 }
604
WebStructProxyMethodWithResult(napi_env env,napi_callback_info info)605 static napi_value WebStructProxyMethodWithResult(napi_env env, napi_callback_info info)
606 {
607 OH_LOG_DEBUG(LOG_APP, "WebStructProxyMethodWithResult start..");
608 int32_t caseNum = GetCaseNum(env, info);
609
610 ArkWeb_ProxyMethodWithResult method = {0};
611 char data[] = "test for user data";
612 switch (caseNum) {
613 case CASE_NUM_0:
614 method.methodName = "test";
615 break;
616 case CASE_NUM_1:
617 method.callback = [](const char *webTag, const ArkWeb_JavaScriptBridgeData *dataArray, size_t arraySize,
618 void *userData) -> ArkWeb_JavaScriptValuePtr { return nullptr; };
619 break;
620 case CASE_NUM_2:
621 method.userData = static_cast<void*>(data);
622 break;
623 default:
624 break;
625 }
626 napi_value result;
627 napi_create_int32(env, 0, &result);
628 OH_LOG_DEBUG(LOG_APP, "WebStructProxyMethodWithResult end..");
629 return result;
630 }
631
WebStructProxyObject(napi_env env,napi_callback_info info)632 static napi_value WebStructProxyObject(napi_env env, napi_callback_info info)
633 {
634 OH_LOG_DEBUG(LOG_APP, "WebStructProxyObject start..");
635 int32_t caseNum = GetCaseNum(env, info);
636
637 ArkWeb_ProxyObject obj = {0};
638 const size_t listSize = 10;
639 ArkWeb_ProxyMethod methodList[listSize] = {0};
640 char data[] = "test for user data";
641 switch (caseNum) {
642 case CASE_NUM_0:
643 obj.objName = "testObj";
644 break;
645 case CASE_NUM_1:
646 obj.methodList = methodList;
647 break;
648 case CASE_NUM_2:
649 obj.size = listSize;
650 break;
651 default:
652 break;
653 }
654 napi_value result;
655 napi_create_int32(env, 0, &result);
656 OH_LOG_DEBUG(LOG_APP, "WebStructProxyObject end..");
657 return result;
658 }
659
WebStructProxyObjectWithResult(napi_env env,napi_callback_info info)660 static napi_value WebStructProxyObjectWithResult(napi_env env, napi_callback_info info)
661 {
662 OH_LOG_DEBUG(LOG_APP, "WebStructProxyObjectWithResult start..");
663 int32_t caseNum = GetCaseNum(env, info);
664
665 ArkWeb_ProxyObjectWithResult obj = {0};
666 const size_t listSize = 10;
667 ArkWeb_ProxyMethodWithResult methodList[listSize] = {0};
668 char data[] = "test for user data";
669 switch (caseNum) {
670 case CASE_NUM_0:
671 obj.objName = "testObjWithResult";
672 break;
673 case CASE_NUM_1:
674 obj.methodList = methodList;
675 break;
676 case CASE_NUM_2:
677 obj.size = listSize;
678 break;
679 default:
680 break;
681 }
682 napi_value result;
683 napi_create_int32(env, 0, &result);
684 OH_LOG_DEBUG(LOG_APP, "WebStructProxyObjectWithResult end..");
685 return result;
686 }
687
WebStructComponentAPI(napi_env env,napi_callback_info info)688 static napi_value WebStructComponentAPI(napi_env env, napi_callback_info info)
689 {
690 OH_LOG_DEBUG(LOG_APP, "WebStructComponentAPI start..");
691 int32_t caseNum = GetCaseNum(env, info);
692
693 ArkWeb_ComponentAPI api = {0};
694 auto onCallBack = [](const char *webTag, ArkWeb_OnComponentCallback callback, void *userData) { return; };
695 switch (caseNum) {
696 case CASE_NUM_0:
697 api.size = sizeof(ArkWeb_ComponentAPI);
698 break;
699 case CASE_NUM_1:
700 api.onControllerAttached = onCallBack;
701 break;
702 case CASE_NUM_2:
703 api.onPageBegin = onCallBack;
704 break;
705 case CASE_NUM_3:
706 api.onPageEnd = onCallBack;
707 break;
708 case CASE_NUM_4:
709 api.onDestroy = onCallBack;
710 break;
711 default:
712 break;
713 }
714 napi_value result;
715 napi_create_int32(env, 0, &result);
716 OH_LOG_DEBUG(LOG_APP, "WebStructComponentAPI end..");
717 return result;
718 }
719
WebStructMessagePortAPI(napi_env env,napi_callback_info info)720 static napi_value WebStructMessagePortAPI(napi_env env, napi_callback_info info)
721 {
722 OH_LOG_DEBUG(LOG_APP, "WebStructMessagePortAPI start..");
723 int32_t caseNum = GetCaseNum(env, info);
724
725 ArkWeb_WebMessagePortAPI api = {0};
726 switch (caseNum) {
727 case CASE_NUM_0:
728 api.size = sizeof(ArkWeb_WebMessagePortAPI);
729 break;
730 case CASE_NUM_1:
731 api.postMessage = [](const ArkWeb_WebMessagePortPtr webMessagePort, const char *webTag,
732 const ArkWeb_WebMessagePtr webMessage) -> ArkWeb_ErrorCode { return ARKWEB_SUCCESS; };
733 break;
734 case CASE_NUM_2:
735 api.close = [](const ArkWeb_WebMessagePortPtr webMessagePort, const char* webTag) { return; };
736 break;
737 case CASE_NUM_3:
738 api.setMessageEventHandler = [](const ArkWeb_WebMessagePortPtr webMessagePort, const char *webTag,
739 ArkWeb_OnMessageEventHandler handler, void *userData) { return; };
740 break;
741 default:
742 break;
743 }
744 napi_value result;
745 napi_create_int32(env, 0, &result);
746 OH_LOG_DEBUG(LOG_APP, "WebStructMessagePortAPI end..");
747 return result;
748 }
749
WebStructCookieManagerAPI(napi_env env,napi_callback_info info)750 static napi_value WebStructCookieManagerAPI(napi_env env, napi_callback_info info)
751 {
752 OH_LOG_DEBUG(LOG_APP, "WebStructCookieManagerAPI start..");
753 int32_t caseNum = GetCaseNum(env, info);
754
755 ArkWeb_CookieManagerAPI api = {0};
756 switch (caseNum) {
757 case CASE_NUM_0:
758 api.size = sizeof(ArkWeb_CookieManagerAPI);
759 break;
760 case CASE_NUM_1:
761 api.fetchCookieSync = [](const char* url, bool incognito, bool includeHttpOnly,
762 char** cookieValue) -> ArkWeb_ErrorCode { return ARKWEB_SUCCESS; };
763 break;
764 case CASE_NUM_2:
765 api.configCookieSync = [](const char *url, const char *cookieValue, bool incognito,
766 bool includeHttpOnly) -> ArkWeb_ErrorCode { return ARKWEB_SUCCESS; };
767 break;
768 case CASE_NUM_3:
769 api.existCookies = [](bool incognito) { return false; };
770 break;
771 case CASE_NUM_4:
772 api.clearAllCookiesSync = [](bool incognito) { return; };
773 break;
774 case CASE_NUM_5:
775 api.clearSessionCookiesSync = []() { return; };
776 break;
777 default:
778 break;
779 }
780 napi_value result;
781 napi_create_int32(env, 0, &result);
782 OH_LOG_DEBUG(LOG_APP, "WebStructCookieManagerAPI end..");
783 return result;
784 }
785
WebStructJavaScriptValueAPI(napi_env env,napi_callback_info info)786 static napi_value WebStructJavaScriptValueAPI(napi_env env, napi_callback_info info)
787 {
788 OH_LOG_DEBUG(LOG_APP, "WebStructCookieManagerAPI start..");
789 int32_t caseNum = GetCaseNum(env, info);
790
791 ArkWeb_JavaScriptValueAPI api = {0};
792 switch (caseNum) {
793 case CASE_NUM_0:
794 api.size = sizeof(ArkWeb_JavaScriptValueAPI);
795 break;
796 case CASE_NUM_1:
797 api.createJavaScriptValue = [](ArkWeb_JavaScriptValueType type, void* data,
798 size_t dataLength) -> ArkWeb_JavaScriptValuePtr { return nullptr; };
799 break;
800 default:
801 break;
802 }
803 napi_value result;
804 napi_create_int32(env, 0, &result);
805 OH_LOG_DEBUG(LOG_APP, "WebStructCookieManagerAPI end..");
806 return result;
807 }
808
WebRegisterJSProxy(napi_env env,napi_callback_info info)809 static napi_value WebRegisterJSProxy(napi_env env, napi_callback_info info)
810 {
811 OH_LOG_DEBUG(LOG_APP, "WebRegJSProxy start..");
812 char webName[MAX_WEB_NAME_SIZE] = {0};
813 int32_t caseNum = -1;
814 GetTestCase(env, info, webName, caseNum);
815
816 ArkWeb_ProxyObjectWithResult proxyObject = {0};
817 proxyObject.objName = "registerForTest";
818 ArkWeb_ProxyMethodWithResult method = {"test", nullptr, nullptr};
819 proxyObject.size = 1;
820 proxyObject.methodList = &method;
821 const char* permission = "all";
822 switch (caseNum) {
823 case CASE_NUM_0:
824 OH_NativeArkWeb_RegisterAsyncThreadJavaScriptProxy(webName, &proxyObject, permission);
825 break;
826 case CASE_NUM_1:
827 OH_NativeArkWeb_RegisterAsyncThreadJavaScriptProxy(webName, &proxyObject, nullptr);
828 break;
829 case CASE_NUM_2:
830 OH_NativeArkWeb_RegisterAsyncThreadJavaScriptProxy(webName, nullptr, permission);
831 break;
832 case CASE_NUM_3:
833 OH_NativeArkWeb_RegisterAsyncThreadJavaScriptProxy("newTest", &proxyObject, permission);
834 break;
835 case CASE_NUM_4:
836 proxyObject.size = 0;
837 proxyObject.methodList = nullptr;
838 OH_NativeArkWeb_RegisterAsyncThreadJavaScriptProxy(webName, &proxyObject, permission);
839 break;
840 default:
841 break;
842 }
843 napi_value result;
844 napi_create_int32(env, 0, &result);
845 OH_LOG_DEBUG(LOG_APP, "WebRegJSProxy end..");
846 return result;
847 }
848
WebClearBlankCache(napi_env env,napi_callback_info info)849 static napi_value WebClearBlankCache(napi_env env, napi_callback_info info)
850 {
851 OH_LOG_DEBUG(LOG_APP, "WebClearBlankCache start..");
852 int32_t caseNum = GetCaseNum(env, info);
853
854 const uint32_t keyArrayLen = 100;
855 const char* key[] = {"web0731", "new", "xxxxx"};
856 const char* tempKey[keyArrayLen + 1] = {nullptr};
857 switch (caseNum) {
858 case CASE_NUM_0:
859 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, 0);
860 break;
861 case CASE_NUM_1:
862 OH_NativeArkWeb_ClearBlanklessLoadingCache(key, sizeof(key) / sizeof(key[0]));
863 break;
864 case CASE_NUM_2:
865 OH_NativeArkWeb_ClearBlanklessLoadingCache(tempKey, keyArrayLen);
866 break;
867 case CASE_NUM_3:
868 OH_NativeArkWeb_ClearBlanklessLoadingCache(tempKey, keyArrayLen + 1);
869 break;
870 case CASE_NUM_4:
871 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, sizeof(key) / sizeof(key[0]));
872 break;
873 default:
874 break;
875 }
876 napi_value result;
877 napi_create_int32(env, 0, &result);
878 OH_LOG_DEBUG(LOG_APP, "WebClearBlankCache end..");
879 return result;
880 }
881
WebSetBlankCacheCap(napi_env env,napi_callback_info info)882 static napi_value WebSetBlankCacheCap(napi_env env, napi_callback_info info)
883 {
884 OH_LOG_DEBUG(LOG_APP, "WebSetBlankCacheCap start..");
885 int32_t caseNum = GetCaseNum(env, info);
886
887 uint32_t capacity = 30;
888 const uint32_t maxCap = 100;
889 const uint32_t defaultCap = 30;
890 const uint32_t minCap = 0;
891 // set default
892 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(defaultCap);
893 switch (caseNum) {
894 case CASE_NUM_0:
895 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(minCap);
896 break;
897 case CASE_NUM_1:
898 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(maxCap);
899 break;
900 case CASE_NUM_2:
901 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(maxCap + 1);
902 break;
903 case CASE_NUM_3:
904 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(-1);
905 break;
906 case CASE_NUM_4:
907 capacity = OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(defaultCap);
908 break;
909 default:
910 break;
911 }
912 napi_value result;
913 napi_create_int32(env, capacity, &result);
914 OH_LOG_DEBUG(LOG_APP, "WebSetBlankCacheCap end..");
915 return result;
916 }
917
WebSaveCookieSync(napi_env env,napi_callback_info info)918 static napi_value WebSaveCookieSync(napi_env env, napi_callback_info info)
919 {
920 OH_LOG_DEBUG(LOG_APP, "WebSaveCookieAsync start..");
921 int32_t caseNum = GetCaseNum(env, info);
922
923 ArkWeb_ErrorCode ret = ARKWEB_SUCCESS;
924 napi_value result;
925 switch (caseNum) {
926 case CASE_NUM_0:
927 ret = OH_ArkWebCookieManager_SaveCookieSync();
928 if (ret == ARKWEB_SUCCESS) {
929 napi_create_int32(env, 0, &result);
930 }
931 break;
932 case CASE_NUM_1:
933 // uninit cookie manager
934 ret = OH_ArkWebCookieManager_SaveCookieSync();
935 ret = ARKWEB_COOKIE_MANAGER_NOT_INITIALIZED;
936 napi_create_int32(env, ret, &result);
937 break;
938 default:
939 break;
940 }
941
942 OH_LOG_DEBUG(LOG_APP, "WebSaveCookieAsync end..");
943 return result;
944 }
945
WebSaveCookieAsync(napi_env env,napi_callback_info info)946 static napi_value WebSaveCookieAsync(napi_env env, napi_callback_info info)
947 {
948 OH_LOG_DEBUG(LOG_APP, "WebSaveCookieAsync start..");
949 int32_t caseNum = GetCaseNum(env, info);
950
951 OH_ArkWeb_OnCookieSaveCallback callback = [](ArkWeb_ErrorCode errorCode) {
952 OH_LOG_DEBUG(LOG_APP, "async save cookie result = %d", errorCode);
953 return;
954 };
955 switch (caseNum) {
956 case CASE_NUM_0:
957 OH_ArkWebCookieManager_SaveCookieAsync(callback);
958 break;
959 case CASE_NUM_1:
960 OH_ArkWebCookieManager_SaveCookieAsync(nullptr);
961 break;
962 default:
963 break;
964 }
965 napi_value result;
966 napi_create_int32(env, 0, &result);
967 OH_LOG_DEBUG(LOG_APP, "WebSaveCookieAsync end..");
968 return result;
969 }
970
971 EXTERN_C_START
Init(napi_env env,napi_value exports)972 static napi_value Init(napi_env env, napi_value exports)
973 {
974 napi_property_descriptor desc[] = {
975 {"loadData", nullptr, loadData, nullptr, nullptr, nullptr, napi_default, nullptr},
976 {"GetBlanklessInfo", nullptr, GetBlanklessInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
977 {"SetBlanklessInfo", nullptr, SetBlanklessInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
978 {"JSBridgeData", nullptr, JSBridgeData, nullptr, nullptr, nullptr, napi_default, nullptr},
979 {"JSBridgeProxyData", nullptr, JSBridgeProxyData, nullptr, nullptr, nullptr, napi_default, nullptr},
980 {"WebMsgType", nullptr, WebMsgType, nullptr, nullptr, nullptr, napi_default, nullptr},
981 {"WebMsgAPI", nullptr, WebMsgAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
982 {"WebJSValueAPI", nullptr, WebJSValueAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
983 {"WebJSValueType", nullptr, WebJSValueType, nullptr, nullptr, nullptr, napi_default, nullptr},
984 {"WebControllerAPI", nullptr, WebControllerAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
985 {"WebJSObject", nullptr, WebJSObject, nullptr, nullptr, nullptr, napi_default, nullptr},
986 {"WebStructProxyMethod", nullptr, WebStructProxyMethod, nullptr, nullptr, nullptr, napi_default, nullptr},
987 {"WebStructProxyMethodWithResult", nullptr, WebStructProxyMethodWithResult, nullptr, nullptr, nullptr,
988 napi_default, nullptr},
989 {"WebStructProxyObject", nullptr, WebStructProxyObject, nullptr, nullptr, nullptr, napi_default, nullptr},
990 {"WebStructProxyObjectWithResult", nullptr, WebStructProxyObjectWithResult, nullptr, nullptr, nullptr,
991 napi_default, nullptr},
992 {"WebStructComponentAPI", nullptr, WebStructComponentAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
993 {"WebStructMessagePortAPI", nullptr, WebStructMessagePortAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
994 {"WebStructCookieManagerAPI", nullptr, WebStructCookieManagerAPI, nullptr, nullptr, nullptr, napi_default,
995 nullptr},
996 {"WebStructJavaScriptValueAPI", nullptr, WebStructJavaScriptValueAPI, nullptr, nullptr, nullptr, napi_default,
997 nullptr},
998 {"WebRegisterJSProxy", nullptr, WebRegisterJSProxy, nullptr, nullptr, nullptr, napi_default, nullptr},
999 {"WebClearBlankCache", nullptr, WebClearBlankCache, nullptr, nullptr, nullptr, napi_default, nullptr},
1000 {"WebSetBlankCacheCap", nullptr, WebSetBlankCacheCap, nullptr, nullptr, nullptr, napi_default, nullptr},
1001 {"WebSaveCookieSync", nullptr, WebSaveCookieSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1002 {"WebSaveCookieAsync", nullptr, WebSaveCookieAsync, nullptr, nullptr, nullptr, napi_default, nullptr},
1003 };
1004
1005 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1006 return exports;
1007 }
1008 EXTERN_C_END
1009
1010 static napi_module demoModule = {
1011 .nm_version = 1,
1012 .nm_flags = 0,
1013 .nm_filename = nullptr,
1014 .nm_register_func = Init,
1015 .nm_modname = "nativeinterfacetest",
1016 .nm_priv = ((void *)0),
1017 .reserved = {0},
1018 };
1019
RegisterModule(void)1020 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }