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 "admin_manager_addon.h"
17 
18 #include "edm_log.h"
19 #include "hisysevent_adapter.h"
20 #include "if_system_ability_manager.h"
21 #include "iservice_registry.h"
22 #ifdef OS_ACCOUNT_EDM_ENABLE
23 #include "os_account_manager.h"
24 #endif
25 #include "system_ability_definition.h"
26 
27 using namespace OHOS::EDM;
28 
EnableAdmin(napi_env env,napi_callback_info info)29 napi_value AdminManager::EnableAdmin(napi_env env, napi_callback_info info)
30 {
31     EDMLOGI("NAPI_EnableAdmin called");
32     ReportEdmEvent(ReportType::EDM_FUNC_EVENT, "enableAdmin", "");
33     size_t argc = ARGS_SIZE_FIVE;
34     napi_value argv[ARGS_SIZE_FIVE] = {nullptr};
35     napi_value thisArg = nullptr;
36     void *data = nullptr;
37     bool hasCallback = false;
38     bool hasUserId = false;
39     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
40     auto asyncCallbackInfo = new (std::nothrow) AsyncEnableAdminCallbackInfo();
41     if (asyncCallbackInfo == nullptr) {
42         return nullptr;
43     }
44     std::unique_ptr<AsyncEnableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
45     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "Parameter count error");
46     ASSERT_AND_THROW_PARAM_ERROR(env, CheckEnableAdminParamType(env, argc, argv, hasCallback, hasUserId),
47         "Parameter type error");
48     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
49         "Parameter want error");
50     ASSERT_AND_THROW_PARAM_ERROR(env, ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]),
51         "Parameter enterprise info error");
52     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->adminType, argv[ARR_INDEX_TWO]),
53         "Parameter admin type error");
54 
55     EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
56         "asyncCallbackInfo->abilityname:%{public}s , adminType:%{public}d",
57         asyncCallbackInfo->elementName.GetBundleName().c_str(), asyncCallbackInfo->elementName.GetAbilityName().c_str(),
58         asyncCallbackInfo->adminType);
59     if (hasUserId) {
60         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_THREE]),
61             "Parameter user id error");
62     } else {
63 #ifdef OS_ACCOUNT_EDM_ENABLE
64         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
65 #endif
66     }
67     if (hasCallback) {
68         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback,
69             argc <= ARGS_SIZE_FIVE ? argv[argc - 1] : argv[ARR_INDEX_FOUR]), "Parameter callback error");
70     }
71     napi_value asyncWorkReturn =
72         HandleAsyncWork(env, asyncCallbackInfo, "EnableAdmin", NativeEnableAdmin, NativeVoidCallbackComplete);
73     callbackPtr.release();
74     return asyncWorkReturn;
75 }
76 
ParseAdminType(int32_t type)77 AdminType AdminManager::ParseAdminType(int32_t type)
78 {
79     if (type == static_cast<int32_t>(AdminType::NORMAL) || type == static_cast<int32_t>(AdminType::ENT)) {
80         return static_cast<AdminType>(type);
81     }
82     return AdminType::UNKNOWN;
83 }
84 
NativeEnableAdmin(napi_env env,void * data)85 void AdminManager::NativeEnableAdmin(napi_env env, void *data)
86 {
87     if (data == nullptr) {
88         EDMLOGE("data is nullptr");
89         return;
90     }
91     AsyncEnableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncEnableAdminCallbackInfo *>(data);
92     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
93 
94     asyncCallbackInfo->ret = proxy->EnableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo,
95         ParseAdminType(asyncCallbackInfo->adminType), asyncCallbackInfo->userId);
96 }
97 
CheckEnableAdminParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)98 bool AdminManager::CheckEnableAdminParamType(napi_env env, size_t argc, napi_value *argv, bool &hasCallback,
99     bool &hasUserId)
100 {
101     EDMLOGI("argc = %{public}zu", argc);
102     if (argc == ARGS_SIZE_THREE) {
103         hasCallback = false;
104         hasUserId = false;
105         EDMLOGI("hasCallback = false; hasUserId = false;");
106         return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
107             MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
108             MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
109     }
110 
111     if (argc == ARGS_SIZE_FOUR) {
112         if (MatchValueType(env, argv[ARR_INDEX_THREE], napi_function)) {
113             hasCallback = true;
114             hasUserId = false;
115             EDMLOGI("hasCallback = true; hasUserId = false;");
116             return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
117                 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
118                 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
119         } else {
120             hasCallback = false;
121             hasUserId = true;
122             EDMLOGI("hasCallback = false;  hasUserId = true;");
123             return 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_number) &&
126                 MatchValueType(env, argv[ARR_INDEX_THREE], napi_number);
127         }
128     }
129     hasCallback = true;
130     hasUserId = true;
131     EDMLOGI("hasCallback = true; hasUserId = true;");
132     return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
133         MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
134         MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
135         MatchValueType(env, argv[ARR_INDEX_THREE], napi_number) &&
136         MatchValueType(env, argv[ARR_INDEX_FOUR], napi_function);
137 }
138 
DisableAdmin(napi_env env,napi_callback_info info)139 napi_value AdminManager::DisableAdmin(napi_env env, napi_callback_info info)
140 {
141     EDMLOGI("NAPI_DisableAdmin called");
142     ReportEdmEvent(ReportType::EDM_FUNC_EVENT, "disableAdmin", "");
143     size_t argc = ARGS_SIZE_THREE;
144     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
145     napi_value thisArg = nullptr;
146     void *data = nullptr;
147     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
148     bool hasCallback = false;
149     bool hasUserId = false;
150     auto asyncCallbackInfo = new (std::nothrow) AsyncDisableAdminCallbackInfo();
151     if (asyncCallbackInfo == nullptr) {
152         return nullptr;
153     }
154     std::unique_ptr<AsyncDisableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
155     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
156     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
157         "Parameter type error");
158     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
159         "Parameter want error");
160 
161     EDMLOGD(
162         "DisableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
163         "asyncCallbackInfo->abilityname:%{public}s",
164         asyncCallbackInfo->elementName.GetBundleName().c_str(),
165         asyncCallbackInfo->elementName.GetAbilityName().c_str());
166     if (hasUserId) {
167         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
168             "Parameter user id error");
169     } else {
170 #ifdef OS_ACCOUNT_EDM_ENABLE
171         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
172 #endif
173     }
174     if (hasCallback) {
175         ASSERT_AND_THROW_PARAM_ERROR(env,
176             ParseCallback(env, asyncCallbackInfo->callback,
177                 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
178             "Parameter callback error");
179     }
180     napi_value asyncWorkReturn =
181         HandleAsyncWork(env, asyncCallbackInfo, "DisableAdmin", NativeDisableAdmin, NativeVoidCallbackComplete);
182     callbackPtr.release();
183     return asyncWorkReturn;
184 }
185 
NativeDisableAdmin(napi_env env,void * data)186 void AdminManager::NativeDisableAdmin(napi_env env, void *data)
187 {
188     EDMLOGI("NAPI_NativeDisableAdmin called");
189     if (data == nullptr) {
190         EDMLOGE("data is nullptr");
191         return;
192     }
193     AsyncDisableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableAdminCallbackInfo *>(data);
194     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
195 
196     asyncCallbackInfo->ret = proxy->DisableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->userId);
197 }
198 
DisableSuperAdmin(napi_env env,napi_callback_info info)199 napi_value AdminManager::DisableSuperAdmin(napi_env env, napi_callback_info info)
200 {
201     EDMLOGI("NAPI_DisableSuperAdmin called");
202     size_t argc = ARGS_SIZE_TWO;
203     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
204     napi_value thisArg = nullptr;
205     void *data = nullptr;
206     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
207     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
208 
209     auto asyncCallbackInfo = new (std::nothrow) AsyncDisableSuperAdminCallbackInfo();
210     if (asyncCallbackInfo == nullptr) {
211         return nullptr;
212     }
213     std::unique_ptr<AsyncDisableSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
214     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
215         "parameter bundle name error");
216     if (argc > ARGS_SIZE_ONE) {
217         bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
218         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
219         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
220     }
221 
222     EDMLOGD("DisableSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
223         asyncCallbackInfo->bundleName.c_str());
224     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisableSuperAdmin", NativeDisableSuperAdmin,
225         NativeVoidCallbackComplete);
226     callbackPtr.release();
227     return asyncWorkReturn;
228 }
229 
NativeDisableSuperAdmin(napi_env env,void * data)230 void AdminManager::NativeDisableSuperAdmin(napi_env env, void *data)
231 {
232     EDMLOGI("NAPI_NativeDisableSuperAdmin called");
233     if (data == nullptr) {
234         EDMLOGE("data is nullptr");
235         return;
236     }
237     AsyncDisableSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableSuperAdminCallbackInfo *>(data);
238     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
239     asyncCallbackInfo->ret = proxy->DisableSuperAdmin(asyncCallbackInfo->bundleName);
240 }
241 
GetEnterpriseInfo(napi_env env,napi_callback_info info)242 napi_value AdminManager::GetEnterpriseInfo(napi_env env, napi_callback_info info)
243 {
244     EDMLOGI("NAPI_GetEnterpriseInfo called");
245     size_t argc = ARGS_SIZE_TWO;
246     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
247     napi_value thisArg = nullptr;
248     void *data = nullptr;
249     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
250     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
251     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
252     if (argc > ARGS_SIZE_ONE) {
253         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
254     }
255     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
256     auto asyncCallbackInfo = new (std::nothrow) AsyncGetEnterpriseInfoCallbackInfo();
257     if (asyncCallbackInfo == nullptr) {
258         return nullptr;
259     }
260     std::unique_ptr<AsyncGetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
261     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
262     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
263     EDMLOGD(
264         "EnableAdmin: asyncCallbackInfo->elementName.bundlename %{public}s, "
265         "asyncCallbackInfo->abilityname:%{public}s",
266         asyncCallbackInfo->elementName.GetBundleName().c_str(),
267         asyncCallbackInfo->elementName.GetAbilityName().c_str());
268     if (argc > ARGS_SIZE_ONE) {
269         EDMLOGD("GetEnterpriseInfo by callback");
270         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
271     }
272 
273     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetEnterpriseInfo", NativeGetEnterpriseInfo,
274         NativeGetEnterpriseInfoComplete);
275     callbackPtr.release();
276     return asyncWorkReturn;
277 }
278 
NativeGetEnterpriseInfo(napi_env env,void * data)279 void AdminManager::NativeGetEnterpriseInfo(napi_env env, void *data)
280 {
281     EDMLOGI("NAPI_NativeGetEnterpriseInfo called");
282     if (data == nullptr) {
283         EDMLOGE("data is nullptr");
284         return;
285     }
286     AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
287     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
288     asyncCallbackInfo->ret = proxy->GetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
289 }
290 
NativeGetEnterpriseInfoComplete(napi_env env,napi_status status,void * data)291 void AdminManager::NativeGetEnterpriseInfoComplete(napi_env env, napi_status status, void *data)
292 {
293     if (data == nullptr) {
294         EDMLOGE("data is nullptr");
295         return;
296     }
297     AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
298 
299     napi_value result[2] = {0};
300     if (asyncCallbackInfo->ret == ERR_OK) {
301         napi_get_null(env, &result[ARR_INDEX_ZERO]);
302         napi_create_object(env, &result[ARR_INDEX_ONE]);
303         ConvertEnterpriseInfo(env, result[ARR_INDEX_ONE], asyncCallbackInfo->entInfo);
304         EDMLOGD(
305             "NativeGetEnterpriseInfoComplete::asyncCallbackInfo->entInfo->enterpriseName %{public}s, "
306             "asyncCallbackInfo->entInfo->description:%{public}s",
307             asyncCallbackInfo->entInfo.enterpriseName.c_str(), asyncCallbackInfo->entInfo.description.c_str());
308     } else {
309         result[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
310         napi_get_null(env, &result[ARR_INDEX_ONE]);
311     }
312     if (asyncCallbackInfo->deferred) {
313         if (asyncCallbackInfo->ret == ERR_OK) {
314             napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ONE]);
315         } else {
316             napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ZERO]);
317         }
318     } else {
319         napi_value callback = nullptr;
320         napi_value placeHolder = nullptr;
321         napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
322         napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[ARR_INDEX_ZERO]), result,
323             &placeHolder);
324         napi_delete_reference(env, asyncCallbackInfo->callback);
325     }
326     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
327     delete asyncCallbackInfo;
328     asyncCallbackInfo = nullptr;
329 }
330 
SetEnterpriseInfo(napi_env env,napi_callback_info info)331 napi_value AdminManager::SetEnterpriseInfo(napi_env env, napi_callback_info info)
332 {
333     EDMLOGI("NAPI_SetEnterpriseInfo called");
334     size_t argc = ARGS_SIZE_THREE;
335     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
336     napi_value thisArg = nullptr;
337     void *data = nullptr;
338     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
339     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
340     bool matchFlag =
341         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
342     if (argc > ARGS_SIZE_TWO) {
343         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
344     }
345     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
346     auto asyncCallbackInfo = new (std::nothrow) AsyncSetEnterpriseInfoCallbackInfo();
347     if (asyncCallbackInfo == nullptr) {
348         return nullptr;
349     }
350     std::unique_ptr<AsyncSetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
351     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
352     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
353     ret = ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]);
354     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "enterprise info param error");
355     EDMLOGD(
356         "SetEnterpriseInfo: asyncCallbackInfo->elementName.bundlename %{public}s, "
357         "asyncCallbackInfo->abilityname:%{public}s",
358         asyncCallbackInfo->elementName.GetBundleName().c_str(),
359         asyncCallbackInfo->elementName.GetAbilityName().c_str());
360     if (argc > ARGS_SIZE_TWO) {
361         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
362     }
363 
364     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetEnterpriseInfo", NativeSetEnterpriseInfo,
365         NativeVoidCallbackComplete);
366     callbackPtr.release();
367     return asyncWorkReturn;
368 }
369 
NativeSetEnterpriseInfo(napi_env env,void * data)370 void AdminManager::NativeSetEnterpriseInfo(napi_env env, void *data)
371 {
372     EDMLOGI("NAPI_NativeSetEnterpriseInfo called");
373     if (data == nullptr) {
374         EDMLOGE("data is nullptr");
375         return;
376     }
377     AsyncSetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetEnterpriseInfoCallbackInfo *>(data);
378     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
379     asyncCallbackInfo->ret = proxy->SetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
380 }
381 
IsSuperAdmin(napi_env env,napi_callback_info info)382 napi_value AdminManager::IsSuperAdmin(napi_env env, napi_callback_info info)
383 {
384     EDMLOGI("NAPI_IsSuperAdmin called");
385     size_t argc = ARGS_SIZE_TWO;
386     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
387     napi_value thisArg = nullptr;
388     void *data = nullptr;
389     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
390     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
391     auto asyncCallbackInfo = new (std::nothrow) AsyncIsSuperAdminCallbackInfo();
392     if (asyncCallbackInfo == nullptr) {
393         return nullptr;
394     }
395     std::unique_ptr<AsyncIsSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
396     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
397         "parameter bundle name error");
398     EDMLOGD("IsSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
399         asyncCallbackInfo->bundleName.c_str());
400     if (argc > ARGS_SIZE_ONE) {
401         bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
402         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
403         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
404     }
405 
406     napi_value asyncWorkReturn =
407         HandleAsyncWork(env, asyncCallbackInfo, "IsSuperAdmin", NativeIsSuperAdmin, NativeBoolCallbackComplete);
408     callbackPtr.release();
409     return asyncWorkReturn;
410 }
411 
IsAdminEnabled(napi_env env,napi_callback_info info)412 napi_value AdminManager::IsAdminEnabled(napi_env env, napi_callback_info info)
413 {
414     EDMLOGI("IsAdminEnabled called");
415     size_t argc = ARGS_SIZE_THREE;
416     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
417     napi_value thisArg = nullptr;
418     void *data = nullptr;
419     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
420     bool hasCallback = false;
421     bool hasUserId = false;
422     auto asyncCallbackInfo = new (std::nothrow) AsyncIsAdminEnabledCallbackInfo();
423     if (asyncCallbackInfo == nullptr) {
424         return nullptr;
425     }
426     std::unique_ptr<AsyncIsAdminEnabledCallbackInfo> callbackPtr{asyncCallbackInfo};
427     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
428     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
429         "Parameter type error");
430     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
431         "Parameter want error");
432     EDMLOGD(
433         "IsAdminEnabled::asyncCallbackInfo->elementName.bundlename %{public}s, "
434         "asyncCallbackInfo->abilityname:%{public}s",
435         asyncCallbackInfo->elementName.GetBundleName().c_str(),
436         asyncCallbackInfo->elementName.GetAbilityName().c_str());
437 
438     if (hasUserId) {
439         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
440             "Parameter user id error");
441     } else {
442 #ifdef OS_ACCOUNT_EDM_ENABLE
443         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
444 #endif
445     }
446     if (hasCallback) {
447         ASSERT_AND_THROW_PARAM_ERROR(env,
448             ParseCallback(env, asyncCallbackInfo->callback,
449                 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
450             "Parameter callback error");
451     }
452 
453     napi_value asyncWorkReturn =
454         HandleAsyncWork(env, asyncCallbackInfo, "isAdminEnabled", NativeIsAdminEnabled, NativeBoolCallbackComplete);
455     callbackPtr.release();
456     return asyncWorkReturn;
457 }
458 
NativeIsSuperAdmin(napi_env env,void * data)459 void AdminManager::NativeIsSuperAdmin(napi_env env, void *data)
460 {
461     EDMLOGI("NAPI_NativeIsSuperAdmin called");
462     if (data == nullptr) {
463         EDMLOGE("data is nullptr");
464         return;
465     }
466     AsyncIsSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsSuperAdminCallbackInfo *>(data);
467     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
468     asyncCallbackInfo->ret = proxy->IsSuperAdmin(asyncCallbackInfo->bundleName, asyncCallbackInfo->boolRet);
469 }
470 
NativeIsAdminEnabled(napi_env env,void * data)471 void AdminManager::NativeIsAdminEnabled(napi_env env, void *data)
472 {
473     EDMLOGI("NAPI_NativeIsAdminEnabled called");
474     if (data == nullptr) {
475         EDMLOGE("data is nullptr");
476         return;
477     }
478     AsyncIsAdminEnabledCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsAdminEnabledCallbackInfo *>(data);
479     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
480     asyncCallbackInfo->ret =
481         proxy->IsAdminEnabled(asyncCallbackInfo->elementName, asyncCallbackInfo->userId, asyncCallbackInfo->boolRet);
482 }
483 
SubscribeManagedEvent(napi_env env,napi_callback_info info)484 napi_value AdminManager::SubscribeManagedEvent(napi_env env, napi_callback_info info)
485 {
486     EDMLOGI("SubscribeManagedEvent called");
487     return HandleManagedEvent(env, info, true);
488 }
489 
UnsubscribeManagedEvent(napi_env env,napi_callback_info info)490 napi_value AdminManager::UnsubscribeManagedEvent(napi_env env, napi_callback_info info)
491 {
492     EDMLOGI("UnsubscribeManagedEvent called");
493     return HandleManagedEvent(env, info, false);
494 }
495 
HandleManagedEvent(napi_env env,napi_callback_info info,bool subscribe)496 napi_value AdminManager::HandleManagedEvent(napi_env env, napi_callback_info info, bool subscribe)
497 {
498     size_t argc = ARGS_SIZE_THREE;
499     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
500     napi_value thisArg = nullptr;
501     void *data = nullptr;
502     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
503     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
504     bool matchFlag =
505         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
506     if (argc > ARGS_SIZE_TWO) {
507         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
508     }
509     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
510     auto asyncCallbackInfo = new (std::nothrow) AsyncSubscribeManagedEventCallbackInfo();
511     if (asyncCallbackInfo == nullptr) {
512         return nullptr;
513     }
514     std::unique_ptr<AsyncSubscribeManagedEventCallbackInfo> callbackPtr{asyncCallbackInfo};
515     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
516     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
517     ret = ParseManagedEvent(env, asyncCallbackInfo->managedEvent, argv[ARR_INDEX_ONE]);
518     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "managed event param error");
519     if (argc > ARGS_SIZE_TWO) {
520         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
521     }
522     asyncCallbackInfo->subscribe = subscribe;
523     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SubscribeManagedEvent",
524         NativeSubscribeManagedEvent, NativeVoidCallbackComplete);
525     callbackPtr.release();
526     return asyncWorkReturn;
527 }
528 
NativeSubscribeManagedEvent(napi_env env,void * data)529 void AdminManager::NativeSubscribeManagedEvent(napi_env env, void *data)
530 {
531     EDMLOGI("NAPI_NativeSubscribeManagedEvent called");
532     if (data == nullptr) {
533         EDMLOGE("data is nullptr");
534         return;
535     }
536     AsyncSubscribeManagedEventCallbackInfo *asyncCallbakInfo =
537         static_cast<AsyncSubscribeManagedEventCallbackInfo *>(data);
538     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
539     asyncCallbakInfo->ret = proxy->HandleManagedEvent(asyncCallbakInfo->elementName, asyncCallbakInfo->managedEvent,
540         asyncCallbakInfo->subscribe);
541 }
542 
ParseEnterpriseInfo(napi_env env,EntInfo & enterpriseInfo,napi_value args)543 bool AdminManager::ParseEnterpriseInfo(napi_env env, EntInfo &enterpriseInfo, napi_value args)
544 {
545     napi_valuetype valueType;
546     if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
547         EDMLOGE("Parameter enterprise info error");
548         return false;
549     }
550     std::string name;
551     std::string description;
552     if (!JsObjectToString(env, args, "name", true, name) ||
553         !JsObjectToString(env, args, "description", true, description)) {
554         EDMLOGE("ParseEnterpriseInfo param error");
555         return false;
556     }
557     EDMLOGD("ParseEnterpriseInfo name %{public}s ", name.c_str());
558     EDMLOGD("ParseEnterpriseInfo description %{public}s", description.c_str());
559 
560     enterpriseInfo.enterpriseName = name;
561     enterpriseInfo.description = description;
562     return true;
563 }
564 
ConvertEnterpriseInfo(napi_env env,napi_value objEntInfo,EntInfo & entInfo)565 void AdminManager::ConvertEnterpriseInfo(napi_env env, napi_value objEntInfo, EntInfo &entInfo)
566 {
567     std::string enterpriseName = entInfo.enterpriseName;
568     std::string description = entInfo.description;
569     napi_value nEnterpriseName;
570     NAPI_CALL_RETURN_VOID(env,
571         napi_create_string_utf8(env, enterpriseName.c_str(), NAPI_AUTO_LENGTH, &nEnterpriseName));
572     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "name", nEnterpriseName));
573 
574     napi_value nDescription;
575     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
576     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "description", nDescription));
577 }
578 
ParseManagedEvent(napi_env env,std::vector<uint32_t> & managedEvent,napi_value args)579 bool AdminManager::ParseManagedEvent(napi_env env, std::vector<uint32_t> &managedEvent, napi_value args)
580 {
581     uint32_t len;
582     if (napi_get_array_length(env, args, &len) != napi_ok) {
583         return false;
584     }
585     for (uint32_t i = 0; i < len; i++) {
586         napi_value event;
587         if (napi_get_element(env, args, i, &event) != napi_ok) {
588             return false;
589         }
590         uint32_t value = 0;
591         if (napi_get_value_uint32(env, event, &value) != napi_ok) {
592             return false;
593         }
594         managedEvent.push_back(value);
595     }
596     return true;
597 }
598 
AuthorizeAdmin(napi_env env,napi_callback_info info)599 napi_value AdminManager::AuthorizeAdmin(napi_env env, napi_callback_info info)
600 {
601     EDMLOGI("NAPI_AuthorizeAdmin called.");
602     size_t argc = ARGS_SIZE_THREE;
603     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
604     napi_value thisArg = nullptr;
605     void *data = nullptr;
606     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
607     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
608     auto asyncCallbackInfo = new (std::nothrow) AsyncAuthorizeAdminCallbackInfo();
609     if (asyncCallbackInfo == nullptr) {
610         return nullptr;
611     }
612     std::unique_ptr<AsyncAuthorizeAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
613     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
614         "Parameter want error");
615     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ONE]),
616         "parameter bundle name error");
617     EDMLOGD("AuthorizeAdmin: asyncCallbackInfo->bundlename %{public}s", asyncCallbackInfo->bundleName.c_str());
618     if (argc > ARR_INDEX_TWO) {
619         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback, argv[ARR_INDEX_TWO]),
620             "parameter bundle name error");
621     }
622     napi_value asyncWorkReturn =
623         HandleAsyncWork(env, asyncCallbackInfo, "AuthorizeAdmin", NativeAuthorizeAdmin, NativeVoidCallbackComplete);
624     callbackPtr.release();
625     return asyncWorkReturn;
626 }
627 
NativeAuthorizeAdmin(napi_env env,void * data)628 void AdminManager::NativeAuthorizeAdmin(napi_env env, void *data)
629 {
630     EDMLOGI("NAPI_NativeAuthorizeAdmin called.");
631     if (data == nullptr) {
632         EDMLOGE("data is nullptr");
633         return;
634     }
635     auto *asyncCallbakInfo = static_cast<AsyncAuthorizeAdminCallbackInfo *>(data);
636     asyncCallbakInfo->ret = EnterpriseDeviceMgrProxy::GetInstance()->AuthorizeAdmin(asyncCallbakInfo->elementName,
637         asyncCallbakInfo->bundleName);
638 }
639 
SetDelegatedPolicies(napi_env env,napi_callback_info info)640 napi_value AdminManager::SetDelegatedPolicies(napi_env env, napi_callback_info info)
641 {
642     EDMLOGI("NAPI_SetDelegatedPolicies called.");
643     size_t argc = ARGS_SIZE_THREE;
644     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
645     napi_value thisArg = nullptr;
646     void *data = nullptr;
647     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
648     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
649 
650     AppExecFwk::ElementName elementName;
651     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
652         "Parameter admin error");
653     std::string bundleName;
654     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, bundleName, argv[ARR_INDEX_ONE]),
655         "parameter bundleName error");
656     std::vector<std::string> policies;
657     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, policies, argv[ARR_INDEX_TWO]),
658         "parameter policies error");
659     int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->SetDelegatedPolicies(elementName, bundleName, policies);
660     if (FAILED(ret)) {
661         napi_throw(env, CreateError(env, ret));
662     }
663     return nullptr;
664 }
665 
GetDelegatedPolicies(napi_env env,napi_callback_info info)666 napi_value AdminManager::GetDelegatedPolicies(napi_env env, napi_callback_info info)
667 {
668     EDMLOGI("NAPI_GetDelegatedPolicies called.");
669     return GetDelegatedPolicies(env, info, EdmInterfaceCode::GET_DELEGATED_POLICIES);
670 }
671 
GetDelegatedBundleNames(napi_env env,napi_callback_info info)672 napi_value AdminManager::GetDelegatedBundleNames(napi_env env, napi_callback_info info)
673 {
674     EDMLOGI("NAPI_GetDelegatedBundleNames called.");
675     return GetDelegatedPolicies(env, info, EdmInterfaceCode::GET_DELEGATED_BUNDLE_NAMES);
676 }
677 
GetDelegatedPolicies(napi_env env,napi_callback_info info,uint32_t code)678 napi_value AdminManager::GetDelegatedPolicies(napi_env env, napi_callback_info info, uint32_t code)
679 {
680     size_t argc = ARGS_SIZE_TWO;
681     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
682     napi_value thisArg = nullptr;
683     void *data = nullptr;
684     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
685     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
686 
687     AppExecFwk::ElementName elementName;
688     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
689         "Parameter admin error");
690     std::string bundleOrPolicyName;
691     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, bundleOrPolicyName, argv[ARR_INDEX_ONE]),
692         "parameter bundleName or policyName error");
693     std::vector<std::string> policies;
694     int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->GetDelegatedPolicies(elementName, bundleOrPolicyName, code,
695         policies);
696     if (FAILED(ret)) {
697         napi_throw(env, CreateError(env, ret));
698         return nullptr;
699     }
700     napi_value result = nullptr;
701     napi_create_array(env, &result);
702     ConvertStringVectorToJS(env, policies, result);
703     return result;
704 }
705 
CreateAdminTypeObject(napi_env env,napi_value value)706 void AdminManager::CreateAdminTypeObject(napi_env env, napi_value value)
707 {
708     napi_value nNomal;
709     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::NORMAL), &nNomal));
710     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_NORMAL", nNomal));
711     napi_value nSuper;
712     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::ENT), &nSuper));
713     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_SUPER", nSuper));
714 }
715 
CreateManagedEventObject(napi_env env,napi_value value)716 void AdminManager::CreateManagedEventObject(napi_env env, napi_value value)
717 {
718     napi_value nBundleAdded;
719     NAPI_CALL_RETURN_VOID(env,
720         napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_ADDED), &nBundleAdded));
721     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_ADDED", nBundleAdded));
722     napi_value nBundleRemoved;
723     NAPI_CALL_RETURN_VOID(env,
724         napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_REMOVED), &nBundleRemoved));
725     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_REMOVED", nBundleRemoved));
726     napi_value nAppStart;
727     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_START), &nAppStart));
728     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_START", nAppStart));
729     napi_value nAppStop;
730     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_STOP), &nAppStop));
731     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_STOP", nAppStop));
732     napi_value nSystemUpdate;
733     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::SYSTEM_UPDATE),
734         &nSystemUpdate));
735     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_SYSTEM_UPDATE", nSystemUpdate));
736 }
737 
GetSuperAdmin(napi_env env,napi_callback_info info)738 napi_value AdminManager::GetSuperAdmin(napi_env env, napi_callback_info info)
739 {
740     EDMLOGI("NAPI_GetSuperAdmin called");
741     auto asyncCallbackInfo = new (std::nothrow) AsyncGetSuperAdminCallbackInfo();
742     if (asyncCallbackInfo == nullptr) {
743         return nullptr;
744     }
745     std::unique_ptr<AsyncGetSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
746     napi_value asyncWorkReturn =
747         HandleAsyncWork(env, asyncCallbackInfo, "GetSuperAdmin", NativeGetSuperAdmin, NativeGetSuperAdminComplete);
748     callbackPtr.release();
749     return asyncWorkReturn;
750 }
751 
NativeGetSuperAdmin(napi_env env,void * data)752 void AdminManager::NativeGetSuperAdmin(napi_env env, void *data)
753 {
754     EDMLOGI("NAPI_NativeGetSuperAdmin called");
755     if (data == nullptr) {
756         EDMLOGE("data is nullptr");
757         return;
758     }
759     AsyncGetSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetSuperAdminCallbackInfo *>(data);
760     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
761     asyncCallbackInfo->ret = proxy->GetSuperAdmin(asyncCallbackInfo->bundleName, asyncCallbackInfo->abilityName);
762 }
763 
NativeGetSuperAdminComplete(napi_env env,napi_status status,void * data)764 void AdminManager::NativeGetSuperAdminComplete(napi_env env, napi_status status, void *data)
765 {
766     if (data == nullptr) {
767         EDMLOGE("data is nullptr");
768         return;
769     }
770     auto *asyncCallbackInfo = static_cast<AsyncGetSuperAdminCallbackInfo *>(data);
771     if (asyncCallbackInfo->deferred != nullptr) {
772         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
773         if (asyncCallbackInfo->ret == ERR_OK) {
774             napi_value accountValue = ConvertWantToJs(env, asyncCallbackInfo->bundleName,
775                 asyncCallbackInfo->abilityName);
776             napi_resolve_deferred(env, asyncCallbackInfo->deferred, accountValue);
777         } else {
778             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
779         }
780     }
781     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
782     delete asyncCallbackInfo;
783 }
784 
ConvertWantToJs(napi_env env,const std::string & bundleName,const std::string & abilityName)785 napi_value AdminManager::ConvertWantToJs(napi_env env, const std::string &bundleName,
786     const std::string &abilityName)
787 {
788     napi_value result = nullptr;
789     NAPI_CALL(env, napi_create_object(env, &result));
790     napi_value bundleNameToJs = nullptr;
791     NAPI_CALL(env, napi_create_string_utf8(env, bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleNameToJs));
792     NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", bundleNameToJs));
793     napi_value abilityNameToJs = nullptr;
794     NAPI_CALL(env, napi_create_string_utf8(env, abilityName.c_str(), NAPI_AUTO_LENGTH, &abilityNameToJs));
795     NAPI_CALL(env, napi_set_named_property(env, result, "abilityName", abilityNameToJs));
796     return result;
797 }
798 
Init(napi_env env,napi_value exports)799 napi_value AdminManager::Init(napi_env env, napi_value exports)
800 {
801     napi_value nAdminType = nullptr;
802     NAPI_CALL(env, napi_create_object(env, &nAdminType));
803     CreateAdminTypeObject(env, nAdminType);
804 
805     napi_value nManagedEvent = nullptr;
806     NAPI_CALL(env, napi_create_object(env, &nManagedEvent));
807     CreateManagedEventObject(env, nManagedEvent);
808 
809     napi_property_descriptor property[] = {
810         DECLARE_NAPI_FUNCTION("enableAdmin", EnableAdmin),
811         DECLARE_NAPI_FUNCTION("disableAdmin", DisableAdmin),
812         DECLARE_NAPI_FUNCTION("disableSuperAdmin", DisableSuperAdmin),
813         DECLARE_NAPI_FUNCTION("isAdminEnabled", IsAdminEnabled),
814         DECLARE_NAPI_FUNCTION("getEnterpriseInfo", GetEnterpriseInfo),
815         DECLARE_NAPI_FUNCTION("setEnterpriseInfo", SetEnterpriseInfo),
816         DECLARE_NAPI_FUNCTION("isSuperAdmin", IsSuperAdmin),
817         DECLARE_NAPI_FUNCTION("subscribeManagedEvent", SubscribeManagedEvent),
818         DECLARE_NAPI_FUNCTION("unsubscribeManagedEvent", UnsubscribeManagedEvent),
819         DECLARE_NAPI_FUNCTION("authorizeAdmin", AuthorizeAdmin),
820         DECLARE_NAPI_FUNCTION("subscribeManagedEventSync", SubscribeManagedEventSync),
821         DECLARE_NAPI_FUNCTION("unsubscribeManagedEventSync", UnsubscribeManagedEventSync),
822         DECLARE_NAPI_FUNCTION("getSuperAdmin", GetSuperAdmin),
823         DECLARE_NAPI_FUNCTION("setDelegatedPolicies", SetDelegatedPolicies),
824         DECLARE_NAPI_FUNCTION("getDelegatedPolicies", GetDelegatedPolicies),
825         DECLARE_NAPI_FUNCTION("getDelegatedBundleNames", GetDelegatedBundleNames),
826 
827         DECLARE_NAPI_PROPERTY("AdminType", nAdminType),
828         DECLARE_NAPI_PROPERTY("ManagedEvent", nManagedEvent),
829     };
830     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
831     return exports;
832 }
833 
SubscribeManagedEventSync(napi_env env,napi_callback_info info)834 napi_value AdminManager::SubscribeManagedEventSync(napi_env env, napi_callback_info info)
835 {
836     EDMLOGI("SubscribeManagedEvent called");
837     return HandleManagedEventSync(env, info, true);
838 }
839 
UnsubscribeManagedEventSync(napi_env env,napi_callback_info info)840 napi_value AdminManager::UnsubscribeManagedEventSync(napi_env env, napi_callback_info info)
841 {
842     EDMLOGI("UnsubscribeManagedEvent called");
843     return HandleManagedEventSync(env, info, false);
844 }
845 
HandleManagedEventSync(napi_env env,napi_callback_info info,bool subscribe)846 napi_value AdminManager::HandleManagedEventSync(napi_env env, napi_callback_info info, bool subscribe)
847 {
848     size_t argc = ARGS_SIZE_TWO;
849     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
850     napi_value thisArg = nullptr;
851     void *data = nullptr;
852     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
853 
854     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
855     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
856     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
857         "parameter managedEvents error");
858     OHOS::AppExecFwk::ElementName elementName;
859     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
860         "parameter admin parse error");
861     std::vector<uint32_t> managedEvent;
862     ASSERT_AND_THROW_PARAM_ERROR(env, ParseManagedEvent(env, managedEvent, argv[ARR_INDEX_ONE]),
863         "parameter managedEvent parse error");
864     EDMLOGD("HandleManagedEventSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
865         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
866 
867     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
868     int32_t ret = proxy->HandleManagedEvent(elementName, managedEvent, subscribe);
869     if (FAILED(ret)) {
870         napi_throw(env, CreateError(env, ret));
871     }
872     return nullptr;
873 }
874 
875 static napi_module g_edmServiceModule = {
876     .nm_version = 1,
877     .nm_flags = 0,
878     .nm_filename = nullptr,
879     .nm_register_func = AdminManager::Init,
880     .nm_modname = "enterprise.adminManager",
881     .nm_priv = ((void *)0),
882     .reserved = {0},
883 };
884 
EdmServiceRegister()885 extern "C" __attribute__((constructor)) void EdmServiceRegister()
886 {
887     napi_module_register(&g_edmServiceModule);
888 }
889