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