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 "upload_task_napiV5.h"
17 #include <uv.h>
18 #include "ability.h"
19 #include "js_util.h"
20 #include "napi_base_context.h"
21 #include "uv_queue.h"
22 #include "upload_task_napi.h"
23
24 namespace OHOS::Request::Upload {
25 constexpr int FIRST_ARGV = 0;
26 constexpr int PARAM_COUNT_ZERO = 0;
27 constexpr int PARAM_COUNT_ONE = 1;
28 constexpr int PARAM_COUNT_TWO = 2;
~UploadTaskNapiV5()29 UploadTaskNapiV5::~UploadTaskNapiV5()
30 {
31 if (env_ == nullptr) {
32 return;
33 }
34
35 RecycleRef *callbackData = new (std::nothrow)
36 RecycleRef{ .env = env_, .successRef = success_, .failRef = fail_, .completeRef = complete_ };
37 if (callbackData == nullptr) {
38 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "Failed to create callbackData");
39 return;
40 }
41 uv_after_work_cb afterCallback = [](uv_work_t *work, int status) {
42 RecycleRef *callbackDataPtr = reinterpret_cast<RecycleRef *>(work->data);
43 if (callbackDataPtr != nullptr) {
44 napi_delete_reference(callbackDataPtr->env, callbackDataPtr->successRef);
45 napi_delete_reference(callbackDataPtr->env, callbackDataPtr->failRef);
46 napi_delete_reference(callbackDataPtr->env, callbackDataPtr->completeRef);
47 delete callbackDataPtr;
48 delete work;
49 }
50 };
51 UvQueue::Call(env_, reinterpret_cast<void *>(callbackData), afterCallback);
52 }
53
ParseCallback(napi_env env,napi_callback_info info)54 bool UploadTaskNapiV5::ParseCallback(napi_env env, napi_callback_info info)
55 {
56 napi_value self = nullptr;
57 size_t argc = JSUtil::MAX_ARGC;
58 napi_value argv[JSUtil::MAX_ARGC] = { nullptr };
59 NAPI_CALL_BASE(env, napi_get_cb_info(env, info, &argc, argv, &self, nullptr), false);
60 if ((JSUtil::ParseFunction(env, argv[FIRST_ARGV], "success", success_)) ||
61 (JSUtil::ParseFunction(env, argv[FIRST_ARGV], "fail", fail_)) ||
62 (JSUtil::ParseFunction(env, argv[FIRST_ARGV], "complete", complete_))) {
63 UPLOAD_HILOGD(UPLOAD_MODULE_JS_NAPI, "Parse CallbackFunction Success. UploadTask API Version is 5");
64 return true;
65 }
66 return false;
67 }
68
AddCallbackToConfig(napi_env env,std::shared_ptr<UploadConfig> & config)69 void UploadTaskNapiV5::AddCallbackToConfig(napi_env env, std::shared_ptr<UploadConfig> &config)
70 {
71 config->fsuccess = std::bind(&UploadTaskNapiV5::OnSystemSuccess, env_, success_, std::placeholders::_1);
72 config->ffail =
73 std::bind(&UploadTaskNapiV5::OnSystemFail, env_, fail_, std::placeholders::_1, std::placeholders::_2);
74 config->fcomplete = std::bind(&UploadTaskNapiV5::OnSystemComplete, env_, complete_);
75 }
76
JsUpload(napi_env env,napi_callback_info info)77 napi_value UploadTaskNapiV5::JsUpload(napi_env env, napi_callback_info info)
78 {
79 UPLOAD_HILOGI(UPLOAD_MODULE_JS_NAPI, "Enter JsUploadV5.");
80 napi_value self = nullptr;
81 size_t argc = JSUtil::MAX_ARGC;
82 napi_value argv[JSUtil::MAX_ARGC] = { nullptr };
83 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &self, nullptr));
84
85 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
86 int paramPosition = 0;
87 napi_status getStatus = UploadTaskNapi::GetContext(env, &argv[FIRST_ARGV], paramPosition, context);
88 if (getStatus != napi_ok) {
89 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "GetContext fail.");
90 NAPI_ASSERT(env, false, "GetContext fail");
91 }
92
93 std::shared_ptr<UploadConfig> UploadConfig = JSUtil::ParseUploadConfig(env, argv[paramPosition], API5);
94 if (UploadConfig == nullptr) {
95 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "ParseUploadConfig fail.");
96 NAPI_ASSERT(env, false, "ParseUploadConfig fail");
97 }
98
99 AddCallbackToConfig(env, UploadConfig);
100 uploadTask_ = std::make_shared<Upload::UploadTask>(UploadConfig);
101 uploadTask_->SetContext(context);
102 uploadTask_->SetUploadProxy(shared_from_this());
103 uploadTask_->ExecuteTask();
104 return nullptr;
105 }
106
OnSystemSuccess(napi_env env,napi_ref ref,Upload::UploadResponse & response)107 void UploadTaskNapiV5::OnSystemSuccess(napi_env env, napi_ref ref, Upload::UploadResponse &response)
108 {
109 UPLOAD_HILOGI(UPLOAD_MODULE_JS_NAPI, "OnSystemSuccess enter");
110
111 SystemSuccessCallback *successCallback = new (std::nothrow)
112 SystemSuccessCallback{ .env = env, .ref = ref, .response = response };
113 if (successCallback == nullptr) {
114 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "Failed to create successCallback");
115 return;
116 }
117 uv_after_work_cb afterCallback = [](uv_work_t *work, int status) {
118 SystemSuccessCallback *successCallback = reinterpret_cast<SystemSuccessCallback *>(work->data);
119 napi_handle_scope scope = nullptr;
120 napi_open_handle_scope(successCallback->env, &scope);
121 napi_value callback = nullptr;
122 napi_value global = nullptr;
123 napi_value result = nullptr;
124 napi_value jsResponse = JSUtil::Convert2JSUploadResponse(successCallback->env, successCallback->response);
125 napi_value args[PARAM_COUNT_ONE] = { jsResponse };
126 napi_get_reference_value(successCallback->env, successCallback->ref, &callback);
127 napi_get_global(successCallback->env, &global);
128 napi_call_function(successCallback->env, global, callback, PARAM_COUNT_ONE, args, &result);
129 napi_close_handle_scope(successCallback->env, scope);
130 delete successCallback;
131 delete work;
132 };
133 UvQueue::Call(env, reinterpret_cast<void *>(successCallback), afterCallback);
134 }
135
OnSystemFail(napi_env env,napi_ref ref,std::string & data,int32_t & code)136 void UploadTaskNapiV5::OnSystemFail(napi_env env, napi_ref ref, std::string &data, int32_t &code)
137 {
138 UPLOAD_HILOGI(UPLOAD_MODULE_JS_NAPI, "OnSystemFail enter");
139 SystemFailCallback *failCallback = new (std::nothrow)
140 SystemFailCallback{ .data = data, .code = code, .env = env, .ref = ref };
141 if (failCallback == nullptr) {
142 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "Failed to create failCallback");
143 return;
144 }
145 uv_after_work_cb afterCallback = [](uv_work_t *work, int status) {
146 SystemFailCallback *failCallback = reinterpret_cast<SystemFailCallback *>(work->data);
147 napi_handle_scope scope = nullptr;
148 napi_open_handle_scope(failCallback->env, &scope);
149 napi_value callback = nullptr;
150 napi_value global = nullptr;
151 napi_value result = nullptr;
152 napi_value jsData = nullptr;
153 napi_create_string_utf8(failCallback->env, failCallback->data.c_str(), failCallback->data.size(), &jsData);
154 napi_value jsCode = nullptr;
155 napi_create_int32(failCallback->env, failCallback->code, &jsCode);
156 napi_value args[PARAM_COUNT_TWO] = { jsData, jsCode };
157 napi_get_reference_value(failCallback->env, failCallback->ref, &callback);
158 napi_get_global(failCallback->env, &global);
159 napi_call_function(failCallback->env, global, callback, PARAM_COUNT_TWO, args, &result);
160 napi_close_handle_scope(failCallback->env, scope);
161 delete failCallback;
162 delete work;
163 };
164 UvQueue::Call(env, reinterpret_cast<void *>(failCallback), afterCallback);
165 }
166
OnSystemComplete(napi_env env,napi_ref ref)167 void UploadTaskNapiV5::OnSystemComplete(napi_env env, napi_ref ref)
168 {
169 UPLOAD_HILOGI(UPLOAD_MODULE_JS_NAPI, "OnSystemComplete enter");
170 SystemCompleteCallback *completeCallback = new (std::nothrow) SystemCompleteCallback{ .env = env, .ref = ref };
171 if (completeCallback == nullptr) {
172 UPLOAD_HILOGE(UPLOAD_MODULE_JS_NAPI, "Failed to create completeCallback");
173 return;
174 }
175 uv_after_work_cb afterCallback = [](uv_work_t *work, int status) {
176 SystemCompleteCallback *completeCallback = reinterpret_cast<SystemCompleteCallback *>(work->data);
177 napi_handle_scope scope = nullptr;
178 napi_open_handle_scope(completeCallback->env, &scope);
179 napi_value callback = nullptr;
180 napi_value global = nullptr;
181 napi_value result = nullptr;
182
183 napi_get_reference_value(completeCallback->env, completeCallback->ref, &callback);
184 napi_get_global(completeCallback->env, &global);
185 napi_call_function(completeCallback->env, global, callback, PARAM_COUNT_ZERO, nullptr, &result);
186 napi_close_handle_scope(completeCallback->env, scope);
187 delete completeCallback;
188 delete work;
189 };
190 UvQueue::Call(env, reinterpret_cast<void *>(completeCallback), afterCallback);
191 }
192 } // namespace OHOS::Request::Upload