Skip to content

Commit b360339

Browse files
CarterLiCarterLi
committed
Battery: refactors status field from string to bit-fields
1 parent f6a363f commit b360339

File tree

10 files changed

+179
-124
lines changed

10 files changed

+179
-124
lines changed

‎src/detection/battery/battery.h‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,13 +5,24 @@
55

66
#define FF_BATTERY_TEMP_UNSET (-DBL_MAX)
77

8+
typedef enum FFBatteryStatus {
9+
FF_BATTERY_STATUS_NONE = 0,
10+
FF_BATTERY_STATUS_UNKNOWN = 1 << 0,
11+
FF_BATTERY_STATUS_AC_CONNECTED = 1 << 1,
12+
FF_BATTERY_STATUS_USB_CONNECTED = 1 << 2,
13+
FF_BATTERY_STATUS_WIRELESS_CONNECTED = 1 << 3,
14+
FF_BATTERY_STATUS_CHARGING = 1 << 4,
15+
FF_BATTERY_STATUS_DISCHARGING = 1 << 5,
16+
FF_BATTERY_STATUS_CRITICAL = 1 << 6,
17+
} FFBatteryStatus;
18+
819
typedef struct FFBatteryResult {
920
FFstrbuf manufacturer;
1021
FFstrbuf manufactureDate;
1122
FFstrbuf modelName;
1223
FFstrbuf technology;
13-
FFstrbuf status;
1424
FFstrbuf serial;
25+
FFBatteryStatus status;
1526
double capacity;
1627
double temperature;
1728
uint32_t cycleCount;

‎src/detection/battery/battery_android.c‎

Lines changed: 10 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -35,9 +35,9 @@ static const char* parseTermuxApi(FFBatteryOptions* options, FFlist* results) {
3535
battery->temperature = FF_BATTERY_TEMP_UNSET;
3636
battery->cycleCount = 0;
3737
battery->timeRemaining = -1;
38+
battery->status = FF_BATTERY_STATUS_NONE;
3839
ffStrbufInit(&battery->manufacturer);
3940
ffStrbufInit(&battery->modelName);
40-
ffStrbufInit(&battery->status);
4141
ffStrbufInit(&battery->technology);
4242
ffStrbufInit(&battery->serial);
4343
ffStrbufInit(&battery->manufactureDate);
@@ -46,23 +46,21 @@ static const char* parseTermuxApi(FFBatteryOptions* options, FFlist* results) {
4646
const char* acStatus = yyjson_get_str(yyjson_obj_get(root, "plugged"));
4747
if (acStatus) {
4848
if (ffStrEquals(acStatus, "PLUGGED_AC")) {
49-
ffStrbufAppendS(&battery->status, "AC Connected, ");
49+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
5050
} else if (ffStrEquals(acStatus, "PLUGGED_USB")) {
51-
ffStrbufAppendS(&battery->status, "USB Connected, ");
51+
battery->status |= FF_BATTERY_STATUS_USB_CONNECTED;
5252
} else if (ffStrEquals(acStatus, "PLUGGED_WIRELESS")) {
53-
ffStrbufAppendS(&battery->status, "Wireless Connected, ");
53+
battery->status |= FF_BATTERY_STATUS_WIRELESS_CONNECTED;
5454
}
5555
}
5656
const char* status = yyjson_get_str(yyjson_obj_get(root, "status"));
5757
if (status) {
5858
if (ffStrEquals(status, "CHARGING")) {
59-
ffStrbufAppendS(&battery->status, "Charging");
59+
battery->status |= FF_BATTERY_STATUS_CHARGING;
6060
} else if (ffStrEquals(status, "DISCHARGING")) {
61-
ffStrbufAppendS(&battery->status, "Discharging");
61+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
6262
}
6363
}
64-
ffStrbufTrimRight(&battery->status, ' ');
65-
ffStrbufTrimRight(&battery->status, ',');
6664

6765
if (options->temp) {
6866
battery->temperature = yyjson_get_num(yyjson_obj_get(root, "temperature"));
@@ -99,31 +97,25 @@ static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results) {
9997
battery->cycleCount = 0;
10098
battery->timeRemaining = -1;
10199
battery->capacity = 0;
100+
battery->status = FF_BATTERY_STATUS_NONE;
102101
ffStrbufInit(&battery->manufacturer);
103102
ffStrbufInit(&battery->modelName);
104-
ffStrbufInit(&battery->status);
105103
ffStrbufInit(&battery->technology);
106104
ffStrbufInit(&battery->serial);
107105
ffStrbufInit(&battery->manufactureDate);
108106

109107
if (ffParsePropLines(start, "AC powered: ", &temp) && ffStrbufEqualS(&temp, "true")) {
110-
ffStrbufAppendS(&battery->status, "AC powered");
108+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
111109
}
112110
ffStrbufClear(&temp);
113111

114112
if (ffParsePropLines(start, "USB powered: ", &temp) && ffStrbufEqualS(&temp, "true")) {
115-
if (battery->status.length) {
116-
ffStrbufAppendS(&battery->status, ", ");
117-
}
118-
ffStrbufAppendS(&battery->status, "USB powered");
113+
battery->status |= FF_BATTERY_STATUS_USB_CONNECTED;
119114
}
120115
ffStrbufClear(&temp);
121116

122117
if (ffParsePropLines(start, "Wireless powered: ", &temp) && ffStrbufEqualS(&temp, "true")) {
123-
if (battery->status.length) {
124-
ffStrbufAppendS(&battery->status, ", ");
125-
}
126-
ffStrbufAppendS(&battery->status, "Wireless powered");
118+
battery->status |= FF_BATTERY_STATUS_WIRELESS_CONNECTED;
127119
}
128120
ffStrbufClear(&temp);
129121

‎src/detection/battery/battery_apple.c‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -38,9 +38,11 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results) {
3838
ffStrbufInit(&battery->modelName);
3939
ffStrbufInit(&battery->serial);
4040
ffStrbufInit(&battery->technology);
41-
ffStrbufInit(&battery->status);
4241
ffStrbufInit(&battery->manufactureDate);
42+
battery->status = FF_BATTERY_STATUS_NONE;
4343
battery->capacity = currentCapacity * 100.0 / maxCapacity;
44+
battery->cycleCount = 0;
45+
battery->timeRemaining = -1;
4446

4547
ffCfDictGetString(properties, CFSTR(kIOPMDeviceNameKey), &battery->modelName);
4648
ffCfDictGetString(properties, CFSTR(kIOPMPSSerialKey), &battery->serial);
@@ -63,9 +65,9 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results) {
6365
battery->timeRemaining = -1;
6466
if (ffCfDictGetBool(properties, CFSTR(kIOPMPSExternalConnectedKey), &boolValue) == NULL) {
6567
if (boolValue) {
66-
ffStrbufAppendS(&battery->status, "AC connected, ");
68+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
6769
} else {
68-
ffStrbufAppendS(&battery->status, "Discharging, ");
70+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
6971
ffCfDictGetInt(properties, CFSTR("AvgTimeToEmpty"), &battery->timeRemaining); // in minutes
7072
if (battery->timeRemaining < 0 || battery->timeRemaining >= 0xFFFF) {
7173
battery->timeRemaining = -1;
@@ -75,13 +77,11 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results) {
7577
}
7678
}
7779
if (ffCfDictGetBool(properties, CFSTR(kIOPMPSIsChargingKey), &boolValue) == NULL && boolValue) {
78-
ffStrbufAppendS(&battery->status, "Charging, ");
80+
battery->status |= FF_BATTERY_STATUS_CHARGING;
7981
}
8082
if (ffCfDictGetBool(properties, CFSTR(kIOPMPSAtCriticalLevelKey), &boolValue) == NULL && boolValue) {
81-
ffStrbufAppendS(&battery->status, "Critical, ");
83+
battery->status |= FF_BATTERY_STATUS_CRITICAL;
8284
}
83-
ffStrbufTrimRight(&battery->status, ' ');
84-
ffStrbufTrimRight(&battery->status, ',');
8585

8686
int sbdsManufactureDate = 0;
8787
if (ffCfDictGetInt(properties, CFSTR(kIOPMPSManufactureDateKey), &sbdsManufactureDate) == NULL) {

‎src/detection/battery/battery_bsd.c‎

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -39,34 +39,32 @@ const char* ffDetectBattery(FF_A_UNUSED FFBatteryOptions* options, FFlist* resul
3939
battery->cycleCount = 0;
4040
ffStrbufInit(&battery->manufacturer);
4141
ffStrbufInit(&battery->modelName);
42-
ffStrbufInit(&battery->status);
4342
ffStrbufInit(&battery->technology);
4443
ffStrbufInit(&battery->serial);
4544
ffStrbufInit(&battery->manufactureDate);
45+
battery->status = FF_BATTERY_STATUS_NONE;
4646
battery->timeRemaining = -1;
4747
if (battio.battinfo.min > 0) {
4848
battery->timeRemaining = battio.battinfo.min * 60;
4949
}
5050
battery->capacity = battio.battinfo.cap;
5151
if (battio.battinfo.state == ACPI_BATT_STAT_INVALID) {
52-
ffStrbufAppendS(&battery->status, "Unknown, ");
52+
battery->status |= FF_BATTERY_STATUS_UNKNOWN;
5353
} else {
5454
if (battio.battinfo.state & ACPI_BATT_STAT_DISCHARG) {
55-
ffStrbufAppendS(&battery->status, "Discharging, ");
56-
} else if (battio.battinfo.state & ACPI_BATT_STAT_CHARGING) {
57-
ffStrbufAppendS(&battery->status, "Charging, ");
55+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
56+
}
57+
if (battio.battinfo.state & ACPI_BATT_STAT_CHARGING) {
58+
battery->status |= FF_BATTERY_STATUS_CHARGING;
5859
}
5960
if (battio.battinfo.state & ACPI_BATT_STAT_CRITICAL) {
60-
ffStrbufAppendS(&battery->status, "Critical, ");
61+
battery->status |= FF_BATTERY_STATUS_CRITICAL;
6162
}
6263
}
6364

6465
int acadStatus;
6566
if (ioctl(acpifd, ACPIIO_ACAD_GET_STATUS, &acadStatus) >= 0 && acadStatus) {
66-
ffStrbufAppendS(&battery->status, "AC Connected");
67-
} else {
68-
ffStrbufTrimRight(&battery->status, ' ');
69-
ffStrbufTrimRight(&battery->status, ',');
67+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
7068
}
7169

7270
#ifdef ACPIIO_BATT_GET_BIX

‎src/detection/battery/battery_haiku.c‎

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -30,27 +30,25 @@ const char* parseBattery(int dfd, const char* battId, FFlist* results) {
3030
ffStrbufInitS(&battery->manufacturer, extended.oem_info);
3131
ffStrbufInit(&battery->manufactureDate);
3232
ffStrbufInitS(&battery->technology, extended.type); // extended.technology?
33-
ffStrbufInit(&battery->status);
3433
ffStrbufInitS(&battery->serial, extended.serial_number);
34+
battery->status = FF_BATTERY_STATUS_NONE;
3535
battery->temperature = FF_BATTERY_TEMP_UNSET;
3636
battery->cycleCount = extended.cycles;
3737
battery->timeRemaining = -1;
3838
battery->capacity = (double) basic.capacity * 100. / (double) extended.last_full_charge;
3939

4040
if (basic.state & BATTERY_DISCHARGING) {
41-
ffStrbufAppendS(&battery->status, "Discharging, ");
41+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
4242
}
4343
if (basic.state & BATTERY_CHARGING) {
44-
ffStrbufAppendS(&battery->status, "Charging, ");
44+
battery->status |= FF_BATTERY_STATUS_CHARGING;
4545
}
4646
if (basic.state & BATTERY_CRITICAL_STATE) {
47-
ffStrbufAppendS(&battery->status, "Critical, ");
47+
battery->status |= FF_BATTERY_STATUS_CRITICAL;
4848
}
49-
if (basic.state & BATTERY_NOT_CHARGING) {
50-
ffStrbufAppendS(&battery->status, "AC Connected, ");
49+
if (basic.state & BATTERY_NOT_CHARGING || basic.state & BATTERY_CHARGING) {
50+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
5151
}
52-
ffStrbufTrimRight(&battery->status, ' ');
53-
ffStrbufTrimRight(&battery->status, ',');
5452

5553
return NULL;
5654
}

‎src/detection/battery/battery_linux.c‎

Lines changed: 20 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -64,9 +64,9 @@ static bool parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
6464
ffStrbufInit(&result->manufacturer);
6565
ffStrbufInit(&result->modelName);
6666
ffStrbufInit(&result->technology);
67-
ffStrbufInit(&result->status);
6867
ffStrbufInit(&result->serial);
6968
ffStrbufInit(&result->manufactureDate);
69+
result->status = FF_BATTERY_STATUS_NONE;
7070
result->capacity = ffStrbufToDouble(&tmpBuffer, 0);
7171
result->cycleCount = 0;
7272
result->temperature = FF_BATTERY_TEMP_UNSET;
@@ -88,21 +88,23 @@ static bool parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
8888
ffStrbufTrimRightSpace(&result->technology);
8989
}
9090

91-
if (ffReadFileBufferRelative(dfd, "status", &result->status)) {
92-
ffStrbufTrimRightSpace(&result->status);
91+
if (ffReadFileBufferRelative(dfd, "status", &tmpBuffer)) {
92+
ffStrbufTrimRightSpace(&tmpBuffer);
9393
}
9494

9595
// Unknown, Charging, Discharging, Not charging, Full
9696

97-
if (ffStrbufEqualS(&result->status, "Discharging")) {
98-
if (ffReadFileBufferRelative(dfd, "time_to_empty_now", &tmpBuffer)) {
99-
result->timeRemaining = (int32_t) ffStrbufToSInt(&tmpBuffer, 0);
97+
if (ffStrbufEqualS(&tmpBuffer, "Discharging")) {
98+
result->status |= FF_BATTERY_STATUS_DISCHARGING;
99+
FF_STRBUF_AUTO_DESTROY now = ffStrbufCreate();
100+
if (ffReadFileBufferRelative(dfd, "time_to_empty_now", &now)) {
101+
result->timeRemaining = (int32_t) ffStrbufToSInt(&now, 0);
100102
} else {
101-
if (ffReadFileBufferRelative(dfd, "charge_now", &tmpBuffer)) {
102-
int64_t chargeNow = ffStrbufToSInt(&tmpBuffer, 0);
103+
if (ffReadFileBufferRelative(dfd, "charge_now", &now)) {
104+
int64_t chargeNow = ffStrbufToSInt(&now, 0);
103105
if (chargeNow > 0) {
104-
if (ffReadFileBufferRelative(dfd, "current_now", &tmpBuffer)) {
105-
int64_t currentNow = ffStrbufToSInt(&tmpBuffer, INT64_MIN);
106+
if (ffReadFileBufferRelative(dfd, "current_now", &now)) {
107+
int64_t currentNow = ffStrbufToSInt(&now, INT64_MIN);
106108
if (currentNow < 0) {
107109
currentNow = -currentNow;
108110
}
@@ -113,19 +115,16 @@ static bool parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
113115
}
114116
}
115117
}
116-
} else if (ffStrbufEqualS(&result->status, "Not charging") ||
117-
ffStrbufEqualS(&result->status, "Full")) {
118-
ffStrbufClear(&result->status);
118+
} else if (ffStrbufEqualS(&tmpBuffer, "Charging")) {
119+
result->status |= FF_BATTERY_STATUS_CHARGING;
120+
} else if (ffStrbufEqualS(&tmpBuffer, "Unknown")) {
121+
result->status |= FF_BATTERY_STATUS_UNKNOWN;
119122
}
120123

121124
if (ffReadFileBufferRelative(dfd, "capacity_level", &tmpBuffer)) {
122125
ffStrbufTrimRightSpace(&tmpBuffer);
123126
if (ffStrbufEqualS(&tmpBuffer, "Critical")) {
124-
if (result->status.length) {
125-
ffStrbufAppendS(&result->status, ", Critical");
126-
} else {
127-
ffStrbufSetStatic(&result->status, "Critical");
128-
}
127+
result->status |= FF_BATTERY_STATUS_CRITICAL;
129128
}
130129
}
131130

@@ -164,8 +163,8 @@ static bool parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
164163
}
165164
}
166165

167-
FF_DEBUG("Battery \"%s\": Capacity: %.2f%%, Status: \"%s\", Time Remaining: %d seconds, Temperature: %.1f°C, Cycle Count: %u",
168-
id, result->capacity, result->status.chars, result->timeRemaining, result->temperature, result->cycleCount);
166+
FF_DEBUG("Battery \"%s\": Capacity: %.2f%%, Status: \"%x\", Time Remaining: %d seconds, Temperature: %.1f°C, Cycle Count: %u",
167+
id, result->capacity, result->status, result->timeRemaining, result->temperature, result->cycleCount);
169168
return true;
170169
}
171170

@@ -191,11 +190,7 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results) {
191190

192191
if (acConnected) {
193192
FF_LIST_FOR_EACH(FFBatteryResult, batt, *results) {
194-
if (batt->status.length) {
195-
ffStrbufAppendS(&batt->status, ", AC Connected");
196-
} else {
197-
ffStrbufSetStatic(&batt->status, "AC Connected");
198-
}
193+
batt->status |= FF_BATTERY_STATUS_AC_CONNECTED;
199194
}
200195
}
201196

‎src/detection/battery/battery_nbsd.c‎

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -79,27 +79,25 @@ const char* ffDetectBattery(FF_A_UNUSED FFBatteryOptions* options, FFlist* resul
7979
battery->cycleCount = 0;
8080
ffStrbufInit(&battery->manufacturer);
8181
ffStrbufInit(&battery->modelName);
82-
ffStrbufInit(&battery->status);
8382
ffStrbufInit(&battery->technology);
8483
ffStrbufInit(&battery->serial);
8584
ffStrbufInit(&battery->manufactureDate);
85+
battery->status = FF_BATTERY_STATUS_NONE;
8686
battery->timeRemaining = -1;
8787

8888
battery->capacity = (double) curr / (double) max * 100.;
8989
if (charging) {
90-
ffStrbufAppendS(&battery->status, "Charging, ");
90+
battery->status |= FF_BATTERY_STATUS_CHARGING;
9191
} else if (dischargeRate) {
92-
ffStrbufAppendS(&battery->status, "Discharging, ");
92+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
9393
battery->timeRemaining = (int32_t) ((double) curr / dischargeRate * 3600);
9494
}
9595
if (critical) {
96-
ffStrbufAppendS(&battery->status, "Critical, ");
96+
battery->status |= FF_BATTERY_STATUS_CRITICAL;
9797
}
9898
if (acConnected) {
99-
ffStrbufAppendS(&battery->status, "AC Connected");
99+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
100100
}
101-
ffStrbufTrimRight(&battery->status, ' ');
102-
ffStrbufTrimRight(&battery->status, ',');
103101
}
104102

105103
prop_object_iterator_release(iter);

‎src/detection/battery/battery_obsd.c‎

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -30,33 +30,28 @@ const char* ffDetectBattery(FF_A_UNUSED FFBatteryOptions* options, FFlist* resul
3030
battery->capacity = info.battery_life;
3131
ffStrbufInit(&battery->manufacturer);
3232
ffStrbufInit(&battery->modelName);
33-
ffStrbufInit(&battery->status);
3433
ffStrbufInit(&battery->technology);
3534
ffStrbufInit(&battery->serial);
3635
ffStrbufInit(&battery->manufactureDate);
36+
battery->status = FF_BATTERY_STATUS_NONE;
3737

38-
if (info.ac_state == APM_AC_ON) {
39-
ffStrbufAppendS(&battery->status, "AC Connected");
40-
} else if (info.ac_state == APM_AC_BACKUP) {
41-
ffStrbufAppendS(&battery->status, "Backup In Use");
38+
if (info.ac_state == APM_AC_ON || info.ac_state == APM_AC_BACKUP) {
39+
battery->status |= FF_BATTERY_STATUS_AC_CONNECTED;
4240
} else if (info.ac_state == APM_AC_OFF) {
4341
battery->timeRemaining = (int) info.minutes_left * 60;
44-
ffStrbufAppendS(&battery->status, "Discharging");
42+
battery->status |= FF_BATTERY_STATUS_DISCHARGING;
4543
}
4644

4745
if (info.battery_state == APM_BATT_CRITICAL || info.battery_state == APM_BATT_CHARGING || info.battery_state == APM_BATT_UNKNOWN) {
48-
if (battery->status.length) {
49-
ffStrbufAppendS(&battery->status, ", ");
50-
}
5146
switch (info.battery_state) {
5247
case APM_BATT_UNKNOWN:
53-
ffStrbufAppendS(&battery->status, "Unknown");
48+
battery->status |= FF_BATTERY_STATUS_UNKNOWN;
5449
break;
5550
case APM_BATT_CHARGING:
56-
ffStrbufAppendS(&battery->status, "Charging");
51+
battery->status |= FF_BATTERY_STATUS_CHARGING;
5752
break;
5853
case APM_BATT_CRITICAL:
59-
ffStrbufAppendS(&battery->status, "Critical");
54+
battery->status |= FF_BATTERY_STATUS_CRITICAL;
6055
break;
6156
}
6257
}

0 commit comments

Comments
 (0)