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