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