Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 1 | /* |
Dees Troy | 3be70a8 | 2013-10-22 14:25:12 +0000 | [diff] [blame] | 2 | 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_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 18 | |
| 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_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 36 | |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 37 | extern "C" |
| 38 | { |
Dees_Troy | 2673cec | 2013-04-02 20:22:16 +0000 | [diff] [blame] | 39 | #include "../twcommon.h" |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 40 | #include <pixelflinger/pixelflinger.h> |
| 41 | } |
bigbiff | d81833a | 2021-01-17 11:06:57 -0500 | [diff] [blame] | 42 | #include "minuitwrp/minui.h" |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 43 | |
| 44 | #include "rapidxml.hpp" |
| 45 | #include "objects.hpp" |
| 46 | #include "../data.hpp" |
| 47 | #include "../variables.h" |
Dees_Troy | 5bf4392 | 2012-09-07 16:07:55 -0400 | [diff] [blame] | 48 | #include "../partitions.hpp" |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 49 | #include "../twrp-functions.hpp" |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 50 | #include "../openrecoveryscript.hpp" |
| 51 | #include "../orscmd/orscmd.h" |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 52 | #include "blanktimer.hpp" |
bigbiff | d58ba18 | 2020-03-23 10:02:29 -0400 | [diff] [blame] | 53 | #include "tw_atomic.hpp" |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 54 | |
Vojtech Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 55 | // Enable to print render time of each frame to the log file |
| 56 | //#define PRINT_RENDER_TIME 1 |
| 57 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 58 | #ifdef _EVENT_LOGGING |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 59 | #define LOGEVENT(...) LOGERR(__VA_ARGS__) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 60 | #else |
| 61 | #define LOGEVENT(...) do {} while (0) |
| 62 | #endif |
| 63 | |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 64 | using namespace rapidxml; |
| 65 | |
| 66 | // Global values |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 67 | static int gGuiInitialized = 0; |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 68 | static TWAtomicInt gForceRender; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 69 | blanktimer blankTimer; |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 70 | int ors_read_fd = -1; |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 71 | static FILE* orsout = NULL; |
Ethan Yonker | 63e414f | 2015-02-06 15:44:39 -0600 | [diff] [blame] | 72 | static float scale_theme_w = 1; |
| 73 | static float scale_theme_h = 1; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 74 | |
| 75 | // Needed by pages.cpp too |
| 76 | int gGuiRunning = 0; |
| 77 | |
that | 1964d19 | 2016-01-07 00:41:03 +0100 | [diff] [blame] | 78 | int g_pty_fd = -1; // set by terminal on init |
| 79 | void terminal_pty_read(); |
| 80 | |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 81 | int select_fd = 0; |
| 82 | |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 83 | static int gRecorder = -1; |
| 84 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 85 | extern "C" void gr_write_frame_to_file(int fd); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 86 | |
Matt Mower | b68bff0 | 2017-01-11 15:46:26 -0600 | [diff] [blame] | 87 | static void flip(void) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 88 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 89 | if (gRecorder != -1) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 90 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 91 | timespec time; |
| 92 | clock_gettime(CLOCK_MONOTONIC, &time); |
| 93 | write(gRecorder, &time, sizeof(timespec)); |
| 94 | gr_write_frame_to_file(gRecorder); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 95 | } |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 96 | gr_flip(); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 97 | } |
| 98 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 99 | void rapidxml::parse_error_handler(const char *what, void *where) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 100 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 101 | 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_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 105 | } |
| 106 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 107 | class InputHandler |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 108 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 109 | public: |
| 110 | void init() |
that | fb759d4 | 2015-01-11 12:16:53 +0100 | [diff] [blame] | 111 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 112 | // 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_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 121 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 122 | #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 Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 128 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 129 | #else |
| 130 | LOGINFO("Skipping screen timeout: TW_NO_SCREEN_TIMEOUT is set\n"); |
| 131 | #endif |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 132 | } |
| 133 | |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 134 | // process input events. returns true if any event was received. |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 135 | bool processInput(int timeout_ms); |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 136 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 137 | void handleDrag(); |
| 138 | |
| 139 | private: |
| 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 | |
| 176 | InputHandler input_handler; |
| 177 | |
| 178 | |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 179 | bool InputHandler::processInput(int timeout_ms) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 180 | { |
| 181 | input_event ev; |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 182 | int ret = ev_get(&ev, timeout_ms); |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 183 | |
| 184 | if (ret < 0) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 185 | { |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 186 | // 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 |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 189 | if (touch_status || key_status) |
| 190 | processHoldAndRepeat(); |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 191 | return (ret != -2); // -2 means no more events in the queue |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 192 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 193 | |
| 194 | switch (ev.type) |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 195 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 196 | case EV_ABS: |
| 197 | process_EV_ABS(ev); |
| 198 | break; |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 199 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 200 | case EV_REL: |
| 201 | process_EV_REL(ev); |
| 202 | break; |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 203 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 204 | case EV_KEY: |
| 205 | process_EV_KEY(ev); |
| 206 | break; |
| 207 | } |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 208 | |
Matt Mower | 9472ba1 | 2016-01-20 18:12:47 -0600 | [diff] [blame] | 209 | if (ev.code != KEY_POWER && ev.code > KEY_RESERVED) |
| 210 | blankTimer.resetTimerAndUnblank(); |
| 211 | |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 212 | return true; // we got an event, so there might be more in the queue |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | void 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); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 232 | } |
| 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); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 238 | } |
| 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(); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 245 | } |
| 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(); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 251 | } |
| 252 | } |
| 253 | |
| 254 | void 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); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | void 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 Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 272 | #ifndef TW_USE_KEY_CODE_TOUCH_SYNC |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 273 | if (state == AS_IN_ACTION_AREA) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 274 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 275 | LOGEVENT("TOUCH_RELEASE: %d,%d\n", x, y); |
| 276 | PageManager::NotifyTouch(TOUCH_RELEASE, x, y); |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 277 | } |
| 278 | touch_status = TS_NONE; |
Ethan Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 279 | #endif |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 280 | } |
| 281 | else |
| 282 | { |
| 283 | if (!touch_status) |
| 284 | { |
Ethan Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 285 | #ifndef TW_USE_KEY_CODE_TOUCH_SYNC |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 286 | doTouchStart(); |
Ethan Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 287 | #endif |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 288 | } |
| 289 | else |
| 290 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 291 | if (state == AS_IN_ACTION_AREA) |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 292 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 293 | LOGEVENT("TOUCH_DRAG: %d,%d\n", x, y); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 294 | } |
Matt Mower | fb1c4ff | 2014-04-16 13:43:36 -0500 | [diff] [blame] | 295 | } |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 296 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 297 | } |
| 298 | |
| 299 | void 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 Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 306 | if (ev.code == BTN_LEFT) |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 307 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 308 | MouseCursor *cursor = PageManager::GetMouseCursor(); |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 309 | if (ev.value == 1) |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 310 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 311 | cursor->GetPos(x, y); |
| 312 | doTouchStart(); |
| 313 | } |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 314 | else if (touch_status) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 315 | { |
| 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 Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 319 | { |
| 320 | cursor->GetPos(x, y); |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 321 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 322 | LOGEVENT("Mouse TOUCH_RELEASE: %d,%d\n", x, y); |
| 323 | PageManager::NotifyTouch(TOUCH_RELEASE, x, y); |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 324 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 325 | touch_status = TS_NONE; |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 326 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 327 | } |
| 328 | // side mouse button, often used for "back" function |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 329 | else if (ev.code == BTN_SIDE) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 330 | { |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 331 | if (ev.value == 1) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 332 | kb->KeyDown(KEY_BACK); |
| 333 | else |
| 334 | kb->KeyUp(KEY_BACK); |
| 335 | } else if (ev.value != 0) { |
| 336 | // This is a key press |
Ethan Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 337 | #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 |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 344 | 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 Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 349 | } else { |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 350 | key_status = KS_NONE; |
| 351 | touch_status = TS_NONE; |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 352 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 353 | } else { |
| 354 | // This is a key release |
| 355 | kb->KeyUp(ev.code); |
| 356 | key_status = KS_NONE; |
| 357 | touch_status = TS_NONE; |
Ethan Yonker | 30fa335 | 2015-03-09 13:57:21 -0500 | [diff] [blame] | 358 | #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 Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 364 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 365 | } |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 366 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 367 | void 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 Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 372 | if (ev.code == REL_X) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 373 | cursor->Move(ev.value, 0); |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 374 | else if (ev.code == REL_Y) |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 375 | cursor->Move(0, ev.value); |
| 376 | |
Matt Mower | a8a89d1 | 2016-12-30 18:10:37 -0600 | [diff] [blame] | 377 | if (touch_status) { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 378 | cursor->GetPos(x, y); |
| 379 | LOGEVENT("Mouse TOUCH_DRAG: %d, %d\n", x, y); |
| 380 | key_status = KS_NONE; |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 381 | } |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 382 | } |
| 383 | |
| 384 | void 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_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 397 | } |
| 398 | |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 399 | void 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 Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 407 | static void setup_ors_command() |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 408 | { |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 409 | ors_read_fd = -1; |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 410 | set_select_fd(); |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 411 | |
| 412 | unlink(ORS_INPUT_FILE); |
| 413 | if (mkfifo(ORS_INPUT_FILE, 06660) != 0) { |
| 414 | LOGINFO("Unable to mkfifo %s\n", ORS_INPUT_FILE); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 415 | return; |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 416 | } |
| 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 Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 421 | return; |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 422 | } |
| 423 | |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 424 | ors_read_fd = open(ORS_INPUT_FILE, O_RDONLY | O_NONBLOCK); |
| 425 | if (ors_read_fd < 0) { |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 426 | LOGINFO("Unable to open %s\n", ORS_INPUT_FILE); |
| 427 | unlink(ORS_INPUT_FILE); |
| 428 | unlink(ORS_OUTPUT_FILE); |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 429 | } |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 430 | set_select_fd(); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 431 | } |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 432 | |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 433 | // callback called after a CLI command was executed |
| 434 | static 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 Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 449 | static void ors_command_read() |
| 450 | { |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 451 | char command[1024]; |
| 452 | int read_ret = read(ors_read_fd, &command, sizeof(command)); |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 453 | |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 454 | if (read_ret > 0) { |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 455 | 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 Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 462 | set_select_fd(); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 463 | 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) { |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 469 | fputs("Failed, operation in progress\n", orsout); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 470 | LOGINFO("Command cannot be performed, operation in progress.\n"); |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 471 | fclose(orsout); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 472 | } else { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 473 | if (strlen(command) == 11 && strncmp(command, "dumpstrings", 11) == 0) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 474 | gui_set_FILE(orsout); |
| 475 | PageManager::GetResources()->DumpStrings(); |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 476 | ors_command_done(); |
Ethan Yonker | 64e0a65 | 2018-07-25 09:52:17 -0500 | [diff] [blame] | 477 | } 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(); |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 484 | } else { |
| 485 | // mirror output messages |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 486 | gui_set_FILE(orsout); |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 487 | // 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 Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 502 | } |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 503 | } |
| 504 | } |
Ethan Yonker | 03a42f6 | 2014-08-08 11:03:51 -0500 | [diff] [blame] | 505 | } |
| 506 | |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 507 | // Get and dispatch input events until it's time to draw the next frame |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 508 | // 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 |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 511 | static void loopTimer(int input_timeout_ms) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 512 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 513 | static timespec lastCall; |
| 514 | static int initialized = 0; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 515 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 516 | if (!initialized) |
Dees_Troy | c8b199c | 2012-09-24 11:55:07 -0400 | [diff] [blame] | 517 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 518 | clock_gettime(CLOCK_MONOTONIC, &lastCall); |
| 519 | initialized = 1; |
| 520 | return; |
Dees_Troy | c8b199c | 2012-09-24 11:55:07 -0400 | [diff] [blame] | 521 | } |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 522 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 523 | do |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 524 | { |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 525 | bool got_event = input_handler.processInput(input_timeout_ms); // get inputs but don't send drag notices |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 526 | timespec curTime; |
| 527 | clock_gettime(CLOCK_MONOTONIC, &curTime); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 528 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 529 | timespec diff = TWFunc::timespec_diff(lastCall, curTime); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 530 | |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 531 | // 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 bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 536 | { |
that | c5837f3 | 2015-02-01 01:59:43 +0100 | [diff] [blame] | 537 | // int32_t input_time = TWFunc::timespec_diff_ms(lastCall, curTime); |
| 538 | // LOGINFO("loopTimer(): %u ms, count: %u\n", input_time, count); |
| 539 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 540 | lastCall = curTime; |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 541 | input_handler.handleDrag(); // send only drag notices if needed |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 542 | return; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 543 | } |
| 544 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 545 | // We need to sleep some period time microseconds |
Ethan Yonker | e13fa63 | 2015-01-27 11:30:03 -0600 | [diff] [blame] | 546 | //unsigned int sleepTime = 33333 -(diff.tv_nsec / 1000); |
| 547 | //usleep(sleepTime); // removed so we can scan for input |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 548 | input_timeout_ms = 0; |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 549 | } while (1); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 550 | } |
| 551 | |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 552 | static int runPages(const char *page_name, const int stop_on_page_done) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 553 | { |
Ethan Yonker | 3f15be4 | 2015-02-09 09:39:47 -0600 | [diff] [blame] | 554 | DataManager::SetValue("tw_page_done", 0); |
| 555 | DataManager::SetValue("tw_gui_done", 0); |
| 556 | |
Ethan Yonker | afde098 | 2016-01-23 08:55:35 -0600 | [diff] [blame] | 557 | if (page_name) { |
| 558 | PageManager::SetStartPage(page_name); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 559 | gui_changePage(page_name); |
Ethan Yonker | afde098 | 2016-01-23 08:55:35 -0600 | [diff] [blame] | 560 | } |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 561 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 562 | gGuiRunning = 1; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 563 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 564 | DataManager::SetValue("tw_loaded", 1); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 565 | |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 566 | struct timeval timeout; |
| 567 | fd_set fdset; |
| 568 | int has_data = 0; |
Vojtech Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 569 | |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 570 | int input_timeout_ms = 0; |
| 571 | int idle_frames = 0; |
| 572 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 573 | for (;;) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 574 | { |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 575 | loopTimer(input_timeout_ms); |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 576 | FD_ZERO(&fdset); |
| 577 | timeout.tv_sec = 0; |
| 578 | timeout.tv_usec = 1; |
that | 1964d19 | 2016-01-07 00:41:03 +0100 | [diff] [blame] | 579 | if (g_pty_fd > 0) { |
that | 1964d19 | 2016-01-07 00:41:03 +0100 | [diff] [blame] | 580 | FD_SET(g_pty_fd, &fdset); |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 581 | } |
| 582 | if (PartitionManager.uevent_pfd.fd > 0) { |
| 583 | FD_SET(PartitionManager.uevent_pfd.fd, &fdset); |
that | 1964d19 | 2016-01-07 00:41:03 +0100 | [diff] [blame] | 584 | } |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 585 | #ifndef TW_OEM_BUILD |
that | 10ae24f | 2015-12-26 20:53:51 +0100 | [diff] [blame] | 586 | if (ors_read_fd > 0 && !orsout) { // orsout is non-NULL if a command is still running |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 587 | FD_SET(ors_read_fd, &fdset); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 588 | } |
| 589 | #endif |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 590 | // 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 bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 600 | |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 601 | if (!gForceRender.get_value()) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 602 | { |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 603 | int ret = PageManager::Update(); |
| 604 | if (ret == 0) |
| 605 | ++idle_frames; |
Ethan Yonker | e0f1f3b | 2015-10-27 09:49:01 -0500 | [diff] [blame] | 606 | else if (ret == -2) |
| 607 | break; // Theme reload failure |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 608 | 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 Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 612 | |
| 613 | #ifndef PRINT_RENDER_TIME |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 614 | if (ret > 1) |
| 615 | PageManager::Render(); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 616 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 617 | if (ret > 0) |
| 618 | flip(); |
Vojtech Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 619 | #else |
| 620 | if (ret > 1) |
| 621 | { |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 622 | timespec start, end; |
| 623 | int32_t render_t, flip_t; |
Vojtech Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 624 | 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 | } |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 635 | else if (ret > 0) |
Vojtech Bocek | e5ffcd1 | 2014-02-06 21:17:32 +0100 | [diff] [blame] | 636 | flip(); |
| 637 | #endif |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 638 | } |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 639 | else |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 640 | { |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 641 | gForceRender.set_value(0); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 642 | PageManager::Render(); |
| 643 | flip(); |
that | de72b6d | 2015-02-08 08:55:00 +0100 | [diff] [blame] | 644 | input_timeout_ms = 0; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 645 | } |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 646 | |
that | fb759d4 | 2015-01-11 12:16:53 +0100 | [diff] [blame] | 647 | blankTimer.checkForTimeout(); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 648 | if (stop_on_page_done && DataManager::GetIntValue("tw_page_done") != 0) |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 649 | { |
| 650 | gui_changePage("main"); |
Dees_Troy | 6ef6635 | 2013-02-21 08:26:57 -0600 | [diff] [blame] | 651 | break; |
| 652 | } |
bigbiff | df8436b | 2020-08-30 16:22:34 -0400 | [diff] [blame] | 653 | if (DataManager::GetIntValue("tw_gui_done") != 0) { |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 654 | break; |
bigbiff | df8436b | 2020-08-30 16:22:34 -0400 | [diff] [blame] | 655 | } |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 656 | } |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 657 | if (ors_read_fd > 0) |
| 658 | close(ors_read_fd); |
| 659 | ors_read_fd = -1; |
Ethan Yonker | 6e8c27a | 2016-12-22 17:55:57 -0600 | [diff] [blame] | 660 | set_select_fd(); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 661 | gGuiRunning = 0; |
| 662 | return 0; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 663 | } |
| 664 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 665 | int gui_forceRender(void) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 666 | { |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 667 | gForceRender.set_value(1); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 668 | return 0; |
| 669 | } |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 670 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 671 | int gui_changePage(std::string newPage) |
| 672 | { |
| 673 | LOGINFO("Set page: '%s'\n", newPage.c_str()); |
| 674 | PageManager::ChangePage(newPage); |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 675 | gForceRender.set_value(1); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 676 | return 0; |
| 677 | } |
| 678 | |
| 679 | int gui_changeOverlay(std::string overlay) |
| 680 | { |
Ethan Yonker | 1c27331 | 2015-03-16 12:18:56 -0500 | [diff] [blame] | 681 | LOGINFO("Set overlay: '%s'\n", overlay.c_str()); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 682 | PageManager::ChangeOverlay(overlay); |
Ethan Yonker | 0453695 | 2015-01-27 08:41:28 -0600 | [diff] [blame] | 683 | gForceRender.set_value(1); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 684 | return 0; |
| 685 | } |
| 686 | |
that | b2e8f67 | 2015-03-05 20:25:39 +0100 | [diff] [blame] | 687 | std::string gui_parse_text(std::string str) |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 688 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 689 | // This function parses text for DataManager values encompassed by %value% in the XML |
that | b2e8f67 | 2015-03-05 20:25:39 +0100 | [diff] [blame] | 690 | // and string resources (%@resource_name%) |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 691 | size_t pos = 0, next, end; |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 692 | |
| 693 | while (1) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 694 | { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 695 | 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 Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 720 | if (next == std::string::npos) |
| 721 | return str; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 722 | |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 723 | end = str.find('%', next + 1); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 724 | if (end == std::string::npos) |
| 725 | return str; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 726 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 727 | // We have a block of data |
that | b2e8f67 | 2015-03-05 20:25:39 +0100 | [diff] [blame] | 728 | std::string var = str.substr(next + 1, (end - next) - 1); |
| 729 | str.erase(next, (end - next) + 1); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 730 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 731 | if (next + 1 == end) |
| 732 | str.insert(next, 1, '%'); |
| 733 | else |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 734 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 735 | std::string value; |
that | b2e8f67 | 2015-03-05 20:25:39 +0100 | [diff] [blame] | 736 | 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 Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 742 | str.insert(next, value); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 743 | } |
| 744 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 745 | pos = next + 1; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 746 | } |
| 747 | } |
| 748 | |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 749 | std::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 Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 753 | extern "C" int gui_init(void) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 754 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 755 | gr_init(); |
Matt Mower | b26c116 | 2016-02-03 21:05:57 -0600 | [diff] [blame] | 756 | TWFunc::Set_Brightness(DataManager::GetStrValue("tw_brightness")); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 757 | |
Sean hoyt | c387622 | 2018-07-15 06:16:09 +0200 | [diff] [blame] | 758 | #ifdef TW_SCREEN_BLANK_ON_BOOT |
| 759 | printf("TW_SCREEN_BLANK_ON_BOOT := true\n"); |
| 760 | blankTimer.blank(); |
| 761 | blankTimer.resetTimerAndUnblank(); |
| 762 | #endif |
| 763 | |
that | 235c648 | 2016-01-24 21:59:00 +0100 | [diff] [blame] | 764 | // load and show splash screen |
| 765 | if (PageManager::LoadPackage("splash", TWRES "splash.xml", "splash")) { |
| 766 | LOGERR("Failed to load splash screen XML.\n"); |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 767 | } |
that | 235c648 | 2016-01-24 21:59:00 +0100 | [diff] [blame] | 768 | else { |
| 769 | PageManager::SelectPackage("splash"); |
| 770 | PageManager::Render(); |
| 771 | flip(); |
| 772 | PageManager::ReleasePackage("splash"); |
Ethan Yonker | 63e414f | 2015-02-06 15:44:39 -0600 | [diff] [blame] | 773 | } |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 774 | |
bigbiff | 1f78066 | 2020-06-26 16:14:32 -0400 | [diff] [blame] | 775 | #ifdef TW_DELAY_TOUCH_INIT_MS |
| 776 | usleep(TW_DELAY_TOUCH_INIT_MS); |
| 777 | #endif |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 778 | ev_init(); |
| 779 | return 0; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 780 | } |
| 781 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 782 | extern "C" int gui_loadResources(void) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 783 | { |
Ethan Yonker | 83e8257 | 2014-04-04 10:59:28 -0500 | [diff] [blame] | 784 | #ifndef TW_OEM_BUILD |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 785 | int check = 0; |
| 786 | DataManager::GetValue(TW_IS_ENCRYPTED, check); |
| 787 | if (check) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 788 | { |
Dees Troy | 3454ade | 2015-01-20 19:21:04 +0000 | [diff] [blame] | 789 | if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "decrypt")) |
Dees_Troy | 5bf4392 | 2012-09-07 16:07:55 -0400 | [diff] [blame] | 790 | { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 791 | gui_err("base_pkg_err=Failed to load base packages."); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 792 | goto error; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 793 | } |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 794 | else |
| 795 | check = 1; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 796 | } |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 797 | |
Ethan Yonker | 86404bd | 2016-03-31 08:01:05 -0500 | [diff] [blame] | 798 | if (check == 0) |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 799 | { |
| 800 | std::string theme_path; |
| 801 | |
| 802 | theme_path = DataManager::GetSettingsStoragePath(); |
| 803 | if (!PartitionManager.Mount_Settings_Storage(false)) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 804 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 805 | int retry_count = 5; |
| 806 | while (retry_count > 0 && !PartitionManager.Mount_Settings_Storage(false)) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 807 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 808 | usleep(500000); |
| 809 | retry_count--; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 810 | } |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 811 | |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 812 | if (!PartitionManager.Mount_Settings_Storage(true)) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 813 | { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 814 | LOGINFO("Unable to mount %s during GUI startup.\n", theme_path.c_str()); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 815 | check = 1; |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 816 | } |
| 817 | } |
| 818 | |
Fernando Oliveira | fe7fa6b | 2023-01-12 16:12:55 -0300 | [diff] [blame] | 819 | theme_path += TWFunc::Check_For_TwrpFolder() + "/theme/ui.zip"; |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 820 | if (check || PageManager::LoadPackage("TWRP", theme_path, "main")) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 821 | { |
Ethan Yonker | 83e8257 | 2014-04-04 10:59:28 -0500 | [diff] [blame] | 822 | #endif // ifndef TW_OEM_BUILD |
Dees Troy | 3454ade | 2015-01-20 19:21:04 +0000 | [diff] [blame] | 823 | if (PageManager::LoadPackage("TWRP", TWRES "ui.xml", "main")) |
bigbiff bigbiff | 8a68c31 | 2013-02-10 14:28:30 -0500 | [diff] [blame] | 824 | { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 825 | gui_err("base_pkg_err=Failed to load base packages."); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 826 | goto error; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 827 | } |
Ethan Yonker | 83e8257 | 2014-04-04 10:59:28 -0500 | [diff] [blame] | 828 | #ifndef TW_OEM_BUILD |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 829 | } |
| 830 | } |
Ethan Yonker | 83e8257 | 2014-04-04 10:59:28 -0500 | [diff] [blame] | 831 | #endif // ifndef TW_OEM_BUILD |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 832 | // Set the default package |
| 833 | PageManager::SelectPackage("TWRP"); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 834 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 835 | gGuiInitialized = 1; |
| 836 | return 0; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 837 | |
| 838 | error: |
Ethan Yonker | 83e8257 | 2014-04-04 10:59:28 -0500 | [diff] [blame] | 839 | LOGERR("An internal error has occurred: unable to load theme.\n"); |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 840 | gGuiInitialized = 0; |
| 841 | return -1; |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 842 | } |
| 843 | |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 844 | extern "C" int gui_loadCustomResources(void) |
| 845 | { |
| 846 | #ifndef TW_OEM_BUILD |
| 847 | if (!PartitionManager.Mount_Settings_Storage(false)) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 848 | LOGINFO("Unable to mount settings storage during GUI startup.\n"); |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 849 | return -1; |
| 850 | } |
| 851 | |
| 852 | std::string theme_path = DataManager::GetSettingsStoragePath(); |
Fernando Oliveira | fe7fa6b | 2023-01-12 16:12:55 -0300 | [diff] [blame] | 853 | theme_path += TWFunc::Check_For_TwrpFolder() + "/theme/ui.zip"; |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 854 | // 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 Troy | 3454ade | 2015-01-20 19:21:04 +0000 | [diff] [blame] | 859 | if (PageManager::ReloadPackage("TWRP", TWRES "ui.xml")) { |
Ethan Yonker | 74db157 | 2015-10-28 12:44:49 -0500 | [diff] [blame] | 860 | gui_err("base_pkg_err=Failed to load base packages."); |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 861 | goto error; |
| 862 | } |
| 863 | } |
| 864 | } |
| 865 | // Set the default package |
| 866 | PageManager::SelectPackage("TWRP"); |
| 867 | #endif |
| 868 | return 0; |
| 869 | |
Patrick Zacharias | 0edce1a | 2020-06-06 16:02:58 +0200 | [diff] [blame] | 870 | #ifndef TW_OEM_BUILD |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 871 | error: |
| 872 | LOGERR("An internal error has occurred: unable to load theme.\n"); |
| 873 | gGuiInitialized = 0; |
| 874 | return -1; |
Patrick Zacharias | 0edce1a | 2020-06-06 16:02:58 +0200 | [diff] [blame] | 875 | #endif |
Ethan Yonker | cf50da5 | 2015-01-12 21:59:07 -0600 | [diff] [blame] | 876 | } |
| 877 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 878 | extern "C" int gui_start(void) |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 879 | { |
Ethan Yonker | afde098 | 2016-01-23 08:55:35 -0600 | [diff] [blame] | 880 | return gui_startPage("main", 1, 0); |
Dees_Troy | 51a0e82 | 2012-09-05 15:24:24 -0400 | [diff] [blame] | 881 | } |
| 882 | |
Patrick Zacharias | 0edce1a | 2020-06-06 16:02:58 +0200 | [diff] [blame] | 883 | extern "C" int gui_startPage(const char *page_name, __attribute__((unused)) const int allow_commands, int stop_on_page_done) |
Dees_Troy | 4bc09ae | 2013-01-18 17:00:54 +0000 | [diff] [blame] | 884 | { |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 885 | if (!gGuiInitialized) |
| 886 | return -1; |
Dees_Troy | 4bc09ae | 2013-01-18 17:00:54 +0000 | [diff] [blame] | 887 | |
Vojtech Bocek | fafb0c5 | 2013-07-25 22:53:02 +0200 | [diff] [blame] | 888 | // Set the default package |
| 889 | PageManager::SelectPackage("TWRP"); |
| 890 | |
that | 9fa5153 | 2015-01-29 02:04:47 +0100 | [diff] [blame] | 891 | input_handler.init(); |
Ethan Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 892 | #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 Yonker | fd0439e | 2015-01-14 11:08:13 -0600 | [diff] [blame] | 904 | return runPages(page_name, stop_on_page_done); |
Dees_Troy | 4bc09ae | 2013-01-18 17:00:54 +0000 | [diff] [blame] | 905 | } |
| 906 | |
Ethan Yonker | 63e414f | 2015-02-06 15:44:39 -0600 | [diff] [blame] | 907 | |
| 908 | extern "C" void set_scale_values(float w, float h) |
| 909 | { |
| 910 | scale_theme_w = w; |
| 911 | scale_theme_h = h; |
| 912 | } |
| 913 | |
| 914 | extern "C" int scale_theme_x(int initial_x) |
| 915 | { |
| 916 | if (scale_theme_w != 1) { |
that | ba75a0e | 2015-02-14 21:20:10 +0100 | [diff] [blame] | 917 | int scaled = (float)initial_x * scale_theme_w; |
| 918 | if (scaled == 0 && initial_x > 0) |
| 919 | return 1; |
| 920 | return scaled; |
Ethan Yonker | 63e414f | 2015-02-06 15:44:39 -0600 | [diff] [blame] | 921 | } |
| 922 | return initial_x; |
| 923 | } |
| 924 | |
| 925 | extern "C" int scale_theme_y(int initial_y) |
| 926 | { |
| 927 | if (scale_theme_h != 1) { |
that | ba75a0e | 2015-02-14 21:20:10 +0100 | [diff] [blame] | 928 | int scaled = (float)initial_y * scale_theme_h; |
| 929 | if (scaled == 0 && initial_y > 0) |
| 930 | return 1; |
| 931 | return scaled; |
Ethan Yonker | 63e414f | 2015-02-06 15:44:39 -0600 | [diff] [blame] | 932 | } |
| 933 | return initial_y; |
| 934 | } |
| 935 | |
| 936 | extern "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 | |
| 947 | extern "C" float get_scale_w() |
| 948 | { |
| 949 | return scale_theme_w; |
| 950 | } |
| 951 | |
| 952 | extern "C" float get_scale_h() |
| 953 | { |
| 954 | return scale_theme_h; |
| 955 | } |