1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "constant.h"
17 #include "js_task.h"
18 #include "legacy/request_manager.h"
19 #include "log.h"
20 #include "napi/native_api.h"
21 #include "napi/native_node_api.h"
22 #include "napi_utils.h"
23 #include "request_event.h"
24
25 using namespace OHOS::Request;
26 #define DECLARE_NAPI_METHOD(name, func) \
27 { \
28 name, 0, func, 0, 0, 0, napi_default, 0 \
29 }
30
31 static constexpr const char *BROADCAST_EVENT_COMPLETE = "ohos.request.event.COMPLETE";
32
NapiCreateAction(napi_env env,napi_value & action)33 static void NapiCreateAction(napi_env env, napi_value &action)
34 {
35 napi_create_object(env, &action);
36 NapiUtils::SetUint32Property(env, action, "DOWNLOAD", static_cast<uint32_t>(Action::DOWNLOAD));
37 NapiUtils::SetUint32Property(env, action, "UPLOAD", static_cast<uint32_t>(Action::UPLOAD));
38 }
39
NapiCreateMode(napi_env env,napi_value & mode)40 static void NapiCreateMode(napi_env env, napi_value &mode)
41 {
42 napi_create_object(env, &mode);
43 NapiUtils::SetUint32Property(env, mode, "BACKGROUND", static_cast<uint32_t>(Mode::BACKGROUND));
44 NapiUtils::SetUint32Property(env, mode, "FOREGROUND", static_cast<uint32_t>(Mode::FOREGROUND));
45 }
46
NapiCreateNetwork(napi_env env,napi_value & network)47 static void NapiCreateNetwork(napi_env env, napi_value &network)
48 {
49 napi_create_object(env, &network);
50 NapiUtils::SetUint32Property(env, network, "ANY", static_cast<uint32_t>(Network::ANY));
51 NapiUtils::SetUint32Property(env, network, "WIFI", static_cast<uint32_t>(Network::WIFI));
52 NapiUtils::SetUint32Property(env, network, "CELLULAR", static_cast<uint32_t>(Network::CELLULAR));
53 }
54
NapiCreateState(napi_env env,napi_value & state)55 static void NapiCreateState(napi_env env, napi_value &state)
56 {
57 napi_create_object(env, &state);
58 NapiUtils::SetUint32Property(env, state, "INITIALIZED", static_cast<uint32_t>(State::INITIALIZED));
59 NapiUtils::SetUint32Property(env, state, "WAITING", static_cast<uint32_t>(State::WAITING));
60 NapiUtils::SetUint32Property(env, state, "RUNNING", static_cast<uint32_t>(State::RUNNING));
61 NapiUtils::SetUint32Property(env, state, "RETRYING", static_cast<uint32_t>(State::RETRYING));
62 NapiUtils::SetUint32Property(env, state, "PAUSED", static_cast<uint32_t>(State::PAUSED));
63 NapiUtils::SetUint32Property(env, state, "STOPPED", static_cast<uint32_t>(State::STOPPED));
64 NapiUtils::SetUint32Property(env, state, "COMPLETED", static_cast<uint32_t>(State::COMPLETED));
65 NapiUtils::SetUint32Property(env, state, "FAILED", static_cast<uint32_t>(State::FAILED));
66 NapiUtils::SetUint32Property(env, state, "REMOVED", static_cast<uint32_t>(State::REMOVED));
67 }
68
NapiCreateFaults(napi_env env,napi_value & faults)69 static void NapiCreateFaults(napi_env env, napi_value &faults)
70 {
71 napi_create_object(env, &faults);
72 NapiUtils::SetUint32Property(env, faults, "OTHERS", static_cast<uint32_t>(Faults::OTHERS));
73 NapiUtils::SetUint32Property(env, faults, "DISCONNECTED", static_cast<uint32_t>(Faults::DISCONNECTED));
74 NapiUtils::SetUint32Property(env, faults, "TIMEOUT", static_cast<uint32_t>(Faults::TIMEOUT));
75 NapiUtils::SetUint32Property(env, faults, "PROTOCOL", static_cast<uint32_t>(Faults::PROTOCOL));
76 NapiUtils::SetUint32Property(env, faults, "PARAM", static_cast<uint32_t>(Faults::PARAM));
77 NapiUtils::SetUint32Property(env, faults, "FSIO", static_cast<uint32_t>(Faults::FSIO));
78 NapiUtils::SetUint32Property(env, faults, "DNS", static_cast<uint32_t>(Faults::DNS));
79 NapiUtils::SetUint32Property(env, faults, "TCP", static_cast<uint32_t>(Faults::TCP));
80 NapiUtils::SetUint32Property(env, faults, "SSL", static_cast<uint32_t>(Faults::SSL));
81 NapiUtils::SetUint32Property(env, faults, "REDIRECT", static_cast<uint32_t>(Faults::REDIRECT));
82 }
83
NapiCreateBroadcastEvent(napi_env env,napi_value & broadcastEvent)84 static void NapiCreateBroadcastEvent(napi_env env, napi_value &broadcastEvent)
85 {
86 napi_create_object(env, &broadcastEvent);
87 NapiUtils::SetStringPropertyUtf8(
88 env, broadcastEvent, "COMPLETE", static_cast<std::string>(BROADCAST_EVENT_COMPLETE));
89 }
90
InitAgent(napi_env env,napi_value exports)91 static napi_value InitAgent(napi_env env, napi_value exports)
92 {
93 napi_value action = nullptr;
94 NapiCreateAction(env, action);
95 napi_value mode = nullptr;
96 NapiCreateMode(env, mode);
97 napi_value network = nullptr;
98 NapiCreateNetwork(env, network);
99 napi_value state = nullptr;
100 NapiCreateState(env, state);
101 napi_value faults = nullptr;
102 NapiCreateFaults(env, faults);
103 napi_value broadcastEvent = nullptr;
104 NapiCreateBroadcastEvent(env, broadcastEvent);
105
106 napi_property_descriptor desc[] = {
107 DECLARE_NAPI_PROPERTY("Action", action),
108 DECLARE_NAPI_PROPERTY("Mode", mode),
109 DECLARE_NAPI_PROPERTY("Network", network),
110 DECLARE_NAPI_PROPERTY("State", state),
111 DECLARE_NAPI_PROPERTY("Faults", faults),
112 DECLARE_NAPI_PROPERTY("BroadcastEvent", broadcastEvent),
113
114 DECLARE_NAPI_METHOD("create", JsTask::JsCreate),
115 DECLARE_NAPI_METHOD("getTask", JsTask::GetTask),
116 DECLARE_NAPI_METHOD("remove", JsTask::Remove),
117 DECLARE_NAPI_METHOD("show", JsTask::Show),
118 DECLARE_NAPI_METHOD("touch", JsTask::Touch),
119 DECLARE_NAPI_METHOD("search", JsTask::Search),
120 DECLARE_NAPI_METHOD("query", JsTask::Query),
121 };
122 napi_status status = napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
123 REQUEST_HILOGI("InitV10 end %{public}d", status);
124 return exports;
125 }
126
Init(napi_env env,napi_value exports)127 static napi_value Init(napi_env env, napi_value exports)
128 {
129 napi_value exception_permission = nullptr;
130 napi_value exception_parameter_check = nullptr;
131 napi_value exception_unsupported = nullptr;
132 napi_value exception_file_IO = nullptr;
133 napi_value exception_file_path = nullptr;
134 napi_value exception_service_error = nullptr;
135 napi_value exception_other = nullptr;
136 napi_value network_mobile = nullptr;
137 napi_value network_wifi = nullptr;
138 napi_value err_cannot_resume = nullptr;
139 napi_value err_dev_not_found = nullptr;
140 napi_value err_file_exist = nullptr;
141 napi_value err_file_error = nullptr;
142 napi_value err_http_data = nullptr;
143 napi_value err_no_space = nullptr;
144 napi_value err_many_redirect = nullptr;
145 napi_value err_http_code = nullptr;
146 napi_value err_unknown = nullptr;
147 napi_value err_offline = nullptr;
148 napi_value err_unsupported_network_type = nullptr;
149 napi_value paused_queue_wifi = nullptr;
150 napi_value paused_for_network = nullptr;
151 napi_value paused_to_retry = nullptr;
152 napi_value paused_by_user = nullptr;
153 napi_value paused_unknown = nullptr;
154 napi_value session_success = nullptr;
155 napi_value session_running = nullptr;
156 napi_value session_pending = nullptr;
157 napi_value session_paused = nullptr;
158 napi_value session_failed = nullptr;
159
160 napi_create_int32(env, static_cast<int32_t>(E_PERMISSION), &exception_permission);
161 napi_create_int32(env, static_cast<int32_t>(E_PARAMETER_CHECK), &exception_parameter_check);
162 napi_create_int32(env, static_cast<int32_t>(E_UNSUPPORTED), &exception_unsupported);
163 napi_create_int32(env, static_cast<int32_t>(E_FILE_IO), &exception_file_IO);
164 napi_create_int32(env, static_cast<int32_t>(E_FILE_PATH), &exception_file_path);
165 napi_create_int32(env, static_cast<int32_t>(E_SERVICE_ERROR), &exception_service_error);
166 napi_create_int32(env, static_cast<int32_t>(E_OTHER), &exception_other);
167
168 napi_create_int32(env, static_cast<int32_t>(NETWORK_MOBILE), &network_mobile);
169 napi_create_int32(env, static_cast<int32_t>(NETWORK_WIFI), &network_wifi);
170
171 napi_create_int32(env, static_cast<int32_t>(ERROR_CANNOT_RESUME), &err_cannot_resume);
172 napi_create_int32(env, static_cast<int32_t>(ERROR_DEVICE_NOT_FOUND), &err_dev_not_found);
173 napi_create_int32(env, static_cast<int32_t>(ERROR_FILE_ALREADY_EXISTS), &err_file_exist);
174 napi_create_int32(env, static_cast<int32_t>(ERROR_FILE_ERROR), &err_file_error);
175 napi_create_int32(env, static_cast<int32_t>(ERROR_HTTP_DATA_ERROR), &err_http_data);
176 napi_create_int32(env, static_cast<int32_t>(ERROR_INSUFFICIENT_SPACE), &err_no_space);
177 napi_create_int32(env, static_cast<int32_t>(ERROR_TOO_MANY_REDIRECTS), &err_many_redirect);
178 napi_create_int32(env, static_cast<int32_t>(ERROR_UNHANDLED_HTTP_CODE), &err_http_code);
179 napi_create_int32(env, static_cast<int32_t>(ERROR_UNKNOWN), &err_unknown);
180 napi_create_int32(env, static_cast<int32_t>(ERROR_OFFLINE), &err_offline);
181 napi_create_int32(env, static_cast<int32_t>(ERROR_UNSUPPORTED_NETWORK_TYPE), &err_unsupported_network_type);
182
183 /* Create paused reason Const */
184 napi_create_int32(env, static_cast<int32_t>(PAUSED_QUEUED_FOR_WIFI), &paused_queue_wifi);
185 napi_create_int32(env, static_cast<int32_t>(PAUSED_WAITING_FOR_NETWORK), &paused_for_network);
186 napi_create_int32(env, static_cast<int32_t>(PAUSED_WAITING_TO_RETRY), &paused_to_retry);
187 napi_create_int32(env, static_cast<int32_t>(PAUSED_BY_USER), &paused_by_user);
188 napi_create_int32(env, static_cast<int32_t>(PAUSED_UNKNOWN), &paused_unknown);
189
190 /* Create session status Const */
191 napi_create_int32(env, static_cast<int32_t>(SESSION_SUCCESS), &session_success);
192 napi_create_int32(env, static_cast<int32_t>(SESSION_RUNNING), &session_running);
193 napi_create_int32(env, static_cast<int32_t>(SESSION_PENDING), &session_pending);
194 napi_create_int32(env, static_cast<int32_t>(SESSION_PAUSED), &session_paused);
195 napi_create_int32(env, static_cast<int32_t>(SESSION_FAILED), &session_failed);
196 napi_value agent = nullptr;
197 napi_create_object(env, &agent);
198 InitAgent(env, agent);
199
200 napi_property_descriptor desc[] = {
201 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_PERMISSION", exception_permission),
202 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_PARAMCHECK", exception_parameter_check),
203 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_UNSUPPORTED", exception_unsupported),
204 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_FILEIO", exception_file_IO),
205 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_FILEPATH", exception_file_path),
206 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_SERVICE", exception_service_error),
207 DECLARE_NAPI_STATIC_PROPERTY("EXCEPTION_OTHERS", exception_other),
208 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_MOBILE", network_mobile),
209 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_WIFI", network_wifi),
210 DECLARE_NAPI_STATIC_PROPERTY("ERROR_CANNOT_RESUME", err_cannot_resume),
211 DECLARE_NAPI_STATIC_PROPERTY("ERROR_DEVICE_NOT_FOUND", err_dev_not_found),
212 DECLARE_NAPI_STATIC_PROPERTY("ERROR_FILE_ALREADY_EXISTS", err_file_exist),
213 DECLARE_NAPI_STATIC_PROPERTY("ERROR_FILE_ERROR", err_file_error),
214 DECLARE_NAPI_STATIC_PROPERTY("ERROR_HTTP_DATA_ERROR", err_http_data),
215 DECLARE_NAPI_STATIC_PROPERTY("ERROR_INSUFFICIENT_SPACE", err_no_space),
216 DECLARE_NAPI_STATIC_PROPERTY("ERROR_TOO_MANY_REDIRECTS", err_many_redirect),
217 DECLARE_NAPI_STATIC_PROPERTY("ERROR_UNHANDLED_HTTP_CODE", err_http_code),
218 DECLARE_NAPI_STATIC_PROPERTY("ERROR_UNKNOWN", err_unknown),
219 DECLARE_NAPI_STATIC_PROPERTY("ERROR_OFFLINE", err_offline),
220 DECLARE_NAPI_STATIC_PROPERTY("ERROR_UNSUPPORTED_NETWORK_TYPE", err_unsupported_network_type),
221 DECLARE_NAPI_STATIC_PROPERTY("PAUSED_QUEUED_FOR_WIFI", paused_queue_wifi),
222 DECLARE_NAPI_STATIC_PROPERTY("PAUSED_WAITING_FOR_NETWORK", paused_for_network),
223 DECLARE_NAPI_STATIC_PROPERTY("PAUSED_WAITING_TO_RETRY", paused_to_retry),
224 DECLARE_NAPI_STATIC_PROPERTY("PAUSED_BY_USER", paused_by_user),
225 DECLARE_NAPI_STATIC_PROPERTY("PAUSED_UNKNOWN", paused_unknown),
226 DECLARE_NAPI_STATIC_PROPERTY("SESSION_SUCCESSFUL", session_success),
227 DECLARE_NAPI_STATIC_PROPERTY("SESSION_RUNNING", session_running),
228 DECLARE_NAPI_STATIC_PROPERTY("SESSION_PENDING", session_pending),
229 DECLARE_NAPI_STATIC_PROPERTY("SESSION_PAUSED", session_paused),
230 DECLARE_NAPI_STATIC_PROPERTY("SESSION_FAILED", session_failed),
231 DECLARE_NAPI_PROPERTY("agent", agent),
232 DECLARE_NAPI_METHOD("download", JsTask::JsDownload),
233 DECLARE_NAPI_METHOD("upload", JsTask::JsUpload),
234 DECLARE_NAPI_METHOD("downloadFile", JsTask::JsRequestFile),
235 DECLARE_NAPI_METHOD("uploadFile", JsTask::JsRequestFile),
236 DECLARE_NAPI_METHOD("onDownloadComplete", Legacy::RequestManager::OnDownloadComplete),
237 };
238
239 napi_status status = napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
240 REQUEST_HILOGD("init request %{public}d", status);
241 return exports;
242 }
243
RegisterModule()244 static __attribute__((constructor)) void RegisterModule()
245 {
246 static napi_module module = { .nm_version = 1,
247 .nm_flags = 0,
248 .nm_filename = nullptr,
249 .nm_register_func = Init,
250 .nm_modname = "request",
251 .nm_priv = ((void *)0),
252 .reserved = { 0 } };
253 napi_module_register(&module);
254 REQUEST_HILOGD("module register request");
255 }
256