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 #ifndef NWEB_WEB_SCHEME_HANDLER_REQUEST_H
17 #define NWEB_WEB_SCHEME_HANDLER_REQUEST_H
18 
19 #include <string>
20 #include <uv.h>
21 
22 #include "napi/native_api.h"
23 #include "napi/native_common.h"
24 #include "napi/native_node_api.h"
25 
26 #include "arkweb_scheme_handler.h"
27 #include "refbase.h"
28 
29 namespace OHOS {
30 namespace NWeb {
31 using WebHeaderList = std::vector<std::pair<std::string, std::string>>;
32 class WebSchemeHandlerRequest {
33 public:
34     explicit WebSchemeHandlerRequest(napi_env env);
35     WebSchemeHandlerRequest(napi_env env, const ArkWeb_ResourceRequest* request);
36     ~WebSchemeHandlerRequest();
37 
38     char* GetRequestUrl();
39     char* GetMethod();
40     char* GetReferrer();
41     bool IsRedirect();
42     bool IsMainFrame();
43     bool HasGesture();
44     const WebHeaderList& GetHeader();
45     ArkWeb_HttpBodyStream* GetHttpBodyStream();
46     int32_t GetRequestResourceType();
47     char* GetFrameUrl();
48 private:
49     napi_env env_;
50     char* url_ = nullptr;
51     char* method_ = nullptr;
52     char* referrer_ = nullptr;
53     bool isRedirect_ = false;
54     bool isMainFrame_ = false;
55     bool hasGesture_ = false;
56     WebHeaderList headerList_;
57     ArkWeb_HttpBodyStream* stream_ = nullptr;
58     int32_t requestResourceType_ = -1;
59     char* frameUrl_ = nullptr;
60 };
61 
62 class WebSchemeHandlerResponse {
63 public:
64     explicit WebSchemeHandlerResponse(napi_env env);
65     WebSchemeHandlerResponse(napi_env env, ArkWeb_Response* response);
66     ~WebSchemeHandlerResponse();
67 
68     char* GetUrl();
69     int32_t SetUrl(const char* url);
70     int32_t GetStatus() const;
71     int32_t SetStatus(int32_t status);
72     char* GetStatusText();
73     int32_t SetStatusText(const char* statusText);
74     char* GetMimeType();
75     int32_t SetMimeType(const char* mimeType);
76     char* GetEncoding() const;
77     int32_t SetEncoding(const char* encoding);
78     char* GetHeaderByName(const char* name);
79     int32_t SetHeaderByName(const char* name, const char* value, bool overwrite);
80     int32_t GetErrorCode();
81     int32_t SetErrorCode(int32_t code);
GetArkWebResponse()82     ArkWeb_Response* GetArkWebResponse()
83     {
84         return response_;
85     }
86 private:
87     napi_env env_;
88     ArkWeb_Response* response_ = nullptr;
89 };
90 
91 class WebSchemeHandler {
92 public:
93     explicit WebSchemeHandler(napi_env env);
94     ~WebSchemeHandler();
95 
96     static const ArkWeb_SchemeHandler* GetArkWebSchemeHandler(
97         WebSchemeHandler* handler);
98     static WebSchemeHandler* GetWebSchemeHandler(
99         const ArkWeb_SchemeHandler* handler);
100 
101     void RequestStart(ArkWeb_ResourceRequest* request,
102                       const ArkWeb_ResourceHandler* ArkWeb_ResourceHandler,
103                       bool* intercept);
104     void RequestStop(const ArkWeb_ResourceRequest* resourceRequest);
105 
106     void PutRequestStart(napi_env, napi_value callback);
107     void PutRequestStop(napi_env, napi_value callback);
108 
109     napi_ref delegate_ = nullptr;
110     static std::unordered_map<WebSchemeHandler*, const ArkWeb_SchemeHandler*>
111         webSchemeHandlerMap_;
112     static std::unordered_map<const ArkWeb_SchemeHandler*, WebSchemeHandler*>
113         arkWebSchemeHandlerMap_;
114 private:
115     typedef struct RequestStopParam {
116         napi_env env_;
117         napi_ref callbackRef_;
118         WebSchemeHandlerRequest* request_;
119         const ArkWeb_ResourceRequest* arkWebRequest_;
120     } RequestStopParam;
121 
122     static void RequestStopAfterWorkCb(uv_work_t* work, int status);
123 
124     napi_env env_;
125     ArkWeb_OnRequestStart onRequestStart_ = nullptr;
126     ArkWeb_OnRequestStop onRequestStop_ = nullptr;
127     napi_ref request_start_callback_ = nullptr;
128     napi_ref request_stop_callback_ = nullptr;
129 };
130 
131 class WebResourceHandler : public RefBase {
132 public:
133     explicit WebResourceHandler(napi_env env);
134     WebResourceHandler(napi_env env, const ArkWeb_ResourceHandler* handler);
135     ~WebResourceHandler();
136     int32_t DidReceiveResponse(const ArkWeb_Response* response);
137     int32_t DidReceiveResponseBody(const uint8_t* buffer, int64_t buflen);
138     int32_t DidFinish();
139     int32_t DidFailWithError(ArkWeb_NetError errorCode);
140     void DestoryArkWebResourceHandler();
SetFinishFlag()141     void SetFinishFlag()
142     {
143         isFinished_ = true;
144     }
145 private:
146     bool isFinished_ = false;
147     ArkWeb_ResourceHandler* handler_ = nullptr;
148     napi_env env_;
149 };
150 
151 class WebHttpBodyStream {
152 public:
153     explicit WebHttpBodyStream(napi_env env);
154     static void HttpBodyStreamReadCallback(
155         const ArkWeb_HttpBodyStream* httpBodyStream, uint8_t* buffer, int bytesRead);
156     static void HttpBodyStreamInitCallback(
157         const ArkWeb_HttpBodyStream* httpBodyStream, ArkWeb_NetError result);
158     WebHttpBodyStream(napi_env env, ArkWeb_HttpBodyStream* stream);
159     ~WebHttpBodyStream();
160     void Init(napi_ref jsCallback, napi_deferred deferred);
161     void Read(int bufLen, napi_ref jsCallback, napi_deferred deferred);
162     uint64_t GetPostion() const;
163     uint64_t GetSize() const;
164     bool IsChunked() const;
165     bool IsEof();
166     bool IsInMemory();
167 
168     void ExecuteInit(ArkWeb_NetError result);
169     void ExecuteRead(uint8_t* buffer, int bytesRead);
170 private:
171     struct InitParam {
172         napi_env env;
173         napi_async_work asyncWork;
174         napi_deferred deferred;
175         napi_ref callbackRef;
176         ArkWeb_NetError result;
177     };
178 
179     struct ReadParam {
180         napi_env env;
181         napi_async_work asyncWork;
182         napi_deferred deferred;
183         napi_ref callbackRef;
184         uint8_t* buffer = nullptr;
185         int bytesRead = 0;
186     };
187 
188     static void ExecuteReadComplete(napi_env env, napi_status status, void* data);
189     static void ExecuteInitComplete(napi_env env, napi_status status, void* data);
190 
191     napi_ref initJsCallback_ = nullptr;
192     napi_deferred initDeferred_ = nullptr;
193     napi_ref readJsCallback_ = nullptr;
194     napi_deferred readDeferred_ = nullptr;
195     napi_env env_;
196     ArkWeb_HttpBodyStream* stream_ = nullptr;
197 };
198 }
199 }
200 #endif
201