adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New kernel drivers and device migrations (#563)

Browse Source
This commit is contained in:
Ken Van Hoeylandt
2026-07-14 20:26:57 +02:00
committed by GitHub
parent 955416dac8
commit 8af6204ba1
215 changed files with 6359 additions and 3633 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/app/power/Power.cpp
+136 -133
View File
@@ -12,6 +12,8 @@
#include <lvgl.h>
#include <vector>
namespace tt::app::power {
#define TAG "power"
@@ -30,20 +32,32 @@ std::shared_ptr<PowerApp> optApp() {
}
}
namespace {
constexpr PowerSupplyProperty DISPLAYED_PROPERTIES[] = {
POWER_SUPPLY_PROP_IS_CHARGING,
POWER_SUPPLY_PROP_VOLTAGE,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_CURRENT,
};
} // namespace
struct PropertyWidget {
PowerSupplyProperty property;
lv_obj_t* label;
};
struct DeviceEntry {
::Device* device = nullptr;
lv_obj_t* enableSwitch = nullptr;
lv_obj_t* quickChargeSwitch = nullptr;
std::vector<PropertyWidget> propertyWidgets;
};
class PowerApp : public App {
Timer update_timer = Timer(Timer::Type::Periodic, kernel::millisToTicks(1000),[]() { onTimer(); });
::Device* power = nullptr;
lv_obj_t* enableLabel = nullptr;
lv_obj_t* enableSwitch = nullptr;
lv_obj_t* quickChargeLabel = nullptr;
lv_obj_t* quickChargeSwitch = nullptr;
lv_obj_t* batteryVoltageLabel = nullptr;
lv_obj_t* chargeStateLabel = nullptr;
lv_obj_t* chargeLevelLabel = nullptr;
lv_obj_t* currentLabel = nullptr;
std::vector<DeviceEntry> entries;
static void onTimer() {
auto app = optApp();
@@ -52,22 +66,31 @@ class PowerApp : public App {
}
}
static bool collectDevice(::Device* device, void* context) {
auto* devices = static_cast<std::vector<::Device*>*>(context);
devices->push_back(device);
return true;
}
void onPowerEnabledChanged(lv_event_t* event) {
lv_event_code_t code = lv_event_get_code(event);
auto* enable_switch = static_cast<lv_obj_t*>(lv_event_get_target(event));
if (code == LV_EVENT_VALUE_CHANGED) {
bool is_on = lv_obj_has_state(enable_switch, LV_STATE_CHECKED);
auto* device = static_cast<::Device*>(lv_event_get_user_data(event));
if (power_supply_is_allowed_to_charge(power) != is_on) {
power_supply_set_allowed_to_charge(power, is_on);
if (power_supply_is_allowed_to_charge(device) != is_on) {
power_supply_set_allowed_to_charge(device, is_on);
updateUi();
}
}
}
static void onPowerEnabledChangedCallback(lv_event_t* event) {
auto* app = (PowerApp*)lv_event_get_user_data(event);
app->onPowerEnabledChanged(event);
auto app = optApp();
if (app != nullptr) {
app->onPowerEnabledChanged(event);
}
}
void onQuickChargeChanged(lv_event_t* event) {
@@ -75,97 +98,61 @@ class PowerApp : public App {
auto* qc_switch = static_cast<lv_obj_t*>(lv_event_get_target(event));
if (code == LV_EVENT_VALUE_CHANGED) {
bool is_on = lv_obj_has_state(qc_switch, LV_STATE_CHECKED);
auto* device = static_cast<::Device*>(lv_event_get_user_data(event));
if (power_supply_is_quick_charge_enabled(power) != is_on) {
power_supply_set_quick_charge_enabled(power, is_on);
if (power_supply_is_quick_charge_enabled(device) != is_on) {
power_supply_set_quick_charge_enabled(device, is_on);
updateUi();
}
}
}
static void onQuickChargeChangedCallback(lv_event_t* event) {
auto* app = (PowerApp*)lv_event_get_user_data(event);
app->onQuickChargeChanged(event);
auto app = optApp();
if (app != nullptr) {
app->onQuickChargeChanged(event);
}
}
static void setPropertyLabelText(lv_obj_t* label, PowerSupplyProperty property, const PowerSupplyPropertyValue& value) {
switch (property) {
case POWER_SUPPLY_PROP_IS_CHARGING:
lv_label_set_text_fmt(label, "Charging: %s", value.int_value ? "yes" : "no");
break;
case POWER_SUPPLY_PROP_VOLTAGE:
lv_label_set_text_fmt(label, "Battery voltage: %d mV", value.int_value);
break;
case POWER_SUPPLY_PROP_CAPACITY:
lv_label_set_text_fmt(label, "Charge level: %d%%", value.int_value);
break;
case POWER_SUPPLY_PROP_CURRENT:
lv_label_set_text_fmt(label, "Current: %d mA", value.int_value);
break;
}
}
void updateUi() {
if (chargeStateLabel == nullptr) {
if (entries.empty()) {
return;
}
const char* charge_state;
PowerSupplyPropertyValue property_value;
if (power_supply_get_property(power, POWER_SUPPLY_PROP_IS_CHARGING, &property_value) == ERROR_NONE) {
charge_state = property_value.int_value ? "yes" : "no";
} else {
charge_state = "N/A";
}
int charge_level;
bool charge_level_scaled_set = false;
if (power_supply_get_property(power, POWER_SUPPLY_PROP_CAPACITY, &property_value) == ERROR_NONE) {
charge_level = property_value.int_value;
charge_level_scaled_set = true;
}
bool charging_enabled_set = power_supply_supports_charge_control(power);
bool charging_enabled_and_allowed = charging_enabled_set && power_supply_is_allowed_to_charge(power);
bool quick_charge_set = power_supply_supports_quick_charge(power);
bool quick_charge_enabled = quick_charge_set && power_supply_is_quick_charge_enabled(power);
int current;
bool current_set = false;
if (power_supply_get_property(power, POWER_SUPPLY_PROP_CURRENT, &property_value) == ERROR_NONE) {
current = property_value.int_value;
current_set = true;
}
int battery_voltage;
bool battery_voltage_set = false;
if (power_supply_get_property(power, POWER_SUPPLY_PROP_VOLTAGE, &property_value) == ERROR_NONE) {
battery_voltage = property_value.int_value;
battery_voltage_set = true;
}
lvgl::lock(kernel::millisToTicks(1000));
if (charging_enabled_set) {
lv_obj_set_state(enableSwitch, LV_STATE_CHECKED, charging_enabled_and_allowed);
lv_obj_remove_flag(enableSwitch, LV_OBJ_FLAG_HIDDEN);
lv_obj_remove_flag(enableLabel, LV_OBJ_FLAG_HIDDEN);
} else {
lv_obj_add_flag(enableSwitch, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(enableLabel, LV_OBJ_FLAG_HIDDEN);
}
for (auto& entry : entries) {
if (entry.enableSwitch != nullptr) {
lv_obj_set_state(entry.enableSwitch, LV_STATE_CHECKED, power_supply_is_allowed_to_charge(entry.device));
}
if (quick_charge_set) {
lv_obj_set_state(quickChargeSwitch, LV_STATE_CHECKED, quick_charge_enabled);
lv_obj_remove_flag(quickChargeSwitch, LV_OBJ_FLAG_HIDDEN);
lv_obj_remove_flag(quickChargeLabel, LV_OBJ_FLAG_HIDDEN);
} else {
lv_obj_add_flag(quickChargeSwitch, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(quickChargeLabel, LV_OBJ_FLAG_HIDDEN);
}
if (entry.quickChargeSwitch != nullptr) {
lv_obj_set_state(entry.quickChargeSwitch, LV_STATE_CHECKED, power_supply_is_quick_charge_enabled(entry.device));
}
lv_label_set_text_fmt(chargeStateLabel, "Charging: %s", charge_state);
if (battery_voltage_set) {
lv_label_set_text_fmt(batteryVoltageLabel, "Battery voltage: %d mV", battery_voltage);
} else {
lv_label_set_text_fmt(batteryVoltageLabel, "Battery voltage: N/A");
}
if (charge_level_scaled_set) {
lv_label_set_text_fmt(chargeLevelLabel, "Charge level: %d%%", charge_level);
} else {
lv_label_set_text_fmt(chargeLevelLabel, "Charge level: N/A");
}
if (current_set) {
lv_label_set_text_fmt(currentLabel, "Current: %d mA", current);
} else {
lv_label_set_text_fmt(currentLabel, "Current: N/A");
PowerSupplyPropertyValue value;
for (auto& widget : entry.propertyWidgets) {
if (power_supply_get_property(entry.device, widget.property, &value) == ERROR_NONE) {
setPropertyLabelText(widget.label, widget.property, value);
}
}
}
lvgl::unlock();
@@ -173,9 +160,7 @@ class PowerApp : public App {
public:
void onCreate(AppContext& app) override {
power = device_find_first_active_by_type(&POWER_SUPPLY_TYPE);
}
void onCreate(AppContext& app) override {}
void onShow(AppContext& app, lv_obj_t* parent) override {
lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
@@ -183,7 +168,10 @@ public:
lvgl::toolbar_create(parent, app);
if (power == nullptr) {
std::vector<::Device*> devices;
device_for_each_of_type(&POWER_SUPPLY_TYPE, &devices, collectDevice);
if (devices.empty()) {
return;
}
@@ -193,60 +181,75 @@ public:
lv_obj_set_flex_grow(wrapper, 1);
lv_obj_set_flex_flow(wrapper, LV_FLEX_FLOW_COLUMN);
// Row: charge enable/disable
lv_obj_t* switch_container = lv_obj_create(wrapper);
lv_obj_set_width(switch_container, LV_PCT(100));
lv_obj_set_height(switch_container, LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(switch_container, 0, 0);
lv_obj_set_style_pad_gap(switch_container, 0, 0);
lvgl::obj_set_style_bg_invisible(switch_container);
entries.clear();
entries.reserve(devices.size());
enableLabel = lv_label_create(switch_container);
lv_label_set_text(enableLabel, "Charging enabled");
lv_obj_set_align(enableLabel, LV_ALIGN_LEFT_MID);
for (size_t i = 0; i < devices.size(); i++) {
::Device* device = devices[i];
lv_obj_t* enable_switch = lv_switch_create(switch_container);
lv_obj_add_event_cb(enable_switch, onPowerEnabledChangedCallback, LV_EVENT_VALUE_CHANGED, this);
lv_obj_set_align(enable_switch, LV_ALIGN_RIGHT_MID);
enableSwitch = enable_switch;
DeviceEntry entry;
entry.device = device;
// Row: quick charge enable/disable
lv_obj_t* qc_container = lv_obj_create(wrapper);
lv_obj_set_width(qc_container, LV_PCT(100));
lv_obj_set_height(qc_container, LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(qc_container, 0, 0);
lv_obj_set_style_pad_gap(qc_container, 0, 0);
lvgl::obj_set_style_bg_invisible(qc_container);
lv_obj_t* header = lv_label_create(wrapper);
lv_label_set_text_fmt(header, "%s:", device->name);
quickChargeLabel = lv_label_create(qc_container);
lv_label_set_text(quickChargeLabel, "Quick charge");
lv_obj_set_align(quickChargeLabel, LV_ALIGN_LEFT_MID);
if (power_supply_supports_charge_control(device)) {
lv_obj_t* switch_container = lv_obj_create(wrapper);
lv_obj_set_width(switch_container, LV_PCT(100));
lv_obj_set_height(switch_container, LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(switch_container, 0, 0);
lv_obj_set_style_pad_gap(switch_container, 0, 0);
lvgl::obj_set_style_bg_invisible(switch_container);
lv_obj_t* qc_switch = lv_switch_create(qc_container);
lv_obj_add_event_cb(qc_switch, onQuickChargeChangedCallback, LV_EVENT_VALUE_CHANGED, this);
lv_obj_set_align(qc_switch, LV_ALIGN_RIGHT_MID);
quickChargeSwitch = qc_switch;
lv_obj_t* label = lv_label_create(switch_container);
lv_label_set_text(label, "Charging enabled");
lv_obj_set_align(label, LV_ALIGN_LEFT_MID);
chargeStateLabel = lv_label_create(wrapper);
chargeLevelLabel = lv_label_create(wrapper);
batteryVoltageLabel = lv_label_create(wrapper);
currentLabel = lv_label_create(wrapper);
lv_obj_t* enable_switch = lv_switch_create(switch_container);
lv_obj_add_event_cb(enable_switch, onPowerEnabledChangedCallback, LV_EVENT_VALUE_CHANGED, device);
lv_obj_set_align(enable_switch, LV_ALIGN_RIGHT_MID);
lv_obj_set_state(enable_switch, LV_STATE_CHECKED, power_supply_is_allowed_to_charge(device));
entry.enableSwitch = enable_switch;
}
updateUi();
if (power_supply_supports_quick_charge(device)) {
lv_obj_t* qc_container = lv_obj_create(wrapper);
lv_obj_set_width(qc_container, LV_PCT(100));
lv_obj_set_height(qc_container, LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(qc_container, 0, 0);
lv_obj_set_style_pad_gap(qc_container, 0, 0);
lvgl::obj_set_style_bg_invisible(qc_container);
lv_obj_t* label = lv_label_create(qc_container);
lv_label_set_text(label, "Quick charge");
lv_obj_set_align(label, LV_ALIGN_LEFT_MID);
lv_obj_t* qc_switch = lv_switch_create(qc_container);
lv_obj_add_event_cb(qc_switch, onQuickChargeChangedCallback, LV_EVENT_VALUE_CHANGED, device);
lv_obj_set_align(qc_switch, LV_ALIGN_RIGHT_MID);
lv_obj_set_state(qc_switch, LV_STATE_CHECKED, power_supply_is_quick_charge_enabled(device));
entry.quickChargeSwitch = qc_switch;
}
PowerSupplyPropertyValue value;
for (auto property : DISPLAYED_PROPERTIES) {
if (power_supply_get_property(device, property, &value) == ERROR_NONE) {
lv_obj_t* label = lv_label_create(wrapper);
lv_obj_set_style_margin_left(label, 24, LV_STATE_DEFAULT);
setPropertyLabelText(label, property, value);
entry.propertyWidgets.push_back({ property, label });
}
}
entries.push_back(entry);
}
update_timer.start();
}
void onHide(AppContext& app) override {
update_timer.stop();
enableLabel = nullptr;
enableSwitch = nullptr;
quickChargeLabel = nullptr;
quickChargeSwitch = nullptr;
chargeStateLabel = nullptr;
chargeLevelLabel = nullptr;
batteryVoltageLabel = nullptr;
currentLabel = nullptr;
entries.clear();
}
};