1 /*
2 * Copyright (c) 2022 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 "zlib_callback_info.h"
17
18 #include "app_log_wrapper.h"
19 #include "common_func.h"
20 #include "business_error.h"
21
22 namespace OHOS {
23 namespace AppExecFwk {
24 namespace LIBZIP {
25 namespace {
26 constexpr size_t ARGS_ONE = 1;
27 }
28
ZlibCallbackInfo(napi_env env,napi_ref callback,napi_deferred deferred,bool isCallback)29 ZlibCallbackInfo::ZlibCallbackInfo(napi_env env, napi_ref callback, napi_deferred deferred, bool isCallback)
30 : env_(env), callback_(callback), deferred_(deferred), isCallBack_(isCallback) {}
31
~ZlibCallbackInfo()32 ZlibCallbackInfo::~ZlibCallbackInfo() {}
33
ExcuteWork(uv_loop_s * loop,uv_work_t * work)34 int32_t ZlibCallbackInfo::ExcuteWork(uv_loop_s* loop, uv_work_t* work)
35 {
36 int32_t ret = uv_queue_work(
37 loop, work, [](uv_work_t* work) {},
38 [](uv_work_t* work, int status) {
39 if (work == nullptr) {
40 return;
41 }
42 AsyncCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncCallbackInfo*>(work->data);
43 if (asyncCallbackInfo == nullptr) {
44 return;
45 }
46 napi_handle_scope scope = nullptr;
47 napi_open_handle_scope(asyncCallbackInfo->env, &scope);
48 if (scope == nullptr) {
49 return;
50 }
51 std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
52 napi_value result[ARGS_ONE] = {0};
53 if (asyncCallbackInfo->deliverErrcode) {
54 if (asyncCallbackInfo->callbackResult == ERR_OK) {
55 CHKRV_SCOPE(asyncCallbackInfo->env, napi_get_null(asyncCallbackInfo->env, &result[0]), scope);
56 } else {
57 result[0] = BusinessError::CreateCommonError(asyncCallbackInfo->env,
58 asyncCallbackInfo->callbackResult, "");
59 }
60 } else {
61 CHKRV_SCOPE(asyncCallbackInfo->env, napi_create_int32(asyncCallbackInfo->env,
62 asyncCallbackInfo->callbackResult, &result[0]), scope);
63 }
64 if (asyncCallbackInfo->isCallBack) {
65 napi_value callback = 0;
66 napi_value placeHolder = nullptr;
67 CHKRV_SCOPE(asyncCallbackInfo->env, napi_get_reference_value(asyncCallbackInfo->env,
68 asyncCallbackInfo->callback, &callback), scope);
69 CHKRV_SCOPE(asyncCallbackInfo->env, napi_call_function(asyncCallbackInfo->env, nullptr,
70 callback, sizeof(result) / sizeof(result[0]), result, &placeHolder), scope);
71 if (asyncCallbackInfo->callback != nullptr) {
72 CHKRV_SCOPE(asyncCallbackInfo->env, napi_delete_reference(asyncCallbackInfo->env,
73 asyncCallbackInfo->callback), scope);
74 }
75 } else {
76 if (asyncCallbackInfo->callbackResult == ERR_OK) {
77 CHKRV_SCOPE(asyncCallbackInfo->env, napi_resolve_deferred(asyncCallbackInfo->env,
78 asyncCallbackInfo->deferred, result[0]), scope);
79 } else {
80 CHKRV_SCOPE(asyncCallbackInfo->env, napi_reject_deferred(asyncCallbackInfo->env,
81 asyncCallbackInfo->deferred, result[0]), scope);
82 }
83 }
84 if (work != nullptr) {
85 delete work;
86 work = nullptr;
87 }
88 napi_close_handle_scope(asyncCallbackInfo->env, scope);
89 });
90 return ret;
91 }
92
OnZipUnZipFinish(ErrCode result)93 void ZlibCallbackInfo::OnZipUnZipFinish(ErrCode result)
94 {
95 std::lock_guard<std::mutex> lock(validMutex_);
96 if (!valid_) {
97 APP_LOGE("%{public}s, module exported object is invalid.", __func__);
98 return;
99 }
100
101 // do callback or promise
102 uv_loop_s* loop = nullptr;
103 napi_get_uv_event_loop(env_, &loop);
104 if (loop == nullptr) {
105 APP_LOGE("%{public}s, loop is nullptr.", __func__);
106 return;
107 }
108 uv_work_t* work = new (std::nothrow) uv_work_t;
109 if (work == nullptr) {
110 APP_LOGE("create work failed!");
111 return;
112 }
113 ErrCode err = ERR_OK;
114 if (!deliverErrcode_) {
115 err = result == ERR_OK ? ERR_OK : ERROR_CODE_ERRNO;
116 } else {
117 err = CommonFunc::ConvertErrCode(result);
118 }
119
120 AsyncCallbackInfo* asyncCallbackInfo = new (std::nothrow)AsyncCallbackInfo {
121 .env = env_,
122 .callback = callback_,
123 .deferred = deferred_,
124 .isCallBack = isCallBack_,
125 .callbackResult = err,
126 .deliverErrcode = deliverErrcode_,
127 };
128 std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
129 if (asyncCallbackInfo == nullptr) {
130 delete work;
131 return;
132 }
133 work->data = reinterpret_cast<void*>(asyncCallbackInfo);
134 int32_t ret = ExcuteWork(loop, work);
135 if (ret != 0) {
136 if (asyncCallbackInfo != nullptr) {
137 delete asyncCallbackInfo;
138 }
139 if (work != nullptr) {
140 delete work;
141 }
142 }
143 callbackPtr.release();
144 }
145
GetIsCallback() const146 bool ZlibCallbackInfo::GetIsCallback() const
147 {
148 return isCallBack_;
149 }
150
SetIsCallback(bool isCallback)151 void ZlibCallbackInfo::SetIsCallback(bool isCallback)
152 {
153 isCallBack_ = isCallback;
154 }
155
SetCallback(napi_ref callback)156 void ZlibCallbackInfo::SetCallback(napi_ref callback)
157 {
158 callback_ = callback;
159 }
160
SetDeferred(napi_deferred deferred)161 void ZlibCallbackInfo::SetDeferred(napi_deferred deferred)
162 {
163 deferred_ = deferred;
164 }
165
SetDeliverErrCode(bool isDeliverErrCode)166 void ZlibCallbackInfo::SetDeliverErrCode(bool isDeliverErrCode)
167 {
168 deliverErrcode_ = isDeliverErrCode;
169 }
170
SetValid(bool valid)171 void ZlibCallbackInfo::SetValid(bool valid)
172 {
173 std::lock_guard<std::mutex> lock(validMutex_);
174 valid_ = valid;
175 }
176 } // namespace LIBZIP
177 } // namespace AppExecFwk
178 } // namespace OHOS
179