1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "admin_manager_addon.h"
17
18 #include "edm_log.h"
19 #include "hisysevent_adapter.h"
20 #include "if_system_ability_manager.h"
21 #include "iservice_registry.h"
22 #include "os_account_manager.h"
23 #include "system_ability_definition.h"
24
25 using namespace OHOS::EDM;
26
EnableAdmin(napi_env env,napi_callback_info info)27 napi_value AdminManager::EnableAdmin(napi_env env, napi_callback_info info)
28 {
29 EDMLOGI("NAPI_EnableAdmin called");
30 ReportEdmEvent(ReportType::EDM_FUNC_EVENT, "enableAdmin", "");
31 size_t argc = ARGS_SIZE_FIVE;
32 napi_value argv[ARGS_SIZE_FIVE] = {nullptr};
33 napi_value thisArg = nullptr;
34 void *data = nullptr;
35 bool hasCallback = false;
36 bool hasUserId = false;
37 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
38 auto asyncCallbackInfo = new (std::nothrow) AsyncEnableAdminCallbackInfo();
39 if (asyncCallbackInfo == nullptr) {
40 return nullptr;
41 }
42 std::unique_ptr<AsyncEnableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
43 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "Parameter count error");
44 ASSERT_AND_THROW_PARAM_ERROR(env, CheckEnableAdminParamType(env, argc, argv, hasCallback, hasUserId),
45 "Parameter type error");
46 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
47 "Parameter want error");
48 ASSERT_AND_THROW_PARAM_ERROR(env, ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]),
49 "Parameter enterprise info error");
50 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->adminType, argv[ARR_INDEX_TWO]),
51 "Parameter admin type error");
52
53 EDMLOGD(
54 "EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
55 "asyncCallbackInfo->abilityname:%{public}s , adminType:%{public}d",
56 asyncCallbackInfo->elementName.GetBundleName().c_str(), asyncCallbackInfo->elementName.GetAbilityName().c_str(),
57 asyncCallbackInfo->adminType);
58 if (hasUserId) {
59 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_THREE]),
60 "Parameter user id error");
61 } else {
62 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
63 }
64 if (hasCallback) {
65 ASSERT_AND_THROW_PARAM_ERROR(env,
66 ParseCallback(env, asyncCallbackInfo->callback,
67 argc <= ARGS_SIZE_FIVE ? argv[argc - 1] : argv[ARR_INDEX_FOUR]),
68 "Parameter callback error");
69 }
70 napi_value asyncWorkReturn =
71 HandleAsyncWork(env, asyncCallbackInfo, "EnableAdmin", NativeEnableAdmin, NativeVoidCallbackComplete);
72 callbackPtr.release();
73 return asyncWorkReturn;
74 }
75
ParseAdminType(int32_t type)76 AdminType AdminManager::ParseAdminType(int32_t type)
77 {
78 if (type == static_cast<int32_t>(AdminType::NORMAL) || type == static_cast<int32_t>(AdminType::ENT)) {
79 return static_cast<AdminType>(type);
80 }
81 return AdminType::UNKNOWN;
82 }
83
NativeEnableAdmin(napi_env env,void * data)84 void AdminManager::NativeEnableAdmin(napi_env env, void *data)
85 {
86 if (data == nullptr) {
87 EDMLOGE("data is nullptr");
88 return;
89 }
90 AsyncEnableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncEnableAdminCallbackInfo *>(data);
91 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
92 if (proxy == nullptr) {
93 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
94 return;
95 }
96
97 asyncCallbackInfo->ret = proxy->EnableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo,
98 ParseAdminType(asyncCallbackInfo->adminType), asyncCallbackInfo->userId);
99 }
100
CheckEnableAdminParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)101 bool AdminManager::CheckEnableAdminParamType(napi_env env, size_t argc, napi_value *argv, bool &hasCallback,
102 bool &hasUserId)
103 {
104 EDMLOGI("argc = %{public}zu", argc);
105 if (argc == ARGS_SIZE_THREE) {
106 hasCallback = false;
107 hasUserId = false;
108 EDMLOGI("hasCallback = false; hasUserId = false;");
109 return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
110 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
111 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
112 }
113
114 if (argc == ARGS_SIZE_FOUR) {
115 if (MatchValueType(env, argv[ARR_INDEX_THREE], napi_function)) {
116 hasCallback = true;
117 hasUserId = false;
118 EDMLOGI("hasCallback = true; hasUserId = false;");
119 return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
120 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
121 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
122 } else {
123 hasCallback = false;
124 hasUserId = true;
125 EDMLOGI("hasCallback = false; hasUserId = true;");
126 return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
127 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
128 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
129 MatchValueType(env, argv[ARR_INDEX_THREE], napi_number);
130 }
131 }
132 hasCallback = true;
133 hasUserId = true;
134 EDMLOGI("hasCallback = true; hasUserId = true;");
135 return MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
136 MatchValueType(env, argv[ARR_INDEX_ONE], napi_object) &&
137 MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
138 MatchValueType(env, argv[ARR_INDEX_THREE], napi_number) &&
139 MatchValueType(env, argv[ARR_INDEX_FOUR], napi_function);
140 }
141
DisableAdmin(napi_env env,napi_callback_info info)142 napi_value AdminManager::DisableAdmin(napi_env env, napi_callback_info info)
143 {
144 EDMLOGI("NAPI_DisableAdmin called");
145 ReportEdmEvent(ReportType::EDM_FUNC_EVENT, "disableAdmin", "");
146 size_t argc = ARGS_SIZE_THREE;
147 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
148 napi_value thisArg = nullptr;
149 void *data = nullptr;
150 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
151 bool hasCallback = false;
152 bool hasUserId = false;
153 auto asyncCallbackInfo = new (std::nothrow) AsyncDisableAdminCallbackInfo();
154 if (asyncCallbackInfo == nullptr) {
155 return nullptr;
156 }
157 std::unique_ptr<AsyncDisableAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
158 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
159 ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
160 "Parameter type error");
161 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
162 "Parameter want error");
163
164 EDMLOGD(
165 "DisableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
166 "asyncCallbackInfo->abilityname:%{public}s",
167 asyncCallbackInfo->elementName.GetBundleName().c_str(),
168 asyncCallbackInfo->elementName.GetAbilityName().c_str());
169 if (hasUserId) {
170 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
171 "Parameter user id error");
172 } else {
173 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
174 }
175 if (hasCallback) {
176 ASSERT_AND_THROW_PARAM_ERROR(env,
177 ParseCallback(env, asyncCallbackInfo->callback,
178 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
179 "Parameter callback error");
180 }
181 napi_value asyncWorkReturn =
182 HandleAsyncWork(env, asyncCallbackInfo, "DisableAdmin", NativeDisableAdmin, NativeVoidCallbackComplete);
183 callbackPtr.release();
184 return asyncWorkReturn;
185 }
186
NativeDisableAdmin(napi_env env,void * data)187 void AdminManager::NativeDisableAdmin(napi_env env, void *data)
188 {
189 EDMLOGI("NAPI_NativeDisableAdmin called");
190 if (data == nullptr) {
191 EDMLOGE("data is nullptr");
192 return;
193 }
194 AsyncDisableAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableAdminCallbackInfo *>(data);
195 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
196 if (proxy == nullptr) {
197 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
198 return;
199 }
200
201 asyncCallbackInfo->ret = proxy->DisableAdmin(asyncCallbackInfo->elementName, asyncCallbackInfo->userId);
202 }
203
DisableSuperAdmin(napi_env env,napi_callback_info info)204 napi_value AdminManager::DisableSuperAdmin(napi_env env, napi_callback_info info)
205 {
206 EDMLOGI("NAPI_DisableSuperAdmin called");
207 size_t argc = ARGS_SIZE_TWO;
208 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
209 napi_value thisArg = nullptr;
210 void *data = nullptr;
211 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
212 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
213
214 auto asyncCallbackInfo = new (std::nothrow) AsyncDisableSuperAdminCallbackInfo();
215 if (asyncCallbackInfo == nullptr) {
216 return nullptr;
217 }
218 std::unique_ptr<AsyncDisableSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
219 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
220 "parameter bundle name error");
221 if (argc > ARGS_SIZE_ONE) {
222 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
223 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
224 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
225 }
226
227 EDMLOGD("DisableSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
228 asyncCallbackInfo->bundleName.c_str());
229 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisableSuperAdmin", NativeDisableSuperAdmin,
230 NativeVoidCallbackComplete);
231 callbackPtr.release();
232 return asyncWorkReturn;
233 }
234
NativeDisableSuperAdmin(napi_env env,void * data)235 void AdminManager::NativeDisableSuperAdmin(napi_env env, void *data)
236 {
237 EDMLOGI("NAPI_NativeDisableSuperAdmin called");
238 if (data == nullptr) {
239 EDMLOGE("data is nullptr");
240 return;
241 }
242 AsyncDisableSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncDisableSuperAdminCallbackInfo *>(data);
243 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
244 if (proxy == nullptr) {
245 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
246 return;
247 }
248 asyncCallbackInfo->ret = proxy->DisableSuperAdmin(asyncCallbackInfo->bundleName);
249 }
250
GetEnterpriseInfo(napi_env env,napi_callback_info info)251 napi_value AdminManager::GetEnterpriseInfo(napi_env env, napi_callback_info info)
252 {
253 EDMLOGI("NAPI_GetEnterpriseInfo called");
254 size_t argc = ARGS_SIZE_TWO;
255 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
256 napi_value thisArg = nullptr;
257 void *data = nullptr;
258 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
259 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
260 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
261 if (argc > ARGS_SIZE_ONE) {
262 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
263 }
264 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
265 auto asyncCallbackInfo = new (std::nothrow) AsyncGetEnterpriseInfoCallbackInfo();
266 if (asyncCallbackInfo == nullptr) {
267 return nullptr;
268 }
269 std::unique_ptr<AsyncGetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
270 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
271 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
272 EDMLOGD(
273 "EnableAdmin: asyncCallbackInfo->elementName.bundlename %{public}s, "
274 "asyncCallbackInfo->abilityname:%{public}s",
275 asyncCallbackInfo->elementName.GetBundleName().c_str(),
276 asyncCallbackInfo->elementName.GetAbilityName().c_str());
277 if (argc > ARGS_SIZE_ONE) {
278 EDMLOGD("GetEnterpriseInfo by callback");
279 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
280 }
281
282 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetEnterpriseInfo", NativeGetEnterpriseInfo,
283 NativeGetEnterpriseInfoComplete);
284 callbackPtr.release();
285 return asyncWorkReturn;
286 }
287
NativeGetEnterpriseInfo(napi_env env,void * data)288 void AdminManager::NativeGetEnterpriseInfo(napi_env env, void *data)
289 {
290 EDMLOGI("NAPI_NativeGetEnterpriseInfo called");
291 if (data == nullptr) {
292 EDMLOGE("data is nullptr");
293 return;
294 }
295 AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
296 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
297 if (proxy == nullptr) {
298 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
299 return;
300 }
301 asyncCallbackInfo->ret = proxy->GetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
302 }
303
NativeGetEnterpriseInfoComplete(napi_env env,napi_status status,void * data)304 void AdminManager::NativeGetEnterpriseInfoComplete(napi_env env, napi_status status, void *data)
305 {
306 if (data == nullptr) {
307 EDMLOGE("data is nullptr");
308 return;
309 }
310 AsyncGetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetEnterpriseInfoCallbackInfo *>(data);
311
312 napi_value result[2] = {0};
313 if (asyncCallbackInfo->ret == ERR_OK) {
314 napi_get_null(env, &result[ARR_INDEX_ZERO]);
315 napi_create_object(env, &result[ARR_INDEX_ONE]);
316 ConvertEnterpriseInfo(env, result[ARR_INDEX_ONE], asyncCallbackInfo->entInfo);
317 EDMLOGD(
318 "NativeGetEnterpriseInfoComplete::asyncCallbackInfo->entInfo->enterpriseName %{public}s, "
319 "asyncCallbackInfo->entInfo->description:%{public}s",
320 asyncCallbackInfo->entInfo.enterpriseName.c_str(), asyncCallbackInfo->entInfo.description.c_str());
321 } else {
322 result[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
323 napi_get_null(env, &result[ARR_INDEX_ONE]);
324 }
325 if (asyncCallbackInfo->deferred) {
326 if (asyncCallbackInfo->ret == ERR_OK) {
327 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ONE]);
328 } else {
329 napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARR_INDEX_ZERO]);
330 }
331 } else {
332 napi_value callback = nullptr;
333 napi_value placeHolder = nullptr;
334 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
335 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[ARR_INDEX_ZERO]), result,
336 &placeHolder);
337 napi_delete_reference(env, asyncCallbackInfo->callback);
338 }
339 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
340 delete asyncCallbackInfo;
341 asyncCallbackInfo = nullptr;
342 }
343
SetEnterpriseInfo(napi_env env,napi_callback_info info)344 napi_value AdminManager::SetEnterpriseInfo(napi_env env, napi_callback_info info)
345 {
346 EDMLOGI("NAPI_SetEnterpriseInfo called");
347 size_t argc = ARGS_SIZE_THREE;
348 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
349 napi_value thisArg = nullptr;
350 void *data = nullptr;
351 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
352 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
353 bool matchFlag =
354 MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
355 if (argc > ARGS_SIZE_TWO) {
356 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
357 }
358 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
359 auto asyncCallbackInfo = new (std::nothrow) AsyncSetEnterpriseInfoCallbackInfo();
360 if (asyncCallbackInfo == nullptr) {
361 return nullptr;
362 }
363 std::unique_ptr<AsyncSetEnterpriseInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
364 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
365 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
366 ret = ParseEnterpriseInfo(env, asyncCallbackInfo->entInfo, argv[ARR_INDEX_ONE]);
367 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "enterprise info param error");
368 EDMLOGD(
369 "SetEnterpriseInfo: asyncCallbackInfo->elementName.bundlename %{public}s, "
370 "asyncCallbackInfo->abilityname:%{public}s",
371 asyncCallbackInfo->elementName.GetBundleName().c_str(),
372 asyncCallbackInfo->elementName.GetAbilityName().c_str());
373 if (argc > ARGS_SIZE_TWO) {
374 napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
375 }
376
377 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetEnterpriseInfo", NativeSetEnterpriseInfo,
378 NativeVoidCallbackComplete);
379 callbackPtr.release();
380 return asyncWorkReturn;
381 }
382
NativeSetEnterpriseInfo(napi_env env,void * data)383 void AdminManager::NativeSetEnterpriseInfo(napi_env env, void *data)
384 {
385 EDMLOGI("NAPI_NativeSetEnterpriseInfo called");
386 if (data == nullptr) {
387 EDMLOGE("data is nullptr");
388 return;
389 }
390 AsyncSetEnterpriseInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetEnterpriseInfoCallbackInfo *>(data);
391 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
392 if (proxy == nullptr) {
393 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
394 return;
395 }
396 asyncCallbackInfo->ret = proxy->SetEnterpriseInfo(asyncCallbackInfo->elementName, asyncCallbackInfo->entInfo);
397 }
398
IsSuperAdmin(napi_env env,napi_callback_info info)399 napi_value AdminManager::IsSuperAdmin(napi_env env, napi_callback_info info)
400 {
401 EDMLOGI("NAPI_IsSuperAdmin called");
402 size_t argc = ARGS_SIZE_TWO;
403 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
404 napi_value thisArg = nullptr;
405 void *data = nullptr;
406 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
407 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
408 auto asyncCallbackInfo = new (std::nothrow) AsyncIsSuperAdminCallbackInfo();
409 if (asyncCallbackInfo == nullptr) {
410 return nullptr;
411 }
412 std::unique_ptr<AsyncIsSuperAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
413 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ZERO]),
414 "parameter bundle name error");
415 EDMLOGD("IsSuperAdmin: asyncCallbackInfo->elementName.bundlename %{public}s",
416 asyncCallbackInfo->bundleName.c_str());
417 if (argc > ARGS_SIZE_ONE) {
418 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
419 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
420 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
421 }
422
423 napi_value asyncWorkReturn =
424 HandleAsyncWork(env, asyncCallbackInfo, "IsSuperAdmin", NativeIsSuperAdmin, NativeBoolCallbackComplete);
425 callbackPtr.release();
426 return asyncWorkReturn;
427 }
428
IsAdminEnabled(napi_env env,napi_callback_info info)429 napi_value AdminManager::IsAdminEnabled(napi_env env, napi_callback_info info)
430 {
431 EDMLOGI("IsAdminEnabled called");
432 size_t argc = ARGS_SIZE_THREE;
433 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
434 napi_value thisArg = nullptr;
435 void *data = nullptr;
436 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
437 bool hasCallback = false;
438 bool hasUserId = false;
439 auto asyncCallbackInfo = new (std::nothrow) AsyncIsAdminEnabledCallbackInfo();
440 if (asyncCallbackInfo == nullptr) {
441 return nullptr;
442 }
443 std::unique_ptr<AsyncIsAdminEnabledCallbackInfo> callbackPtr{asyncCallbackInfo};
444 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
445 ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
446 "Parameter type error");
447 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
448 "Parameter want error");
449 EDMLOGD(
450 "IsAdminEnabled::asyncCallbackInfo->elementName.bundlename %{public}s, "
451 "asyncCallbackInfo->abilityname:%{public}s",
452 asyncCallbackInfo->elementName.GetBundleName().c_str(),
453 asyncCallbackInfo->elementName.GetAbilityName().c_str());
454
455 if (hasUserId) {
456 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
457 "Parameter user id error");
458 } else {
459 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
460 }
461 if (hasCallback) {
462 ASSERT_AND_THROW_PARAM_ERROR(env,
463 ParseCallback(env, asyncCallbackInfo->callback,
464 argc <= ARGS_SIZE_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
465 "Parameter callback error");
466 }
467
468 napi_value asyncWorkReturn =
469 HandleAsyncWork(env, asyncCallbackInfo, "isAdminEnabled", NativeIsAdminEnabled, NativeBoolCallbackComplete);
470 callbackPtr.release();
471 return asyncWorkReturn;
472 }
473
NativeIsSuperAdmin(napi_env env,void * data)474 void AdminManager::NativeIsSuperAdmin(napi_env env, void *data)
475 {
476 EDMLOGI("NAPI_NativeIsSuperAdmin called");
477 if (data == nullptr) {
478 EDMLOGE("data is nullptr");
479 return;
480 }
481 AsyncIsSuperAdminCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsSuperAdminCallbackInfo *>(data);
482 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
483 if (proxy == nullptr) {
484 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
485 return;
486 }
487 asyncCallbackInfo->ret = proxy->IsSuperAdmin(asyncCallbackInfo->bundleName, asyncCallbackInfo->boolRet);
488 }
489
NativeIsAdminEnabled(napi_env env,void * data)490 void AdminManager::NativeIsAdminEnabled(napi_env env, void *data)
491 {
492 EDMLOGI("NAPI_NativeIsAdminEnabled called");
493 if (data == nullptr) {
494 EDMLOGE("data is nullptr");
495 return;
496 }
497 AsyncIsAdminEnabledCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsAdminEnabledCallbackInfo *>(data);
498 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
499 if (proxy == nullptr) {
500 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
501 return;
502 }
503 asyncCallbackInfo->ret =
504 proxy->IsAdminEnabled(asyncCallbackInfo->elementName, asyncCallbackInfo->userId, asyncCallbackInfo->boolRet);
505 }
506
SubscribeManagedEvent(napi_env env,napi_callback_info info)507 napi_value AdminManager::SubscribeManagedEvent(napi_env env, napi_callback_info info)
508 {
509 EDMLOGI("SubscribeManagedEvent called");
510 return HandleManagedEvent(env, info, true);
511 }
512
UnsubscribeManagedEvent(napi_env env,napi_callback_info info)513 napi_value AdminManager::UnsubscribeManagedEvent(napi_env env, napi_callback_info info)
514 {
515 EDMLOGI("UnsubscribeManagedEvent called");
516 return HandleManagedEvent(env, info, false);
517 }
518
HandleManagedEvent(napi_env env,napi_callback_info info,bool subscribe)519 napi_value AdminManager::HandleManagedEvent(napi_env env, napi_callback_info info, bool subscribe)
520 {
521 size_t argc = ARGS_SIZE_THREE;
522 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
523 napi_value thisArg = nullptr;
524 void *data = nullptr;
525 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
526 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
527 bool matchFlag =
528 MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
529 if (argc > ARGS_SIZE_TWO) {
530 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
531 }
532 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
533 auto asyncCallbackInfo = new (std::nothrow) AsyncSubscribeManagedEventCallbackInfo();
534 if (asyncCallbackInfo == nullptr) {
535 return nullptr;
536 }
537 std::unique_ptr<AsyncSubscribeManagedEventCallbackInfo> callbackPtr{asyncCallbackInfo};
538 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
539 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
540 ret = ParseManagedEvent(env, asyncCallbackInfo->managedEvent, argv[ARR_INDEX_ONE]);
541 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "managed event param error");
542 if (argc > ARGS_SIZE_TWO) {
543 napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
544 }
545 asyncCallbackInfo->subscribe = subscribe;
546 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SubscribeManagedEvent",
547 NativeSubscribeManagedEvent, NativeVoidCallbackComplete);
548 callbackPtr.release();
549 return asyncWorkReturn;
550 }
551
NativeSubscribeManagedEvent(napi_env env,void * data)552 void AdminManager::NativeSubscribeManagedEvent(napi_env env, void *data)
553 {
554 EDMLOGI("NAPI_NativeSubscribeManagedEvent called");
555 if (data == nullptr) {
556 EDMLOGE("data is nullptr");
557 return;
558 }
559 AsyncSubscribeManagedEventCallbackInfo *asyncCallbakInfo =
560 static_cast<AsyncSubscribeManagedEventCallbackInfo *>(data);
561 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
562 if (proxy == nullptr) {
563 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
564 return;
565 }
566 asyncCallbakInfo->ret = proxy->HandleManagedEvent(asyncCallbakInfo->elementName, asyncCallbakInfo->managedEvent,
567 asyncCallbakInfo->subscribe);
568 }
569
ParseEnterpriseInfo(napi_env env,EntInfo & enterpriseInfo,napi_value args)570 bool AdminManager::ParseEnterpriseInfo(napi_env env, EntInfo &enterpriseInfo, napi_value args)
571 {
572 napi_valuetype valueType;
573 if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
574 EDMLOGE("Parameter enterprise info error");
575 return false;
576 }
577 std::string name;
578 std::string description;
579 if (!JsObjectToString(env, args, "name", true, name) ||
580 !JsObjectToString(env, args, "description", true, description)) {
581 EDMLOGE("ParseEnterpriseInfo param error");
582 return false;
583 }
584 EDMLOGD("ParseEnterpriseInfo name %{public}s ", name.c_str());
585 EDMLOGD("ParseEnterpriseInfo description %{public}s", description.c_str());
586
587 enterpriseInfo.enterpriseName = name;
588 enterpriseInfo.description = description;
589 return true;
590 }
591
ConvertEnterpriseInfo(napi_env env,napi_value objEntInfo,EntInfo & entInfo)592 void AdminManager::ConvertEnterpriseInfo(napi_env env, napi_value objEntInfo, EntInfo &entInfo)
593 {
594 std::string enterpriseName = entInfo.enterpriseName;
595 std::string description = entInfo.description;
596 napi_value nEnterpriseName;
597 NAPI_CALL_RETURN_VOID(env,
598 napi_create_string_utf8(env, enterpriseName.c_str(), NAPI_AUTO_LENGTH, &nEnterpriseName));
599 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "name", nEnterpriseName));
600
601 napi_value nDescription;
602 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
603 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objEntInfo, "description", nDescription));
604 }
605
ParseManagedEvent(napi_env env,std::vector<uint32_t> & managedEvent,napi_value args)606 bool AdminManager::ParseManagedEvent(napi_env env, std::vector<uint32_t> &managedEvent, napi_value args)
607 {
608 uint32_t len;
609 if (napi_get_array_length(env, args, &len) != napi_ok) {
610 return false;
611 }
612 for (uint32_t i = 0; i < len; i++) {
613 napi_value event;
614 if (napi_get_element(env, args, i, &event) != napi_ok) {
615 return false;
616 }
617 uint32_t value = 0;
618 if (napi_get_value_uint32(env, event, &value) != napi_ok) {
619 return false;
620 }
621 managedEvent.push_back(value);
622 }
623 return true;
624 }
625
AuthorizeAdmin(napi_env env,napi_callback_info info)626 napi_value AdminManager::AuthorizeAdmin(napi_env env, napi_callback_info info)
627 {
628 EDMLOGI("NAPI_AuthorizeAdmin called.");
629 size_t argc = ARGS_SIZE_THREE;
630 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
631 napi_value thisArg = nullptr;
632 void *data = nullptr;
633 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
634 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
635 auto asyncCallbackInfo = new (std::nothrow) AsyncAuthorizeAdminCallbackInfo();
636 if (asyncCallbackInfo == nullptr) {
637 return nullptr;
638 }
639 std::unique_ptr<AsyncAuthorizeAdminCallbackInfo> callbackPtr{asyncCallbackInfo};
640 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
641 "Parameter want error");
642 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ONE]),
643 "parameter bundle name error");
644 EDMLOGD("AuthorizeAdmin: asyncCallbackInfo->bundlename %{public}s", asyncCallbackInfo->bundleName.c_str());
645 if (argc > ARR_INDEX_TWO) {
646 ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback, argv[ARR_INDEX_TWO]),
647 "parameter bundle name error");
648 }
649 napi_value asyncWorkReturn =
650 HandleAsyncWork(env, asyncCallbackInfo, "AuthorizeAdmin", NativeAuthorizeAdmin, NativeVoidCallbackComplete);
651 callbackPtr.release();
652 return asyncWorkReturn;
653 }
654
NativeAuthorizeAdmin(napi_env env,void * data)655 void AdminManager::NativeAuthorizeAdmin(napi_env env, void *data)
656 {
657 EDMLOGI("NAPI_NativeAuthorizeAdmin called.");
658 if (data == nullptr) {
659 EDMLOGE("data is nullptr");
660 return;
661 }
662 auto *asyncCallbakInfo = static_cast<AsyncAuthorizeAdminCallbackInfo *>(data);
663 asyncCallbakInfo->ret = EnterpriseDeviceMgrProxy::GetInstance()->AuthorizeAdmin(asyncCallbakInfo->elementName,
664 asyncCallbakInfo->bundleName);
665 }
666
CreateAdminTypeObject(napi_env env,napi_value value)667 void AdminManager::CreateAdminTypeObject(napi_env env, napi_value value)
668 {
669 napi_value nNomal;
670 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::NORMAL), &nNomal));
671 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_NORMAL", nNomal));
672 napi_value nSuper;
673 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(AdminType::ENT), &nSuper));
674 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ADMIN_TYPE_SUPER", nSuper));
675 }
676
CreateManagedEventObject(napi_env env,napi_value value)677 void AdminManager::CreateManagedEventObject(napi_env env, napi_value value)
678 {
679 napi_value nBundleAdded;
680 NAPI_CALL_RETURN_VOID(env,
681 napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_ADDED), &nBundleAdded));
682 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_ADDED", nBundleAdded));
683 napi_value nBundleRemoved;
684 NAPI_CALL_RETURN_VOID(env,
685 napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::BUNDLE_REMOVED), &nBundleRemoved));
686 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_BUNDLE_REMOVED", nBundleRemoved));
687 napi_value nAppStart;
688 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_START), &nAppStart));
689 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_START", nAppStart));
690 napi_value nAppStop;
691 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(ManagedEvent::APP_STOP), &nAppStop));
692 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "MANAGED_EVENT_APP_STOP", nAppStop));
693 }
694
Init(napi_env env,napi_value exports)695 napi_value AdminManager::Init(napi_env env, napi_value exports)
696 {
697 napi_value nAdminType = nullptr;
698 NAPI_CALL(env, napi_create_object(env, &nAdminType));
699 CreateAdminTypeObject(env, nAdminType);
700
701 napi_value nManagedEvent = nullptr;
702 NAPI_CALL(env, napi_create_object(env, &nManagedEvent));
703 CreateManagedEventObject(env, nManagedEvent);
704
705 napi_property_descriptor property[] = {
706 DECLARE_NAPI_FUNCTION("enableAdmin", EnableAdmin),
707 DECLARE_NAPI_FUNCTION("disableAdmin", DisableAdmin),
708 DECLARE_NAPI_FUNCTION("disableSuperAdmin", DisableSuperAdmin),
709 DECLARE_NAPI_FUNCTION("isAdminEnabled", IsAdminEnabled),
710 DECLARE_NAPI_FUNCTION("getEnterpriseInfo", GetEnterpriseInfo),
711 DECLARE_NAPI_FUNCTION("setEnterpriseInfo", SetEnterpriseInfo),
712 DECLARE_NAPI_FUNCTION("isSuperAdmin", IsSuperAdmin),
713 DECLARE_NAPI_FUNCTION("subscribeManagedEvent", SubscribeManagedEvent),
714 DECLARE_NAPI_FUNCTION("unsubscribeManagedEvent", UnsubscribeManagedEvent),
715 DECLARE_NAPI_FUNCTION("authorizeAdmin", AuthorizeAdmin),
716
717 DECLARE_NAPI_PROPERTY("AdminType", nAdminType),
718 DECLARE_NAPI_PROPERTY("ManagedEvent", nManagedEvent),
719 };
720 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
721 return exports;
722 }
723
724 static napi_module g_edmServiceModule = {
725 .nm_version = 1,
726 .nm_flags = 0,
727 .nm_filename = nullptr,
728 .nm_register_func = AdminManager::Init,
729 .nm_modname = "enterprise.adminManager",
730 .nm_priv = ((void *)0),
731 .reserved = {0},
732 };
733
EdmServiceRegister()734 extern "C" __attribute__((constructor)) void EdmServiceRegister()
735 {
736 napi_module_register(&g_edmServiceModule);
737 }
738