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         DECLARE_NAPI_FUNCTION("addKeepAliveApps", AddKeepAliveApps),
38         DECLARE_NAPI_FUNCTION("removeKeepAliveApps", RemoveKeepAliveApps),
39         DECLARE_NAPI_FUNCTION("getKeepAliveApps", GetKeepAliveApps),
40     };
41     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
42     return exports;
43 }
44 
AddKeepAliveApps(napi_env env,napi_callback_info info)45 napi_value ApplicationManagerAddon::AddKeepAliveApps(napi_env env, napi_callback_info info)
46 {
47     EDMLOGI("NAPI_AddKeepAliveApps called");
48     return AddOrRemoveKeepAliveApps(env, info, "AddKeepAliveApps");
49 }
50 
RemoveKeepAliveApps(napi_env env,napi_callback_info info)51 napi_value ApplicationManagerAddon::RemoveKeepAliveApps(napi_env env, napi_callback_info info)
52 {
53     EDMLOGI("NAPI_RemoveKeepAliveApps called");
54     return AddOrRemoveKeepAliveApps(env, info, "RemoveKeepAliveApps");
55 }
56 
AddOrRemoveKeepAliveApps(napi_env env,napi_callback_info info,std::string function)57 napi_value ApplicationManagerAddon::AddOrRemoveKeepAliveApps(napi_env env, napi_callback_info info,
58     std::string function)
59 {
60     EDMLOGI("NAPI_AddOrRemoveKeepAliveApps called");
61     size_t argc = ARGS_SIZE_THREE;
62     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
63     napi_value thisArg = nullptr;
64     void *data = nullptr;
65     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
66     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
67 
68     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
69     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
70     OHOS::AppExecFwk::ElementName elementName;
71     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
72         "Parameter elementName error");
73 
74     std::vector<std::string> keepAliveApps;
75     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, keepAliveApps, argv[ARR_INDEX_ONE]),
76         "Parameter keepAliveApps error");
77     int32_t userId = 0;
78     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_TWO]), "Parameter userId error");
79     EDMLOGD(
80         "EnableAdmin: elementName.bundlename %{public}s, "
81         "elementName.abilityname:%{public}s",
82         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
83 
84     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
85     return nullptr;
86 }
87 
GetKeepAliveApps(napi_env env,napi_callback_info info)88 napi_value ApplicationManagerAddon::GetKeepAliveApps(napi_env env, napi_callback_info info)
89 {
90     EDMLOGI("NAPI_GetKeepAliveApps called");
91     size_t argc = ARGS_SIZE_TWO;
92     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
93     napi_value thisArg = nullptr;
94     void *data = nullptr;
95     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
96     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
97     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
98     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
99 
100     OHOS::AppExecFwk::ElementName elementName;
101     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
102         "Parameter elementName error");
103     int32_t userId = 0;
104     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "Parameter userId error");
105     EDMLOGD(
106         "EnableAdmin: elementName.bundlename %{public}s, "
107         "elementName.abilityname:%{public}s",
108         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
109 
110     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
111     napi_value napiKeepAliveApps = nullptr;
112     NAPI_CALL(env, napi_create_array(env, &napiKeepAliveApps));
113     return napiKeepAliveApps;
114 }
115 
AddAutoStartApps(napi_env env,napi_callback_info info)116 napi_value ApplicationManagerAddon::AddAutoStartApps(napi_env env, napi_callback_info info)
117 {
118     return AddOrRemoveAutoStartApps(env, info, "AddAutoStartApps");
119 }
120 
RemoveAutoStartApps(napi_env env,napi_callback_info info)121 napi_value ApplicationManagerAddon::RemoveAutoStartApps(napi_env env, napi_callback_info info)
122 {
123     return AddOrRemoveAutoStartApps(env, info, "RemoveAutoStartApps");
124 }
125 
AddOrRemoveAutoStartApps(napi_env env,napi_callback_info info,std::string function)126 napi_value ApplicationManagerAddon::AddOrRemoveAutoStartApps(napi_env env, napi_callback_info info,
127     std::string function)
128 {
129     EDMLOGI("NAPI_AddOrRemoveAutoStartApps called");
130     size_t argc = ARGS_SIZE_TWO;
131     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
132     napi_value thisArg = nullptr;
133     void *data = nullptr;
134     OHOS::AppExecFwk::ElementName elementName;
135 
136     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
137     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
138     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
139     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
140     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
141         "element name param error");
142     std::vector<AppExecFwk::ElementName> autoStartApps;
143     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementArray(env, autoStartApps, argv[ARR_INDEX_ONE]),
144         "Parameter autoStartApps error");
145     EDMLOGD(
146         "EnableAdmin: elementName.bundlename %{public}s, "
147         "elementName.abilityname:%{public}s",
148         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
149     auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
150     int32_t ret = 0;
151     if (function == "AddAutoStartApps") {
152         ret = applicationManagerProxy->AddAutoStartApps(elementName, autoStartApps);
153     } else {
154         ret = applicationManagerProxy->RemoveAutoStartApps(elementName, autoStartApps);
155     }
156     if (FAILED(ret)) {
157         napi_throw(env, CreateError(env, ret));
158     }
159     return nullptr;
160 }
161 
GetAutoStartApps(napi_env env,napi_callback_info info)162 napi_value ApplicationManagerAddon::GetAutoStartApps(napi_env env, napi_callback_info info)
163 {
164     EDMLOGI("NAPI_GetAutoStartApps called");
165     size_t argc = ARGS_SIZE_ONE;
166     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
167     napi_value thisArg = nullptr;
168     void *data = nullptr;
169     OHOS::AppExecFwk::ElementName elementName;
170 
171     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
172     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
173     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
174     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
175     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
176         "element name param error");
177     EDMLOGD(
178         "EnableAdmin: elementName.bundlename %{public}s, "
179         "elementName.abilityname:%{public}s",
180         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
181     auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
182     std::vector<OHOS::AppExecFwk::ElementName> autoStartApps;
183     int32_t ret = applicationManagerProxy->GetAutoStartApps(elementName, autoStartApps);
184     if (FAILED(ret)) {
185         napi_throw(env, CreateError(env, ret));
186         return nullptr;
187     }
188     napi_value napiAutoStartApps = nullptr;
189     napi_create_array(env, &napiAutoStartApps);
190     size_t idx = 0;
191     for (const auto &element : autoStartApps) {
192         napi_value objAutoStartApps = nullptr;
193         NAPI_CALL(env, napi_create_object(env, &objAutoStartApps));
194         napi_value napi_bundleName;
195         napi_value napi_abilityName;
196         NAPI_CALL(env, napi_create_string_utf8(env, element.GetBundleName().c_str(),
197             element.GetBundleName().size(), &napi_bundleName));
198         NAPI_CALL(env, napi_create_string_utf8(env, element.GetAbilityName().c_str(),
199             element.GetAbilityName().size(), &napi_abilityName));
200         NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "bundleName", napi_bundleName));
201         NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "abilityName", napi_abilityName));
202         napi_set_element(env, napiAutoStartApps, idx, objAutoStartApps);
203         idx++;
204     }
205     return napiAutoStartApps;
206 }
207 
GetDisallowedRunningBundles(napi_env env,napi_callback_info info)208 napi_value ApplicationManagerAddon::GetDisallowedRunningBundles(napi_env env, napi_callback_info info)
209 {
210     EDMLOGI("NAPI_GetDisallowedRunningBundles called");
211     size_t argc = ARGS_SIZE_THREE;
212     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
213     napi_value thisArg = nullptr;
214     void *data = nullptr;
215     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
216     bool hasCallback = false;
217     bool hasUserId = false;
218     auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
219     if (asyncCallbackInfo == nullptr) {
220         return nullptr;
221     }
222     std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
223     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
224     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
225         "Parameter type error");
226     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
227         "Parameter want error");
228 
229     EDMLOGD("GetDisallowedRunningBundles::asyncCallbackInfo->elementName.bundlename %{public}s, "
230         "asyncCallbackInfo->abilityname:%{public}s",
231         asyncCallbackInfo->elementName.GetBundleName().c_str(),
232         asyncCallbackInfo->elementName.GetAbilityName().c_str());
233     if (hasUserId) {
234         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
235             "Parameter user id error");
236     } else {
237 #ifdef OS_ACCOUNT_EDM_ENABLE
238         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
239 #endif
240     }
241     if (hasCallback) {
242         ASSERT_AND_THROW_PARAM_ERROR(env,
243             ParseCallback(env, asyncCallbackInfo->callback,
244                 argc <= ARR_INDEX_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
245             "Parameter callback error");
246     }
247     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetDisallowedRunningBundles",
248         NativeGetDisallowedRunningBundles, NativeArrayStringCallbackComplete);
249     callbackPtr.release();
250     return asyncWorkReturn;
251 }
252 
NativeGetDisallowedRunningBundles(napi_env env,void * data)253 void ApplicationManagerAddon::NativeGetDisallowedRunningBundles(napi_env env, void *data)
254 {
255     EDMLOGI("NAPI_NativeGetDisallowedRunningBundles called");
256     if (data == nullptr) {
257         EDMLOGE("data is nullptr");
258         return;
259     }
260     AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
261         static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
262     auto proxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
263     if (proxy_ == nullptr) {
264         EDMLOGE("can not get EnterpriseDeviceMgrProxy");
265         return;
266     }
267 
268     asyncCallbackInfo->ret = proxy_->GetDisallowedRunningBundles(asyncCallbackInfo->elementName,
269         asyncCallbackInfo->userId, asyncCallbackInfo->arrayStringRet);
270 }
271 
AddDisallowedRunningBundles(napi_env env,napi_callback_info info)272 napi_value ApplicationManagerAddon::AddDisallowedRunningBundles(napi_env env, napi_callback_info info)
273 {
274     return AddOrRemovellowedRunningBundles(env, info, "AddDisallowedRunningBundles", NativeAddDisallowedRunningBundles);
275 }
276 
RemoveDisallowedRunningBundles(napi_env env,napi_callback_info info)277 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundles(napi_env env, napi_callback_info info)
278 {
279     return AddOrRemovellowedRunningBundles(env, info, "RemoveDisallowedRunningBundles",
280         NativeRemoveDisallowedRunningBundles);
281 }
282 
NativeAddDisallowedRunningBundles(napi_env env,void * data)283 void ApplicationManagerAddon::NativeAddDisallowedRunningBundles(napi_env env, void *data)
284 {
285     EDMLOGI("NAPI_NativeAddDisallowedRunningBundles called");
286     if (data == nullptr) {
287         EDMLOGE("data is nullptr");
288         return;
289     }
290     AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
291         static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
292     auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
293     if (applicationManagerProxy_ == nullptr) {
294         EDMLOGE("can not get applicationManagerProxy");
295         return;
296     }
297     asyncCallbackInfo->ret = applicationManagerProxy_->AddDisallowedRunningBundles(asyncCallbackInfo->elementName,
298         asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
299 }
300 
CheckAddDisallowedRunningBundlesParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)301 bool ApplicationManagerAddon::CheckAddDisallowedRunningBundlesParamType(napi_env env, size_t argc,
302     napi_value* argv, bool &hasCallback, bool &hasUserId)
303 {
304     if (!MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) || !MatchValueType(env, argv[ARR_INDEX_ONE],
305         napi_object)) {
306         EDMLOGE("CheckAddDisallowedRunningBundlesParamType admin or array type check failed");
307         return false;
308     }
309     EDMLOGI("CheckAddDisallowedRunningBundlesParamType argc = %{public}zu", argc);
310     if (argc == ARGS_SIZE_TWO) {
311         hasCallback = false;
312         hasUserId = false;
313         EDMLOGI("hasCallback = false; hasUserId = false;");
314         return true;
315     }
316 
317     if (argc == ARGS_SIZE_THREE) {
318         if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_function)) {
319             hasCallback = true;
320             hasUserId = false;
321             EDMLOGI("hasCallback = true; hasUserId = false;");
322             return true;
323         } else {
324             hasCallback = false;
325             hasUserId = true;
326             EDMLOGI("hasCallback = false;  hasUserId = true;");
327             return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
328         }
329     }
330     hasCallback = true;
331     hasUserId = true;
332     EDMLOGI("hasCallback = true; hasUserId = true;");
333     return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
334         MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
335 }
336 
AddOrRemovellowedRunningBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)337 napi_value ApplicationManagerAddon::AddOrRemovellowedRunningBundles(napi_env env, napi_callback_info info,
338     const std::string &workName, napi_async_execute_callback execute)
339 {
340     size_t argc = ARGS_SIZE_FOUR;
341     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
342     napi_value thisArg = nullptr;
343     void *data = nullptr;
344     bool hasCallback = false;
345     bool hasUserId = false;
346     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
347     auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
348     if (asyncCallbackInfo == nullptr) {
349         return nullptr;
350     }
351     std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
352     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
353     ASSERT_AND_THROW_PARAM_ERROR(env,
354         CheckAddDisallowedRunningBundlesParamType(env, argc, argv, hasCallback, hasUserId), "Parameter type error");
355     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
356         "Parameter want error");
357     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->appIds, argv[ARR_INDEX_ONE]),
358         "Parameter bundles error");
359     ASSERT_AND_THROW_PARAM_ERROR(env, asyncCallbackInfo->appIds.size() <= EdmConstants::APPID_MAX_SIZE,
360         "Parameter bundles too large");
361     EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
362         "asyncCallbackInfo->abilityname:%{public}s",
363         asyncCallbackInfo->elementName.GetBundleName().c_str(),
364         asyncCallbackInfo->elementName.GetAbilityName().c_str());
365     if (hasUserId) {
366         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
367             "Parameter user id error");
368     } else {
369 #ifdef OS_ACCOUNT_EDM_ENABLE
370         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
371 #endif
372     }
373     if (hasCallback) {
374         ASSERT_AND_THROW_PARAM_ERROR(env,
375             ParseCallback(env, asyncCallbackInfo->callback,
376                 argc <= ARR_INDEX_FOUR ? argv[argc - 1] : argv[ARR_INDEX_THREE]),
377             "Parameter callback error");
378     }
379     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, workName,
380         execute, NativeVoidCallbackComplete);
381     callbackPtr.release();
382     return asyncWorkReturn;
383 }
384 
NativeRemoveDisallowedRunningBundles(napi_env env,void * data)385 void ApplicationManagerAddon::NativeRemoveDisallowedRunningBundles(napi_env env, void *data)
386 {
387     EDMLOGI("NativeRemoveDisallowedRunningBundles called");
388     if (data == nullptr) {
389         EDMLOGE("data is nullptr");
390         return;
391     }
392     AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
393         static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
394     auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
395     if (applicationManagerProxy_ == nullptr) {
396         EDMLOGE("can not get ApplicationManagerProxy");
397         return;
398     }
399     asyncCallbackInfo->ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(asyncCallbackInfo->elementName,
400         asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
401 }
402 
AddDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)403 napi_value ApplicationManagerAddon::AddDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
404 {
405     return AddOrRemoveDisallowedRunningBundlesSync(env, info, true);
406 }
407 
RemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)408 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
409 {
410     return AddOrRemoveDisallowedRunningBundlesSync(env, info, false);
411 }
412 
AddOrRemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info,bool isAdd)413 napi_value ApplicationManagerAddon::AddOrRemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info,
414     bool isAdd)
415 {
416     EDMLOGI("NAPI_AddOrRemoveDisallowedRunningBundlesSync called");
417     size_t argc = ARGS_SIZE_THREE;
418     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
419     napi_value thisArg = nullptr;
420     void *data = nullptr;
421     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
422 
423     bool hasAccountId = (argc == ARGS_SIZE_THREE);
424     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
425     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
426     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter appIds error");
427     OHOS::AppExecFwk::ElementName elementName;
428     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
429         "parameter admin parse error");
430     std::vector<std::string> appIds;
431     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, appIds, argv[ARR_INDEX_ONE]),
432         "parameter appIds parse error");
433     EDMLOGD("AddOrRemoveDisallowedRunningBundlesSync: "
434         "elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
435         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
436     int32_t accountId = 0;
437     if (hasAccountId) {
438         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
439             "parameter accountId error");
440         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
441             "parameter accountId parse error");
442     } else {
443 #ifdef OS_ACCOUNT_EDM_ENABLE
444         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
445 #endif
446     }
447 
448     auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
449     if (applicationManagerProxy == nullptr) {
450         EDMLOGE("can not get applicationManagerProxy");
451         return nullptr;
452     }
453     int32_t ret = ERR_OK;
454     if (isAdd) {
455         ret = applicationManagerProxy->AddDisallowedRunningBundles(elementName, appIds, accountId, true);
456     } else {
457         ret = applicationManagerProxy->RemoveDisallowedRunningBundles(elementName, appIds, accountId, true);
458     }
459     if (FAILED(ret)) {
460         napi_throw(env, CreateError(env, ret));
461     }
462     return nullptr;
463 }
464 
GetDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)465 napi_value ApplicationManagerAddon::GetDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
466 {
467     EDMLOGI("NAPI_GetDisallowedRunningBundlesSync called");
468     size_t argc = ARGS_SIZE_TWO;
469     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
470     napi_value thisArg = nullptr;
471     void *data = nullptr;
472     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
473     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
474     bool hasAccountId = (argc == ARGS_SIZE_TWO);
475     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
476     OHOS::AppExecFwk::ElementName elementName;
477     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
478         "parameter admin parse error");
479     EDMLOGD("GetDisallowedRunningBundlesSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
480         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
481     int32_t accountId = 0;
482     if (hasAccountId) {
483         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
484             "parameter accountId error");
485         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
486             "parameter accountId parse error");
487     } else {
488 #ifdef OS_ACCOUNT_EDM_ENABLE
489         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
490 #endif
491     }
492 
493     auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
494     if (applicationManagerProxy == nullptr) {
495         EDMLOGE("can not get applicationManagerProxy");
496         return nullptr;
497     }
498     std::vector<std::string> appIds;
499     int32_t ret = applicationManagerProxy->GetDisallowedRunningBundles(elementName, accountId, appIds, true);
500     if (FAILED(ret)) {
501         napi_throw(env, CreateError(env, ret));
502         return nullptr;
503     }
504     napi_value result = nullptr;
505     napi_create_array(env, &result);
506     ConvertStringVectorToJS(env, appIds, result);
507     return result;
508 }
509 
510 static napi_module g_applicationManagerModule = {
511     .nm_version = 1,
512     .nm_flags = 0,
513     .nm_filename = nullptr,
514     .nm_register_func = ApplicationManagerAddon::Init,
515     .nm_modname = "enterprise.applicationManager",
516     .nm_priv = ((void *)0),
517     .reserved = { 0 },
518 };
519 
ApplicationManagerRegister()520 extern "C" __attribute__((constructor)) void ApplicationManagerRegister()
521 {
522     napi_module_register(&g_applicationManagerModule);
523 }