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