• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-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 <unordered_map>
17 
18 #include "installer.h"
19 
20 #include "appexecfwk_errors.h"
21 #include "app_log_wrapper.h"
22 #include "bundle_errors.h"
23 #include "bundle_death_recipient.h"
24 #include "bundle_mgr_interface.h"
25 #include "bundle_mgr_proxy.h"
26 #include "business_error.h"
27 #include "common_func.h"
28 #include "if_system_ability_manager.h"
29 #include "installer_callback.h"
30 #include "napi_arg.h"
31 #include "napi_constants.h"
32 #include "system_ability_definition.h"
33 
34 namespace OHOS {
35 namespace AppExecFwk {
36 namespace {
37 // resource name
38 const std::string RESOURCE_NAME_OF_GET_BUNDLE_INSTALLER = "GetBundleInstaller";
39 const std::string RESOURCE_NAME_OF_GET_BUNDLE_INSTALLER_SYNC = "GetBundleInstallerSync";
40 const std::string RESOURCE_NAME_OF_INSTALL = "Install";
41 const std::string RESOURCE_NAME_OF_UNINSTALL = "Uninstall";
42 const std::string RESOURCE_NAME_OF_RECOVER = "Recover";
43 const std::string RESOURCE_NAME_OF_UPDATE_BUNDLE_FOR_SELF = "UpdateBundleForSelf";
44 const std::string EMPTY_STRING = "";
45 // install message
46 constexpr const char* INSTALL_PERMISSION =
47     "ohos.permission.INSTALL_BUNDLE or "
48     "ohos.permission.INSTALL_ENTERPRISE_BUNDLE or "
49     "ohos.permission.INSTALL_ENTERPRISE_MDM_BUNDLE or "
50     "ohos.permission.INSTALL_ENTERPRISE_NORMAL_BUNDLE";
51 constexpr const char* UNINSTALL_PERMISSION = "ohos.permission.INSTALL_BUNDLE or ohos.permission.UNINSTALL_BUNDLE";
52 constexpr const char* RECOVER_PERMISSION = "ohos.permission.INSTALL_BUNDLE or ohos.permission.RECOVER_BUNDLE";
53 constexpr const char* INSTALL_SELF_PERMISSION = "ohos.permission.INSTALL_SELF_BUNDLE";
54 constexpr const char* PARAMETERS = "parameters";
55 constexpr const char* CORRESPONDING_TYPE = "corresponding type";
56 constexpr const char* FUNCTION_TYPE = "napi_function";
57 constexpr const char* CALLBACK = "callback";
58 // property name
59 const std::string USER_ID = "userId";
60 const std::string INSTALL_FLAG = "installFlag";
61 const std::string IS_KEEP_DATA = "isKeepData";
62 const std::string CROWD_TEST_DEADLINE = "crowdtestDeadline";
63 const std::string MODULE_NAME = "moduleName";
64 const std::string HASH_VALUE = "hashValue";
65 const std::string HASH_PARAMS = "hashParams";
66 const std::string BUNDLE_NAME = "bundleName";
67 const std::string VERSION_CODE = "versionCode";
68 const std::string SHARED_BUNDLE_DIR_PATHS = "sharedBundleDirPaths";
69 const std::string SPECIFIED_DISTRIBUTION_TYPE = "specifiedDistributionType";
70 const std::string ADDITIONAL_INFO = "additionalInfo";
71 const std::string VERIFY_CODE_PARAM = "verifyCodeParams";
72 const std::string SIGNATURE_FILE_PATH = "signatureFilePath";
73 const std::string HAPS_FILE_NEEDED =
74     "BusinessError 401: Parameter error. parameter hapFiles is needed for code signature";
75 constexpr int32_t FIRST_PARAM = 0;
76 constexpr int32_t SECOND_PARAM = 1;
77 
78 constexpr int32_t SPECIFIED_DISTRIBUTION_TYPE_MAX_SIZE = 128;
79 constexpr int32_t ADDITIONAL_INFO_MAX_SIZE = 3000;
80 } // namespace
81 napi_ref thread_local g_classBundleInstaller;
82 bool g_isSystemApp = false;
83 
~AsyncInstallCallbackInfo()84 AsyncInstallCallbackInfo::~AsyncInstallCallbackInfo()
85 {
86     if (callback) {
87         napi_delete_reference(env, callback);
88         callback = nullptr;
89     }
90     if (asyncWork) {
91         napi_delete_async_work(env, asyncWork);
92         asyncWork = nullptr;
93     }
94 }
95 
~AsyncGetBundleInstallerCallbackInfo()96 AsyncGetBundleInstallerCallbackInfo::~AsyncGetBundleInstallerCallbackInfo()
97 {
98     if (callback) {
99         napi_delete_reference(env, callback);
100         callback = nullptr;
101     }
102     if (asyncWork) {
103         napi_delete_async_work(env, asyncWork);
104         asyncWork = nullptr;
105     }
106 }
107 
GetBundleInstallerCompleted(napi_env env,napi_status status,void * data)108 void GetBundleInstallerCompleted(napi_env env, napi_status status, void *data)
109 {
110     AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
111         reinterpret_cast<AsyncGetBundleInstallerCallbackInfo *>(data);
112     std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
113 
114     napi_value m_classBundleInstaller = nullptr;
115     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, g_classBundleInstaller,
116         &m_classBundleInstaller));
117     napi_value result[CALLBACK_PARAM_SIZE] = {0};
118     auto iBundleMgr = CommonFunc::GetBundleMgr();
119     if (iBundleMgr == nullptr) {
120         APP_LOGE("can not get iBundleMgr");
121         return;
122     }
123     if (!g_isSystemApp && !iBundleMgr->VerifySystemApi(Constants::INVALID_API_VERSION)) {
124         APP_LOGE("non-system app calling system api");
125         result[0] = BusinessError::CreateCommonError(
126             env, ERROR_NOT_SYSTEM_APP, RESOURCE_NAME_OF_GET_BUNDLE_INSTALLER, INSTALL_PERMISSION);
127         if (callbackPtr->deferred) {
128             NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
129         } else {
130             napi_value callback = nullptr;
131             napi_value placeHolder = nullptr;
132             NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
133             NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
134                 sizeof(result) / sizeof(result[0]), result, &placeHolder));
135         }
136         return;
137     }
138     g_isSystemApp = true;
139     NAPI_CALL_RETURN_VOID(env, napi_new_instance(env, m_classBundleInstaller, 0, nullptr, &result[SECOND_PARAM]));
140 
141     if (callbackPtr->deferred) {
142         NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, callbackPtr->deferred, result[SECOND_PARAM]));
143     } else {
144         napi_value callback = CommonFunc::WrapVoidToJS(env);
145         NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callbackPtr->callback, &callback));
146         napi_value undefined = CommonFunc::WrapVoidToJS(env);
147         NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
148         napi_value callResult = CommonFunc::WrapVoidToJS(env);
149         NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, CALLBACK_PARAM_SIZE,
150             &result[FIRST_PARAM], &callResult));
151     }
152 }
153 
154 /**
155  * Promise and async callback
156  */
GetBundleInstaller(napi_env env,napi_callback_info info)157 napi_value GetBundleInstaller(napi_env env, napi_callback_info info)
158 {
159     APP_LOGD("GetBundleInstaller called");
160     NapiArg args(env, info);
161     if (!args.Init(FIRST_PARAM, SECOND_PARAM)) {
162         APP_LOGE("GetBundleInstaller args init failed");
163         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
164         return nullptr;
165     }
166     std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr =
167         std::make_unique<AsyncGetBundleInstallerCallbackInfo>(env);
168 
169     auto argc = args.GetMaxArgc();
170     APP_LOGD("GetBundleInstaller argc = [%{public}zu]", argc);
171     // check param
172     if (argc == SECOND_PARAM) {
173         napi_value arg = args.GetArgv(argc - SECOND_PARAM);
174         if (arg == nullptr) {
175             APP_LOGE("the param is nullptr");
176             BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
177             return nullptr;
178         }
179         napi_valuetype valuetype = napi_undefined;
180         NAPI_CALL(env, napi_typeof(env, arg, &valuetype));
181         if (valuetype != napi_function) {
182             APP_LOGE("the param type is invalid");
183             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, CALLBACK, FUNCTION_TYPE);
184             return nullptr;
185         }
186         NAPI_CALL(env, napi_create_reference(env, arg, NAPI_RETURN_ONE, &callbackPtr->callback));
187     }
188 
189     auto executeFunc = [](napi_env env, void *data) {};
190     napi_value promise = CommonFunc::AsyncCallNativeMethod(
191         env,
192         callbackPtr.get(),
193         RESOURCE_NAME_OF_GET_BUNDLE_INSTALLER,
194         executeFunc,
195         GetBundleInstallerCompleted);
196     callbackPtr.release();
197     return promise;
198 }
199 
GetBundleInstallerSync(napi_env env,napi_callback_info info)200 napi_value GetBundleInstallerSync(napi_env env, napi_callback_info info)
201 {
202     APP_LOGD("NAPI GetBundleInstallerSync called.");
203     napi_value m_classBundleInstaller = nullptr;
204     NAPI_CALL(env, napi_get_reference_value(env, g_classBundleInstaller,
205         &m_classBundleInstaller));
206     auto iBundleMgr = CommonFunc::GetBundleMgr();
207     if (iBundleMgr == nullptr) {
208         APP_LOGE("can not get iBundleMgr");
209         return nullptr;
210     }
211     if (!g_isSystemApp && !iBundleMgr->VerifySystemApi(Constants::INVALID_API_VERSION)) {
212         APP_LOGE("non-system app calling system api");
213         napi_value businessError = BusinessError::CreateCommonError(
214             env, ERROR_NOT_SYSTEM_APP, RESOURCE_NAME_OF_GET_BUNDLE_INSTALLER_SYNC, INSTALL_PERMISSION);
215         napi_throw(env, businessError);
216         return nullptr;
217     }
218     g_isSystemApp = true;
219     napi_value nBundleInstaller = nullptr;
220     NAPI_CALL(env, napi_new_instance(env, m_classBundleInstaller, 0, nullptr, &nBundleInstaller));
221     APP_LOGD("call GetBundleInstallerSync done.");
222     return nBundleInstaller;
223 }
224 
CreateErrCodeMap(std::unordered_map<int32_t,int32_t> & errCodeMap)225 static void CreateErrCodeMap(std::unordered_map<int32_t, int32_t> &errCodeMap)
226 {
227     errCodeMap = {
228         { IStatusReceiver::SUCCESS, SUCCESS},
229         { IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
230         { IStatusReceiver::ERR_INSTALL_HOST_INSTALLER_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
231         { IStatusReceiver::ERR_INSTALLD_PARAM_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
232         { IStatusReceiver::ERR_INSTALLD_GET_PROXY_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
233         { IStatusReceiver::ERR_INSTALL_INSTALLD_SERVICE_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
234         { IStatusReceiver::ERR_UNINSTALL_BUNDLE_MGR_SERVICE_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
235         { IStatusReceiver::ERR_FAILED_SERVICE_DIED, ERROR_BUNDLE_SERVICE_EXCEPTION },
236         { IStatusReceiver::ERR_FAILED_GET_INSTALLER_PROXY, ERROR_BUNDLE_SERVICE_EXCEPTION },
237         { IStatusReceiver::ERR_USER_CREATE_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
238         { IStatusReceiver::ERR_USER_REMOVE_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
239         { IStatusReceiver::ERR_UNINSTALL_KILLING_APP_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
240         { IStatusReceiver::ERR_INSTALL_GENERATE_UID_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
241         { IStatusReceiver::ERR_INSTALL_STATE_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
242         { IStatusReceiver::ERR_RECOVER_NOT_ALLOWED, ERROR_BUNDLE_SERVICE_EXCEPTION },
243         { IStatusReceiver::ERR_RECOVER_GET_BUNDLEPATH_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
244         { IStatusReceiver::ERR_UNINSTALL_SYSTEM_APP_ERROR, ERROR_UNINSTALL_PREINSTALL_APP_FAILED },
245         { IStatusReceiver::ERR_INSTALL_PARSE_FAILED, ERROR_INSTALL_PARSE_FAILED },
246         { IStatusReceiver::ERR_INSTALL_PARSE_UNEXPECTED, ERROR_INSTALL_PARSE_FAILED },
247         { IStatusReceiver::ERR_INSTALL_PARSE_MISSING_BUNDLE, ERROR_INSTALL_PARSE_FAILED },
248         { IStatusReceiver::ERR_INSTALL_PARSE_NO_PROFILE, ERROR_INSTALL_PARSE_FAILED },
249         { IStatusReceiver::ERR_INSTALL_PARSE_BAD_PROFILE, ERROR_INSTALL_PARSE_FAILED },
250         { IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_PROP_TYPE_ERROR, ERROR_INSTALL_PARSE_FAILED },
251         { IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_MISSING_PROP, ERROR_INSTALL_PARSE_FAILED },
252         { IStatusReceiver::ERR_INSTALL_PARSE_PERMISSION_ERROR, ERROR_INSTALL_PARSE_FAILED },
253         { IStatusReceiver::ERR_INSTALL_PARSE_RPCID_FAILED, ERROR_INSTALL_PARSE_FAILED },
254         { IStatusReceiver::ERR_INSTALL_PARSE_NATIVE_SO_FAILED, ERROR_INSTALL_PARSE_FAILED },
255         { IStatusReceiver::ERR_INSTALL_PARSE_AN_FAILED, ERROR_INSTALL_PARSE_FAILED },
256         { IStatusReceiver::ERR_INSTALL_PARSE_MISSING_ABILITY, ERROR_INSTALL_PARSE_FAILED },
257         { IStatusReceiver::ERR_INSTALL_FAILED_PROFILE_PARSE_FAIL, ERROR_INSTALL_PARSE_FAILED },
258         { IStatusReceiver::ERR_INSTALL_VERIFICATION_FAILED, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
259         { IStatusReceiver::ERR_INSTALL_FAILED_INCOMPATIBLE_SIGNATURE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
260         { IStatusReceiver::ERR_INSTALL_FAILED_INVALID_SIGNATURE_FILE_PATH, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
261         { IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE_FILE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
262         { IStatusReceiver::ERR_INSTALL_FAILED_NO_BUNDLE_SIGNATURE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
263         { IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_APP_PKCS7_FAIL, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
264         { IStatusReceiver::ERR_INSTALL_FAILED_APP_SOURCE_NOT_TRUESTED, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
265         { IStatusReceiver::ERR_INSTALL_FAILED_BAD_DIGEST, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
266         { IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_INTEGRITY_VERIFICATION_FAILURE,
267             ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
268         { IStatusReceiver::ERR_INSTALL_FAILED_BAD_PUBLICKEY, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
269         { IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
270         { IStatusReceiver::ERR_INSTALL_FAILED_NO_PROFILE_BLOCK_FAIL, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
271         { IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_SIGNATURE_VERIFICATION_FAILURE,
272             ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
273         { IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_SOURCE_INIT_FAIL, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
274         { IStatusReceiver::ERR_INSTALL_SINGLETON_INCOMPATIBLE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
275         { IStatusReceiver::ERR_INSTALL_FAILED_INCONSISTENT_SIGNATURE, ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
276         { IStatusReceiver::ERR_INSTALL_PARAM_ERROR, ERROR_BUNDLE_NOT_EXIST },
277         { IStatusReceiver::ERR_UNINSTALL_PARAM_ERROR, ERROR_BUNDLE_NOT_EXIST },
278         { IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME, ERROR_BUNDLE_NOT_EXIST },
279         { IStatusReceiver::ERR_UNINSTALL_INVALID_NAME, ERROR_BUNDLE_NOT_EXIST },
280         { IStatusReceiver::ERR_INSTALL_INVALID_BUNDLE_FILE, ERROR_INSTALL_HAP_FILEPATH_INVALID },
281         { IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_EMPTY, ERROR_MODULE_NOT_EXIST },
282         { IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_DUPLICATE, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
283         { IStatusReceiver::ERR_INSTALL_FAILED_CHECK_HAP_HASH_PARAM, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
284         { IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_BUNDLE, ERROR_BUNDLE_NOT_EXIST },
285         { IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_MODULE, ERROR_MODULE_NOT_EXIST },
286         { IStatusReceiver::ERR_USER_NOT_INSTALL_HAP, ERROR_BUNDLE_NOT_EXIST },
287         { IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID, ERROR_INSTALL_HAP_FILEPATH_INVALID },
288         { IStatusReceiver::ERR_INSTALL_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
289         { IStatusReceiver::ERR_UNINSTALL_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
290         { IStatusReceiver::ERR_INSTALL_GRANT_REQUEST_PERMISSIONS_FAILED, ERROR_PERMISSION_DENIED_ERROR },
291         { IStatusReceiver::ERR_INSTALL_UPDATE_HAP_TOKEN_FAILED, ERROR_PERMISSION_DENIED_ERROR },
292         { IStatusReceiver::ERR_INSTALLD_CREATE_DIR_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
293         { IStatusReceiver::ERR_INSTALLD_CHOWN_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
294         { IStatusReceiver::ERR_INSTALLD_CREATE_DIR_EXIST, ERROR_BUNDLE_SERVICE_EXCEPTION },
295         { IStatusReceiver::ERR_INSTALLD_REMOVE_DIR_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
296         { IStatusReceiver::ERR_INSTALLD_EXTRACT_FILES_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
297         { IStatusReceiver::ERR_INSTALLD_RNAME_DIR_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
298         { IStatusReceiver::ERR_INSTALLD_CLEAN_DIR_FAILED, ERROR_BUNDLE_SERVICE_EXCEPTION },
299         { IStatusReceiver::ERR_INSTALL_ENTRY_ALREADY_EXIST, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
300         { IStatusReceiver::ERR_INSTALL_ALREADY_EXIST, ERROR_INSTALL_ALREADY_EXIST },
301         { IStatusReceiver::ERR_INSTALL_BUNDLENAME_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
302         { IStatusReceiver::ERR_INSTALL_VERSIONCODE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
303         { IStatusReceiver::ERR_INSTALL_VERSIONNAME_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
304         { IStatusReceiver::ERR_INSTALL_MINCOMPATIBLE_VERSIONCODE_NOT_SAME,
305             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
306         { IStatusReceiver::ERR_INSTALL_VENDOR_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
307         { IStatusReceiver::ERR_INSTALL_RELEASETYPE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
308         { IStatusReceiver::ERR_INSTALL_RELEASETYPE_TARGET_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
309         { IStatusReceiver::ERR_INSTALL_RELEASETYPE_COMPATIBLE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
310         { IStatusReceiver::ERR_INSTALL_SINGLETON_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
311         { IStatusReceiver::ERR_INSTALL_ZERO_USER_WITH_NO_SINGLETON, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
312         { IStatusReceiver::ERR_INSTALL_CHECK_SYSCAP_FAILED, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
313         { IStatusReceiver::ERR_INSTALL_APPTYPE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
314         { IStatusReceiver::ERR_INSTALL_URI_DUPLICATE, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
315         { IStatusReceiver::ERR_INSTALL_VERSION_NOT_COMPATIBLE, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
316         { IStatusReceiver::ERR_INSTALL_APP_DISTRIBUTION_TYPE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
317         { IStatusReceiver::ERR_INSTALL_APP_PROVISION_TYPE_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
318         { IStatusReceiver::ERR_INSTALL_SO_INCOMPATIBLE, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
319         { IStatusReceiver::ERR_INSTALL_AN_INCOMPATIBLE, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
320         { IStatusReceiver::ERR_INSTALL_TYPE_ERROR, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
321         { IStatusReceiver::ERR_INSTALL_TYPE_ERROR, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
322         { IStatusReceiver::ERR_INSTALL_NOT_UNIQUE_DISTRO_MODULE_NAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
323         { IStatusReceiver::ERR_INSTALL_INCONSISTENT_MODULE_NAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
324         { IStatusReceiver::ERR_INSTALL_INVALID_NUMBER_OF_ENTRY_HAP, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
325         { IStatusReceiver::ERR_INSTALL_ASAN_ENABLED_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
326         { IStatusReceiver::ERR_INSTALL_ASAN_ENABLED_NOT_SUPPORT, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT},
327         { IStatusReceiver::ERR_INSTALL_BUNDLE_TYPE_NOT_SAME, ERROR_INSTALL_PARSE_FAILED},
328         { IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT, ERROR_INSTALL_NO_DISK_SPACE_LEFT },
329         { IStatusReceiver::ERR_USER_NOT_EXIST, ERROR_INVALID_USER_ID },
330         { IStatusReceiver::ERR_INSTALL_VERSION_DOWNGRADE, ERROR_INSTALL_VERSION_DOWNGRADE },
331         { IStatusReceiver::ERR_INSTALL_DEVICE_TYPE_NOT_SUPPORTED, ERROR_INSTALL_PARSE_FAILED },
332         { IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_PROP_SIZE_CHECK_ERROR, ERROR_INSTALL_PARSE_FAILED },
333         { IStatusReceiver::ERR_INSTALL_DEPENDENT_MODULE_NOT_EXIST, ERROR_INSTALL_DEPENDENT_MODULE_NOT_EXIST },
334         { IStatusReceiver::ERR_INSTALL_SHARE_APP_LIBRARY_NOT_ALLOWED, ERROR_INSTALL_SHARE_APP_LIBRARY_NOT_ALLOWED },
335         { IStatusReceiver::ERR_INSTALL_COMPATIBLE_POLICY_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
336         { IStatusReceiver::ERR_INSTALL_FILE_IS_SHARED_LIBRARY, ERROR_INSTALL_FILE_IS_SHARED_LIBRARY },
337         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR, ERROR_BUNDLE_SERVICE_EXCEPTION },
338         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INVALID_BUNDLE_NAME, ERROR_BUNDLE_NOT_EXIST },
339         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INVALID_MODULE_NAME, ERROR_MODULE_NOT_EXIST},
340         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_ERROR_HAP_TYPE, ERROR_INVALID_TYPE },
341         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_ERROR_BUNDLE_TYPE, ERROR_INVALID_TYPE },
342         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_BUNDLE_NAME_MISSED, ERROR_INSTALL_PARSE_FAILED },
343         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_MODULE_NAME_MISSED, ERROR_INSTALL_PARSE_FAILED },
344         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_BUNDLE_NAME_NOT_SAME,
345             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
346         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INTERNAL_EXTERNAL_OVERLAY_EXISTED_SIMULTANEOUSLY,
347             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
348         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_PRIORITY_NOT_SAME,
349             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
350         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INVALID_PRIORITY, ERROR_INSTALL_PARSE_FAILED },
351         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INCONSISTENT_VERSION_CODE,
352             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
353         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_SERVICE_EXCEPTION, ERROR_BUNDLE_SERVICE_EXCEPTION },
354         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_BUNDLE_NAME_SAME_WITH_TARGET_BUNDLE_NAME,
355             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT},
356         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_NO_SYSTEM_APPLICATION_FOR_EXTERNAL_OVERLAY,
357             ERROR_INSTALL_HAP_OVERLAY_CHECK_FAILED },
358         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_DIFFERENT_SIGNATURE_CERTIFICATE,
359             ERROR_INSTALL_VERIFY_SIGNATURE_FAILED },
360         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_BUNDLE_IS_OVERLAY_BUNDLE,
361             ERROR_INSTALL_HAP_OVERLAY_CHECK_FAILED },
362         {IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_TARGET_MODULE_IS_OVERLAY_MODULE,
363             ERROR_INSTALL_HAP_OVERLAY_CHECK_FAILED },
364         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_OVERLAY_TYPE_NOT_SAME,
365             ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
366         { IStatusReceiver::ERR_OVERLAY_INSTALLATION_FAILED_INVALID_BUNDLE_DIR, ERROR_BUNDLE_SERVICE_EXCEPTION },
367         { IStatusReceiver::ERR_APPEXECFWK_UNINSTALL_SHARE_APP_LIBRARY_IS_NOT_EXIST,
368             ERROR_UNINSTALL_SHARE_APP_LIBRARY_IS_NOT_EXIST},
369         { IStatusReceiver::ERR_APPEXECFWK_UNINSTALL_SHARE_APP_LIBRARY_IS_RELIED,
370             ERROR_UNINSTALL_SHARE_APP_LIBRARY_IS_RELIED},
371         { IStatusReceiver::ERR_APPEXECFWK_UNINSTALL_BUNDLE_IS_SHARED_LIBRARY,
372             ERROR_UNINSTALL_BUNDLE_IS_SHARED_BUNDLE},
373         { IStatusReceiver::ERR_INSATLL_CHECK_PROXY_DATA_URI_FAILED,
374             ERROR_INSTALL_WRONG_DATA_PROXY_URI},
375         { IStatusReceiver::ERR_INSATLL_CHECK_PROXY_DATA_PERMISSION_FAILED,
376             ERROR_INSTALL_WRONG_DATA_PROXY_PERMISSION},
377         { IStatusReceiver::ERR_INSTALL_FAILED_DEBUG_NOT_SAME, ERROR_INSTALL_MULTIPLE_HAP_INFO_INCONSISTENT },
378         { IStatusReceiver::ERR_INSTALL_DISALLOWED, ERROR_DISALLOW_INSTALL},
379         { IStatusReceiver::ERR_INSTALL_ISOLATION_MODE_FAILED, ERROR_INSTALL_WRONG_MODE_ISOLATION },
380         { IStatusReceiver::ERR_UNINSTALL_DISALLOWED, ERROR_DISALLOW_UNINSTALL },
381         { IStatusReceiver::ERR_INSTALL_CODE_SIGNATURE_FAILED, ERROR_INSTALL_CODE_SIGNATURE_FAILED },
382         { IStatusReceiver::ERR_INSTALL_CODE_SIGNATURE_FILE_IS_INVALID, ERROR_INSTALL_CODE_SIGNATURE_FAILED},
383         { IStatusReceiver::ERR_UNINSTALL_FROM_BMS_EXTENSION_FAILED, ERROR_BUNDLE_NOT_EXIST},
384         { IStatusReceiver::ERR_INSTALL_SELF_UPDATE_NOT_MDM, ERROR_INSTALL_SELF_UPDATE_NOT_MDM},
385         { IStatusReceiver::ERR_INSTALL_ENTERPRISE_BUNDLE_NOT_ALLOWED, ERROR_INSTALL_ENTERPRISE_BUNDLE_NOT_ALLOWED},
386         { IStatusReceiver::ERR_INSTALL_SELF_UPDATE_BUNDLENAME_NOT_SAME, ERROR_INSTALL_SELF_UPDATE_BUNDLENAME_NOT_SAME},
387     };
388 }
389 
ConvertInstallResult(InstallResult & installResult)390 static void ConvertInstallResult(InstallResult &installResult)
391 {
392     APP_LOGD("ConvertInstallResult msg %{public}s, errCode is %{public}d.", installResult.resultMsg.c_str(),
393         installResult.resultCode);
394     std::unordered_map<int32_t, int32_t> errCodeMap;
395     CreateErrCodeMap(errCodeMap);
396     auto iter = errCodeMap.find(installResult.resultCode);
397     if (iter != errCodeMap.end()) {
398         installResult.resultCode = iter->second;
399         return;
400     }
401     installResult.resultCode = ERROR_BUNDLE_SERVICE_EXCEPTION;
402 }
403 
ParseHashParam(napi_env env,napi_value args,std::string & key,std::string & value)404 static bool ParseHashParam(napi_env env, napi_value args, std::string &key, std::string &value)
405 {
406     APP_LOGD("start to parse moduleName");
407     bool ret = CommonFunc::ParseStringPropertyFromObject(env, args, MODULE_NAME, true, key);
408     if (!ret || key.empty()) {
409         APP_LOGE("param string moduleName is empty.");
410         return false;
411     }
412     APP_LOGD("ParseHashParam moduleName=%{public}s.", key.c_str());
413 
414     APP_LOGD("start to parse hashValue");
415     ret = CommonFunc::ParseStringPropertyFromObject(env, args, HASH_VALUE, true, value);
416     if (!ret || value.empty()) {
417         APP_LOGE("param string hashValue is empty.");
418         return false;
419     }
420     APP_LOGD("ParseHashParam hashValue=%{public}s.", value.c_str());
421     return true;
422 }
423 
ParseHashParams(napi_env env,napi_value args,std::map<std::string,std::string> & hashParams)424 static bool ParseHashParams(napi_env env, napi_value args, std::map<std::string, std::string> &hashParams)
425 {
426     APP_LOGD("start to parse hashParams");
427     std::vector<napi_value> valueVec;
428     bool res = CommonFunc::ParsePropertyArray(env, args, HASH_PARAMS, valueVec);
429     if (!res) {
430         APP_LOGW("hashParams type error,using default value.");
431         return true;
432     }
433     if (valueVec.empty()) {
434         APP_LOGW("hashParams is empty,using default value.");
435         return true;
436     }
437     for (const auto &property : valueVec) {
438         std::string key;
439         std::string value;
440         if (!ParseHashParam(env, property, key, value)) {
441             APP_LOGE("parse hash param failed");
442             return false;
443         }
444         if (hashParams.find(key) != hashParams.end()) {
445             APP_LOGE("moduleName(%{public}s) is duplicate", key.c_str());
446             return false;
447         }
448         hashParams.emplace(key, value);
449     }
450     return true;
451 }
452 
ParseVerifyCodeParam(napi_env env,napi_value args,std::string & key,std::string & value)453 static bool ParseVerifyCodeParam(napi_env env, napi_value args, std::string &key, std::string &value)
454 {
455     APP_LOGD("start to parse moduleName");
456     bool ret = CommonFunc::ParseStringPropertyFromObject(env, args, MODULE_NAME, true, key);
457     if (!ret || key.empty()) {
458         APP_LOGE("param string moduleName is empty.");
459         return false;
460     }
461     APP_LOGD("ParseVerifyCodeParam moduleName is %{public}s.", key.c_str());
462 
463     APP_LOGD("start to parse signatureFilePath");
464     ret = CommonFunc::ParseStringPropertyFromObject(env, args, SIGNATURE_FILE_PATH, true, value);
465     if (!ret || value.empty()) {
466         APP_LOGE("param string signatureFilePath is empty.");
467         return false;
468     }
469     APP_LOGD("ParseVerifyCodeParam signatureFilePath is %{public}s.", value.c_str());
470     return true;
471 }
472 
ParseVerifyCodeParams(napi_env env,napi_value args,std::map<std::string,std::string> & verifyCodeParams)473 static bool ParseVerifyCodeParams(napi_env env, napi_value args, std::map<std::string, std::string> &verifyCodeParams)
474 {
475     APP_LOGD("start to parse verifyCodeParams");
476     std::vector<napi_value> valueVec;
477     bool res = CommonFunc::ParsePropertyArray(env, args, VERIFY_CODE_PARAM, valueVec);
478     if (!res) {
479         APP_LOGW("verifyCodeParams type error, using default value.");
480         return true;
481     }
482     if (valueVec.empty()) {
483         APP_LOGW("verifyCodeParams is empty, using default value.");
484         return true;
485     }
486     for (const auto &property : valueVec) {
487         std::string key;
488         std::string value;
489         if (!ParseVerifyCodeParam(env, property, key, value)) {
490             APP_LOGE("parse verify code param failed");
491             return false;
492         }
493         if (verifyCodeParams.find(key) != verifyCodeParams.end()) {
494             APP_LOGE("moduleName(%{public}s) is duplicate", key.c_str());
495             return false;
496         }
497         verifyCodeParams.emplace(key, value);
498     }
499     return true;
500 }
501 
ParseBundleName(napi_env env,napi_value args,std::string & bundleName)502 static bool ParseBundleName(napi_env env, napi_value args, std::string &bundleName)
503 {
504     APP_LOGD("start to parse bundleName");
505     PropertyInfo propertyInfo = {
506         .propertyName = BUNDLE_NAME,
507         .isNecessary = true,
508         .propertyType = napi_string
509     };
510     napi_value property = nullptr;
511     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
512     if (!res) {
513         APP_LOGE("parse bundleName failed");
514         return res;
515     }
516     if (property != nullptr) {
517         if (!CommonFunc::ParseString(env, property, bundleName)) {
518             APP_LOGE("ParseString failed!");
519             return false;
520         }
521     }
522     APP_LOGD("param bundleName is %{public}s", bundleName.c_str());
523     return true;
524 }
525 
ParseModuleName(napi_env env,napi_value args,std::string & moduleName)526 static bool ParseModuleName(napi_env env, napi_value args, std::string &moduleName)
527 {
528     APP_LOGD("start to parse moduleName");
529     PropertyInfo propertyInfo = {
530         .propertyName = MODULE_NAME,
531         .isNecessary = false,
532         .propertyType = napi_string
533     };
534     napi_value property = nullptr;
535     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
536     if (!res) {
537         APP_LOGE("parse moduleName failed");
538         return res;
539     }
540     if (property != nullptr) {
541         if (!CommonFunc::ParseString(env, property, moduleName)) {
542             APP_LOGE("ParseString failed!");
543             return false;
544         }
545     }
546     return true;
547 }
548 
ParseVersionCode(napi_env env,napi_value args,int32_t & versionCode)549 static bool ParseVersionCode(napi_env env, napi_value args, int32_t &versionCode)
550 {
551     APP_LOGD("start to parse versionCode");
552     PropertyInfo propertyInfo = {
553         .propertyName = VERSION_CODE,
554         .isNecessary = false,
555         .propertyType = napi_number
556     };
557     napi_value property = nullptr;
558     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
559     if (!res) {
560         APP_LOGE("parse versionCode failed!");
561         return res;
562     }
563     if (property != nullptr) {
564         PARSE_PROPERTY(env, property, int32, versionCode);
565     }
566     APP_LOGD("param versionCode is %{public}d", versionCode);
567     return true;
568 }
569 
ParseUserId(napi_env env,napi_value args,int32_t & userId)570 static bool ParseUserId(napi_env env, napi_value args, int32_t &userId)
571 {
572     APP_LOGD("start to parse userId");
573     PropertyInfo propertyInfo = {
574         .propertyName = USER_ID,
575         .isNecessary = false,
576         .propertyType = napi_number
577     };
578     napi_value property = nullptr;
579     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
580     if (!res) {
581         APP_LOGE("parse userId failed");
582         return res;
583     }
584     if (property != nullptr) {
585         PARSE_PROPERTY(env, property, int32, userId);
586     }
587     APP_LOGD("param userId is %{public}d", userId);
588     return true;
589 }
590 
ParseInstallFlag(napi_env env,napi_value args,InstallFlag & installFlag)591 static bool ParseInstallFlag(napi_env env, napi_value args, InstallFlag &installFlag)
592 {
593     APP_LOGD("start to parse installFlag");
594     PropertyInfo propertyInfo = {
595         .propertyName = INSTALL_FLAG,
596         .isNecessary = false,
597         .propertyType = napi_number
598     };
599     napi_value property = nullptr;
600     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
601     if (!res) {
602         APP_LOGE("parse installFlag failed");
603         return res;
604     }
605 
606     if (property != nullptr) {
607         int32_t flag = 0;
608         PARSE_PROPERTY(env, property, int32, flag);
609         APP_LOGD("param installFlag is %{public}d", flag);
610         if ((flag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::NORMAL)) &&
611             (flag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::REPLACE_EXISTING)) &&
612             (flag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::FREE_INSTALL))) {
613             APP_LOGE("invalid installFlag param");
614             return false;
615         }
616         installFlag = static_cast<OHOS::AppExecFwk::InstallFlag>(flag);
617     }
618     return true;
619 }
620 
ParseIsKeepData(napi_env env,napi_value args,bool & isKeepData)621 static bool ParseIsKeepData(napi_env env, napi_value args, bool &isKeepData)
622 {
623     APP_LOGD("start to parse isKeepData");
624     PropertyInfo propertyInfo = {
625         .propertyName = IS_KEEP_DATA,
626         .isNecessary = false,
627         .propertyType = napi_boolean
628     };
629     napi_value property = nullptr;
630     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
631     if (!res) {
632         APP_LOGE("parse isKeepData failed");
633         return res;
634     }
635     if (property != nullptr) {
636         PARSE_PROPERTY(env, property, bool, isKeepData);
637     }
638     APP_LOGD("param isKeepData is %{public}d", isKeepData);
639     return true;
640 }
641 
ParseCrowdtestDeadline(napi_env env,napi_value args,int64_t & crowdtestDeadline)642 static bool ParseCrowdtestDeadline(napi_env env, napi_value args, int64_t &crowdtestDeadline)
643 {
644     APP_LOGD("start to parse crowdtestDeadline");
645     PropertyInfo propertyInfo = {
646         .propertyName = CROWD_TEST_DEADLINE,
647         .isNecessary = false,
648         .propertyType = napi_number
649     };
650     napi_value property = nullptr;
651     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
652     if (!res) {
653         APP_LOGE("parse crowdtestDeadline failed");
654         return res;
655     }
656     if (property != nullptr) {
657         PARSE_PROPERTY(env, property, int64, crowdtestDeadline);
658     }
659     return true;
660 }
661 
ParseSharedBundleDirPaths(napi_env env,napi_value args,std::vector<std::string> & sharedBundleDirPaths)662 static bool ParseSharedBundleDirPaths(napi_env env, napi_value args, std::vector<std::string> &sharedBundleDirPaths)
663 {
664     APP_LOGD("start to parse sharedBundleDirPaths");
665     std::vector<napi_value> valueVec;
666     bool res = CommonFunc::ParsePropertyArray(env, args, SHARED_BUNDLE_DIR_PATHS, valueVec);
667     if (!res) {
668         APP_LOGE("parse sharedBundleDirPaths failed");
669         return res;
670     }
671     if (valueVec.empty()) {
672         APP_LOGD("sharedBundleDirPaths is empty");
673         return true;
674     }
675     for (const auto &value : valueVec) {
676         std::string path;
677         if (!CommonFunc::ParseString(env, value, path)) {
678             APP_LOGE("parse sharedBundleDirPaths element failed");
679             return false;
680         }
681         sharedBundleDirPaths.emplace_back(path);
682     }
683     return true;
684 }
685 
ParseSpecifiedDistributionType(napi_env env,napi_value args,std::string & specifiedDistributionType)686 static bool ParseSpecifiedDistributionType(napi_env env, napi_value args, std::string &specifiedDistributionType)
687 {
688     APP_LOGD("start to parse specifiedDistributionType");
689     PropertyInfo propertyInfo = {
690         .propertyName = SPECIFIED_DISTRIBUTION_TYPE,
691         .isNecessary = false,
692         .propertyType = napi_string
693     };
694     napi_value property = nullptr;
695     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
696     if (!res) {
697         APP_LOGE("parse specifiedDistributionType failed");
698         return res;
699     }
700     if (property != nullptr) {
701         if (!CommonFunc::ParseString(env, property, specifiedDistributionType)) {
702             APP_LOGE("ParseString failed!");
703             return false;
704         }
705     }
706     APP_LOGD("param specifiedDistributionType is %{public}s", specifiedDistributionType.c_str());
707     return true;
708 }
709 
ParseAdditionalInfo(napi_env env,napi_value args,std::string & additionalInfo)710 static bool ParseAdditionalInfo(napi_env env, napi_value args, std::string &additionalInfo)
711 {
712     APP_LOGD("start to parse the additionalInfo");
713     PropertyInfo propertyInfo = {
714         .propertyName = ADDITIONAL_INFO,
715         .isNecessary = false,
716         .propertyType = napi_string
717     };
718     napi_value property = nullptr;
719     bool res = CommonFunc::ParsePropertyFromObject(env, args, propertyInfo, property);
720     if (!res) {
721         APP_LOGE("parse additionalInfo failed");
722         return res;
723     }
724     if (property != nullptr) {
725         if (!CommonFunc::ParseString(env, property, additionalInfo)) {
726             APP_LOGE("ParseString failed!");
727             return false;
728         }
729     }
730     APP_LOGD("param additionalInfo is %{public}s", additionalInfo.c_str());
731     return true;
732 }
733 
CheckInstallParam(napi_env env,InstallParam & installParam)734 static bool CheckInstallParam(napi_env env, InstallParam &installParam)
735 {
736     if (installParam.specifiedDistributionType.size() > SPECIFIED_DISTRIBUTION_TYPE_MAX_SIZE) {
737         APP_LOGE("Parse specifiedDistributionType size failed");
738         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR,
739             "BusinessError 401: The size of specifiedDistributionType is greater than 128");
740         return false;
741     }
742     if (installParam.additionalInfo.size() > ADDITIONAL_INFO_MAX_SIZE) {
743         APP_LOGE("Parse additionalInfo size failed");
744         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR,
745             "BusinessError 401: The size of additionalInfo is greater than 3000");
746         return false;
747     }
748     return true;
749 }
750 
ParseInstallParam(napi_env env,napi_value args,InstallParam & installParam)751 static bool ParseInstallParam(napi_env env, napi_value args, InstallParam &installParam)
752 {
753     if (!ParseHashParams(env, args, installParam.hashParams)) {
754         return false;
755     }
756     if (!ParseVerifyCodeParams(env, args, installParam.verifyCodeParams)) {
757         return false;
758     }
759     if (!ParseUserId(env, args, installParam.userId)) {
760         APP_LOGW("Parse userId failed,using default value.");
761     }
762     if (!ParseInstallFlag(env, args, installParam.installFlag)) {
763         APP_LOGW("Parse installFlag failed,using default value.");
764     }
765     if (!ParseIsKeepData(env, args, installParam.isKeepData)) {
766         APP_LOGW("Parse isKeepData failed,using default value.");
767     }
768     if (!ParseCrowdtestDeadline(env, args, installParam.crowdtestDeadline)) {
769         APP_LOGW("Parse crowdtestDeadline failed,using default value.");
770     }
771     if (!ParseSharedBundleDirPaths(env, args, installParam.sharedBundleDirPaths)) {
772         APP_LOGW("Parse sharedBundleDirPaths failed,using default value.");
773     }
774     if (!ParseSpecifiedDistributionType(env, args, installParam.specifiedDistributionType)) {
775         APP_LOGW("Parse specifiedDistributionType failed,using default value.");
776     }
777     if (!ParseAdditionalInfo(env, args, installParam.additionalInfo)) {
778         APP_LOGW("Parse additionalInfo failed,using default value.");
779     }
780     return true;
781 }
782 
ParseUninstallParam(napi_env env,napi_value args,UninstallParam & uninstallParam)783 static bool ParseUninstallParam(napi_env env, napi_value args, UninstallParam &uninstallParam)
784 {
785     if (!ParseBundleName(env, args, uninstallParam.bundleName) ||
786         !ParseModuleName(env, args, uninstallParam.moduleName) ||
787         !ParseVersionCode(env, args, uninstallParam.versionCode) ||
788         !ParseUserId(env, args, uninstallParam.userId)) {
789             APP_LOGE("Parse UninstallParam faied!");
790             return false;
791     }
792     return true;
793 }
794 
CreateProxyErrCode(std::unordered_map<int32_t,int32_t> & errCodeMap)795 static void CreateProxyErrCode(std::unordered_map<int32_t, int32_t> &errCodeMap)
796 {
797     errCodeMap = {
798         { ERR_APPEXECFWK_INSTALL_PARAM_ERROR, IStatusReceiver::ERR_INSTALL_PARAM_ERROR },
799         { ERR_APPEXECFWK_INSTALL_INTERNAL_ERROR, IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR },
800         { ERR_APPEXECFWK_INSTALL_FILE_PATH_INVALID, IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID },
801         { ERR_APPEXECFWK_INSTALL_DISK_MEM_INSUFFICIENT, IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT },
802         { ERR_BUNDLEMANAGER_INSTALL_CODE_SIGNATURE_FILE_IS_INVALID,
803             IStatusReceiver::ERR_INSTALL_CODE_SIGNATURE_FILE_IS_INVALID}
804     };
805 }
806 
InstallExecuter(napi_env env,void * data)807 void InstallExecuter(napi_env env, void *data)
808 {
809     AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
810     if (asyncCallbackInfo == nullptr) {
811         APP_LOGE("asyncCallbackInfo is nullptr");
812         return;
813     }
814     const std::vector<std::string> bundleFilePath = asyncCallbackInfo->hapFiles;
815     InstallResult &installResult = asyncCallbackInfo->installResult;
816     if (bundleFilePath.empty() && asyncCallbackInfo->installParam.sharedBundleDirPaths.empty()) {
817         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID);
818         return;
819     }
820     auto iBundleInstaller = CommonFunc::GetBundleInstaller();
821     if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
822         APP_LOGE("can not get iBundleInstaller");
823         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
824         return;
825     }
826 
827     sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
828     sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
829     if (callback == nullptr || recipient == nullptr) {
830         APP_LOGE("callback or death recipient is nullptr");
831         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
832         return;
833     }
834     iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
835 
836     ErrCode res = iBundleInstaller->StreamInstall(bundleFilePath, asyncCallbackInfo->installParam, callback);
837     if (res == ERR_OK) {
838         installResult.resultCode = callback->GetResultCode();
839         APP_LOGD("InnerInstall resultCode %{public}d", installResult.resultCode);
840         installResult.resultMsg = callback->GetResultMsg();
841         APP_LOGD("InnerInstall resultMsg %{public}s", installResult.resultMsg.c_str());
842         return;
843     }
844     APP_LOGE("install failed due to %{public}d", res);
845     std::unordered_map<int32_t, int32_t> proxyErrCodeMap;
846     CreateProxyErrCode(proxyErrCodeMap);
847     if (proxyErrCodeMap.find(res) != proxyErrCodeMap.end()) {
848         installResult.resultCode = proxyErrCodeMap.at(res);
849     } else {
850         installResult.resultCode = IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR;
851     }
852 }
853 
GetFunctionName(const InstallOption & option)854 static std::string GetFunctionName(const InstallOption &option)
855 {
856     if (option == InstallOption::INSTALL) {
857         return RESOURCE_NAME_OF_INSTALL;
858     } else if (option == InstallOption::RECOVER) {
859         return RESOURCE_NAME_OF_RECOVER;
860     } else if (option == InstallOption::UNINSTALL) {
861         return RESOURCE_NAME_OF_UNINSTALL;
862     } else if (option == InstallOption::UPDATE_BUNDLE_FOR_SELF) {
863         return RESOURCE_NAME_OF_UPDATE_BUNDLE_FOR_SELF;
864     }
865     return EMPTY_STRING;
866 }
867 
OperationCompleted(napi_env env,napi_status status,void * data)868 void OperationCompleted(napi_env env, napi_status status, void *data)
869 {
870     AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
871     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
872     napi_value result[CALLBACK_PARAM_SIZE] = {0};
873     ConvertInstallResult(callbackPtr->installResult);
874     if (callbackPtr->installResult.resultCode != SUCCESS) {
875         switch (callbackPtr->option) {
876             case InstallOption::INSTALL:
877                 result[FIRST_PARAM] = BusinessError::CreateCommonError(env, callbackPtr->installResult.resultCode,
878                     RESOURCE_NAME_OF_INSTALL, INSTALL_PERMISSION);
879                 break;
880             case InstallOption::RECOVER:
881                 result[FIRST_PARAM] = BusinessError::CreateCommonError(env, callbackPtr->installResult.resultCode,
882                     RESOURCE_NAME_OF_RECOVER, RECOVER_PERMISSION);
883                 break;
884             case InstallOption::UNINSTALL:
885                 result[FIRST_PARAM] = BusinessError::CreateCommonError(env, callbackPtr->installResult.resultCode,
886                     RESOURCE_NAME_OF_UNINSTALL, UNINSTALL_PERMISSION);
887                 break;
888             case InstallOption::UPDATE_BUNDLE_FOR_SELF:
889                 result[FIRST_PARAM] = BusinessError::CreateCommonError(env, callbackPtr->installResult.resultCode,
890                     RESOURCE_NAME_OF_UPDATE_BUNDLE_FOR_SELF, INSTALL_SELF_PERMISSION);
891                 break;
892             default:
893                 break;
894         }
895     } else {
896         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[FIRST_PARAM]));
897     }
898     callbackPtr->err = callbackPtr->installResult.resultCode;
899     CommonFunc::NapiReturnDeferred<AsyncInstallCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_ONE);
900 }
901 
902 /**
903  * Promise and async callback
904  */
Install(napi_env env,napi_callback_info info)905 napi_value Install(napi_env env, napi_callback_info info)
906 {
907     APP_LOGD("Install called");
908     // obtain arguments of install interface
909     NapiArg args(env, info);
910     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
911         APP_LOGE("init param failed");
912         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
913         return nullptr;
914     }
915     auto argc = args.GetMaxArgc();
916     APP_LOGD("the number of argc is  %{public}zu", argc);
917     if (argc < ARGS_SIZE_ONE) {
918         APP_LOGE("the params number is incorrect");
919         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
920         return nullptr;
921     }
922     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr = std::make_unique<AsyncInstallCallbackInfo>(env);
923     callbackPtr->option = InstallOption::INSTALL;
924     for (size_t i = 0; i < argc; ++i) {
925         napi_valuetype valueType = napi_undefined;
926         napi_typeof(env, args[i], &valueType);
927         if (i == ARGS_POS_ZERO) {
928             if (!CommonFunc::ParseStringArray(env, callbackPtr->hapFiles, args[i])) {
929                 APP_LOGE("Flags %{public}s invalid!", callbackPtr->bundleName.c_str());
930                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
931                 return nullptr;
932             }
933         } else if (i == ARGS_POS_ONE) {
934             if (valueType == napi_function) {
935                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
936                 break;
937             }
938             if (valueType == napi_object && !ParseInstallParam(env, args[i], callbackPtr->installParam)) {
939                 APP_LOGE("Parse installParam failed");
940                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
941                 return nullptr;
942             }
943         } else if (i == ARGS_POS_TWO) {
944             if (valueType == napi_function) {
945                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
946                 break;
947             }
948         } else {
949             APP_LOGE("param check error");
950             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
951             return nullptr;
952         }
953     }
954     if (!CheckInstallParam(env, callbackPtr->installParam)) {
955         return nullptr;
956     }
957     if (callbackPtr->hapFiles.empty() && !callbackPtr->installParam.verifyCodeParams.empty()) {
958         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, HAPS_FILE_NEEDED);
959         return nullptr;
960     }
961     auto promise = CommonFunc::AsyncCallNativeMethod(env, callbackPtr.get(), RESOURCE_NAME_OF_INSTALL, InstallExecuter,
962         OperationCompleted);
963     callbackPtr.release();
964     return promise;
965 }
966 
UninstallOrRecoverExecuter(napi_env env,void * data)967 void UninstallOrRecoverExecuter(napi_env env, void *data)
968 {
969     AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
970     if (asyncCallbackInfo == nullptr) {
971         APP_LOGE("asyncCallbackInfo is nullptr");
972         return;
973     }
974     const std::string bundleName = asyncCallbackInfo->bundleName;
975     InstallResult &installResult = asyncCallbackInfo->installResult;
976     if (bundleName.empty()) {
977         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME);
978         return;
979     }
980     auto iBundleInstaller = CommonFunc::GetBundleInstaller();
981     if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
982         APP_LOGE("can not get iBundleInstaller");
983         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
984         return;
985     }
986 
987     sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
988     sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
989     if (callback == nullptr || recipient == nullptr) {
990         APP_LOGE("callback or death recipient is nullptr");
991         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
992         return;
993     }
994     iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
995     if (asyncCallbackInfo->option == InstallOption::RECOVER) {
996         iBundleInstaller->Recover(bundleName, asyncCallbackInfo->installParam, callback);
997     } else if (asyncCallbackInfo->option == InstallOption::UNINSTALL) {
998         iBundleInstaller->Uninstall(bundleName, asyncCallbackInfo->installParam, callback);
999     } else {
1000         APP_LOGE("error install option");
1001         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
1002         return;
1003     }
1004     installResult.resultMsg = callback->GetResultMsg();
1005     APP_LOGD("InnerRecover resultMsg %{public}s.", installResult.resultMsg.c_str());
1006     installResult.resultCode = callback->GetResultCode();
1007     APP_LOGD("InnerRecover resultCode %{public}d.", installResult.resultCode);
1008 }
1009 
UninstallByUninstallParamExecuter(napi_env env,void * data)1010 void UninstallByUninstallParamExecuter(napi_env env, void* data)
1011 {
1012     AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
1013     if (asyncCallbackInfo == nullptr) {
1014         APP_LOGE("asyncCallbackInfo is nullptr");
1015         return;
1016     }
1017     const std::string bundleName = asyncCallbackInfo->uninstallParam.bundleName;
1018     InstallResult &installResult = asyncCallbackInfo->installResult;
1019     if (bundleName.empty()) {
1020         installResult.resultCode =
1021             static_cast<int32_t>(IStatusReceiver::ERR_APPEXECFWK_UNINSTALL_SHARE_APP_LIBRARY_IS_NOT_EXIST);
1022         return;
1023     }
1024     auto iBundleInstaller = CommonFunc::GetBundleInstaller();
1025     if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
1026         APP_LOGE("can not get iBundleInstaller");
1027         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
1028         return;
1029     }
1030     sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
1031     sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
1032     if (callback == nullptr || recipient == nullptr) {
1033         APP_LOGE("callback or death recipient is nullptr");
1034         installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR);
1035         return;
1036     }
1037     iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
1038     iBundleInstaller->Uninstall(asyncCallbackInfo->uninstallParam, callback);
1039     installResult.resultMsg = callback->GetResultMsg();
1040     installResult.resultCode = callback->GetResultCode();
1041 }
1042 
UninstallByUninstallParam(napi_env env,napi_callback_info info,std::unique_ptr<AsyncInstallCallbackInfo> & callbackPtr)1043 napi_value UninstallByUninstallParam(napi_env env, napi_callback_info info,
1044     std::unique_ptr<AsyncInstallCallbackInfo> &callbackPtr)
1045 {
1046     NapiArg args(env, info);
1047     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
1048         APP_LOGE("init param failed");
1049         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
1050         return nullptr;
1051     }
1052     for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
1053         napi_valuetype valueType = napi_undefined;
1054         napi_typeof(env, args[i], &valueType);
1055         if (i == ARGS_POS_ZERO) {
1056             if (!ParseUninstallParam(env, args[i], callbackPtr->uninstallParam)) {
1057                 APP_LOGE("parse uninstallParam failed!");
1058                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1059                 return nullptr;
1060             }
1061         } else if ((i == ARGS_POS_ONE) && (valueType == napi_function)) {
1062             NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
1063             break;
1064         } else {
1065             APP_LOGE("param check error");
1066             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1067             return nullptr;
1068         }
1069     }
1070     auto promise = CommonFunc::AsyncCallNativeMethod(env, callbackPtr.get(), GetFunctionName(callbackPtr->option),
1071         UninstallByUninstallParamExecuter, OperationCompleted);
1072     callbackPtr.release();
1073     return promise;
1074 }
1075 
UninstallOrRecover(napi_env env,napi_callback_info info,std::unique_ptr<AsyncInstallCallbackInfo> & callbackPtr)1076 napi_value UninstallOrRecover(napi_env env, napi_callback_info info,
1077     std::unique_ptr<AsyncInstallCallbackInfo> &callbackPtr)
1078 {
1079     APP_LOGD("UninstallOrRecover by bundleName called");
1080     // obtain arguments of install interface
1081     NapiArg args(env, info);
1082     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
1083         APP_LOGE("init param failed");
1084         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
1085         return nullptr;
1086     }
1087 
1088     auto argc = args.GetMaxArgc();
1089     APP_LOGD("the number of argc is  %{public}zu", argc);
1090     if (argc < ARGS_SIZE_ONE) {
1091         APP_LOGE("the params number is incorrect");
1092         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
1093         return nullptr;
1094     }
1095 
1096     for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
1097         napi_valuetype valueType = napi_undefined;
1098         napi_typeof(env, args[i], &valueType);
1099         if (i == ARGS_POS_ZERO) {
1100             if (!CommonFunc::ParseString(env, args[i], callbackPtr->bundleName)) {
1101                 APP_LOGE("Flags %{public}s invalid!", callbackPtr->bundleName.c_str());
1102                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1103                 return nullptr;
1104             }
1105         } else if (i == ARGS_POS_ONE) {
1106             if (valueType == napi_function) {
1107                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
1108                 break;
1109             }
1110             if (valueType == napi_object && !ParseInstallParam(env, args[i], callbackPtr->installParam)) {
1111                 APP_LOGE("Parse installParam.hashParams failed");
1112                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1113                 return nullptr;
1114             }
1115         } else if (i == ARGS_POS_TWO) {
1116             if (valueType == napi_function) {
1117                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
1118                 break;
1119             }
1120         } else {
1121             APP_LOGE("param check error");
1122             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1123             return nullptr;
1124         }
1125     }
1126 
1127     auto promise = CommonFunc::AsyncCallNativeMethod(env, callbackPtr.get(), GetFunctionName(callbackPtr->option),
1128         UninstallOrRecoverExecuter, OperationCompleted);
1129     callbackPtr.release();
1130     return promise;
1131 }
1132 
Recover(napi_env env,napi_callback_info info)1133 napi_value Recover(napi_env env, napi_callback_info info)
1134 {
1135     APP_LOGD("Recover called");
1136     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr = std::make_unique<AsyncInstallCallbackInfo>(env);
1137     callbackPtr->option = InstallOption::RECOVER;
1138     return UninstallOrRecover(env, info, callbackPtr);
1139 }
1140 
Uninstall(napi_env env,napi_callback_info info)1141 napi_value Uninstall(napi_env env, napi_callback_info info)
1142 {
1143     APP_LOGD("Uninstall called");
1144     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr = std::make_unique<AsyncInstallCallbackInfo>(env);
1145     callbackPtr->option = InstallOption::UNINSTALL;
1146     // uninstall uninstallParam
1147     NapiArg args(env, info);
1148     args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE);
1149     napi_valuetype firstType = napi_undefined;
1150     napi_typeof(env, args[FIRST_PARAM], &firstType);
1151     if (firstType == napi_object) {
1152         return UninstallByUninstallParam(env, info, callbackPtr);
1153     }
1154     return UninstallOrRecover(env, info, callbackPtr);
1155 }
1156 
BundleInstallerConstructor(napi_env env,napi_callback_info info)1157 napi_value BundleInstallerConstructor(napi_env env, napi_callback_info info)
1158 {
1159     napi_value jsthis = nullptr;
1160     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
1161     return jsthis;
1162 }
1163 
1164 /**
1165  * Promise and async callback
1166  */
UpdateBundleForSelf(napi_env env,napi_callback_info info)1167 napi_value UpdateBundleForSelf(napi_env env, napi_callback_info info)
1168 {
1169     APP_LOGD("UpdateBundleForSelf called");
1170     // obtain arguments of install interface
1171     NapiArg args(env, info);
1172     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
1173         APP_LOGE("init param failed");
1174         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
1175         return nullptr;
1176     }
1177     auto argc = args.GetMaxArgc();
1178     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr = std::make_unique<AsyncInstallCallbackInfo>(env);
1179     callbackPtr->option = InstallOption::UPDATE_BUNDLE_FOR_SELF;
1180     for (size_t i = 0; i < argc; ++i) {
1181         napi_valuetype valueType = napi_undefined;
1182         napi_typeof(env, args[i], &valueType);
1183         if (i == ARGS_POS_ZERO) {
1184             if (!CommonFunc::ParseStringArray(env, callbackPtr->hapFiles, args[i])) {
1185                 APP_LOGE("Flags %{public}s invalid!", callbackPtr->bundleName.c_str());
1186                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1187                 return nullptr;
1188             }
1189         } else if (i == ARGS_POS_ONE) {
1190             if (valueType == napi_function) {
1191                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
1192                 break;
1193             }
1194             if (valueType == napi_object && !ParseInstallParam(env, args[i], callbackPtr->installParam)) {
1195                 APP_LOGE("Parse installParam failed");
1196                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1197                 return nullptr;
1198             }
1199         } else if (i == ARGS_POS_TWO) {
1200             if (valueType == napi_function) {
1201                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &callbackPtr->callback));
1202                 break;
1203             }
1204         } else {
1205             APP_LOGE("param check error");
1206             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PARAMETERS, CORRESPONDING_TYPE);
1207             return nullptr;
1208         }
1209     }
1210     if (!CheckInstallParam(env, callbackPtr->installParam)) {
1211         return nullptr;
1212     }
1213     if (callbackPtr->hapFiles.empty() && !callbackPtr->installParam.verifyCodeParams.empty()) {
1214         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, HAPS_FILE_NEEDED);
1215         return nullptr;
1216     }
1217     callbackPtr->installParam.isSelfUpdate = true;
1218     auto promise = CommonFunc::AsyncCallNativeMethod(env, callbackPtr.get(), RESOURCE_NAME_OF_INSTALL, InstallExecuter,
1219         OperationCompleted);
1220     callbackPtr.release();
1221     return promise;
1222 }
1223 } // AppExecFwk
1224 } // OHOS