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 "advanced_ui_component/navpushpathhelper/include/hsp_silentinstall_napi.h"
17 #include "advanced_ui_component/navpushpathhelper/include/hsp_silentinstall.h"
18 #include "base/log/log.h"
19 
20 using namespace std;
21 
22 namespace OHOS::NavPushPathHelper {
23 
IsHspExist(napi_env env,napi_callback_info info)24 napi_value HspSilentInstallNapi::IsHspExist(napi_env env, napi_callback_info info)
25 {
26     size_t argc = 2;
27     size_t requireArgc = 2;
28     napi_value args[2] = { nullptr };
29     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
30     NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments");
31 
32     // get first parameter：moduleName
33     napi_valuetype moduleNameType;
34     NAPI_CALL(env, napi_typeof(env, args[0], &moduleNameType));
35     NAPI_ASSERT(env, moduleNameType == napi_string, "Wrong argument type. String expected.");
36 
37     size_t maxValueLen = 1024;
38     char moduleNameValue[maxValueLen];
39     size_t moduleNameLength = 0;
40     napi_get_value_string_utf8(env, args[0], moduleNameValue, maxValueLen, &moduleNameLength);
41     std::string moduleName = moduleNameValue;
42 
43     // get second parameter：pathName
44     napi_valuetype pathNameType;
45     NAPI_CALL(env, napi_typeof(env, args[1], &pathNameType));
46     NAPI_ASSERT(env, pathNameType == napi_string, "Wrong argument type. String expected.");
47 
48     char pathNameValue[maxValueLen];
49     size_t pathNameLength = 0;
50     napi_get_value_string_utf8(env, args[1], pathNameValue, maxValueLen, &pathNameLength);
51     std::string pathName = pathNameValue;
52 
53     bool isHspExits = HspSilentInstall::IsHspExist(moduleName, pathName);
54     napi_value jsResult;
55     NAPI_CALL(env, napi_get_boolean(env, isHspExits, &jsResult));
56     return jsResult;
57 }
58 
InitRouteMap(napi_env env,napi_callback_info info)59 napi_value HspSilentInstallNapi::InitRouteMap(napi_env env, napi_callback_info info)
60 {
61     HspSilentInstall::InitRouteMap();
62     return nullptr;
63 }
64 
SilentInstall(napi_env env,napi_callback_info info)65 napi_value HspSilentInstallNapi::SilentInstall(napi_env env, napi_callback_info info)
66 {
67     napi_value result = nullptr;
68     size_t argc = 3;
69     size_t requireArgc = 3;
70     napi_value args[3] = { nullptr };
71     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
72     NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments");
73 
74     // get first parameter：moduleName
75     std::string moduleName;
76     getModuleName(env, args[0], moduleName);
77 
78     auto callbackData = new CallbackData();
79     int parameterNum = 1;
80     const int indexTwo = 2;
81     napi_create_reference(env, args[1], parameterNum, &(callbackData->successCallback));
82     napi_create_reference(env, args[indexTwo], parameterNum, &(callbackData->failCallback));
83     callbackData->env = env;
84 
85     auto successCallback = [callbackData]() {
86         uv_loop_s *loop = nullptr;
87         napi_get_uv_event_loop(callbackData->env, &loop);
88         uv_work_t *work = new (std::nothrow) uv_work_t;
89         work->data = reinterpret_cast<void *>(callbackData);
90         uv_queue_work(loop, work, [](uv_work_t *work) { (void)work; }, SendSuccessBackWork);
91     };
92 
93     auto failCallback = [callbackData](int32_t errorCode, const std::string& errorMessage) {
94         callbackData->errCode = errorCode;
95         callbackData->errorMessage = errorMessage;
96 
97         uv_loop_s *loop = nullptr;
98         napi_get_uv_event_loop(callbackData->env, &loop);
99         uv_work_t *work = new (std::nothrow) uv_work_t;
100         work->data = reinterpret_cast<void *>(callbackData);
101         uv_queue_work(loop, work, [](uv_work_t *work) { (void)work; }, SendFailBackWork);
102     };
103 
104     HspSilentInstall::SilentInstall(moduleName, successCallback, failCallback);
105     return result;
106 }
107 
getModuleName(napi_env env,napi_value args,std::string & moduleName)108 napi_value HspSilentInstallNapi::getModuleName(napi_env env, napi_value args, std::string& moduleName)
109 {
110     napi_valuetype moduleNameType;
111     NAPI_CALL(env, napi_typeof(env, args, &moduleNameType));
112     NAPI_ASSERT(env, moduleNameType == napi_string, "Wrong argument type. String expected.");
113 
114     napi_status status;
115     size_t maxValueLen = 1024;
116     char moduleNameValue[maxValueLen];
117     size_t moduleNameLength = 0;
118     status = napi_get_value_string_utf8(env, args, moduleNameValue, maxValueLen, &moduleNameLength);
119     NAPI_ASSERT(env, status == napi_ok, "Failed to napi_get_value_string_utf8");
120     moduleName = moduleNameValue;
121     return nullptr;
122 }
123 
SendSuccessBackWork(uv_work_t * work,int statusIn)124 void HspSilentInstallNapi::SendSuccessBackWork(uv_work_t *work, int statusIn)
125 {
126     (void)statusIn;
127     napi_status status;
128     napi_handle_scope scope = nullptr;
129     CallbackData *callbackData = reinterpret_cast<CallbackData *>(work->data);
130     if (callbackData == nullptr) {
131         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendSuccessBackWork -> callbackData is null");
132         return;
133     }
134 
135     napi_open_handle_scope(callbackData->env, &scope);
136     if (scope == nullptr) {
137         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendSuccessBackWork -> scope is null");
138         return;
139     }
140 
141     napi_value callback = nullptr;
142     status = napi_get_reference_value(callbackData->env, callbackData->successCallback, &callback);
143     if (status != napi_ok) {
144         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendSuccessBackWork -> napi_get_reference_value error");
145         napi_close_handle_scope(callbackData->env, scope);
146         return;
147     }
148 
149     napi_value result;
150     status = napi_call_function(callbackData->env, nullptr, callback, 0, nullptr, &result);
151     if (status != napi_ok) {
152         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendSuccessBackWork -> napi_call_function error");
153         napi_close_handle_scope(callbackData->env, scope);
154         return;
155     }
156 
157     napi_close_handle_scope(callbackData->env, scope);
158 
159     if (callbackData != nullptr) {
160         delete callbackData;
161         callbackData = nullptr;
162     }
163 
164     if (work != nullptr) {
165         delete work;
166         work = nullptr;
167     }
168 }
169 
SendFailBackWork(uv_work_t * work,int statusIn)170 void HspSilentInstallNapi::SendFailBackWork(uv_work_t *work, int statusIn)
171 {
172     (void)statusIn;
173     napi_status status;
174     napi_handle_scope scope = nullptr;
175     CallbackData *callbackData = reinterpret_cast<CallbackData *>(work->data);
176     if (callbackData == nullptr) {
177         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendFailBackWork -> callbackData is null");
178         return;
179     }
180 
181     napi_open_handle_scope(callbackData->env, &scope);
182     if (scope == nullptr) {
183         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendFailBackWork -> scope is null");
184         return;
185     }
186 
187     napi_value callback = nullptr;
188     status = napi_get_reference_value(callbackData->env, callbackData->failCallback, &callback);
189     if (status != napi_ok) {
190         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendFailBackWork -> napi_get_reference_value error");
191         napi_close_handle_scope(callbackData->env, scope);
192         return;
193     }
194 
195     size_t resultLength = 1;
196     napi_value resultMessage = CreateResultMessage(callbackData);
197     napi_value result[] = { resultMessage };
198     status = napi_call_function(callbackData->env, nullptr, callback, resultLength, result, nullptr);
199     if (status != napi_ok) {
200         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "SendFailBackWork -> napi_call_function error");
201         napi_close_handle_scope(callbackData->env, scope);
202         return;
203     }
204 
205     napi_close_handle_scope(callbackData->env, scope);
206 
207     if (callbackData != nullptr) {
208         delete callbackData;
209         callbackData = nullptr;
210     }
211 
212     if (work != nullptr) {
213         delete work;
214         work = nullptr;
215     }
216 }
217 
CreateResultMessage(CallbackData * callbackData)218 napi_value HspSilentInstallNapi::CreateResultMessage(CallbackData *callbackData)
219 {
220     napi_status status;
221     napi_value result = nullptr;
222     napi_value code = nullptr;
223 
224     status = napi_create_int32(callbackData->env, callbackData->errCode, &code);
225     if (status != napi_ok) {
226         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "CreateResultMessage -> napi_create_int32 error");
227         return result;
228     }
229 
230     napi_value message = nullptr;
231     status = napi_create_string_utf8(callbackData->env, callbackData->errorMessage.c_str(),
232         NAPI_AUTO_LENGTH, &message);
233     if (status != napi_ok) {
234         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "CreateResultMessage -> napi_create_string_utf8 error");
235         return result;
236     }
237 
238     napi_value businessError = nullptr;
239     status = napi_create_object(callbackData->env, &businessError);
240     if (status != napi_ok) {
241         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "CreateResultMessage -> napi_create_object error");
242         return result;
243     }
244 
245     status = napi_set_named_property(callbackData->env, businessError, "code", code);
246     if (status != napi_ok) {
247         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "CreateResultMessage -> napi_set_named_property error");
248         return result;
249     }
250 
251     status = napi_set_named_property(callbackData->env, businessError, "message", message);
252     if (status != napi_ok) {
253         TAG_LOGE(OHOS::Ace::AceLogTag::ACE_DEFAULT_DOMAIN, "CreateResultMessage -> napi_set_named_property error");
254         return result;
255     }
256     return businessError;
257 }
258 }