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