1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "application_manager_addon.h"
17 #include "edm_constants.h"
18 #include "edm_log.h"
19 #ifdef OS_ACCOUNT_EDM_ENABLE
20 #include "os_account_manager.h"
21 #endif
22
23 using namespace OHOS::EDM;
24
Init(napi_env env,napi_value exports)25 napi_value ApplicationManagerAddon::Init(napi_env env, napi_value exports)
26 {
27 napi_property_descriptor property[] = {
28 DECLARE_NAPI_FUNCTION("addDisallowedRunningBundles", AddDisallowedRunningBundles),
29 DECLARE_NAPI_FUNCTION("removeDisallowedRunningBundles", RemoveDisallowedRunningBundles),
30 DECLARE_NAPI_FUNCTION("getDisallowedRunningBundles", GetDisallowedRunningBundles),
31 DECLARE_NAPI_FUNCTION("addAutoStartApps", AddAutoStartApps),
32 DECLARE_NAPI_FUNCTION("removeAutoStartApps", RemoveAutoStartApps),
33 DECLARE_NAPI_FUNCTION("getAutoStartApps", GetAutoStartApps),
34 DECLARE_NAPI_FUNCTION("addDisallowedRunningBundlesSync", AddDisallowedRunningBundlesSync),
35 DECLARE_NAPI_FUNCTION("removeDisallowedRunningBundlesSync", RemoveDisallowedRunningBundlesSync),
36 DECLARE_NAPI_FUNCTION("getDisallowedRunningBundlesSync", GetDisallowedRunningBundlesSync),
37 };
38 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
39 return exports;
40 }
41
AddAutoStartApps(napi_env env,napi_callback_info info)42 napi_value ApplicationManagerAddon::AddAutoStartApps(napi_env env, napi_callback_info info)
43 {
44 return AddOrRemoveAutoStartApps(env, info, "AddAutoStartApps");
45 }
46
RemoveAutoStartApps(napi_env env,napi_callback_info info)47 napi_value ApplicationManagerAddon::RemoveAutoStartApps(napi_env env, napi_callback_info info)
48 {
49 return AddOrRemoveAutoStartApps(env, info, "RemoveAutoStartApps");
50 }
51
AddOrRemoveAutoStartApps(napi_env env,napi_callback_info info,std::string function)52 napi_value ApplicationManagerAddon::AddOrRemoveAutoStartApps(napi_env env, napi_callback_info info,
53 std::string function)
54 {
55 EDMLOGI("NAPI_AddOrRemoveAutoStartApps called");
56 size_t argc = ARGS_SIZE_TWO;
57 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
58 napi_value thisArg = nullptr;
59 void *data = nullptr;
60 OHOS::AppExecFwk::ElementName elementName;
61
62 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
63 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
64 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
65 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
66 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
67 "element name param error");
68 std::vector<AppExecFwk::ElementName> autoStartApps;
69 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementArray(env, autoStartApps, argv[ARR_INDEX_ONE]),
70 "Parameter autoStartApps error");
71 EDMLOGD(
72 "EnableAdmin: elementName.bundlename %{public}s, "
73 "elementName.abilityname:%{public}s",
74 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
75 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
76 int32_t ret = 0;
77 if (function == "AddAutoStartApps") {
78 ret = applicationManagerProxy->AddAutoStartApps(elementName, autoStartApps);
79 } else {
80 ret = applicationManagerProxy->RemoveAutoStartApps(elementName, autoStartApps);
81 }
82 if (FAILED(ret)) {
83 napi_throw(env, CreateError(env, ret));
84 }
85 return nullptr;
86 }
87
GetAutoStartApps(napi_env env,napi_callback_info info)88 napi_value ApplicationManagerAddon::GetAutoStartApps(napi_env env, napi_callback_info info)
89 {
90 EDMLOGI("NAPI_GetAutoStartApps called");
91 size_t argc = ARGS_SIZE_ONE;
92 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
93 napi_value thisArg = nullptr;
94 void *data = nullptr;
95 OHOS::AppExecFwk::ElementName elementName;
96
97 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
98 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
99 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
100 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
101 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
102 "element name param error");
103 EDMLOGD(
104 "EnableAdmin: elementName.bundlename %{public}s, "
105 "elementName.abilityname:%{public}s",
106 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
107 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
108 std::vector<OHOS::AppExecFwk::ElementName> autoStartApps;
109 int32_t ret = applicationManagerProxy->GetAutoStartApps(elementName, autoStartApps);
110 if (FAILED(ret)) {
111 napi_throw(env, CreateError(env, ret));
112 return nullptr;
113 }
114 napi_value napiAutoStartApps = nullptr;
115 napi_create_array(env, &napiAutoStartApps);
116 size_t idx = 0;
117 for (const auto &element : autoStartApps) {
118 napi_value objAutoStartApps = nullptr;
119 NAPI_CALL(env, napi_create_object(env, &objAutoStartApps));
120 napi_value napi_bundleName;
121 napi_value napi_abilityName;
122 NAPI_CALL(env, napi_create_string_utf8(env, element.GetBundleName().c_str(),
123 element.GetBundleName().size(), &napi_bundleName));
124 NAPI_CALL(env, napi_create_string_utf8(env, element.GetAbilityName().c_str(),
125 element.GetAbilityName().size(), &napi_abilityName));
126 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "bundleName", napi_bundleName));
127 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "abilityName", napi_abilityName));
128 napi_set_element(env, napiAutoStartApps, idx, objAutoStartApps);
129 idx++;
130 }
131 return napiAutoStartApps;
132 }
133
GetDisallowedRunningBundles(napi_env env,napi_callback_info info)134 napi_value ApplicationManagerAddon::GetDisallowedRunningBundles(napi_env env, napi_callback_info info)
135 {
136 EDMLOGI("NAPI_GetDisallowedRunningBundles called");
137 size_t argc = ARGS_SIZE_THREE;
138 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
139 napi_value thisArg = nullptr;
140 void *data = nullptr;
141 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
142 bool hasCallback = false;
143 bool hasUserId = false;
144 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
145 if (asyncCallbackInfo == nullptr) {
146 return nullptr;
147 }
148 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
149 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
150 ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
151 "Parameter type error");
152 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
153 "Parameter want error");
154
155 EDMLOGD("GetDisallowedRunningBundles::asyncCallbackInfo->elementName.bundlename %{public}s, "
156 "asyncCallbackInfo->abilityname:%{public}s",
157 asyncCallbackInfo->elementName.GetBundleName().c_str(),
158 asyncCallbackInfo->elementName.GetAbilityName().c_str());
159 if (hasUserId) {
160 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
161 "Parameter user id error");
162 } else {
163 #ifdef OS_ACCOUNT_EDM_ENABLE
164 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
165 #endif
166 }
167 if (hasCallback) {
168 ASSERT_AND_THROW_PARAM_ERROR(env,
169 ParseCallback(env, asyncCallbackInfo->callback,
170 argc <= ARR_INDEX_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
171 "Parameter callback error");
172 }
173 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetDisallowedRunningBundles",
174 NativeGetDisallowedRunningBundles, NativeArrayStringCallbackComplete);
175 callbackPtr.release();
176 return asyncWorkReturn;
177 }
178
NativeGetDisallowedRunningBundles(napi_env env,void * data)179 void ApplicationManagerAddon::NativeGetDisallowedRunningBundles(napi_env env, void *data)
180 {
181 EDMLOGI("NAPI_NativeGetDisallowedRunningBundles called");
182 if (data == nullptr) {
183 EDMLOGE("data is nullptr");
184 return;
185 }
186 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
187 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
188 auto proxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
189 if (proxy_ == nullptr) {
190 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
191 return;
192 }
193
194 asyncCallbackInfo->ret = proxy_->GetDisallowedRunningBundles(asyncCallbackInfo->elementName,
195 asyncCallbackInfo->userId, asyncCallbackInfo->arrayStringRet);
196 }
197
AddDisallowedRunningBundles(napi_env env,napi_callback_info info)198 napi_value ApplicationManagerAddon::AddDisallowedRunningBundles(napi_env env, napi_callback_info info)
199 {
200 return AddOrRemovellowedRunningBundles(env, info, "AddDisallowedRunningBundles", NativeAddDisallowedRunningBundles);
201 }
202
RemoveDisallowedRunningBundles(napi_env env,napi_callback_info info)203 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundles(napi_env env, napi_callback_info info)
204 {
205 return AddOrRemovellowedRunningBundles(env, info, "RemoveDisallowedRunningBundles",
206 NativeRemoveDisallowedRunningBundles);
207 }
208
NativeAddDisallowedRunningBundles(napi_env env,void * data)209 void ApplicationManagerAddon::NativeAddDisallowedRunningBundles(napi_env env, void *data)
210 {
211 EDMLOGI("NAPI_NativeAddDisallowedRunningBundles called");
212 if (data == nullptr) {
213 EDMLOGE("data is nullptr");
214 return;
215 }
216 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
217 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
218 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
219 if (applicationManagerProxy_ == nullptr) {
220 EDMLOGE("can not get applicationManagerProxy");
221 return;
222 }
223 asyncCallbackInfo->ret = applicationManagerProxy_->AddDisallowedRunningBundles(asyncCallbackInfo->elementName,
224 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
225 }
226
CheckAddDisallowedRunningBundlesParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)227 bool ApplicationManagerAddon::CheckAddDisallowedRunningBundlesParamType(napi_env env, size_t argc,
228 napi_value* argv, bool &hasCallback, bool &hasUserId)
229 {
230 if (!MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) || !MatchValueType(env, argv[ARR_INDEX_ONE],
231 napi_object)) {
232 EDMLOGE("CheckAddDisallowedRunningBundlesParamType admin or array type check failed");
233 return false;
234 }
235 EDMLOGI("CheckAddDisallowedRunningBundlesParamType argc = %{public}zu", argc);
236 if (argc == ARGS_SIZE_TWO) {
237 hasCallback = false;
238 hasUserId = false;
239 EDMLOGI("hasCallback = false; hasUserId = false;");
240 return true;
241 }
242
243 if (argc == ARGS_SIZE_THREE) {
244 if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_function)) {
245 hasCallback = true;
246 hasUserId = false;
247 EDMLOGI("hasCallback = true; hasUserId = false;");
248 return true;
249 } else {
250 hasCallback = false;
251 hasUserId = true;
252 EDMLOGI("hasCallback = false; hasUserId = true;");
253 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
254 }
255 }
256 hasCallback = true;
257 hasUserId = true;
258 EDMLOGI("hasCallback = true; hasUserId = true;");
259 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
260 MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
261 }
262
AddOrRemovellowedRunningBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)263 napi_value ApplicationManagerAddon::AddOrRemovellowedRunningBundles(napi_env env, napi_callback_info info,
264 const std::string &workName, napi_async_execute_callback execute)
265 {
266 size_t argc = ARGS_SIZE_FOUR;
267 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
268 napi_value thisArg = nullptr;
269 void *data = nullptr;
270 bool hasCallback = false;
271 bool hasUserId = false;
272 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
273 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
274 if (asyncCallbackInfo == nullptr) {
275 return nullptr;
276 }
277 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
278 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
279 ASSERT_AND_THROW_PARAM_ERROR(env,
280 CheckAddDisallowedRunningBundlesParamType(env, argc, argv, hasCallback, hasUserId), "Parameter type error");
281 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
282 "Parameter want error");
283 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->appIds, argv[ARR_INDEX_ONE]),
284 "Parameter bundles error");
285 ASSERT_AND_THROW_PARAM_ERROR(env, asyncCallbackInfo->appIds.size() <= EdmConstants::APPID_MAX_SIZE,
286 "Parameter bundles too large");
287 EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
288 "asyncCallbackInfo->abilityname:%{public}s",
289 asyncCallbackInfo->elementName.GetBundleName().c_str(),
290 asyncCallbackInfo->elementName.GetAbilityName().c_str());
291 if (hasUserId) {
292 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
293 "Parameter user id error");
294 } else {
295 #ifdef OS_ACCOUNT_EDM_ENABLE
296 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
297 #endif
298 }
299 if (hasCallback) {
300 ASSERT_AND_THROW_PARAM_ERROR(env,
301 ParseCallback(env, asyncCallbackInfo->callback,
302 argc <= ARR_INDEX_FOUR ? argv[argc - 1] : argv[ARR_INDEX_THREE]),
303 "Parameter callback error");
304 }
305 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, workName,
306 execute, NativeVoidCallbackComplete);
307 callbackPtr.release();
308 return asyncWorkReturn;
309 }
310
NativeRemoveDisallowedRunningBundles(napi_env env,void * data)311 void ApplicationManagerAddon::NativeRemoveDisallowedRunningBundles(napi_env env, void *data)
312 {
313 EDMLOGI("NativeRemoveDisallowedRunningBundles called");
314 if (data == nullptr) {
315 EDMLOGE("data is nullptr");
316 return;
317 }
318 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
319 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
320 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
321 if (applicationManagerProxy_ == nullptr) {
322 EDMLOGE("can not get ApplicationManagerProxy");
323 return;
324 }
325 asyncCallbackInfo->ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(asyncCallbackInfo->elementName,
326 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
327 }
328
AddDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)329 napi_value ApplicationManagerAddon::AddDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
330 {
331 return AddOrRemoveDisallowedRunningBundlesSync(env, info, true);
332 }
333
RemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)334 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
335 {
336 return AddOrRemoveDisallowedRunningBundlesSync(env, info, false);
337 }
338
AddOrRemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info,bool isAdd)339 napi_value ApplicationManagerAddon::AddOrRemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info,
340 bool isAdd)
341 {
342 EDMLOGI("NAPI_AddOrRemoveDisallowedRunningBundlesSync called");
343 size_t argc = ARGS_SIZE_THREE;
344 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
345 napi_value thisArg = nullptr;
346 void *data = nullptr;
347 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
348
349 bool hasAccountId = (argc == ARGS_SIZE_THREE);
350 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
351 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
352 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter appIds error");
353 OHOS::AppExecFwk::ElementName elementName;
354 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
355 "parameter admin parse error");
356 std::vector<std::string> appIds;
357 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, appIds, argv[ARR_INDEX_ONE]),
358 "parameter appIds parse error");
359 EDMLOGD("AddOrRemoveDisallowedRunningBundlesSync: "
360 "elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
361 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
362 int32_t accountId = 0;
363 if (hasAccountId) {
364 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
365 "parameter accountId error");
366 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
367 "parameter accountId parse error");
368 } else {
369 #ifdef OS_ACCOUNT_EDM_ENABLE
370 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
371 #endif
372 }
373
374 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
375 if (applicationManagerProxy == nullptr) {
376 EDMLOGE("can not get applicationManagerProxy");
377 return nullptr;
378 }
379 int32_t ret = ERR_OK;
380 if (isAdd) {
381 ret = applicationManagerProxy->AddDisallowedRunningBundles(elementName, appIds, accountId, true);
382 } else {
383 ret = applicationManagerProxy->RemoveDisallowedRunningBundles(elementName, appIds, accountId, true);
384 }
385 if (FAILED(ret)) {
386 napi_throw(env, CreateError(env, ret));
387 }
388 return nullptr;
389 }
390
GetDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)391 napi_value ApplicationManagerAddon::GetDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
392 {
393 EDMLOGI("NAPI_GetDisallowedRunningBundlesSync called");
394 size_t argc = ARGS_SIZE_TWO;
395 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
396 napi_value thisArg = nullptr;
397 void *data = nullptr;
398 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
399 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
400 bool hasAccountId = (argc == ARGS_SIZE_TWO);
401 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
402 OHOS::AppExecFwk::ElementName elementName;
403 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
404 "parameter admin parse error");
405 EDMLOGD("GetDisallowedRunningBundlesSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
406 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
407 int32_t accountId = 0;
408 if (hasAccountId) {
409 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
410 "parameter accountId error");
411 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
412 "parameter accountId parse error");
413 } else {
414 #ifdef OS_ACCOUNT_EDM_ENABLE
415 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
416 #endif
417 }
418
419 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
420 if (applicationManagerProxy == nullptr) {
421 EDMLOGE("can not get applicationManagerProxy");
422 return nullptr;
423 }
424 std::vector<std::string> appIds;
425 int32_t ret = applicationManagerProxy->GetDisallowedRunningBundles(elementName, accountId, appIds, true);
426 if (FAILED(ret)) {
427 napi_throw(env, CreateError(env, ret));
428 return nullptr;
429 }
430 napi_value result = nullptr;
431 napi_create_array(env, &result);
432 ConvertStringVectorToJS(env, appIds, result);
433 return result;
434 }
435
436 static napi_module g_applicationManagerModule = {
437 .nm_version = 1,
438 .nm_flags = 0,
439 .nm_filename = nullptr,
440 .nm_register_func = ApplicationManagerAddon::Init,
441 .nm_modname = "enterprise.applicationManager",
442 .nm_priv = ((void *)0),
443 .reserved = { 0 },
444 };
445
ApplicationManagerRegister()446 extern "C" __attribute__((constructor)) void ApplicationManagerRegister()
447 {
448 napi_module_register(&g_applicationManagerModule);
449 }