blob: c2a439acbc484f045844b77badebd720b8946889 [file] [log] [blame]
Dees_Troy51a0e822012-09-05 15:24:24 -04001/*
Dees Troy3be70a82013-10-22 14:25:12 +00002 Copyright 2012 bigbiff/Dees_Troy TeamWin
3 This file is part of TWRP/TeamWin Recovery Project.
4
5 TWRP is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 TWRP is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with TWRP. If not, see <http://www.gnu.org/licenses/>.
17*/
Dees_Troy51a0e822012-09-05 15:24:24 -040018
19#include <linux/input.h>
20#include <pthread.h>
21#include <stdarg.h>
22#include <stdio.h>
23#include <errno.h>
24#include <stdlib.h>
25#include <string.h>
26#include <fcntl.h>
27#include <sys/reboot.h>
28#include <sys/stat.h>
29#include <sys/time.h>
30#include <sys/mman.h>
31#include <sys/types.h>
32#include <sys/ioctl.h>
33#include <sys/mount.h>
34#include <time.h>
35#include <unistd.h>
36#include <stdlib.h>
37
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050038extern "C"
39{
Dees_Troy2673cec2013-04-02 20:22:16 +000040#include "../twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040041#include <pixelflinger/pixelflinger.h>
42}
Ethan Yonkerfbb43532015-12-28 21:54:50 +010043#include "../minuitwrp/minui.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040044
45#include "rapidxml.hpp"
46#include "objects.hpp"
47#include "../data.hpp"
48#include "../variables.h"
Dees_Troy5bf43922012-09-07 16:07:55 -040049#include "../partitions.hpp"
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050050#include "../twrp-functions.hpp"
Ethan Yonker03a42f62014-08-08 11:03:51 -050051#include "../openrecoveryscript.hpp"
52#include "../orscmd/orscmd.h"
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050053#include "blanktimer.hpp"
Ethan Yonker04536952015-01-27 08:41:28 -060054#include "../tw_atomic.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040055
Vojtech Boceke5ffcd12014-02-06 21:17:32 +010056// Enable to print render time of each frame to the log file
57//#define PRINT_RENDER_TIME 1
58
that9fa51532015-01-29 02:04:47 +010059#ifdef _EVENT_LOGGING
thatc5837f32015-02-01 01:59:43 +010060#define LOGEVENT(...) LOGERR(__VA_ARGS__)
that9fa51532015-01-29 02:04:47 +010061#else
62#define LOGEVENT(...) do {} while (0)
63#endif
64
Dees_Troy51a0e822012-09-05 15:24:24 -040065using namespace rapidxml;
66
67// Global values
Dees_Troy51a0e822012-09-05 15:24:24 -040068static int gGuiInitialized = 0;
Ethan Yonker04536952015-01-27 08:41:28 -060069static TWAtomicInt gForceRender;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050070blanktimer blankTimer;
Ethan Yonkerfd0439e2015-01-14 11:08:13 -060071int ors_read_fd = -1;
that10ae24f2015-12-26 20:53:51 +010072static FILE* orsout = NULL;
Ethan Yonker63e414f2015-02-06 15:44:39 -060073static float scale_theme_w = 1;
74static float scale_theme_h = 1;
Dees_Troy51a0e822012-09-05 15:24:24 -040075
76// Needed by pages.cpp too
77int gGuiRunning = 0;
78
that1964d192016-01-07 00:41:03 +010079int g_pty_fd = -1; // set by terminal on init
80void terminal_pty_read();
81
Dees_Troy51a0e822012-09-05 15:24:24 -040082static int gRecorder = -1;
83
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020084extern "C" void gr_write_frame_to_file(int fd);
Dees_Troy51a0e822012-09-05 15:24:24 -040085
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020086void flip(void)
Dees_Troy51a0e822012-09-05 15:24:24 -040087{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020088 if (gRecorder != -1)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050089 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020090 timespec time;
91 clock_gettime(CLOCK_MONOTONIC, &time);
92 write(gRecorder, &time, sizeof(timespec));
93 gr_write_frame_to_file(gRecorder);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050094 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020095 gr_flip();
Dees_Troy51a0e822012-09-05 15:24:24 -040096}
97
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020098void rapidxml::parse_error_handler(const char *what, void *where)
Dees_Troy51a0e822012-09-05 15:24:24 -040099{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200100 fprintf(stderr, "Parser error: %s\n", what);
101 fprintf(stderr, " Start of string: %s\n",(char *) where);
102 LOGERR("Error parsing XML file.\n");
103 //abort();
Dees_Troy51a0e822012-09-05 15:24:24 -0400104}
105
that9fa51532015-01-29 02:04:47 +0100106class InputHandler
Dees_Troy51a0e822012-09-05 15:24:24 -0400107{
that9fa51532015-01-29 02:04:47 +0100108public:
109 void init()
thatfb759d42015-01-11 12:16:53 +0100110 {
that9fa51532015-01-29 02:04:47 +0100111 // these might be read from DataManager in the future
112 touch_hold_ms = 500;
113 touch_repeat_ms = 100;
114 key_hold_ms = 500;
115 key_repeat_ms = 100;
116 touch_status = TS_NONE;
117 key_status = KS_NONE;
118 state = AS_NO_ACTION;
119 x = y = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400120
that9fa51532015-01-29 02:04:47 +0100121#ifndef TW_NO_SCREEN_TIMEOUT
122 {
123 string seconds;
124 DataManager::GetValue("tw_screen_timeout_secs", seconds);
125 blankTimer.setTime(atoi(seconds.c_str()));
126 blankTimer.resetTimerAndUnblank();
Ethan Yonkere13fa632015-01-27 11:30:03 -0600127 }
that9fa51532015-01-29 02:04:47 +0100128#else
129 LOGINFO("Skipping screen timeout: TW_NO_SCREEN_TIMEOUT is set\n");
130#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600131 }
132
thatc5837f32015-02-01 01:59:43 +0100133 // process input events. returns true if any event was received.
thatde72b6d2015-02-08 08:55:00 +0100134 bool processInput(int timeout_ms);
thatc5837f32015-02-01 01:59:43 +0100135
that9fa51532015-01-29 02:04:47 +0100136 void handleDrag();
137
138private:
139 // timeouts for touch/key hold and repeat
140 int touch_hold_ms;
141 int touch_repeat_ms;
142 int key_hold_ms;
143 int key_repeat_ms;
144
145 enum touch_status_enum {
146 TS_NONE = 0,
147 TS_TOUCH_AND_HOLD = 1,
148 TS_TOUCH_REPEAT = 2,
149 };
150
151 enum key_status_enum {
152 KS_NONE = 0,
153 KS_KEY_PRESSED = 1,
154 KS_KEY_REPEAT = 2,
155 };
156
157 enum action_state_enum {
158 AS_IN_ACTION_AREA = 0, // we've touched a spot with an action
159 AS_NO_ACTION = 1, // we've touched in an empty area (no action) and ignore remaining events until touch release
160 };
161 touch_status_enum touch_status;
162 key_status_enum key_status;
163 action_state_enum state;
164 int x, y; // x and y coordinates of last touch
165 struct timeval touchStart; // used to track time for long press / key repeat
166
167 void processHoldAndRepeat();
168 void process_EV_REL(input_event& ev);
169 void process_EV_ABS(input_event& ev);
170 void process_EV_KEY(input_event& ev);
171
172 void doTouchStart();
173};
174
175InputHandler input_handler;
176
177
thatde72b6d2015-02-08 08:55:00 +0100178bool InputHandler::processInput(int timeout_ms)
that9fa51532015-01-29 02:04:47 +0100179{
180 input_event ev;
thatde72b6d2015-02-08 08:55:00 +0100181 int ret = ev_get(&ev, timeout_ms);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600182
183 if (ret < 0)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500184 {
Ethan Yonkere13fa632015-01-27 11:30:03 -0600185 // This path means that we did not get any new touch data, but
186 // we do not get new touch data if you press and hold on either
187 // the screen or on a keyboard key or mouse button
that9fa51532015-01-29 02:04:47 +0100188 if (touch_status || key_status)
189 processHoldAndRepeat();
thatc5837f32015-02-01 01:59:43 +0100190 return (ret != -2); // -2 means no more events in the queue
Ethan Yonkere13fa632015-01-27 11:30:03 -0600191 }
that9fa51532015-01-29 02:04:47 +0100192
193 switch (ev.type)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600194 {
that9fa51532015-01-29 02:04:47 +0100195 case EV_ABS:
196 process_EV_ABS(ev);
197 break;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600198
that9fa51532015-01-29 02:04:47 +0100199 case EV_REL:
200 process_EV_REL(ev);
201 break;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600202
that9fa51532015-01-29 02:04:47 +0100203 case EV_KEY:
204 process_EV_KEY(ev);
205 break;
206 }
thatc5837f32015-02-01 01:59:43 +0100207
208 blankTimer.resetTimerAndUnblank();
209 return true; // we got an event, so there might be more in the queue
that9fa51532015-01-29 02:04:47 +0100210}
211
212void InputHandler::processHoldAndRepeat()
213{
214 HardwareKeyboard *kb = PageManager::GetHardwareKeyboard();
215
216 // touch and key repeat section
217 struct timeval curTime;
218 gettimeofday(&curTime, NULL);
219 long seconds = curTime.tv_sec - touchStart.tv_sec;
220 long useconds = curTime.tv_usec - touchStart.tv_usec;
221 long mtime = ((seconds) * 1000 + useconds / 1000.0) + 0.5;
222
223 if (touch_status == TS_TOUCH_AND_HOLD && mtime > touch_hold_ms)
224 {
225 touch_status = TS_TOUCH_REPEAT;
226 gettimeofday(&touchStart, NULL);
227 LOGEVENT("TOUCH_HOLD: %d,%d\n", x, y);
228 PageManager::NotifyTouch(TOUCH_HOLD, x, y);
that9fa51532015-01-29 02:04:47 +0100229 }
230 else if (touch_status == TS_TOUCH_REPEAT && mtime > touch_repeat_ms)
231 {
232 LOGEVENT("TOUCH_REPEAT: %d,%d\n", x, y);
233 gettimeofday(&touchStart, NULL);
234 PageManager::NotifyTouch(TOUCH_REPEAT, x, y);
that9fa51532015-01-29 02:04:47 +0100235 }
236 else if (key_status == KS_KEY_PRESSED && mtime > key_hold_ms)
237 {
238 LOGEVENT("KEY_HOLD: %d,%d\n", x, y);
239 gettimeofday(&touchStart, NULL);
240 key_status = KS_KEY_REPEAT;
241 kb->KeyRepeat();
that9fa51532015-01-29 02:04:47 +0100242 }
243 else if (key_status == KS_KEY_REPEAT && mtime > key_repeat_ms)
244 {
245 LOGEVENT("KEY_REPEAT: %d,%d\n", x, y);
246 gettimeofday(&touchStart, NULL);
247 kb->KeyRepeat();
that9fa51532015-01-29 02:04:47 +0100248 }
249}
250
251void InputHandler::doTouchStart()
252{
253 LOGEVENT("TOUCH_START: %d,%d\n", x, y);
254 if (PageManager::NotifyTouch(TOUCH_START, x, y) > 0)
255 state = AS_NO_ACTION;
256 else
257 state = AS_IN_ACTION_AREA;
258 touch_status = TS_TOUCH_AND_HOLD;
259 gettimeofday(&touchStart, NULL);
that9fa51532015-01-29 02:04:47 +0100260}
261
262void InputHandler::process_EV_ABS(input_event& ev)
263{
264 x = ev.value >> 16;
265 y = ev.value & 0xFFFF;
266
267 if (ev.code == 0)
268 {
Ethan Yonker30fa3352015-03-09 13:57:21 -0500269#ifndef TW_USE_KEY_CODE_TOUCH_SYNC
that9fa51532015-01-29 02:04:47 +0100270 if (state == AS_IN_ACTION_AREA)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500271 {
that9fa51532015-01-29 02:04:47 +0100272 LOGEVENT("TOUCH_RELEASE: %d,%d\n", x, y);
273 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
that9fa51532015-01-29 02:04:47 +0100274 }
275 touch_status = TS_NONE;
Ethan Yonker30fa3352015-03-09 13:57:21 -0500276#endif
that9fa51532015-01-29 02:04:47 +0100277 }
278 else
279 {
280 if (!touch_status)
281 {
Ethan Yonker30fa3352015-03-09 13:57:21 -0500282#ifndef TW_USE_KEY_CODE_TOUCH_SYNC
that9fa51532015-01-29 02:04:47 +0100283 doTouchStart();
Ethan Yonker30fa3352015-03-09 13:57:21 -0500284#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600285 }
286 else
287 {
that9fa51532015-01-29 02:04:47 +0100288 if (state == AS_IN_ACTION_AREA)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600289 {
that9fa51532015-01-29 02:04:47 +0100290 LOGEVENT("TOUCH_DRAG: %d,%d\n", x, y);
Dees_Troy51a0e822012-09-05 15:24:24 -0400291 }
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500292 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500293 }
that9fa51532015-01-29 02:04:47 +0100294}
295
296void InputHandler::process_EV_KEY(input_event& ev)
297{
298 HardwareKeyboard *kb = PageManager::GetHardwareKeyboard();
299
300 // Handle key-press here
301 LOGEVENT("TOUCH_KEY: %d\n", ev.code);
302 // Left mouse button is treated as a touch
303 if(ev.code == BTN_LEFT)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600304 {
that9fa51532015-01-29 02:04:47 +0100305 MouseCursor *cursor = PageManager::GetMouseCursor();
306 if(ev.value == 1)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600307 {
that9fa51532015-01-29 02:04:47 +0100308 cursor->GetPos(x, y);
309 doTouchStart();
310 }
311 else if(touch_status)
312 {
313 // Left mouse button was previously pressed and now is
314 // being released so send a TOUCH_RELEASE
315 if (state == AS_IN_ACTION_AREA)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600316 {
317 cursor->GetPos(x, y);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600318
that9fa51532015-01-29 02:04:47 +0100319 LOGEVENT("Mouse TOUCH_RELEASE: %d,%d\n", x, y);
320 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600321 }
that9fa51532015-01-29 02:04:47 +0100322 touch_status = TS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600323 }
that9fa51532015-01-29 02:04:47 +0100324 }
325 // side mouse button, often used for "back" function
326 else if(ev.code == BTN_SIDE)
327 {
328 if(ev.value == 1)
329 kb->KeyDown(KEY_BACK);
330 else
331 kb->KeyUp(KEY_BACK);
332 } else if (ev.value != 0) {
333 // This is a key press
Ethan Yonker30fa3352015-03-09 13:57:21 -0500334#ifdef TW_USE_KEY_CODE_TOUCH_SYNC
335 if (ev.code == TW_USE_KEY_CODE_TOUCH_SYNC) {
336 LOGEVENT("key code %i key press == touch start %i %i\n", TW_USE_KEY_CODE_TOUCH_SYNC, x, y);
337 doTouchStart();
338 return;
339 }
340#endif
that9fa51532015-01-29 02:04:47 +0100341 if (kb->KeyDown(ev.code)) {
342 // Key repeat is enabled for this key
343 key_status = KS_KEY_PRESSED;
344 touch_status = TS_NONE;
345 gettimeofday(&touchStart, NULL);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600346 } else {
Ethan Yonkere13fa632015-01-27 11:30:03 -0600347 key_status = KS_NONE;
348 touch_status = TS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600349 }
that9fa51532015-01-29 02:04:47 +0100350 } else {
351 // This is a key release
352 kb->KeyUp(ev.code);
353 key_status = KS_NONE;
354 touch_status = TS_NONE;
Ethan Yonker30fa3352015-03-09 13:57:21 -0500355#ifdef TW_USE_KEY_CODE_TOUCH_SYNC
356 if (ev.code == TW_USE_KEY_CODE_TOUCH_SYNC) {
357 LOGEVENT("key code %i key release == touch release %i %i\n", TW_USE_KEY_CODE_TOUCH_SYNC, x, y);
358 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
359 }
360#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600361 }
that9fa51532015-01-29 02:04:47 +0100362}
Ethan Yonkere13fa632015-01-27 11:30:03 -0600363
that9fa51532015-01-29 02:04:47 +0100364void InputHandler::process_EV_REL(input_event& ev)
365{
366 // Mouse movement
367 MouseCursor *cursor = PageManager::GetMouseCursor();
368 LOGEVENT("EV_REL %d %d\n", ev.code, ev.value);
369 if(ev.code == REL_X)
370 cursor->Move(ev.value, 0);
371 else if(ev.code == REL_Y)
372 cursor->Move(0, ev.value);
373
374 if(touch_status) {
375 cursor->GetPos(x, y);
376 LOGEVENT("Mouse TOUCH_DRAG: %d, %d\n", x, y);
377 key_status = KS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600378 }
that9fa51532015-01-29 02:04:47 +0100379}
380
381void InputHandler::handleDrag()
382{
383 // This allows us to only send one NotifyTouch event per render
384 // cycle to reduce overhead and perceived input latency.
385 static int prevx = 0, prevy = 0; // these track where the last drag notice was so that we don't send duplicate drag notices
386 if (touch_status && (x != prevx || y != prevy)) {
387 prevx = x;
388 prevy = y;
389 if (PageManager::NotifyTouch(TOUCH_DRAG, x, y) > 0)
390 state = AS_NO_ACTION;
391 else
392 state = AS_IN_ACTION_AREA;
393 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400394}
395
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600396static void setup_ors_command()
Ethan Yonker03a42f62014-08-08 11:03:51 -0500397{
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600398 ors_read_fd = -1;
Ethan Yonker03a42f62014-08-08 11:03:51 -0500399
400 unlink(ORS_INPUT_FILE);
401 if (mkfifo(ORS_INPUT_FILE, 06660) != 0) {
402 LOGINFO("Unable to mkfifo %s\n", ORS_INPUT_FILE);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600403 return;
Ethan Yonker03a42f62014-08-08 11:03:51 -0500404 }
405 unlink(ORS_OUTPUT_FILE);
406 if (mkfifo(ORS_OUTPUT_FILE, 06666) != 0) {
407 LOGINFO("Unable to mkfifo %s\n", ORS_OUTPUT_FILE);
408 unlink(ORS_INPUT_FILE);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600409 return;
Ethan Yonker03a42f62014-08-08 11:03:51 -0500410 }
411
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600412 ors_read_fd = open(ORS_INPUT_FILE, O_RDONLY | O_NONBLOCK);
413 if (ors_read_fd < 0) {
Ethan Yonker03a42f62014-08-08 11:03:51 -0500414 LOGINFO("Unable to open %s\n", ORS_INPUT_FILE);
415 unlink(ORS_INPUT_FILE);
416 unlink(ORS_OUTPUT_FILE);
Ethan Yonker03a42f62014-08-08 11:03:51 -0500417 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600418}
Ethan Yonker03a42f62014-08-08 11:03:51 -0500419
that10ae24f2015-12-26 20:53:51 +0100420// callback called after a CLI command was executed
421static void ors_command_done()
422{
423 gui_set_FILE(NULL);
424 fclose(orsout);
425 orsout = NULL;
426
427 if (DataManager::GetIntValue("tw_page_done") == 0) {
428 // The select function will return ready to read and the
429 // read function will return errno 19 no such device unless
430 // we set everything up all over again.
431 close(ors_read_fd);
432 setup_ors_command();
433 }
434}
435
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600436static void ors_command_read()
437{
that10ae24f2015-12-26 20:53:51 +0100438 char command[1024];
439 int read_ret = read(ors_read_fd, &command, sizeof(command));
Ethan Yonker03a42f62014-08-08 11:03:51 -0500440
that10ae24f2015-12-26 20:53:51 +0100441 if (read_ret > 0) {
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600442 command[1022] = '\n';
443 command[1023] = '\0';
444 LOGINFO("Command '%s' received\n", command);
445 orsout = fopen(ORS_OUTPUT_FILE, "w");
446 if (!orsout) {
447 close(ors_read_fd);
448 ors_read_fd = -1;
449 LOGINFO("Unable to fopen %s\n", ORS_OUTPUT_FILE);
450 unlink(ORS_INPUT_FILE);
451 unlink(ORS_OUTPUT_FILE);
452 return;
453 }
454 if (DataManager::GetIntValue("tw_busy") != 0) {
that10ae24f2015-12-26 20:53:51 +0100455 fputs("Failed, operation in progress\n", orsout);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600456 LOGINFO("Command cannot be performed, operation in progress.\n");
that10ae24f2015-12-26 20:53:51 +0100457 fclose(orsout);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600458 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500459 if (strlen(command) == 11 && strncmp(command, "dumpstrings", 11) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500460 gui_set_FILE(orsout);
461 PageManager::GetResources()->DumpStrings();
that10ae24f2015-12-26 20:53:51 +0100462 ors_command_done();
463 } else {
464 // mirror output messages
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600465 gui_set_FILE(orsout);
that10ae24f2015-12-26 20:53:51 +0100466 // close orsout and restart listener after command is done
467 OpenRecoveryScript::Call_After_CLI_Command(ors_command_done);
468 // run the command in a threaded action...
469 DataManager::SetValue("tw_action", "twcmd");
470 DataManager::SetValue("tw_action_param", command);
471 // ...and switch back to the current page when finished
472 std::string currentPage = PageManager::GetCurrentPage();
473 DataManager::SetValue("tw_has_action2", "1");
474 DataManager::SetValue("tw_action2", "page");
475 DataManager::SetValue("tw_action2_param", currentPage);
476 DataManager::SetValue("tw_action_text1", gui_lookup("running_recovery_commands", "Running Recovery Commands"));
477 DataManager::SetValue("tw_action_text2", "");
478 gui_changePage("singleaction_page");
479 // now immediately return to the GUI main loop (the action runs in the background thread)
480 // put all things that need to be done after the command is finished into ors_command_done, not here
Ethan Yonker03a42f62014-08-08 11:03:51 -0500481 }
Ethan Yonker03a42f62014-08-08 11:03:51 -0500482 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600483 } else {
484 LOGINFO("ORS command line read returned an error: %i, %i, %s\n", read_ret, errno, strerror(errno));
Ethan Yonker03a42f62014-08-08 11:03:51 -0500485 }
Ethan Yonker03a42f62014-08-08 11:03:51 -0500486}
487
that10ae24f2015-12-26 20:53:51 +0100488// Get and dispatch input events until it's time to draw the next frame
Dees_Troy51a0e822012-09-05 15:24:24 -0400489// This special function will return immediately the first time, but then
490// always returns 1/30th of a second (or immediately if called later) from
491// the last time it was called
thatde72b6d2015-02-08 08:55:00 +0100492static void loopTimer(int input_timeout_ms)
Dees_Troy51a0e822012-09-05 15:24:24 -0400493{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200494 static timespec lastCall;
495 static int initialized = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400496
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200497 if (!initialized)
Dees_Troyc8b199c2012-09-24 11:55:07 -0400498 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200499 clock_gettime(CLOCK_MONOTONIC, &lastCall);
500 initialized = 1;
501 return;
Dees_Troyc8b199c2012-09-24 11:55:07 -0400502 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400503
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200504 do
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500505 {
thatde72b6d2015-02-08 08:55:00 +0100506 bool got_event = input_handler.processInput(input_timeout_ms); // get inputs but don't send drag notices
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200507 timespec curTime;
508 clock_gettime(CLOCK_MONOTONIC, &curTime);
Dees_Troy51a0e822012-09-05 15:24:24 -0400509
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200510 timespec diff = TWFunc::timespec_diff(lastCall, curTime);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500511
thatc5837f32015-02-01 01:59:43 +0100512 // This is really 2 or 30 times per second
513 // As long as we get events, increase the timeout so we can catch up with input
514 long timeout = got_event ? 500000000 : 33333333;
515
516 if (diff.tv_sec || diff.tv_nsec > timeout)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500517 {
thatc5837f32015-02-01 01:59:43 +0100518 // int32_t input_time = TWFunc::timespec_diff_ms(lastCall, curTime);
519 // LOGINFO("loopTimer(): %u ms, count: %u\n", input_time, count);
520
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200521 lastCall = curTime;
that9fa51532015-01-29 02:04:47 +0100522 input_handler.handleDrag(); // send only drag notices if needed
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200523 return;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500524 }
525
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200526 // We need to sleep some period time microseconds
Ethan Yonkere13fa632015-01-27 11:30:03 -0600527 //unsigned int sleepTime = 33333 -(diff.tv_nsec / 1000);
528 //usleep(sleepTime); // removed so we can scan for input
thatde72b6d2015-02-08 08:55:00 +0100529 input_timeout_ms = 0;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200530 } while (1);
Dees_Troy51a0e822012-09-05 15:24:24 -0400531}
532
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600533static int runPages(const char *page_name, const int stop_on_page_done)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500534{
Ethan Yonker3f15be42015-02-09 09:39:47 -0600535 DataManager::SetValue("tw_page_done", 0);
536 DataManager::SetValue("tw_gui_done", 0);
537
Ethan Yonkerafde0982016-01-23 08:55:35 -0600538 if (page_name) {
539 PageManager::SetStartPage(page_name);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600540 gui_changePage(page_name);
Ethan Yonkerafde0982016-01-23 08:55:35 -0600541 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600542
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200543 gGuiRunning = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500544
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200545 DataManager::SetValue("tw_loaded", 1);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500546
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600547 struct timeval timeout;
548 fd_set fdset;
549 int has_data = 0;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100550
thatde72b6d2015-02-08 08:55:00 +0100551 int input_timeout_ms = 0;
552 int idle_frames = 0;
553
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200554 for (;;)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500555 {
thatde72b6d2015-02-08 08:55:00 +0100556 loopTimer(input_timeout_ms);
that1964d192016-01-07 00:41:03 +0100557 if (g_pty_fd > 0) {
558 // TODO: this is not nice, we should have one central select for input, pty, and ors
559 FD_ZERO(&fdset);
560 FD_SET(g_pty_fd, &fdset);
561 timeout.tv_sec = 0;
562 timeout.tv_usec = 1;
563 has_data = select(g_pty_fd+1, &fdset, NULL, NULL, &timeout);
564 if (has_data > 0) {
565 terminal_pty_read();
566 }
567 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600568#ifndef TW_OEM_BUILD
that10ae24f2015-12-26 20:53:51 +0100569 if (ors_read_fd > 0 && !orsout) { // orsout is non-NULL if a command is still running
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600570 FD_ZERO(&fdset);
571 FD_SET(ors_read_fd, &fdset);
572 timeout.tv_sec = 0;
573 timeout.tv_usec = 1;
574 has_data = select(ors_read_fd+1, &fdset, NULL, NULL, &timeout);
575 if (has_data > 0) {
576 ors_command_read();
577 }
578 }
579#endif
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500580
Ethan Yonker04536952015-01-27 08:41:28 -0600581 if (!gForceRender.get_value())
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500582 {
thatde72b6d2015-02-08 08:55:00 +0100583 int ret = PageManager::Update();
584 if (ret == 0)
585 ++idle_frames;
Ethan Yonkere0f1f3b2015-10-27 09:49:01 -0500586 else if (ret == -2)
587 break; // Theme reload failure
thatde72b6d2015-02-08 08:55:00 +0100588 else
589 idle_frames = 0;
590 // due to possible animation objects, we need to delay activating the input timeout
591 input_timeout_ms = idle_frames > 15 ? 1000 : 0;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100592
593#ifndef PRINT_RENDER_TIME
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200594 if (ret > 1)
595 PageManager::Render();
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500596
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200597 if (ret > 0)
598 flip();
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100599#else
600 if (ret > 1)
601 {
that9fa51532015-01-29 02:04:47 +0100602 timespec start, end;
603 int32_t render_t, flip_t;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100604 clock_gettime(CLOCK_MONOTONIC, &start);
605 PageManager::Render();
606 clock_gettime(CLOCK_MONOTONIC, &end);
607 render_t = TWFunc::timespec_diff_ms(start, end);
608
609 flip();
610 clock_gettime(CLOCK_MONOTONIC, &start);
611 flip_t = TWFunc::timespec_diff_ms(end, start);
612
613 LOGINFO("Render(): %u ms, flip(): %u ms, total: %u ms\n", render_t, flip_t, render_t+flip_t);
614 }
thatde72b6d2015-02-08 08:55:00 +0100615 else if (ret > 0)
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100616 flip();
617#endif
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500618 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200619 else
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500620 {
Ethan Yonker04536952015-01-27 08:41:28 -0600621 gForceRender.set_value(0);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200622 PageManager::Render();
623 flip();
thatde72b6d2015-02-08 08:55:00 +0100624 input_timeout_ms = 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500625 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200626
thatfb759d42015-01-11 12:16:53 +0100627 blankTimer.checkForTimeout();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600628 if (stop_on_page_done && DataManager::GetIntValue("tw_page_done") != 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200629 {
630 gui_changePage("main");
Dees_Troy6ef66352013-02-21 08:26:57 -0600631 break;
632 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600633 if (DataManager::GetIntValue("tw_gui_done") != 0)
634 break;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500635 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600636 if (ors_read_fd > 0)
637 close(ors_read_fd);
638 ors_read_fd = -1;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200639 gGuiRunning = 0;
640 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500641}
642
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200643int gui_forceRender(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500644{
Ethan Yonker04536952015-01-27 08:41:28 -0600645 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200646 return 0;
647}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500648
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200649int gui_changePage(std::string newPage)
650{
651 LOGINFO("Set page: '%s'\n", newPage.c_str());
652 PageManager::ChangePage(newPage);
Ethan Yonker04536952015-01-27 08:41:28 -0600653 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200654 return 0;
655}
656
657int gui_changeOverlay(std::string overlay)
658{
Ethan Yonker1c273312015-03-16 12:18:56 -0500659 LOGINFO("Set overlay: '%s'\n", overlay.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200660 PageManager::ChangeOverlay(overlay);
Ethan Yonker04536952015-01-27 08:41:28 -0600661 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200662 return 0;
663}
664
thatb2e8f672015-03-05 20:25:39 +0100665std::string gui_parse_text(std::string str)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200666{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200667 // This function parses text for DataManager values encompassed by %value% in the XML
thatb2e8f672015-03-05 20:25:39 +0100668 // and string resources (%@resource_name%)
Ethan Yonker74db1572015-10-28 12:44:49 -0500669 size_t pos = 0, next, end;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200670
671 while (1)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500672 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500673 next = str.find("{@", pos);
674 if (next == std::string::npos)
675 break;
676
677 end = str.find('}', next + 1);
678 if (end == std::string::npos)
679 break;
680
681 std::string var = str.substr(next + 2, (end - next) - 2);
682 str.erase(next, (end - next) + 1);
683
684 size_t default_loc = var.find('=', 0);
685 std::string lookup;
686 if (default_loc == std::string::npos) {
687 str.insert(next, PageManager::GetResources()->FindString(var));
688 } else {
689 lookup = var.substr(0, default_loc);
690 std::string default_string = var.substr(default_loc + 1, var.size() - default_loc - 1);
691 str.insert(next, PageManager::GetResources()->FindString(lookup, default_string));
692 }
693 }
694 pos = 0;
695 while (1)
696 {
697 next = str.find('%', pos);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200698 if (next == std::string::npos)
699 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500700
Ethan Yonker74db1572015-10-28 12:44:49 -0500701 end = str.find('%', next + 1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200702 if (end == std::string::npos)
703 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500704
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200705 // We have a block of data
thatb2e8f672015-03-05 20:25:39 +0100706 std::string var = str.substr(next + 1, (end - next) - 1);
707 str.erase(next, (end - next) + 1);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500708
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200709 if (next + 1 == end)
710 str.insert(next, 1, '%');
711 else
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500712 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200713 std::string value;
thatb2e8f672015-03-05 20:25:39 +0100714 if (var.size() > 0 && var[0] == '@') {
715 // this is a string resource ("%@string_name%")
716 value = PageManager::GetResources()->FindString(var.substr(1));
717 str.insert(next, value);
718 }
719 else if (DataManager::GetValue(var, value) == 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200720 str.insert(next, value);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500721 }
722
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200723 pos = next + 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500724 }
725}
726
Ethan Yonker74db1572015-10-28 12:44:49 -0500727std::string gui_lookup(const std::string& resource_name, const std::string& default_value) {
728 return PageManager::GetResources()->FindString(resource_name, default_value);
729}
730
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200731extern "C" int gui_init(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500732{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200733 gr_init();
Matt Mowerb26c1162016-02-03 21:05:57 -0600734 TWFunc::Set_Brightness(DataManager::GetStrValue("tw_brightness"));
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500735
that235c6482016-01-24 21:59:00 +0100736 // load and show splash screen
737 if (PageManager::LoadPackage("splash", TWRES "splash.xml", "splash")) {
738 LOGERR("Failed to load splash screen XML.\n");
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500739 }
that235c6482016-01-24 21:59:00 +0100740 else {
741 PageManager::SelectPackage("splash");
742 PageManager::Render();
743 flip();
744 PageManager::ReleasePackage("splash");
Ethan Yonker63e414f2015-02-06 15:44:39 -0600745 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500746
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200747 ev_init();
748 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500749}
750
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200751extern "C" int gui_loadResources(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400752{
Ethan Yonker83e82572014-04-04 10:59:28 -0500753#ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200754 int check = 0;
755 DataManager::GetValue(TW_IS_ENCRYPTED, check);
Dees Troy3454ade2015-01-20 19:21:04 +0000756
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200757 if (check)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500758 {
Dees Troy3454ade2015-01-20 19:21:04 +0000759 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "decrypt"))
Dees_Troy5bf43922012-09-07 16:07:55 -0400760 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500761 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200762 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400763 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200764 else
765 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500766 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400767
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200768 if (check == 0 && PageManager::LoadPackage("TWRP", "/script/ui.xml", "main"))
769 {
770 std::string theme_path;
771
772 theme_path = DataManager::GetSettingsStoragePath();
773 if (!PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400774 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200775 int retry_count = 5;
776 while (retry_count > 0 && !PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400777 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200778 usleep(500000);
779 retry_count--;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500780 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200781
Ethan Yonker74db1572015-10-28 12:44:49 -0500782 if (!PartitionManager.Mount_Settings_Storage(true))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500783 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500784 LOGINFO("Unable to mount %s during GUI startup.\n", theme_path.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200785 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500786 }
787 }
788
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200789 theme_path += "/TWRP/theme/ui.zip";
790 if (check || PageManager::LoadPackage("TWRP", theme_path, "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500791 {
Ethan Yonker83e82572014-04-04 10:59:28 -0500792#endif // ifndef TW_OEM_BUILD
Dees Troy3454ade2015-01-20 19:21:04 +0000793 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500794 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500795 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200796 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400797 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500798#ifndef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -0400799 }
800 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500801#endif // ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200802 // Set the default package
803 PageManager::SelectPackage("TWRP");
Dees_Troy51a0e822012-09-05 15:24:24 -0400804
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200805 gGuiInitialized = 1;
806 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400807
808error:
Ethan Yonker83e82572014-04-04 10:59:28 -0500809 LOGERR("An internal error has occurred: unable to load theme.\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200810 gGuiInitialized = 0;
811 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400812}
813
Ethan Yonkercf50da52015-01-12 21:59:07 -0600814extern "C" int gui_loadCustomResources(void)
815{
816#ifndef TW_OEM_BUILD
817 if (!PartitionManager.Mount_Settings_Storage(false)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500818 LOGINFO("Unable to mount settings storage during GUI startup.\n");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600819 return -1;
820 }
821
822 std::string theme_path = DataManager::GetSettingsStoragePath();
823 theme_path += "/TWRP/theme/ui.zip";
824 // Check for a custom theme
825 if (TWFunc::Path_Exists(theme_path)) {
826 // There is a custom theme, try to load it
827 if (PageManager::ReloadPackage("TWRP", theme_path)) {
828 // Custom theme failed to load, try to load stock theme
Dees Troy3454ade2015-01-20 19:21:04 +0000829 if (PageManager::ReloadPackage("TWRP", TWRES "ui.xml")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500830 gui_err("base_pkg_err=Failed to load base packages.");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600831 goto error;
832 }
833 }
834 }
835 // Set the default package
836 PageManager::SelectPackage("TWRP");
837#endif
838 return 0;
839
840error:
841 LOGERR("An internal error has occurred: unable to load theme.\n");
842 gGuiInitialized = 0;
843 return -1;
844}
845
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200846extern "C" int gui_start(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400847{
Ethan Yonkerafde0982016-01-23 08:55:35 -0600848 return gui_startPage("main", 1, 0);
Dees_Troy51a0e822012-09-05 15:24:24 -0400849}
850
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600851extern "C" int gui_startPage(const char *page_name, const int allow_commands, int stop_on_page_done)
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000852{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200853 if (!gGuiInitialized)
854 return -1;
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000855
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200856 // Set the default package
857 PageManager::SelectPackage("TWRP");
858
that9fa51532015-01-29 02:04:47 +0100859 input_handler.init();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600860#ifndef TW_OEM_BUILD
861 if (allow_commands)
862 {
863 if (ors_read_fd < 0)
864 setup_ors_command();
865 } else {
866 if (ors_read_fd >= 0) {
867 close(ors_read_fd);
868 ors_read_fd = -1;
869 }
870 }
871#endif
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600872 return runPages(page_name, stop_on_page_done);
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000873}
874
Ethan Yonker63e414f2015-02-06 15:44:39 -0600875
876extern "C" void set_scale_values(float w, float h)
877{
878 scale_theme_w = w;
879 scale_theme_h = h;
880}
881
882extern "C" int scale_theme_x(int initial_x)
883{
884 if (scale_theme_w != 1) {
thatba75a0e2015-02-14 21:20:10 +0100885 int scaled = (float)initial_x * scale_theme_w;
886 if (scaled == 0 && initial_x > 0)
887 return 1;
888 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600889 }
890 return initial_x;
891}
892
893extern "C" int scale_theme_y(int initial_y)
894{
895 if (scale_theme_h != 1) {
thatba75a0e2015-02-14 21:20:10 +0100896 int scaled = (float)initial_y * scale_theme_h;
897 if (scaled == 0 && initial_y > 0)
898 return 1;
899 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600900 }
901 return initial_y;
902}
903
904extern "C" int scale_theme_min(int initial_value)
905{
906 if (scale_theme_w != 1 || scale_theme_h != 1) {
907 if (scale_theme_w < scale_theme_h)
908 return scale_theme_x(initial_value);
909 else
910 return scale_theme_y(initial_value);
911 }
912 return initial_value;
913}
914
915extern "C" float get_scale_w()
916{
917 return scale_theme_w;
918}
919
920extern "C" float get_scale_h()
921{
922 return scale_theme_h;
923}