/*

* Copyright (C) 2007 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.

*/

#include <errno.h>

#include <fcntl.h>

#include <linux/input.h>

#include <pthread.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/types.h>

#include <time.h>

#include <unistd.h>

#include "common.h"

#include <cutils/android_reboot.h>

#include <cutils/properties.h>

#include "minui/minui.h"

#include "recovery_ui.h"

extern int __system(const char *command);

#if defined(BOARD_HAS_NO_SELECT_BUTTON) || defined(BOARD_TOUCH_RECOVERY)

static int gShowBackButton = 1;

#else

static int gShowBackButton = 0;

#endif

#define MAX_COLS 96

#define MAX_ROWS 32

#define MENU_MAX_COLS 64

#define MENU_MAX_ROWS 250

#define MIN_LOG_ROWS 3

#define CHAR_WIDTH BOARD_RECOVERY_CHAR_WIDTH

#define CHAR_HEIGHT BOARD_RECOVERY_CHAR_HEIGHT

#define UI_WAIT_KEY_TIMEOUT_SEC 3600

#define UI_KEY_REPEAT_INTERVAL 80

#define UI_KEY_WAIT_REPEAT 400

UIParameters ui_parameters = {

6, // indeterminate progress bar frames

20, // fps

7, // installation icon frames (0 == static image)

13, 190, // installation icon overlay offset

};

static pthread_mutex_t gUpdateMutex = PTHREAD_MUTEX_INITIALIZER;

static gr_surface gBackgroundIcon[NUM_BACKGROUND_ICONS];

static gr_surface *gInstallationOverlay;

static gr_surface *gProgressBarIndeterminate;

static gr_surface gProgressBarEmpty;

static gr_surface gProgressBarFill;

static gr_surface gBackground;

static int ui_has_initialized = 0;

static int ui_log_stdout = 1;

static int boardEnableKeyRepeat = 0;

static int boardRepeatableKeys[64], boardNumRepeatableKeys = 0;

static const struct { gr_surface* surface; const char *name; } BITMAPS[] = {

{ &gBackgroundIcon[BACKGROUND_ICON_INSTALLING], "icon_installing" },

{ &gBackgroundIcon[BACKGROUND_ICON_ERROR], "icon_error" },

{ &gBackgroundIcon[BACKGROUND_ICON_CLOCKWORK], "icon_clockwork" },

{ &gBackgroundIcon[BACKGROUND_ICON_CID], "icon_cid" },

{ &gBackgroundIcon[BACKGROUND_ICON_FIRMWARE_INSTALLING], "icon_firmware_install" },

{ &gBackgroundIcon[BACKGROUND_ICON_FIRMWARE_ERROR], "icon_firmware_error" },

{ &gProgressBarEmpty, "progress_empty" },

{ &gProgressBarFill, "progress_fill" },

{ &gBackground, "stitch" },

{ NULL, NULL },

};

static int gCurrentIcon = 0;

static int gInstallingFrame = 0;

static enum ProgressBarType {

} gProgressBarType = PROGRESSBAR_TYPE_NONE;

// Progress bar scope of current operation

static float gProgressScopeStart = 0, gProgressScopeSize = 0, gProgress = 0;

static double gProgressScopeTime, gProgressScopeDuration;

// Set to 1 when both graphics pages are the same (except for the progress bar)

static int gPagesIdentical = 0;

// Log text overlay, displayed when a magic key is pressed

static char text[MAX_ROWS][MAX_COLS];

static int text_cols = 0, text_rows = 0;

static int text_col = 0, text_row = 0, text_top = 0;

static int show_text = 0;

static int show_text_ever = 0; // has show_text ever been 1?

static char menu[MENU_MAX_ROWS][MENU_MAX_COLS];

static int show_menu = 0;

static int menu_top = 0, menu_items = 0, menu_sel = 0;

static int menu_show_start = 0; // this is line which menu display is starting at

static int max_menu_rows;

// 添加彩虹模式

static int cur_rainbow_color = 0;

static int gRainbowMode = 0;

// Key event input queue

static pthread_mutex_t key_queue_mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t key_queue_cond = PTHREAD_COND_INITIALIZER;

static int key_queue[256], key_queue_len = 0;

static unsigned long key_last_repeat[KEY_MAX + 1], key_press_time[KEY_MAX + 1];

static volatile char key_pressed[KEY_MAX + 1];

static void update_screen_locked(void);

// 添加电量时间显示

int get_batt_stats(void);

#ifdef BOARD_TOUCH_RECOVERY

#include "../../vendor/koush/recovery/touch.c"

#endif

// Return the current time as a double (including fractions of a second).

static double now() {

struct timeval tv;

gettimeofday(&tv, NULL);

return tv.tv_sec + tv.tv_usec / 1000000.0;

}

// Draw the given frame over the installation overlay animation. The

// background is not cleared or draw with the base icon first; we

// assume that the frame already contains some other frame of the

// animation. Does nothing if no overlay animation is defined.

// Should only be called with gUpdateMutex locked.

static void draw_install_overlay_locked(int frame) {

if (gInstallationOverlay == NULL) return;

gr_surface surface = gInstallationOverlay[frame];

int iconWidth = gr_get_width(surface);

int iconHeight = gr_get_height(surface);

gr_blit(surface, 0, 0, iconWidth, iconHeight,

ui_parameters.install_overlay_offset_x,

ui_parameters.install_overlay_offset_y);

}

// Clear the screen and draw the currently selected background icon (if any).

// Should only be called with gUpdateMutex locked.

static void draw_background_locked(int icon)

{

gPagesIdentical = 0;

// gr_color(0, 0, 0, 255);

// gr_fill(0, 0, gr_fb_width(), gr_fb_height());

{

int bw = gr_get_width(gBackground);

int bh = gr_get_height(gBackground);

int bx = 0;

int by = 0;

for (by = 0; by < gr_fb_height(); by += bh) {

for (bx = 0; bx < gr_fb_width(); bx += bw) {

gr_blit(gBackground, 0, 0, bw, bh, bx, by);

}

}

}

if (icon) {

gr_surface surface = gBackgroundIcon[icon];

int iconWidth = gr_get_width(surface);

int iconHeight = gr_get_height(surface);

int iconX = (gr_fb_width() - iconWidth) / 2;

int iconY = (gr_fb_height() - iconHeight) / 2;

gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);

if (icon == BACKGROUND_ICON_INSTALLING) {

draw_install_overlay_locked(gInstallingFrame);

}

}

}

// Draw the progress bar (if any) on the screen. Does not flip pages.

// Should only be called with gUpdateMutex locked.

static void draw_progress_locked()

{

if (gCurrentIcon == BACKGROUND_ICON_INSTALLING) {

draw_install_overlay_locked(gInstallingFrame);

}

if (gProgressBarType != PROGRESSBAR_TYPE_NONE) {

int iconHeight = gr_get_height(gBackgroundIcon[BACKGROUND_ICON_INSTALLING]);

int width = gr_get_width(gProgressBarEmpty);

int height = gr_get_height(gProgressBarEmpty);

int dx = (gr_fb_width() - width)/2;

int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;

// Erase behind the progress bar (in case this was a progress-only update)

gr_color(0, 0, 0, 255);

gr_fill(dx, dy, width, height);

if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL) {

float progress = gProgressScopeStart + gProgress * gProgressScopeSize;

int pos = (int) (progress * width);

if (pos > 0) {

gr_blit(gProgressBarFill, 0, 0, pos, height, dx, dy);

}

if (pos < width-1) {

gr_blit(gProgressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);

}

}

if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE) {

static int frame = 0;

gr_blit(gProgressBarIndeterminate[frame], 0, 0, width, height, dx, dy);

frame = (frame + 1) % ui_parameters.indeterminate_frames;

}

}

}

// 添加电量时间显示

#define LEFT_ALIGN 0

#define CENTER_ALIGN 1

#define RIGHT_ALIGN 2

static void draw_text_line(int row, const char* t, int align) {

int col = 0;

if (t[0] != '\0') {

int length = strnlen(t, MENU_MAX_COLS) * CHAR_WIDTH;

switch(align)

{

case LEFT_ALIGN:

col = 1;

break;

case CENTER_ALIGN:

col = ((gr_fb_width() - length) / 2);

break;

case RIGHT_ALIGN:

col = gr_fb_width() - length - 1;

break;

}

// 添加彩虹模式

if (ui_get_rainbow_mode()) ui_rainbow_mode();

// 添加电量时间显示

gr_text(col, (row+1)*CHAR_HEIGHT-1, t);

}

}

//#define MENU_TEXT_COLOR 255, 160, 49, 255

#define MENU_TEXT_COLOR 0, 191, 255, 255

#define NORMAL_TEXT_COLOR 200, 200, 200, 255

// 添加电量时间显示

#define HEADER_TEXT_COLOR MENU_TEXT_COLOR

// Redraw everything on the screen. Does not flip pages.

// Should only be called with gUpdateMutex locked.

static void draw_screen_locked(void)

{

if (!ui_has_initialized) return;

draw_background_locked(gCurrentIcon);

draw_progress_locked();

if (show_text) {

// don't "disable" the background anymore with this...

// gr_color(0, 0, 0, 160);

// gr_fill(0, 0, gr_fb_width(), gr_fb_height());

int total_rows = gr_fb_height() / CHAR_HEIGHT;

int i = 0;

int j = 0;

int row = 0; // current row that we are drawing on

if (show_menu) {

#ifndef BOARD_TOUCH_RECOVERY

gr_color(MENU_TEXT_COLOR);

// 添加电量时间显示

int batt_level = 0;

batt_level = get_batt_stats();

if(batt_level < 20) {

gr_color(255, 0, 0, 255);

}

struct tm *current;

time_t now;

now = time(NULL) + (3600 * 8); // add 8 hours

current = localtime(&now);

char batt_text[40];

sprintf(batt_text, "[%d%% %02D:%02D]", batt_level, current->tm_hour, current->tm_min);

if (now == NULL) { // just in case

sprintf(batt_text, "[%d%%]", batt_level);

}

gr_color(MENU_TEXT_COLOR);

draw_text_line(0, batt_text, RIGHT_ALIGN);

gr_fill(0, (menu_top + menu_sel - menu_show_start) * CHAR_HEIGHT,

gr_fb_width(), (menu_top + menu_sel - menu_show_start + 1)*CHAR_HEIGHT+1);

gr_color(HEADER_TEXT_COLOR);

for (i = 0; i < menu_top; ++i) {

// 添加电量时间显示

// draw_text_line(i, menu[i]);

draw_text_line(i, menu[i], LEFT_ALIGN);

row++;

}

if (menu_items - menu_show_start + menu_top >= max_menu_rows)

j = max_menu_rows - menu_top;

else

j = menu_items - menu_show_start;

gr_color(MENU_TEXT_COLOR);

for (i = menu_show_start + menu_top; i < (menu_show_start + menu_top + j); ++i) {

if (i == menu_top + menu_sel) {

gr_color(255, 255, 255, 255);

// 添加电量时间显示

// draw_text_line(i - menu_show_start , menu[i]);

draw_text_line(i - menu_show_start , menu[i], LEFT_ALIGN);

gr_color(MENU_TEXT_COLOR);

} else {

gr_color(MENU_TEXT_COLOR);

// 添加电量时间显示

// draw_text_line(i - menu_show_start, menu[i]);

draw_text_line(i - menu_show_start, menu[i], LEFT_ALIGN);

}

row++;

if (row >= max_menu_rows)

break;

}

gr_fill(0, row*CHAR_HEIGHT+CHAR_HEIGHT/2-1,

gr_fb_width(), row*CHAR_HEIGHT+CHAR_HEIGHT/2+1);

#else

row = draw_touch_menu(menu, menu_items, menu_top, menu_sel, menu_show_start);

#endif

}

gr_color(NORMAL_TEXT_COLOR);

int cur_row = text_row;

int available_rows = total_rows - row - 1;

int start_row = row + 1;

if (available_rows < MAX_ROWS)

cur_row = (cur_row + (MAX_ROWS - available_rows)) % MAX_ROWS;

else

start_row = total_rows - MAX_ROWS;

int r;

for (r = 0; r < (available_rows < MAX_ROWS ? available_rows : MAX_ROWS); r++) {

// 添加电量时间显示

// draw_text_line(start_row + r, text[(cur_row + r) % MAX_ROWS]);

draw_text_line(start_row + r, text[(cur_row + r) % MAX_ROWS], LEFT_ALIGN);

}

}

}

// Redraw everything on the screen and flip the screen (make it visible).

// Should only be called with gUpdateMutex locked.

static void update_screen_locked(void)

{

if (!ui_has_initialized) return;

draw_screen_locked();

gr_flip();

}

// Updates only the progress bar, if possible, otherwise redraws the screen.

// Should only be called with gUpdateMutex locked.

static void update_progress_locked(void)

{

if (!ui_has_initialized) return;

if (show_text || !gPagesIdentical) {

draw_screen_locked(); // Must redraw the whole screen

gPagesIdentical = 1;

} else {

draw_progress_locked(); // Draw only the progress bar and overlays

}

gr_flip();

}

// Keeps the progress bar updated, even when the process is otherwise busy.

static void *progress_thread(void *cookie)

{

double interval = 1.0 / ui_parameters.update_fps;

for (;;) {

double start = now();

pthread_mutex_lock(&gUpdateMutex);

int redraw = 0;

// update the installation animation, if active

// skip this if we have a text overlay (too expensive to update)

if (gCurrentIcon == BACKGROUND_ICON_INSTALLING &&

ui_parameters.installing_frames > 0 &&

!show_text) {

gInstallingFrame =

(gInstallingFrame + 1) % ui_parameters.installing_frames;

redraw = 1;

}

// update the progress bar animation, if active

// skip this if we have a text overlay (too expensive to update)

if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE && !show_text) {

redraw = 1;

}

// move the progress bar forward on timed intervals, if configured

int duration = gProgressScopeDuration;

if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL && duration > 0) {

double elapsed = now() - gProgressScopeTime;

float progress = 1.0 * elapsed / duration;

if (progress > 1.0) progress = 1.0;

if (progress > gProgress) {

gProgress = progress;

redraw = 1;

}

}

if (redraw) update_progress_locked();

pthread_mutex_unlock(&gUpdateMutex);

double end = now();

// minimum of 20ms delay between frames

double delay = interval - (end-start);

if (delay < 0.02) delay = 0.02;

usleep((long)(delay * 1000000));

}

return NULL;

}

static int rel_sum = 0;

static int input_callback(int fd, short revents, void *data)

{

struct input_event ev;

int ret;

int fake_key = 0;

ret = ev_get_input(fd, revents, &ev);

if (ret)

return -1;

#ifdef BOARD_TOUCH_RECOVERY

if (touch_handle_input(fd, ev))

return 0;

#endif

if (ev.type == EV_SYN) {

return 0;

} else if (ev.type == EV_REL) {

if (ev.code == REL_Y) {

// accumulate the up or down motion reported by

// the trackball. When it exceeds a threshold

// (positive or negative), fake an up/down

// key event.

rel_sum += ev.value;

if (rel_sum > 3) {

fake_key = 1;

ev.type = EV_KEY;

ev.code = KEY_DOWN;

ev.value = 1;

rel_sum = 0;

} else if (rel_sum < -3) {

fake_key = 1;

ev.type = EV_KEY;

ev.code = KEY_UP;

ev.value = 1;

rel_sum = 0;

}

}

} else {

rel_sum = 0;

}

if (ev.type != EV_KEY || ev.code > KEY_MAX)

return 0;

if (ev.value == 2) {

boardEnableKeyRepeat = 0;

}

pthread_mutex_lock(&key_queue_mutex);

if (!fake_key) {

// our "fake" keys only report a key-down event (no

// key-up), so don't record them in the key_pressed

// table.

key_pressed[ev.code] = ev.value;

}

const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);

if (ev.value > 0 && key_queue_len < queue_max) {

key_queue[key_queue_len++] = ev.code;

if (boardEnableKeyRepeat) {

struct timeval now;

gettimeofday(&now, NULL);

key_press_time[ev.code] = (now.tv_sec * 1000) + (now.tv_usec / 1000);

key_last_repeat[ev.code] = 0;

}

pthread_cond_signal(&key_queue_cond);

}

pthread_mutex_unlock(&key_queue_mutex);

if (ev.value > 0 && device_toggle_display(key_pressed, ev.code)) {

pthread_mutex_lock(&gUpdateMutex);

show_text = !show_text;

if (show_text) show_text_ever = 1;

update_screen_locked();

pthread_mutex_unlock(&gUpdateMutex);

}

if (ev.value > 0 && device_reboot_now(key_pressed, ev.code)) {

android_reboot(ANDROID_RB_RESTART, 0, 0);

}

return 0;

}

// Reads input events, handles special hot keys, and adds to the key queue.

static void *input_thread(void *cookie)

{

for (;;) {

if (!ev_wait(-1))

ev_dispatch();

}

return NULL;

}

void ui_init(void)

{

ui_has_initialized = 1;

gr_init();

ev_init(input_callback, NULL);

#ifdef BOARD_TOUCH_RECOVERY

touch_init();

#endif

text_col = text_row = 0;

text_rows = gr_fb_height() / CHAR_HEIGHT;

max_menu_rows = text_rows - MIN_LOG_ROWS;

#ifdef BOARD_TOUCH_RECOVERY

max_menu_rows = get_max_menu_rows(max_menu_rows);

#endif

if (max_menu_rows > MENU_MAX_ROWS)

max_menu_rows = MENU_MAX_ROWS;

if (text_rows > MAX_ROWS) text_rows = MAX_ROWS;

text_top = 1;

text_cols = gr_fb_width() / CHAR_WIDTH;

if (text_cols > MAX_COLS - 1) text_cols = MAX_COLS - 1;

int i;

for (i = 0; BITMAPS[i].name != NULL; ++i) {

int result = res_create_surface(BITMAPS[i].name, BITMAPS[i].surface);

if (result < 0) {

LOGE("Missing bitmap %s\n(Code %d)\n", BITMAPS[i].name, result);

}

}

gProgressBarIndeterminate = malloc(ui_parameters.indeterminate_frames *

sizeof(gr_surface));

for (i = 0; i < ui_parameters.indeterminate_frames; ++i) {

char filename[40];

// "indeterminate01.png", "indeterminate02.png", ...

sprintf(filename, "indeterminate%02d", i+1);

int result = res_create_surface(filename, gProgressBarIndeterminate+i);

if (result < 0) {

LOGE("Missing bitmap %s\n(Code %d)\n", filename, result);

}

}

if (ui_parameters.installing_frames > 0) {

gInstallationOverlay = malloc(ui_parameters.installing_frames *

sizeof(gr_surface));

for (i = 0; i < ui_parameters.installing_frames; ++i) {

char filename[40];

// "icon_installing_overlay01.png",

// "icon_installing_overlay02.png", ...

sprintf(filename, "icon_installing_overlay%02d", i+1);

int result = res_create_surface(filename, gInstallationOverlay+i);

if (result < 0) {

LOGE("Missing bitmap %s\n(Code %d)\n", filename, result);

}

}

// Adjust the offset to account for the positioning of the

// base image on the screen.

if (gBackgroundIcon[BACKGROUND_ICON_INSTALLING] != NULL) {

gr_surface bg = gBackgroundIcon[BACKGROUND_ICON_INSTALLING];

ui_parameters.install_overlay_offset_x +=

(gr_fb_width() - gr_get_width(bg)) / 2;

ui_parameters.install_overlay_offset_y +=

(gr_fb_height() - gr_get_height(bg)) / 2;

}

} else {

gInstallationOverlay = NULL;

}

char enable_key_repeat[PROPERTY_VALUE_MAX];

property_get("ro.cwm.enable_key_repeat", enable_key_repeat, "");

if (!strcmp(enable_key_repeat, "true") || !strcmp(enable_key_repeat, "1")) {

boardEnableKeyRepeat = 1;

char key_list[PROPERTY_VALUE_MAX];

property_get("ro.cwm.repeatable_keys", key_list, "");

if (strlen(key_list) == 0) {

boardRepeatableKeys[boardNumRepeatableKeys++] = KEY_UP;

boardRepeatableKeys[boardNumRepeatableKeys++] = KEY_DOWN;

boardRepeatableKeys[boardNumRepeatableKeys++] = KEY_VOLUMEUP;

boardRepeatableKeys[boardNumRepeatableKeys++] = KEY_VOLUMEDOWN;

} else {

char *pch = strtok(key_list, ",");

while (pch != NULL) {

boardRepeatableKeys[boardNumRepeatableKeys++] = atoi(pch);

pch = strtok(NULL, ",");

}

}

}

pthread_t t;

pthread_create(&t, NULL, progress_thread, NULL);

pthread_create(&t, NULL, input_thread, NULL);

ui_print("编译作者 mandfx\n");

ui_print("支持微博 weibo.com/AnZhiDenG\n");

ui_print("编译时间 2013-11-16\n\n");

}

char *ui_copy_image(int icon, int *width, int *height, int *bpp) {

pthread_mutex_lock(&gUpdateMutex);

draw_background_locked(icon);

*width = gr_fb_width();

*height = gr_fb_height();

*bpp = sizeof(gr_pixel) * 8;

int size = *width * *height * sizeof(gr_pixel);

char *ret = malloc(size);

if (ret == NULL) {

LOGE("Can't allocate %d bytes for image\n", size);

} else {

memcpy(ret, gr_fb_data(), size);

}

pthread_mutex_unlock(&gUpdateMutex);

return ret;

}

void ui_set_background(int icon)

{

pthread_mutex_lock(&gUpdateMutex);

gCurrentIcon = icon;

update_screen_locked();

pthread_mutex_unlock(&gUpdateMutex);

}

void ui_show_indeterminate_progress()

{

pthread_mutex_lock(&gUpdateMutex);

if (gProgressBarType != PROGRESSBAR_TYPE_INDETERMINATE) {

gProgressBarType = PROGRESSBAR_TYPE_INDETERMINATE;

update_progress_locked();

}

pthread_mutex_unlock(&gUpdateMutex);

}

void ui_show_progress(float portion, int seconds)

{

pthread_mutex_lock(&gUpdateMutex);

gProgressBarType = PROGRESSBAR_TYPE_NORMAL;

gProgressScopeStart += gProgressScopeSize;

gProgressScopeSize = portion;

gProgressScopeTime = now();

gProgressScopeDuration = seconds;

gProgress = 0;

update_progress_locked();

pthread_mutex_unlock(&gUpdateMutex);

}

void ui_set_progress(float fraction)

{

pthread_mutex_lock(&gUpdateMutex);

if (fraction < 0.0) fraction = 0.0;

if (fraction > 1.0) fraction = 1.0;

if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL && fraction > gProgress) {

// Skip updates that aren't visibly different.

int width = gr_get_width(gProgressBarIndeterminate[0]);

float scale = width * gProgressScopeSize;

if ((int) (gProgress * scale) != (int) (fraction * scale)) {

gProgress = fraction;

update_progress_locked();

}

}

pthread_mutex_unlock(&gUpdateMutex);

}

void ui_reset_progress()

{

pthread_mutex_lock(&gUpdateMutex);

gProgressBarType = PROGRESSBAR_TYPE_NONE;

gProgressScopeStart = gProgressScopeSize = 0;

gProgressScopeTime = gProgressScopeDuration = 0;

gProgress = 0;

update_screen_locked();

pthread_mutex_unlock(&gUpdateMutex);

}

static long delta_milliseconds(struct timeval from, struct timeval to) {

long delta_sec = (to.tv_sec - from.tv_sec)*1000;

long delta_usec = (to.tv_usec - from.tv_usec)/1000;

return (delta_sec + delta_usec);

}

static struct timeval lastupdate = (struct timeval) {0};

static int ui_nice = 0;

static int ui_niced = 0;

void ui_set_nice(int enabled) {

ui_nice = enabled;

}

#define NICE_INTERVAL 100

int ui_was_niced() {

return ui_niced;

}

int ui_get_text_cols() {

return text_cols;

}

void ui_print(const char *fmt, ...)

{

char buf[256];

va_list ap;

va_start(ap, fmt);

vsnprintf(buf, 256, fmt, ap);

va_end(ap);

if (ui_log_stdout)

fputs(buf, stdout);

// if we are running 'ui nice' mode, we do not want to force a screen update

// for this line if not necessary.

ui_niced = 0;

if (ui_nice) {

struct timeval curtime;

gettimeofday(&curtime, NULL);

long ms = delta_milliseconds(lastupdate, curtime);

if (ms < NICE_INTERVAL && ms >= 0) {

ui_niced = 1;

return;

}

}

// This can get called before ui_init(), so be careful.

pthread_mutex_lock(&gUpdateMutex);

gettimeofday(&lastupdate, NULL);

if (text_rows > 0 && text_cols > 0) {

char *ptr;

for (ptr = buf; *ptr != '\0'; ++ptr) {

if (*ptr == '\n' || text_col >= text_cols) {

text[text_row][text_col] = '\0';

text_col = 0;

text_row = (text_row + 1) % text_rows;

if (text_row == text_top) text_top = (text_top + 1) % text_rows;

}

if (*ptr != '\n') text[text_row][text_col++] = *ptr;

}

text[text_row][text_col] = '\0';

update_screen_locked();

}

pthread_mutex_unlock(&gUpdateMutex);

}

void ui_printlogtail(int nb_lines) {

char * log_data;

char tmp[PATH_MAX];

FILE * f;

int line=0;

//don't log output to recovery.log

ui_log_stdout=0;

sprintf(tmp, "tail -n %d /tmp/recovery.log > /tmp/tail.log", nb_lines);

__system(tmp);

f = fopen("/tmp/tail.log", "rb");

if (f != NULL) {

while (line < nb_lines) {

log_data = fgets(tmp, PATH_MAX, f);

if (log_data == NULL) break;

ui_print("%s", tmp);

line++;

}

fclose(f);

}

ui_log_stdout=1;

}

#define MENU_ITEM_HEADER " - "

#define MENU_ITEM_HEADER_LENGTH strlen(MENU_ITEM_HEADER)

int ui_start_menu(char** headers, char** items, int initial_selection) {

int i;

pthread_mutex_lock(&gUpdateMutex);

if (text_rows > 0 && text_cols > 0) {

for (i = 0; i < text_rows; ++i) {

if (headers[i] == NULL) break;

strncpy(menu[i], headers[i], text_cols-1);

menu[i][text_cols-1] = '\0';

}

menu_top = i;

for (; i < MENU_MAX_ROWS; ++i) {

if (items[i-menu_top] == NULL) break;

strcpy(menu[i], MENU_ITEM_HEADER);

strncpy(menu[i] + MENU_ITEM_HEADER_LENGTH, items[i-menu_top], MENU_MAX_COLS - 1 - MENU_ITEM_HEADER_LENGTH);

menu[i][MENU_MAX_COLS-1] = '\0';

}

if (gShowBackButton && !ui_root_menu) {

strcpy(menu[i], " - +++++返回+++++");

++i;

}

menu_items = i - menu_top;

show_menu = 1;

menu_sel = menu_show_start = initial_selection;

update_screen_locked();

}

pthread_mutex_unlock(&gUpdateMutex);

if (gShowBackButton && !ui_root_menu) {

return menu_items - 1;

}

return menu_items;

}

int ui_menu_select(int sel) {

int old_sel;

pthread_mutex_lock(&gUpdateMutex);

if (show_menu > 0) {

old_sel = menu_sel;

menu_sel = sel;

if (menu_sel < 0) menu_sel = menu_items + menu_sel;

if (menu_sel >= menu_items) menu_sel = menu_sel - menu_items;

if (menu_sel < menu_show_start && menu_show_start > 0) {

menu_show_start = menu_sel;

}

if (menu_sel - menu_show_start + menu_top >= max_menu_rows) {

menu_show_start = menu_sel + menu_top - max_menu_rows + 1;

}

sel = menu_sel;

if (menu_sel != old_sel) update_screen_locked();

}

pthread_mutex_unlock(&gUpdateMutex);

return sel;

}

void ui_end_menu() {

int i;

pthread_mutex_lock(&gUpdateMutex);

if (show_menu > 0 && text_rows > 0 && text_cols > 0) {

show_menu = 0;

update_screen_locked();

}

pthread_mutex_unlock(&gUpdateMutex);

}

int ui_text_visible()

{

pthread_mutex_lock(&gUpdateMutex);

int visible = show_text;

pthread_mutex_unlock(&gUpdateMutex);

return visible;

}

int ui_text_ever_visible()

{

pthread_mutex_lock(&gUpdateMutex);

int ever_visible = show_text_ever;

pthread_mutex_unlock(&gUpdateMutex);

return ever_visible;

}

void ui_show_text(int visible)

{

pthread_mutex_lock(&gUpdateMutex);

show_text = visible;

if (show_text) show_text_ever = 1;

update_screen_locked();

pthread_mutex_unlock(&gUpdateMutex);

}

// Return true if USB is connected.

static int usb_connected() {

int fd = open("/sys/class/android_usb/android0/state", O_RDONLY);

if (fd < 0) {

printf("failed to open /sys/class/android_usb/android0/state: %s\n",

strerror(errno));

return 0;

}

char buf;

/* USB is connected if android_usb state is CONNECTED or CONFIGURED */

int connected = (read(fd, &buf, 1) == 1) && (buf == 'C');

if (close(fd) < 0) {

printf("failed to close /sys/class/android_usb/android0/state: %s\n",

strerror(errno));

}

return connected;

}

void ui_cancel_wait_key() {

pthread_mutex_lock(&key_queue_mutex);

key_queue[key_queue_len] = -2;

key_queue_len++;

pthread_cond_signal(&key_queue_cond);

pthread_mutex_unlock(&key_queue_mutex);

}

int ui_wait_key()

{

if (boardEnableKeyRepeat) return ui_wait_key_with_repeat();

pthread_mutex_lock(&key_queue_mutex);

// Time out after UI_WAIT_KEY_TIMEOUT_SEC, unless a USB cable is

// plugged in.

do {

struct timeval now;

struct timespec timeout;

gettimeofday(&now, NULL);

timeout.tv_sec = now.tv_sec;

timeout.tv_nsec = now.tv_usec * 1000;

timeout.tv_sec += UI_WAIT_KEY_TIMEOUT_SEC;

int rc = 0;

while (key_queue_len == 0 && rc != ETIMEDOUT) {

rc = pthread_cond_timedwait(&key_queue_cond, &key_queue_mutex,

&timeout);

}

} while (usb_connected() && key_queue_len == 0);

int key = -1;

if (key_queue_len > 0) {

key = key_queue[0];

memcpy(&key_queue[0], &key_queue[1], sizeof(int) * --key_queue_len);

}

pthread_mutex_unlock(&key_queue_mutex);

return key;

}

// util for ui_wait_key_with_repeat

int key_can_repeat(int key)

{

int k = 0;

for (;k < boardNumRepeatableKeys; ++k) {

if (boardRepeatableKeys[k] == key) {

break;

}

}

if (k < boardNumRepeatableKeys) return 1;

return 0;

}

int ui_wait_key_with_repeat()

{

int key = -1;

// Loop to wait for more keys.

do {

struct timeval now;

struct timespec timeout;

gettimeofday(&now, NULL);

timeout.tv_sec = now.tv_sec;

timeout.tv_nsec = now.tv_usec * 1000;

timeout.tv_sec += UI_WAIT_KEY_TIMEOUT_SEC;

int rc = 0;

pthread_mutex_lock(&key_queue_mutex);