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
18 #include "clear_up_application_data_param.h"
19 #include "edm_constants.h"
20 #include "edm_log.h"
21 #include "kiosk_feature.h"
22 #include "napi_edm_adapter.h"
23 #ifdef OS_ACCOUNT_EDM_ENABLE
24 #include "os_account_manager.h"
25 #endif
26
27 using namespace OHOS::EDM;
28
29 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
Init(napi_env env,napi_value exports)30 napi_value ApplicationManagerAddon::Init(napi_env env, napi_value exports)
31 {
32 napi_value nKioskFeature = nullptr;
33 NAPI_CALL(env, napi_create_object(env, &nKioskFeature));
34 CreateKioskFeatureObject(env, nKioskFeature);
35
36 napi_property_descriptor property[] = {
37 DECLARE_NAPI_FUNCTION("addDisallowedRunningBundles", AddDisallowedRunningBundles),
38 DECLARE_NAPI_FUNCTION("removeDisallowedRunningBundles", RemoveDisallowedRunningBundles),
39 DECLARE_NAPI_FUNCTION("getDisallowedRunningBundles", GetDisallowedRunningBundles),
40 DECLARE_NAPI_FUNCTION("addAutoStartApps", AddAutoStartApps),
41 DECLARE_NAPI_FUNCTION("removeAutoStartApps", RemoveAutoStartApps),
42 DECLARE_NAPI_FUNCTION("getAutoStartApps", GetAutoStartApps),
43 DECLARE_NAPI_FUNCTION("addDisallowedRunningBundlesSync", AddDisallowedRunningBundlesSync),
44 DECLARE_NAPI_FUNCTION("removeDisallowedRunningBundlesSync", RemoveDisallowedRunningBundlesSync),
45 DECLARE_NAPI_FUNCTION("getDisallowedRunningBundlesSync", GetDisallowedRunningBundlesSync),
46 DECLARE_NAPI_FUNCTION("setKioskFeatures", SetKioskFeatures),
47 DECLARE_NAPI_FUNCTION("addKeepAliveApps", AddKeepAliveApps),
48 DECLARE_NAPI_FUNCTION("removeKeepAliveApps", RemoveKeepAliveApps),
49 DECLARE_NAPI_FUNCTION("getKeepAliveApps", GetKeepAliveApps),
50 DECLARE_NAPI_FUNCTION("setAllowedKioskApps", SetAllowedKioskApps),
51 DECLARE_NAPI_FUNCTION("getAllowedKioskApps", GetAllowedKioskApps),
52 DECLARE_NAPI_FUNCTION("isAppKioskAllowed", IsAppKioskAllowed),
53 DECLARE_NAPI_PROPERTY("KioskFeature", nKioskFeature),
54 DECLARE_NAPI_FUNCTION("clearUpApplicationData", ClearUpApplicationData),
55 DECLARE_NAPI_FUNCTION("isModifyKeepAliveAppsDisallowed", IsModifyKeepAliveAppsDisallowed),
56 DECLARE_NAPI_FUNCTION("isModifyAutoStartAppsDisallowed", IsModifyAutoStartAppsDisallowed),
57 };
58 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
59 return exports;
60 }
61
IsModifyKeepAliveAppsDisallowed(napi_env env,napi_callback_info info)62 napi_value ApplicationManagerAddon::IsModifyKeepAliveAppsDisallowed(napi_env env, napi_callback_info info)
63 {
64 EDMLOGI("NAPI_IsModifyKeepAliveAppsDisallowed called");
65 size_t argc = ARGS_SIZE_THREE;
66 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
67 napi_value thisArg = nullptr;
68 void *data = nullptr;
69 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
70 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
71 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
72 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
73
74 OHOS::AppExecFwk::ElementName elementName;
75 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
76 "Parameter elementName error");
77
78 int32_t userId = 0;
79 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "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 std::string keepAliveApp;
86 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, keepAliveApp, argv[ARR_INDEX_TWO]) && keepAliveApp.size() > 0,
87 "Parameter keepAliveApps error");
88
89 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
90 bool isModifyKeepAliveAppsDisallowed = true;
91 int32_t ret = applicationManagerProxy->IsModifyKeepAliveAppsDisallowed(elementName, keepAliveApp,
92 userId, isModifyKeepAliveAppsDisallowed);
93 if (FAILED(ret)) {
94 napi_throw(env, CreateError(env, ret));
95 return nullptr;
96 }
97 napi_value napiIsModify = nullptr;
98 napi_get_boolean(env, isModifyKeepAliveAppsDisallowed, &napiIsModify);
99 return napiIsModify;
100 }
101
AddKeepAliveApps(napi_env env,napi_callback_info info)102 napi_value ApplicationManagerAddon::AddKeepAliveApps(napi_env env, napi_callback_info info)
103 {
104 EDMLOGI("NAPI_AddKeepAliveApps called");
105 return AddOrRemoveKeepAliveApps(env, info, "AddKeepAliveApps");
106 }
107
RemoveKeepAliveApps(napi_env env,napi_callback_info info)108 napi_value ApplicationManagerAddon::RemoveKeepAliveApps(napi_env env, napi_callback_info info)
109 {
110 EDMLOGI("NAPI_RemoveKeepAliveApps called");
111 return AddOrRemoveKeepAliveApps(env, info, "RemoveKeepAliveApps");
112 }
113
AddOrRemoveKeepAliveApps(napi_env env,napi_callback_info info,std::string function)114 napi_value ApplicationManagerAddon::AddOrRemoveKeepAliveApps(napi_env env, napi_callback_info info,
115 std::string function)
116 {
117 EDMLOGI("NAPI_AddOrRemoveKeepAliveApps called");
118 size_t argc = ARGS_SIZE_FOUR;
119 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
120 napi_value thisArg = nullptr;
121 void *data = nullptr;
122 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
123 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
124 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
125 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
126 OHOS::AppExecFwk::ElementName elementName;
127 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
128 "Parameter elementName error");
129 std::vector<std::string> keepAliveApps;
130 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, keepAliveApps, argv[ARR_INDEX_ONE]),
131 "Parameter keepAliveApps error");
132 int32_t userId = 0;
133 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_TWO]), "Parameter userId error");
134 bool disallowModify = true;
135 if (argc >= ARGS_SIZE_FOUR) {
136 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallowModify, argv[ARR_INDEX_THREE]),
137 "Parameter disallowModify error");
138 EDMLOGI("NAPI_AddOrRemoveKeepAliveApps called disallowModify: %{public}d", disallowModify);
139 }
140 EDMLOGD(
141 "EnableAdmin: elementName.bundlename %{public}s, "
142 "elementName.abilityname:%{public}s",
143 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
144 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
145 int32_t ret = 0;
146 std::string retMessage;
147 if (function == "AddKeepAliveApps") {
148 ret = applicationManagerProxy->AddKeepAliveApps(elementName, keepAliveApps, disallowModify, userId, retMessage);
149 } else {
150 ret = applicationManagerProxy->RemoveKeepAliveApps(elementName, keepAliveApps, userId);
151 }
152 if (FAILED(ret)) {
153 if (ret == EdmReturnErrCode::ADD_KEEP_ALIVE_APP_FAILED) {
154 napi_throw(env, CreateErrorWithInnerCode(env, ret, retMessage));
155 } else {
156 napi_throw(env, CreateError(env, ret));
157 }
158 }
159 return nullptr;
160 }
161
GetKeepAliveApps(napi_env env,napi_callback_info info)162 napi_value ApplicationManagerAddon::GetKeepAliveApps(napi_env env, napi_callback_info info)
163 {
164 EDMLOGI("NAPI_GetKeepAliveApps called");
165 size_t argc = ARGS_SIZE_TWO;
166 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
167 napi_value thisArg = nullptr;
168 void *data = nullptr;
169 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
170 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
171 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
172 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
173
174 OHOS::AppExecFwk::ElementName elementName;
175 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
176 "Parameter elementName error");
177 int32_t userId = 0;
178 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "Parameter userId error");
179 EDMLOGD(
180 "EnableAdmin: elementName.bundlename %{public}s, "
181 "elementName.abilityname:%{public}s",
182 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
183
184 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
185 std::vector<std::string> keepAliveApps;
186 int32_t ret = applicationManagerProxy->GetKeepAliveApps(elementName, keepAliveApps, userId);
187 if (FAILED(ret)) {
188 napi_throw(env, CreateError(env, ret));
189 return nullptr;
190 }
191 napi_value napiKeepAliveApps = nullptr;
192 napi_create_array(env, &napiKeepAliveApps);
193 ConvertStringVectorToJS(env, keepAliveApps, napiKeepAliveApps);
194 return napiKeepAliveApps;
195 }
196
AddAutoStartApps(napi_env env,napi_callback_info info)197 napi_value ApplicationManagerAddon::AddAutoStartApps(napi_env env, napi_callback_info info)
198 {
199 return AddOrRemoveAutoStartApps(env, info, "AddAutoStartApps");
200 }
201
RemoveAutoStartApps(napi_env env,napi_callback_info info)202 napi_value ApplicationManagerAddon::RemoveAutoStartApps(napi_env env, napi_callback_info info)
203 {
204 return AddOrRemoveAutoStartApps(env, info, "RemoveAutoStartApps");
205 }
206
AddOrRemoveAutoStartApps(napi_env env,napi_callback_info info,std::string function)207 napi_value ApplicationManagerAddon::AddOrRemoveAutoStartApps(napi_env env, napi_callback_info info,
208 std::string function)
209 {
210 EDMLOGI("NAPI_AddOrRemoveAutoStartApps called");
211 size_t argc = ARGS_SIZE_FOUR;
212 napi_value argv[ARGS_SIZE_FOUR] = {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 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
217 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
218 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
219 OHOS::AppExecFwk::ElementName elementName;
220 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
221 "Parameter elementName error");
222 std::vector<AppExecFwk::ElementName> autoStartApps;
223 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementArray(env, autoStartApps, argv[ARR_INDEX_ONE]),
224 "Parameter autoStartApps error");
225 int32_t userId = 0;
226 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
227 if ((argc >= ARGS_SIZE_FOUR && function == "AddAutoStartApps") ||
228 (argc >= ARGS_SIZE_THREE && function == "removeAutoStartApps")) {
229 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_TWO]), "Parameter userId error");
230 }
231 MessageParcel parcelData;
232 parcelData.WriteInterfaceToken(DESCRIPTOR);
233 parcelData.WriteInt32(HAS_USERID);
234 parcelData.WriteInt32(userId);
235 parcelData.WriteParcelable(&elementName);
236 parcelData.WriteString(WITHOUT_PERMISSION_TAG);
237 std::vector<std::string> autoStartAppsString;
238 for (size_t i = 0; i < autoStartApps.size(); i++) {
239 std::string appWant = autoStartApps[i].GetBundleName() + "/" + autoStartApps[i].GetAbilityName();
240 autoStartAppsString.push_back(appWant);
241 }
242 parcelData.WriteStringVector(autoStartAppsString);
243 bool disallowModify = true;
244 if (argc >= ARGS_SIZE_FOUR) {
245 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallowModify, argv[ARR_INDEX_THREE]),
246 "Parameter disallowModify error");
247 EDMLOGI("NAPI_AddOrRemoveAutoStartApps called disallowModify: %{public}d", disallowModify);
248 }
249 parcelData.WriteBool(disallowModify);
250 int32_t ret = ApplicationManagerProxy::GetApplicationManagerProxy()->AddOrRemoveAutoStartApps(
251 parcelData, function == "AddAutoStartApps");
252 if (FAILED(ret)) {
253 napi_throw(env, CreateError(env, ret));
254 }
255 return nullptr;
256 }
257
GetAutoStartApps(napi_env env,napi_callback_info info)258 napi_value ApplicationManagerAddon::GetAutoStartApps(napi_env env, napi_callback_info info)
259 {
260 EDMLOGI("NAPI_GetAutoStartApps called");
261 size_t argc = ARGS_SIZE_TWO;
262 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
263 napi_value thisArg = nullptr;
264 void *data = nullptr;
265 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
266 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
267 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
268 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
269 OHOS::AppExecFwk::ElementName elementName;
270 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
271 "Parameter elementName error");
272 int32_t userId = 0;
273 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
274 if (argc >= ARGS_SIZE_TWO) {
275 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "Parameter userId error");
276 }
277 MessageParcel parcelData;
278 SetBaseDataForGetPolicy(userId, parcelData);
279 parcelData.WriteInt32(HAS_ADMIN);
280 parcelData.WriteParcelable(&elementName);
281 parcelData.WriteString(OHOS::EDM::EdmConstants::AutoStart::GET_MANAGE_AUTO_START_APPS_BUNDLE_INFO);
282 std::vector<OHOS::AppExecFwk::ElementName> autoStartApps;
283 int32_t ret = ApplicationManagerProxy::GetApplicationManagerProxy()->GetAutoStartApps(
284 parcelData, autoStartApps);
285 if (FAILED(ret)) {
286 napi_throw(env, CreateError(env, ret));
287 return nullptr;
288 }
289 napi_value napiAutoStartApps = nullptr;
290 NAPI_CALL(env, napi_create_array(env, &napiAutoStartApps));
291 size_t idx = 0;
292 for (const auto &element : autoStartApps) {
293 napi_value objAutoStartApps = nullptr;
294 NAPI_CALL(env, napi_create_object(env, &objAutoStartApps));
295 napi_value napi_bundleName;
296 napi_value napi_abilityName;
297 NAPI_CALL(env, napi_create_string_utf8(env, element.GetBundleName().c_str(),
298 element.GetBundleName().size(), &napi_bundleName));
299 NAPI_CALL(env, napi_create_string_utf8(env, element.GetAbilityName().c_str(),
300 element.GetAbilityName().size(), &napi_abilityName));
301 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "bundleName", napi_bundleName));
302 NAPI_CALL(env, napi_set_named_property(env, objAutoStartApps, "abilityName", napi_abilityName));
303 napi_set_element(env, napiAutoStartApps, idx, objAutoStartApps);
304 idx++;
305 }
306 return napiAutoStartApps;
307 }
308
SetBaseDataForGetPolicy(int32_t userId,MessageParcel & data)309 void ApplicationManagerAddon::SetBaseDataForGetPolicy(int32_t userId, MessageParcel &data)
310 {
311 data.WriteInterfaceToken(DESCRIPTOR);
312 data.WriteInt32(HAS_USERID);
313 data.WriteInt32(userId);
314 data.WriteString(WITHOUT_PERMISSION_TAG);
315 }
316
IsModifyAutoStartAppsDisallowed(napi_env env,napi_callback_info info)317 napi_value ApplicationManagerAddon::IsModifyAutoStartAppsDisallowed(napi_env env, napi_callback_info info)
318 {
319 EDMLOGI("IsModifyAutoStartAppsDisallowed called");
320 size_t argc = ARGS_SIZE_THREE;
321 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
322 napi_value thisArg = nullptr;
323 void *data = nullptr;
324 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
325 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
326 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
327 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
328 OHOS::AppExecFwk::ElementName elementName;
329 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
330 "Parameter elementName error");
331 OHOS::AppExecFwk::ElementName autoStartApp;
332 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, autoStartApp, argv[ARR_INDEX_ONE]),
333 "Parameter autoStartApp error");
334 int32_t userId = 0;
335 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_TWO]), "Parameter userId error");
336 MessageParcel parcelData;
337 parcelData.WriteInterfaceToken(DESCRIPTOR);
338 parcelData.WriteInt32(HAS_USERID);
339 parcelData.WriteInt32(userId);
340 parcelData.WriteString(WITHOUT_PERMISSION_TAG);
341 parcelData.WriteInt32(HAS_ADMIN);
342 parcelData.WriteParcelable(&elementName);
343 parcelData.WriteString(OHOS::EDM::EdmConstants::AutoStart::GET_MANAGE_AUTO_START_APP_DISALLOW_MODIFY);
344 std::string appWant = autoStartApp.GetBundleName() + "/" + autoStartApp.GetAbilityName();
345 parcelData.WriteString(appWant);
346
347 bool isModifyAutoStartAppDisallowed = true;
348 int32_t ret = ApplicationManagerProxy::GetApplicationManagerProxy()->IsModifyAutoStartAppsDisallowed(
349 parcelData, isModifyAutoStartAppDisallowed);
350 if (FAILED(ret)) {
351 napi_throw(env, CreateError(env, ret));
352 return nullptr;
353 }
354 napi_value napiIsModify = nullptr;
355 napi_get_boolean(env, isModifyAutoStartAppDisallowed, &napiIsModify);
356 return napiIsModify;
357 }
358
GetDisallowedRunningBundles(napi_env env,napi_callback_info info)359 napi_value ApplicationManagerAddon::GetDisallowedRunningBundles(napi_env env, napi_callback_info info)
360 {
361 EDMLOGI("NAPI_GetDisallowedRunningBundles called");
362 size_t argc = ARGS_SIZE_THREE;
363 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
364 napi_value thisArg = nullptr;
365 void *data = nullptr;
366 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
367 bool hasCallback = false;
368 bool hasUserId = false;
369 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
370 if (asyncCallbackInfo == nullptr) {
371 return nullptr;
372 }
373 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
374 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
375 ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
376 "Parameter type error");
377 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
378 "Parameter want error");
379
380 EDMLOGD("GetDisallowedRunningBundles::asyncCallbackInfo->elementName.bundlename %{public}s, "
381 "asyncCallbackInfo->abilityname:%{public}s",
382 asyncCallbackInfo->elementName.GetBundleName().c_str(),
383 asyncCallbackInfo->elementName.GetAbilityName().c_str());
384 if (hasUserId) {
385 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
386 "Parameter user id error");
387 } else {
388 #ifdef OS_ACCOUNT_EDM_ENABLE
389 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
390 #endif
391 }
392 if (hasCallback) {
393 ASSERT_AND_THROW_PARAM_ERROR(env,
394 ParseCallback(env, asyncCallbackInfo->callback,
395 argc <= ARR_INDEX_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
396 "Parameter callback error");
397 }
398 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetDisallowedRunningBundles",
399 NativeGetDisallowedRunningBundles, NativeArrayStringCallbackComplete);
400 callbackPtr.release();
401 return asyncWorkReturn;
402 }
403
NativeGetDisallowedRunningBundles(napi_env env,void * data)404 void ApplicationManagerAddon::NativeGetDisallowedRunningBundles(napi_env env, void *data)
405 {
406 EDMLOGI("NAPI_NativeGetDisallowedRunningBundles called");
407 if (data == nullptr) {
408 EDMLOGE("data is nullptr");
409 return;
410 }
411 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
412 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
413 auto proxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
414 if (proxy_ == nullptr) {
415 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
416 return;
417 }
418
419 asyncCallbackInfo->ret = proxy_->GetDisallowedRunningBundles(asyncCallbackInfo->elementName,
420 asyncCallbackInfo->userId, asyncCallbackInfo->arrayStringRet);
421 }
422
AddDisallowedRunningBundles(napi_env env,napi_callback_info info)423 napi_value ApplicationManagerAddon::AddDisallowedRunningBundles(napi_env env, napi_callback_info info)
424 {
425 return AddOrRemovellowedRunningBundles(env, info, "AddDisallowedRunningBundles", NativeAddDisallowedRunningBundles);
426 }
427
RemoveDisallowedRunningBundles(napi_env env,napi_callback_info info)428 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundles(napi_env env, napi_callback_info info)
429 {
430 return AddOrRemovellowedRunningBundles(env, info, "RemoveDisallowedRunningBundles",
431 NativeRemoveDisallowedRunningBundles);
432 }
433
NativeAddDisallowedRunningBundles(napi_env env,void * data)434 void ApplicationManagerAddon::NativeAddDisallowedRunningBundles(napi_env env, void *data)
435 {
436 EDMLOGI("NAPI_NativeAddDisallowedRunningBundles called");
437 if (data == nullptr) {
438 EDMLOGE("data is nullptr");
439 return;
440 }
441 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
442 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
443 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
444 if (applicationManagerProxy_ == nullptr) {
445 EDMLOGE("can not get applicationManagerProxy");
446 return;
447 }
448 asyncCallbackInfo->ret = applicationManagerProxy_->AddDisallowedRunningBundles(asyncCallbackInfo->elementName,
449 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
450 }
451
CheckAddDisallowedRunningBundlesParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)452 bool ApplicationManagerAddon::CheckAddDisallowedRunningBundlesParamType(napi_env env, size_t argc,
453 napi_value* argv, bool &hasCallback, bool &hasUserId)
454 {
455 if (!MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) || !MatchValueType(env, argv[ARR_INDEX_ONE],
456 napi_object)) {
457 EDMLOGE("CheckAddDisallowedRunningBundlesParamType admin or array type check failed");
458 return false;
459 }
460 EDMLOGI("CheckAddDisallowedRunningBundlesParamType argc = %{public}zu", argc);
461 if (argc == ARGS_SIZE_TWO) {
462 hasCallback = false;
463 hasUserId = false;
464 EDMLOGI("hasCallback = false; hasUserId = false;");
465 return true;
466 }
467
468 if (argc == ARGS_SIZE_THREE) {
469 if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_function)) {
470 hasCallback = true;
471 hasUserId = false;
472 EDMLOGI("hasCallback = true; hasUserId = false;");
473 return true;
474 } else {
475 hasCallback = false;
476 hasUserId = true;
477 EDMLOGI("hasCallback = false; hasUserId = true;");
478 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
479 }
480 }
481 hasCallback = true;
482 hasUserId = true;
483 EDMLOGI("hasCallback = true; hasUserId = true;");
484 return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
485 MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
486 }
487
AddOrRemovellowedRunningBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)488 napi_value ApplicationManagerAddon::AddOrRemovellowedRunningBundles(napi_env env, napi_callback_info info,
489 const std::string &workName, napi_async_execute_callback execute)
490 {
491 size_t argc = ARGS_SIZE_FOUR;
492 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
493 napi_value thisArg = nullptr;
494 void *data = nullptr;
495 bool hasCallback = false;
496 bool hasUserId = false;
497 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
498 auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowedRunningBundlesCallbackInfo();
499 if (asyncCallbackInfo == nullptr) {
500 return nullptr;
501 }
502 std::unique_ptr<AsyncDisallowedRunningBundlesCallbackInfo> callbackPtr {asyncCallbackInfo};
503 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
504 ASSERT_AND_THROW_PARAM_ERROR(env,
505 CheckAddDisallowedRunningBundlesParamType(env, argc, argv, hasCallback, hasUserId), "Parameter type error");
506 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
507 "Parameter want error");
508 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->appIds, argv[ARR_INDEX_ONE]),
509 "Parameter bundles error");
510 ASSERT_AND_THROW_PARAM_ERROR(env, asyncCallbackInfo->appIds.size() <= EdmConstants::APPID_MAX_SIZE,
511 "Parameter bundles too large");
512 EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
513 "asyncCallbackInfo->abilityname:%{public}s",
514 asyncCallbackInfo->elementName.GetBundleName().c_str(),
515 asyncCallbackInfo->elementName.GetAbilityName().c_str());
516 if (hasUserId) {
517 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
518 "Parameter user id error");
519 } else {
520 #ifdef OS_ACCOUNT_EDM_ENABLE
521 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
522 #endif
523 }
524 if (hasCallback) {
525 ASSERT_AND_THROW_PARAM_ERROR(env,
526 ParseCallback(env, asyncCallbackInfo->callback,
527 argc <= ARR_INDEX_FOUR ? argv[argc - 1] : argv[ARR_INDEX_THREE]),
528 "Parameter callback error");
529 }
530 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, workName,
531 execute, NativeVoidCallbackComplete);
532 callbackPtr.release();
533 return asyncWorkReturn;
534 }
535
NativeRemoveDisallowedRunningBundles(napi_env env,void * data)536 void ApplicationManagerAddon::NativeRemoveDisallowedRunningBundles(napi_env env, void *data)
537 {
538 EDMLOGI("NativeRemoveDisallowedRunningBundles called");
539 if (data == nullptr) {
540 EDMLOGE("data is nullptr");
541 return;
542 }
543 AsyncDisallowedRunningBundlesCallbackInfo *asyncCallbackInfo =
544 static_cast<AsyncDisallowedRunningBundlesCallbackInfo *>(data);
545 auto applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
546 if (applicationManagerProxy_ == nullptr) {
547 EDMLOGE("can not get ApplicationManagerProxy");
548 return;
549 }
550 asyncCallbackInfo->ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(asyncCallbackInfo->elementName,
551 asyncCallbackInfo->appIds, asyncCallbackInfo->userId);
552 }
553
AddDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)554 napi_value ApplicationManagerAddon::AddDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
555 {
556 return AddOrRemoveDisallowedRunningBundlesSync(env, info, true);
557 }
558
RemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)559 napi_value ApplicationManagerAddon::RemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
560 {
561 return AddOrRemoveDisallowedRunningBundlesSync(env, info, false);
562 }
563
AddOrRemoveDisallowedRunningBundlesSync(napi_env env,napi_callback_info info,bool isAdd)564 napi_value ApplicationManagerAddon::AddOrRemoveDisallowedRunningBundlesSync(napi_env env, napi_callback_info info,
565 bool isAdd)
566 {
567 EDMLOGI("NAPI_AddOrRemoveDisallowedRunningBundlesSync called");
568 size_t argc = ARGS_SIZE_THREE;
569 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
570 napi_value thisArg = nullptr;
571 void *data = nullptr;
572 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
573
574 bool hasAccountId = (argc == ARGS_SIZE_THREE);
575 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
576 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
577 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter appIds error");
578 OHOS::AppExecFwk::ElementName elementName;
579 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
580 "parameter admin parse error");
581 std::vector<std::string> appIds;
582 ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, appIds, argv[ARR_INDEX_ONE]),
583 "parameter appIds parse error");
584 EDMLOGD("AddOrRemoveDisallowedRunningBundlesSync: "
585 "elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
586 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
587 int32_t accountId = 0;
588 if (hasAccountId) {
589 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
590 "parameter accountId error");
591 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
592 "parameter accountId parse error");
593 } else {
594 #ifdef OS_ACCOUNT_EDM_ENABLE
595 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
596 #endif
597 }
598
599 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
600 if (applicationManagerProxy == nullptr) {
601 EDMLOGE("can not get applicationManagerProxy");
602 return nullptr;
603 }
604 int32_t ret = ERR_OK;
605 if (isAdd) {
606 ret = applicationManagerProxy->AddDisallowedRunningBundles(elementName, appIds, accountId, true);
607 } else {
608 ret = applicationManagerProxy->RemoveDisallowedRunningBundles(elementName, appIds, accountId, true);
609 }
610 if (FAILED(ret)) {
611 napi_throw(env, CreateError(env, ret));
612 }
613 return nullptr;
614 }
615
GetDisallowedRunningBundlesSync(napi_env env,napi_callback_info info)616 napi_value ApplicationManagerAddon::GetDisallowedRunningBundlesSync(napi_env env, napi_callback_info info)
617 {
618 EDMLOGI("NAPI_GetDisallowedRunningBundlesSync called");
619 size_t argc = ARGS_SIZE_TWO;
620 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
621 napi_value thisArg = nullptr;
622 void *data = nullptr;
623 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
624 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
625 bool hasAccountId = (argc == ARGS_SIZE_TWO);
626 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
627 OHOS::AppExecFwk::ElementName elementName;
628 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
629 "parameter admin parse error");
630 EDMLOGD("GetDisallowedRunningBundlesSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
631 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
632 int32_t accountId = 0;
633 if (hasAccountId) {
634 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
635 "parameter accountId error");
636 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
637 "parameter accountId parse error");
638 } else {
639 #ifdef OS_ACCOUNT_EDM_ENABLE
640 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
641 #endif
642 }
643
644 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
645 if (applicationManagerProxy == nullptr) {
646 EDMLOGE("can not get applicationManagerProxy");
647 return nullptr;
648 }
649 std::vector<std::string> appIds;
650 int32_t ret = applicationManagerProxy->GetDisallowedRunningBundles(elementName, accountId, appIds, true);
651 if (FAILED(ret)) {
652 napi_throw(env, CreateError(env, ret));
653 return nullptr;
654 }
655 napi_value result = nullptr;
656 NAPI_CALL(env, napi_create_array(env, &result));
657 ConvertStringVectorToJS(env, appIds, result);
658 return result;
659 }
660
CreateKioskFeatureObject(napi_env env,napi_value value)661 void ApplicationManagerAddon::CreateKioskFeatureObject(napi_env env, napi_value value)
662 {
663 napi_value nAllowNotificationCenter;
664 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env,
665 static_cast<uint32_t>(KioskFeature::ALLOW_NOTIFICATION_CENTER), &nAllowNotificationCenter));
666 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW_NOTIFICATION_CENTER",
667 nAllowNotificationCenter));
668
669 napi_value nAllowContorlCenter;
670 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env,
671 static_cast<uint32_t>(KioskFeature::ALLOW_CONTROL_CENTER), &nAllowContorlCenter));
672 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW_CONTROL_CENTER", nAllowContorlCenter));
673 }
674
SetKioskFeatures(napi_env env,napi_callback_info info)675 napi_value ApplicationManagerAddon::SetKioskFeatures(napi_env env, napi_callback_info info)
676 {
677 EDMLOGI("NAPI_SetKioskFeatures called");
678 auto convertKioskFeature2Data = [](napi_env env, napi_value argv, MessageParcel &data,
679 const AddonMethodSign &methodSign) {
680 std::vector<int32_t> kioskFeatures;
681 bool parseRet = ParseIntArray(env, kioskFeatures, argv);
682 if (!parseRet) {
683 EDMLOGE("NAPI_SetKioskFeatures ParseIntArray fail");
684 return false;
685 }
686 data.WriteInt32Vector(kioskFeatures);
687 return true;
688 };
689 AddonMethodSign addonMethodSign;
690 addonMethodSign.name = "SetKioskFeatures";
691 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
692 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
693 addonMethodSign.argsConvert = {nullptr, convertKioskFeature2Data};
694 AdapterAddonData adapterAddonData{};
695 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
696 if (result == nullptr) {
697 return nullptr;
698 }
699 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
700 int32_t ret = applicationManagerProxy->SetKioskFeatures(adapterAddonData.data);
701 if (FAILED(ret)) {
702 napi_throw(env, CreateError(env, ret));
703 EDMLOGE("SetKioskFeatures failed!");
704 }
705 return nullptr;
706 }
707
SetAllowedKioskApps(napi_env env,napi_callback_info info)708 napi_value ApplicationManagerAddon::SetAllowedKioskApps(napi_env env, napi_callback_info info)
709 {
710 EDMLOGI("NAPI_SetAllowedKioskApps called");
711 size_t argc = ARGS_SIZE_TWO;
712 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
713 napi_value thisArg = nullptr;
714 void *data = nullptr;
715 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
716 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
717 ASSERT_AND_THROW_PARAM_ERROR(
718 env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "The first parameter must be want.");
719 OHOS::AppExecFwk::ElementName elementName;
720 ASSERT_AND_THROW_PARAM_ERROR(
721 env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]), "Parameter elementName error");
722 std::vector<std::string> appIdentifiers;
723 ASSERT_AND_THROW_PARAM_ERROR(
724 env, ParseStringArray(env, appIdentifiers, argv[ARR_INDEX_ONE]), "Parameter appIdentifiers error");
725 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
726 int32_t ret = applicationManagerProxy->SetAllowedKioskApps(elementName, appIdentifiers);
727 if (FAILED(ret)) {
728 napi_throw(env, CreateError(env, ret));
729 }
730 return nullptr;
731 }
732
GetAllowedKioskApps(napi_env env,napi_callback_info info)733 napi_value ApplicationManagerAddon::GetAllowedKioskApps(napi_env env, napi_callback_info info)
734 {
735 EDMLOGI("NAPI_GetAllowedKioskApps called");
736 size_t argc = ARGS_SIZE_ONE;
737 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
738 napi_value thisArg = nullptr;
739 void *data = nullptr;
740 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
741 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
742 ASSERT_AND_THROW_PARAM_ERROR(
743 env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "The first parameter must be want.");
744 OHOS::AppExecFwk::ElementName elementName;
745 ASSERT_AND_THROW_PARAM_ERROR(
746 env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]), "Parameter elementName error");
747 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
748 std::vector<std::string> appIdentifiers;
749 int32_t ret = applicationManagerProxy->GetAllowedKioskApps(elementName, appIdentifiers);
750 if (FAILED(ret)) {
751 napi_throw(env, CreateError(env, ret));
752 return nullptr;
753 }
754 napi_value napiAppIdentifiers = nullptr;
755 NAPI_CALL(env, napi_create_array(env, &napiAppIdentifiers));
756 ConvertStringVectorToJS(env, appIdentifiers, napiAppIdentifiers);
757 return napiAppIdentifiers;
758 }
759
IsAppKioskAllowed(napi_env env,napi_callback_info info)760 napi_value ApplicationManagerAddon::IsAppKioskAllowed(napi_env env, napi_callback_info info)
761 {
762 EDMLOGI("NAPI_IsAppKioskAllowed called");
763 size_t argc = ARGS_SIZE_ONE;
764 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
765 napi_value thisArg = nullptr;
766 void *data = nullptr;
767 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
768 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
769 ASSERT_AND_THROW_PARAM_ERROR(
770 env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_string), "Parameter appIdentifier error.");
771 std::string appIdentifier;
772 ASSERT_AND_THROW_PARAM_ERROR(
773 env, ParseString(env, appIdentifier, argv[ARR_INDEX_ZERO]), "Parameter appIdentifier parse error");
774 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
775 bool isAllowed = false;
776 int32_t ret = applicationManagerProxy->IsAppKioskAllowed(appIdentifier, isAllowed);
777 if (FAILED(ret)) {
778 napi_throw(env, CreateError(env, ret));
779 return nullptr;
780 }
781 napi_value result = nullptr;
782 NAPI_CALL(env, napi_get_boolean(env, isAllowed, &result));
783 return result;
784 }
785
ClearUpApplicationData(napi_env env,napi_callback_info info)786 napi_value ApplicationManagerAddon::ClearUpApplicationData(napi_env env, napi_callback_info info)
787 {
788 EDMLOGI("NAPI_ClearUpApplicationData called");
789 size_t argc = ARGS_SIZE_FOUR;
790 napi_value argv[ARGS_SIZE_FOUR] = { nullptr };
791 napi_value thisArg = nullptr;
792 void *data = nullptr;
793 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
794
795 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "Parameter count error.");
796 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "Parameter admin error.");
797 ASSERT_AND_THROW_PARAM_ERROR(
798 env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "Parameter bundleName error.");
799 ASSERT_AND_THROW_PARAM_ERROR(
800 env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number), "Parameter appIndex error.");
801 ASSERT_AND_THROW_PARAM_ERROR(
802 env, MatchValueType(env, argv[ARR_INDEX_THREE], napi_number), "Parameter accountId error.");
803
804 OHOS::AppExecFwk::ElementName elementName;
805 ASSERT_AND_THROW_PARAM_ERROR(
806 env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]), "Parameter elementName parse error.");
807
808 ClearUpApplicationDataParam param;
809 ASSERT_AND_THROW_PARAM_ERROR(
810 env, ParseString(env, param.bundleName, argv[ARR_INDEX_ONE]), "Parameter bundleName parse error.");
811 ASSERT_AND_THROW_PARAM_ERROR(
812 env, ParseInt(env, param.appIndex, argv[ARR_INDEX_TWO]), "Parameter appIndex parse error.");
813 ASSERT_AND_THROW_PARAM_ERROR(
814 env, ParseInt(env, param.userId, argv[ARR_INDEX_THREE]), "Parameter accountId parse error.");
815 EDMLOGD("EnableAdmin: elementName.bundlename %{public}s, "
816 "elementName.abilityname:%{public}s",
817 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
818
819 auto applicationManagerProxy = ApplicationManagerProxy::GetApplicationManagerProxy();
820 int32_t ret = applicationManagerProxy->ClearUpApplicationData(elementName, param);
821 if (FAILED(ret)) {
822 napi_throw(env, CreateError(env, ret));
823 }
824
825 return nullptr;
826 }
827
828 static napi_module g_applicationManagerModule = {
829 .nm_version = 1,
830 .nm_flags = 0,
831 .nm_filename = nullptr,
832 .nm_register_func = ApplicationManagerAddon::Init,
833 .nm_modname = "enterprise.applicationManager",
834 .nm_priv = ((void *)0),
835 .reserved = { 0 },
836 };
837
ApplicationManagerRegister()838 extern "C" __attribute__((constructor)) void ApplicationManagerRegister()
839 {
840 napi_module_register(&g_applicationManagerModule);
841 }