openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
platform_system_core/charger/charger.c

992 lines
25 KiB
C
Raw Blame History

/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define DEBUG_UEVENTS
#define CHARGER_KLOG_LEVEL 6
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/input.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/poll.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <cutils/android_reboot.h>
#include <cutils/klog.h>
#include <cutils/list.h>
#include <cutils/misc.h>
#include <cutils/uevent.h>
#include "minui/minui.h"
#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define MSEC_PER_SEC (1000LL)
#define NSEC_PER_MSEC (1000000LL)
#define BATTERY_UNKNOWN_TIME (2 * MSEC_PER_SEC)
#define POWER_ON_KEY_TIME (2 * MSEC_PER_SEC)
#define UNPLUGGED_SHUTDOWN_TIME (10 * MSEC_PER_SEC)
#define BATTERY_FULL_THRESH 95
#define LAST_KMSG_PATH "/proc/last_kmsg"
#define LAST_KMSG_MAX_SZ (32 * 1024)
#define LOGE(x...) do { KLOG_ERROR("charger", x); } while (0)
#define LOGI(x...) do { KLOG_INFO("charger", x); } while (0)
#define LOGV(x...) do { KLOG_DEBUG("charger", x); } while (0)
struct key_state {
bool pending;
bool down;
int64_t timestamp;
};
struct power_supply {
struct listnode list;
char name[256];
char type[32];
bool online;
bool valid;
char cap_path[PATH_MAX];
};
struct frame {
const char *name;
int disp_time;
int min_capacity;
bool level_only;
gr_surface surface;
};
struct animation {
bool run;
struct frame *frames;
int cur_frame;
int num_frames;
int cur_cycle;
int num_cycles;
/* current capacity being animated */
int capacity;
};
struct charger {
int64_t next_screen_transition;
int64_t next_key_check;
int64_t next_pwr_check;
struct key_state keys[KEY_MAX + 1];
int uevent_fd;
struct listnode supplies;
int num_supplies;
int num_supplies_online;
struct animation *batt_anim;
gr_surface surf_unknown;
struct power_supply *battery;
};
struct uevent {
const char *action;
const char *path;
const char *subsystem;
const char *ps_name;
const char *ps_type;
const char *ps_online;
};
static struct frame batt_anim_frames[] = {
{
.name = "charger/battery_0",
.disp_time = 750,
.min_capacity = 0,
},
{
.name = "charger/battery_1",
.disp_time = 750,
.min_capacity = 20,
},
{
.name = "charger/battery_2",
.disp_time = 750,
.min_capacity = 40,
},
{
.name = "charger/battery_3",
.disp_time = 750,
.min_capacity = 60,
},
{
.name = "charger/battery_4",
.disp_time = 750,
.min_capacity = 80,
.level_only = true,
},
{
.name = "charger/battery_5",
.disp_time = 750,
.min_capacity = BATTERY_FULL_THRESH,
},
};
static struct animation battery_animation = {
.frames = batt_anim_frames,
.num_frames = ARRAY_SIZE(batt_anim_frames),
.num_cycles = 3,
};
static struct charger charger_state = {
.batt_anim = &battery_animation,
};
static int char_width;
static int char_height;
/* current time in milliseconds */
static int64_t curr_time_ms(void)
{
struct timespec tm;
clock_gettime(CLOCK_MONOTONIC, &tm);
return tm.tv_sec * MSEC_PER_SEC + (tm.tv_nsec / NSEC_PER_MSEC);
}
static void clear_screen(void)
{
gr_color(0, 0, 0, 255);
gr_fill(0, 0, gr_fb_width(), gr_fb_height());
};
#define MAX_KLOG_WRITE_BUF_SZ 256
static void dump_last_kmsg(void)
{
char *buf;
char *ptr;
unsigned sz = 0;
int len;
LOGI("\n");
LOGI("*************** LAST KMSG ***************\n");
LOGI("\n");
buf = load_file(LAST_KMSG_PATH, &sz);
if (!buf || !sz) {
LOGI("last_kmsg not found. Cold reset?\n");
goto out;
}
len = min(sz, LAST_KMSG_MAX_SZ);
ptr = buf + (sz - len);
while (len > 0) {
int cnt = min(len, MAX_KLOG_WRITE_BUF_SZ);
char yoink;
char *nl;
nl = memrchr(ptr, '\n', cnt - 1);
if (nl)
cnt = nl - ptr + 1;
yoink = ptr[cnt];
ptr[cnt] = '\0';
klog_write(6, "<6>%s", ptr);
ptr[cnt] = yoink;
len -= cnt;
ptr += cnt;
}
free(buf);
out:
LOGI("\n");
LOGI("************* END LAST KMSG *************\n");
LOGI("\n");
}
static int read_file(const char *path, char *buf, size_t sz)
{
int fd;
size_t cnt;
fd = open(path, O_RDONLY, 0);
if (fd < 0)
goto err;
cnt = read(fd, buf, sz - 1);
if (cnt <= 0)
goto err;
buf[cnt] = '\0';
if (buf[cnt - 1] == '\n') {
cnt--;
buf[cnt] = '\0';
}
close(fd);
return cnt;
err:
if (fd >= 0)
close(fd);
return -1;
}
static int read_file_int(const char *path, int *val)
{
char buf[32];
int ret;
int tmp;
char *end;
ret = read_file(path, buf, sizeof(buf));
if (ret < 0)
return -1;
tmp = strtol(buf, &end, 0);
if (end == buf ||
((end < buf+sizeof(buf)) && (*end != '\n' && *end != '\0')))
goto err;
*val = tmp;
return 0;
err:
return -1;
}
static int get_battery_capacity(struct charger *charger)
{
int ret;
int batt_cap = -1;
if (!charger->battery)
return -1;
ret = read_file_int(charger->battery->cap_path, &batt_cap);
if (ret < 0 || batt_cap > 100) {
batt_cap = -1;
}
return batt_cap;
}
static struct power_supply *find_supply(struct charger *charger,
const char *name)
{
struct listnode *node;
struct power_supply *supply;
list_for_each(node, &charger->supplies) {
supply = node_to_item(node, struct power_supply, list);
if (!strncmp(name, supply->name, sizeof(supply->name)))
return supply;
}
return NULL;
}
static struct power_supply *add_supply(struct charger *charger,
const char *name, const char *type,
const char *path, bool online)
{
struct power_supply *supply;
supply = calloc(1, sizeof(struct power_supply));
if (!supply)
return NULL;
strlcpy(supply->name, name, sizeof(supply->name));
strlcpy(supply->type, type, sizeof(supply->type));
snprintf(supply->cap_path, sizeof(supply->cap_path),
"/sys/%s/capacity", path);
supply->online = online;
list_add_tail(&charger->supplies, &supply->list);
charger->num_supplies++;
LOGV("... added %s %s %d\n", supply->name, supply->type, online);
return supply;
}
static void remove_supply(struct charger *charger, struct power_supply *supply)
{
if (!supply)
return;
list_remove(&supply->list);
charger->num_supplies--;
free(supply);
}
static void parse_uevent(const char *msg, struct uevent *uevent)
{
uevent->action = "";
uevent->path = "";
uevent->subsystem = "";
uevent->ps_name = "";
uevent->ps_online = "";
uevent->ps_type = "";
/* currently ignoring SEQNUM */
while (*msg) {
#ifdef DEBUG_UEVENTS
LOGV("uevent str: %s\n", msg);
#endif
if (!strncmp(msg, "ACTION=", 7)) {
msg += 7;
uevent->action = msg;
} else if (!strncmp(msg, "DEVPATH=", 8)) {
msg += 8;
uevent->path = msg;
} else if (!strncmp(msg, "SUBSYSTEM=", 10)) {
msg += 10;
uevent->subsystem = msg;
} else if (!strncmp(msg, "POWER_SUPPLY_NAME=", 18)) {
msg += 18;
uevent->ps_name = msg;
} else if (!strncmp(msg, "POWER_SUPPLY_ONLINE=", 20)) {
msg += 20;
uevent->ps_online = msg;
} else if (!strncmp(msg, "POWER_SUPPLY_TYPE=", 18)) {
msg += 18;
uevent->ps_type = msg;
}
/* advance to after the next \0 */
while (*msg++)
;
}
LOGV("event { '%s', '%s', '%s', '%s', '%s', '%s' }\n",
uevent->action, uevent->path, uevent->subsystem,
uevent->ps_name, uevent->ps_type, uevent->ps_online);
}
static void process_ps_uevent(struct charger *charger, struct uevent *uevent)
{
int online;
char ps_type[32];
struct power_supply *supply = NULL;
int i;
bool was_online = false;
bool battery = false;
if (uevent->ps_type[0] == '\0') {
char *path;
int ret;
if (uevent->path[0] == '\0')
return;
ret = asprintf(&path, "/sys/%s/type", uevent->path);
if (ret <= 0)
return;
ret = read_file(path, ps_type, sizeof(ps_type));
free(path);
if (ret < 0)
return;
} else {
strlcpy(ps_type, uevent->ps_type, sizeof(ps_type));
}
if (!strncmp(ps_type, "Battery", 7))
battery = true;
online = atoi(uevent->ps_online);
supply = find_supply(charger, uevent->ps_name);
if (supply) {
was_online = supply->online;
supply->online = online;
}
if (!strcmp(uevent->action, "add")) {
if (!supply) {
supply = add_supply(charger, uevent->ps_name, ps_type, uevent->path,
online);
if (!supply) {
LOGE("cannot add supply '%s' (%s %d)\n", uevent->ps_name,
uevent->ps_type, online);
return;
}
/* only pick up the first battery for now */
if (battery && !charger->battery)
charger->battery = supply;
} else {
LOGE("supply '%s' already exists..\n", uevent->ps_name);
}
} else if (!strcmp(uevent->action, "remove")) {
if (supply) {
if (charger->battery == supply)
charger->battery = NULL;
remove_supply(charger, supply);
supply = NULL;
}
} else if (!strcmp(uevent->action, "change")) {
if (!supply) {
LOGE("power supply '%s' not found ('%s' %d)\n",
uevent->ps_name, ps_type, online);
return;
}
} else {
return;
}
/* allow battery to be managed in the supply list but make it not
* contribute to online power supplies. */
if (!battery) {
if (was_online && !online)
charger->num_supplies_online--;
else if (supply && !was_online && online)
charger->num_supplies_online++;
}
LOGI("power supply %s (%s) %s (action=%s num_online=%d num_supplies=%d)\n",
uevent->ps_name, ps_type, battery ? "" : online ? "online" : "offline",
uevent->action, charger->num_supplies_online, charger->num_supplies);
}
static void process_uevent(struct charger *charger, struct uevent *uevent)
{
if (!strcmp(uevent->subsystem, "power_supply"))
process_ps_uevent(charger, uevent);
}
#define UEVENT_MSG_LEN 1024
static int handle_uevent_fd(struct charger *charger, int fd)
{
char msg[UEVENT_MSG_LEN+2];
int n;
if (fd < 0)
return -1;
while (true) {
struct uevent uevent;
n = uevent_kernel_multicast_recv(fd, msg, UEVENT_MSG_LEN);
if (n <= 0)
break;
if (n >= UEVENT_MSG_LEN) /* overflow -- discard */
continue;
msg[n] = '\0';
msg[n+1] = '\0';
parse_uevent(msg, &uevent);
process_uevent(charger, &uevent);
}
return 0;
}
static int uevent_callback(int fd, short revents, void *data)
{
struct charger *charger = data;
if (!(revents & POLLIN))
return -1;
return handle_uevent_fd(charger, fd);
}
/* force the kernel to regenerate the change events for the existing
* devices, if valid */
static void do_coldboot(struct charger *charger, DIR *d, const char *event,
bool follow_links, int max_depth)
{
struct dirent *de;
int dfd, fd;
dfd = dirfd(d);
fd = openat(dfd, "uevent", O_WRONLY);
if (fd >= 0) {
write(fd, event, strlen(event));
close(fd);
handle_uevent_fd(charger, charger->uevent_fd);
}
while ((de = readdir(d)) && max_depth > 0) {
DIR *d2;
LOGV("looking at '%s'\n", de->d_name);
if ((de->d_type != DT_DIR && !(de->d_type == DT_LNK && follow_links)) ||
de->d_name[0] == '.') {
LOGV("skipping '%s' type %d (depth=%d follow=%d)\n",
de->d_name, de->d_type, max_depth, follow_links);
continue;
}
LOGV("can descend into '%s'\n", de->d_name);
fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);
if (fd < 0) {
LOGE("cannot openat %d '%s' (%d: %s)\n", dfd, de->d_name,
errno, strerror(errno));
continue;
}
d2 = fdopendir(fd);
if (d2 == 0)
close(fd);
else {
LOGV("opened '%s'\n", de->d_name);
do_coldboot(charger, d2, event, follow_links, max_depth - 1);
closedir(d2);
}
}
}
static void coldboot(struct charger *charger, const char *path,
const char *event)
{
char str[256];
LOGV("doing coldboot '%s' in '%s'\n", event, path);
DIR *d = opendir(path);
if (d) {
snprintf(str, sizeof(str), "%s\n", event);
do_coldboot(charger, d, str, true, 1);
closedir(d);
}
}
static int draw_text(const char *str, int x, int y)
{
int str_len_px = gr_measure(str);
if (x < 0)
x = (gr_fb_width() - str_len_px) / 2;
if (y < 0)
y = (gr_fb_height() - char_height) / 2;
gr_text(x, y, str);
return y + char_height;
}
static void android_green(void)
{
gr_color(0xa4, 0xc6, 0x39, 255);
}
/* returns the last y-offset of where the surface ends */
static int draw_surface_centered(struct charger *charger, gr_surface surface)
{
int w;
int h;
int x;
int y;
w = gr_get_width(surface);
h = gr_get_height(surface);
x = (gr_fb_width() - w) / 2 ;
y = (gr_fb_height() - h) / 2 ;
LOGV("drawing surface %dx%d+%d+%d\n", w, h, x, y);
gr_blit(surface, 0, 0, w, h, x, y);
return y + h;
}
static void draw_unknown(struct charger *charger)
{
int y;
if (charger->surf_unknown) {
draw_surface_centered(charger, charger->surf_unknown);
} else {
android_green();
y = draw_text("Charging!", -1, -1);
draw_text("?\?/100", -1, y + 25);
}
}
static void draw_battery(struct charger *charger)
{
struct animation *batt_anim = charger->batt_anim;
struct frame *frame = &batt_anim->frames[batt_anim->cur_frame];
if (batt_anim->num_frames != 0) {
draw_surface_centered(charger, frame->surface);
LOGV("drawing frame #%d name=%s min_cap=%d time=%d\n",
batt_anim->cur_frame, frame->name, frame->min_capacity,
frame->disp_time);
}
}
static void redraw_screen(struct charger *charger)
{
struct animation *batt_anim = charger->batt_anim;
clear_screen();
/* try to display *something* */
if (batt_anim->capacity < 0 || batt_anim->num_frames == 0)
draw_unknown(charger);
else
draw_battery(charger);
gr_flip();
}
static void kick_animation(struct animation *anim)
{
anim->run = true;
}
static void reset_animation(struct animation *anim)
{
anim->cur_cycle = 0;
anim->cur_frame = 0;
anim->run = false;
}
static void update_screen_state(struct charger *charger, int64_t now)
{
struct animation *batt_anim = charger->batt_anim;
int cur_frame;
int disp_time;
if (!batt_anim->run || now < charger->next_screen_transition)
return;
/* animation is over, blank screen and leave */
if (batt_anim->cur_cycle == batt_anim->num_cycles) {
reset_animation(batt_anim);
charger->next_screen_transition = -1;
gr_fb_blank(true);
LOGV("[%lld] animation done\n", now);
return;
}
disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time;
/* animation starting, set up the animation */
if (batt_anim->cur_frame == 0) {
int batt_cap;
int ret;
LOGV("[%lld] animation starting\n", now);
batt_cap = get_battery_capacity(charger);
if (batt_cap >= 0 && batt_anim->num_frames != 0) {
int i;
/* find first frame given current capacity */
for (i = 1; i < batt_anim->num_frames; i++) {
if (batt_cap < batt_anim->frames[i].min_capacity)
break;
}
batt_anim->cur_frame = i - 1;
/* show the first frame for twice as long */
disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time * 2;
}
batt_anim->capacity = batt_cap;
}
/* unblank the screen on first cycle */
if (batt_anim->cur_cycle == 0)
gr_fb_blank(false);
/* draw the new frame (@ cur_frame) */
redraw_screen(charger);
/* if we don't have anim frames, we only have one image, so just bump
* the cycle counter and exit
*/
if (batt_anim->num_frames == 0 || batt_anim->capacity < 0) {
LOGV("[%lld] animation missing or unknown battery status\n", now);
charger->next_screen_transition = now + BATTERY_UNKNOWN_TIME;
batt_anim->cur_cycle++;
return;
}
/* schedule next screen transition */
charger->next_screen_transition = now + disp_time;
/* advance frame cntr to the next valid frame
* if necessary, advance cycle cntr, and reset frame cntr
*/
batt_anim->cur_frame++;
/* if the frame is used for level-only, that is only show it when it's
* the current level, skip it during the animation.
*/
while (batt_anim->cur_frame < batt_anim->num_frames &&
batt_anim->frames[batt_anim->cur_frame].level_only)
batt_anim->cur_frame++;
if (batt_anim->cur_frame >= batt_anim->num_frames) {
batt_anim->cur_cycle++;
batt_anim->cur_frame = 0;
/* don't reset the cycle counter, since we use that as a signal
* in a test above to check if animation is over
*/
}
}
static int set_key_callback(int code, int value, void *data)
{
struct charger *charger = data;
int64_t now = curr_time_ms();
int down = !!value;
if (code > KEY_MAX)
return -1;
/* ignore events that don't modify our state */
if (charger->keys[code].down == down)
return 0;
/* only record the down even timestamp, as the amount
* of time the key spent not being pressed is not useful */
if (down)
charger->keys[code].timestamp = now;
charger->keys[code].down = down;
charger->keys[code].pending = true;
if (down) {
LOGV("[%lld] key[%d] down\n", now, code);
} else {
int64_t duration = now - charger->keys[code].timestamp;
int64_t secs = duration / 1000;
int64_t msecs = duration - secs * 1000;
LOGV("[%lld] key[%d] up (was down for %lld.%lldsec)\n", now,
code, secs, msecs);
}
return 0;
}
static void update_input_state(struct charger *charger,
struct input_event *ev)
{
if (ev->type != EV_KEY)
return;
set_key_callback(ev->code, ev->value, charger);
}
static void set_next_key_check(struct charger *charger,
struct key_state *key,
int64_t timeout)
{
int64_t then = key->timestamp + timeout;
if (charger->next_key_check == -1 || then < charger->next_key_check)
charger->next_key_check = then;
}
static void process_key(struct charger *charger, int code, int64_t now)
{
struct key_state *key = &charger->keys[code];
int64_t next_key_check;
if (code == KEY_POWER) {
if (key->down) {
int64_t reboot_timeout = key->timestamp + POWER_ON_KEY_TIME;
if (now >= reboot_timeout) {
LOGI("[%lld] rebooting\n", now);
android_reboot(ANDROID_RB_RESTART, 0, 0);
} else {
/* if the key is pressed but timeout hasn't expired,
* make sure we wake up at the right-ish time to check
*/
set_next_key_check(charger, key, POWER_ON_KEY_TIME);
}
} else {
/* if the power key got released, force screen state cycle */
if (key->pending)
kick_animation(charger->batt_anim);
}
}
key->pending = false;
}
static void handle_input_state(struct charger *charger, int64_t now)
{
process_key(charger, KEY_POWER, now);
if (charger->next_key_check != -1 && now > charger->next_key_check)
charger->next_key_check = -1;
}
static void handle_power_supply_state(struct charger *charger, int64_t now)
{
if (charger->num_supplies_online == 0) {
if (charger->next_pwr_check == -1) {
charger->next_pwr_check = now + UNPLUGGED_SHUTDOWN_TIME;
LOGI("[%lld] device unplugged: shutting down in %lld (@ %lld)\n",
now, UNPLUGGED_SHUTDOWN_TIME, charger->next_pwr_check);
} else if (now >= charger->next_pwr_check) {
LOGI("[%lld] shutting down\n", now);
android_reboot(ANDROID_RB_POWEROFF, 0, 0);
} else {
/* otherwise we already have a shutdown timer scheduled */
}
} else {
/* online supply present, reset shutdown timer if set */
if (charger->next_pwr_check != -1) {
LOGI("[%lld] device plugged in: shutdown cancelled\n", now);
kick_animation(charger->batt_anim);
}
charger->next_pwr_check = -1;
}
}
static void wait_next_event(struct charger *charger, int64_t now)
{
int64_t next_event = INT64_MAX;
int64_t timeout;
struct input_event ev;
int ret;
LOGV("[%lld] next screen: %lld next key: %lld next pwr: %lld\n", now,
charger->next_screen_transition, charger->next_key_check,
charger->next_pwr_check);
if (charger->next_screen_transition != -1)
next_event = charger->next_screen_transition;
if (charger->next_key_check != -1 && charger->next_key_check < next_event)
next_event = charger->next_key_check;
if (charger->next_pwr_check != -1 && charger->next_pwr_check < next_event)
next_event = charger->next_pwr_check;
if (next_event != -1 && next_event != INT64_MAX)
timeout = max(0, next_event - now);
else
timeout = -1;
LOGV("[%lld] blocking (%lld)\n", now, timeout);
ret = ev_wait((int)timeout);
if (!ret)
ev_dispatch();
}
static int input_callback(int fd, short revents, void *data)
{
struct charger *charger = data;
struct input_event ev;
int ret;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
update_input_state(charger, &ev);
return 0;
}
static void event_loop(struct charger *charger)
{
int ret;
while (true) {
int64_t now = curr_time_ms();
LOGV("[%lld] event_loop()\n", now);
handle_input_state(charger, now);
handle_power_supply_state(charger, now);
/* do screen update last in case any of the above want to start
* screen transitions (animations, etc)
*/
update_screen_state(charger, now);
wait_next_event(charger, now);
}
}
int main(int argc, char **argv)
{
int ret;
struct charger *charger = &charger_state;
int64_t now = curr_time_ms() - 1;
int fd;
int i;
list_init(&charger->supplies);
klog_init();
klog_set_level(CHARGER_KLOG_LEVEL);
dump_last_kmsg();
LOGI("--------------- STARTING CHARGER MODE ---------------\n");
gr_init();
gr_font_size(&char_width, &char_height);
ev_init(input_callback, charger);
fd = uevent_open_socket(64*1024, true);
if (fd >= 0) {
fcntl(fd, F_SETFL, O_NONBLOCK);
ev_add_fd(fd, uevent_callback, charger);
}
charger->uevent_fd = fd;
coldboot(charger, "/sys/class/power_supply", "add");
ret = res_create_surface("charger/battery_fail", &charger->surf_unknown);
if (ret < 0) {
LOGE("Cannot load image\n");
charger->surf_unknown = NULL;
}
for (i = 0; i < charger->batt_anim->num_frames; i++) {
struct frame *frame = &charger->batt_anim->frames[i];
ret = res_create_surface(frame->name, &frame->surface);
if (ret < 0) {
LOGE("Cannot load image %s\n", frame->name);
/* TODO: free the already allocated surfaces... */
charger->batt_anim->num_frames = 0;
charger->batt_anim->num_cycles = 1;
break;
}
}
ev_sync_key_state(set_key_callback, charger);
#ifndef CHARGER_DISABLE_INIT_BLANK
gr_fb_blank(true);
#endif
charger->next_screen_transition = now - 1;
charger->next_key_check = -1;
charger->next_pwr_check = -1;
reset_animation(charger->batt_anim);
kick_animation(charger->batt_anim);
event_loop(charger);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink