1 /*
2  * Copyright (c) 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 #include "device_settings_addon.h"
16 
17 #include "cJSON.h"
18 #include "cjson_check.h"
19 #include "datetime_manager_proxy.h"
20 #include "edm_constants.h"
21 #include "edm_log.h"
22 
23 using namespace OHOS::EDM;
24 
CreatePowerSceneObject(napi_env env,napi_value value)25 void DeviceSettingsAddon::CreatePowerSceneObject(napi_env env, napi_value value)
26 {
27     napi_value nTimeOut;
28     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(PowerScene::TIME_OUT), &nTimeOut));
29     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TIME_OUT", nTimeOut));
30 }
31 
CreatePowerPolicyActionObject(napi_env env,napi_value value)32 void DeviceSettingsAddon::CreatePowerPolicyActionObject(napi_env env, napi_value value)
33 {
34     napi_value nActionNone;
35     NAPI_CALL_RETURN_VOID(env,
36         napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::NONE), &nActionNone));
37     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "NONE", nActionNone));
38     napi_value nActionAutoSuspend;
39     NAPI_CALL_RETURN_VOID(env,
40         napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::AUTO_SUSPEND), &nActionAutoSuspend));
41     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "AUTO_SUSPEND", nActionAutoSuspend));
42     napi_value nActionForceSuspend;
43     NAPI_CALL_RETURN_VOID(env,
44         napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::FORCE_SUSPEND), &nActionForceSuspend));
45     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "FORCE_SUSPEND", nActionForceSuspend));
46     napi_value nActionHibernate;
47     NAPI_CALL_RETURN_VOID(env,
48         napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::HIBERNATE), &nActionHibernate));
49     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "HIBERNATE", nActionHibernate));
50     napi_value nActionShutDown;
51     NAPI_CALL_RETURN_VOID(env,
52         napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::SHUTDOWN), &nActionShutDown));
53     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "SHUTDOWN", nActionShutDown));
54 }
55 
Init(napi_env env,napi_value exports)56 napi_value DeviceSettingsAddon::Init(napi_env env, napi_value exports)
57 {
58     napi_value nTimeOut = nullptr;
59     NAPI_CALL(env, napi_create_object(env, &nTimeOut));
60     CreatePowerSceneObject(env, nTimeOut);
61     napi_value nPolicyAction = nullptr;
62     NAPI_CALL(env, napi_create_object(env, &nPolicyAction));
63     CreatePowerPolicyActionObject(env, nPolicyAction);
64 
65     napi_property_descriptor property[] = {
66         DECLARE_NAPI_FUNCTION("setScreenOffTime", SetScreenOffTime),
67         DECLARE_NAPI_FUNCTION("getScreenOffTime", GetScreenOffTime),
68         DECLARE_NAPI_FUNCTION("setPowerPolicy", SetPowerPolicy),
69         DECLARE_NAPI_FUNCTION("getPowerPolicy", GetPowerPolicy),
70         DECLARE_NAPI_FUNCTION("installUserCertificate", InstallUserCertificate),
71         DECLARE_NAPI_FUNCTION("uninstallUserCertificate", UninstallUserCertificate),
72         DECLARE_NAPI_PROPERTY("PowerScene", nTimeOut),
73         DECLARE_NAPI_PROPERTY("PowerPolicyAction", nPolicyAction),
74         DECLARE_NAPI_FUNCTION("setValue", SetValue),
75         DECLARE_NAPI_FUNCTION("getValue", GetValue)
76     };
77     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
78     return exports;
79 }
80 
SetPowerPolicy(napi_env env,napi_callback_info info)81 napi_value DeviceSettingsAddon::SetPowerPolicy(napi_env env, napi_callback_info info)
82 {
83     EDMLOGI("NAPI_SetPowerPolicy called");
84     size_t argc = ARGS_SIZE_THREE;
85     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
86     napi_value thisArg = nullptr;
87     void *data = nullptr;
88     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
89     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
90     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
91     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter number error");
92     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_object), "parameter object error");
93 
94     OHOS::AppExecFwk::ElementName elementName;
95     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
96         "element name param error");
97     PowerScene powerScene;
98     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerScene(env, argv[ARR_INDEX_ONE], powerScene),
99         "power scene param error");
100     PowerPolicy powerPolicy;
101     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerPolicy(env, argv[ARR_INDEX_TWO], powerPolicy),
102         "power policy param error");
103     int32_t ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->SetPowerPolicy(elementName, powerScene, powerPolicy);
104     if (FAILED(ret)) {
105         napi_throw(env, CreateError(env, ret));
106         EDMLOGE("SetPowerPolicy failed!");
107     }
108     return nullptr;
109 }
110 
GetPowerPolicy(napi_env env,napi_callback_info info)111 napi_value DeviceSettingsAddon::GetPowerPolicy(napi_env env, napi_callback_info info)
112 {
113     EDMLOGI("NAPI_GetPowerPolicy called");
114     size_t argc = ARGS_SIZE_TWO;
115     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
116     napi_value thisArg = nullptr;
117     void *data = nullptr;
118     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
119     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
120     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
121     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter number error");
122     OHOS::AppExecFwk::ElementName elementName;
123     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
124         "element name param error");
125     PowerScene powerScene;
126     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerScene(env, argv[ARR_INDEX_ONE], powerScene),
127         "power scene param error");
128     PowerPolicy powerPolicy;
129     int32_t ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->GetPowerPolicy(elementName, powerScene, powerPolicy);
130     if (FAILED(ret)) {
131         napi_throw(env, CreateError(env, ret));
132         EDMLOGE("SetPowerPolicy failed!");
133         return nullptr;
134     }
135     napi_value result = ConvertPolicyPolicyToJs(env, powerPolicy);
136     return result;
137 }
138 
JsObjToPowerScene(napi_env env,napi_value object,PowerScene & powerScene)139 bool DeviceSettingsAddon::JsObjToPowerScene(napi_env env, napi_value object, PowerScene &powerScene)
140 {
141     uint32_t powerInt = 0;
142     if (ParseUint(env, powerInt, object) && powerInt == static_cast<uint32_t>(PowerScene::TIME_OUT)) {
143         powerScene = PowerScene(powerInt);
144         return true;
145     }
146     return false;
147 }
148 
JsObjToPowerPolicy(napi_env env,napi_value object,PowerPolicy & powerPolicy)149 bool DeviceSettingsAddon::JsObjToPowerPolicy(napi_env env, napi_value object, PowerPolicy &powerPolicy)
150 {
151     uint32_t action = 0;
152     if (!JsObjectToUint(env, object, "powerPolicyAction", true, action)) {
153         EDMLOGE("SetPowerPolicy powerPolicyAction parse error!");
154         return false;
155     }
156     uint32_t delayTime = 0;
157     if (!JsObjectToUint(env, object, "delayTime", true, delayTime)) {
158         EDMLOGE("SetPowerPolicy delayTime parse error!");
159         return false;
160     }
161     powerPolicy.SetDelayTime(delayTime);
162     if (!powerPolicy.SetPowerPolicyAction(action)) {
163         return false;
164     }
165     return true;
166 }
167 
ConvertPolicyPolicyToJs(napi_env env,PowerPolicy & powerPolicy)168 napi_value DeviceSettingsAddon::ConvertPolicyPolicyToJs(napi_env env, PowerPolicy &powerPolicy)
169 {
170     napi_value result = nullptr;
171     NAPI_CALL(env, napi_create_object(env, &result));
172     napi_value action = nullptr;
173     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(powerPolicy.GetPowerPolicyAction()), &action));
174     napi_value delayTime = nullptr;
175     NAPI_CALL(env, napi_create_uint32(env, powerPolicy.GetDealyTime(), &delayTime));
176     NAPI_CALL(env, napi_set_named_property(env, result, "powerPolicyAction", action));
177     NAPI_CALL(env, napi_set_named_property(env, result, "delayTime", delayTime));
178     return result;
179 }
180 
SetScreenOffTime(napi_env env,napi_callback_info info)181 napi_value DeviceSettingsAddon::SetScreenOffTime(napi_env env, napi_callback_info info)
182 {
183     EDMLOGI("NAPI_SetScreenOffTime called");
184     size_t argc = ARGS_SIZE_TWO;
185     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
186     napi_value thisArg = nullptr;
187     void *data = nullptr;
188     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
189     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
190     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
191     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter number error");
192 
193     auto asyncCallbackInfo = new (std::nothrow) AsyncScreenOffTimeCallbackInfo();
194     if (asyncCallbackInfo == nullptr) {
195         return nullptr;
196     }
197     std::unique_ptr<AsyncScreenOffTimeCallbackInfo> callbackPtr{asyncCallbackInfo};
198     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
199         "element name param error");
200     EDMLOGD(
201         "SetScreenOffTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
202         "asyncCallbackInfo->abilityname:%{public}s",
203         asyncCallbackInfo->elementName.GetBundleName().c_str(),
204         asyncCallbackInfo->elementName.GetAbilityName().c_str());
205     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->time, argv[ARR_INDEX_ONE]),
206         "element name param error");
207     EDMLOGD("SetScreenOffTime time = %{public}d", asyncCallbackInfo->time);
208     asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->SetScreenOffTime(
209         asyncCallbackInfo->elementName, asyncCallbackInfo->time);
210     if (FAILED(asyncCallbackInfo->ret)) {
211         napi_throw(env, CreateError(env, asyncCallbackInfo->ret));
212         EDMLOGE("SetScreenOffTime failed!");
213     }
214     return nullptr;
215 }
216 
GetScreenOffTime(napi_env env,napi_callback_info info)217 napi_value DeviceSettingsAddon::GetScreenOffTime(napi_env env, napi_callback_info info)
218 {
219     EDMLOGI("NAPI_GetScreenOffTime called");
220     size_t argc = ARGS_SIZE_TWO;
221     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
222     napi_value thisArg = nullptr;
223     void *data = nullptr;
224     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
225     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
226     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
227     if (argc > ARGS_SIZE_ONE) {
228         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
229     }
230     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
231     auto asyncCallbackInfo = new (std::nothrow) AsyncScreenOffTimeCallbackInfo();
232     if (asyncCallbackInfo == nullptr) {
233         return nullptr;
234     }
235     std::unique_ptr<AsyncScreenOffTimeCallbackInfo> callbackPtr{asyncCallbackInfo};
236     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
237     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
238     EDMLOGD(
239         "GetScreenOffTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
240         "asyncCallbackInfo->abilityname:%{public}s",
241         asyncCallbackInfo->elementName.GetBundleName().c_str(),
242         asyncCallbackInfo->elementName.GetAbilityName().c_str());
243     if (argc > ARGS_SIZE_ONE) {
244         EDMLOGD("GetScreenOffTime argc == ARGS_SIZE_TWO");
245         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
246     }
247     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetScreenOffTime", NativeGetScreenOffTime,
248         NativeNumberCallbackComplete);
249     callbackPtr.release();
250     return asyncWorkReturn;
251 }
252 
NativeGetScreenOffTime(napi_env env,void * data)253 void DeviceSettingsAddon::NativeGetScreenOffTime(napi_env env, void *data)
254 {
255     EDMLOGI("NAPI_NativeGetScreenOffTime called");
256     if (data == nullptr) {
257         EDMLOGE("data is nullptr");
258         return;
259     }
260     AsyncScreenOffTimeCallbackInfo *asyncCallbackInfo = static_cast<AsyncScreenOffTimeCallbackInfo *>(data);
261     asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->GetScreenOffTime(
262         asyncCallbackInfo->elementName, asyncCallbackInfo->intRet);
263 }
264 
InstallUserCertificate(napi_env env,napi_callback_info info)265 napi_value DeviceSettingsAddon::InstallUserCertificate(napi_env env, napi_callback_info info)
266 {
267     EDMLOGI("NAPI_InstallUserCertificate called");
268     size_t argc = ARGS_SIZE_THREE;
269     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
270     napi_value thisArg = nullptr;
271     void *data = nullptr;
272     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
273     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
274     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
275     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
276     matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
277     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter certblob error");
278     if (argc > ARGS_SIZE_TWO) {
279         matchFlag = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
280         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter callback error");
281     }
282     auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
283     if (asyncCallbackInfo == nullptr) {
284         return nullptr;
285     }
286     std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
287     bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
288     ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
289     EDMLOGD(
290         "InstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
291         "asyncCallbackInfo->abilityname:%{public}s",
292         asyncCallbackInfo->elementName.GetBundleName().c_str(),
293         asyncCallbackInfo->elementName.GetAbilityName().c_str());
294 
295     bool retCertBlob = ParseCertBlob(env, argv[ARR_INDEX_ONE], asyncCallbackInfo);
296     ASSERT_AND_THROW_PARAM_ERROR(env, retCertBlob, "element cert blob error");
297 
298     if (argc > ARGS_SIZE_TWO) {
299         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
300     }
301     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "InstallUserCertificate",
302         NativeInstallUserCertificate, NativeStringCallbackComplete);
303     callbackPtr.release();
304     return asyncWorkReturn;
305 }
306 
NativeInstallUserCertificate(napi_env env,void * data)307 void DeviceSettingsAddon::NativeInstallUserCertificate(napi_env env, void *data)
308 {
309     EDMLOGI("NAPI_NativeInstallUserCertificate called");
310     if (data == nullptr) {
311         EDMLOGE("data is nullptr");
312         return;
313     }
314     AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
315     asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->InstallUserCertificate(
316         asyncCallbackInfo->elementName, asyncCallbackInfo->certArray, asyncCallbackInfo->alias,
317         asyncCallbackInfo->stringRet, asyncCallbackInfo->innerCodeMsg);
318 }
319 
UninstallUserCertificate(napi_env env,napi_callback_info info)320 napi_value DeviceSettingsAddon::UninstallUserCertificate(napi_env env, napi_callback_info info)
321 {
322     EDMLOGI("NAPI_UninstallUserCertificate called");
323     size_t argc = ARGS_SIZE_THREE;
324     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
325     napi_value thisArg = nullptr;
326     void *data = nullptr;
327     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
328     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
329     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
330     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
331     matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
332     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter uri error");
333     if (argc > ARGS_SIZE_TWO) {
334         matchFlag = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
335         ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter callback error");
336     }
337     auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
338     if (asyncCallbackInfo == nullptr) {
339         return nullptr;
340     }
341     std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
342     bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
343     ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
344     EDMLOGD(
345         "UninstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
346         "asyncCallbackInfo->abilityname:%{public}s",
347         asyncCallbackInfo->elementName.GetBundleName().c_str(),
348         asyncCallbackInfo->elementName.GetAbilityName().c_str());
349 
350     bool retAlias = ParseString(env, asyncCallbackInfo->alias, argv[ARR_INDEX_ONE]);
351     ASSERT_AND_THROW_PARAM_ERROR(env, retAlias, "element alias error");
352 
353     if (argc > ARGS_SIZE_TWO) {
354         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
355     }
356     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "uninstallUserCertificate",
357         NativeUninstallUserCertificate, NativeVoidCallbackComplete);
358     callbackPtr.release();
359     return asyncWorkReturn;
360 }
361 
NativeUninstallUserCertificate(napi_env env,void * data)362 void DeviceSettingsAddon::NativeUninstallUserCertificate(napi_env env, void *data)
363 {
364     EDMLOGI("NAPI_NativeUninstallUserCertificate called");
365     if (data == nullptr) {
366         EDMLOGE("data is nullptr");
367         return;
368     }
369     AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
370     asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->UninstallUserCertificate(
371         asyncCallbackInfo->elementName, asyncCallbackInfo->alias, asyncCallbackInfo->innerCodeMsg);
372 }
373 
ParseCertBlob(napi_env env,napi_value object,AsyncCertCallbackInfo * asyncCertCallbackInfo)374 bool DeviceSettingsAddon::ParseCertBlob(napi_env env, napi_value object, AsyncCertCallbackInfo *asyncCertCallbackInfo)
375 {
376     napi_valuetype type = napi_undefined;
377     NAPI_CALL_BASE(env, napi_typeof(env, object, &type), false);
378     if (type != napi_object) {
379         EDMLOGE("type of param certblob is not object");
380         return false;
381     }
382     if (!JsObjectToU8Vector(env, object, "inData", asyncCertCallbackInfo->certArray)) {
383         EDMLOGE("uint8Array to vector failed");
384         return false;
385     }
386     return JsObjectToString(env, object, "alias", true, asyncCertCallbackInfo->alias);
387 }
388 
SetValue(napi_env env,napi_callback_info info)389 napi_value DeviceSettingsAddon::SetValue(napi_env env, napi_callback_info info)
390 {
391     EDMLOGI("NAPI_SetValue called");
392     size_t argc = ARGS_SIZE_THREE;
393     napi_value argv[ARGS_SIZE_THREE] = { nullptr };
394     napi_value thisArg = nullptr;
395     void *data = nullptr;
396     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
397     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
398     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
399     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter item error");
400     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_string), "parameter value error");
401 
402     OHOS::AppExecFwk::ElementName elementName;
403     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
404         "element name param error");
405     std::string item;
406     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, item, argv[ARR_INDEX_ONE]), "param 'item' error");
407     std::string value;
408     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, value, argv[ARR_INDEX_TWO]), "param 'value' error");
409     int32_t ret = ERR_OK;
410     auto proxy = DeviceSettingsProxy::GetDeviceSettingsProxy();
411     if (item == EdmConstants::DeviceSettings::SCREEN_OFF) {
412         int32_t screenOffTime = 0;
413         ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringToInt(value, screenOffTime), "param 'screenOffTime' error");
414         ret = proxy->SetScreenOffTime(elementName, screenOffTime, EdmConstants::PERMISSION_TAG_VERSION_12);
415     } else if (item == EdmConstants::DeviceSettings::POWER_POLICY) {
416         PowerScene powerScene;
417         ASSERT_AND_THROW_PARAM_ERROR(env, JsStrToPowerScene(env, value, powerScene), "param 'powerScene' error");
418         PowerPolicy powerPolicy;
419         ASSERT_AND_THROW_PARAM_ERROR(env, JsStrToPowerPolicy(env, value, powerPolicy), "param 'powerPolicy' error");
420         ret = proxy->SetPowerPolicy(elementName, powerScene, powerPolicy);
421     } else if (item == EdmConstants::DeviceSettings::DATE_TIME) {
422         int64_t dateTime = 0;
423         ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringToLong(value, dateTime), "param 'dateTime' error");
424         ret = DatetimeManagerProxy::GetDatetimeManagerProxy()->SetDateTime(elementName, dateTime,
425             EdmConstants::PERMISSION_TAG_VERSION_12);
426     } else {
427         ret = EdmReturnErrCode::INTERFACE_UNSUPPORTED;
428     }
429     if (FAILED(ret)) {
430         napi_throw(env, CreateError(env, ret));
431         EDMLOGE("SetValue failed! item is %{public}s", item.c_str());
432     }
433     return nullptr;
434 }
435 
GetValue(napi_env env,napi_callback_info info)436 napi_value DeviceSettingsAddon::GetValue(napi_env env, napi_callback_info info)
437 {
438     EDMLOGI("NAPI_GetValue called");
439     size_t argc = ARGS_SIZE_TWO;
440     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
441     napi_value thisArg = nullptr;
442     void *data = nullptr;
443     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
444     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
445     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
446     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter item error");
447     OHOS::AppExecFwk::ElementName elementName;
448     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
449         "element name param error");
450     std::string item;
451     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, item, argv[ARR_INDEX_ONE]), "param 'item' error");
452     int32_t ret = ERR_OK;
453     std::string stringRet;
454     auto proxy = DeviceSettingsProxy::GetDeviceSettingsProxy();
455     if (item == EdmConstants::DeviceSettings::SCREEN_OFF) {
456         int32_t screenOffTime;
457         ret = proxy->GetScreenOffTime(elementName, screenOffTime, EdmConstants::PERMISSION_TAG_VERSION_12);
458         stringRet = std::to_string(screenOffTime);
459     } else if (item == EdmConstants::DeviceSettings::POWER_POLICY) {
460         PowerScene powerScene = PowerScene::TIME_OUT;
461         PowerPolicy powerPolicy;
462         ret = proxy->GetPowerPolicy(elementName, powerScene, powerPolicy);
463         if (SUCCEEDED(ret)) {
464             ret = ConvertPowerPolicyToJsStr(env, powerScene, powerPolicy, stringRet);
465         }
466     } else {
467         ret = EdmReturnErrCode::INTERFACE_UNSUPPORTED;
468     }
469     if (FAILED(ret)) {
470         napi_throw(env, CreateError(env, ret));
471         EDMLOGE("GetValue failed! item is %{public}s", item.c_str());
472         return nullptr;
473     }
474     napi_value result;
475     napi_create_string_utf8(env, stringRet.c_str(), stringRet.size(), &result);
476     return result;
477 }
478 
JsStrToPowerScene(napi_env env,std::string jsStr,PowerScene & powerScene)479 bool DeviceSettingsAddon::JsStrToPowerScene(napi_env env, std::string jsStr, PowerScene &powerScene)
480 {
481     cJSON *json = cJSON_Parse(jsStr.c_str());
482     if (json == nullptr) {
483         return false;
484     }
485     cJSON *itemPowerScene = cJSON_GetObjectItem(json, "powerScene");
486     if (!cJSON_IsNumber(itemPowerScene)) {
487         cJSON_Delete(json);
488         return false;
489     }
490     powerScene = PowerScene(itemPowerScene->valueint);
491     cJSON_Delete(json);
492     return true;
493 }
494 
JsStrToPowerPolicy(napi_env env,std::string jsStr,PowerPolicy & powerPolicy)495 bool DeviceSettingsAddon::JsStrToPowerPolicy(napi_env env, std::string jsStr, PowerPolicy &powerPolicy)
496 {
497     cJSON *json = cJSON_Parse(jsStr.c_str());
498     if (json == nullptr) {
499         return false;
500     }
501     cJSON *itemPowerPolicy = cJSON_GetObjectItem(json, "powerPolicy");
502     if (!cJSON_IsObject(itemPowerPolicy)) {
503         cJSON_Delete(json);
504         return false;
505     }
506     cJSON *delayTime = cJSON_GetObjectItem(itemPowerPolicy, "delayTime");
507     if (!cJSON_IsNumber(delayTime)) {
508         cJSON_Delete(json);
509         return false;
510     }
511     powerPolicy.SetDelayTime(delayTime->valueint);
512     cJSON *powerPolicyAction = cJSON_GetObjectItem(itemPowerPolicy, "powerPolicyAction");
513     if (!cJSON_IsNumber(powerPolicyAction)) {
514         cJSON_Delete(json);
515         return false;
516     }
517     bool setActionRet = powerPolicy.SetPowerPolicyAction(powerPolicyAction->valueint);
518     cJSON_Delete(json);
519     return setActionRet;
520 }
521 
ConvertPowerPolicyToJsStr(napi_env env,PowerScene & powerScene,PowerPolicy & powerPolicy,std::string & info)522 int32_t DeviceSettingsAddon::ConvertPowerPolicyToJsStr(napi_env env, PowerScene &powerScene, PowerPolicy &powerPolicy,
523     std::string &info)
524 {
525     cJSON *json = nullptr;
526     CJSON_CREATE_OBJECT_AND_CHECK(json, EdmReturnErrCode::SYSTEM_ABNORMALLY);
527     cJSON *powerPoilcyJs = nullptr;
528     CJSON_CREATE_OBJECT_AND_CHECK_AND_CLEAR(powerPoilcyJs, EdmReturnErrCode::SYSTEM_ABNORMALLY, json);
529     cJSON_AddNumberToObject(powerPoilcyJs, "powerPolicyAction",
530         static_cast<uint32_t>(powerPolicy.GetPowerPolicyAction()));
531     cJSON_AddNumberToObject(powerPoilcyJs, "delayTime", powerPolicy.GetDealyTime());
532     bool ret = cJSON_AddItemToObject(json, std::to_string(static_cast<uint32_t>(powerScene)).c_str(), powerPoilcyJs);
533     if (!ret) {
534         cJSON_Delete(json);
535         cJSON_Delete(powerPoilcyJs);
536         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
537     }
538     char *jsonStr = cJSON_PrintUnformatted(json);
539     if (jsonStr == nullptr) {
540         cJSON_Delete(json);
541         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
542     }
543     info = std::string(jsonStr);
544     cJSON_Delete(json);
545     cJSON_free(jsonStr);
546     return ERR_OK;
547 }
548 
549 static napi_module g_deviceSettingsModule = {
550     .nm_version = 1,
551     .nm_flags = 0,
552     .nm_filename = nullptr,
553     .nm_register_func = DeviceSettingsAddon::Init,
554     .nm_modname = "enterprise.deviceSettings",
555     .nm_priv = ((void *)0),
556     .reserved = {0},
557 };
558 
DeviceSettingsRegister()559 extern "C" __attribute__((constructor)) void DeviceSettingsRegister()
560 {
561     napi_module_register(&g_deviceSettingsModule);
562 }