From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/power/SDL_power.c | 113 ++++ contrib/SDL-3.2.8/src/power/SDL_syspower.h | 46 ++ contrib/SDL-3.2.8/src/power/android/SDL_syspower.c | 60 ++ .../SDL-3.2.8/src/power/emscripten/SDL_syspower.c | 59 ++ contrib/SDL-3.2.8/src/power/haiku/SDL_syspower.c | 123 ++++ contrib/SDL-3.2.8/src/power/linux/SDL_syspower.c | 648 +++++++++++++++++++++ contrib/SDL-3.2.8/src/power/macos/SDL_syspower.c | 185 ++++++ contrib/SDL-3.2.8/src/power/n3ds/SDL_syspower.c | 104 ++++ contrib/SDL-3.2.8/src/power/psp/SDL_syspower.c | 61 ++ contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.h | 28 + contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.m | 105 ++++ contrib/SDL-3.2.8/src/power/vita/SDL_syspower.c | 61 ++ contrib/SDL-3.2.8/src/power/windows/SDL_syspower.c | 70 +++ 13 files changed, 1663 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/power/SDL_power.c create mode 100644 contrib/SDL-3.2.8/src/power/SDL_syspower.h create mode 100644 contrib/SDL-3.2.8/src/power/android/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/emscripten/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/haiku/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/linux/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/macos/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/n3ds/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/psp/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.h create mode 100644 contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.m create mode 100644 contrib/SDL-3.2.8/src/power/vita/SDL_syspower.c create mode 100644 contrib/SDL-3.2.8/src/power/windows/SDL_syspower.c (limited to 'contrib/SDL-3.2.8/src/power') diff --git a/contrib/SDL-3.2.8/src/power/SDL_power.c b/contrib/SDL-3.2.8/src/power/SDL_power.c new file mode 100644 index 0000000..5dde3b1 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/SDL_power.c @@ -0,0 +1,113 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" +#include "SDL_syspower.h" + +/* + * Returns true if we have a definitive answer. + * false to try next implementation. + */ +typedef bool (*SDL_GetPowerInfo_Impl)(SDL_PowerState *state, int *seconds, + int *percent); + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_HARDWIRED +// This is for things that _never_ have a battery +static bool SDL_GetPowerInfo_Hardwired(SDL_PowerState *state, int *seconds, int *percent) +{ + *seconds = -1; + *percent = -1; + *state = SDL_POWERSTATE_NO_BATTERY; + return true; +} +#endif + +static SDL_GetPowerInfo_Impl implementations[] = { +#ifdef SDL_POWER_LINUX // in order of preference. More than could work. + SDL_GetPowerInfo_Linux_org_freedesktop_upower, + SDL_GetPowerInfo_Linux_sys_class_power_supply, + SDL_GetPowerInfo_Linux_proc_acpi, + SDL_GetPowerInfo_Linux_proc_apm, +#endif +#ifdef SDL_POWER_WINDOWS // handles Win32, Win64, PocketPC. + SDL_GetPowerInfo_Windows, +#endif +#ifdef SDL_POWER_UIKIT // handles iPhone/iPad/etc + SDL_GetPowerInfo_UIKit, +#endif +#ifdef SDL_POWER_MACOSX // handles macOS, Darwin. + SDL_GetPowerInfo_MacOSX, +#endif +#ifdef SDL_POWER_HAIKU // with BeOS euc.jp apm driver. Does this work on Haiku? + SDL_GetPowerInfo_Haiku, +#endif +#ifdef SDL_POWER_ANDROID // handles Android. + SDL_GetPowerInfo_Android, +#endif +#ifdef SDL_POWER_PSP // handles PSP. + SDL_GetPowerInfo_PSP, +#endif +#ifdef SDL_POWER_VITA // handles PSVita. + SDL_GetPowerInfo_VITA, +#endif +#ifdef SDL_POWER_N3DS // handles N3DS. + SDL_GetPowerInfo_N3DS, +#endif +#ifdef SDL_POWER_EMSCRIPTEN // handles Emscripten + SDL_GetPowerInfo_Emscripten, +#endif + +#ifdef SDL_POWER_HARDWIRED + SDL_GetPowerInfo_Hardwired, +#endif +}; +#endif + +SDL_PowerState SDL_GetPowerInfo(int *seconds, int *percent) +{ +#ifndef SDL_POWER_DISABLED + const int total = sizeof(implementations) / sizeof(implementations[0]); + SDL_PowerState result = SDL_POWERSTATE_UNKNOWN; + int i; +#endif + + int _seconds, _percent; + // Make these never NULL for platform-specific implementations. + if (!seconds) { + seconds = &_seconds; + } + if (!percent) { + percent = &_percent; + } + +#ifndef SDL_POWER_DISABLED + for (i = 0; i < total; i++) { + if (implementations[i](&result, seconds, percent)) { + return result; + } + } +#endif + + // nothing was definitive. + *seconds = -1; + *percent = -1; + return SDL_POWERSTATE_UNKNOWN; +} diff --git a/contrib/SDL-3.2.8/src/power/SDL_syspower.h b/contrib/SDL-3.2.8/src/power/SDL_syspower.h new file mode 100644 index 0000000..5f8fa53 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/SDL_syspower.h @@ -0,0 +1,46 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// These are functions that need to be implemented by a port of SDL + +#ifndef SDL_syspower_h_ +#define SDL_syspower_h_ + +// Not all of these are available in a given build. Use #ifdefs, etc. +bool SDL_GetPowerInfo_Linux_org_freedesktop_upower(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Linux_sys_class_power_supply(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Linux_proc_acpi(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Windows(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_UIKit(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_MacOSX(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Haiku(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Android(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_PSP(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_VITA(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_N3DS(SDL_PowerState *, int *, int *); +bool SDL_GetPowerInfo_Emscripten(SDL_PowerState *, int *, int *); + +// this one is static in SDL_power.c +/* bool SDL_GetPowerInfo_Hardwired(SDL_PowerState *, int *, int *);*/ + +#endif // SDL_syspower_h_ diff --git a/contrib/SDL-3.2.8/src/power/android/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/android/SDL_syspower.c new file mode 100644 index 0000000..7f8d3f9 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/android/SDL_syspower.c @@ -0,0 +1,60 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_ANDROID + +#include "../SDL_syspower.h" + +#include "../../core/android/SDL_android.h" + +bool SDL_GetPowerInfo_Android(SDL_PowerState *state, int *seconds, int *percent) +{ + int battery; + int plugged; + int charged; + + if (Android_JNI_GetPowerInfo(&plugged, &charged, &battery, seconds, percent) != -1) { + if (plugged) { + if (charged) { + *state = SDL_POWERSTATE_CHARGED; + } else if (battery) { + *state = SDL_POWERSTATE_CHARGING; + } else { + *state = SDL_POWERSTATE_NO_BATTERY; + *seconds = -1; + *percent = -1; + } + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + } + } else { + *state = SDL_POWERSTATE_UNKNOWN; + *seconds = -1; + *percent = -1; + } + + return true; +} + +#endif // SDL_POWER_ANDROID +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/emscripten/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/emscripten/SDL_syspower.c new file mode 100644 index 0000000..14928de --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/emscripten/SDL_syspower.c @@ -0,0 +1,59 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_EMSCRIPTEN + +#include + +bool SDL_GetPowerInfo_Emscripten(SDL_PowerState *state, int *seconds, int *percent) +{ + EmscriptenBatteryEvent batteryState; + int haveBattery = 0; + + if (emscripten_get_battery_status(&batteryState) == EMSCRIPTEN_RESULT_NOT_SUPPORTED) { + return false; + } + + haveBattery = batteryState.level != 1.0 || !batteryState.charging || batteryState.chargingTime != 0.0; + + if (!haveBattery) { + *state = SDL_POWERSTATE_NO_BATTERY; + *seconds = -1; + *percent = -1; + return true; + } + + if (batteryState.charging) { + *state = batteryState.chargingTime == 0.0 ? SDL_POWERSTATE_CHARGED : SDL_POWERSTATE_CHARGING; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + } + + *seconds = (int)batteryState.dischargingTime; + *percent = (int)batteryState.level * 100; + + return true; +} + +#endif // SDL_POWER_EMSCRIPTEN +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/haiku/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/haiku/SDL_syspower.c new file mode 100644 index 0000000..c334fa6 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/haiku/SDL_syspower.c @@ -0,0 +1,123 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// uses BeOS euc.jp apm driver. +// !!! FIXME: does this thing even work on Haiku? + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_HAIKU + +#include +#include +#include +#include +#include +#include + +// These values are from apm.h ... +#define APM_DEVICE_PATH "/dev/misc/apm" +#define APM_FUNC_OFFSET 0x5300 +#define APM_FUNC_GET_POWER_STATUS 10 +#define APM_DEVICE_ALL 1 +#define APM_BIOS_CALL (B_DEVICE_OP_CODES_END + 3) + +bool SDL_GetPowerInfo_Haiku(SDL_PowerState *state, int *seconds, int *percent) +{ + const int fd = open("/dev/misc/apm", O_RDONLY | O_CLOEXEC); + bool need_details = false; + uint16 regs[6]; + uint8 ac_status; + uint8 battery_status; + uint8 battery_flags; + uint8 battery_life; + uint32 battery_time; + int rc; + + if (fd == -1) { + return false; // maybe some other method will work? + } + + SDL_memset(regs, '\0', sizeof(regs)); + regs[0] = APM_FUNC_OFFSET + APM_FUNC_GET_POWER_STATUS; + regs[1] = APM_DEVICE_ALL; + rc = ioctl(fd, APM_BIOS_CALL, regs); + close(fd); + + if (rc < 0) { + return false; + } + + ac_status = regs[1] >> 8; + battery_status = regs[1] & 0xFF; + battery_flags = regs[2] >> 8; + battery_life = regs[2] & 0xFF; + battery_time = (uint32)regs[3]; + + // in theory, _something_ should be set in battery_flags, right? + if (battery_flags == 0x00) { // older APM BIOS? Less fields. + battery_time = 0xFFFF; + if (battery_status == 0xFF) { + battery_flags = 0xFF; + } else { + battery_flags = (1 << battery_status); + } + } + + if ((battery_time != 0xFFFF) && (battery_time & (1 << 15))) { + // time is in minutes, not seconds + battery_time = (battery_time & 0x7FFF) * 60; + } + + if (battery_flags == 0xFF) { // unknown state + *state = SDL_POWERSTATE_UNKNOWN; + } else if (battery_flags & (1 << 7)) { // no battery + *state = SDL_POWERSTATE_NO_BATTERY; + } else if (battery_flags & (1 << 3)) { // charging + *state = SDL_POWERSTATE_CHARGING; + need_details = true; + } else if (ac_status == 1) { + *state = SDL_POWERSTATE_CHARGED; // on AC, not charging. + need_details = true; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; // not on AC. + need_details = true; + } + + *percent = -1; + *seconds = -1; + if (need_details) { + const int pct = (int)battery_life; + const int secs = (int)battery_time; + + if (pct != 255) { // 255 == unknown + *percent = (pct > 100) ? 100 : pct; // clamp between 0%, 100% + } + if (secs != 0xFFFF) { // 0xFFFF == unknown + *seconds = secs; + } + } + + return true; // the definitive answer if APM driver replied. +} + +#endif // SDL_POWER_HAIKU +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/linux/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/linux/SDL_syspower.c new file mode 100644 index 0000000..428be4a --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/linux/SDL_syspower.c @@ -0,0 +1,648 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_LINUX + +#include +#include + +#include +#include +#include +#include + +#include "../SDL_syspower.h" + +#include "../../core/linux/SDL_dbus.h" + +static const char *proc_apm_path = "/proc/apm"; +static const char *proc_acpi_battery_path = "/proc/acpi/battery"; +static const char *proc_acpi_ac_adapter_path = "/proc/acpi/ac_adapter"; +static const char *sys_class_power_supply_path = "/sys/class/power_supply"; + +static int open_power_file(const char *base, const char *node, const char *key) +{ + int fd; + const size_t pathlen = SDL_strlen(base) + SDL_strlen(node) + SDL_strlen(key) + 3; + char *path = SDL_stack_alloc(char, pathlen); + if (!path) { + return -1; // oh well. + } + + (void)SDL_snprintf(path, pathlen, "%s/%s/%s", base, node, key); + fd = open(path, O_RDONLY | O_CLOEXEC); + SDL_stack_free(path); + return fd; +} + +static bool read_power_file(const char *base, const char *node, const char *key, + char *buf, size_t buflen) +{ + ssize_t br = 0; + const int fd = open_power_file(base, node, key); + if (fd == -1) { + return false; + } + br = read(fd, buf, buflen - 1); + close(fd); + if (br < 0) { + return false; + } + buf[br] = '\0'; // null-terminate the string. + return true; +} + +static bool make_proc_acpi_key_val(char **_ptr, char **_key, char **_val) +{ + char *ptr = *_ptr; + + while (*ptr == ' ') { + ptr++; // skip whitespace. + } + + if (*ptr == '\0') { + return false; // EOF. + } + + *_key = ptr; + + while ((*ptr != ':') && (*ptr != '\0')) { + ptr++; + } + + if (*ptr == '\0') { + return false; // (unexpected) EOF. + } + + *(ptr++) = '\0'; // terminate the key. + + while (*ptr == ' ') { + ptr++; // skip whitespace. + } + + if (*ptr == '\0') { + return false; // (unexpected) EOF. + } + + *_val = ptr; + + while ((*ptr != '\n') && (*ptr != '\0')) { + ptr++; + } + + if (*ptr != '\0') { + *(ptr++) = '\0'; // terminate the value. + } + + *_ptr = ptr; // store for next time. + return true; +} + +static void check_proc_acpi_battery(const char *node, bool *have_battery, + bool *charging, int *seconds, int *percent) +{ + const char *base = proc_acpi_battery_path; + char info[1024]; + char state[1024]; + char *ptr = NULL; + char *key = NULL; + char *val = NULL; + bool charge = false; + bool choose = false; + int maximum = -1; + int remaining = -1; + int secs = -1; + int pct = -1; + + if (!read_power_file(base, node, "state", state, sizeof(state))) { + return; + } else if (!read_power_file(base, node, "info", info, sizeof(info))) { + return; + } + + ptr = &state[0]; + while (make_proc_acpi_key_val(&ptr, &key, &val)) { + if (SDL_strcasecmp(key, "present") == 0) { + if (SDL_strcasecmp(val, "yes") == 0) { + *have_battery = true; + } + } else if (SDL_strcasecmp(key, "charging state") == 0) { + // !!! FIXME: what exactly _does_ charging/discharging mean? + if (SDL_strcasecmp(val, "charging/discharging") == 0) { + charge = true; + } else if (SDL_strcasecmp(val, "charging") == 0) { + charge = true; + } + } else if (SDL_strcasecmp(key, "remaining capacity") == 0) { + char *endptr = NULL; + const int cvt = (int)SDL_strtol(val, &endptr, 10); + if (*endptr == ' ') { + remaining = cvt; + } + } + } + + ptr = &info[0]; + while (make_proc_acpi_key_val(&ptr, &key, &val)) { + if (SDL_strcasecmp(key, "design capacity") == 0) { + char *endptr = NULL; + const int cvt = (int)SDL_strtol(val, &endptr, 10); + if (*endptr == ' ') { + maximum = cvt; + } + } + } + + if ((maximum >= 0) && (remaining >= 0)) { + pct = (int)((((float)remaining) / ((float)maximum)) * 100.0f); + if (pct < 0) { + pct = 0; + } else if (pct > 100) { + pct = 100; + } + } + + // !!! FIXME: calculate (secs). + + /* + * We pick the battery that claims to have the most minutes left. + * (failing a report of minutes, we'll take the highest percent.) + */ + if ((secs < 0) && (*seconds < 0)) { + if ((pct < 0) && (*percent < 0)) { + choose = true; // at least we know there's a battery. + } + if (pct > *percent) { + choose = true; + } + } else if (secs > *seconds) { + choose = true; + } + + if (choose) { + *seconds = secs; + *percent = pct; + *charging = charge; + } +} + +static void check_proc_acpi_ac_adapter(const char *node, bool *have_ac) +{ + const char *base = proc_acpi_ac_adapter_path; + char state[256]; + char *ptr = NULL; + char *key = NULL; + char *val = NULL; + + if (!read_power_file(base, node, "state", state, sizeof(state))) { + return; + } + + ptr = &state[0]; + while (make_proc_acpi_key_val(&ptr, &key, &val)) { + if (SDL_strcasecmp(key, "state") == 0) { + if (SDL_strcasecmp(val, "on-line") == 0) { + *have_ac = true; + } + } + } +} + +bool SDL_GetPowerInfo_Linux_proc_acpi(SDL_PowerState *state, int *seconds, int *percent) +{ + struct dirent *dent = NULL; + DIR *dirp = NULL; + bool have_battery = false; + bool have_ac = false; + bool charging = false; + + *seconds = -1; + *percent = -1; + *state = SDL_POWERSTATE_UNKNOWN; + + dirp = opendir(proc_acpi_battery_path); + if (!dirp) { + return false; // can't use this interface. + } else { + while ((dent = readdir(dirp)) != NULL) { + const char *node = dent->d_name; + check_proc_acpi_battery(node, &have_battery, &charging, + seconds, percent); + } + closedir(dirp); + } + + dirp = opendir(proc_acpi_ac_adapter_path); + if (!dirp) { + return false; // can't use this interface. + } else { + while ((dent = readdir(dirp)) != NULL) { + const char *node = dent->d_name; + check_proc_acpi_ac_adapter(node, &have_ac); + } + closedir(dirp); + } + + if (!have_battery) { + *state = SDL_POWERSTATE_NO_BATTERY; + } else if (charging) { + *state = SDL_POWERSTATE_CHARGING; + } else if (have_ac) { + *state = SDL_POWERSTATE_CHARGED; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + } + + return true; // definitive answer. +} + +static bool next_string(char **_ptr, char **_str) +{ + char *ptr = *_ptr; + char *str; + + while (*ptr == ' ') { // skip any spaces... + ptr++; + } + + if (*ptr == '\0') { + return false; + } + + str = ptr; + while ((*ptr != ' ') && (*ptr != '\n') && (*ptr != '\0')) { + ptr++; + } + + if (*ptr != '\0') { + *(ptr++) = '\0'; + } + + *_str = str; + *_ptr = ptr; + return true; +} + +static bool int_string(char *str, int *val) +{ + char *endptr = NULL; + *val = (int)SDL_strtol(str, &endptr, 0); + return (*str != '\0') && (*endptr == '\0'); +} + +// http://lxr.linux.no/linux+v2.6.29/drivers/char/apm-emulation.c +bool SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState *state, int *seconds, int *percent) +{ + bool need_details = false; + int ac_status = 0; + int battery_status = 0; + int battery_flag = 0; + int battery_percent = 0; + int battery_time = 0; + const int fd = open(proc_apm_path, O_RDONLY | O_CLOEXEC); + char buf[128]; + char *ptr = &buf[0]; + char *str = NULL; + ssize_t br; + + if (fd == -1) { + return false; // can't use this interface. + } + + br = read(fd, buf, sizeof(buf) - 1); + close(fd); + + if (br < 0) { + return false; + } + + buf[br] = '\0'; // null-terminate the string. + if (!next_string(&ptr, &str)) { // driver version + return false; + } + if (!next_string(&ptr, &str)) { // BIOS version + return false; + } + if (!next_string(&ptr, &str)) { // APM flags + return false; + } + + if (!next_string(&ptr, &str)) { // AC line status + return false; + } else if (!int_string(str, &ac_status)) { + return false; + } + + if (!next_string(&ptr, &str)) { // battery status + return false; + } else if (!int_string(str, &battery_status)) { + return false; + } + if (!next_string(&ptr, &str)) { // battery flag + return false; + } else if (!int_string(str, &battery_flag)) { + return false; + } + if (!next_string(&ptr, &str)) { // remaining battery life percent + return false; + } + if (str[SDL_strlen(str) - 1] == '%') { + str[SDL_strlen(str) - 1] = '\0'; + } + if (!int_string(str, &battery_percent)) { + return false; + } + + if (!next_string(&ptr, &str)) { // remaining battery life time + return false; + } else if (!int_string(str, &battery_time)) { + return false; + } + + if (!next_string(&ptr, &str)) { // remaining battery life time units + return false; + } else if (SDL_strcasecmp(str, "min") == 0) { + battery_time *= 60; + } + + if (battery_flag == 0xFF) { // unknown state + *state = SDL_POWERSTATE_UNKNOWN; + } else if (battery_flag & (1 << 7)) { // no battery + *state = SDL_POWERSTATE_NO_BATTERY; + } else if (battery_flag & (1 << 3)) { // charging + *state = SDL_POWERSTATE_CHARGING; + need_details = true; + } else if (ac_status == 1) { + *state = SDL_POWERSTATE_CHARGED; // on AC, not charging. + need_details = true; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + need_details = true; + } + + *percent = -1; + *seconds = -1; + if (need_details) { + const int pct = battery_percent; + const int secs = battery_time; + + if (pct >= 0) { // -1 == unknown + *percent = (pct > 100) ? 100 : pct; // clamp between 0%, 100% + } + if (secs >= 0) { // -1 == unknown + *seconds = secs; + } + } + + return true; +} + +bool SDL_GetPowerInfo_Linux_sys_class_power_supply(SDL_PowerState *state, int *seconds, int *percent) +{ + const char *base = sys_class_power_supply_path; + struct dirent *dent; + DIR *dirp; + + dirp = opendir(base); + if (!dirp) { + return false; + } + + *state = SDL_POWERSTATE_NO_BATTERY; // assume we're just plugged in. + *seconds = -1; + *percent = -1; + + while ((dent = readdir(dirp)) != NULL) { + const char *name = dent->d_name; + bool choose = false; + char str[64]; + SDL_PowerState st; + int secs; + int pct; + int energy; + int power; + + if ((SDL_strcmp(name, ".") == 0) || (SDL_strcmp(name, "..") == 0)) { + continue; // skip these, of course. + } else if (!read_power_file(base, name, "type", str, sizeof(str))) { + continue; // Don't know _what_ we're looking at. Give up on it. + } else if (SDL_strcasecmp(str, "Battery\n") != 0) { + continue; // we don't care about UPS and such. + } + + /* if the scope is "device," it might be something like a PS4 + controller reporting its own battery, and not something that powers + the system. Most system batteries don't list a scope at all; we + assume it's a system battery if not specified. */ + if (read_power_file(base, name, "scope", str, sizeof(str))) { + if (SDL_strcasecmp(str, "Device\n") == 0) { + continue; // skip external devices with their own batteries. + } + } + + // some drivers don't offer this, so if it's not explicitly reported assume it's present. + if (read_power_file(base, name, "present", str, sizeof(str)) && (SDL_strcmp(str, "0\n") == 0)) { + st = SDL_POWERSTATE_NO_BATTERY; + } else if (!read_power_file(base, name, "status", str, sizeof(str))) { + st = SDL_POWERSTATE_UNKNOWN; // uh oh + } else if (SDL_strcasecmp(str, "Charging\n") == 0) { + st = SDL_POWERSTATE_CHARGING; + } else if (SDL_strcasecmp(str, "Discharging\n") == 0) { + st = SDL_POWERSTATE_ON_BATTERY; + } else if ((SDL_strcasecmp(str, "Full\n") == 0) || (SDL_strcasecmp(str, "Not charging\n") == 0)) { + st = SDL_POWERSTATE_CHARGED; + } else { + st = SDL_POWERSTATE_UNKNOWN; // uh oh + } + + if (!read_power_file(base, name, "capacity", str, sizeof(str))) { + pct = -1; + } else { + pct = SDL_atoi(str); + pct = (pct > 100) ? 100 : pct; // clamp between 0%, 100% + } + + if (read_power_file(base, name, "time_to_empty_now", str, sizeof(str))) { + secs = SDL_atoi(str); + secs = (secs <= 0) ? -1 : secs; // 0 == unknown + } else if (st == SDL_POWERSTATE_ON_BATTERY) { + /* energy is Watt*hours and power is Watts */ + energy = (read_power_file(base, name, "energy_now", str, sizeof(str))) ? SDL_atoi(str) : -1; + power = (read_power_file(base, name, "power_now", str, sizeof(str))) ? SDL_atoi(str) : -1; + secs = (energy >= 0 && power > 0) ? (3600LL * energy) / power : -1; + } else { + secs = -1; + } + + /* + * We pick the battery that claims to have the most minutes left. + * (failing a report of minutes, we'll take the highest percent.) + */ + if ((secs < 0) && (*seconds < 0)) { + if ((pct < 0) && (*percent < 0)) { + choose = true; // at least we know there's a battery. + } else if (pct > *percent) { + choose = true; + } + } else if (secs > *seconds) { + choose = true; + } + + if (choose) { + *seconds = secs; + *percent = pct; + *state = st; + } + } + + closedir(dirp); + return true; // don't look any further. +} + +// d-bus queries to org.freedesktop.UPower. +#ifdef SDL_USE_LIBDBUS +#define UPOWER_DBUS_NODE "org.freedesktop.UPower" +#define UPOWER_DBUS_PATH "/org/freedesktop/UPower" +#define UPOWER_DBUS_INTERFACE "org.freedesktop.UPower" +#define UPOWER_DEVICE_DBUS_INTERFACE "org.freedesktop.UPower.Device" + +static void check_upower_device(DBusConnection *conn, const char *path, SDL_PowerState *state, int *seconds, int *percent) +{ + bool choose = false; + SDL_PowerState st; + int secs; + int pct; + Uint32 ui32 = 0; + Sint64 si64 = 0; + double d = 0.0; + + if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "Type", DBUS_TYPE_UINT32, &ui32)) { + return; // Don't know _what_ we're looking at. Give up on it. + } else if (ui32 != 2) { // 2==Battery + return; // we don't care about UPS and such. + } else if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "PowerSupply", DBUS_TYPE_BOOLEAN, &ui32)) { + return; + } else if (!ui32) { + return; // we don't care about random devices with batteries, like wireless controllers, etc + } + + if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "IsPresent", DBUS_TYPE_BOOLEAN, &ui32)) { + return; + } + if (!ui32) { + st = SDL_POWERSTATE_NO_BATTERY; + } else { + /* Get updated information on the battery status + * This can occasionally fail, and we'll just return slightly stale data in that case + */ + SDL_DBus_CallMethodOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "Refresh", DBUS_TYPE_INVALID, DBUS_TYPE_INVALID); + + if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "State", DBUS_TYPE_UINT32, &ui32)) { + st = SDL_POWERSTATE_UNKNOWN; // uh oh + } else if (ui32 == 1) { // 1 == charging + st = SDL_POWERSTATE_CHARGING; + } else if ((ui32 == 2) || (ui32 == 3) || (ui32 == 6)) { + /* 2 == discharging; + * 3 == empty; + * 6 == "pending discharge" which GNOME interprets as equivalent + * to discharging */ + st = SDL_POWERSTATE_ON_BATTERY; + } else if ((ui32 == 4) || (ui32 == 5)) { + /* 4 == full; + * 5 == "pending charge" which GNOME shows as "Not charging", + * used when a battery is configured to stop charging at a + * lower than 100% threshold */ + st = SDL_POWERSTATE_CHARGED; + } else { + st = SDL_POWERSTATE_UNKNOWN; // uh oh + } + } + + if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "Percentage", DBUS_TYPE_DOUBLE, &d)) { + pct = -1; // some old/cheap batteries don't set this property. + } else { + pct = (int)d; + pct = (pct > 100) ? 100 : pct; // clamp between 0%, 100% + } + + if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "TimeToEmpty", DBUS_TYPE_INT64, &si64)) { + secs = -1; + } else { + secs = (int)si64; + secs = (secs <= 0) ? -1 : secs; // 0 == unknown + } + + /* + * We pick the battery that claims to have the most minutes left. + * (failing a report of minutes, we'll take the highest percent.) + */ + if ((secs < 0) && (*seconds < 0)) { + if ((pct < 0) && (*percent < 0)) { + choose = true; // at least we know there's a battery. + } else if (pct > *percent) { + choose = true; + } + } else if (secs > *seconds) { + choose = true; + } + + if (choose) { + *seconds = secs; + *percent = pct; + *state = st; + } +} +#endif + +bool SDL_GetPowerInfo_Linux_org_freedesktop_upower(SDL_PowerState *state, int *seconds, int *percent) +{ + bool result = false; + +#ifdef SDL_USE_LIBDBUS + SDL_DBusContext *dbus = SDL_DBus_GetContext(); + char **paths = NULL; + int i, numpaths = 0; + + if (!dbus || !SDL_DBus_CallMethodOnConnection(dbus->system_conn, UPOWER_DBUS_NODE, UPOWER_DBUS_PATH, UPOWER_DBUS_INTERFACE, "EnumerateDevices", + DBUS_TYPE_INVALID, + DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &numpaths, DBUS_TYPE_INVALID)) { + return false; // try a different approach than UPower. + } + + result = true; // Clearly we can use this interface. + *state = SDL_POWERSTATE_NO_BATTERY; // assume we're just plugged in. + *seconds = -1; + *percent = -1; + + for (i = 0; i < numpaths; i++) { + check_upower_device(dbus->system_conn, paths[i], state, seconds, percent); + } + + dbus->free_string_array(paths); +#endif // SDL_USE_LIBDBUS + + return result; +} + +#endif // SDL_POWER_LINUX +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/macos/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/macos/SDL_syspower.c new file mode 100644 index 0000000..4764da9 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/macos/SDL_syspower.c @@ -0,0 +1,185 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_MACOSX + +#include +#include +#include + +// CoreFoundation is so verbose... +#define STRMATCH(a, b) (CFStringCompare(a, b, 0) == kCFCompareEqualTo) +#define GETVAL(k, v) \ + CFDictionaryGetValueIfPresent(dict, CFSTR(k), (const void **)v) + +// Note that AC power sources also include a laptop battery it is charging. +static void checkps(CFDictionaryRef dict, bool *have_ac, bool *have_battery, + bool *charging, int *seconds, int *percent) +{ + CFStringRef strval; // don't CFRelease() this. + CFBooleanRef bval; + CFNumberRef numval; + bool charge = false; + bool choose = false; + bool is_ac = false; + int secs = -1; + int maxpct = -1; + int pct = -1; + + if ((GETVAL(kIOPSIsPresentKey, &bval)) && (bval == kCFBooleanFalse)) { + return; // nothing to see here. + } + + if (!GETVAL(kIOPSPowerSourceStateKey, &strval)) { + return; + } + + if (STRMATCH(strval, CFSTR(kIOPSACPowerValue))) { + is_ac = *have_ac = true; + } else if (!STRMATCH(strval, CFSTR(kIOPSBatteryPowerValue))) { + return; // not a battery? + } + + if ((GETVAL(kIOPSIsChargingKey, &bval)) && (bval == kCFBooleanTrue)) { + charge = true; + } + + if (GETVAL(kIOPSMaxCapacityKey, &numval)) { + SInt32 val = -1; + CFNumberGetValue(numval, kCFNumberSInt32Type, &val); + if (val > 0) { + *have_battery = true; + maxpct = (int)val; + } + } + + if (GETVAL(kIOPSMaxCapacityKey, &numval)) { + SInt32 val = -1; + CFNumberGetValue(numval, kCFNumberSInt32Type, &val); + if (val > 0) { + *have_battery = true; + maxpct = (int)val; + } + } + + if (GETVAL(kIOPSTimeToEmptyKey, &numval)) { + SInt32 val = -1; + CFNumberGetValue(numval, kCFNumberSInt32Type, &val); + + // macOS reports 0 minutes until empty if you're plugged in. :( + if ((val == 0) && (is_ac)) { + val = -1; // !!! FIXME: calc from timeToFull and capacity? + } + + secs = (int)val; + if (secs > 0) { + secs *= 60; // value is in minutes, so convert to seconds. + } + } + + if (GETVAL(kIOPSCurrentCapacityKey, &numval)) { + SInt32 val = -1; + CFNumberGetValue(numval, kCFNumberSInt32Type, &val); + pct = (int)val; + } + + if ((pct > 0) && (maxpct > 0)) { + pct = (int)((((double)pct) / ((double)maxpct)) * 100.0); + } + + if (pct > 100) { + pct = 100; + } + + /* + * We pick the battery that claims to have the most minutes left. + * (failing a report of minutes, we'll take the highest percent.) + */ + if ((secs < 0) && (*seconds < 0)) { + if ((pct < 0) && (*percent < 0)) { + choose = true; // at least we know there's a battery. + } + if (pct > *percent) { + choose = true; + } + } else if (secs > *seconds) { + choose = true; + } + + if (choose) { + *seconds = secs; + *percent = pct; + *charging = charge; + } +} + +#undef GETVAL +#undef STRMATCH + +bool SDL_GetPowerInfo_MacOSX(SDL_PowerState *state, int *seconds, int *percent) +{ + CFTypeRef blob = IOPSCopyPowerSourcesInfo(); + + *seconds = -1; + *percent = -1; + *state = SDL_POWERSTATE_UNKNOWN; + + if (blob != NULL) { + CFArrayRef list = IOPSCopyPowerSourcesList(blob); + if (list != NULL) { + // don't CFRelease() the list items, or dictionaries! + bool have_ac = false; + bool have_battery = false; + bool charging = false; + const CFIndex total = CFArrayGetCount(list); + CFIndex i; + for (i = 0; i < total; i++) { + CFTypeRef ps = (CFTypeRef)CFArrayGetValueAtIndex(list, i); + CFDictionaryRef dict = + IOPSGetPowerSourceDescription(blob, ps); + if (dict != NULL) { + checkps(dict, &have_ac, &have_battery, &charging, + seconds, percent); + } + } + + if (!have_battery) { + *state = SDL_POWERSTATE_NO_BATTERY; + } else if (charging) { + *state = SDL_POWERSTATE_CHARGING; + } else if (have_ac) { + *state = SDL_POWERSTATE_CHARGED; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + } + + CFRelease(list); + } + CFRelease(blob); + } + + return true; // always the definitive answer on macOS. +} + +#endif // SDL_POWER_MACOSX +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/n3ds/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/n3ds/SDL_syspower.c new file mode 100644 index 0000000..822398a --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/n3ds/SDL_syspower.c @@ -0,0 +1,104 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_internal.h" + +#if !defined(SDL_POWER_DISABLED) && defined(SDL_POWER_N3DS) + +#include <3ds.h> + +static SDL_PowerState GetPowerState(void); +static bool ReadStateFromPTMU(bool *is_plugged, u8 *is_charging); +static int GetBatteryPercentage(void); + +#define BATTERY_PERCENT_REG 0xB +#define BATTERY_PERCENT_REG_SIZE 2 + +bool SDL_GetPowerInfo_N3DS(SDL_PowerState *state, int *seconds, int *percent) +{ + *state = GetPowerState(); + *percent = GetBatteryPercentage(); + *seconds = -1; // libctru doesn't provide a way to estimate battery life + + return true; +} + +static SDL_PowerState GetPowerState(void) +{ + bool is_plugged; + u8 is_charging; + + if (!ReadStateFromPTMU(&is_plugged, &is_charging)) { + return SDL_POWERSTATE_UNKNOWN; + } + + if (is_charging) { + return SDL_POWERSTATE_CHARGING; + } + + if (is_plugged) { + return SDL_POWERSTATE_CHARGED; + } + + return SDL_POWERSTATE_ON_BATTERY; +} + +static bool ReadStateFromPTMU(bool *is_plugged, u8 *is_charging) +{ + if (R_FAILED(ptmuInit())) { + return SDL_SetError("Failed to initialise PTMU service"); + } + + if (R_FAILED(PTMU_GetAdapterState(is_plugged))) { + ptmuExit(); + return SDL_SetError("Failed to read adapter state"); + } + + if (R_FAILED(PTMU_GetBatteryChargeState(is_charging))) { + ptmuExit(); + return SDL_SetError("Failed to read battery charge state"); + } + + ptmuExit(); + return true; +} + +static int GetBatteryPercentage(void) +{ + u8 data[BATTERY_PERCENT_REG_SIZE]; + + if (R_FAILED(mcuHwcInit())) { + SDL_SetError("Failed to initialise mcuHwc service"); + return -1; + } + + if (R_FAILED(MCUHWC_ReadRegister(BATTERY_PERCENT_REG, data, BATTERY_PERCENT_REG_SIZE))) { + mcuHwcExit(); + SDL_SetError("Failed to read battery register"); + return -1; + } + + mcuHwcExit(); + + return (int)SDL_round(data[0] + data[1] / 256.0); +} + +#endif // !SDL_POWER_DISABLED && SDL_POWER_N3DS diff --git a/contrib/SDL-3.2.8/src/power/psp/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/psp/SDL_syspower.c new file mode 100644 index 0000000..231411f --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/psp/SDL_syspower.c @@ -0,0 +1,61 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_PSP + +#include + +bool SDL_GetPowerInfo_PSP(SDL_PowerState *state, int *seconds, int *percent) +{ + int battery = scePowerIsBatteryExist(); + int plugged = scePowerIsPowerOnline(); + int charging = scePowerIsBatteryCharging(); + + *state = SDL_POWERSTATE_UNKNOWN; + *seconds = -1; + *percent = -1; + + if (!battery) { + *state = SDL_POWERSTATE_NO_BATTERY; + *seconds = -1; + *percent = -1; + } else if (charging) { + *state = SDL_POWERSTATE_CHARGING; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } else if (plugged) { + *state = SDL_POWERSTATE_CHARGED; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } + + return true; // always the definitive answer on PSP. +} + +#endif // SDL_POWER_PSP +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.h b/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.h new file mode 100644 index 0000000..41fc43b --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.h @@ -0,0 +1,28 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifdef SDL_POWER_UIKIT + +void SDL_UIKit_UpdateBatteryMonitoring(void); +bool SDL_GetPowerInfo_UIKit(SDL_PowerState *state, int *seconds, int *percent); + +#endif // SDL_POWER_UIKIT diff --git a/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.m b/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.m new file mode 100644 index 0000000..561f2de --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/uikit/SDL_syspower.m @@ -0,0 +1,105 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_UIKIT + +#import + +#include "SDL_syspower.h" + +#ifndef SDL_PLATFORM_TVOS +// turn off the battery monitor if it's been more than X ms since last check. +static const int BATTERY_MONITORING_TIMEOUT = 3000; +static Uint64 SDL_UIKitLastPowerInfoQuery = 0; + +void SDL_UIKit_UpdateBatteryMonitoring(void) +{ + if (SDL_UIKitLastPowerInfoQuery) { + if (SDL_GetTicks() >= (SDL_UIKitLastPowerInfoQuery + BATTERY_MONITORING_TIMEOUT)) { + UIDevice *uidev = [UIDevice currentDevice]; + SDL_assert([uidev isBatteryMonitoringEnabled] == YES); + [uidev setBatteryMonitoringEnabled:NO]; + SDL_UIKitLastPowerInfoQuery = 0; + } + } +} +#else +void SDL_UIKit_UpdateBatteryMonitoring(void) +{ + // Do nothing. +} +#endif // !SDL_PLATFORM_TVOS + +bool SDL_GetPowerInfo_UIKit(SDL_PowerState *state, int *seconds, int *percent) +{ +#ifdef SDL_PLATFORM_TVOS + *state = SDL_POWERSTATE_NO_BATTERY; + *seconds = -1; + *percent = -1; +#else // SDL_PLATFORM_TVOS + @autoreleasepool { + UIDevice *uidev = [UIDevice currentDevice]; + + if (!SDL_UIKitLastPowerInfoQuery) { + SDL_assert(uidev.isBatteryMonitoringEnabled == NO); + uidev.batteryMonitoringEnabled = YES; + } + + /* UIKit_GL_SwapWindow() (etc) will check this and disable the battery + * monitoring if the app hasn't queried it in the last X seconds. + * Apparently monitoring the battery burns battery life. :) + * Apple's docs say not to monitor the battery unless you need it. + */ + SDL_UIKitLastPowerInfoQuery = SDL_GetTicks(); + + *seconds = -1; // no API to estimate this in UIKit. + + switch (uidev.batteryState) { + case UIDeviceBatteryStateCharging: + *state = SDL_POWERSTATE_CHARGING; + break; + + case UIDeviceBatteryStateFull: + *state = SDL_POWERSTATE_CHARGED; + break; + + case UIDeviceBatteryStateUnplugged: + *state = SDL_POWERSTATE_ON_BATTERY; + break; + + case UIDeviceBatteryStateUnknown: + default: + *state = SDL_POWERSTATE_UNKNOWN; + break; + } + + const float level = uidev.batteryLevel; + *percent = ((level < 0.0f) ? -1 : ((int)((level * 100) + 0.5f))); + } +#endif // SDL_PLATFORM_TVOS + + return true; // always the definitive answer on iOS. +} + +#endif // SDL_POWER_UIKIT +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/vita/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/vita/SDL_syspower.c new file mode 100644 index 0000000..5dc8f5e --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/vita/SDL_syspower.c @@ -0,0 +1,61 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_VITA + +#include + +bool SDL_GetPowerInfo_VITA(SDL_PowerState *state, int *seconds, int *percent) +{ + int battery = 1; + int plugged = scePowerIsPowerOnline(); + int charging = scePowerIsBatteryCharging(); + + *state = SDL_POWERSTATE_UNKNOWN; + *seconds = -1; + *percent = -1; + + if (!battery) { + *state = SDL_POWERSTATE_NO_BATTERY; + *seconds = -1; + *percent = -1; + } else if (charging) { + *state = SDL_POWERSTATE_CHARGING; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } else if (plugged) { + *state = SDL_POWERSTATE_CHARGED; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; + *percent = scePowerGetBatteryLifePercent(); + *seconds = scePowerGetBatteryLifeTime() * 60; + } + + return true; // always the definitive answer on VITA. +} + +#endif // SDL_POWER_VITA +#endif // SDL_POWER_DISABLED diff --git a/contrib/SDL-3.2.8/src/power/windows/SDL_syspower.c b/contrib/SDL-3.2.8/src/power/windows/SDL_syspower.c new file mode 100644 index 0000000..ab334f3 --- /dev/null +++ b/contrib/SDL-3.2.8/src/power/windows/SDL_syspower.c @@ -0,0 +1,70 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_POWER_DISABLED +#ifdef SDL_POWER_WINDOWS + +#include "../../core/windows/SDL_windows.h" + +bool SDL_GetPowerInfo_Windows(SDL_PowerState *state, int *seconds, int *percent) +{ + SYSTEM_POWER_STATUS status; + bool need_details = false; + + // This API should exist back to Win95. + if (!GetSystemPowerStatus(&status)) { + // !!! FIXME: push GetLastError() into SDL_GetError() + *state = SDL_POWERSTATE_UNKNOWN; + } else if (status.BatteryFlag == 0xFF) { // unknown state + *state = SDL_POWERSTATE_UNKNOWN; + } else if (status.BatteryFlag & (1 << 7)) { // no battery + *state = SDL_POWERSTATE_NO_BATTERY; + } else if (status.BatteryFlag & (1 << 3)) { // charging + *state = SDL_POWERSTATE_CHARGING; + need_details = true; + } else if (status.ACLineStatus == 1) { + *state = SDL_POWERSTATE_CHARGED; // on AC, not charging. + need_details = true; + } else { + *state = SDL_POWERSTATE_ON_BATTERY; // not on AC. + need_details = true; + } + + *percent = -1; + *seconds = -1; + if (need_details) { + const int pct = (int)status.BatteryLifePercent; + const int secs = (int)status.BatteryLifeTime; + + if (pct != 255) { // 255 == unknown + *percent = (pct > 100) ? 100 : pct; // clamp between 0%, 100% + } + if (secs != 0xFFFFFFFF) { // ((DWORD)-1) == unknown + *seconds = secs; + } + } + + return true; // always the definitive answer on Windows. +} + +#endif // SDL_POWER_WINDOWS +#endif // SDL_POWER_DISABLED -- cgit v1.2.3