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 "js_default_app.h"
17
18 #include <string>
19
20 #include "app_log_wrapper.h"
21 #include "bundle_errors.h"
22 #include "bundle_mgr_interface.h"
23 #include "bundle_mgr_proxy.h"
24 #include "business_error.h"
25 #include "common_func.h"
26 #include "if_system_ability_manager.h"
27 #include "ipc_skeleton.h"
28 #include "iservice_registry.h"
29 #include "napi_arg.h"
30 #include "napi_constants.h"
31 #include "system_ability_definition.h"
32
33 namespace OHOS {
34 namespace AppExecFwk {
35 using namespace OHOS::AAFwk;
36
37 namespace {
38 constexpr int32_t NAPI_RETURN_ZERO = 0;
39 const std::string IS_DEFAULT_APPLICATION = "IsDefaultApplication";
40 const std::string GET_DEFAULT_APPLICATION = "GetDefaultApplication";
41 const std::string SET_DEFAULT_APPLICATION = "SetDefaultApplication";
42 const std::string RESET_DEFAULT_APPLICATION = "ResetDefaultApplication";
43 const std::string PARAM_TYPE_CHECK_ERROR = "param type check error";
44 const std::string PARAM_TYPE_CHECK_ERROR_WITH_POS = "param type check error, error position : ";
45 }
46
47 static const std::unordered_map<std::string, std::string> TYPE_MAPPING = {
48 {"Web Browser", "BROWSER"},
49 {"Image Gallery", "IMAGE"},
50 {"Audio Player", "AUDIO"},
51 {"Video Player", "VIDEO"},
52 {"PDF Viewer", "PDF"},
53 {"Word Viewer", "WORD"},
54 {"Excel Viewer", "EXCEL"},
55 {"PPT Viewer", "PPT"}
56 };
57
ParseType(napi_env env,napi_value value,std::string & result)58 static bool ParseType(napi_env env, napi_value value, std::string& result)
59 {
60 napi_valuetype valueType = napi_undefined;
61 napi_typeof(env, value, &valueType);
62 if (valueType != napi_string) {
63 APP_LOGE("type not string");
64 return false;
65 }
66 size_t size = 0;
67 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
68 APP_LOGE("napi_get_value_string_utf8 error.");
69 return false;
70 }
71 result.reserve(size + 1);
72 result.resize(size);
73 if (napi_get_value_string_utf8(env, value, result.data(), (size + 1), &size) != napi_ok) {
74 APP_LOGE("napi_get_value_string_utf8 error");
75 return false;
76 }
77 if (TYPE_MAPPING.find(result) != TYPE_MAPPING.end()) {
78 result = TYPE_MAPPING.at(result);
79 }
80 return true;
81 }
82
GetDefaultAppProxy()83 static OHOS::sptr<OHOS::AppExecFwk::IDefaultApp> GetDefaultAppProxy()
84 {
85 auto systemAbilityManager = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
86 if (systemAbilityManager == nullptr) {
87 APP_LOGE("systemAbilityManager is null.");
88 return nullptr;
89 }
90 auto bundleMgrSa = systemAbilityManager->GetSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
91 if (bundleMgrSa == nullptr) {
92 APP_LOGE("bundleMgrSa is null.");
93 return nullptr;
94 }
95 auto bundleMgr = OHOS::iface_cast<IBundleMgr>(bundleMgrSa);
96 if (bundleMgr == nullptr) {
97 APP_LOGE("iface_cast failed.");
98 return nullptr;
99 }
100 auto defaultAppProxy = bundleMgr->GetDefaultAppProxy();
101 if (defaultAppProxy == nullptr) {
102 APP_LOGE("GetDefaultAppProxy failed.");
103 return nullptr;
104 }
105 return defaultAppProxy;
106 }
107
ConvertAbilityInfo(napi_env env,napi_value objAbilityInfo,const AbilityInfo & abilityInfo)108 static void ConvertAbilityInfo(napi_env env, napi_value objAbilityInfo, const AbilityInfo &abilityInfo)
109 {
110 APP_LOGD("begin to ConvertAbilityInfo");
111 napi_value nBundleName;
112 NAPI_CALL_RETURN_VOID(
113 env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
114 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "bundleName", nBundleName));
115
116 napi_value nModuleName;
117 NAPI_CALL_RETURN_VOID(
118 env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
119 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "moduleName", nModuleName));
120
121 napi_value nName;
122 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
123 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "name", nName));
124
125 napi_value nLabel;
126 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
127 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "label", nLabel));
128
129 napi_value nLabelId;
130 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.labelId, &nLabelId));
131 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "labelId", nLabelId));
132
133 napi_value nDescription;
134 NAPI_CALL_RETURN_VOID(
135 env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
136 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "description", nDescription));
137
138 napi_value nDescriptionId;
139 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.descriptionId, &nDescriptionId));
140 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "descriptionId", nDescriptionId));
141
142 napi_value nIconPath;
143 NAPI_CALL_RETURN_VOID(
144 env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
145 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "icon", nIconPath));
146
147 napi_value nIconId;
148 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.iconId, &nIconId));
149 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "iconId", nIconId));
150 APP_LOGD("ConvertAbilityInfo done");
151 }
152
ConvertExtensionInfo(napi_env env,napi_value objExtensionInfo,const ExtensionAbilityInfo & extensionInfo)153 static void ConvertExtensionInfo(napi_env env, napi_value objExtensionInfo, const ExtensionAbilityInfo& extensionInfo)
154 {
155 APP_LOGD("begin to ConvertExtensionInfo");
156 napi_value nBundleName;
157 NAPI_CALL_RETURN_VOID(
158 env, napi_create_string_utf8(env, extensionInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
159 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "bundleName", nBundleName));
160
161 napi_value nModuleName;
162 NAPI_CALL_RETURN_VOID(
163 env, napi_create_string_utf8(env, extensionInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
164 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "moduleName", nModuleName));
165
166 napi_value nName;
167 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, extensionInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
168 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "name", nName));
169
170 napi_value nLabelId;
171 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.labelId, &nLabelId));
172 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "labelId", nLabelId));
173
174 napi_value nDescriptionId;
175 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.descriptionId, &nDescriptionId));
176 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "descriptionId", nDescriptionId));
177
178 napi_value nIconId;
179 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.iconId, &nIconId));
180 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, "iconId", nIconId));
181 APP_LOGD("ConvertExtensionInfo done");
182 }
183
ConvertBundleInfo(napi_env env,napi_value objBundleInfo,const BundleInfo & bundleInfo)184 static void ConvertBundleInfo(napi_env env, napi_value objBundleInfo, const BundleInfo &bundleInfo)
185 {
186 APP_LOGD("begin to ConvertBundleInfo");
187 napi_value nName;
188 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
189 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "name", nName));
190
191 napi_value nHapModulesInfo;
192 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nHapModulesInfo));
193 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "hapModulesInfo", nHapModulesInfo));
194
195 napi_value nAbilityInfos;
196 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilityInfos));
197 for (size_t idx = 0; idx < bundleInfo.abilityInfos.size(); idx++) {
198 napi_value objAbilityInfo;
199 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAbilityInfo));
200 ConvertAbilityInfo(env, objAbilityInfo, bundleInfo.abilityInfos[idx]);
201 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilityInfos, idx, objAbilityInfo));
202 }
203
204 napi_value nHapModuleInfo;
205 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nHapModuleInfo));
206 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nHapModulesInfo, 0, nHapModuleInfo));
207
208 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nHapModuleInfo, "abilitiesInfo", nAbilityInfos));
209
210 napi_value nExtensionAbilityInfos;
211 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nExtensionAbilityInfos));
212 for (size_t idx = 0; idx < bundleInfo.extensionInfos.size(); idx++) {
213 napi_value objExtensionInfo;
214 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objExtensionInfo));
215 ConvertExtensionInfo(env, objExtensionInfo, bundleInfo.extensionInfos[idx]);
216 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nExtensionAbilityInfos, idx, objExtensionInfo));
217 }
218
219 NAPI_CALL_RETURN_VOID(env,
220 napi_set_named_property(env, nHapModuleInfo, "extensionAbilitiesInfo", nExtensionAbilityInfos));
221 APP_LOGD("ConvertBundleInfo done");
222 }
223
InnerIsDefaultApplication(DefaultAppCallbackInfo * info)224 static ErrCode InnerIsDefaultApplication(DefaultAppCallbackInfo *info)
225 {
226 if (info == nullptr) {
227 APP_LOGE("info is null");
228 return ERROR_BUNDLE_SERVICE_EXCEPTION;
229 }
230 auto defaultAppProxy = GetDefaultAppProxy();
231 if (defaultAppProxy == nullptr) {
232 APP_LOGE("defaultAppProxy is null");
233 return ERROR_BUNDLE_SERVICE_EXCEPTION;
234 }
235 ErrCode ret = defaultAppProxy->IsDefaultApplication(info->type, info->isDefaultApp);
236 APP_LOGD("IsDefaultApplication ErrCode : %{public}d", ret);
237 return CommonFunc::ConvertErrCode(ret);
238 }
239
IsDefaultApplicationExec(napi_env env,void * data)240 void IsDefaultApplicationExec(napi_env env, void *data)
241 {
242 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
243 if (asyncCallbackInfo == nullptr) {
244 APP_LOGE("asyncCallbackInfo is null");
245 return;
246 }
247 asyncCallbackInfo->err = InnerIsDefaultApplication(asyncCallbackInfo);
248 }
249
IsDefaultApplicationComplete(napi_env env,napi_status status,void * data)250 void IsDefaultApplicationComplete(napi_env env, napi_status status, void *data)
251 {
252 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
253 if (asyncCallbackInfo == nullptr) {
254 APP_LOGE("asyncCallbackInfo is null in %{public}s", __func__);
255 return;
256 }
257 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
258 napi_value result[ARGS_SIZE_TWO] = {0};
259 if (asyncCallbackInfo->err == NO_ERROR) {
260 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
261 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->isDefaultApp, &result[ARGS_POS_ONE]));
262 } else {
263 result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
264 IS_DEFAULT_APPLICATION, "");
265 }
266 if (asyncCallbackInfo->deferred) {
267 if (asyncCallbackInfo->err == NO_ERROR) {
268 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ONE]));
269 } else {
270 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
271 }
272 } else {
273 napi_value callback = nullptr;
274 napi_value placeHolder = nullptr;
275 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
276 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
277 sizeof(result) / sizeof(result[ARGS_POS_ZERO]), result, &placeHolder));
278 }
279 }
280
IsDefaultApplication(napi_env env,napi_callback_info info)281 napi_value IsDefaultApplication(napi_env env, napi_callback_info info)
282 {
283 APP_LOGD("begin of IsDefaultApplication");
284 NapiArg args(env, info);
285 DefaultAppCallbackInfo *asyncCallbackInfo = new (std::nothrow) DefaultAppCallbackInfo(env);
286 if (asyncCallbackInfo == nullptr) {
287 APP_LOGE("asyncCallbackInfo is null");
288 return nullptr;
289 }
290 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
291 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
292 APP_LOGE("param count invalid");
293 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
294 return nullptr;
295 }
296 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
297 napi_valuetype valueType = napi_undefined;
298 napi_typeof(env, args[i], &valueType);
299 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
300 if (!ParseType(env, args[i], asyncCallbackInfo->type)) {
301 APP_LOGE("type invalid!");
302 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
303 return nullptr;
304 }
305 } else if (i == ARGS_POS_ONE) {
306 if (valueType == napi_function) {
307 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
308 }
309 break;
310 } else {
311 APP_LOGE("param check error");
312 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
313 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
314 return nullptr;
315 }
316 }
317 auto promise = CommonFunc::AsyncCallNativeMethod<DefaultAppCallbackInfo>(
318 env, asyncCallbackInfo, IS_DEFAULT_APPLICATION, IsDefaultApplicationExec, IsDefaultApplicationComplete);
319 callbackPtr.release();
320 APP_LOGD("call IsDefaultApplication done");
321 return promise;
322 }
323
InnerGetDefaultApplication(DefaultAppCallbackInfo * info)324 static ErrCode InnerGetDefaultApplication(DefaultAppCallbackInfo *info)
325 {
326 if (info == nullptr) {
327 APP_LOGE("info is null");
328 return ERROR_BUNDLE_SERVICE_EXCEPTION;
329 }
330 auto defaultAppProxy = GetDefaultAppProxy();
331 if (defaultAppProxy == nullptr) {
332 APP_LOGE("defaultAppProxy is null");
333 return ERROR_BUNDLE_SERVICE_EXCEPTION;
334 }
335 ErrCode ret = defaultAppProxy->GetDefaultApplication(info->userId, info->type, info->bundleInfo);
336 APP_LOGD("GetDefaultApplication ErrCode : %{public}d", ret);
337 return CommonFunc::ConvertErrCode(ret);
338 }
339
GetDefaultApplicationExec(napi_env env,void * data)340 void GetDefaultApplicationExec(napi_env env, void *data)
341 {
342 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
343 if (asyncCallbackInfo == nullptr) {
344 APP_LOGE("asyncCallbackInfo is null");
345 return;
346 }
347 asyncCallbackInfo->err = InnerGetDefaultApplication(asyncCallbackInfo);
348 }
349
GetDefaultApplicationComplete(napi_env env,napi_status status,void * data)350 void GetDefaultApplicationComplete(napi_env env, napi_status status, void *data)
351 {
352 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
353 if (asyncCallbackInfo == nullptr) {
354 APP_LOGE("asyncCallbackInfo is null in %{public}s", __func__);
355 return;
356 }
357 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
358 napi_value result[ARGS_SIZE_TWO] = {0};
359 if (asyncCallbackInfo->err == NO_ERROR) {
360 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
361 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[ARGS_POS_ONE]));
362 ConvertBundleInfo(env, result[ARGS_POS_ONE], asyncCallbackInfo->bundleInfo);
363 } else {
364 result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
365 GET_DEFAULT_APPLICATION, Constants::PERMISSION_GET_DEFAULT_APPLICATION);
366 }
367 if (asyncCallbackInfo->deferred) {
368 if (asyncCallbackInfo->err == NO_ERROR) {
369 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ONE]));
370 } else {
371 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
372 }
373 } else {
374 napi_value callback = nullptr;
375 napi_value placeHolder = nullptr;
376 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
377 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
378 sizeof(result) / sizeof(result[ARGS_POS_ZERO]), result, &placeHolder));
379 }
380 }
381
GetDefaultApplication(napi_env env,napi_callback_info info)382 napi_value GetDefaultApplication(napi_env env, napi_callback_info info)
383 {
384 APP_LOGD("begin to GetDefaultApplication");
385 NapiArg args(env, info);
386 DefaultAppCallbackInfo *asyncCallbackInfo = new (std::nothrow) DefaultAppCallbackInfo(env);
387 if (asyncCallbackInfo == nullptr) {
388 APP_LOGE("asyncCallbackInfo is null");
389 return nullptr;
390 }
391 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
392 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
393 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
394 APP_LOGE("param count invalid");
395 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
396 return nullptr;
397 }
398 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
399 napi_valuetype valueType = napi_undefined;
400 napi_typeof(env, args[i], &valueType);
401 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
402 if (!ParseType(env, args[i], asyncCallbackInfo->type)) {
403 APP_LOGE("type invalid!");
404 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
405 return nullptr;
406 }
407 } else if (i == ARGS_POS_ONE) {
408 if (valueType == napi_number) {
409 CommonFunc::ParseInt(env, args[i], asyncCallbackInfo->userId);
410 } else if (valueType == napi_function) {
411 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
412 break;
413 } else {
414 APP_LOGE("param check error");
415 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
416 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
417 return nullptr;
418 }
419 } else if (i == ARGS_POS_TWO) {
420 if (valueType == napi_function) {
421 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
422 }
423 break;
424 } else {
425 APP_LOGE("param check error");
426 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
427 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
428 return nullptr;
429 }
430 }
431 auto promise = CommonFunc::AsyncCallNativeMethod<DefaultAppCallbackInfo>(
432 env, asyncCallbackInfo, GET_DEFAULT_APPLICATION, GetDefaultApplicationExec, GetDefaultApplicationComplete);
433 callbackPtr.release();
434 APP_LOGD("call GetDefaultApplication done");
435 return promise;
436 }
437
InnerSetDefaultApplication(const DefaultAppCallbackInfo * info)438 static ErrCode InnerSetDefaultApplication(const DefaultAppCallbackInfo *info)
439 {
440 if (info == nullptr) {
441 APP_LOGE("info is null");
442 return ERROR_BUNDLE_SERVICE_EXCEPTION;
443 }
444 auto defaultAppProxy = GetDefaultAppProxy();
445 if (defaultAppProxy == nullptr) {
446 APP_LOGE("defaultAppProxy is null");
447 return ERROR_BUNDLE_SERVICE_EXCEPTION;
448 }
449 ErrCode ret = defaultAppProxy->SetDefaultApplication(info->userId, info->type, info->want);
450 APP_LOGD("SetDefaultApplication ErrCode : %{public}d", ret);
451 return CommonFunc::ConvertErrCode(ret);
452 }
453
SetDefaultApplicationExec(napi_env env,void * data)454 void SetDefaultApplicationExec(napi_env env, void *data)
455 {
456 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
457 if (asyncCallbackInfo == nullptr) {
458 APP_LOGE("asyncCallbackInfo is null");
459 return;
460 }
461 asyncCallbackInfo->err = InnerSetDefaultApplication(asyncCallbackInfo);
462 }
463
SetDefaultApplicationComplete(napi_env env,napi_status status,void * data)464 void SetDefaultApplicationComplete(napi_env env, napi_status status, void *data)
465 {
466 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
467 if (asyncCallbackInfo == nullptr) {
468 APP_LOGE("asyncCallbackInfo is null in %{public}s", __func__);
469 return;
470 }
471 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
472 napi_value result[ARGS_SIZE_ONE] = {0};
473 if (asyncCallbackInfo->err == NO_ERROR) {
474 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
475 } else {
476 result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
477 SET_DEFAULT_APPLICATION, Constants::PERMISSION_SET_DEFAULT_APPLICATION);
478 }
479 if (asyncCallbackInfo->deferred) {
480 if (asyncCallbackInfo->err == NO_ERROR) {
481 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
482 } else {
483 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
484 }
485 } else {
486 napi_value callback = nullptr;
487 napi_value placeHolder = nullptr;
488 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
489 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
490 sizeof(result) / sizeof(result[ARGS_POS_ZERO]), result, &placeHolder));
491 }
492 }
493
SetDefaultApplication(napi_env env,napi_callback_info info)494 napi_value SetDefaultApplication(napi_env env, napi_callback_info info)
495 {
496 APP_LOGD("begin to SetDefaultApplication");
497 NapiArg args(env, info);
498 DefaultAppCallbackInfo *asyncCallbackInfo = new (std::nothrow) DefaultAppCallbackInfo(env);
499 if (asyncCallbackInfo == nullptr) {
500 APP_LOGE("asyncCallbackInfo is null");
501 return nullptr;
502 }
503 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
504 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
505 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_FOUR)) {
506 APP_LOGE("param count invalid");
507 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
508 return nullptr;
509 }
510 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
511 napi_valuetype valueType = napi_undefined;
512 napi_typeof(env, args[i], &valueType);
513 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
514 if (!ParseType(env, args[i], asyncCallbackInfo->type)) {
515 APP_LOGE("type invalid!");
516 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
517 return nullptr;
518 }
519 } else if ((i == ARGS_POS_ONE) && (valueType == napi_object)) {
520 if (!CommonFunc::ParseElementName(env, args[i], asyncCallbackInfo->want)) {
521 APP_LOGE("invalid elementName");
522 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
523 return nullptr;
524 }
525 } else if (i == ARGS_POS_TWO) {
526 if (valueType == napi_number) {
527 CommonFunc::ParseInt(env, args[i], asyncCallbackInfo->userId);
528 } else if (valueType == napi_function) {
529 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
530 break;
531 } else {
532 APP_LOGE("param check error");
533 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
534 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
535 return nullptr;
536 }
537 } else if (i == ARGS_POS_THREE) {
538 if (valueType == napi_function) {
539 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
540 }
541 break;
542 } else {
543 APP_LOGE("param check error");
544 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
545 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
546 return nullptr;
547 }
548 }
549 auto promise = CommonFunc::AsyncCallNativeMethod<DefaultAppCallbackInfo>(
550 env, asyncCallbackInfo, SET_DEFAULT_APPLICATION, SetDefaultApplicationExec, SetDefaultApplicationComplete);
551 callbackPtr.release();
552 APP_LOGD("call SetDefaultApplication done");
553 return promise;
554 }
555
InnerResetDefaultApplication(const DefaultAppCallbackInfo * info)556 static ErrCode InnerResetDefaultApplication(const DefaultAppCallbackInfo *info)
557 {
558 if (info == nullptr) {
559 APP_LOGE("info is null");
560 return ERROR_BUNDLE_SERVICE_EXCEPTION;
561 }
562 auto defaultAppProxy = GetDefaultAppProxy();
563 if (defaultAppProxy == nullptr) {
564 APP_LOGE("defaultAppProxy is null");
565 return ERROR_BUNDLE_SERVICE_EXCEPTION;
566 }
567 ErrCode ret = defaultAppProxy->ResetDefaultApplication(info->userId, info->type);
568 APP_LOGD("ResetDefaultApplication ErrCode : %{public}d", ret);
569 return CommonFunc::ConvertErrCode(ret);
570 }
571
ResetDefaultApplicationExec(napi_env env,void * data)572 void ResetDefaultApplicationExec(napi_env env, void *data)
573 {
574 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
575 if (asyncCallbackInfo == nullptr) {
576 APP_LOGE("asyncCallbackInfo is null");
577 return;
578 }
579 asyncCallbackInfo->err = InnerResetDefaultApplication(asyncCallbackInfo);
580 }
581
ResetDefaultApplicationComplete(napi_env env,napi_status status,void * data)582 void ResetDefaultApplicationComplete(napi_env env, napi_status status, void *data)
583 {
584 DefaultAppCallbackInfo *asyncCallbackInfo = reinterpret_cast<DefaultAppCallbackInfo *>(data);
585 if (asyncCallbackInfo == nullptr) {
586 APP_LOGE("asyncCallbackInfo is null in %{public}s", __func__);
587 return;
588 }
589 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
590 napi_value result[ARGS_SIZE_ONE] = {0};
591 if (asyncCallbackInfo->err == NO_ERROR) {
592 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
593 } else {
594 result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
595 RESET_DEFAULT_APPLICATION, Constants::PERMISSION_SET_DEFAULT_APPLICATION);
596 }
597 if (asyncCallbackInfo->deferred) {
598 if (asyncCallbackInfo->err == NO_ERROR) {
599 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
600 } else {
601 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
602 }
603 } else {
604 napi_value callback = nullptr;
605 napi_value placeHolder = nullptr;
606 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
607 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
608 sizeof(result) / sizeof(result[ARGS_POS_ZERO]), result, &placeHolder));
609 }
610 }
611
ResetDefaultApplication(napi_env env,napi_callback_info info)612 napi_value ResetDefaultApplication(napi_env env, napi_callback_info info)
613 {
614 APP_LOGD("begin to ResetDefaultApplication");
615 NapiArg args(env, info);
616 DefaultAppCallbackInfo *asyncCallbackInfo = new (std::nothrow) DefaultAppCallbackInfo(env);
617 if (asyncCallbackInfo == nullptr) {
618 APP_LOGE("asyncCallbackInfo is null");
619 return nullptr;
620 }
621 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
622 std::unique_ptr<DefaultAppCallbackInfo> callbackPtr {asyncCallbackInfo};
623 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
624 APP_LOGE("param count invalid");
625 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
626 return nullptr;
627 }
628 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
629 napi_valuetype valueType = napi_undefined;
630 napi_typeof(env, args[i], &valueType);
631 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
632 if (!ParseType(env, args[i], asyncCallbackInfo->type)) {
633 APP_LOGE("type invalid!");
634 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
635 return nullptr;
636 }
637 } else if (i == ARGS_POS_ONE) {
638 if (valueType == napi_number) {
639 CommonFunc::ParseInt(env, args[i], asyncCallbackInfo->userId);
640 } else if (valueType == napi_function) {
641 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
642 break;
643 } else {
644 APP_LOGE("param check error");
645 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
646 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
647 return nullptr;
648 }
649 } else if (i == ARGS_POS_TWO) {
650 if (valueType == napi_function) {
651 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
652 }
653 break;
654 } else {
655 APP_LOGE("param check error");
656 std::string errMsg = PARAM_TYPE_CHECK_ERROR_WITH_POS + std::to_string(i + 1);
657 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, errMsg);
658 return nullptr;
659 }
660 }
661 auto promise = CommonFunc::AsyncCallNativeMethod<DefaultAppCallbackInfo>(env,
662 asyncCallbackInfo, RESET_DEFAULT_APPLICATION, ResetDefaultApplicationExec, ResetDefaultApplicationComplete);
663 callbackPtr.release();
664 APP_LOGD("call ResetDefaultApplication done");
665 return promise;
666 }
667 }
668 }
669