1 /*
2 * Copyright (c) 2023-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 "device_control_addon.h"
17 #include "operate_device_param.h"
18 #ifdef OS_ACCOUNT_EDM_ENABLE
19 #include "os_account_manager.h"
20 #endif
21 #include "edm_log.h"
22
23 using namespace OHOS::EDM;
24
Init(napi_env env,napi_value exports)25 napi_value DeviceControlAddon::Init(napi_env env, napi_value exports)
26 {
27 napi_property_descriptor property[] = {
28 DECLARE_NAPI_FUNCTION("resetFactory", ResetFactory),
29 DECLARE_NAPI_FUNCTION("shutdown", Shutdown),
30 DECLARE_NAPI_FUNCTION("reboot", Reboot),
31 DECLARE_NAPI_FUNCTION("lockScreen", LockScreen),
32 DECLARE_NAPI_FUNCTION("operateDevice", OperateDevice),
33 };
34 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
35 return exports;
36 }
37
SetPolicyCommon(AddonMethodSign & addonMethodSign,const std::string & workName)38 void DeviceControlAddon::SetPolicyCommon(AddonMethodSign &addonMethodSign, const std::string &workName)
39 {
40 addonMethodSign.name = workName;
41 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
42 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
43 }
44
ResetFactory(napi_env env,napi_callback_info info)45 napi_value DeviceControlAddon::ResetFactory(napi_env env, napi_callback_info info)
46 {
47 EDMLOGI("NAPI_resetFactory called");
48 AddonMethodSign addonMethodSign;
49 SetPolicyCommon(addonMethodSign, "ResetFactory");
50 return AddonMethodAdapter(env, info, addonMethodSign, NativeResetFactory, NativeVoidCallbackComplete);
51 }
52
LockScreen(napi_env env,napi_callback_info info)53 napi_value DeviceControlAddon::LockScreen(napi_env env, napi_callback_info info)
54 {
55 EDMLOGI("NAPI_lockScreen called");
56 size_t argc = ARGS_SIZE_TWO;
57 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
58 napi_value thisArg = nullptr;
59 void *data = nullptr;
60 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
61 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
62 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
63 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
64 OHOS::AppExecFwk::ElementName elementName;
65 bool ret = ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]);
66 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
67 EDMLOGD("lockScreen: asyncCallbackInfo->elementName.bundlename %{public}s, "
68 "asyncCallbackInfo->abilityname:%{public}s",
69 elementName.GetBundleName().c_str(),
70 elementName.GetAbilityName().c_str());
71 int32_t userId = 0;
72 #ifdef OS_ACCOUNT_EDM_ENABLE
73 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
74 EDMLOGI("NAPI_lockScreen called userId");
75 #else
76 EDMLOGI("NAPI_lockScreen don't call userId");
77 #endif
78 int32_t result = DeviceControlProxy::GetDeviceControlProxy()->LockScreen(elementName, userId);
79 if (FAILED(result)) {
80 napi_throw(env, CreateError(env, result));
81 }
82 return nullptr;
83 }
84
Shutdown(napi_env env,napi_callback_info info)85 napi_value DeviceControlAddon::Shutdown(napi_env env, napi_callback_info info)
86 {
87 EDMLOGI("NAPI_shutdown called");
88 AddonMethodSign addonMethodSign;
89 SetPolicyCommon(addonMethodSign, "Shutdown");
90 AdapterAddonData adapterAddonData{};
91 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
92 return nullptr;
93 }
94 int32_t result = DeviceControlProxy::GetDeviceControlProxy()->Shutdown(adapterAddonData.data);
95 if (FAILED(result)) {
96 napi_throw(env, CreateError(env, result));
97 }
98 return nullptr;
99 }
100
Reboot(napi_env env,napi_callback_info info)101 napi_value DeviceControlAddon::Reboot(napi_env env, napi_callback_info info)
102 {
103 EDMLOGI("NAPI_reboot called");
104 AddonMethodSign addonMethodSign;
105 SetPolicyCommon(addonMethodSign, "Reboot");
106 AdapterAddonData adapterAddonData{};
107 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
108 return nullptr;
109 }
110 int32_t result = DeviceControlProxy::GetDeviceControlProxy()->Reboot(adapterAddonData.data);
111 if (FAILED(result)) {
112 napi_throw(env, CreateError(env, result));
113 }
114 return nullptr;
115 }
116
NativeResetFactory(napi_env env,void * data)117 void DeviceControlAddon::NativeResetFactory(napi_env env, void *data)
118 {
119 EDMLOGI("NAPI_NativeResetFactory called");
120 if (data == nullptr) {
121 EDMLOGE("data is nullptr");
122 return;
123 }
124 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
125 if (DeviceControlProxy::GetDeviceControlProxy() == nullptr) {
126 EDMLOGE("can not get GetDeviceControlProxy");
127 return;
128 }
129 asyncCallbackInfo->ret =
130 DeviceControlProxy::GetDeviceControlProxy()->ResetFactory(asyncCallbackInfo->data);
131 }
132
OperateDevice(napi_env env,napi_callback_info info)133 napi_value DeviceControlAddon::OperateDevice(napi_env env, napi_callback_info info)
134 {
135 EDMLOGI("NAPI_OperateDevice called");
136 size_t argc = ARGS_SIZE_THREE;
137 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
138 napi_value thisArg = nullptr;
139 void *data = nullptr;
140 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
141 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
142 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
143 MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
144 if (argc > ARGS_SIZE_TWO) {
145 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_string);
146 }
147 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
148
149 AppExecFwk::ElementName elementName;
150 ASSERT_AND_THROW_PARAM_ERROR(
151 env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]), "element name param error");
152 EDMLOGD("resetFactory: elementName.bundlename %{public}s, abilityname:%{public}s",
153 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
154 OperateDeviceParam param;
155 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, param.operate, argv[ARR_INDEX_ONE]), "operate param error");
156 if (argc > ARGS_SIZE_TWO) {
157 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, param.addition, argv[ARR_INDEX_TWO]),
158 "addition param error");
159 }
160 #ifdef OS_ACCOUNT_EDM_ENABLE
161 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(param.userId);
162 EDMLOGI("NAPI_lockScreen called userId");
163 #else
164 EDMLOGI("NAPI_lockScreen don't call userId");
165 #endif
166 int32_t ret = DeviceControlProxy::GetDeviceControlProxy()->OperateDevice(elementName, param);
167 if (FAILED(ret)) {
168 napi_throw(env, CreateError(env, ret));
169 }
170 return nullptr;
171 }
172
173 static napi_module g_deviceControlModule = {
174 .nm_version = 1,
175 .nm_flags = 0,
176 .nm_filename = nullptr,
177 .nm_register_func = DeviceControlAddon::Init,
178 .nm_modname = "enterprise.deviceControl",
179 .nm_priv = ((void *)0),
180 .reserved = { 0 },
181 };
182
DeviceControlManagerRegister()183 extern "C" __attribute__((constructor)) void DeviceControlManagerRegister()
184 {
185 napi_module_register(&g_deviceControlModule);
186 }
187