1 /*
2  * Copyright (c) 2021-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 <cstdint>
17 #include <cstdio>
18 #include <string>
19 #include "js_native_api.h"
20 #include "js_native_api_types.h"
21 #include "napi/native_common.h"
22 #include "napi/native_api.h"
23 #include "battery_info.h"
24 #include "battery_srv_client.h"
25 #include "battery_log.h"
26 #include "napi_utils.h"
27 #include "napi_error.h"
28 
29 using namespace OHOS::PowerMgr;
30 
31 constexpr int32_t INDEX_0 = 0;
32 constexpr int32_t INDEX_1 = 1;
33 constexpr int32_t INDEX_2 = 2;
34 
35 thread_local static BatterySrvClient& g_battClient = BatterySrvClient::GetInstance();
36 
BatterySOC(napi_env env,napi_callback_info info)37 static napi_value BatterySOC(napi_env env, napi_callback_info info)
38 {
39     napi_value napiValue = nullptr;
40     int32_t capacity = g_battClient.GetCapacity();
41 
42     NAPI_CALL(env, napi_create_int32(env, capacity, &napiValue));
43 
44     BATTERY_HILOGD(FEATURE_BATT_INFO, "capacity %{public}d", capacity);
45     return napiValue;
46 }
47 
GetChargingState(napi_env env,napi_callback_info info)48 static napi_value GetChargingState(napi_env env, napi_callback_info info)
49 {
50     napi_value napiValue = nullptr;
51     int32_t chargingState = (int32_t)g_battClient.GetChargingStatus();
52 
53     NAPI_CALL(env, napi_create_int32(env, chargingState, &napiValue));
54 
55     BATTERY_HILOGD(FEATURE_BATT_INFO, "chargingState %{public}d", chargingState);
56 
57     return napiValue;
58 }
59 
GetHealthState(napi_env env,napi_callback_info info)60 static napi_value GetHealthState(napi_env env, napi_callback_info info)
61 {
62     napi_value napiValue = nullptr;
63     int32_t healthStatus = (int32_t)g_battClient.GetHealthStatus();
64 
65     NAPI_CALL(env, napi_create_int32(env, healthStatus, &napiValue));
66 
67     BATTERY_HILOGD(FEATURE_BATT_INFO, "healthStatus %{public}d", healthStatus);
68 
69     return napiValue;
70 }
71 
GetPluggedType(napi_env env,napi_callback_info info)72 static napi_value GetPluggedType(napi_env env, napi_callback_info info)
73 {
74     napi_value napiValue = nullptr;
75     int32_t pluggedType = (int32_t)g_battClient.GetPluggedType();
76 
77     NAPI_CALL(env, napi_create_int32(env, pluggedType, &napiValue));
78 
79     BATTERY_HILOGD(FEATURE_BATT_INFO, "pluggedType %{public}d", pluggedType);
80 
81     return napiValue;
82 }
83 
GetVoltage(napi_env env,napi_callback_info info)84 static napi_value GetVoltage(napi_env env, napi_callback_info info)
85 {
86     napi_value napiValue = nullptr;
87     int32_t voltage = g_battClient.GetVoltage();
88 
89     NAPI_CALL(env, napi_create_int32(env, voltage, &napiValue));
90 
91     BATTERY_HILOGD(FEATURE_BATT_INFO, "voltage %{public}d", voltage);
92 
93     return napiValue;
94 }
95 
GetTechnology(napi_env env,napi_callback_info info)96 static napi_value GetTechnology(napi_env env, napi_callback_info info)
97 {
98     napi_value napiValue = nullptr;
99     auto technology = g_battClient.GetTechnology();
100     const char* technologyStr = technology.c_str();
101 
102     NAPI_CALL(env, napi_create_string_utf8(env, technologyStr, strlen(technologyStr), &napiValue));
103 
104     BATTERY_HILOGD(FEATURE_BATT_INFO, "technology %{public}s", technologyStr);
105     return napiValue;
106 }
107 
GetBatteryTemperature(napi_env env,napi_callback_info info)108 static napi_value GetBatteryTemperature(napi_env env, napi_callback_info info)
109 {
110     napi_value napiValue = nullptr;
111     int32_t temperature = g_battClient.GetBatteryTemperature();
112 
113     NAPI_CALL(env, napi_create_int32(env, temperature, &napiValue));
114 
115     BATTERY_HILOGD(FEATURE_BATT_INFO, "temperature %{public}d", temperature);
116 
117     return napiValue;
118 }
119 
GetBatteryPresent(napi_env env,napi_callback_info info)120 static napi_value GetBatteryPresent(napi_env env, napi_callback_info info)
121 {
122     napi_value napiValue = nullptr;
123     bool present = g_battClient.GetPresent();
124 
125     NAPI_CALL(env, napi_get_boolean(env, present, &napiValue));
126 
127     BATTERY_HILOGD(FEATURE_BATT_INFO, "present %{public}d", present);
128 
129     return napiValue;
130 }
131 
GetBatteryNowCurrent(napi_env env,napi_callback_info info)132 static napi_value GetBatteryNowCurrent(napi_env env, napi_callback_info info)
133 {
134     napi_value napiValue = nullptr;
135     int32_t curNow = g_battClient.GetNowCurrent();
136 
137     NAPI_CALL(env, napi_create_int32(env, curNow, &napiValue));
138 
139     BATTERY_HILOGD(FEATURE_BATT_INFO, "curNow %{public}d", curNow);
140     return napiValue;
141 }
142 
GetBatteryRemainEnergy(napi_env env,napi_callback_info info)143 static napi_value GetBatteryRemainEnergy(napi_env env, napi_callback_info info)
144 {
145     napi_value napiValue = nullptr;
146     int32_t remainEnergy = g_battClient.GetRemainEnergy();
147 
148     NAPI_CALL(env, napi_create_int32(env, remainEnergy, &napiValue));
149 
150     BATTERY_HILOGD(FEATURE_BATT_INFO, "remainEnergy %{public}d", remainEnergy);
151     return napiValue;
152 }
153 
GetRemainingChargeTime(napi_env env,napi_callback_info info)154 static napi_value GetRemainingChargeTime(napi_env env, napi_callback_info info)
155 {
156     napi_value napiValue = nullptr;
157     int64_t time = g_battClient.GetRemainingChargeTime();
158 
159     NAPI_CALL(env, napi_create_int64(env, time, &napiValue));
160     return napiValue;
161 }
162 
GetTotalEnergy(napi_env env,napi_callback_info info)163 static napi_value GetTotalEnergy(napi_env env, napi_callback_info info)
164 {
165     napi_value napiValue = nullptr;
166     int32_t totalEnergy = (int32_t)g_battClient.GetTotalEnergy();
167 
168     NAPI_CALL(env, napi_create_int32(env, totalEnergy, &napiValue));
169 
170     BATTERY_HILOGD(FEATURE_BATT_INFO, "totalEnergy %{public}d", totalEnergy);
171     return napiValue;
172 }
173 
GetCapacityLevel(napi_env env,napi_callback_info info)174 static napi_value GetCapacityLevel(napi_env env, napi_callback_info info)
175 {
176     napi_value napiValue = nullptr;
177     int32_t batteryCapacityLevel = (int32_t)g_battClient.GetCapacityLevel();
178 
179     NAPI_CALL(env, napi_create_int32(env, batteryCapacityLevel, &napiValue));
180 
181     BATTERY_HILOGD(FEATURE_BATT_INFO, "batteryCapacityLevel %{public}d", batteryCapacityLevel);
182     return napiValue;
183 }
184 
SetBatteryConfig(napi_env env,napi_callback_info info)185 static napi_value SetBatteryConfig(napi_env env, napi_callback_info info)
186 {
187     size_t argc = INDEX_2;
188     napi_value argv[argc];
189     NapiUtils::GetCallbackInfo(env, info, argc, argv);
190     NapiError error;
191 
192     if (argc != INDEX_2 || !NapiUtils::CheckValueType(env, argv[INDEX_0], napi_string)
193         || !NapiUtils::CheckValueType(env, argv[INDEX_1], napi_string)) {
194         BATTERY_HILOGW(FEATURE_BATT_INFO, "set charge config failed, param is invalid");
195         error.ThrowError(env, BatteryError::ERR_PARAM_INVALID);
196         return nullptr;
197     }
198 
199     std::string sceneName = NapiUtils::GetStringFromNapi(env, argv[INDEX_0]);
200     std::string value = NapiUtils::GetStringFromNapi(env, argv[INDEX_1]);
201 
202     BatteryError code = g_battClient.SetBatteryConfig(sceneName, value);
203     BATTERY_HILOGI(FEATURE_BATT_INFO, "set charge config, sceneName: %{public}s, value: %{public}s, ret: %{public}d",
204         sceneName.c_str(), value.c_str(), static_cast<int32_t>(code));
205 
206     napi_value napiValue;
207     NAPI_CALL(env, napi_create_uint32(env, static_cast<int32_t>(code), &napiValue));
208     if (code != BatteryError::ERR_OK) {
209         error.ThrowError(env, code);
210         return napiValue;
211     }
212     return napiValue;
213 }
214 
GetBatteryConfig(napi_env env,napi_callback_info info)215 static napi_value GetBatteryConfig(napi_env env, napi_callback_info info)
216 {
217     size_t argc = 1;
218     napi_value argv[argc];
219     NapiUtils::GetCallbackInfo(env, info, argc, argv);
220     NapiError error;
221 
222     if (argc != 1 || !NapiUtils::CheckValueType(env, argv[INDEX_0], napi_string)) {
223         BATTERY_HILOGW(FEATURE_BATT_INFO, "get charge config failed, param is invalid");
224         error.ThrowError(env, BatteryError::ERR_PARAM_INVALID);
225         return nullptr;
226     }
227 
228     std::string sceneName = NapiUtils::GetStringFromNapi(env, argv[INDEX_0]);
229     BATTERY_HILOGD(COMP_FWK, "get charge config, sceneName: %{public}s", sceneName.c_str());
230 
231     std::string result;
232     BatteryError code = g_battClient.GetBatteryConfig(sceneName, result);
233     BATTERY_HILOGD(COMP_FWK, "get charge config, sceneValue: %{public}s", result.c_str());
234 
235     napi_value napiValue;
236     NAPI_CALL(env, napi_create_string_utf8(env, result.c_str(), result.size(), &napiValue));
237     if (code != BatteryError::ERR_OK) {
238         error.ThrowError(env, code);
239         return napiValue;
240     }
241     return napiValue;
242 }
243 
IsBatteryConfigSupported(napi_env env,napi_callback_info info)244 static napi_value IsBatteryConfigSupported(napi_env env, napi_callback_info info)
245 {
246     size_t argc = 1;
247     napi_value argv[argc];
248     NapiUtils::GetCallbackInfo(env, info, argc, argv);
249     NapiError error;
250 
251     if (argc != 1 || !NapiUtils::CheckValueType(env, argv[INDEX_0], napi_string)) {
252         BATTERY_HILOGW(FEATURE_BATT_INFO, "support charge config failed, param is invalid");
253         error.ThrowError(env, BatteryError::ERR_PARAM_INVALID);
254         return nullptr;
255     }
256 
257     std::string sceneName = NapiUtils::GetStringFromNapi(env, argv[INDEX_0]);
258     BATTERY_HILOGI(COMP_FWK, "get support charge config, featureName: %{public}s", sceneName.c_str());
259 
260     bool result = false;
261     BatteryError code = g_battClient.IsBatteryConfigSupported(sceneName, result);
262 
263     BATTERY_HILOGI(COMP_FWK, "get support charge config, sceneValue: %{public}d", static_cast<uint32_t>(result));
264 
265     napi_value napiValue;
266     NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(result), &napiValue));
267     if (code != BatteryError::ERR_OK) {
268         error.ThrowError(env, code);
269         return napiValue;
270     }
271     return napiValue;
272 }
273 
EnumHealthClassConstructor(napi_env env,napi_callback_info info)274 static napi_value EnumHealthClassConstructor(napi_env env, napi_callback_info info)
275 {
276     napi_value thisArg = nullptr;
277     void* data = nullptr;
278 
279     napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
280 
281     napi_value global = nullptr;
282     napi_get_global(env, &global);
283 
284     return thisArg;
285 }
286 
EnumLevelClassConstructor(napi_env env,napi_callback_info info)287 static napi_value EnumLevelClassConstructor(napi_env env, napi_callback_info info)
288 {
289     napi_value thisArg = nullptr;
290     void* data = nullptr;
291 
292     napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
293 
294     napi_value global = nullptr;
295     napi_get_global(env, &global);
296 
297     return thisArg;
298 }
299 
CreateEnumHealthState(napi_env env,napi_value exports)300 static napi_value CreateEnumHealthState(napi_env env, napi_value exports)
301 {
302     napi_value unknown = nullptr;
303     napi_value good = nullptr;
304     napi_value overheat = nullptr;
305     napi_value overvoltage = nullptr;
306     napi_value cold = nullptr;
307     napi_value dead = nullptr;
308 
309     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_UNKNOWN, &unknown);
310     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_GOOD, &good);
311     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_OVERHEAT, &overheat);
312     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_OVERVOLTAGE, &overvoltage);
313     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_COLD, &cold);
314     napi_create_int32(env, (int32_t)BatteryHealthState::HEALTH_STATE_DEAD, &dead);
315 
316     napi_property_descriptor desc[] = {
317         DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN", unknown),
318         DECLARE_NAPI_STATIC_PROPERTY("GOOD", good),
319         DECLARE_NAPI_STATIC_PROPERTY("OVERHEAT", overheat),
320         DECLARE_NAPI_STATIC_PROPERTY("OVERVOLTAGE", overvoltage),
321         DECLARE_NAPI_STATIC_PROPERTY("COLD", cold),
322         DECLARE_NAPI_STATIC_PROPERTY("DEAD", dead),
323     };
324     napi_value result = nullptr;
325     napi_define_class(env, "BatteryHealthState", NAPI_AUTO_LENGTH, EnumHealthClassConstructor, nullptr,
326         sizeof(desc) / sizeof(*desc), desc, &result);
327 
328     napi_set_named_property(env, exports, "BatteryHealthState", result);
329 
330     return exports;
331 }
332 
CreateEnumLevelState(napi_env env,napi_value exports)333 static napi_value CreateEnumLevelState(napi_env env, napi_value exports)
334 {
335     napi_value full = nullptr;
336     napi_value high = nullptr;
337     napi_value normal = nullptr;
338     napi_value low = nullptr;
339     napi_value warning = nullptr;
340     napi_value critical = nullptr;
341     napi_value shutdown = nullptr;
342 
343     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_FULL, &full);
344     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_HIGH, &high);
345     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_NORMAL, &normal);
346     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_LOW, &low);
347     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_WARNING, &warning);
348     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_CRITICAL, &critical);
349     napi_create_int32(env, (int32_t)BatteryCapacityLevel::LEVEL_SHUTDOWN, &shutdown);
350 
351     napi_property_descriptor desc[] = {
352         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_FULL", full),
353         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_HIGH", high),
354         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_NORMAL", normal),
355         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_LOW", low),
356         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_WARNING", warning),
357         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_CRITICAL", critical),
358         DECLARE_NAPI_STATIC_PROPERTY("LEVEL_SHUTDOWN", shutdown),
359     };
360     napi_value result = nullptr;
361     napi_define_class(env, "BatteryCapacityLevel", NAPI_AUTO_LENGTH, EnumLevelClassConstructor, nullptr,
362         sizeof(desc) / sizeof(*desc), desc, &result);
363 
364     napi_set_named_property(env, exports, "BatteryCapacityLevel", result);
365 
366     return exports;
367 }
368 
EnumChargeClassConstructor(napi_env env,napi_callback_info info)369 static napi_value EnumChargeClassConstructor(napi_env env, napi_callback_info info)
370 {
371     napi_value thisArg = nullptr;
372     void* data = nullptr;
373 
374     napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
375 
376     napi_value global = nullptr;
377     napi_get_global(env, &global);
378 
379     return thisArg;
380 }
381 
CreateEnumChargeState(napi_env env,napi_value exports)382 static napi_value CreateEnumChargeState(napi_env env, napi_value exports)
383 {
384     napi_value none = nullptr;
385     napi_value enable = nullptr;
386     napi_value disable = nullptr;
387     napi_value full = nullptr;
388 
389     napi_create_int32(env, (int32_t)BatteryChargeState::CHARGE_STATE_NONE, &none);
390     napi_create_int32(env, (int32_t)BatteryChargeState::CHARGE_STATE_ENABLE, &enable);
391     napi_create_int32(env, (int32_t)BatteryChargeState::CHARGE_STATE_DISABLE, &disable);
392     napi_create_int32(env, (int32_t)BatteryChargeState::CHARGE_STATE_FULL, &full);
393 
394     napi_property_descriptor desc[] = {
395         DECLARE_NAPI_STATIC_PROPERTY("NONE", none),
396         DECLARE_NAPI_STATIC_PROPERTY("ENABLE", enable),
397         DECLARE_NAPI_STATIC_PROPERTY("DISABLE", disable),
398         DECLARE_NAPI_STATIC_PROPERTY("FULL", full),
399     };
400 
401     napi_value result = nullptr;
402     napi_define_class(env, "BatteryChargeState", NAPI_AUTO_LENGTH, EnumChargeClassConstructor, nullptr,
403         sizeof(desc) / sizeof(*desc), desc, &result);
404 
405     napi_set_named_property(env, exports, "BatteryChargeState", result);
406 
407     return exports;
408 }
409 
EnumPluggedClassConstructor(napi_env env,napi_callback_info info)410 static napi_value EnumPluggedClassConstructor(napi_env env, napi_callback_info info)
411 {
412     napi_value thisArg = nullptr;
413     void* data = nullptr;
414 
415     napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
416 
417     napi_value global = nullptr;
418     napi_get_global(env, &global);
419 
420     return thisArg;
421 }
422 
CreateEnumPluggedType(napi_env env,napi_value exports)423 static napi_value CreateEnumPluggedType(napi_env env, napi_value exports)
424 {
425     napi_value none = nullptr;
426     napi_value ac = nullptr;
427     napi_value usb = nullptr;
428     napi_value wireless = nullptr;
429 
430     napi_create_int32(env, (int32_t)BatteryPluggedType::PLUGGED_TYPE_NONE, &none);
431     napi_create_int32(env, (int32_t)BatteryPluggedType::PLUGGED_TYPE_AC, &ac);
432     napi_create_int32(env, (int32_t)BatteryPluggedType::PLUGGED_TYPE_USB, &usb);
433     napi_create_int32(env, (int32_t)BatteryPluggedType::PLUGGED_TYPE_WIRELESS, &wireless);
434 
435     napi_property_descriptor desc[] = {
436         DECLARE_NAPI_STATIC_PROPERTY("NONE", none),
437         DECLARE_NAPI_STATIC_PROPERTY("AC", ac),
438         DECLARE_NAPI_STATIC_PROPERTY("USB", usb),
439         DECLARE_NAPI_STATIC_PROPERTY("WIRELESS", wireless),
440     };
441 
442     napi_value result = nullptr;
443     napi_define_class(env, "BatteryPluggedType", NAPI_AUTO_LENGTH, EnumPluggedClassConstructor, nullptr,
444         sizeof(desc) / sizeof(*desc), desc, &result);
445 
446     napi_set_named_property(env, exports, "BatteryPluggedType", result);
447 
448     return exports;
449 }
450 
EnumEventChangedCodeConstructor(napi_env env,napi_callback_info info)451 static napi_value EnumEventChangedCodeConstructor(napi_env env, napi_callback_info info)
452 {
453     napi_value thisArg = nullptr;
454     void* data = nullptr;
455 
456     napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
457 
458     napi_value global = nullptr;
459     napi_get_global(env, &global);
460 
461     return thisArg;
462 }
463 
CreateEventBatteryChangedKey(napi_env env,napi_value exports)464 static napi_value CreateEventBatteryChangedKey(napi_env env, napi_value exports)
465 {
466     napi_value soc = nullptr;
467     napi_value chargeState = nullptr;
468     napi_value healthState = nullptr;
469     napi_value pluggedType = nullptr;
470     napi_value voltage = nullptr;
471     napi_value technology = nullptr;
472     napi_value temperature = nullptr;
473     napi_value present = nullptr;
474     napi_value capacityLevel = nullptr;
475 
476     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_CAPACITY, NAPI_AUTO_LENGTH, &soc);
477     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE, NAPI_AUTO_LENGTH, &chargeState);
478     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_HEALTH_STATE, NAPI_AUTO_LENGTH, &healthState);
479     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_PLUGGED_TYPE, NAPI_AUTO_LENGTH, &pluggedType);
480     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_VOLTAGE, NAPI_AUTO_LENGTH, &voltage);
481     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_TECHNOLOGY, NAPI_AUTO_LENGTH, &technology);
482     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_TEMPERATURE, NAPI_AUTO_LENGTH, &temperature);
483     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_PRESENT, NAPI_AUTO_LENGTH, &present);
484     napi_create_string_utf8(env, BatteryInfo::COMMON_EVENT_KEY_CAPACITY_LEVEL, NAPI_AUTO_LENGTH, &capacityLevel);
485 
486     napi_property_descriptor desc[] = {
487         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_SOC", soc),
488         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_CHARGE_STATE", chargeState),
489         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_HEALTH_STATE", healthState),
490         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_PLUGGED_TYPE", pluggedType),
491         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_VOLTAGE", voltage),
492         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_TECHNOLOGY", technology),
493         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_TEMPERATURE", temperature),
494         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_PRESENT", present),
495         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_CAPACITY_LEVEL", capacityLevel),
496     };
497 
498     napi_value result = nullptr;
499     napi_define_class(env, "CommonEventBatteryChangedKey", NAPI_AUTO_LENGTH, EnumEventChangedCodeConstructor, nullptr,
500         sizeof(desc) / sizeof(*desc), desc, &result);
501 
502     napi_set_named_property(env, exports, "CommonEventBatteryChangedKey", result);
503 
504     return exports;
505 }
506 
CreateEventBatteryChangedCode(napi_env env,napi_value exports)507 static napi_value CreateEventBatteryChangedCode(napi_env env, napi_value exports)
508 {
509     napi_value soc = nullptr;
510     napi_value voltage = nullptr;
511     napi_value temperature = nullptr;
512     napi_value healthState = nullptr;
513     napi_value pluggedType = nullptr;
514     napi_value maxCurrent = nullptr;
515     napi_value maxVoltage = nullptr;
516     napi_value chargeState = nullptr;
517     napi_value chargeCounter = nullptr;
518     napi_value present = nullptr;
519     napi_value technology = nullptr;
520     napi_value batteryCapacityLevel = nullptr;
521 
522     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_CAPACITY, &soc);
523     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_VOLTAGE, &voltage);
524     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_TEMPERATURE, &temperature);
525     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_HEALTH_STATE, &healthState);
526     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_PLUGGED_TYPE, &pluggedType);
527     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_PLUGGED_MAX_CURRENT, &maxCurrent);
528     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_PLUGGED_MAX_VOLTAGE, &maxVoltage);
529     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_CHARGE_STATE, &chargeState);
530     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_CHARGE_COUNTER, &chargeCounter);
531     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_PRESENT, &present);
532     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_TECHNOLOGY, &technology);
533     napi_create_int32(env, (int32_t)BatteryInfo::COMMON_EVENT_CODE_CAPACITY_LEVEL, &batteryCapacityLevel);
534 
535     napi_property_descriptor desc[] = {
536         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_SOC", soc),
537         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_VOLTAGE", voltage),
538         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_TEMPERATURE", temperature),
539         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_HEALTH_STATE", healthState),
540         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_PLUGGED_TYPE", pluggedType),
541         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_MAX_CURRENT", maxCurrent),
542         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_MAX_VOLTAGE", maxVoltage),
543         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_CHARGE_STATE", chargeState),
544         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_CHARGE_COUNTER", chargeCounter),
545         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_PRESENT", present),
546         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_TECHNOLOGY", technology),
547         DECLARE_NAPI_STATIC_PROPERTY("EXTRA_CAPACITY_LEVEL", batteryCapacityLevel),
548     };
549 
550     napi_value result = nullptr;
551     napi_define_class(env, "CommonEventBatteryChangedCode", NAPI_AUTO_LENGTH, EnumEventChangedCodeConstructor, nullptr,
552         sizeof(desc) / sizeof(*desc), desc, &result);
553 
554     napi_set_named_property(env, exports, "CommonEventBatteryChangedCode", result);
555 
556     return exports;
557 }
558 
559 EXTERN_C_START
560 /*
561  * function for module exports
562  */
BatteryInit(napi_env env,napi_value exports)563 static napi_value BatteryInit(napi_env env, napi_value exports)
564 {
565     BATTERY_HILOGD(COMP_FWK, "Enter");
566 
567     napi_property_descriptor desc[] = {
568         DECLARE_NAPI_GETTER("batterySOC", BatterySOC),
569         DECLARE_NAPI_GETTER("chargingStatus", GetChargingState),
570         DECLARE_NAPI_GETTER("healthStatus", GetHealthState),
571         DECLARE_NAPI_GETTER("pluggedType", GetPluggedType),
572         DECLARE_NAPI_GETTER("voltage", GetVoltage),
573         DECLARE_NAPI_GETTER("technology", GetTechnology),
574         DECLARE_NAPI_GETTER("batteryTemperature", GetBatteryTemperature),
575         DECLARE_NAPI_GETTER("isBatteryPresent", GetBatteryPresent),
576         DECLARE_NAPI_GETTER("batteryCapacityLevel", GetCapacityLevel),
577         DECLARE_NAPI_GETTER("estimatedRemainingChargeTime", GetRemainingChargeTime),
578         DECLARE_NAPI_GETTER("nowCurrent", GetBatteryNowCurrent),
579         DECLARE_NAPI_GETTER("remainingEnergy", GetBatteryRemainEnergy),
580         DECLARE_NAPI_GETTER("totalEnergy", GetTotalEnergy),
581         DECLARE_NAPI_FUNCTION("setBatteryConfig", SetBatteryConfig),
582         DECLARE_NAPI_FUNCTION("getBatteryConfig", GetBatteryConfig),
583         DECLARE_NAPI_FUNCTION("isBatteryConfigSupported", IsBatteryConfigSupported),
584     };
585     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
586 
587     CreateEnumPluggedType(env, exports);
588     CreateEnumChargeState(env, exports);
589     CreateEnumHealthState(env, exports);
590     CreateEnumLevelState(env, exports);
591     CreateEventBatteryChangedKey(env, exports);
592     CreateEventBatteryChangedCode(env, exports);
593 
594     BATTERY_HILOGD(COMP_FWK, "Success");
595 
596     return exports;
597 }
598 EXTERN_C_END
599 
600 /*
601  * Module definition
602  */
603 static napi_module g_module = {
604     .nm_version = 1,
605     .nm_flags = 0,
606     .nm_filename = "batteryInfo",
607     .nm_register_func = BatteryInit,
608     .nm_modname = "batteryInfo",
609     .nm_priv = ((void*)0),
610     .reserved = {0}
611 };
612 
613 /*
614  * Module registration
615  */
RegisterModule(void)616 extern "C" __attribute__((constructor)) void RegisterModule(void)
617 {
618     napi_module_register(&g_module);
619 }
620