blob: bab7ed21df34487966ea286c817d82df368712b9 [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>
Dees_Troy51a0e822012-09-05 15:24:24 -040036
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050037extern "C"
38{
Dees_Troy2673cec2013-04-02 20:22:16 +000039#include "../twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040040#include <pixelflinger/pixelflinger.h>
41}
Ethan Yonkerfbb43532015-12-28 21:54:50 +010042#include "../minuitwrp/minui.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040043
44#include "rapidxml.hpp"
45#include "objects.hpp"
46#include "../data.hpp"
47#include "../variables.h"
Dees_Troy5bf43922012-09-07 16:07:55 -040048#include "../partitions.hpp"
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050049#include "../twrp-functions.hpp"
Ethan Yonker03a42f62014-08-08 11:03:51 -050050#include "../openrecoveryscript.hpp"
51#include "../orscmd/orscmd.h"
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050052#include "blanktimer.hpp"
bigbiffd58ba182020-03-23 10:02:29 -040053#include "tw_atomic.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040054
Vojtech Boceke5ffcd12014-02-06 21:17:32 +010055// Enable to print render time of each frame to the log file
56//#define PRINT_RENDER_TIME 1
57
that9fa51532015-01-29 02:04:47 +010058#ifdef _EVENT_LOGGING
thatc5837f32015-02-01 01:59:43 +010059#define LOGEVENT(...) LOGERR(__VA_ARGS__)
that9fa51532015-01-29 02:04:47 +010060#else
61#define LOGEVENT(...) do {} while (0)
62#endif
63
Dees_Troy51a0e822012-09-05 15:24:24 -040064using namespace rapidxml;
65
66// Global values
Dees_Troy51a0e822012-09-05 15:24:24 -040067static int gGuiInitialized = 0;
Ethan Yonker04536952015-01-27 08:41:28 -060068static TWAtomicInt gForceRender;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050069blanktimer blankTimer;
Ethan Yonkerfd0439e2015-01-14 11:08:13 -060070int ors_read_fd = -1;
that10ae24f2015-12-26 20:53:51 +010071static FILE* orsout = NULL;
Ethan Yonker63e414f2015-02-06 15:44:39 -060072static float scale_theme_w = 1;
73static float scale_theme_h = 1;
Dees_Troy51a0e822012-09-05 15:24:24 -040074
75// Needed by pages.cpp too
76int gGuiRunning = 0;
77
that1964d192016-01-07 00:41:03 +010078int g_pty_fd = -1; // set by terminal on init
79void terminal_pty_read();
80
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060081int select_fd = 0;
82
Dees_Troy51a0e822012-09-05 15:24:24 -040083static int gRecorder = -1;
84
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020085extern "C" void gr_write_frame_to_file(int fd);
Dees_Troy51a0e822012-09-05 15:24:24 -040086
Matt Mowerb68bff02017-01-11 15:46:26 -060087static void flip(void)
Dees_Troy51a0e822012-09-05 15:24:24 -040088{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020089 if (gRecorder != -1)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050090 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020091 timespec time;
92 clock_gettime(CLOCK_MONOTONIC, &time);
93 write(gRecorder, &time, sizeof(timespec));
94 gr_write_frame_to_file(gRecorder);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050095 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020096 gr_flip();
Dees_Troy51a0e822012-09-05 15:24:24 -040097}
98
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020099void rapidxml::parse_error_handler(const char *what, void *where)
Dees_Troy51a0e822012-09-05 15:24:24 -0400100{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200101 fprintf(stderr, "Parser error: %s\n", what);
102 fprintf(stderr, " Start of string: %s\n",(char *) where);
103 LOGERR("Error parsing XML file.\n");
104 //abort();
Dees_Troy51a0e822012-09-05 15:24:24 -0400105}
106
that9fa51532015-01-29 02:04:47 +0100107class InputHandler
Dees_Troy51a0e822012-09-05 15:24:24 -0400108{
that9fa51532015-01-29 02:04:47 +0100109public:
110 void init()
thatfb759d42015-01-11 12:16:53 +0100111 {
that9fa51532015-01-29 02:04:47 +0100112 // these might be read from DataManager in the future
113 touch_hold_ms = 500;
114 touch_repeat_ms = 100;
115 key_hold_ms = 500;
116 key_repeat_ms = 100;
117 touch_status = TS_NONE;
118 key_status = KS_NONE;
119 state = AS_NO_ACTION;
120 x = y = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400121
that9fa51532015-01-29 02:04:47 +0100122#ifndef TW_NO_SCREEN_TIMEOUT
123 {
124 string seconds;
125 DataManager::GetValue("tw_screen_timeout_secs", seconds);
126 blankTimer.setTime(atoi(seconds.c_str()));
127 blankTimer.resetTimerAndUnblank();
Ethan Yonkere13fa632015-01-27 11:30:03 -0600128 }
that9fa51532015-01-29 02:04:47 +0100129#else
130 LOGINFO("Skipping screen timeout: TW_NO_SCREEN_TIMEOUT is set\n");
131#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600132 }
133
thatc5837f32015-02-01 01:59:43 +0100134 // process input events. returns true if any event was received.
thatde72b6d2015-02-08 08:55:00 +0100135 bool processInput(int timeout_ms);
thatc5837f32015-02-01 01:59:43 +0100136
that9fa51532015-01-29 02:04:47 +0100137 void handleDrag();
138
139private:
140 // timeouts for touch/key hold and repeat
141 int touch_hold_ms;
142 int touch_repeat_ms;
143 int key_hold_ms;
144 int key_repeat_ms;
145
146 enum touch_status_enum {
147 TS_NONE = 0,
148 TS_TOUCH_AND_HOLD = 1,
149 TS_TOUCH_REPEAT = 2,
150 };
151
152 enum key_status_enum {
153 KS_NONE = 0,
154 KS_KEY_PRESSED = 1,
155 KS_KEY_REPEAT = 2,
156 };
157
158 enum action_state_enum {
159 AS_IN_ACTION_AREA = 0, // we've touched a spot with an action
160 AS_NO_ACTION = 1, // we've touched in an empty area (no action) and ignore remaining events until touch release
161 };
162 touch_status_enum touch_status;
163 key_status_enum key_status;
164 action_state_enum state;
165 int x, y; // x and y coordinates of last touch
166 struct timeval touchStart; // used to track time for long press / key repeat
167
168 void processHoldAndRepeat();
169 void process_EV_REL(input_event& ev);
170 void process_EV_ABS(input_event& ev);
171 void process_EV_KEY(input_event& ev);
172
173 void doTouchStart();
174};
175
176InputHandler input_handler;
177
178
thatde72b6d2015-02-08 08:55:00 +0100179bool InputHandler::processInput(int timeout_ms)
that9fa51532015-01-29 02:04:47 +0100180{
181 input_event ev;
thatde72b6d2015-02-08 08:55:00 +0100182 int ret = ev_get(&ev, timeout_ms);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600183
184 if (ret < 0)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500185 {
Ethan Yonkere13fa632015-01-27 11:30:03 -0600186 // This path means that we did not get any new touch data, but
187 // we do not get new touch data if you press and hold on either
188 // the screen or on a keyboard key or mouse button
that9fa51532015-01-29 02:04:47 +0100189 if (touch_status || key_status)
190 processHoldAndRepeat();
thatc5837f32015-02-01 01:59:43 +0100191 return (ret != -2); // -2 means no more events in the queue
Ethan Yonkere13fa632015-01-27 11:30:03 -0600192 }
that9fa51532015-01-29 02:04:47 +0100193
194 switch (ev.type)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600195 {
that9fa51532015-01-29 02:04:47 +0100196 case EV_ABS:
197 process_EV_ABS(ev);
198 break;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600199
that9fa51532015-01-29 02:04:47 +0100200 case EV_REL:
201 process_EV_REL(ev);
202 break;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600203
that9fa51532015-01-29 02:04:47 +0100204 case EV_KEY:
205 process_EV_KEY(ev);
206 break;
207 }
thatc5837f32015-02-01 01:59:43 +0100208
Matt Mower9472ba12016-01-20 18:12:47 -0600209 if (ev.code != KEY_POWER && ev.code > KEY_RESERVED)
210 blankTimer.resetTimerAndUnblank();
211
thatc5837f32015-02-01 01:59:43 +0100212 return true; // we got an event, so there might be more in the queue
that9fa51532015-01-29 02:04:47 +0100213}
214
215void InputHandler::processHoldAndRepeat()
216{
217 HardwareKeyboard *kb = PageManager::GetHardwareKeyboard();
218
219 // touch and key repeat section
220 struct timeval curTime;
221 gettimeofday(&curTime, NULL);
222 long seconds = curTime.tv_sec - touchStart.tv_sec;
223 long useconds = curTime.tv_usec - touchStart.tv_usec;
224 long mtime = ((seconds) * 1000 + useconds / 1000.0) + 0.5;
225
226 if (touch_status == TS_TOUCH_AND_HOLD && mtime > touch_hold_ms)
227 {
228 touch_status = TS_TOUCH_REPEAT;
229 gettimeofday(&touchStart, NULL);
230 LOGEVENT("TOUCH_HOLD: %d,%d\n", x, y);
231 PageManager::NotifyTouch(TOUCH_HOLD, x, y);
that9fa51532015-01-29 02:04:47 +0100232 }
233 else if (touch_status == TS_TOUCH_REPEAT && mtime > touch_repeat_ms)
234 {
235 LOGEVENT("TOUCH_REPEAT: %d,%d\n", x, y);
236 gettimeofday(&touchStart, NULL);
237 PageManager::NotifyTouch(TOUCH_REPEAT, x, y);
that9fa51532015-01-29 02:04:47 +0100238 }
239 else if (key_status == KS_KEY_PRESSED && mtime > key_hold_ms)
240 {
241 LOGEVENT("KEY_HOLD: %d,%d\n", x, y);
242 gettimeofday(&touchStart, NULL);
243 key_status = KS_KEY_REPEAT;
244 kb->KeyRepeat();
that9fa51532015-01-29 02:04:47 +0100245 }
246 else if (key_status == KS_KEY_REPEAT && mtime > key_repeat_ms)
247 {
248 LOGEVENT("KEY_REPEAT: %d,%d\n", x, y);
249 gettimeofday(&touchStart, NULL);
250 kb->KeyRepeat();
that9fa51532015-01-29 02:04:47 +0100251 }
252}
253
254void InputHandler::doTouchStart()
255{
256 LOGEVENT("TOUCH_START: %d,%d\n", x, y);
257 if (PageManager::NotifyTouch(TOUCH_START, x, y) > 0)
258 state = AS_NO_ACTION;
259 else
260 state = AS_IN_ACTION_AREA;
261 touch_status = TS_TOUCH_AND_HOLD;
262 gettimeofday(&touchStart, NULL);
that9fa51532015-01-29 02:04:47 +0100263}
264
265void InputHandler::process_EV_ABS(input_event& ev)
266{
267 x = ev.value >> 16;
268 y = ev.value & 0xFFFF;
269
270 if (ev.code == 0)
271 {
Ethan Yonker30fa3352015-03-09 13:57:21 -0500272#ifndef TW_USE_KEY_CODE_TOUCH_SYNC
that9fa51532015-01-29 02:04:47 +0100273 if (state == AS_IN_ACTION_AREA)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500274 {
that9fa51532015-01-29 02:04:47 +0100275 LOGEVENT("TOUCH_RELEASE: %d,%d\n", x, y);
276 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
that9fa51532015-01-29 02:04:47 +0100277 }
278 touch_status = TS_NONE;
Ethan Yonker30fa3352015-03-09 13:57:21 -0500279#endif
that9fa51532015-01-29 02:04:47 +0100280 }
281 else
282 {
283 if (!touch_status)
284 {
Ethan Yonker30fa3352015-03-09 13:57:21 -0500285#ifndef TW_USE_KEY_CODE_TOUCH_SYNC
that9fa51532015-01-29 02:04:47 +0100286 doTouchStart();
Ethan Yonker30fa3352015-03-09 13:57:21 -0500287#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600288 }
289 else
290 {
that9fa51532015-01-29 02:04:47 +0100291 if (state == AS_IN_ACTION_AREA)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600292 {
that9fa51532015-01-29 02:04:47 +0100293 LOGEVENT("TOUCH_DRAG: %d,%d\n", x, y);
Dees_Troy51a0e822012-09-05 15:24:24 -0400294 }
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500295 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500296 }
that9fa51532015-01-29 02:04:47 +0100297}
298
299void InputHandler::process_EV_KEY(input_event& ev)
300{
301 HardwareKeyboard *kb = PageManager::GetHardwareKeyboard();
302
303 // Handle key-press here
304 LOGEVENT("TOUCH_KEY: %d\n", ev.code);
305 // Left mouse button is treated as a touch
Matt Mowera8a89d12016-12-30 18:10:37 -0600306 if (ev.code == BTN_LEFT)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600307 {
that9fa51532015-01-29 02:04:47 +0100308 MouseCursor *cursor = PageManager::GetMouseCursor();
Matt Mowera8a89d12016-12-30 18:10:37 -0600309 if (ev.value == 1)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600310 {
that9fa51532015-01-29 02:04:47 +0100311 cursor->GetPos(x, y);
312 doTouchStart();
313 }
Matt Mowera8a89d12016-12-30 18:10:37 -0600314 else if (touch_status)
that9fa51532015-01-29 02:04:47 +0100315 {
316 // Left mouse button was previously pressed and now is
317 // being released so send a TOUCH_RELEASE
318 if (state == AS_IN_ACTION_AREA)
Ethan Yonkere13fa632015-01-27 11:30:03 -0600319 {
320 cursor->GetPos(x, y);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600321
that9fa51532015-01-29 02:04:47 +0100322 LOGEVENT("Mouse TOUCH_RELEASE: %d,%d\n", x, y);
323 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600324 }
that9fa51532015-01-29 02:04:47 +0100325 touch_status = TS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600326 }
that9fa51532015-01-29 02:04:47 +0100327 }
328 // side mouse button, often used for "back" function
Matt Mowera8a89d12016-12-30 18:10:37 -0600329 else if (ev.code == BTN_SIDE)
that9fa51532015-01-29 02:04:47 +0100330 {
Matt Mowera8a89d12016-12-30 18:10:37 -0600331 if (ev.value == 1)
that9fa51532015-01-29 02:04:47 +0100332 kb->KeyDown(KEY_BACK);
333 else
334 kb->KeyUp(KEY_BACK);
335 } else if (ev.value != 0) {
336 // This is a key press
Ethan Yonker30fa3352015-03-09 13:57:21 -0500337#ifdef TW_USE_KEY_CODE_TOUCH_SYNC
338 if (ev.code == TW_USE_KEY_CODE_TOUCH_SYNC) {
339 LOGEVENT("key code %i key press == touch start %i %i\n", TW_USE_KEY_CODE_TOUCH_SYNC, x, y);
340 doTouchStart();
341 return;
342 }
343#endif
that9fa51532015-01-29 02:04:47 +0100344 if (kb->KeyDown(ev.code)) {
345 // Key repeat is enabled for this key
346 key_status = KS_KEY_PRESSED;
347 touch_status = TS_NONE;
348 gettimeofday(&touchStart, NULL);
Ethan Yonkere13fa632015-01-27 11:30:03 -0600349 } else {
Ethan Yonkere13fa632015-01-27 11:30:03 -0600350 key_status = KS_NONE;
351 touch_status = TS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600352 }
that9fa51532015-01-29 02:04:47 +0100353 } else {
354 // This is a key release
355 kb->KeyUp(ev.code);
356 key_status = KS_NONE;
357 touch_status = TS_NONE;
Ethan Yonker30fa3352015-03-09 13:57:21 -0500358#ifdef TW_USE_KEY_CODE_TOUCH_SYNC
359 if (ev.code == TW_USE_KEY_CODE_TOUCH_SYNC) {
360 LOGEVENT("key code %i key release == touch release %i %i\n", TW_USE_KEY_CODE_TOUCH_SYNC, x, y);
361 PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
362 }
363#endif
Ethan Yonkere13fa632015-01-27 11:30:03 -0600364 }
that9fa51532015-01-29 02:04:47 +0100365}
Ethan Yonkere13fa632015-01-27 11:30:03 -0600366
that9fa51532015-01-29 02:04:47 +0100367void InputHandler::process_EV_REL(input_event& ev)
368{
369 // Mouse movement
370 MouseCursor *cursor = PageManager::GetMouseCursor();
371 LOGEVENT("EV_REL %d %d\n", ev.code, ev.value);
Matt Mowera8a89d12016-12-30 18:10:37 -0600372 if (ev.code == REL_X)
that9fa51532015-01-29 02:04:47 +0100373 cursor->Move(ev.value, 0);
Matt Mowera8a89d12016-12-30 18:10:37 -0600374 else if (ev.code == REL_Y)
that9fa51532015-01-29 02:04:47 +0100375 cursor->Move(0, ev.value);
376
Matt Mowera8a89d12016-12-30 18:10:37 -0600377 if (touch_status) {
that9fa51532015-01-29 02:04:47 +0100378 cursor->GetPos(x, y);
379 LOGEVENT("Mouse TOUCH_DRAG: %d, %d\n", x, y);
380 key_status = KS_NONE;
Ethan Yonkere13fa632015-01-27 11:30:03 -0600381 }
that9fa51532015-01-29 02:04:47 +0100382}
383
384void InputHandler::handleDrag()
385{
386 // This allows us to only send one NotifyTouch event per render
387 // cycle to reduce overhead and perceived input latency.
388 static int prevx = 0, prevy = 0; // these track where the last drag notice was so that we don't send duplicate drag notices
389 if (touch_status && (x != prevx || y != prevy)) {
390 prevx = x;
391 prevy = y;
392 if (PageManager::NotifyTouch(TOUCH_DRAG, x, y) > 0)
393 state = AS_NO_ACTION;
394 else
395 state = AS_IN_ACTION_AREA;
396 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400397}
398
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600399void set_select_fd() {
400 select_fd = ors_read_fd + 1;
401 if (g_pty_fd >= select_fd)
402 select_fd = g_pty_fd + 1;
403 if (PartitionManager.uevent_pfd.fd >= select_fd)
404 select_fd = PartitionManager.uevent_pfd.fd + 1;
405}
406
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600407static void setup_ors_command()
Ethan Yonker03a42f62014-08-08 11:03:51 -0500408{
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600409 ors_read_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600410 set_select_fd();
Ethan Yonker03a42f62014-08-08 11:03:51 -0500411
412 unlink(ORS_INPUT_FILE);
413 if (mkfifo(ORS_INPUT_FILE, 06660) != 0) {
414 LOGINFO("Unable to mkfifo %s\n", ORS_INPUT_FILE);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600415 return;
Ethan Yonker03a42f62014-08-08 11:03:51 -0500416 }
417 unlink(ORS_OUTPUT_FILE);
418 if (mkfifo(ORS_OUTPUT_FILE, 06666) != 0) {
419 LOGINFO("Unable to mkfifo %s\n", ORS_OUTPUT_FILE);
420 unlink(ORS_INPUT_FILE);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600421 return;
Ethan Yonker03a42f62014-08-08 11:03:51 -0500422 }
423
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600424 ors_read_fd = open(ORS_INPUT_FILE, O_RDONLY | O_NONBLOCK);
425 if (ors_read_fd < 0) {
Ethan Yonker03a42f62014-08-08 11:03:51 -0500426 LOGINFO("Unable to open %s\n", ORS_INPUT_FILE);
427 unlink(ORS_INPUT_FILE);
428 unlink(ORS_OUTPUT_FILE);
Ethan Yonker03a42f62014-08-08 11:03:51 -0500429 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600430 set_select_fd();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600431}
Ethan Yonker03a42f62014-08-08 11:03:51 -0500432
that10ae24f2015-12-26 20:53:51 +0100433// callback called after a CLI command was executed
434static void ors_command_done()
435{
436 gui_set_FILE(NULL);
437 fclose(orsout);
438 orsout = NULL;
439
440 if (DataManager::GetIntValue("tw_page_done") == 0) {
441 // The select function will return ready to read and the
442 // read function will return errno 19 no such device unless
443 // we set everything up all over again.
444 close(ors_read_fd);
445 setup_ors_command();
446 }
447}
448
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600449static void ors_command_read()
450{
that10ae24f2015-12-26 20:53:51 +0100451 char command[1024];
452 int read_ret = read(ors_read_fd, &command, sizeof(command));
Ethan Yonker03a42f62014-08-08 11:03:51 -0500453
that10ae24f2015-12-26 20:53:51 +0100454 if (read_ret > 0) {
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600455 command[1022] = '\n';
456 command[1023] = '\0';
457 LOGINFO("Command '%s' received\n", command);
458 orsout = fopen(ORS_OUTPUT_FILE, "w");
459 if (!orsout) {
460 close(ors_read_fd);
461 ors_read_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600462 set_select_fd();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600463 LOGINFO("Unable to fopen %s\n", ORS_OUTPUT_FILE);
464 unlink(ORS_INPUT_FILE);
465 unlink(ORS_OUTPUT_FILE);
466 return;
467 }
468 if (DataManager::GetIntValue("tw_busy") != 0) {
that10ae24f2015-12-26 20:53:51 +0100469 fputs("Failed, operation in progress\n", orsout);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600470 LOGINFO("Command cannot be performed, operation in progress.\n");
that10ae24f2015-12-26 20:53:51 +0100471 fclose(orsout);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600472 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500473 if (strlen(command) == 11 && strncmp(command, "dumpstrings", 11) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500474 gui_set_FILE(orsout);
475 PageManager::GetResources()->DumpStrings();
that10ae24f2015-12-26 20:53:51 +0100476 ors_command_done();
Ethan Yonker64e0a652018-07-25 09:52:17 -0500477 } else if (strlen(command) == 11 && strncmp(command, "reloadtheme", 11) == 0) {
478 PageManager::RequestReload();
479 ors_command_done();
480 } else if (strlen(command) > 11 && strncmp(command, "changepage=", 11) == 0) {
481 char* pg = &command[11];
482 gui_changePage(pg);
483 ors_command_done();
that10ae24f2015-12-26 20:53:51 +0100484 } else {
485 // mirror output messages
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600486 gui_set_FILE(orsout);
that10ae24f2015-12-26 20:53:51 +0100487 // close orsout and restart listener after command is done
488 OpenRecoveryScript::Call_After_CLI_Command(ors_command_done);
489 // run the command in a threaded action...
490 DataManager::SetValue("tw_action", "twcmd");
491 DataManager::SetValue("tw_action_param", command);
492 // ...and switch back to the current page when finished
493 std::string currentPage = PageManager::GetCurrentPage();
494 DataManager::SetValue("tw_has_action2", "1");
495 DataManager::SetValue("tw_action2", "page");
496 DataManager::SetValue("tw_action2_param", currentPage);
497 DataManager::SetValue("tw_action_text1", gui_lookup("running_recovery_commands", "Running Recovery Commands"));
498 DataManager::SetValue("tw_action_text2", "");
499 gui_changePage("singleaction_page");
500 // now immediately return to the GUI main loop (the action runs in the background thread)
501 // 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 -0500502 }
Ethan Yonker03a42f62014-08-08 11:03:51 -0500503 }
504 }
Ethan Yonker03a42f62014-08-08 11:03:51 -0500505}
506
that10ae24f2015-12-26 20:53:51 +0100507// Get and dispatch input events until it's time to draw the next frame
Dees_Troy51a0e822012-09-05 15:24:24 -0400508// This special function will return immediately the first time, but then
509// always returns 1/30th of a second (or immediately if called later) from
510// the last time it was called
thatde72b6d2015-02-08 08:55:00 +0100511static void loopTimer(int input_timeout_ms)
Dees_Troy51a0e822012-09-05 15:24:24 -0400512{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200513 static timespec lastCall;
514 static int initialized = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400515
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200516 if (!initialized)
Dees_Troyc8b199c2012-09-24 11:55:07 -0400517 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200518 clock_gettime(CLOCK_MONOTONIC, &lastCall);
519 initialized = 1;
520 return;
Dees_Troyc8b199c2012-09-24 11:55:07 -0400521 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400522
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200523 do
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500524 {
thatde72b6d2015-02-08 08:55:00 +0100525 bool got_event = input_handler.processInput(input_timeout_ms); // get inputs but don't send drag notices
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200526 timespec curTime;
527 clock_gettime(CLOCK_MONOTONIC, &curTime);
Dees_Troy51a0e822012-09-05 15:24:24 -0400528
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200529 timespec diff = TWFunc::timespec_diff(lastCall, curTime);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500530
thatc5837f32015-02-01 01:59:43 +0100531 // This is really 2 or 30 times per second
532 // As long as we get events, increase the timeout so we can catch up with input
533 long timeout = got_event ? 500000000 : 33333333;
534
535 if (diff.tv_sec || diff.tv_nsec > timeout)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500536 {
thatc5837f32015-02-01 01:59:43 +0100537 // int32_t input_time = TWFunc::timespec_diff_ms(lastCall, curTime);
538 // LOGINFO("loopTimer(): %u ms, count: %u\n", input_time, count);
539
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200540 lastCall = curTime;
that9fa51532015-01-29 02:04:47 +0100541 input_handler.handleDrag(); // send only drag notices if needed
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200542 return;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500543 }
544
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200545 // We need to sleep some period time microseconds
Ethan Yonkere13fa632015-01-27 11:30:03 -0600546 //unsigned int sleepTime = 33333 -(diff.tv_nsec / 1000);
547 //usleep(sleepTime); // removed so we can scan for input
thatde72b6d2015-02-08 08:55:00 +0100548 input_timeout_ms = 0;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200549 } while (1);
Dees_Troy51a0e822012-09-05 15:24:24 -0400550}
551
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600552static int runPages(const char *page_name, const int stop_on_page_done)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500553{
Ethan Yonker3f15be42015-02-09 09:39:47 -0600554 DataManager::SetValue("tw_page_done", 0);
555 DataManager::SetValue("tw_gui_done", 0);
556
Ethan Yonkerafde0982016-01-23 08:55:35 -0600557 if (page_name) {
558 PageManager::SetStartPage(page_name);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600559 gui_changePage(page_name);
Ethan Yonkerafde0982016-01-23 08:55:35 -0600560 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600561
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200562 gGuiRunning = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500563
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200564 DataManager::SetValue("tw_loaded", 1);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500565
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600566 struct timeval timeout;
567 fd_set fdset;
568 int has_data = 0;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100569
thatde72b6d2015-02-08 08:55:00 +0100570 int input_timeout_ms = 0;
571 int idle_frames = 0;
572
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200573 for (;;)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500574 {
thatde72b6d2015-02-08 08:55:00 +0100575 loopTimer(input_timeout_ms);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600576 FD_ZERO(&fdset);
577 timeout.tv_sec = 0;
578 timeout.tv_usec = 1;
that1964d192016-01-07 00:41:03 +0100579 if (g_pty_fd > 0) {
that1964d192016-01-07 00:41:03 +0100580 FD_SET(g_pty_fd, &fdset);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600581 }
582 if (PartitionManager.uevent_pfd.fd > 0) {
583 FD_SET(PartitionManager.uevent_pfd.fd, &fdset);
that1964d192016-01-07 00:41:03 +0100584 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600585#ifndef TW_OEM_BUILD
that10ae24f2015-12-26 20:53:51 +0100586 if (ors_read_fd > 0 && !orsout) { // orsout is non-NULL if a command is still running
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600587 FD_SET(ors_read_fd, &fdset);
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600588 }
589#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600590 // TODO: combine this select with the poll done by input handling
591 has_data = select(select_fd, &fdset, NULL, NULL, &timeout);
592 if (has_data > 0) {
593 if (g_pty_fd > 0 && FD_ISSET(g_pty_fd, &fdset))
594 terminal_pty_read();
595 if (PartitionManager.uevent_pfd.fd > 0 && FD_ISSET(PartitionManager.uevent_pfd.fd, &fdset))
596 PartitionManager.read_uevent();
597 if (ors_read_fd > 0 && !orsout && FD_ISSET(ors_read_fd, &fdset))
598 ors_command_read();
599 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500600
Ethan Yonker04536952015-01-27 08:41:28 -0600601 if (!gForceRender.get_value())
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500602 {
thatde72b6d2015-02-08 08:55:00 +0100603 int ret = PageManager::Update();
604 if (ret == 0)
605 ++idle_frames;
Ethan Yonkere0f1f3b2015-10-27 09:49:01 -0500606 else if (ret == -2)
607 break; // Theme reload failure
thatde72b6d2015-02-08 08:55:00 +0100608 else
609 idle_frames = 0;
610 // due to possible animation objects, we need to delay activating the input timeout
611 input_timeout_ms = idle_frames > 15 ? 1000 : 0;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100612
613#ifndef PRINT_RENDER_TIME
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200614 if (ret > 1)
615 PageManager::Render();
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500616
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200617 if (ret > 0)
618 flip();
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100619#else
620 if (ret > 1)
621 {
that9fa51532015-01-29 02:04:47 +0100622 timespec start, end;
623 int32_t render_t, flip_t;
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100624 clock_gettime(CLOCK_MONOTONIC, &start);
625 PageManager::Render();
626 clock_gettime(CLOCK_MONOTONIC, &end);
627 render_t = TWFunc::timespec_diff_ms(start, end);
628
629 flip();
630 clock_gettime(CLOCK_MONOTONIC, &start);
631 flip_t = TWFunc::timespec_diff_ms(end, start);
632
633 LOGINFO("Render(): %u ms, flip(): %u ms, total: %u ms\n", render_t, flip_t, render_t+flip_t);
634 }
thatde72b6d2015-02-08 08:55:00 +0100635 else if (ret > 0)
Vojtech Boceke5ffcd12014-02-06 21:17:32 +0100636 flip();
637#endif
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500638 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200639 else
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500640 {
Ethan Yonker04536952015-01-27 08:41:28 -0600641 gForceRender.set_value(0);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200642 PageManager::Render();
643 flip();
thatde72b6d2015-02-08 08:55:00 +0100644 input_timeout_ms = 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500645 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200646
thatfb759d42015-01-11 12:16:53 +0100647 blankTimer.checkForTimeout();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600648 if (stop_on_page_done && DataManager::GetIntValue("tw_page_done") != 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200649 {
650 gui_changePage("main");
Dees_Troy6ef66352013-02-21 08:26:57 -0600651 break;
652 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600653 if (DataManager::GetIntValue("tw_gui_done") != 0)
654 break;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500655 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600656 if (ors_read_fd > 0)
657 close(ors_read_fd);
658 ors_read_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600659 set_select_fd();
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200660 gGuiRunning = 0;
661 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500662}
663
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200664int gui_forceRender(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500665{
Ethan Yonker04536952015-01-27 08:41:28 -0600666 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200667 return 0;
668}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500669
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200670int gui_changePage(std::string newPage)
671{
672 LOGINFO("Set page: '%s'\n", newPage.c_str());
673 PageManager::ChangePage(newPage);
Ethan Yonker04536952015-01-27 08:41:28 -0600674 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200675 return 0;
676}
677
678int gui_changeOverlay(std::string overlay)
679{
Ethan Yonker1c273312015-03-16 12:18:56 -0500680 LOGINFO("Set overlay: '%s'\n", overlay.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200681 PageManager::ChangeOverlay(overlay);
Ethan Yonker04536952015-01-27 08:41:28 -0600682 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200683 return 0;
684}
685
thatb2e8f672015-03-05 20:25:39 +0100686std::string gui_parse_text(std::string str)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200687{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200688 // This function parses text for DataManager values encompassed by %value% in the XML
thatb2e8f672015-03-05 20:25:39 +0100689 // and string resources (%@resource_name%)
Ethan Yonker74db1572015-10-28 12:44:49 -0500690 size_t pos = 0, next, end;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200691
692 while (1)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500693 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500694 next = str.find("{@", pos);
695 if (next == std::string::npos)
696 break;
697
698 end = str.find('}', next + 1);
699 if (end == std::string::npos)
700 break;
701
702 std::string var = str.substr(next + 2, (end - next) - 2);
703 str.erase(next, (end - next) + 1);
704
705 size_t default_loc = var.find('=', 0);
706 std::string lookup;
707 if (default_loc == std::string::npos) {
708 str.insert(next, PageManager::GetResources()->FindString(var));
709 } else {
710 lookup = var.substr(0, default_loc);
711 std::string default_string = var.substr(default_loc + 1, var.size() - default_loc - 1);
712 str.insert(next, PageManager::GetResources()->FindString(lookup, default_string));
713 }
714 }
715 pos = 0;
716 while (1)
717 {
718 next = str.find('%', pos);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200719 if (next == std::string::npos)
720 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500721
Ethan Yonker74db1572015-10-28 12:44:49 -0500722 end = str.find('%', next + 1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200723 if (end == std::string::npos)
724 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500725
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200726 // We have a block of data
thatb2e8f672015-03-05 20:25:39 +0100727 std::string var = str.substr(next + 1, (end - next) - 1);
728 str.erase(next, (end - next) + 1);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500729
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200730 if (next + 1 == end)
731 str.insert(next, 1, '%');
732 else
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500733 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200734 std::string value;
thatb2e8f672015-03-05 20:25:39 +0100735 if (var.size() > 0 && var[0] == '@') {
736 // this is a string resource ("%@string_name%")
737 value = PageManager::GetResources()->FindString(var.substr(1));
738 str.insert(next, value);
739 }
740 else if (DataManager::GetValue(var, value) == 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200741 str.insert(next, value);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500742 }
743
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200744 pos = next + 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500745 }
746}
747
Ethan Yonker74db1572015-10-28 12:44:49 -0500748std::string gui_lookup(const std::string& resource_name, const std::string& default_value) {
749 return PageManager::GetResources()->FindString(resource_name, default_value);
750}
751
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200752extern "C" int gui_init(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500753{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200754 gr_init();
Matt Mowerb26c1162016-02-03 21:05:57 -0600755 TWFunc::Set_Brightness(DataManager::GetStrValue("tw_brightness"));
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500756
that235c6482016-01-24 21:59:00 +0100757 // load and show splash screen
758 if (PageManager::LoadPackage("splash", TWRES "splash.xml", "splash")) {
759 LOGERR("Failed to load splash screen XML.\n");
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500760 }
that235c6482016-01-24 21:59:00 +0100761 else {
762 PageManager::SelectPackage("splash");
763 PageManager::Render();
764 flip();
765 PageManager::ReleasePackage("splash");
Ethan Yonker63e414f2015-02-06 15:44:39 -0600766 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500767
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200768 ev_init();
769 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500770}
771
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200772extern "C" int gui_loadResources(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400773{
Ethan Yonker83e82572014-04-04 10:59:28 -0500774#ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200775 int check = 0;
776 DataManager::GetValue(TW_IS_ENCRYPTED, check);
Dees Troy3454ade2015-01-20 19:21:04 +0000777
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200778 if (check)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500779 {
Dees Troy3454ade2015-01-20 19:21:04 +0000780 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "decrypt"))
Dees_Troy5bf43922012-09-07 16:07:55 -0400781 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500782 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200783 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400784 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200785 else
786 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500787 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400788
Ethan Yonker86404bd2016-03-31 08:01:05 -0500789 if (check == 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200790 {
791 std::string theme_path;
792
793 theme_path = DataManager::GetSettingsStoragePath();
794 if (!PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400795 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200796 int retry_count = 5;
797 while (retry_count > 0 && !PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400798 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200799 usleep(500000);
800 retry_count--;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500801 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200802
Ethan Yonker74db1572015-10-28 12:44:49 -0500803 if (!PartitionManager.Mount_Settings_Storage(true))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500804 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500805 LOGINFO("Unable to mount %s during GUI startup.\n", theme_path.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200806 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500807 }
808 }
809
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200810 theme_path += "/TWRP/theme/ui.zip";
811 if (check || PageManager::LoadPackage("TWRP", theme_path, "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500812 {
Ethan Yonker83e82572014-04-04 10:59:28 -0500813#endif // ifndef TW_OEM_BUILD
Dees Troy3454ade2015-01-20 19:21:04 +0000814 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500815 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500816 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200817 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400818 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500819#ifndef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -0400820 }
821 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500822#endif // ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200823 // Set the default package
824 PageManager::SelectPackage("TWRP");
Dees_Troy51a0e822012-09-05 15:24:24 -0400825
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200826 gGuiInitialized = 1;
827 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400828
829error:
Ethan Yonker83e82572014-04-04 10:59:28 -0500830 LOGERR("An internal error has occurred: unable to load theme.\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200831 gGuiInitialized = 0;
832 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400833}
834
Ethan Yonkercf50da52015-01-12 21:59:07 -0600835extern "C" int gui_loadCustomResources(void)
836{
837#ifndef TW_OEM_BUILD
838 if (!PartitionManager.Mount_Settings_Storage(false)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500839 LOGINFO("Unable to mount settings storage during GUI startup.\n");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600840 return -1;
841 }
842
843 std::string theme_path = DataManager::GetSettingsStoragePath();
844 theme_path += "/TWRP/theme/ui.zip";
845 // Check for a custom theme
846 if (TWFunc::Path_Exists(theme_path)) {
847 // There is a custom theme, try to load it
848 if (PageManager::ReloadPackage("TWRP", theme_path)) {
849 // Custom theme failed to load, try to load stock theme
Dees Troy3454ade2015-01-20 19:21:04 +0000850 if (PageManager::ReloadPackage("TWRP", TWRES "ui.xml")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500851 gui_err("base_pkg_err=Failed to load base packages.");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600852 goto error;
853 }
854 }
855 }
856 // Set the default package
857 PageManager::SelectPackage("TWRP");
858#endif
859 return 0;
860
861error:
862 LOGERR("An internal error has occurred: unable to load theme.\n");
863 gGuiInitialized = 0;
864 return -1;
865}
866
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200867extern "C" int gui_start(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400868{
Ethan Yonkerafde0982016-01-23 08:55:35 -0600869 return gui_startPage("main", 1, 0);
Dees_Troy51a0e822012-09-05 15:24:24 -0400870}
871
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600872extern "C" int gui_startPage(const char *page_name, const int allow_commands, int stop_on_page_done)
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000873{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200874 if (!gGuiInitialized)
875 return -1;
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000876
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200877 // Set the default package
878 PageManager::SelectPackage("TWRP");
879
that9fa51532015-01-29 02:04:47 +0100880 input_handler.init();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600881#ifndef TW_OEM_BUILD
882 if (allow_commands)
883 {
884 if (ors_read_fd < 0)
885 setup_ors_command();
886 } else {
887 if (ors_read_fd >= 0) {
888 close(ors_read_fd);
889 ors_read_fd = -1;
890 }
891 }
892#endif
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600893 return runPages(page_name, stop_on_page_done);
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000894}
895
Ethan Yonker63e414f2015-02-06 15:44:39 -0600896
897extern "C" void set_scale_values(float w, float h)
898{
899 scale_theme_w = w;
900 scale_theme_h = h;
901}
902
903extern "C" int scale_theme_x(int initial_x)
904{
905 if (scale_theme_w != 1) {
thatba75a0e2015-02-14 21:20:10 +0100906 int scaled = (float)initial_x * scale_theme_w;
907 if (scaled == 0 && initial_x > 0)
908 return 1;
909 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600910 }
911 return initial_x;
912}
913
914extern "C" int scale_theme_y(int initial_y)
915{
916 if (scale_theme_h != 1) {
thatba75a0e2015-02-14 21:20:10 +0100917 int scaled = (float)initial_y * scale_theme_h;
918 if (scaled == 0 && initial_y > 0)
919 return 1;
920 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600921 }
922 return initial_y;
923}
924
925extern "C" int scale_theme_min(int initial_value)
926{
927 if (scale_theme_w != 1 || scale_theme_h != 1) {
928 if (scale_theme_w < scale_theme_h)
929 return scale_theme_x(initial_value);
930 else
931 return scale_theme_y(initial_value);
932 }
933 return initial_value;
934}
935
936extern "C" float get_scale_w()
937{
938 return scale_theme_w;
939}
940
941extern "C" float get_scale_h()
942{
943 return scale_theme_h;
944}