blob: bb80632b0bad56d986fbdce419ca874acea20aaf [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}
bigbiffd81833a2021-01-17 11:06:57 -050042#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 }
bigbiffdf8436b2020-08-30 16:22:34 -0400653 if (DataManager::GetIntValue("tw_gui_done") != 0) {
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600654 break;
bigbiffdf8436b2020-08-30 16:22:34 -0400655 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500656 }
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600657 if (ors_read_fd > 0)
658 close(ors_read_fd);
659 ors_read_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600660 set_select_fd();
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200661 gGuiRunning = 0;
662 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500663}
664
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200665int gui_forceRender(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500666{
Ethan Yonker04536952015-01-27 08:41:28 -0600667 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200668 return 0;
669}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500670
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200671int gui_changePage(std::string newPage)
672{
673 LOGINFO("Set page: '%s'\n", newPage.c_str());
674 PageManager::ChangePage(newPage);
Ethan Yonker04536952015-01-27 08:41:28 -0600675 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200676 return 0;
677}
678
679int gui_changeOverlay(std::string overlay)
680{
Ethan Yonker1c273312015-03-16 12:18:56 -0500681 LOGINFO("Set overlay: '%s'\n", overlay.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200682 PageManager::ChangeOverlay(overlay);
Ethan Yonker04536952015-01-27 08:41:28 -0600683 gForceRender.set_value(1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200684 return 0;
685}
686
thatb2e8f672015-03-05 20:25:39 +0100687std::string gui_parse_text(std::string str)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200688{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200689 // This function parses text for DataManager values encompassed by %value% in the XML
thatb2e8f672015-03-05 20:25:39 +0100690 // and string resources (%@resource_name%)
Ethan Yonker74db1572015-10-28 12:44:49 -0500691 size_t pos = 0, next, end;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200692
693 while (1)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500694 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500695 next = str.find("{@", pos);
696 if (next == std::string::npos)
697 break;
698
699 end = str.find('}', next + 1);
700 if (end == std::string::npos)
701 break;
702
703 std::string var = str.substr(next + 2, (end - next) - 2);
704 str.erase(next, (end - next) + 1);
705
706 size_t default_loc = var.find('=', 0);
707 std::string lookup;
708 if (default_loc == std::string::npos) {
709 str.insert(next, PageManager::GetResources()->FindString(var));
710 } else {
711 lookup = var.substr(0, default_loc);
712 std::string default_string = var.substr(default_loc + 1, var.size() - default_loc - 1);
713 str.insert(next, PageManager::GetResources()->FindString(lookup, default_string));
714 }
715 }
716 pos = 0;
717 while (1)
718 {
719 next = str.find('%', pos);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200720 if (next == std::string::npos)
721 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500722
Ethan Yonker74db1572015-10-28 12:44:49 -0500723 end = str.find('%', next + 1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200724 if (end == std::string::npos)
725 return str;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500726
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200727 // We have a block of data
thatb2e8f672015-03-05 20:25:39 +0100728 std::string var = str.substr(next + 1, (end - next) - 1);
729 str.erase(next, (end - next) + 1);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500730
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200731 if (next + 1 == end)
732 str.insert(next, 1, '%');
733 else
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500734 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200735 std::string value;
thatb2e8f672015-03-05 20:25:39 +0100736 if (var.size() > 0 && var[0] == '@') {
737 // this is a string resource ("%@string_name%")
738 value = PageManager::GetResources()->FindString(var.substr(1));
739 str.insert(next, value);
740 }
741 else if (DataManager::GetValue(var, value) == 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200742 str.insert(next, value);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500743 }
744
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200745 pos = next + 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500746 }
747}
748
Ethan Yonker74db1572015-10-28 12:44:49 -0500749std::string gui_lookup(const std::string& resource_name, const std::string& default_value) {
750 return PageManager::GetResources()->FindString(resource_name, default_value);
751}
752
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200753extern "C" int gui_init(void)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500754{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200755 gr_init();
Matt Mowerb26c1162016-02-03 21:05:57 -0600756 TWFunc::Set_Brightness(DataManager::GetStrValue("tw_brightness"));
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500757
Sean hoytc3876222018-07-15 06:16:09 +0200758#ifdef TW_SCREEN_BLANK_ON_BOOT
759 printf("TW_SCREEN_BLANK_ON_BOOT := true\n");
760 blankTimer.blank();
761 blankTimer.resetTimerAndUnblank();
762#endif
763
that235c6482016-01-24 21:59:00 +0100764 // load and show splash screen
765 if (PageManager::LoadPackage("splash", TWRES "splash.xml", "splash")) {
766 LOGERR("Failed to load splash screen XML.\n");
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500767 }
that235c6482016-01-24 21:59:00 +0100768 else {
769 PageManager::SelectPackage("splash");
770 PageManager::Render();
771 flip();
772 PageManager::ReleasePackage("splash");
Ethan Yonker63e414f2015-02-06 15:44:39 -0600773 }
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500774
bigbiff1f780662020-06-26 16:14:32 -0400775#ifdef TW_DELAY_TOUCH_INIT_MS
776 usleep(TW_DELAY_TOUCH_INIT_MS);
777#endif
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200778 ev_init();
779 return 0;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500780}
781
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200782extern "C" int gui_loadResources(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400783{
Ethan Yonker83e82572014-04-04 10:59:28 -0500784#ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200785 int check = 0;
786 DataManager::GetValue(TW_IS_ENCRYPTED, check);
787 if (check)
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500788 {
Dees Troy3454ade2015-01-20 19:21:04 +0000789 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "decrypt"))
Dees_Troy5bf43922012-09-07 16:07:55 -0400790 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500791 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200792 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400793 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200794 else
795 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500796 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400797
Ethan Yonker86404bd2016-03-31 08:01:05 -0500798 if (check == 0)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200799 {
800 std::string theme_path;
801
Fernando Oliveira80c34602023-02-01 12:52:32 -0300802 theme_path = DataManager::GetCurrentStoragePath();
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200803 if (!PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400804 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200805 int retry_count = 5;
806 while (retry_count > 0 && !PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -0400807 {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200808 usleep(500000);
809 retry_count--;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500810 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200811
Ethan Yonker74db1572015-10-28 12:44:49 -0500812 if (!PartitionManager.Mount_Settings_Storage(true))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500813 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500814 LOGINFO("Unable to mount %s during GUI startup.\n", theme_path.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200815 check = 1;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500816 }
817 }
818
Fernando Oliveirafe7fa6b2023-01-12 16:12:55 -0300819 theme_path += TWFunc::Check_For_TwrpFolder() + "/theme/ui.zip";
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200820 if (check || PageManager::LoadPackage("TWRP", theme_path, "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500821 {
Ethan Yonker83e82572014-04-04 10:59:28 -0500822#endif // ifndef TW_OEM_BUILD
Dees Troy3454ade2015-01-20 19:21:04 +0000823 if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "main"))
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500824 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500825 gui_err("base_pkg_err=Failed to load base packages.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200826 goto error;
Dees_Troy51a0e822012-09-05 15:24:24 -0400827 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500828#ifndef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -0400829 }
830 }
Ethan Yonker83e82572014-04-04 10:59:28 -0500831#endif // ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200832 // Set the default package
833 PageManager::SelectPackage("TWRP");
Dees_Troy51a0e822012-09-05 15:24:24 -0400834
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200835 gGuiInitialized = 1;
836 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400837
838error:
Ethan Yonker83e82572014-04-04 10:59:28 -0500839 LOGERR("An internal error has occurred: unable to load theme.\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200840 gGuiInitialized = 0;
841 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400842}
843
Ethan Yonkercf50da52015-01-12 21:59:07 -0600844extern "C" int gui_loadCustomResources(void)
845{
846#ifndef TW_OEM_BUILD
847 if (!PartitionManager.Mount_Settings_Storage(false)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500848 LOGINFO("Unable to mount settings storage during GUI startup.\n");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600849 return -1;
850 }
851
Fernando Oliveira80c34602023-02-01 12:52:32 -0300852 std::string theme_path = DataManager::GetCurrentStoragePath();
Fernando Oliveirafe7fa6b2023-01-12 16:12:55 -0300853 theme_path += TWFunc::Check_For_TwrpFolder() + "/theme/ui.zip";
Ethan Yonkercf50da52015-01-12 21:59:07 -0600854 // Check for a custom theme
855 if (TWFunc::Path_Exists(theme_path)) {
856 // There is a custom theme, try to load it
857 if (PageManager::ReloadPackage("TWRP", theme_path)) {
858 // Custom theme failed to load, try to load stock theme
Dees Troy3454ade2015-01-20 19:21:04 +0000859 if (PageManager::ReloadPackage("TWRP", TWRES "ui.xml")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500860 gui_err("base_pkg_err=Failed to load base packages.");
Ethan Yonkercf50da52015-01-12 21:59:07 -0600861 goto error;
862 }
863 }
864 }
865 // Set the default package
866 PageManager::SelectPackage("TWRP");
867#endif
868 return 0;
869
Patrick Zacharias0edce1a2020-06-06 16:02:58 +0200870#ifndef TW_OEM_BUILD
Ethan Yonkercf50da52015-01-12 21:59:07 -0600871error:
872 LOGERR("An internal error has occurred: unable to load theme.\n");
873 gGuiInitialized = 0;
874 return -1;
Patrick Zacharias0edce1a2020-06-06 16:02:58 +0200875#endif
Ethan Yonkercf50da52015-01-12 21:59:07 -0600876}
877
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200878extern "C" int gui_start(void)
Dees_Troy51a0e822012-09-05 15:24:24 -0400879{
Ethan Yonkerafde0982016-01-23 08:55:35 -0600880 return gui_startPage("main", 1, 0);
Dees_Troy51a0e822012-09-05 15:24:24 -0400881}
882
Patrick Zacharias0edce1a2020-06-06 16:02:58 +0200883extern "C" int gui_startPage(const char *page_name, __attribute__((unused)) const int allow_commands, int stop_on_page_done)
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000884{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200885 if (!gGuiInitialized)
886 return -1;
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000887
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200888 // Set the default package
889 PageManager::SelectPackage("TWRP");
890
that9fa51532015-01-29 02:04:47 +0100891 input_handler.init();
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600892#ifndef TW_OEM_BUILD
893 if (allow_commands)
894 {
895 if (ors_read_fd < 0)
896 setup_ors_command();
897 } else {
898 if (ors_read_fd >= 0) {
899 close(ors_read_fd);
900 ors_read_fd = -1;
901 }
902 }
903#endif
Ethan Yonkerfd0439e2015-01-14 11:08:13 -0600904 return runPages(page_name, stop_on_page_done);
Dees_Troy4bc09ae2013-01-18 17:00:54 +0000905}
906
Ethan Yonker63e414f2015-02-06 15:44:39 -0600907
908extern "C" void set_scale_values(float w, float h)
909{
910 scale_theme_w = w;
911 scale_theme_h = h;
912}
913
914extern "C" int scale_theme_x(int initial_x)
915{
916 if (scale_theme_w != 1) {
thatba75a0e2015-02-14 21:20:10 +0100917 int scaled = (float)initial_x * scale_theme_w;
918 if (scaled == 0 && initial_x > 0)
919 return 1;
920 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600921 }
922 return initial_x;
923}
924
925extern "C" int scale_theme_y(int initial_y)
926{
927 if (scale_theme_h != 1) {
thatba75a0e2015-02-14 21:20:10 +0100928 int scaled = (float)initial_y * scale_theme_h;
929 if (scaled == 0 && initial_y > 0)
930 return 1;
931 return scaled;
Ethan Yonker63e414f2015-02-06 15:44:39 -0600932 }
933 return initial_y;
934}
935
936extern "C" int scale_theme_min(int initial_value)
937{
938 if (scale_theme_w != 1 || scale_theme_h != 1) {
939 if (scale_theme_w < scale_theme_h)
940 return scale_theme_x(initial_value);
941 else
942 return scale_theme_y(initial_value);
943 }
944 return initial_value;
945}
946
947extern "C" float get_scale_w()
948{
949 return scale_theme_w;
950}
951
952extern "C" float get_scale_h()
953{
954 return scale_theme_h;
955}