• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-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 "ability_context.h"
17 #include "ability_manager_client.h"
18 #include "admin_manager_addon.h"
19 
20 #include "edm_constants.h"
21 #include "edm_log.h"
22 #include "if_system_ability_manager.h"
23 #include "iservice_registry.h"
24 #include "napi_base_context.h"
25 #include "policy_flag.h"
26 #ifdef OS_ACCOUNT_EDM_ENABLE
27 #include "os_account_manager.h"
28 #endif
29 #include "system_ability_definition.h"
30 
31 using namespace OHOS::EDM;
32 namespace {
33 const std::string ADMIN_PROVISIONING_ABILITY_NAME = "ByodAdminProvisionAbility";
34 const int32_t JS_BYOD_TYPE = 2;
35 const uint32_t MAX_ADMINPROVISION_PARAM_NUM = 10;
36 const uint32_t MIN_ACTIVATEID_LEN = 32;
37 const uint32_t MAX_ACTIVATEID_LEN = 256;
38 const uint32_t MAX_CUSTOMIZEDINFO_LEN = 10240;
39 const std::string ACTIVATEID = "activateId";
40 const std::string CUSTOMIZEDINFO = "customizedInfo";
41 }
EnableAdmin(napi_env env,napi_callback_info info)42 napi_value AdminManager::EnableAdmin(napi_env env, napi_callback_info info)
43 {
44     EDMLOGI("NAPI_EnableAdmin called");
45     size_t argc = ARGS_SIZE_FIVE;
46     napi_value argv[ARGS_SIZE_FIVE] = {nullptr};
47     napi_value thisArg = nullptr;
48     void *data = nullptr;
49     bool hasCallback = false;
50     bool hasUserId = false;
51     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
52     auto asyncCallbackInfo = new (std::nothrow) AsyncEnableAdminCallbackInfo();
53     if (asyncCallbackInfo == nullptr) {
54         return nullptr;
55     }
56     std::unique_ptr<AsyncEnableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
57     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "Parameter count error");
58     ASSERT_AND_THROW_PARAM_ERROR(env, CheckEnableAdminParamType(env, argc, argv, hasCallback, hasUserId),
59         "Parameter type error");
60     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
61         "Parameter want error");
62     ASSERT_AND_THROW_PARAM_ERROR(env, ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]),
63         "Parameter enterprise info error");
64     int32_t jsAdminType;
65     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, jsAdminType, argv[ARR_INDEX_TWO]), "Parameter admin type error");
66     asyncCallbackInfo->adminType = JsAdminTypeToAdminType(jsAdminType);
67     EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
68         "asyncCallbackInfo->abilityname:%{public}s , adminType:%{public}d",
69         asyncCallbackInfo->elementName.GetBundleName().c_str(), asyncCallbackInfo->elementName.GetAbilityName().c_str(),
70         asyncCallbackInfo->adminType);
71     if (hasUserId) {
72         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_THREE]),
73             "Parameter user id error");
74     } else {
75 #ifdef OS_ACCOUNT_EDM_ENABLE
76         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
77 #endif
78     }
79     if (hasCallback) {
80         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback,
81             argc <= ARGS_SIZE_FIVE ? argv[argc - 1] : argv[ARR_INDEX_FOUR]), "Parameter callback error");
82     }
83     napi_value asyncWorkReturn =
84         HandleAsyncWork(env, asyncCallbackInfo, "EnableAdmin", NativeEnableAdmin, NativeVoidCallbackComplete);
85     callbackPtr.release();
86     return asyncWorkReturn;
87 }
88 
JsAdminTypeToAdminType(int32_t jsAdminType)89 int32_t AdminManager::JsAdminTypeToAdminType(int32_t jsAdminType)
90 {
91     if (jsAdminType == JS_BYOD_TYPE) {
92         return static_cast<int32_t>(AdminType::BYOD);
93     }
94     if (jsAdminType == static_cast<int32_t>(AdminType::NORMAL) || jsAdminType == static_cast<int32_t>(AdminType::ENT)) {
95         return jsAdminType;
96     }
97     return static_cast<int32_t>(AdminType::UNKNOWN);
98 }
99 
AdminTypeToJsAdminType(int32_t AdminType)100 int32_t AdminManager::AdminTypeToJsAdminType(int32_t AdminType)
101 {
102     if (AdminType == static_cast<int32_t>(AdminType::BYOD)) {
103         return JS_BYOD_TYPE;
104     }
105     if (AdminType == static_cast<int32_t>(AdminType::NORMAL) || AdminType == static_cast<int32_t>(AdminType::ENT)) {
106         return AdminType;
107     }
108     return static_cast<int32_t>(AdminType::UNKNOWN);
109 }
110 
ReplaceSuperAdmin(napi_env env,napi_callback_info info)111 napi_value AdminManager::ReplaceSuperAdmin(napi_env env, napi_callback_info info)
112 {
113     EDMLOGI("NAPI_ReplaceSuperAdmin called");
114     AppExecFwk::ElementName oldAdmin;
115     AppExecFwk::ElementName newAdmin;
116     bool keepPolicy = true;
117     size_t argc = ARGS_SIZE_THREE;
118     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
119     napi_value thisArg = nullptr;
120     void *data = nullptr;
121     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
122     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "Parameter count error");
123     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
124         MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
125         MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean);
126 
127     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
128     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, oldAdmin, argv[ARR_INDEX_ZERO]),
129         "oldAdmin param error");
130     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, newAdmin, argv[ARR_INDEX_ONE]),
131         "newAdmin param error");
132     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, keepPolicy, argv[ARR_INDEX_TWO]),
133         "keepPolicy param error");
134 
135     EDMLOGD(
136         "ReplaceSuperAdmin: elementName.bundlename %{public}s, "
137         "elementName.abilityname:%{public}s",
138         newAdmin.GetBundleName().c_str(),
139         newAdmin.GetAbilityName().c_str());
140     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
141     int32_t retCode = proxy->ReplaceSuperAdmin(oldAdmin, newAdmin, keepPolicy);
142     if (FAILED(retCode)) {
143         napi_throw(env, CreateError(env, retCode));
144     }
145     return nullptr;
146 }
147 
ParseAdminType(int32_t type)148 AdminType AdminManager::ParseAdminType(int32_t type)
149 {
150     if (type == static_cast<int32_t>(AdminType::NORMAL) || type == static_cast<int32_t>(AdminType::ENT) ||
151         type == static_cast<int32_t>(AdminType::BYOD)) {
152         return static_cast<AdminType>(type);
153     }
154     return AdminType::UNKNOWN;
155 }
156 
NativeEnableAdmin(napi_env env,void * data)157 void AdminManager::NativeEnableAdmin(napi_env env, void *data)
158 {
159     if (data == nullptr) {
160         EDMLOGE("data is nullptr");
161         return;
162     }
163     AsyncEnableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncEnableAdminCallbackInfo *>(data);
164     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
165 #ifdef FEATURE_PC_ONLY
166     if (ParseAdminType(asyncCallbackInfo->adminType) == AdminType::ENT) {
167         asyncCallbackInfo->userId = EdmConstants::DEFAULT_USER_ID;
168     }
169 #endif
170     asyncCallbackInfo->ret = proxy->EnableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo,
171         ParseAdminType(asyncCallbackInfo->adminType), asyncCallbackInfo->userId);
172 }
173 
CheckEnableAdminParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)174 bool AdminManager::CheckEnableAdminParamType(napi_env env, size_t argc, napi_value *argv, bool &hasCallback,
175     bool &hasUserId)
176 {
177     EDMLOGI("argc = %{public}zu", argc);
178     if (argc == ARGS_SIZE_THREE) {
179         hasCallback = false;
180         hasUserId = false;
181         EDMLOGI("hasCallback = false; hasUserId = false;");
182         return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
183             MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
184             MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
185     }
186 
187     if (argc == ARGS_SIZE_FOUR) {
188         if (MatchValueType(env, argv[ARR_INDEX_THREE], napi_function)) {
189             hasCallback = true;
190             hasUserId = false;
191             EDMLOGI("hasCallback = true; hasUserId = false;");
192             return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
193                 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
194                 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
195         } else {
196             hasCallback = false;
197             hasUserId = true;
198             EDMLOGI("hasCallback = false;  hasUserId = true;");
199             return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
200                 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
201                 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
202                 MatchValueType(env, argv[ARR_INDEX_THREE], napi_number);
203         }
204     }
205     hasCallback = true;
206     hasUserId = true;
207     EDMLOGI("hasCallback = true; hasUserId = true;");
208     return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
209         MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
210         MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
211         MatchValueType(env, argv[ARR_INDEX_THREE], napi_number) &&
212         MatchValueType(env, argv[ARR_INDEX_FOUR], napi_function);
213 }
214 
DisableAdmin(napi_env env,napi_callback_info info)215 napi_value AdminManager::DisableAdmin(napi_env env, napi_callback_info info)
216 {
217     EDMLOGI("NAPI_DisableAdmin called");
218     size_t argc = ARGS_SIZE_THREE;
219     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
220     napi_value thisArg = nullptr;
221     void *data = nullptr;
222     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
223     bool hasCallback = false;
224     bool hasUserId = false;
225     auto asyncCallbackInfo = new (std::nothrow) AsyncDisableAdminCallbackInfo();
226     if (asyncCallbackInfo == nullptr) {
227         return nullptr;
228     }
229     std::unique_ptr<AsyncDisableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
230     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
231     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
232         "Parameter type error");
233     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
234         "Parameter want error");
235 
236     EDMLOGD(
237         "DisableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
238         "asyncCallbackInfo->abilityname:%{public}s",
239         asyncCallbackInfo->elementName.GetBundleName().c_str(),
240         asyncCallbackInfo->elementName.GetAbilityName().c_str());
241     if (hasUserId) {
242         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
243             "Parameter user id error");
244     } else {
245 #ifdef OS_ACCOUNT_EDM_ENABLE
246         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
247 #endif
248     }
249     if (hasCallback) {
250         ASSERT_AND_THROW_PARAM_ERROR(env,
251             ParseCallback(env, asyncCallbackInfo->callback,
252                 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
253             "Parameter callback error");
254     }
255     napi_value asyncWorkReturn =
256         HandleAsyncWork(env, asyncCallbackInfo, "DisableAdmin", NativeDisableAdmin, NativeVoidCallbackComplete);
257     callbackPtr.release();
258     return asyncWorkReturn;
259 }
260 
NativeDisableAdmin(napi_env env,void * data)261 void AdminManager::NativeDisableAdmin(napi_env env, void *data)
262 {
263     EDMLOGI("NAPI_NativeDisableAdmin called");
264     if (data == nullptr) {
265         EDMLOGE("data is nullptr");
266         return;
267     }
268     AsyncDisableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableAdminCallbackInfo *>(data);
269     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
270 
271     asyncCallbackInfo->ret = proxy->DisableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->userId);
272 }
273 
DisableSuperAdmin(napi_env env,napi_callback_info info)274 napi_value AdminManager::DisableSuperAdmin(napi_env env, napi_callback_info info)
275 {
276     EDMLOGI("NAPI_DisableSuperAdmin called");
277     size_t argc = ARGS_SIZE_TWO;
278     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
279     napi_value thisArg = nullptr;
280     void *data = nullptr;
281     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
282     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
283 
284     auto asyncCallbackInfo = new (std::nothrow) AsyncDisableSuperAdminCallbackInfo();
285     if (asyncCallbackInfo == nullptr) {
286         return nullptr;
287     }
288     std::unique_ptr<AsyncDisableSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
289     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
290         "parameter bundle name error");
291     if (argc > ARGS_SIZE_ONE) {
292         bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
293         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
294         NAPI_CALL(env, napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
295     }
296 
297     EDMLOGD("DisableSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
298         asyncCallbackInfo->bundleName.c_str());
299     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisableSuperAdmin", NativeDisableSuperAdmin,
300         NativeVoidCallbackComplete);
301     callbackPtr.release();
302     return asyncWorkReturn;
303 }
304 
NativeDisableSuperAdmin(napi_env env,void * data)305 void AdminManager::NativeDisableSuperAdmin(napi_env env, void *data)
306 {
307     EDMLOGI("NAPI_NativeDisableSuperAdmin called");
308     if (data == nullptr) {
309         EDMLOGE("data is nullptr");
310         return;
311     }
312     AsyncDisableSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableSuperAdminCallbackInfo *>(data);
313     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
314     asyncCallbackInfo->ret = proxy->DisableSuperAdmin(asyncCallbackInfo->bundleName);
315 }
316 
GetEnterpriseInfo(napi_env env,napi_callback_info info)317 napi_value AdminManager::GetEnterpriseInfo(napi_env env, napi_callback_info info)
318 {
319     EDMLOGI("NAPI_GetEnterpriseInfo called");
320     size_t argc = ARGS_SIZE_TWO;
321     napi_value argv[ARGS_SIZE_TWO] = {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_ONE, "parameter count error");
326     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
327     if (argc > ARGS_SIZE_ONE) {
328         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
329     }
330     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
331     auto asyncCallbackInfo = new (std::nothrow) AsyncGetEnterpriseInfoCallbackInfo();
332     if (asyncCallbackInfo == nullptr) {
333         return nullptr;
334     }
335     std::unique_ptr<AsyncGetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
336     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
337     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
338     EDMLOGD(
339         "EnableAdmin: asyncCallbackInfo->elementName.bundlename %{public}s, "
340         "asyncCallbackInfo->abilityname:%{public}s",
341         asyncCallbackInfo->elementName.GetBundleName().c_str(),
342         asyncCallbackInfo->elementName.GetAbilityName().c_str());
343     if (argc > ARGS_SIZE_ONE) {
344         EDMLOGD("GetEnterpriseInfo by callback");
345         NAPI_CALL(env, napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
346     }
347 
348     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetEnterpriseInfo", NativeGetEnterpriseInfo,
349         NativeGetEnterpriseInfoComplete);
350     callbackPtr.release();
351     return asyncWorkReturn;
352 }
353 
NativeGetEnterpriseInfo(napi_env env,void * data)354 void AdminManager::NativeGetEnterpriseInfo(napi_env env, void *data)
355 {
356     EDMLOGI("NAPI_NativeGetEnterpriseInfo called");
357     if (data == nullptr) {
358         EDMLOGE("data is nullptr");
359         return;
360     }
361     AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
362     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
363     asyncCallbackInfo->ret = proxy->GetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
364 }
365 
NativeGetEnterpriseInfoComplete(napi_env env,napi_status status,void * data)366 void AdminManager::NativeGetEnterpriseInfoComplete(napi_env env, napi_status status, void *data)
367 {
368     if (data == nullptr) {
369         EDMLOGE("data is nullptr");
370         return;
371     }
372     AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
373 
374     napi_value result[2] = {0};
375     if (asyncCallbackInfo->ret == ERR_OK) {
376         napi_get_null(env, &result[ARR_INDEX_ZERO]);
377         napi_create_object(env, &result[ARR_INDEX_ONE]);
378         ConvertEnterpriseInfo(env, result[ARR_INDEX_ONE], asyncCallbackInfo->entInfo);
379         EDMLOGD(
380             "NativeGetEnterpriseInfoComplete::asyncCallbackInfo->entInfo->enterpriseName %{public}s, "
381             "asyncCallbackInfo->entInfo->description:%{public}s",
382             asyncCallbackInfo->entInfo.enterpriseName.c_str(), asyncCallbackInfo->entInfo.description.c_str());
383     } else {
384         result[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
385         napi_get_null(env, &result[ARR_INDEX_ONE]);
386     }
387     if (asyncCallbackInfo->deferred) {
388         if (asyncCallbackInfo->ret == ERR_OK) {
389             napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ONE]);
390         } else {
391             napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ZERO]);
392         }
393     } else {
394         napi_value callback = nullptr;
395         napi_value placeHolder = nullptr;
396         napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
397         napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[ARR_INDEX_ZERO]), result,
398             &placeHolder);
399         napi_delete_reference(env, asyncCallbackInfo->callback);
400     }
401     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
402     delete asyncCallbackInfo;
403     asyncCallbackInfo = nullptr;
404 }
405 
SetEnterpriseInfo(napi_env env,napi_callback_info info)406 napi_value AdminManager::SetEnterpriseInfo(napi_env env, napi_callback_info info)
407 {
408     EDMLOGI("NAPI_SetEnterpriseInfo called");
409     size_t argc = ARGS_SIZE_THREE;
410     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
411     napi_value thisArg = nullptr;
412     void *data = nullptr;
413     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
414     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
415     bool matchFlag =
416         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
417     if (argc > ARGS_SIZE_TWO) {
418         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
419     }
420     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
421     auto asyncCallbackInfo = new (std::nothrow) AsyncSetEnterpriseInfoCallbackInfo();
422     if (asyncCallbackInfo == nullptr) {
423         return nullptr;
424     }
425     std::unique_ptr<AsyncSetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
426     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
427     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
428     ret = ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]);
429     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "enterprise info param error");
430     EDMLOGD(
431         "SetEnterpriseInfo: asyncCallbackInfo->elementName.bundlename %{public}s, "
432         "asyncCallbackInfo->abilityname:%{public}s",
433         asyncCallbackInfo->elementName.GetBundleName().c_str(),
434         asyncCallbackInfo->elementName.GetAbilityName().c_str());
435     if (argc > ARGS_SIZE_TWO) {
436         NAPI_CALL(env, napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
437     }
438 
439     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetEnterpriseInfo", NativeSetEnterpriseInfo,
440         NativeVoidCallbackComplete);
441     callbackPtr.release();
442     return asyncWorkReturn;
443 }
444 
NativeSetEnterpriseInfo(napi_env env,void * data)445 void AdminManager::NativeSetEnterpriseInfo(napi_env env, void *data)
446 {
447     EDMLOGI("NAPI_NativeSetEnterpriseInfo called");
448     if (data == nullptr) {
449         EDMLOGE("data is nullptr");
450         return;
451     }
452     AsyncSetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetEnterpriseInfoCallbackInfo *>(data);
453     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
454     asyncCallbackInfo->ret = proxy->SetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
455 }
456 
SetAdminRunningMode(napi_env env,napi_callback_info info)457 napi_value AdminManager::SetAdminRunningMode(napi_env env, napi_callback_info info)
458 {
459     EDMLOGI("NAPI_SetAdminRunningMode called.");
460     size_t argc = ARGS_SIZE_TWO;
461     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
462     napi_value thisArg = nullptr;
463     void *data = nullptr;
464     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
465     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
466 
467     AppExecFwk::ElementName elementName;
468     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
469         "Parameter admin error");
470     int32_t runningMode;
471     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, runningMode, argv[ARR_INDEX_ONE]), "Parameter mode error");
472     int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->SetAdminRunningMode(elementName, runningMode);
473     if (FAILED(ret)) {
474         napi_throw(env, CreateError(env, ret));
475     }
476     return nullptr;
477 }
478 
IsSuperAdmin(napi_env env,napi_callback_info info)479 napi_value AdminManager::IsSuperAdmin(napi_env env, napi_callback_info info)
480 {
481     EDMLOGI("NAPI_IsSuperAdmin called");
482     size_t argc = ARGS_SIZE_TWO;
483     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
484     napi_value thisArg = nullptr;
485     void *data = nullptr;
486     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
487     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
488     auto asyncCallbackInfo = new (std::nothrow) AsyncIsSuperAdminCallbackInfo();
489     if (asyncCallbackInfo == nullptr) {
490         return nullptr;
491     }
492     std::unique_ptr<AsyncIsSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
493     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
494         "parameter bundle name error");
495     EDMLOGD("IsSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
496         asyncCallbackInfo->bundleName.c_str());
497     if (argc > ARGS_SIZE_ONE) {
498         bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
499         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
500         NAPI_CALL(env, napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
501     }
502 
503     napi_value asyncWorkReturn =
504         HandleAsyncWork(env, asyncCallbackInfo, "IsSuperAdmin", NativeIsSuperAdmin, NativeBoolCallbackComplete);
505     callbackPtr.release();
506     return asyncWorkReturn;
507 }
508 
IsByodAdmin(napi_env env,napi_callback_info info)509 napi_value AdminManager::IsByodAdmin(napi_env env, napi_callback_info info)
510 {
511     EDMLOGI("NAPI_IsByodAdmin called");
512     size_t argc = ARGS_SIZE_ONE;
513     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
514     napi_value thisArg = nullptr;
515     void *data = nullptr;
516     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
517     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
518     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
519     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
520     OHOS::AppExecFwk::ElementName elementName;
521     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
522         "Parameter elementName error");
523     bool activeStatus = false;
524     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
525     ErrCode ret = proxy->IsByodAdmin(elementName, activeStatus);
526     if (FAILED(ret)) {
527         napi_throw(env, CreateError(env, ret));
528     }
529     napi_value result = nullptr;
530     NAPI_CALL(env, napi_get_boolean(env, activeStatus, &result));
531     return result;
532 }
533 
IsAdminEnabled(napi_env env,napi_callback_info info)534 napi_value AdminManager::IsAdminEnabled(napi_env env, napi_callback_info info)
535 {
536     EDMLOGI("IsAdminEnabled called");
537     size_t argc = ARGS_SIZE_THREE;
538     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
539     napi_value thisArg = nullptr;
540     void *data = nullptr;
541     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
542     bool hasCallback = false;
543     bool hasUserId = false;
544     auto asyncCallbackInfo = new (std::nothrow) AsyncIsAdminEnabledCallbackInfo();
545     if (asyncCallbackInfo == nullptr) {
546         return nullptr;
547     }
548     std::unique_ptr<AsyncIsAdminEnabledCallbackInfo> callbackPtr{asyncCallbackInfo};
549     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
550     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
551         "Parameter type error");
552     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
553         "Parameter want error");
554     EDMLOGD(
555         "IsAdminEnabled::asyncCallbackInfo->elementName.bundlename %{public}s, "
556         "asyncCallbackInfo->abilityname:%{public}s",
557         asyncCallbackInfo->elementName.GetBundleName().c_str(),
558         asyncCallbackInfo->elementName.GetAbilityName().c_str());
559 
560     if (hasUserId) {
561         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
562             "Parameter user id error");
563     } else {
564 #ifdef OS_ACCOUNT_EDM_ENABLE
565         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
566 #endif
567     }
568     if (hasCallback) {
569         ASSERT_AND_THROW_PARAM_ERROR(env,
570             ParseCallback(env, asyncCallbackInfo->callback,
571                 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
572             "Parameter callback error");
573     }
574 
575     napi_value asyncWorkReturn =
576         HandleAsyncWork(env, asyncCallbackInfo, "isAdminEnabled", NativeIsAdminEnabled, NativeBoolCallbackComplete);
577     callbackPtr.release();
578     return asyncWorkReturn;
579 }
580 
NativeIsSuperAdmin(napi_env env,void * data)581 void AdminManager::NativeIsSuperAdmin(napi_env env, void *data)
582 {
583     EDMLOGI("NAPI_NativeIsSuperAdmin called");
584     if (data == nullptr) {
585         EDMLOGE("data is nullptr");
586         return;
587     }
588     AsyncIsSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsSuperAdminCallbackInfo *>(data);
589     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
590     asyncCallbackInfo->ret = proxy->IsSuperAdmin(asyncCallbackInfo->bundleName, asyncCallbackInfo->boolRet);
591 }
592 
NativeIsAdminEnabled(napi_env env,void * data)593 void AdminManager::NativeIsAdminEnabled(napi_env env, void *data)
594 {
595     EDMLOGI("NAPI_NativeIsAdminEnabled called");
596     if (data == nullptr) {
597         EDMLOGE("data is nullptr");
598         return;
599     }
600     AsyncIsAdminEnabledCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsAdminEnabledCallbackInfo *>(data);
601     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
602     asyncCallbackInfo->ret =
603         proxy->IsAdminEnabled(asyncCallbackInfo->elementName, asyncCallbackInfo->userId, asyncCallbackInfo->boolRet);
604 }
605 
SubscribeManagedEvent(napi_env env,napi_callback_info info)606 napi_value AdminManager::SubscribeManagedEvent(napi_env env, napi_callback_info info)
607 {
608     EDMLOGI("SubscribeManagedEvent called");
609     return HandleManagedEvent(env, info, true);
610 }
611 
UnsubscribeManagedEvent(napi_env env,napi_callback_info info)612 napi_value AdminManager::UnsubscribeManagedEvent(napi_env env, napi_callback_info info)
613 {
614     EDMLOGI("UnsubscribeManagedEvent called");
615     return HandleManagedEvent(env, info, false);
616 }
617 
HandleManagedEvent(napi_env env,napi_callback_info info,bool subscribe)618 napi_value AdminManager::HandleManagedEvent(napi_env env, napi_callback_info info, bool subscribe)
619 {
620     size_t argc = ARGS_SIZE_THREE;
621     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
622     napi_value thisArg = nullptr;
623     void *data = nullptr;
624     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
625     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
626     bool matchFlag =
627         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
628     if (argc > ARGS_SIZE_TWO) {
629         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
630     }
631     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
632     auto asyncCallbackInfo = new (std::nothrow) AsyncSubscribeManagedEventCallbackInfo();
633     if (asyncCallbackInfo == nullptr) {
634         return nullptr;
635     }
636     std::unique_ptr<AsyncSubscribeManagedEventCallbackInfo> callbackPtr{asyncCallbackInfo};
637     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
638     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
639     ret = ParseManagedEvent(env, asyncCallbackInfo->managedEvent, argv[ARR_INDEX_ONE]);
640     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "managed event param error");
641     if (argc > ARGS_SIZE_TWO) {
642         NAPI_CALL(env, napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
643     }
644     asyncCallbackInfo->subscribe = subscribe;
645     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SubscribeManagedEvent",
646         NativeSubscribeManagedEvent, NativeVoidCallbackComplete);
647     callbackPtr.release();
648     return asyncWorkReturn;
649 }
650 
NativeSubscribeManagedEvent(napi_env env,void * data)651 void AdminManager::NativeSubscribeManagedEvent(napi_env env, void *data)
652 {
653     EDMLOGI("NAPI_NativeSubscribeManagedEvent called");
654     if (data == nullptr) {
655         EDMLOGE("data is nullptr");
656         return;
657     }
658     AsyncSubscribeManagedEventCallbackInfo *asyncCallbakInfo =
659         static_cast<AsyncSubscribeManagedEventCallbackInfo *>(data);
660     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
661     asyncCallbakInfo->ret = proxy->HandleManagedEvent(asyncCallbakInfo->elementName, asyncCallbakInfo->managedEvent,
662         asyncCallbakInfo->subscribe);
663 }
664 
ParseEnterpriseInfo(napi_env env,EntInfo & enterpriseInfo,napi_value args)665 bool AdminManager::ParseEnterpriseInfo(napi_env env, EntInfo &enterpriseInfo, napi_value args)
666 {
667     napi_valuetype valueType;
668     if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
669         EDMLOGE("Parameter enterprise info error");
670         return false;
671     }
672     std::string name;
673     std::string description;
674     if (!JsObjectToString(env, args, "name", true, name) ||
675         !JsObjectToString(env, args, "description", true, description)) {
676         EDMLOGE("ParseEnterpriseInfo param error");
677         return false;
678     }
679     EDMLOGD("ParseEnterpriseInfo name %{public}s ", name.c_str());
680     EDMLOGD("ParseEnterpriseInfo description %{public}s", description.c_str());
681 
682     enterpriseInfo.enterpriseName = name;
683     enterpriseInfo.description = description;
684     return true;
685 }
686 
ConvertEnterpriseInfo(napi_env env,napi_value objEntInfo,EntInfo & entInfo)687 void AdminManager::ConvertEnterpriseInfo(napi_env env, napi_value objEntInfo, EntInfo &entInfo)
688 {
689     std::string enterpriseName = entInfo.enterpriseName;
690     std::string description = entInfo.description;
691     napi_value nEnterpriseName;
692     NAPI_CALL_RETURN_VOID(env,
693         napi_create_string_utf8(env, enterpriseName.c_str(), NAPI_AUTO_LENGTH, &nEnterpriseName));
694     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "name", nEnterpriseName));
695 
696     napi_value nDescription;
697     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
698     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "description", nDescription));
699 }
700 
ParseManagedEvent(napi_env env,std::vector<uint32_t> & managedEvent,napi_value args)701 bool AdminManager::ParseManagedEvent(napi_env env, std::vector<uint32_t> &managedEvent, napi_value args)
702 {
703     bool isArray = false;
704     if (napi_is_array(env, args, &isArray) != napi_ok || !isArray) {
705         return false;
706     }
707     uint32_t len;
708     if (napi_get_array_length(env, args, &len) != napi_ok) {
709         return false;
710     }
711     for (uint32_t i = 0; i < len; i++) {
712         napi_value event;
713         if (napi_get_element(env, args, i, &event) != napi_ok) {
714             return false;
715         }
716         uint32_t value = 0;
717         if (napi_get_value_uint32(env, event, &value) != napi_ok) {
718             return false;
719         }
720         managedEvent.push_back(value);
721     }
722     return true;
723 }
724 
AuthorizeAdmin(napi_env env,napi_callback_info info)725 napi_value AdminManager::AuthorizeAdmin(napi_env env, napi_callback_info info)
726 {
727     EDMLOGI("NAPI_AuthorizeAdmin called.");
728     size_t argc = ARGS_SIZE_THREE;
729     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
730     napi_value thisArg = nullptr;
731     void *data = nullptr;
732     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
733     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
734     auto asyncCallbackInfo = new (std::nothrow) AsyncAuthorizeAdminCallbackInfo();
735     if (asyncCallbackInfo == nullptr) {
736         return nullptr;
737     }
738     std::unique_ptr<AsyncAuthorizeAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
739     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
740         "Parameter want error");
741     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ONE]),
742         "parameter bundle name error");
743     EDMLOGD("AuthorizeAdmin: asyncCallbackInfo->bundlename %{public}s", asyncCallbackInfo->bundleName.c_str());
744     if (argc > ARR_INDEX_TWO) {
745         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback, argv[ARR_INDEX_TWO]),
746             "parameter bundle name error");
747     }
748     napi_value asyncWorkReturn =
749         HandleAsyncWork(env, asyncCallbackInfo, "AuthorizeAdmin", NativeAuthorizeAdmin, NativeVoidCallbackComplete);
750     callbackPtr.release();
751     return asyncWorkReturn;
752 }
753 
NativeAuthorizeAdmin(napi_env env,void * data)754 void AdminManager::NativeAuthorizeAdmin(napi_env env, void *data)
755 {
756     EDMLOGI("NAPI_NativeAuthorizeAdmin called.");
757     if (data == nullptr) {
758         EDMLOGE("data is nullptr");
759         return;
760     }
761     auto *asyncCallbakInfo = static_cast<AsyncAuthorizeAdminCallbackInfo *>(data);
762     asyncCallbakInfo->ret = EnterpriseDeviceMgrProxy::GetInstance()->AuthorizeAdmin(asyncCallbakInfo->elementName,
763         asyncCallbakInfo->bundleName);
764 }
765 
SetDelegatedPolicies(napi_env env,napi_callback_info info)766 napi_value AdminManager::SetDelegatedPolicies(napi_env env, napi_callback_info info)
767 {
768     EDMLOGI("NAPI_SetDelegatedPolicies called.");
769     size_t argc = ARGS_SIZE_THREE;
770     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
771     napi_value thisArg = nullptr;
772     void *data = nullptr;
773     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
774     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
775     bool matchFlag =
776         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
777     if (matchFlag) {
778         AppExecFwk::ElementName elementName;
779         ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
780             "Parameter admin error");
781         std::string bundleName;
782         ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, bundleName, argv[ARR_INDEX_ONE]),
783             "parameter bundleName error");
784         std::vector<std::string> policies;
785         ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, policies, argv[ARR_INDEX_TWO]),
786             "parameter policies error");
787         int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->SetDelegatedPolicies(elementName, bundleName, policies);
788         if (FAILED(ret)) {
789             napi_throw(env, CreateError(env, ret));
790         }
791     } else {
792         std::string bundleName;
793         ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, bundleName, argv[ARR_INDEX_ZERO]),
794             "parameter bundleName error");
795         std::vector<std::string> policies;
796         ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, policies, argv[ARR_INDEX_ONE]),
797             "parameter policies error");
798         int32_t userId = 0;
799         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_TWO]),
800             "Parameter user id error");
801         int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->SetDelegatedPolicies(bundleName, policies, userId);
802         if (FAILED(ret)) {
803             napi_throw(env, CreateError(env, ret));
804         }
805     }
806     return nullptr;
807 }
808 
GetDelegatedPolicies(napi_env env,napi_callback_info info)809 napi_value AdminManager::GetDelegatedPolicies(napi_env env, napi_callback_info info)
810 {
811     EDMLOGI("NAPI_GetDelegatedPolicies called.");
812     return GetDelegatedPolicies(env, info, EdmInterfaceCode::GET_DELEGATED_POLICIES);
813 }
814 
GetDelegatedBundleNames(napi_env env,napi_callback_info info)815 napi_value AdminManager::GetDelegatedBundleNames(napi_env env, napi_callback_info info)
816 {
817     EDMLOGI("NAPI_GetDelegatedBundleNames called.");
818     return GetDelegatedPolicies(env, info, EdmInterfaceCode::GET_DELEGATED_BUNDLE_NAMES);
819 }
820 
GetDelegatedPolicies(napi_env env,napi_callback_info info,uint32_t code)821 napi_value AdminManager::GetDelegatedPolicies(napi_env env, napi_callback_info info, uint32_t code)
822 {
823     size_t argc = ARGS_SIZE_TWO;
824     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
825     napi_value thisArg = nullptr;
826     void *data = nullptr;
827     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
828     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
829 
830     AppExecFwk::ElementName elementName;
831     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
832         "Parameter admin error");
833     std::string bundleOrPolicyName;
834     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, bundleOrPolicyName, argv[ARR_INDEX_ONE]),
835         "parameter bundleName or policyName error");
836     std::vector<std::string> policies;
837     int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->GetDelegatedPolicies(elementName, bundleOrPolicyName, code,
838         policies);
839     if (FAILED(ret)) {
840         napi_throw(env, CreateError(env, ret));
841         return nullptr;
842     }
843     napi_value result = nullptr;
844     NAPI_CALL(env, napi_create_array(env, &result));
845     ConvertStringVectorToJS(env, policies, result);
846     return result;
847 }
848 
GetAdmins(napi_env env,napi_callback_info info)849 napi_value AdminManager::GetAdmins(napi_env env, napi_callback_info info)
850 {
851     EDMLOGI("NAPI_GetAdmins called");
852     auto adapterAddonData = new (std::nothrow) AsyncGetAdminsCallbackInfo();
853     if (adapterAddonData == nullptr) {
854         return nullptr;
855     }
856     std::unique_ptr<AsyncGetAdminsCallbackInfo> callbackPtr{adapterAddonData};
857     napi_value asyncWorkReturn =
858         HandleAsyncWork(env, adapterAddonData, "GetAdmins", NativeGetAdmins, NativeGetAdminsComplete);
859     callbackPtr.release();
860     return asyncWorkReturn;
861 }
862 
StartAdminProvision(napi_env env,napi_callback_info info)863 napi_value AdminManager::StartAdminProvision(napi_env env, napi_callback_info info)
864 {
865     EDMLOGI("NAPI_StartAdminProvision called.");
866     size_t argc = ARGS_SIZE_FOUR;
867     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
868     napi_value thisArg = nullptr;
869     void *data = nullptr;
870     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
871     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "parameter count error");
872     AppExecFwk::ElementName elementName;
873     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
874         "Parameter admin error");
875     int32_t jsAdminType;
876     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, jsAdminType, argv[ARR_INDEX_ONE]),
877         "parameter adminType error");
878     bool stageMode = false;
879     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, argv[ARR_INDEX_TWO], stageMode);
880     ASSERT_AND_THROW_PARAM_ERROR(env, status == napi_ok && stageMode,
881         "Parse param context failed, must be a context of stageMode.");
882     auto context = OHOS::AbilityRuntime::GetStageModeContext(env, argv[ARR_INDEX_TWO]);
883     ASSERT_AND_THROW_PARAM_ERROR(env, context != nullptr, "Parse param context failed, must not be nullptr.");
884     auto uiAbilityContext = AbilityRuntime::Context::ConvertTo<AbilityRuntime::AbilityContext>(context);
885     ASSERT_AND_THROW_PARAM_ERROR(env, uiAbilityContext != nullptr,
886         "Parse param context failed, must be UIAbilityContext.");
887     std::map<std::string, std::string> parameters;
888     ASSERT_AND_THROW_PARAM_ERROR(env, ParseMapStringAndString(env, parameters, argv[ARR_INDEX_THREE]),
889         "parameter parameters error");
890     int32_t adminType = JsAdminTypeToAdminType(jsAdminType);
891     ASSERT_AND_THROW_PARAM_ERROR(env, CheckByodParams(elementName, uiAbilityContext->GetBundleName(), adminType,
892         parameters), "byod parameters error");
893     std::string bundleName;
894     ErrCode ret = EnterpriseDeviceMgrProxy::GetInstance()->CheckAndGetAdminProvisionInfo(elementName, bundleName);
895     if (FAILED(ret)) {
896         napi_throw(env, CreateError(env, ret));
897         return nullptr;
898     }
899     AppExecFwk::ElementName adminProvisionElement("", bundleName, ADMIN_PROVISIONING_ABILITY_NAME);
900     AAFwk::Want want;
901     want.SetElement(adminProvisionElement);
902     want.SetParam("bundleName", elementName.GetBundleName());
903     want.SetParam("abilityName", elementName.GetAbilityName());
904     for (auto &param : parameters) {
905         want.SetParam(param.first, param.second);
906     }
907     auto token = uiAbilityContext->GetToken();
908     ret = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, token);
909     if (FAILED(ret)) {
910         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
911     }
912     return nullptr;
913 }
914 
CheckByodParams(AppExecFwk::ElementName elementName,const std::string & callerBundleName,int32_t adminType,std::map<std::string,std::string> & parameters)915 bool AdminManager::CheckByodParams(AppExecFwk::ElementName elementName, const std::string &callerBundleName,
916     int32_t adminType, std::map<std::string, std::string> &parameters)
917 {
918     if (elementName.GetBundleName().empty() || elementName.GetAbilityName().empty()) {
919         EDMLOGE("CheckByodParams: bundleName or abilityName is empty.");
920         return false;
921     }
922     if (callerBundleName != elementName.GetBundleName()) {
923         EDMLOGE("CheckByodParams: callerBundleName is not the input bundleName.");
924         return false;
925     }
926     if (adminType != static_cast<int32_t>(AdminType::BYOD)) {
927         EDMLOGE("CheckByodParams: admin type is not byod.");
928         return false;
929     }
930     if (parameters.size() > MAX_ADMINPROVISION_PARAM_NUM) {
931         EDMLOGE("CheckByodParams: parameters size is too much. Max is ten.");
932         return false;
933     }
934     if (parameters.find(ACTIVATEID) == parameters.end()) {
935         EDMLOGE("CheckByodParams: activateId is not exist.");
936         return false;
937     }
938     size_t activateIdLen = parameters[ACTIVATEID].length();
939     if (activateIdLen < MIN_ACTIVATEID_LEN || activateIdLen > MAX_ACTIVATEID_LEN) {
940         EDMLOGE("CheckByodParams:the length of activateId is not in [32, 256].The length is %{public}zu",
941             activateIdLen);
942         return false;
943     }
944     if (parameters.find(CUSTOMIZEDINFO) != parameters.end() &&
945         parameters[CUSTOMIZEDINFO].length() > MAX_CUSTOMIZEDINFO_LEN) {
946         EDMLOGE("CheckByodParams: the length of customizedInfo is more than 10240.");
947         return false;
948     }
949     return true;
950 }
951 
CreateAdminTypeObject(napi_env env,napi_value value)952 void AdminManager::CreateAdminTypeObject(napi_env env, napi_value value)
953 {
954     napi_value nNomal;
955     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::NORMAL), &nNomal));
956     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_NORMAL", nNomal));
957     napi_value nSuper;
958     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::ENT), &nSuper));
959     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_SUPER", nSuper));
960     napi_value nByod;
961     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, JS_BYOD_TYPE, &nByod));
962     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_BYOD", nByod));
963 }
964 
CreateManagedEventObject(napi_env env,napi_value value)965 void AdminManager::CreateManagedEventObject(napi_env env, napi_value value)
966 {
967     napi_value nBundleAdded;
968     NAPI_CALL_RETURN_VOID(env,
969         napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_ADDED), &nBundleAdded));
970     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_ADDED", nBundleAdded));
971     napi_value nBundleRemoved;
972     NAPI_CALL_RETURN_VOID(env,
973         napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_REMOVED), &nBundleRemoved));
974     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_REMOVED", nBundleRemoved));
975     napi_value nAppStart;
976     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_START), &nAppStart));
977     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_START", nAppStart));
978     napi_value nAppStop;
979     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_STOP), &nAppStop));
980     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_STOP", nAppStop));
981     napi_value nSystemUpdate;
982     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::SYSTEM_UPDATE),
983         &nSystemUpdate));
984     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_SYSTEM_UPDATE", nSystemUpdate));
985     napi_value nUserAdded;
986     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::USER_ADDED),
987         &nUserAdded));
988     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_ACCOUNT_ADDED", nUserAdded));
989     napi_value nUserSwitched;
990     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::USER_SWITCHED),
991         &nUserSwitched));
992     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_ACCOUNT_SWITCHED", nUserSwitched));
993     napi_value nUserRemoved;
994     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::USER_REMOVED),
995         &nUserRemoved));
996     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_ACCOUNT_REMOVED", nUserRemoved));
997 }
998 
CreateRunningModeObject(napi_env env,napi_value value)999 void AdminManager::CreateRunningModeObject(napi_env env, napi_value value)
1000 {
1001     napi_value nDefault;
1002     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(RunningMode::DEFAULT), &nDefault));
1003     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DEFAULT", nDefault));
1004     napi_value nMultiUser;
1005     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(RunningMode::MULTI_USER), &nMultiUser));
1006     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MULTI_USER", nMultiUser));
1007 }
1008 
CreatePolicyObject(napi_env env,napi_value value)1009 void AdminManager::CreatePolicyObject(napi_env env, napi_value value)
1010 {
1011     napi_value nBlock;
1012     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(PolicyFlag::BLOCK_LIST), &nBlock));
1013     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "BLOCK_LIST", nBlock));
1014     napi_value nTrust;
1015     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(PolicyFlag::TRUST_LIST), &nTrust));
1016     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TRUST_LIST", nTrust));
1017 }
1018 
GetSuperAdmin(napi_env env,napi_callback_info info)1019 napi_value AdminManager::GetSuperAdmin(napi_env env, napi_callback_info info)
1020 {
1021     EDMLOGI("NAPI_GetSuperAdmin called");
1022     auto asyncCallbackInfo = new (std::nothrow) AsyncGetSuperAdminCallbackInfo();
1023     if (asyncCallbackInfo == nullptr) {
1024         return nullptr;
1025     }
1026     std::unique_ptr<AsyncGetSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
1027     napi_value asyncWorkReturn =
1028         HandleAsyncWork(env, asyncCallbackInfo, "GetSuperAdmin", NativeGetSuperAdmin, NativeGetSuperAdminComplete);
1029     callbackPtr.release();
1030     return asyncWorkReturn;
1031 }
1032 
NativeGetSuperAdmin(napi_env env,void * data)1033 void AdminManager::NativeGetSuperAdmin(napi_env env, void *data)
1034 {
1035     EDMLOGI("NAPI_NativeGetSuperAdmin called");
1036     if (data == nullptr) {
1037         EDMLOGE("data is nullptr");
1038         return;
1039     }
1040     AsyncGetSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetSuperAdminCallbackInfo *>(data);
1041     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
1042     asyncCallbackInfo->ret = proxy->GetSuperAdmin(asyncCallbackInfo->bundleName, asyncCallbackInfo->abilityName);
1043 }
1044 
NativeGetSuperAdminComplete(napi_env env,napi_status status,void * data)1045 void AdminManager::NativeGetSuperAdminComplete(napi_env env, napi_status status, void *data)
1046 {
1047     if (data == nullptr) {
1048         EDMLOGE("data is nullptr");
1049         return;
1050     }
1051     auto *asyncCallbackInfo = static_cast<AsyncGetSuperAdminCallbackInfo *>(data);
1052     if (asyncCallbackInfo->deferred != nullptr) {
1053         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
1054         if (asyncCallbackInfo->ret == ERR_OK) {
1055             napi_value accountValue = ConvertWantToJs(env, asyncCallbackInfo->bundleName,
1056                 asyncCallbackInfo->abilityName);
1057             napi_resolve_deferred(env, asyncCallbackInfo->deferred, accountValue);
1058         } else {
1059             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
1060         }
1061     }
1062     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1063     delete asyncCallbackInfo;
1064 }
1065 
NativeGetAdmins(napi_env env,void * data)1066 void AdminManager::NativeGetAdmins(napi_env env, void *data)
1067 {
1068     EDMLOGI("NAPI_NativeGetAdmins called");
1069     if (data == nullptr) {
1070         EDMLOGE("data is nullptr");
1071         return;
1072     }
1073     AsyncGetAdminsCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetAdminsCallbackInfo *>(data);
1074     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
1075     asyncCallbackInfo->ret = proxy->GetAdmins(asyncCallbackInfo->wants);
1076 }
1077 
NativeGetAdminsComplete(napi_env env,napi_status status,void * data)1078 void AdminManager::NativeGetAdminsComplete(napi_env env, napi_status status, void *data)
1079 {
1080     if (data == nullptr) {
1081         EDMLOGE("data is nullptr");
1082         return;
1083     }
1084     auto *asyncCallbackInfo = static_cast<AsyncGetAdminsCallbackInfo *>(data);
1085     if (asyncCallbackInfo->deferred != nullptr) {
1086         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
1087         if (asyncCallbackInfo->ret == ERR_OK) {
1088             napi_value admins = ConvertWantToJsWithType(env, asyncCallbackInfo->wants);
1089             napi_resolve_deferred(env, asyncCallbackInfo->deferred, admins);
1090         } else {
1091             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
1092         }
1093     }
1094     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1095     delete asyncCallbackInfo;
1096 }
1097 
ConvertWantToJs(napi_env env,const std::string & bundleName,const std::string & abilityName)1098 napi_value AdminManager::ConvertWantToJs(napi_env env, const std::string &bundleName,
1099     const std::string &abilityName)
1100 {
1101     napi_value result = nullptr;
1102     NAPI_CALL(env, napi_create_object(env, &result));
1103     napi_value bundleNameToJs = nullptr;
1104     NAPI_CALL(env, napi_create_string_utf8(env, bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleNameToJs));
1105     NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", bundleNameToJs));
1106     napi_value abilityNameToJs = nullptr;
1107     NAPI_CALL(env, napi_create_string_utf8(env, abilityName.c_str(), NAPI_AUTO_LENGTH, &abilityNameToJs));
1108     NAPI_CALL(env, napi_set_named_property(env, result, "abilityName", abilityNameToJs));
1109     return result;
1110 }
1111 
ConvertWantToJsWithType(napi_env env,std::vector<std::shared_ptr<AAFwk::Want>> & wants)1112 napi_value AdminManager::ConvertWantToJsWithType(napi_env env, std::vector<std::shared_ptr<AAFwk::Want>> &wants)
1113 {
1114     napi_value result = nullptr;
1115     NAPI_CALL(env, napi_create_array(env, &result));
1116     size_t idx = 0;
1117     for (std::shared_ptr<AAFwk::Want> want : wants) {
1118         std::string bundleName = want->GetStringParam("bundleName");
1119         std::string abilityName = want->GetStringParam("abilityName");
1120         int32_t adminType = want->GetIntParam("adminType", -1);
1121         if (bundleName.empty() || abilityName.empty() || adminType == -1) {
1122             napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
1123             return nullptr;
1124         }
1125         napi_value wantItem = ConvertWantToJs(env, bundleName, abilityName);
1126         if (wantItem == nullptr) {
1127             napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
1128             return nullptr;
1129         }
1130         napi_value parameters = nullptr;
1131         NAPI_CALL(env, napi_create_object(env, &parameters));
1132         napi_value adminTypeToJs = nullptr;
1133         NAPI_CALL(env, napi_create_int32(env, AdminTypeToJsAdminType(adminType), &adminTypeToJs));
1134         NAPI_CALL(env, napi_set_named_property(env, parameters, "adminType", adminTypeToJs));
1135         NAPI_CALL(env, napi_set_named_property(env, wantItem, "parameters", parameters));
1136         NAPI_CALL(env, napi_set_element(env, result, idx, wantItem));
1137     }
1138     return result;
1139 }
1140 
Init(napi_env env,napi_value exports)1141 napi_value AdminManager::Init(napi_env env, napi_value exports)
1142 {
1143     napi_value nAdminType = nullptr;
1144     NAPI_CALL(env, napi_create_object(env, &nAdminType));
1145     CreateAdminTypeObject(env, nAdminType);
1146 
1147     napi_value nManagedEvent = nullptr;
1148     NAPI_CALL(env, napi_create_object(env, &nManagedEvent));
1149     CreateManagedEventObject(env, nManagedEvent);
1150 
1151     napi_value nRunningMode = nullptr;
1152     NAPI_CALL(env, napi_create_object(env, &nRunningMode));
1153     CreateRunningModeObject(env, nRunningMode);
1154 
1155     napi_value nPolicy = nullptr;
1156     NAPI_CALL(env, napi_create_object(env, &nPolicy));
1157     CreatePolicyObject(env, nPolicy);
1158 
1159     napi_property_descriptor property[] = {
1160         DECLARE_NAPI_FUNCTION("enableAdmin", EnableAdmin),
1161         DECLARE_NAPI_FUNCTION("disableAdmin", DisableAdmin),
1162         DECLARE_NAPI_FUNCTION("disableSuperAdmin", DisableSuperAdmin),
1163         DECLARE_NAPI_FUNCTION("isAdminEnabled", IsAdminEnabled),
1164         DECLARE_NAPI_FUNCTION("getEnterpriseInfo", GetEnterpriseInfo),
1165         DECLARE_NAPI_FUNCTION("setEnterpriseInfo", SetEnterpriseInfo),
1166         DECLARE_NAPI_FUNCTION("isSuperAdmin", IsSuperAdmin),
1167         DECLARE_NAPI_FUNCTION("isByodAdmin", IsByodAdmin),
1168         DECLARE_NAPI_FUNCTION("subscribeManagedEvent", SubscribeManagedEvent),
1169         DECLARE_NAPI_FUNCTION("unsubscribeManagedEvent", UnsubscribeManagedEvent),
1170         DECLARE_NAPI_FUNCTION("authorizeAdmin", AuthorizeAdmin),
1171         DECLARE_NAPI_FUNCTION("subscribeManagedEventSync", SubscribeManagedEventSync),
1172         DECLARE_NAPI_FUNCTION("unsubscribeManagedEventSync", UnsubscribeManagedEventSync),
1173         DECLARE_NAPI_FUNCTION("getSuperAdmin", GetSuperAdmin),
1174         DECLARE_NAPI_FUNCTION("setDelegatedPolicies", SetDelegatedPolicies),
1175         DECLARE_NAPI_FUNCTION("getDelegatedPolicies", GetDelegatedPolicies),
1176         DECLARE_NAPI_FUNCTION("getDelegatedBundleNames", GetDelegatedBundleNames),
1177         DECLARE_NAPI_FUNCTION("startAdminProvision", StartAdminProvision),
1178         DECLARE_NAPI_FUNCTION("getAdmins", GetAdmins),
1179         DECLARE_NAPI_FUNCTION("replaceSuperAdmin", ReplaceSuperAdmin),
1180         DECLARE_NAPI_FUNCTION("setAdminRunningMode", SetAdminRunningMode),
1181 
1182         DECLARE_NAPI_PROPERTY("AdminType", nAdminType),
1183         DECLARE_NAPI_PROPERTY("ManagedEvent", nManagedEvent),
1184         DECLARE_NAPI_PROPERTY("RunningMode", nRunningMode),
1185         DECLARE_NAPI_PROPERTY("Policy", nPolicy),
1186     };
1187     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
1188     return exports;
1189 }
1190 
SubscribeManagedEventSync(napi_env env,napi_callback_info info)1191 napi_value AdminManager::SubscribeManagedEventSync(napi_env env, napi_callback_info info)
1192 {
1193     EDMLOGI("SubscribeManagedEvent called");
1194     return HandleManagedEventSync(env, info, true);
1195 }
1196 
UnsubscribeManagedEventSync(napi_env env,napi_callback_info info)1197 napi_value AdminManager::UnsubscribeManagedEventSync(napi_env env, napi_callback_info info)
1198 {
1199     EDMLOGI("UnsubscribeManagedEvent called");
1200     return HandleManagedEventSync(env, info, false);
1201 }
1202 
HandleManagedEventSync(napi_env env,napi_callback_info info,bool subscribe)1203 napi_value AdminManager::HandleManagedEventSync(napi_env env, napi_callback_info info, bool subscribe)
1204 {
1205     size_t argc = ARGS_SIZE_TWO;
1206     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1207     napi_value thisArg = nullptr;
1208     void *data = nullptr;
1209     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1210 
1211     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1212     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
1213     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
1214         "parameter managedEvents error");
1215     OHOS::AppExecFwk::ElementName elementName;
1216     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1217         "parameter admin parse error");
1218     std::vector<uint32_t> managedEvent;
1219     ASSERT_AND_THROW_PARAM_ERROR(env, ParseManagedEvent(env, managedEvent, argv[ARR_INDEX_ONE]),
1220         "parameter managedEvent parse error");
1221     EDMLOGD("HandleManagedEventSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
1222         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
1223 
1224     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
1225     int32_t ret = proxy->HandleManagedEvent(elementName, managedEvent, subscribe);
1226     if (FAILED(ret)) {
1227         napi_throw(env, CreateError(env, ret));
1228     }
1229     return nullptr;
1230 }
1231 
1232 static napi_module g_edmServiceModule = {
1233     .nm_version = 1,
1234     .nm_flags = 0,
1235     .nm_filename = nullptr,
1236     .nm_register_func = AdminManager::Init,
1237     .nm_modname = "enterprise.adminManager",
1238     .nm_priv = ((void *)0),
1239     .reserved = {0},
1240 };
1241 
EdmServiceRegister()1242 extern "C" __attribute__((constructor)) void EdmServiceRegister()
1243 {
1244     napi_module_register(&g_edmServiceModule);
1245 }
1246