1 /*
2 * Copyright (c) 2024 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_web_scheme_handler_request.h"
17
18 #include <js_native_api.h>
19 #include <js_native_api_types.h>
20 #include <napi/native_api.h>
21 #include <securec.h>
22 #include <cstring>
23 #include <unordered_set>
24
25 #include "business_error.h"
26 #include "nweb_napi_scope.h"
27 #include "web_scheme_handler_request.h"
28 #include "nweb_log.h"
29 #include "napi_parse_utils.h"
30 #include "web_errors.h"
31
32 using namespace OHOS::NWebError;
33
34 namespace OHOS {
35 namespace NWeb {
36
37 namespace {
IsArkWebNetErrorValid(int32_t code)38 bool IsArkWebNetErrorValid(int32_t code) {
39 static const std::unordered_set<int32_t> validCodes = {
40 ARKWEB_NET_OK,
41 ARKWEB_ERR_IO_PENDING,
42 ARKWEB_ERR_FAILED,
43 ARKWEB_ERR_ABORTED,
44 ARKWEB_ERR_INVALID_ARGUMENT,
45 ARKWEB_ERR_INVALID_HANDLE,
46 ARKWEB_ERR_FILE_NOT_FOUND,
47 ARKWEB_ERR_TIMED_OUT,
48 ARKWEB_ERR_FILE_TOO_LARGE,
49 ARKWEB_ERR_UNEXPECTED,
50 ARKWEB_ERR_ACCESS_DENIED,
51 ARKWEB_ERR_NOT_IMPLEMENTED,
52 ARKWEB_ERR_INSUFFICIENT_RESOURCES,
53 ARKWEB_ERR_OUT_OF_MEMORY,
54 ARKWEB_ERR_UPLOAD_FILE_CHANGED,
55 ARKWEB_ERR_SOCKET_NOT_CONNECTED,
56 ARKWEB_ERR_FILE_EXISTS,
57 ARKWEB_ERR_FILE_PATH_TOO_LONG,
58 ARKWEB_ERR_FILE_NO_SPACE,
59 ARKWEB_ERR_FILE_VIRUS_INFECTED,
60 ARKWEB_ERR_BLOCKED_BY_CLIENT,
61 ARKWEB_ERR_NETWORK_CHANGED,
62 ARKWEB_ERR_BLOCKED_BY_ADMINISTRATOR,
63 ARKWEB_ERR_SOCKET_CONNECTED,
64 ARKWEB_ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED,
65 ARKWEB_ERR_CONTEXT_SHUT_DOWN,
66 ARKWEB_ERR_BLOCKED_BY_RESPONSE,
67 ARKWEB_ERR_CLEARTEXT_NOT_PERMITTED,
68 ARKWEB_ERR_BLOCKED_BY_CSP,
69 ARKWEB_ERR_H2_OR_QUIC_REQUIRED,
70 ARKWEB_ERR_BLOCKED_BY_ORB,
71 ARKWEB_ERR_CONNECTION_CLOSED,
72 ARKWEB_ERR_CONNECTION_RESET,
73 ARKWEB_ERR_CONNECTION_REFUSED,
74 ARKWEB_ERR_CONNECTION_ABORTED,
75 ARKWEB_ERR_CONNECTION_FAILED,
76 ARKWEB_ERR_NAME_NOT_RESOLVED,
77 ARKWEB_ERR_INTERNET_DISCONNECTED,
78 ARKWEB_ERR_SSL_PROTOCOL_ERROR,
79 ARKWEB_ERR_ADDRESS_INVALID,
80 ARKWEB_ERR_ADDRESS_UNREACHABLE,
81 ARKWEB_ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
82 ARKWEB_ERR_TUNNEL_CONNECTION_FAILED,
83 ARKWEB_ERR_NO_SSL_VERSIONS_ENABLED,
84 ARKWEB_ERR_SSL_VERSION_OR_CIPHER_MISMATCH,
85 ARKWEB_ERR_SSL_RENEGOTIATION_REQUESTED,
86 ARKWEB_ERR_PROXY_AUTH_UNSUPPORTED,
87 ARKWEB_ERR_BAD_SSL_CLIENT_AUTH_CERT,
88 ARKWEB_ERR_CONNECTION_TIMED_OUT,
89 ARKWEB_ERR_HOST_RESOLVER_QUEUE_TOO_LARGE,
90 ARKWEB_ERR_SOCKS_CONNECTION_FAILED,
91 ARKWEB_ERR_SOCKS_CONNECTION_HOST_UNREACHABLE,
92 ARKWEB_ERR_ALPN_NEGOTIATION_FAILED,
93 ARKWEB_ERR_SSL_NO_RENEGOTIATION,
94 ARKWEB_ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES,
95 ARKWEB_ERR_SSL_DECOMPRESSION_FAILURE_ALERT,
96 ARKWEB_ERR_SSL_BAD_RECORD_MAC_ALERT,
97 ARKWEB_ERR_PROXY_AUTH_REQUESTED,
98 ARKWEB_ERR_PROXY_CONNECTION_FAILED,
99 ARKWEB_ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
100 ARKWEB_ERR_PRECONNECT_MAX_SOCKET_LIMIT,
101 ARKWEB_ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED,
102 ARKWEB_ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY,
103 ARKWEB_ERR_PROXY_CERTIFICATE_INVALID,
104 ARKWEB_ERR_NAME_RESOLUTION_FAILED,
105 ARKWEB_ERR_NETWORK_ACCESS_DENIED,
106 ARKWEB_ERR_TEMPORARILY_THROTTLED,
107 ARKWEB_ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT,
108 ARKWEB_ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED,
109 ARKWEB_ERR_MSG_TOO_BIG,
110 ARKWEB_ERR_WS_PROTOCOL_ERROR,
111 ARKWEB_ERR_ADDRESS_IN_USE,
112 ARKWEB_ERR_SSL_HANDSHAKE_NOT_COMPLETED,
113 ARKWEB_ERR_SSL_BAD_PEER_PUBLIC_KEY,
114 ARKWEB_ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN,
115 ARKWEB_ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED,
116 ARKWEB_ERR_SSL_DECRYPT_ERROR_ALERT,
117 ARKWEB_ERR_WS_THROTTLE_QUEUE_TOO_LARGE,
118 ARKWEB_ERR_SSL_SERVER_CERT_CHANGED,
119 ARKWEB_ERR_SSL_UNRECOGNIZED_NAME_ALERT,
120 ARKWEB_ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR,
121 ARKWEB_ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR,
122 ARKWEB_ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE,
123 ARKWEB_ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE,
124 ARKWEB_ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT,
125 ARKWEB_ERR_ICANN_NAME_COLLISION,
126 ARKWEB_ERR_SSL_SERVER_CERT_BAD_FORMAT,
127 ARKWEB_ERR_CT_STH_PARSING_FAILED,
128 ARKWEB_ERR_CT_STH_INCOMPLETE,
129 ARKWEB_ERR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH,
130 ARKWEB_ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED,
131 ARKWEB_ERR_SSL_OBSOLETE_CIPHER,
132 ARKWEB_ERR_WS_UPGRADE,
133 ARKWEB_ERR_READ_IF_READY_NOT_IMPLEMENTED,
134 ARKWEB_ERR_NO_BUFFER_SPACE,
135 ARKWEB_ERR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS,
136 ARKWEB_ERR_EARLY_DATA_REJECTED,
137 ARKWEB_ERR_WRONG_VERSION_ON_EARLY_DATA,
138 ARKWEB_ERR_TLS13_DOWNGRADE_DETECTED,
139 ARKWEB_ERR_SSL_KEY_USAGE_INCOMPATIBLE,
140 ARKWEB_ERR_INVALID_ECH_CONFIG_LIST,
141 ARKWEB_ERR_ECH_NOT_NEGOTIATED,
142 ARKWEB_ERR_ECH_FALLBACK_CERTIFICATE_INVALID,
143 ARKWEB_ERR_CERT_COMMON_NAME_INVALID,
144 ARKWEB_ERR_CERT_DATE_INVALID,
145 ARKWEB_ERR_CERT_AUTHORITY_INVALID,
146 ARKWEB_ERR_CERT_CONTAINS_ERRORS,
147 ARKWEB_ERR_CERT_NO_REVOCATION_MECHANISM,
148 ARKWEB_ERR_CERT_UNABLE_TO_CHECK_REVOCATION,
149 ARKWEB_ERR_CERT_REVOKED,
150 ARKWEB_ERR_CERT_INVALID,
151 ARKWEB_ERR_CERT_WEAK_SIGNATURE_ALGORITHM,
152 ARKWEB_ERR_CERT_NON_UNIQUE_NAME,
153 ARKWEB_ERR_CERT_WEAK_KEY,
154 ARKWEB_ERR_CERT_NAME_CONSTRAINT_VIOLATION,
155 ARKWEB_ERR_CERT_VALIDITY_TOO_LONG,
156 ARKWEB_ERR_CERTIFICATE_TRANSPARENCY_REQUIRED,
157 ARKWEB_ERR_CERT_SYMANTEC_LEGACY,
158 ARKWEB_ERR_CERT_KNOWN_INTERCEPTION_BLOCKED,
159 ARKWEB_ERR_SSL_OBSOLETE_VERSION_OR_CIPHER,
160 ARKWEB_ERR_CERT_END,
161 ARKWEB_ERR_INVALID_URL,
162 ARKWEB_ERR_DISALLOWED_URL_SCHEME,
163 ARKWEB_ERR_UNKNOWN_URL_SCHEME,
164 ARKWEB_ERR_INVALID_REDIRECT,
165 ARKWEB_ERR_TOO_MANY_REDIRECTS,
166 ARKWEB_ERR_UNSAFE_REDIRECT,
167 ARKWEB_ERR_UNSAFE_PORT,
168 ARKWEB_ERR_INVALID_RESPONSE,
169 ARKWEB_ERR_INVALID_CHUNKED_ENCODING,
170 ARKWEB_ERR_METHOD_UNSUPPORTED,
171 ARKWEB_ERR_UNEXPECTED_PROXY_AUTH,
172 ARKWEB_ERR_EMPTY_RESPONSE,
173 ARKWEB_ERR_RESPONSE_HEADERS_TOO_BIG,
174 ARKWEB_ERR_PAC_SCRIPT_FAILED,
175 ARKWEB_ERR_REQUEST_RANGE_NOT_SATISFIABLE,
176 ARKWEB_ERR_MALFORMED_IDENTITY,
177 ARKWEB_ERR_CONTENT_DECODING_FAILED,
178 ARKWEB_ERR_NETWORK_IO_SUSPENDED,
179 ARKWEB_ERR_SYN_REPLY_NOT_RECEIVED,
180 ARKWEB_ERR_ENCODING_CONVERSION_FAILED,
181 ARKWEB_ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT,
182 ARKWEB_ERR_NO_SUPPORTED_PROXIES,
183 ARKWEB_ERR_HTTP2_PROTOCOL_ERROR,
184 ARKWEB_ERR_INVALID_AUTH_CREDENTIALS,
185 ARKWEB_ERR_UNSUPPORTED_AUTH_SCHEME,
186 ARKWEB_ERR_ENCODING_DETECTION_FAILED,
187 ARKWEB_ERR_MISSING_AUTH_CREDENTIALS,
188 ARKWEB_ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS,
189 ARKWEB_ERR_MISCONFIGURED_AUTH_ENVIRONMENT,
190 ARKWEB_ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS,
191 ARKWEB_ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN,
192 ARKWEB_ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH,
193 ARKWEB_ERR_INCOMPLETE_HTTP2_HEADERS,
194 ARKWEB_ERR_PAC_NOT_IN_DHCP,
195 ARKWEB_ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION,
196 ARKWEB_ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION,
197 ARKWEB_ERR_HTTP2_SERVER_REFUSED_STREAM,
198 ARKWEB_ERR_HTTP2_PING_FAILED,
199 ARKWEB_ERR_CONTENT_LENGTH_MISMATCH,
200 ARKWEB_ERR_INCOMPLETE_CHUNKED_ENCODING,
201 ARKWEB_ERR_QUIC_PROTOCOL_ERROR,
202 ARKWEB_ERR_RESPONSE_HEADERS_TRUNCATED,
203 ARKWEB_ERR_QUIC_HANDSHAKE_FAILED,
204 ARKWEB_ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY,
205 ARKWEB_ERR_HTTP2_FLOW_CONTROL_ERROR,
206 ARKWEB_ERR_HTTP2_FRAME_SIZE_ERROR,
207 ARKWEB_ERR_HTTP2_COMPRESSION_ERROR,
208 ARKWEB_ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION,
209 ARKWEB_ERR_HTTP_1_1_REQUIRED,
210 ARKWEB_ERR_PROXY_HTTP_1_1_REQUIRED,
211 ARKWEB_ERR_PAC_SCRIPT_TERMINATED,
212 ARKWEB_ERR_INVALID_HTTP_RESPONSE,
213 ARKWEB_ERR_CONTENT_DECODING_INIT_FAILED,
214 ARKWEB_ERR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED,
215 ARKWEB_ERR_HTTP2_PUSHED_STREAM_NOT_AVAILABLE,
216 ARKWEB_ERR_HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER,
217 ARKWEB_ERR_TOO_MANY_RETRIES,
218 ARKWEB_ERR_HTTP2_STREAM_CLOSED,
219 ARKWEB_ERR_HTTP2_CLIENT_REFUSED_STREAM,
220 ARKWEB_ERR_HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH,
221 ARKWEB_ERR_HTTP_RESPONSE_CODE_FAILURE,
222 ARKWEB_ERR_QUIC_UNKNOWN_CERT_ROOT,
223 ARKWEB_ERR_QUIC_GOAWAY_REQUEST_CAN_BE_RETRIED,
224 ARKWEB_ERR_TOO_MANY_ACCEPT_CH_RESTARTS,
225 ARKWEB_ERR_INCONSISTENT_IP_ADDRESS_SPACE,
226 ARKWEB_ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_LOCAL_NETWORK_ACCESS_POLICY,
227 ARKWEB_ERR_CACHE_MISS,
228 ARKWEB_ERR_CACHE_READ_FAILURE,
229 ARKWEB_ERR_CACHE_WRITE_FAILURE,
230 ARKWEB_ERR_CACHE_OPERATION_UNSUPPORTED,
231 ARKWEB_ERR_CACHE_OPEN_FAILURE,
232 ARKWEB_ERR_CACHE_CREATE_FAILURE,
233 ARKWEB_ERR_CACHE_RACE,
234 ARKWEB_ERR_CACHE_CHECKSUM_READ_FAILURE,
235 ARKWEB_ERR_CACHE_CHECKSUM_MISMATCH,
236 ARKWEB_ERR_CACHE_LOCK_TIMEOUT,
237 ARKWEB_ERR_CACHE_AUTH_FAILURE_AFTER_READ,
238 ARKWEB_ERR_CACHE_ENTRY_NOT_SUITABLE,
239 ARKWEB_ERR_CACHE_DOOM_FAILURE,
240 ARKWEB_ERR_CACHE_OPEN_OR_CREATE_FAILURE,
241 ARKWEB_ERR_INSECURE_RESPONSE,
242 ARKWEB_ERR_NO_PRIVATE_KEY_FOR_CERT,
243 ARKWEB_ERR_ADD_USER_CERT_FAILED,
244 ARKWEB_ERR_INVALID_SIGNED_EXCHANGE,
245 ARKWEB_ERR_INVALID_WEB_BUNDLE,
246 ARKWEB_ERR_TRUST_TOKEN_OPERATION_FAILED,
247 ARKWEB_ERR_TRUST_TOKEN_OPERATION_SUCCESS_WITHOUT_SENDING_REQUEST,
248 ARKWEB_ERR_FTP_FAILED,
249 ARKWEB_ERR_FTP_SERVICE_UNAVAILABLE,
250 ARKWEB_ERR_FTP_TRANSFER_ABORTED,
251 ARKWEB_ERR_FTP_FILE_BUSY,
252 ARKWEB_ERR_FTP_SYNTAX_ERROR,
253 ARKWEB_ERR_FTP_COMMAND_UNSUPPORTED,
254 ARKWEB_ERR_FTP_BAD_COMMAND_SEQUENCE,
255 ARKWEB_ERR_PKCS12_IMPORT_BAD_PASSWORD,
256 ARKWEB_ERR_PKCS12_IMPORT_FAILED,
257 ARKWEB_ERR_IMPORT_CA_CERT_NOT_CA,
258 ARKWEB_ERR_IMPORT_CERT_ALREADY_EXISTS,
259 ARKWEB_ERR_IMPORT_CA_CERT_FAILED,
260 ARKWEB_ERR_IMPORT_SERVER_CERT_FAILED,
261 ARKWEB_ERR_PKCS12_IMPORT_INVALID_MAC,
262 ARKWEB_ERR_PKCS12_IMPORT_INVALID_FILE,
263 ARKWEB_ERR_PKCS12_IMPORT_UNSUPPORTED,
264 ARKWEB_ERR_KEY_GENERATION_FAILED,
265 ARKWEB_ERR_PRIVATE_KEY_EXPORT_FAILED,
266 ARKWEB_ERR_SELF_SIGNED_CERT_GENERATION_FAILED,
267 ARKWEB_ERR_CERT_DATABASE_CHANGED,
268 ARKWEB_ERR_CERT_VERIFIER_CHANGED,
269 ARKWEB_ERR_DNS_MALFORMED_RESPONSE,
270 ARKWEB_ERR_DNS_SERVER_REQUIRES_TCP,
271 ARKWEB_ERR_DNS_SERVER_FAILED,
272 ARKWEB_ERR_DNS_TIMED_OUT,
273 ARKWEB_ERR_DNS_CACHE_MISS,
274 ARKWEB_ERR_DNS_SEARCH_EMPTY,
275 ARKWEB_ERR_DNS_SORT_ERROR,
276 ARKWEB_ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED,
277 ARKWEB_ERR_DNS_NAME_HTTPS_ONLY,
278 ARKWEB_ERR_DNS_REQUEST_CANCELED,
279 ARKWEB_ERR_DNS_NO_MATCHING_SUPPORTED_ALPN
280 };
281 return validCodes.count(code) > 0;
282 }
283 }
284
Init(napi_env env,napi_value exports)285 napi_value NapiWebSchemeHandlerRequest::Init(napi_env env, napi_value exports)
286 {
287 WVLOG_D("NapiWebSchemeHandlerRequest::Init");
288 ExportWebSchemeHandlerRequestClass(env, &exports);
289 ExportEnumWebResourceType(env, &exports);
290 return exports;
291 }
292
ExportWebSchemeHandlerRequestClass(napi_env env,napi_value * exportsPointer)293 void NapiWebSchemeHandlerRequest::ExportWebSchemeHandlerRequestClass(
294 napi_env env, napi_value* exportsPointer)
295 {
296 napi_property_descriptor properties[] = {
297 DECLARE_NAPI_FUNCTION("getHeader", JS_GetHeader),
298 DECLARE_NAPI_FUNCTION("getRequestUrl", JS_GetRequestUrl),
299 DECLARE_NAPI_FUNCTION("getRequestMethod", JS_GetRequestMethod),
300 DECLARE_NAPI_FUNCTION("getReferrer", JS_GetReferrer),
301 DECLARE_NAPI_FUNCTION("isRedirect", JS_IsRedirect),
302 DECLARE_NAPI_FUNCTION("isMainFrame", JS_IsMainFrame),
303 DECLARE_NAPI_FUNCTION("hasGesture", JS_HasGesture),
304 DECLARE_NAPI_FUNCTION("getHttpBodyStream", JS_HttpBodyStream),
305 DECLARE_NAPI_FUNCTION("getRequestResourceType", JS_GetRequestResourceType),
306 DECLARE_NAPI_FUNCTION("getFrameUrl", JS_GetFrameUrl),
307 };
308 napi_value webSchemeHandlerRequest = nullptr;
309 napi_define_class(env, WEB_SCHEME_HANDLER_REQUEST.c_str(), WEB_SCHEME_HANDLER_REQUEST.length(),
310 JS_Constructor, nullptr,
311 sizeof(properties) / sizeof(properties[0]), properties, &webSchemeHandlerRequest);
312 napi_set_named_property(env, *exportsPointer, WEB_SCHEME_HANDLER_REQUEST.c_str(),
313 webSchemeHandlerRequest);
314 }
315
DefineProperties(napi_env env,napi_value * object)316 napi_status NapiWebSchemeHandlerRequest::DefineProperties(
317 napi_env env, napi_value* object)
318 {
319 napi_property_descriptor properties[] = {
320 DECLARE_NAPI_FUNCTION("getHeader", JS_GetHeader),
321 DECLARE_NAPI_FUNCTION("getRequestUrl", JS_GetRequestUrl),
322 DECLARE_NAPI_FUNCTION("getRequestMethod", JS_GetRequestMethod),
323 DECLARE_NAPI_FUNCTION("getReferrer", JS_GetReferrer),
324 DECLARE_NAPI_FUNCTION("isRedirect", JS_IsRedirect),
325 DECLARE_NAPI_FUNCTION("isMainFrame", JS_IsMainFrame),
326 DECLARE_NAPI_FUNCTION("hasGesture", JS_HasGesture),
327 DECLARE_NAPI_FUNCTION("getHttpBodyStream", JS_HttpBodyStream),
328 DECLARE_NAPI_FUNCTION("getRequestResourceType", JS_GetRequestResourceType),
329 DECLARE_NAPI_FUNCTION("getFrameUrl", JS_GetFrameUrl),
330 };
331 return napi_define_properties(env, *object, sizeof(properties) / sizeof(properties[0]), properties);
332 }
333
JS_Constructor(napi_env env,napi_callback_info cbinfo)334 napi_value NapiWebSchemeHandlerRequest::JS_Constructor(napi_env env, napi_callback_info cbinfo)
335 {
336 WVLOG_D("NapiWebSchemeHandlerRequest::JS_Constructor is called");
337 napi_value thisVar = nullptr;
338 void *data = nullptr;
339 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
340
341 WebSchemeHandlerRequest *request = new (std::nothrow) WebSchemeHandlerRequest(env);
342 if (request == nullptr) {
343 return nullptr;
344 }
345
346 napi_wrap(
347 env, thisVar, request,
348 [](napi_env /* env */, void *data, void * /* hint */) {
349 WebSchemeHandlerRequest *request = reinterpret_cast<WebSchemeHandlerRequest *>(data);
350 delete request;
351 },
352 nullptr, nullptr);
353
354 return thisVar;
355 }
356
JS_GetHeader(napi_env env,napi_callback_info cbinfo)357 napi_value NapiWebSchemeHandlerRequest::JS_GetHeader(napi_env env, napi_callback_info cbinfo)
358 {
359 napi_value thisVar = nullptr;
360 void *data = nullptr;
361 WebSchemeHandlerRequest *request = nullptr;
362 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
363
364 napi_unwrap(env, thisVar, (void **)&request);
365 if (!request) {
366 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetHeader request is nullptr");
367 return nullptr;
368 }
369
370 WebHeaderList list = request->GetHeader();
371 napi_value result = nullptr;
372 napi_create_array(env, &result);
373 size_t headerSize = list.size();
374 for (size_t index = 0; index < headerSize; index++) {
375 NApiScope scope(env);
376 if (!scope.IsVaild()) {
377 break;
378 }
379 napi_value webHeaderObj = nullptr;
380 napi_value headerKey = nullptr;
381 napi_value headerValue = nullptr;
382 NAPI_CALL(env, napi_create_object(env, &webHeaderObj));
383 napi_create_string_utf8(env, list[index].first.c_str(), NAPI_AUTO_LENGTH, &headerKey);
384 napi_create_string_utf8(env, list[index].second.c_str(), NAPI_AUTO_LENGTH, &headerValue);
385 napi_set_named_property(env, webHeaderObj, "headerKey", headerKey);
386 napi_set_named_property(env, webHeaderObj, "headerValue", headerValue);
387 napi_set_element(env, result, index, webHeaderObj);
388 }
389 return result;
390 }
391
JS_GetRequestUrl(napi_env env,napi_callback_info cbinfo)392 napi_value NapiWebSchemeHandlerRequest::JS_GetRequestUrl(napi_env env, napi_callback_info cbinfo)
393 {
394 napi_value thisVar = nullptr;
395 void *data = nullptr;
396 WebSchemeHandlerRequest *request = nullptr;
397 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
398
399 napi_unwrap(env, thisVar, (void **)&request);
400 if (!request) {
401 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetRequestUrl request is nullptr");
402 return nullptr;
403 }
404
405 napi_value value;
406 char *result = request->GetRequestUrl();
407 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &value);
408 if (status != napi_ok) {
409 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetRequestUrl response get url failed");
410 return nullptr;
411 }
412 return value;
413 }
414
JS_GetRequestMethod(napi_env env,napi_callback_info cbinfo)415 napi_value NapiWebSchemeHandlerRequest::JS_GetRequestMethod(napi_env env, napi_callback_info cbinfo)
416 {
417 napi_value thisVar = nullptr;
418 void *data = nullptr;
419 WebSchemeHandlerRequest *request = nullptr;
420 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
421
422 napi_unwrap(env, thisVar, (void **)&request);
423 if (!request) {
424 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetRequestMethod request is nullptr");
425 return nullptr;
426 }
427
428 napi_value value;
429 char *result = request->GetMethod();
430 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &value);
431 if (status != napi_ok) {
432 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetRequestMethod response get url failed");
433 return nullptr;
434 }
435 return value;
436 }
437
JS_GetReferrer(napi_env env,napi_callback_info cbinfo)438 napi_value NapiWebSchemeHandlerRequest::JS_GetReferrer(napi_env env, napi_callback_info cbinfo)
439 {
440 napi_value thisVar = nullptr;
441 void *data = nullptr;
442 WebSchemeHandlerRequest *request = nullptr;
443 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
444
445 napi_unwrap(env, thisVar, (void **)&request);
446 if (!request) {
447 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetReferrer request is nullptr");
448 return nullptr;
449 }
450
451 napi_value value;
452 char *result = request->GetReferrer();
453 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &value);
454 if (status != napi_ok) {
455 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetReferrer response get url failed");
456 return nullptr;
457 }
458 return value;
459 }
460
JS_IsRedirect(napi_env env,napi_callback_info cbinfo)461 napi_value NapiWebSchemeHandlerRequest::JS_IsRedirect(napi_env env, napi_callback_info cbinfo)
462 {
463 napi_value thisVar = nullptr;
464 void *data = nullptr;
465 WebSchemeHandlerRequest *request = nullptr;
466 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
467
468 napi_unwrap(env, thisVar, (void **)&request);
469 if (!request) {
470 WVLOG_E("NapiWebSchemeHandlerRequest::JS_IsRedirect request is nullptr");
471 return nullptr;
472 }
473
474 napi_value value;
475 bool result = request->IsRedirect();
476 NAPI_CALL(env, napi_get_boolean(env, result, &value));
477 return value;
478 }
479
JS_IsMainFrame(napi_env env,napi_callback_info cbinfo)480 napi_value NapiWebSchemeHandlerRequest::JS_IsMainFrame(napi_env env, napi_callback_info cbinfo)
481 {
482 napi_value thisVar = nullptr;
483 void *data = nullptr;
484 WebSchemeHandlerRequest *request = nullptr;
485 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
486
487 napi_unwrap(env, thisVar, (void **)&request);
488 if (!request) {
489 WVLOG_E("NapiWebSchemeHandlerRequest::JS_IsMainFrame request is nullptr");
490 return nullptr;
491 }
492
493 napi_value value;
494 bool result = request->IsMainFrame();
495 NAPI_CALL(env, napi_get_boolean(env, result, &value));
496 return value;
497 }
498
JS_HasGesture(napi_env env,napi_callback_info cbinfo)499 napi_value NapiWebSchemeHandlerRequest::JS_HasGesture(napi_env env, napi_callback_info cbinfo)
500 {
501 napi_value thisVar = nullptr;
502 void *data = nullptr;
503 WebSchemeHandlerRequest *request = nullptr;
504 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
505
506 napi_unwrap(env, thisVar, (void **)&request);
507 if (!request) {
508 WVLOG_E("NapiWebSchemeHandlerRequest::JS_HasGesture request is nullptr");
509 return nullptr;
510 }
511
512 napi_value value;
513 bool result = request->HasGesture();
514 NAPI_CALL(env, napi_get_boolean(env, result, &value));
515 return value;
516 }
517
JS_HttpBodyStream(napi_env env,napi_callback_info cbinfo)518 napi_value NapiWebSchemeHandlerRequest::JS_HttpBodyStream(napi_env env, napi_callback_info cbinfo)
519 {
520 napi_value thisVar = nullptr;
521 void *data = nullptr;
522 WebSchemeHandlerRequest *request = nullptr;
523 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
524
525 napi_unwrap(env, thisVar, (void **)&request);
526 if (!request) {
527 WVLOG_E("NapiWebSchemeHandlerRequest::JS_HttpBodyStream request is nullptr");
528 return nullptr;
529 }
530
531 ArkWeb_HttpBodyStream* arkWebPostStream = request->GetHttpBodyStream();
532 if (!arkWebPostStream) {
533 WVLOG_D("NapiWebSchemeHandlerRequest::JS_HttpBodyStream stream is nullptr");
534 return nullptr;
535 }
536 napi_value httpBodyStreamObject;
537 WebHttpBodyStream* stream = new (std::nothrow) WebHttpBodyStream(env, arkWebPostStream);
538 if (stream == nullptr) {
539 return nullptr;
540 }
541 NAPI_CALL(env, napi_create_object(env, &httpBodyStreamObject));
542 napi_wrap(
543 env, httpBodyStreamObject, stream,
544 [](napi_env /* env */, void *data, void * /* hint */) {
545 WebHttpBodyStream *stream = reinterpret_cast<WebHttpBodyStream *>(data);
546 delete stream;
547 },
548 nullptr, nullptr);
549 NapiWebHttpBodyStream::DefineProperties(env, &httpBodyStreamObject);
550 return httpBodyStreamObject;
551 }
552
JS_GetRequestResourceType(napi_env env,napi_callback_info cbinfo)553 napi_value NapiWebSchemeHandlerRequest::JS_GetRequestResourceType(napi_env env, napi_callback_info cbinfo)
554 {
555 napi_value thisVar = nullptr;
556 void *data = nullptr;
557 WebSchemeHandlerRequest *request = nullptr;
558 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
559
560 napi_unwrap(env, thisVar, (void **)&request);
561 if (!request) {
562 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetRequestResourceType request is nullptr");
563 return nullptr;
564 }
565
566 napi_value value;
567 napi_create_int32(env, request->GetRequestResourceType(), &value);
568 return value;
569 }
570
JS_GetFrameUrl(napi_env env,napi_callback_info cbinfo)571 napi_value NapiWebSchemeHandlerRequest::JS_GetFrameUrl(napi_env env, napi_callback_info cbinfo)
572 {
573 napi_value thisVar = nullptr;
574 void *data = nullptr;
575 WebSchemeHandlerRequest *request = nullptr;
576 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
577
578 napi_unwrap(env, thisVar, (void **)&request);
579 if (!request) {
580 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetFrameUrl request is nullptr");
581 return nullptr;
582 }
583
584 napi_value value;
585 char *result = request->GetFrameUrl();
586 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &value);
587 if (status != napi_ok) {
588 WVLOG_E("NapiWebSchemeHandlerRequest::JS_GetFrameUrl response get frame url failed");
589 return nullptr;
590 }
591 return value;
592 }
593
ExportEnumWebResourceType(napi_env env,napi_value * value)594 napi_status NapiWebSchemeHandlerRequest::ExportEnumWebResourceType(napi_env env, napi_value* value)
595 {
596 WVLOG_D("begin to export enum web resource type");
597
598 const std::string NPI_WEB_RESOURCE_TYPE_ENUM_NAME = "WebResourceType";
599 napi_property_descriptor properties[] = {
600 DECLARE_NAPI_STATIC_PROPERTY(
601 "MAIN_FRAME", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::MAIN_FRAME))),
602 DECLARE_NAPI_STATIC_PROPERTY(
603 "SUB_FRAME", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::SUB_FRAME))),
604 DECLARE_NAPI_STATIC_PROPERTY(
605 "STYLE_SHEET", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::STYLE_SHEET))),
606 DECLARE_NAPI_STATIC_PROPERTY(
607 "SCRIPT", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::SCRIPT))),
608 DECLARE_NAPI_STATIC_PROPERTY(
609 "IMAGE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::IMAGE))),
610 DECLARE_NAPI_STATIC_PROPERTY(
611 "FONT_RESOURCE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::FONT_RESOURCE))),
612 DECLARE_NAPI_STATIC_PROPERTY(
613 "SUB_RESOURCE", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::SUB_RESOURCE))),
614 DECLARE_NAPI_STATIC_PROPERTY(
615 "OBJECT", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::OBJECT))),
616 DECLARE_NAPI_STATIC_PROPERTY(
617 "MEDIA", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::MEDIA))),
618 DECLARE_NAPI_STATIC_PROPERTY(
619 "WORKER", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::WORKER))),
620 DECLARE_NAPI_STATIC_PROPERTY(
621 "SHARED_WORKER", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::SHARED_WORKER))),
622 DECLARE_NAPI_STATIC_PROPERTY(
623 "PREFETCH", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::PREFETCH))),
624 DECLARE_NAPI_STATIC_PROPERTY(
625 "FAVICON", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::FAVICON))),
626 DECLARE_NAPI_STATIC_PROPERTY(
627 "XHR", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::XHR))),
628 DECLARE_NAPI_STATIC_PROPERTY(
629 "PING", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::PING))),
630 DECLARE_NAPI_STATIC_PROPERTY(
631 "SERVICE_WORKER", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::SERVICE_WORKER))),
632 DECLARE_NAPI_STATIC_PROPERTY(
633 "CSP_REPORT", NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::CSP_REPORT))),
634 DECLARE_NAPI_STATIC_PROPERTY("PLUGIN_RESOURCE",
635 NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::PLUGIN_RESOURCE))),
636 DECLARE_NAPI_STATIC_PROPERTY("NAVIGATION_PRELOAD_MAIN_FRAME",
637 NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::NAVIGATION_PRELOAD_MAIN_FRAME))),
638 DECLARE_NAPI_STATIC_PROPERTY("NAVIGATION_PRELOAD_SUB_FRAME",
639 NapiParseUtils::ToInt32Value(env, static_cast<int32_t>(WebResourceType::NAVIGATION_PRELOAD_SUB_FRAME))),
640 };
641
642 napi_value enumValue = nullptr;
643 napi_define_class(env, NPI_WEB_RESOURCE_TYPE_ENUM_NAME.c_str(), NPI_WEB_RESOURCE_TYPE_ENUM_NAME.length(),
644 NapiParseUtils::CreateEnumConstructor, nullptr, sizeof(properties) / sizeof(properties[0]), properties,
645 &enumValue);
646 return napi_set_named_property(env, *value, NPI_WEB_RESOURCE_TYPE_ENUM_NAME.c_str(), enumValue);
647 }
648
Init(napi_env env,napi_value exports)649 napi_value NapiWebSchemeHandlerResponse::Init(napi_env env, napi_value exports)
650 {
651 ExportWebSchemeHandlerResponseClass(env, &exports);
652 return exports;
653 }
654
ExportWebSchemeHandlerResponseClass(napi_env env,napi_value * exportsPointer)655 void NapiWebSchemeHandlerResponse::ExportWebSchemeHandlerResponseClass(
656 napi_env env, napi_value* exportsPointer)
657 {
658 napi_property_descriptor properties[] = {
659 DECLARE_NAPI_FUNCTION("getUrl", JS_GetUrl),
660 DECLARE_NAPI_FUNCTION("setUrl", JS_SetUrl),
661 DECLARE_NAPI_FUNCTION("getStatus", JS_GetStatus),
662 DECLARE_NAPI_FUNCTION("setStatus", JS_SetStatus),
663 DECLARE_NAPI_FUNCTION("getStatusText", JS_GetStatusText),
664 DECLARE_NAPI_FUNCTION("setStatusText", JS_SetStatusText),
665 DECLARE_NAPI_FUNCTION("getMimeType", JS_GetMimeType),
666 DECLARE_NAPI_FUNCTION("setMimeType", JS_SetMimeType),
667 DECLARE_NAPI_FUNCTION("getEncoding", JS_GetEncoding),
668 DECLARE_NAPI_FUNCTION("setEncoding", JS_SetEncoding),
669 DECLARE_NAPI_FUNCTION("getHeaderByName", JS_GetHeaderByName),
670 DECLARE_NAPI_FUNCTION("setHeaderByName", JS_SetHeaderByName),
671 DECLARE_NAPI_FUNCTION("getNetErrorCode", JS_GetNetErrorCode),
672 DECLARE_NAPI_FUNCTION("setNetErrorCode", JS_SetNetErrorCode),
673 };
674 napi_value webSchemeHandlerResponse = nullptr;
675 napi_define_class(env, WEB_SCHEME_HANDLER_RESPONSE.c_str(), WEB_SCHEME_HANDLER_RESPONSE.length(),
676 JS_Constructor, nullptr,
677 sizeof(properties) / sizeof(properties[0]), properties, &webSchemeHandlerResponse);
678 napi_set_named_property(env, *exportsPointer, WEB_SCHEME_HANDLER_RESPONSE.c_str(),
679 webSchemeHandlerResponse);
680 }
681
JS_Constructor(napi_env env,napi_callback_info cbinfo)682 napi_value NapiWebSchemeHandlerResponse::JS_Constructor(napi_env env, napi_callback_info cbinfo)
683 {
684 WVLOG_D("NapiWebSchemeHandlerResponse::JS_Constructor is called");
685 napi_value thisVar = nullptr;
686 void *data = nullptr;
687 napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisVar, &data);
688
689 WebSchemeHandlerResponse *response = new WebSchemeHandlerResponse(env);
690
691 napi_wrap(
692 env, thisVar, response,
693 [](napi_env /* env */, void *data, void * /* hint */) {
694 WebSchemeHandlerResponse *response = (WebSchemeHandlerResponse *)data;
695 delete response;
696 },
697 nullptr, nullptr);
698
699 return thisVar;
700 }
701
JS_GetUrl(napi_env env,napi_callback_info cbinfo)702 napi_value NapiWebSchemeHandlerResponse::JS_GetUrl(napi_env env, napi_callback_info cbinfo)
703 {
704 size_t argc = 1;
705 napi_value argv[1] = {0};
706 napi_value thisVar = nullptr;
707 void *data = nullptr;
708 WebSchemeHandlerResponse *response = nullptr;
709 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
710
711 napi_unwrap(env, thisVar, (void **)&response);
712 if (!response) {
713 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetUrl response is nullptr");
714 return nullptr;
715 }
716
717 napi_value urlValue;
718 char *result = response->GetUrl();
719 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &urlValue);
720 OH_ArkWeb_ReleaseString(result);
721 if (status != napi_ok) {
722 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetUrl response get url failed");
723 return nullptr;
724 }
725 return urlValue;
726 }
727
JS_SetUrl(napi_env env,napi_callback_info cbinfo)728 napi_value NapiWebSchemeHandlerResponse::JS_SetUrl(napi_env env, napi_callback_info cbinfo)
729 {
730 size_t argc = 1;
731 napi_value argv[1] = {0};
732 napi_value thisVar = nullptr;
733 void *data = nullptr;
734 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
735
736 WebSchemeHandlerResponse *response = nullptr;
737 napi_unwrap(env, thisVar, (void **)&response);
738
739 if (!response) {
740 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
741 return nullptr;
742 }
743 std::string url = "";
744 if (!NapiParseUtils::ParseString(env, argv[0], url)) {
745 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
746 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "url", "string"));
747 return nullptr;
748 }
749 response->SetUrl(url.c_str());
750 return nullptr;
751 }
752
JS_GetStatus(napi_env env,napi_callback_info cbinfo)753 napi_value NapiWebSchemeHandlerResponse::JS_GetStatus(napi_env env, napi_callback_info cbinfo)
754 {
755 size_t argc = 1;
756 napi_value argv[1] = {0};
757 napi_value thisVar = nullptr;
758 void *data = nullptr;
759 WebSchemeHandlerResponse *response = nullptr;
760 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
761
762 napi_unwrap(env, thisVar, (void **)&response);
763 if (!response) {
764 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetStatus response is nullptr");
765 return nullptr;
766 }
767
768 napi_value status;
769 napi_create_int32(env, response->GetStatus(), &status);
770 return status;
771 }
772
JS_SetStatus(napi_env env,napi_callback_info cbinfo)773 napi_value NapiWebSchemeHandlerResponse::JS_SetStatus(napi_env env, napi_callback_info cbinfo)
774 {
775 size_t argc = 1;
776 napi_value argv[1] = {0};
777 napi_value thisVar = nullptr;
778 void *data = nullptr;
779 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
780
781 WebSchemeHandlerResponse *response = nullptr;
782 napi_unwrap(env, thisVar, (void **)&response);
783
784 if (!response) {
785 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
786 return nullptr;
787 }
788 int32_t status = 0;
789 if (!NapiParseUtils::ParseInt32(env, argv[0], status)) {
790 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
791 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "code", "int"));
792 WVLOG_E("NapiWebSchemeHandlerResponse::JS_SetStatus parse failed");
793 return nullptr;
794 }
795 response->SetStatus(status);
796 return nullptr;
797 }
798
JS_GetStatusText(napi_env env,napi_callback_info cbinfo)799 napi_value NapiWebSchemeHandlerResponse::JS_GetStatusText(napi_env env, napi_callback_info cbinfo)
800 {
801 size_t argc = 1;
802 napi_value argv[1] = {0};
803 napi_value thisVar = nullptr;
804 void *data = nullptr;
805 WebSchemeHandlerResponse *response = nullptr;
806 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
807
808 napi_unwrap(env, thisVar, (void **)&response);
809 if (!response) {
810 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetStatusText response is nullptr");
811 return nullptr;
812 }
813
814 napi_value statusText;
815 char* result = response->GetStatusText();
816 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &statusText);
817 OH_ArkWeb_ReleaseString(result);
818 if (status != napi_ok) {
819 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetStatusText response get failed");
820 return nullptr;
821 }
822 return statusText;
823 }
824
JS_SetStatusText(napi_env env,napi_callback_info cbinfo)825 napi_value NapiWebSchemeHandlerResponse::JS_SetStatusText(napi_env env, napi_callback_info cbinfo)
826 {
827 size_t argc = 1;
828 napi_value argv[1] = {0};
829 napi_value thisVar = nullptr;
830 void *data = nullptr;
831 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
832
833 WebSchemeHandlerResponse *response = nullptr;
834 napi_unwrap(env, thisVar, (void **)&response);
835
836 if (!response) {
837 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
838 return nullptr;
839 }
840 std::string statusText = "";
841 if (!NapiParseUtils::ParseString(env, argv[0], statusText)) {
842 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
843 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "text", "string"));
844 return nullptr;
845 }
846 response->SetStatusText(statusText.c_str());
847 return nullptr;
848 }
849
JS_GetMimeType(napi_env env,napi_callback_info cbinfo)850 napi_value NapiWebSchemeHandlerResponse::JS_GetMimeType(napi_env env, napi_callback_info cbinfo)
851 {
852 size_t argc = 1;
853 napi_value argv[1] = {0};
854 napi_value thisVar = nullptr;
855 void *data = nullptr;
856 WebSchemeHandlerResponse *response = nullptr;
857 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
858
859 napi_unwrap(env, thisVar, (void **)&response);
860 if (!response) {
861 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetMimeType response is nullptr");
862 return nullptr;
863 }
864
865 napi_value mimeType;
866 char* result = response->GetMimeType();
867 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &mimeType);
868 OH_ArkWeb_ReleaseString(result);
869 if (status != napi_ok) {
870 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetMimeType response get failed");
871 return nullptr;
872 }
873 return mimeType;
874 }
875
JS_SetMimeType(napi_env env,napi_callback_info cbinfo)876 napi_value NapiWebSchemeHandlerResponse::JS_SetMimeType(napi_env env, napi_callback_info cbinfo)
877 {
878 size_t argc = 1;
879 napi_value argv[1] = {0};
880 napi_value thisVar = nullptr;
881 void *data = nullptr;
882 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
883 WebSchemeHandlerResponse *response = nullptr;
884 napi_unwrap(env, thisVar, (void **)&response);
885
886 if (!response) {
887 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
888 return nullptr;
889 }
890 std::string mimeType = "";
891 if (!NapiParseUtils::ParseString(env, argv[0], mimeType)) {
892 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
893 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "type", "string"));
894 return nullptr;
895 }
896 response->SetMimeType(mimeType.c_str());
897 return nullptr;
898 }
899
JS_GetEncoding(napi_env env,napi_callback_info cbinfo)900 napi_value NapiWebSchemeHandlerResponse::JS_GetEncoding(napi_env env, napi_callback_info cbinfo)
901 {
902 size_t argc = 1;
903 napi_value argv[1] = {0};
904 napi_value thisVar = nullptr;
905 void *data = nullptr;
906 WebSchemeHandlerResponse *response = nullptr;
907 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
908
909 napi_unwrap(env, thisVar, (void **)&response);
910 if (!response) {
911 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response is nullptr");
912 return nullptr;
913 }
914
915 napi_value encoding;
916 char* result = response->GetEncoding();
917 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &encoding);
918 OH_ArkWeb_ReleaseString(result);
919 if (status != napi_ok) {
920 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response get failed");
921 return nullptr;
922 }
923 return encoding;
924 }
925
JS_SetEncoding(napi_env env,napi_callback_info cbinfo)926 napi_value NapiWebSchemeHandlerResponse::JS_SetEncoding(napi_env env, napi_callback_info cbinfo)
927 {
928 size_t argc = 1;
929 napi_value argv[1] = {0};
930 napi_value thisVar = nullptr;
931 void *data = nullptr;
932 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
933
934 WebSchemeHandlerResponse *response = nullptr;
935 napi_unwrap(env, thisVar, (void **)&response);
936
937 if (!response) {
938 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
939 return nullptr;
940 }
941 std::string encoding = "";
942 if (!NapiParseUtils::ParseString(env, argv[0], encoding)) {
943 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
944 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "encoding", "string"));
945 return nullptr;
946 }
947 response->SetEncoding(encoding.c_str());
948 return nullptr;
949 }
950
JS_GetHeaderByName(napi_env env,napi_callback_info cbinfo)951 napi_value NapiWebSchemeHandlerResponse::JS_GetHeaderByName(napi_env env, napi_callback_info cbinfo)
952 {
953 size_t argc = 1;
954 napi_value argv[1] = {0};
955 napi_value thisVar = nullptr;
956 void *data = nullptr;
957 WebSchemeHandlerResponse *response = nullptr;
958 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
959
960 napi_unwrap(env, thisVar, (void **)&response);
961 if (!response) {
962 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response is nullptr");
963 return nullptr;
964 }
965
966 std::string name;
967 if (!NapiParseUtils::ParseString(env, argv[0], name)) {
968 return nullptr;
969 }
970
971 napi_value headerValue;
972 char* result = response->GetHeaderByName(name.c_str());
973 napi_status status = napi_create_string_utf8(env, result, NAPI_AUTO_LENGTH, &headerValue);
974 OH_ArkWeb_ReleaseString(result);
975 if (status != napi_ok) {
976 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response get failed");
977 return nullptr;
978 }
979 return headerValue;
980 }
981
JS_SetHeaderByName(napi_env env,napi_callback_info cbinfo)982 napi_value NapiWebSchemeHandlerResponse::JS_SetHeaderByName(napi_env env, napi_callback_info cbinfo)
983 {
984 size_t argc = INTEGER_THREE;
985 napi_value argv[INTEGER_THREE] = {0};
986 napi_value thisVar = nullptr;
987 void *data = nullptr;
988 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
989
990 WebSchemeHandlerResponse *response = nullptr;
991 napi_unwrap(env, thisVar, (void **)&response);
992
993 if (!response) {
994 WVLOG_E("unwrap WebSchemeHandlerResponse failed");
995 return nullptr;
996 }
997 std::string name;
998 std::string value;
999 bool overwrite = false;
1000 if (argc != INTEGER_THREE) {
1001 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1002 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "three"));
1003 WVLOG_E("NapiWebSchemeHandlerResponse::JS_SetHeaderByName parse failed");
1004 return nullptr;
1005 }
1006 if (!NapiParseUtils::ParseString(env, argv[INTEGER_ZERO], name)) {
1007 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1008 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "name", "string"));
1009 WVLOG_E("NapiWebSchemeHandlerResponse::JS_SetHeaderByName parse failed");
1010 return nullptr;
1011 }
1012 if (!NapiParseUtils::ParseString(env, argv[INTEGER_ONE], value)) {
1013 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1014 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "value", "string"));
1015 WVLOG_E("NapiWebSchemeHandlerResponse::JS_SetHeaderByName parse failed");
1016 return nullptr;
1017 }
1018 if (!NapiParseUtils::ParseBoolean(env, argv[INTEGER_TWO], overwrite)) {
1019 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1020 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "overwrite", "booleane"));
1021 WVLOG_E("NapiWebSchemeHandlerResponse::JS_SetHeaderByName parse failed");
1022 return nullptr;
1023 }
1024 response->SetHeaderByName(name.c_str(), value.c_str(), overwrite);
1025 return nullptr;
1026 }
1027
JS_GetNetErrorCode(napi_env env,napi_callback_info cbinfo)1028 napi_value NapiWebSchemeHandlerResponse::JS_GetNetErrorCode(napi_env env, napi_callback_info cbinfo)
1029 {
1030 size_t argc = 1;
1031 napi_value argv[1] = {0};
1032 napi_value thisVar = nullptr;
1033 void *data = nullptr;
1034 WebSchemeHandlerResponse *response = nullptr;
1035 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
1036
1037 napi_unwrap(env, thisVar, (void **)&response);
1038 if (!response) {
1039 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response is nullptr");
1040 return nullptr;
1041 }
1042
1043 napi_value code;
1044 int32_t result = response->GetErrorCode();
1045 NAPI_CALL(env, napi_create_int32(env, result, &code));
1046 return code;
1047 }
1048
JS_SetNetErrorCode(napi_env env,napi_callback_info cbinfo)1049 napi_value NapiWebSchemeHandlerResponse::JS_SetNetErrorCode(napi_env env, napi_callback_info cbinfo)
1050 {
1051 size_t argc = INTEGER_ONE;
1052 napi_value argv[INTEGER_ONE] = {0};
1053 napi_value thisVar = nullptr;
1054 void *data = nullptr;
1055 WebSchemeHandlerResponse *response = nullptr;
1056 napi_get_cb_info(env, cbinfo, &argc, argv, &thisVar, &data);
1057
1058 napi_unwrap(env, thisVar, (void **)&response);
1059 if (!response) {
1060 WVLOG_E("NapiWebSchemeHandlerResponse::JS_GetEncoding response is nullptr");
1061 return nullptr;
1062 }
1063 int32_t code = 0;
1064 if (argc != INTEGER_ONE) {
1065 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1066 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1067 return nullptr;
1068 }
1069 if (!NapiParseUtils::ParseInt32(env, argv[0], code)) {
1070 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1071 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "code", "int"));
1072 return nullptr;
1073 }
1074 response->SetErrorCode(code);
1075 return nullptr;
1076 }
1077
Init(napi_env env,napi_value exports)1078 napi_value NapiWebSchemeHandler::Init(napi_env env, napi_value exports)
1079 {
1080 WVLOG_D("NapiWebSchemeHandler::Init");
1081 napi_property_descriptor properties[] = {
1082 DECLARE_NAPI_FUNCTION("onRequestStart", JS_RequestStart),
1083 DECLARE_NAPI_FUNCTION("onRequestStop", JS_RequestStop),
1084 };
1085 napi_value webSchemeHandler = nullptr;
1086 napi_define_class(env, WEB_SCHEME_HANDLER.c_str(), WEB_SCHEME_HANDLER.length(),
1087 JS_Constructor, nullptr,
1088 sizeof(properties) / sizeof(properties[0]), properties, &webSchemeHandler);
1089 napi_set_named_property(env, exports, WEB_SCHEME_HANDLER.c_str(),
1090 webSchemeHandler);
1091 return exports;
1092 }
1093
JS_Constructor(napi_env env,napi_callback_info info)1094 napi_value NapiWebSchemeHandler::JS_Constructor(napi_env env, napi_callback_info info)
1095 {
1096 WVLOG_D("NapiWebSchemeHandler::JS_Constructor is called");
1097 napi_value thisVar = nullptr;
1098 void *data = nullptr;
1099 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1100
1101 WebSchemeHandler *handler = new WebSchemeHandler(env);
1102
1103 napi_wrap(
1104 env, thisVar, handler,
1105 [](napi_env /* env */, void *data, void * /* hint */) {
1106 WebSchemeHandler *handler = (WebSchemeHandler *)data;
1107 delete handler;
1108 },
1109 nullptr, nullptr);
1110
1111 return thisVar;
1112 }
1113
JS_RequestStart(napi_env env,napi_callback_info info)1114 napi_value NapiWebSchemeHandler::JS_RequestStart(napi_env env, napi_callback_info info)
1115 {
1116 WVLOG_D("NapiWebSchemeHandler::JS_RequestStart");
1117 size_t argc = 1;
1118 napi_value argv[1] = {0};
1119 napi_value thisVar = nullptr;
1120 void *data = nullptr;
1121 WebSchemeHandler *handler = nullptr;
1122 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1123
1124 napi_unwrap(env, thisVar, (void **)&handler);
1125 if (!handler) {
1126 WVLOG_E("webSchemeHandler is null");
1127 return thisVar;
1128 }
1129
1130 napi_valuetype valueType = napi_undefined;
1131 napi_typeof(env, argv[0], &valueType);
1132
1133 if (argc != INTEGER_ONE) {
1134 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1135 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1136 return nullptr;
1137 }
1138 if (valueType != napi_function) {
1139 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1140 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
1141 return nullptr;
1142 }
1143
1144 handler->PutRequestStart(env, argv[0]);
1145 return thisVar;
1146 }
1147
JS_RequestStop(napi_env env,napi_callback_info info)1148 napi_value NapiWebSchemeHandler::JS_RequestStop(napi_env env, napi_callback_info info)
1149 {
1150 WVLOG_D("NapiWebSchemeHandler::JS_RequestStop");
1151 size_t argc = 1;
1152 napi_value argv[1] = {0};
1153 napi_value thisVar = nullptr;
1154 void *data = nullptr;
1155 WebSchemeHandler *handler = nullptr;
1156 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1157
1158 napi_unwrap(env, thisVar, (void **)&handler);
1159 if (!handler) {
1160 WVLOG_E("webSchemeHandler is null");
1161 return thisVar;
1162 }
1163
1164 napi_valuetype valueType = napi_undefined;
1165 napi_typeof(env, argv[0], &valueType);
1166
1167 if (argc != INTEGER_ONE || valueType != napi_function) {
1168 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
1169 return nullptr;
1170 }
1171
1172 handler->PutRequestStop(env, argv[0]);
1173 return thisVar;
1174 }
1175
Init(napi_env env,napi_value exports)1176 napi_value NapiWebResourceHandler::Init(napi_env env, napi_value exports)
1177 {
1178 ExportWebResourceHandlerClass(env, &exports);
1179 return exports;
1180 }
1181
ExportWebResourceHandlerClass(napi_env env,napi_value * exportsPointer)1182 void NapiWebResourceHandler::ExportWebResourceHandlerClass(
1183 napi_env env, napi_value* exportsPointer)
1184 {
1185 napi_property_descriptor properties[] = {
1186 DECLARE_NAPI_FUNCTION("didReceiveResponse", JS_DidReceiveResponse),
1187 DECLARE_NAPI_FUNCTION("didReceiveResponseBody", JS_DidReceiveResponseBody),
1188 DECLARE_NAPI_FUNCTION("didFinish", JS_DidFinish),
1189 DECLARE_NAPI_FUNCTION("didFail", JS_DidFailWithError),
1190 };
1191 napi_value webResourceHandler = nullptr;
1192 napi_define_class(env, WEB_RESOURCE_HANDLER.c_str(), WEB_RESOURCE_HANDLER.length(),
1193 JS_Constructor, nullptr,
1194 sizeof(properties) / sizeof(properties[0]), properties, &webResourceHandler);
1195 napi_set_named_property(env, *exportsPointer, WEB_RESOURCE_HANDLER.c_str(),
1196 webResourceHandler);
1197 }
1198
DefineProperties(napi_env env,napi_value * object)1199 napi_status NapiWebResourceHandler::DefineProperties(
1200 napi_env env, napi_value* object)
1201 {
1202 napi_property_descriptor properties[] = {
1203 DECLARE_NAPI_FUNCTION("didReceiveResponse", JS_DidReceiveResponse),
1204 DECLARE_NAPI_FUNCTION("didReceiveResponseBody", JS_DidReceiveResponseBody),
1205 DECLARE_NAPI_FUNCTION("didFinish", JS_DidFinish),
1206 DECLARE_NAPI_FUNCTION("didFail", JS_DidFailWithError),
1207 };
1208 return napi_define_properties(env, *object, sizeof(properties) / sizeof(properties[0]), properties);
1209 }
1210
JS_Constructor(napi_env env,napi_callback_info info)1211 napi_value NapiWebResourceHandler::JS_Constructor(napi_env env, napi_callback_info info)
1212 {
1213 WVLOG_D("NapiWebResourceHandler::JS_Constructor is called");
1214 napi_value thisVar = nullptr;
1215 void *data = nullptr;
1216 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1217
1218 WebResourceHandler *handler = new WebResourceHandler(env);
1219
1220 napi_wrap(
1221 env, thisVar, handler,
1222 [](napi_env /* env */, void *data, void * /* hint */) {
1223 WebResourceHandler *handler = (WebResourceHandler *)data;
1224 delete handler;
1225 },
1226 nullptr, nullptr);
1227
1228 return thisVar;
1229 }
1230
JS_DidReceiveResponse(napi_env env,napi_callback_info info)1231 napi_value NapiWebResourceHandler::JS_DidReceiveResponse(napi_env env, napi_callback_info info)
1232 {
1233 WVLOG_D("NapiWebResourceHandler::JS_DidReceiveResponse is called");
1234 size_t argc = 1;
1235 napi_value argv[1] = {0};
1236 napi_value thisVar = nullptr;
1237 void *data = nullptr;
1238 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1239
1240 if (argc != 1) {
1241 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1242 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1243 return nullptr;
1244 }
1245
1246 WebResourceHandler *resourceHandler = nullptr;
1247 napi_unwrap(env, thisVar, (void **)&resourceHandler);
1248
1249 if (!resourceHandler) {
1250 WVLOG_E("JS_DidReceiveResponse unwrap resource handler failed");
1251 return nullptr;
1252 }
1253
1254 WebSchemeHandlerResponse* response = nullptr;
1255 napi_value obj = argv[0];
1256 napi_unwrap(env, obj, (void**)&response);
1257 if (!response) {
1258 WVLOG_E("JS_DidReceiveResponse unwrap response failed");
1259 return nullptr;
1260 }
1261 int32_t ret =
1262 resourceHandler->DidReceiveResponse(response->GetArkWebResponse());
1263 if (ret != 0) {
1264 BusinessError::ThrowErrorByErrcode(env, RESOURCE_HANDLER_INVALID);
1265 }
1266 return nullptr;
1267 }
1268
JS_DidReceiveResponseBody(napi_env env,napi_callback_info info)1269 napi_value NapiWebResourceHandler::JS_DidReceiveResponseBody(napi_env env, napi_callback_info info)
1270 {
1271 WVLOG_D("NapiWebResourceHandler::JS_DidReceiveResponseBody is called");
1272 size_t argc = 1;
1273 napi_value argv[1] = {0};
1274 napi_value thisVar = nullptr;
1275 void *data = nullptr;
1276 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1277
1278 if (argc != 1) {
1279 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1280 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
1281 return nullptr;
1282 }
1283
1284 WebResourceHandler *resourceHandler = nullptr;
1285 napi_unwrap(env, thisVar, (void **)&resourceHandler);
1286
1287 if (!resourceHandler) {
1288 WVLOG_E("unwrap resource handler failed");
1289 return nullptr;
1290 }
1291 bool isArrayBuffer = false;
1292 NAPI_CALL(env, napi_is_arraybuffer(env, argv[0], &isArrayBuffer));
1293 if (!isArrayBuffer) {
1294 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR);
1295 return nullptr;
1296 }
1297
1298 uint8_t *arrBuf = nullptr;
1299 size_t byteLength = 0;
1300 napi_get_arraybuffer_info(env, argv[0], (void **)&arrBuf, &byteLength);
1301 int32_t ret = resourceHandler->DidReceiveResponseBody(
1302 arrBuf, static_cast<int64_t>(byteLength));
1303 if (ret != 0) {
1304 WVLOG_E("JS_DidReceiveResponseBody ret=%{public}d", ret);
1305 BusinessError::ThrowErrorByErrcode(env, RESOURCE_HANDLER_INVALID);
1306 }
1307 return nullptr;
1308 }
1309
JS_DidFinish(napi_env env,napi_callback_info info)1310 napi_value NapiWebResourceHandler::JS_DidFinish(napi_env env, napi_callback_info info)
1311 {
1312 WVLOG_D("NapiWebResourceHandler::JS_DidFinish is called");
1313 napi_value thisVar = nullptr;
1314 void *data = nullptr;
1315 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1316
1317 WebResourceHandler *resourceHandler = nullptr;
1318 napi_unwrap(env, thisVar, (void **)&resourceHandler);
1319
1320 if (!resourceHandler) {
1321 WVLOG_E("unwrap resource handler failed");
1322 return nullptr;
1323 }
1324
1325 int32_t ret = resourceHandler->DidFinish();
1326 if (ret != 0) {
1327 BusinessError::ThrowErrorByErrcode(env, RESOURCE_HANDLER_INVALID);
1328 WVLOG_E("JS_DidFinish ret=%{public}d", ret);
1329 }
1330 return nullptr;
1331 }
1332
JS_DidFailWithError(napi_env env,napi_callback_info info)1333 napi_value NapiWebResourceHandler::JS_DidFailWithError(napi_env env, napi_callback_info info)
1334 {
1335 size_t argc = 2;
1336 napi_value argv[2] = {0};
1337 napi_value thisVar = nullptr;
1338 void *data = nullptr;
1339 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1340
1341 WebResourceHandler *resourceHandler = nullptr;
1342 napi_unwrap(env, thisVar, (void **)&resourceHandler);
1343
1344 if (!resourceHandler) {
1345 WVLOG_E("unwrap resource handler failed");
1346 return nullptr;
1347 }
1348
1349 int32_t errorCode;
1350 static constexpr int LEVEL_20_COUNT = 2;
1351 if (!NapiParseUtils::ParseInt32(env, argv[0], errorCode)) {
1352 WVLOG_E("JS_DidFailWithError unwrap error code failed");
1353 if (argc < LEVEL_20_COUNT) {
1354 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1355 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "code", "int"));
1356 } else {
1357 BusinessError::ThrowErrorByErrcode(env, INVALID_NET_ERROR,
1358 NWebError::GetErrMsgByErrCode(INVALID_NET_ERROR));
1359 }
1360
1361 return nullptr;
1362 }
1363
1364 if (argc >= LEVEL_20_COUNT && (!IsArkWebNetErrorValid(errorCode) || errorCode == ARKWEB_NET_OK)) {
1365 BusinessError::ThrowErrorByErrcode(env, INVALID_NET_ERROR,
1366 NWebError::GetErrMsgByErrCode(INVALID_NET_ERROR));
1367 }
1368
1369 bool completeIfNoResponse = false;
1370 if (!NapiParseUtils::ParseBoolean(env, argv[1], completeIfNoResponse)) {
1371 WVLOG_E("JS_DidFailWithError unwrap error completeIfNoResponse failed");
1372 }
1373
1374 int32_t ret = resourceHandler->DidFailWithError(
1375 static_cast<ArkWeb_NetError>(errorCode), completeIfNoResponse);
1376 if (ret != 0) {
1377 BusinessError::ThrowErrorByErrcode(env, RESOURCE_HANDLER_INVALID);
1378 WVLOG_E("JS_DidFailWithError ret=%{public}d", ret);
1379 }
1380 return nullptr;
1381 }
1382
Init(napi_env env,napi_value exports)1383 napi_value NapiWebHttpBodyStream::Init(napi_env env, napi_value exports)
1384 {
1385 ExportWebHttpBodyStreamClass(env, &exports);
1386 return exports;
1387 }
1388
ExportWebHttpBodyStreamClass(napi_env env,napi_value * exportsPointer)1389 void NapiWebHttpBodyStream::ExportWebHttpBodyStreamClass(
1390 napi_env env, napi_value* exportsPointer)
1391 {
1392 napi_property_descriptor properties[] = {
1393 DECLARE_NAPI_FUNCTION("initialize", JS_Initialize),
1394 DECLARE_NAPI_FUNCTION("read", JS_Read),
1395 DECLARE_NAPI_FUNCTION("getSize", JS_GetSize),
1396 DECLARE_NAPI_FUNCTION("getPosition", JS_GetPostion),
1397 DECLARE_NAPI_FUNCTION("isChunked", JS_IsChunked),
1398 DECLARE_NAPI_FUNCTION("isEof", JS_IsEof),
1399 DECLARE_NAPI_FUNCTION("isInMemory", JS_IsInMemory),
1400 };
1401 napi_value webHttpBodyStream = nullptr;
1402 napi_define_class(env, WEB_HTTP_BODY_STREAM.c_str(), WEB_HTTP_BODY_STREAM.length(),
1403 JS_Constructor, nullptr,
1404 sizeof(properties) / sizeof(properties[0]), properties, &webHttpBodyStream);
1405 napi_set_named_property(env, *exportsPointer, WEB_HTTP_BODY_STREAM.c_str(),
1406 webHttpBodyStream);
1407 }
1408
DefineProperties(napi_env env,napi_value * object)1409 napi_status NapiWebHttpBodyStream::DefineProperties(napi_env env, napi_value* object)
1410 {
1411 napi_property_descriptor properties[] = {
1412 DECLARE_NAPI_FUNCTION("initialize", JS_Initialize),
1413 DECLARE_NAPI_FUNCTION("read", JS_Read),
1414 DECLARE_NAPI_FUNCTION("getSize", JS_GetSize),
1415 DECLARE_NAPI_FUNCTION("getPosition", JS_GetPostion),
1416 DECLARE_NAPI_FUNCTION("isChunked", JS_IsChunked),
1417 DECLARE_NAPI_FUNCTION("isEof", JS_IsEof),
1418 DECLARE_NAPI_FUNCTION("isInMemory", JS_IsInMemory),
1419 };
1420 return napi_define_properties(env, *object,
1421 sizeof(properties) / sizeof(properties[0]), properties);
1422 }
1423
JS_Constructor(napi_env env,napi_callback_info info)1424 napi_value NapiWebHttpBodyStream::JS_Constructor(napi_env env, napi_callback_info info)
1425 {
1426 WVLOG_D("NapiWebHttpBodyStream::JS_Constructor is called");
1427 napi_value thisVar = nullptr;
1428 void *data = nullptr;
1429 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1430
1431 WebHttpBodyStream *stream = new WebHttpBodyStream(env);
1432 napi_wrap(
1433 env, thisVar, stream,
1434 [](napi_env /* env */, void *data, void * /* hint */) {
1435 WebHttpBodyStream *stream = (WebHttpBodyStream *)data;
1436 delete stream;
1437 },
1438 nullptr, nullptr);
1439 return thisVar;
1440 }
1441
JS_Initialize(napi_env env,napi_callback_info info)1442 napi_value NapiWebHttpBodyStream::JS_Initialize(napi_env env, napi_callback_info info)
1443 {
1444 napi_value thisVar = nullptr;
1445 size_t argc = INTEGER_ONE;
1446 size_t argcPromise = INTEGER_ZERO;
1447 size_t argcCallback = INTEGER_ONE;
1448 napi_value argv[INTEGER_ONE] = {0};
1449 WebHttpBodyStream *stream = nullptr;
1450
1451 napi_value result = nullptr;
1452 napi_get_undefined(env, &result);
1453 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
1454 napi_unwrap(env, thisVar, (void **)&stream);
1455 if (!stream) {
1456 WVLOG_E("NapiWebHttpBodyStream::JS_Initialize stream is nullptr");
1457 return nullptr;
1458 }
1459 if (argc != argcPromise && argc != argcCallback) {
1460 NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
1461 return nullptr;
1462 }
1463 if (argc == argcCallback) {
1464 napi_valuetype valueType = napi_null;
1465 napi_typeof(env, argv[argcCallback - 1], &valueType);
1466 if (valueType != napi_function) {
1467 NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR);
1468 return nullptr;
1469 }
1470 napi_ref jsCallback = nullptr;
1471 napi_create_reference(env, argv[argcCallback - 1], INTEGER_ONE, &jsCallback);
1472
1473 if (jsCallback) {
1474 stream->Init(std::move(jsCallback), nullptr);
1475 }
1476 return result;
1477 }
1478
1479 napi_deferred deferred = nullptr;
1480 napi_value promise = nullptr;
1481 napi_create_promise(env, &deferred, &promise);
1482 if (promise && deferred) {
1483 stream->Init(nullptr, std::move(deferred));
1484 return promise;
1485 }
1486 return result;
1487 }
1488
CheckReadParamsNumber(napi_env env,const size_t argc)1489 bool CheckReadParamsNumber(napi_env env, const size_t argc)
1490 {
1491 size_t argcPromise = INTEGER_ONE;
1492 size_t argcCallback = INTEGER_TWO;
1493 if (argc != argcPromise && argc != argcCallback) {
1494 NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
1495 NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "one", "two"));
1496 WVLOG_E("NapiWebHttpBodyStream::JS_Read parse failed");
1497 return false;
1498 }
1499 return true;
1500 }
1501
checkReadBufLen(napi_env env,const int32_t bufLen)1502 bool checkReadBufLen(napi_env env, const int32_t bufLen)
1503 {
1504 if (bufLen <= 0) {
1505 BusinessError::ThrowErrorByErrcode(env, PARAM_CHECK_ERROR,
1506 "BusinessError 401: Parameter error. The value of size must be a number greater than 0.");
1507 WVLOG_E("NapiWebHttpBodyStream::JS_Read parse failed");
1508 return false;
1509 }
1510 return true;
1511 }
1512
JS_Read(napi_env env,napi_callback_info info)1513 napi_value NapiWebHttpBodyStream::JS_Read(napi_env env, napi_callback_info info)
1514 {
1515 napi_value thisVar = nullptr;
1516 void* data = nullptr;
1517 size_t argc = INTEGER_TWO;
1518 size_t argcCallback = INTEGER_TWO;
1519 napi_value argv[INTEGER_TWO] = {0};
1520 WebHttpBodyStream *stream = nullptr;
1521
1522 napi_value result = nullptr;
1523 napi_get_undefined(env, &result);
1524 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1525 napi_unwrap(env, thisVar, (void **)&stream);
1526 if (!stream) {
1527 WVLOG_E("NapiWebHttpBodyStream::JS_Initialize stream is nullptr");
1528 return nullptr;
1529 }
1530 if (!CheckReadParamsNumber(env, argc)) {
1531 return nullptr;
1532 }
1533
1534 int32_t bufLen = 0;
1535 NapiParseUtils::ParseInt32(env, argv[0], bufLen);
1536 if (!checkReadBufLen(env, bufLen)) {
1537 return nullptr;
1538 }
1539
1540 if (argc == argcCallback) {
1541 napi_valuetype valueType = napi_null;
1542 napi_typeof(env, argv[argcCallback - 1], &valueType);
1543 if (valueType != napi_function) {
1544 NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
1545 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
1546 return nullptr;
1547 }
1548 napi_ref jsCallback = nullptr;
1549 napi_create_reference(env, argv[argcCallback - 1], INTEGER_ONE, &jsCallback);
1550
1551 if (jsCallback) {
1552 stream->Read(bufLen, std::move(jsCallback), nullptr);
1553 }
1554 return result;
1555 }
1556
1557 napi_deferred deferred = nullptr;
1558 napi_value promise = nullptr;
1559 napi_create_promise(env, &deferred, &promise);
1560 if (promise && deferred) {
1561 stream->Read(bufLen, nullptr, std::move(deferred));
1562 return promise;
1563 }
1564 return result;
1565 }
1566
JS_GetSize(napi_env env,napi_callback_info info)1567 napi_value NapiWebHttpBodyStream::JS_GetSize(napi_env env, napi_callback_info info)
1568 {
1569 napi_value thisVar = nullptr;
1570 void *data = nullptr;
1571 WebHttpBodyStream *stream = nullptr;
1572 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1573
1574 napi_unwrap(env, thisVar, (void **)&stream);
1575 if (!stream) {
1576 WVLOG_E("NapiWebHttpBodyStream::JS_GetSize stream is nullptr");
1577 return nullptr;
1578 }
1579
1580 napi_value value;
1581 int64_t result = static_cast<int64_t>(stream->GetSize());
1582 napi_create_int64(env, result, &value);
1583 return value;
1584 }
1585
JS_GetPostion(napi_env env,napi_callback_info info)1586 napi_value NapiWebHttpBodyStream::JS_GetPostion(napi_env env, napi_callback_info info)
1587 {
1588 napi_value thisVar = nullptr;
1589 void *data = nullptr;
1590 WebHttpBodyStream *stream = nullptr;
1591 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1592
1593 napi_unwrap(env, thisVar, (void **)&stream);
1594 if (!stream) {
1595 WVLOG_E("NapiWebHttpBodyStream::JS_GetPostion stream is nullptr");
1596 return nullptr;
1597 }
1598
1599 napi_value value;
1600 int64_t result = static_cast<int64_t>(stream->GetPostion());
1601 napi_create_int64(env, result, &value);
1602 return value;
1603 }
1604
JS_IsChunked(napi_env env,napi_callback_info info)1605 napi_value NapiWebHttpBodyStream::JS_IsChunked(napi_env env, napi_callback_info info)
1606 {
1607 napi_value thisVar = nullptr;
1608 void *data = nullptr;
1609 WebHttpBodyStream *stream = nullptr;
1610 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1611
1612 napi_unwrap(env, thisVar, (void **)&stream);
1613 if (!stream) {
1614 WVLOG_E("NapiWebHttpBodyStream::JS_IsChunked stream is nullptr");
1615 return nullptr;
1616 }
1617
1618 napi_value value;
1619 bool result = stream->IsChunked();
1620 NAPI_CALL(env, napi_get_boolean(env, result, &value));
1621 return value;
1622 }
1623
JS_IsEof(napi_env env,napi_callback_info info)1624 napi_value NapiWebHttpBodyStream::JS_IsEof(napi_env env, napi_callback_info info)
1625 {
1626 napi_value thisVar = nullptr;
1627 void *data = nullptr;
1628 WebHttpBodyStream *stream = nullptr;
1629 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1630
1631 napi_unwrap(env, thisVar, (void **)&stream);
1632 if (!stream) {
1633 WVLOG_E("NapiWebHttpBodyStream::JS_IsEof stream is nullptr");
1634 return nullptr;
1635 }
1636
1637 napi_value value;
1638 bool result = stream->IsEof();
1639 NAPI_CALL(env, napi_get_boolean(env, result, &value));
1640 return value;
1641 }
1642
JS_IsInMemory(napi_env env,napi_callback_info info)1643 napi_value NapiWebHttpBodyStream::JS_IsInMemory(napi_env env, napi_callback_info info)
1644 {
1645 napi_value thisVar = nullptr;
1646 void *data = nullptr;
1647 WebHttpBodyStream *stream = nullptr;
1648 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data);
1649
1650 napi_unwrap(env, thisVar, (void **)&stream);
1651 if (!stream) {
1652 WVLOG_E("NapiWebHttpBodyStream::JS_IsInMemory stream is nullptr");
1653 return nullptr;
1654 }
1655
1656 napi_value value;
1657 bool result = stream->IsInMemory();
1658 NAPI_CALL(env, napi_get_boolean(env, result, &value));
1659 return value;
1660 }
1661 }
1662 }
1663