blob: 047dc6267d67bb6247a038b2a8064ca0298f1f5a [file] [log] [blame]
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001/*
Dees_Troya13d74f2013-03-24 08:54:55 -05002 Copyright 2013 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 <stdarg.h>
20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23#include <fcntl.h>
24#include <sys/stat.h>
25#include <sys/time.h>
26#include <sys/mman.h>
27#include <sys/types.h>
28#include <sys/ioctl.h>
29#include <linux/input.h>
30#include <time.h>
31#include <unistd.h>
32#include <stdlib.h>
Dees_Troy657c3092012-09-10 20:32:10 -040033#include <sys/wait.h>
Dees_Troy83bd4832013-05-04 12:39:56 +000034#include <dirent.h>
Matt Mower0c88b842017-01-15 16:00:49 -060035#include <private/android_filesystem_config.h>
bigbiffdf8436b2020-08-30 16:22:34 -040036#include <android-base/properties.h>
Fernando Oliveira25062d72023-02-01 12:52:32 -030037#include <fstream>
Dees_Troy51a0e822012-09-05 15:24:24 -040038
39#include <string>
40#include <sstream>
41#include "../partitions.hpp"
Dees_Troy38bd7602012-09-14 13:33:53 -040042#include "../twrp-functions.hpp"
bigbiffad58e1b2020-07-06 20:24:34 -040043#include "../twrpRepacker.hpp"
Dees_Troy812660f2012-09-20 09:55:17 -040044#include "../openrecoveryscript.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040045
bigbiff1f9e4842020-10-31 11:33:15 -040046#include "twinstall/adb_install.h"
bigbiffd58ba182020-03-23 10:02:29 -040047
48#include "fuse_sideload.h"
bigbiff bigbiff8a68c312013-02-10 14:28:30 -050049#include "blanktimer.hpp"
bigbiff1f9e4842020-10-31 11:33:15 -040050#include "twinstall.h"
Ethan Yonkerfbb43532015-12-28 21:54:50 +010051
Dees_Troy51a0e822012-09-05 15:24:24 -040052extern "C" {
Dees_Troy2673cec2013-04-02 20:22:16 +000053#include "../twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040054#include "../variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000055#include "cutils/properties.h"
bigbiff673c7ae2020-12-02 19:44:56 -050056#include "twinstall/adb_install.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040057};
bigbiffd58ba182020-03-23 10:02:29 -040058#include "set_metadata.h"
bigbiffd81833a2021-01-17 11:06:57 -050059#include "minuitwrp/minui.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040060
61#include "rapidxml.hpp"
62#include "objects.hpp"
bigbiffd58ba182020-03-23 10:02:29 -040063#include "tw_atomic.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040064
that3f7b1ac2014-12-30 11:30:13 +010065GUIAction::mapFunc GUIAction::mf;
thatc6085482015-01-09 22:12:43 +010066std::set<string> GUIAction::setActionsRunningInCallerThread;
that3f7b1ac2014-12-30 11:30:13 +010067static string zip_queue[10];
68static int zip_queue_index;
thatcc8ddca2015-01-03 01:59:36 +010069pid_t sideload_child_pid;
Noah Jacobson81d638d2019-04-28 00:10:07 -040070extern std::vector<users_struct> Users_List;
Mohd Faraz77bbeb02020-08-12 12:29:42 +000071extern GUITerminal* term;
that3f7b1ac2014-12-30 11:30:13 +010072
that73a52952015-01-28 23:07:34 +010073static void *ActionThread_work_wrapper(void *data);
74
75class ActionThread
76{
77public:
78 ActionThread();
79 ~ActionThread();
80
81 void threadActions(GUIAction *act);
82 void run(void *data);
83private:
84 friend void *ActionThread_work_wrapper(void*);
85 struct ThreadData
86 {
87 ActionThread *this_;
88 GUIAction *act;
89 ThreadData(ActionThread *this_, GUIAction *act) : this_(this_), act(act) {}
90 };
91
92 pthread_t m_thread;
93 bool m_thread_running;
94 pthread_mutex_t m_act_lock;
95};
96
97static ActionThread action_thread; // for all kinds of longer running actions
98static ActionThread cancel_thread; // for longer running "cancel" actions
thatc6085482015-01-09 22:12:43 +010099
100static void *ActionThread_work_wrapper(void *data)
101{
that73a52952015-01-28 23:07:34 +0100102 static_cast<ActionThread::ThreadData*>(data)->this_->run(data);
thatc6085482015-01-09 22:12:43 +0100103 return NULL;
104}
105
106ActionThread::ActionThread()
107{
108 m_thread_running = false;
109 pthread_mutex_init(&m_act_lock, NULL);
110}
111
112ActionThread::~ActionThread()
113{
114 pthread_mutex_lock(&m_act_lock);
Matt Mowera8a89d12016-12-30 18:10:37 -0600115 if (m_thread_running) {
thatc6085482015-01-09 22:12:43 +0100116 pthread_mutex_unlock(&m_act_lock);
117 pthread_join(m_thread, NULL);
118 } else {
119 pthread_mutex_unlock(&m_act_lock);
120 }
121 pthread_mutex_destroy(&m_act_lock);
122}
123
that7d3b54f2015-01-09 22:52:51 +0100124void ActionThread::threadActions(GUIAction *act)
thatc6085482015-01-09 22:12:43 +0100125{
126 pthread_mutex_lock(&m_act_lock);
127 if (m_thread_running) {
128 pthread_mutex_unlock(&m_act_lock);
that7d3b54f2015-01-09 22:52:51 +0100129 LOGERR("Another threaded action is already running -- not running %u actions starting with '%s'\n",
130 act->mActions.size(), act->mActions[0].mFunction.c_str());
thatc6085482015-01-09 22:12:43 +0100131 } else {
132 m_thread_running = true;
133 pthread_mutex_unlock(&m_act_lock);
that73a52952015-01-28 23:07:34 +0100134 ThreadData *d = new ThreadData(this, act);
thatc6085482015-01-09 22:12:43 +0100135 pthread_create(&m_thread, NULL, &ActionThread_work_wrapper, d);
136 }
137}
138
139void ActionThread::run(void *data)
140{
141 ThreadData *d = (ThreadData*)data;
142 GUIAction* act = d->act;
143
144 std::vector<GUIAction::Action>::iterator it;
that7d3b54f2015-01-09 22:52:51 +0100145 for (it = act->mActions.begin(); it != act->mActions.end(); ++it)
thatc6085482015-01-09 22:12:43 +0100146 act->doAction(*it);
147
148 pthread_mutex_lock(&m_act_lock);
149 m_thread_running = false;
150 pthread_mutex_unlock(&m_act_lock);
151 delete d;
152}
153
Dees_Troy51a0e822012-09-05 15:24:24 -0400154GUIAction::GUIAction(xml_node<>* node)
Vojtech Bocekede51c52014-02-07 23:58:09 +0100155 : GUIObject(node)
Dees_Troy51a0e822012-09-05 15:24:24 -0400156{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200157 xml_node<>* child;
158 xml_node<>* actions;
159 xml_attribute<>* attr;
Dees_Troy51a0e822012-09-05 15:24:24 -0400160
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200161 if (!node) return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400162
that3f7b1ac2014-12-30 11:30:13 +0100163 if (mf.empty()) {
Vojtech Bocekecd89182015-01-15 16:28:54 +0100164#define ADD_ACTION(n) mf[#n] = &GUIAction::n
165#define ADD_ACTION_EX(name, func) mf[name] = &GUIAction::func
thatc6085482015-01-09 22:12:43 +0100166 // These actions will be run in the caller's thread
Vojtech Bocekecd89182015-01-15 16:28:54 +0100167 ADD_ACTION(reboot);
168 ADD_ACTION(home);
169 ADD_ACTION(key);
170 ADD_ACTION(page);
171 ADD_ACTION(reload);
172 ADD_ACTION(readBackup);
173 ADD_ACTION(set);
174 ADD_ACTION(clear);
175 ADD_ACTION(mount);
176 ADD_ACTION(unmount);
177 ADD_ACTION_EX("umount", unmount);
178 ADD_ACTION(restoredefaultsettings);
179 ADD_ACTION(copylog);
180 ADD_ACTION(compute);
181 ADD_ACTION_EX("addsubtract", compute);
182 ADD_ACTION(setguitimezone);
183 ADD_ACTION(overlay);
184 ADD_ACTION(queuezip);
185 ADD_ACTION(cancelzip);
186 ADD_ACTION(queueclear);
187 ADD_ACTION(sleep);
Matt Mower9a2a2052016-05-31 21:31:22 -0500188 ADD_ACTION(sleepcounter);
Vojtech Bocekecd89182015-01-15 16:28:54 +0100189 ADD_ACTION(appenddatetobackupname);
190 ADD_ACTION(generatebackupname);
191 ADD_ACTION(checkpartitionlist);
192 ADD_ACTION(getpartitiondetails);
193 ADD_ACTION(screenshot);
194 ADD_ACTION(setbrightness);
195 ADD_ACTION(fileexists);
196 ADD_ACTION(killterminal);
197 ADD_ACTION(checkbackupname);
198 ADD_ACTION(adbsideloadcancel);
199 ADD_ACTION(fixsu);
200 ADD_ACTION(startmtp);
201 ADD_ACTION(stopmtp);
202 ADD_ACTION(cancelbackup);
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500203 ADD_ACTION(checkpartitionlifetimewrites);
204 ADD_ACTION(mountsystemtoggle);
Ethan Yonker74db1572015-10-28 12:44:49 -0500205 ADD_ACTION(setlanguage);
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600206 ADD_ACTION(checkforapp);
Matt Mower9472ba12016-01-20 18:12:47 -0600207 ADD_ACTION(togglebacklight);
bigbiffdf8436b2020-08-30 16:22:34 -0400208 ADD_ACTION(enableadb);
209 ADD_ACTION(enablefastboot);
Mohd Faraz77bbeb02020-08-12 12:29:42 +0000210 ADD_ACTION(changeterminal);
bigbiffcfa875c2021-06-20 16:20:27 -0400211 ADD_ACTION(unmapsuperdevices);
thatc6085482015-01-09 22:12:43 +0100212
213 // remember actions that run in the caller thread
214 for (mapFunc::const_iterator it = mf.begin(); it != mf.end(); ++it)
215 setActionsRunningInCallerThread.insert(it->first);
216
217 // These actions will run in a separate thread
Vojtech Bocekecd89182015-01-15 16:28:54 +0100218 ADD_ACTION(flash);
219 ADD_ACTION(wipe);
220 ADD_ACTION(refreshsizes);
221 ADD_ACTION(nandroid);
Ethan Yonkerb5fab762016-01-28 14:03:33 -0600222 ADD_ACTION(fixcontexts);
Vojtech Bocekecd89182015-01-15 16:28:54 +0100223 ADD_ACTION(fixpermissions);
224 ADD_ACTION(dd);
225 ADD_ACTION(partitionsd);
Vojtech Bocekecd89182015-01-15 16:28:54 +0100226 ADD_ACTION(cmd);
227 ADD_ACTION(terminalcommand);
228 ADD_ACTION(reinjecttwrp);
229 ADD_ACTION(decrypt);
230 ADD_ACTION(adbsideload);
231 ADD_ACTION(openrecoveryscript);
232 ADD_ACTION(installsu);
233 ADD_ACTION(decrypt_backup);
234 ADD_ACTION(repair);
Ethan Yonkera2719152015-05-28 09:44:41 -0500235 ADD_ACTION(resize);
Vojtech Bocekecd89182015-01-15 16:28:54 +0100236 ADD_ACTION(changefilesystem);
237 ADD_ACTION(flashimage);
that10ae24f2015-12-26 20:53:51 +0100238 ADD_ACTION(twcmd);
Ethan Yonker1b190162016-12-05 15:25:19 -0600239 ADD_ACTION(setbootslot);
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600240 ADD_ACTION(installapp);
Ethan Yonker76bbd3a2019-05-10 10:50:04 -0500241 ADD_ACTION(uninstalltwrpsystemapp);
Ethan Yonker53796e72019-01-11 22:49:52 -0600242 ADD_ACTION(repackimage);
nebrassyac29e692021-05-20 13:03:30 +0200243 ADD_ACTION(reflashtwrp);
Ethan Yonker53796e72019-01-11 22:49:52 -0600244 ADD_ACTION(fixabrecoverybootloop);
epicXa721f952021-01-04 13:01:31 +0530245 ADD_ACTION(applycustomtwrpfolder);
Captain Throwback16dd81b2021-02-12 19:32:36 -0500246#ifndef TW_EXCLUDE_NANO
247 ADD_ACTION(editfile);
248#endif
bigbiffd21252f2021-09-18 15:56:32 -0400249 ADD_ACTION(mergesnapshots);
that3f7b1ac2014-12-30 11:30:13 +0100250 }
251
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200252 // First, get the action
Ethan Yonker21ff02a2015-02-18 14:35:00 -0600253 actions = FindNode(node, "actions");
254 if (actions) child = FindNode(actions, "action");
255 else child = FindNode(node, "action");
Dees_Troy51a0e822012-09-05 15:24:24 -0400256
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200257 if (!child) return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400258
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200259 while (child)
260 {
261 Action action;
Dees_Troy51a0e822012-09-05 15:24:24 -0400262
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200263 attr = child->first_attribute("function");
264 if (!attr) return;
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500265
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200266 action.mFunction = attr->value();
267 action.mArg = child->value();
268 mActions.push_back(action);
Dees_Troy51a0e822012-09-05 15:24:24 -0400269
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200270 child = child->next_sibling("action");
271 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400272
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200273 // Now, let's get either the key or region
Ethan Yonker21ff02a2015-02-18 14:35:00 -0600274 child = FindNode(node, "touch");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200275 if (child)
276 {
277 attr = child->first_attribute("key");
278 if (attr)
279 {
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100280 std::vector<std::string> keys = TWFunc::Split_String(attr->value(), "+");
Matt Mowera8a89d12016-12-30 18:10:37 -0600281 for (size_t i = 0; i < keys.size(); ++i)
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100282 {
283 const int key = getKeyByName(keys[i]);
284 mKeys[key] = false;
285 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200286 }
287 else
288 {
289 attr = child->first_attribute("x");
290 if (!attr) return;
291 mActionX = atol(attr->value());
292 attr = child->first_attribute("y");
293 if (!attr) return;
294 mActionY = atol(attr->value());
295 attr = child->first_attribute("w");
296 if (!attr) return;
297 mActionW = atol(attr->value());
298 attr = child->first_attribute("h");
299 if (!attr) return;
300 mActionH = atol(attr->value());
301 }
302 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400303}
304
Matt Mower25036b72016-06-24 12:30:18 -0500305int GUIAction::NotifyTouch(TOUCH_STATE state, int x __unused, int y __unused)
Dees_Troy51a0e822012-09-05 15:24:24 -0400306{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200307 if (state == TOUCH_RELEASE)
308 doActions();
Dees_Troy51a0e822012-09-05 15:24:24 -0400309
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200310 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400311}
312
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100313int GUIAction::NotifyKey(int key, bool down)
Dees_Troy51a0e822012-09-05 15:24:24 -0400314{
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100315 std::map<int, bool>::iterator itr = mKeys.find(key);
Matt Mowera8a89d12016-12-30 18:10:37 -0600316 if (itr == mKeys.end())
that8834a0f2016-01-05 23:29:30 +0100317 return 1;
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100318
319 bool prevState = itr->second;
320 itr->second = down;
321
322 // If there is only one key for this action, wait for key up so it
323 // doesn't trigger with multi-key actions.
324 // Else, check if all buttons are pressed, then consume their release events
325 // so they don't trigger one-button actions and reset mKeys pressed status
Matt Mowera8a89d12016-12-30 18:10:37 -0600326 if (mKeys.size() == 1) {
327 if (!down && prevState) {
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100328 doActions();
thatd4725ca2016-01-19 00:15:21 +0100329 return 0;
330 }
Matt Mowera8a89d12016-12-30 18:10:37 -0600331 } else if (down) {
332 for (itr = mKeys.begin(); itr != mKeys.end(); ++itr) {
333 if (!itr->second)
that8834a0f2016-01-05 23:29:30 +0100334 return 1;
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100335 }
336
337 // Passed, all req buttons are pressed, reset them and consume release events
338 HardwareKeyboard *kb = PageManager::GetHardwareKeyboard();
Matt Mowera8a89d12016-12-30 18:10:37 -0600339 for (itr = mKeys.begin(); itr != mKeys.end(); ++itr) {
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100340 kb->ConsumeKeyRelease(itr->first);
341 itr->second = false;
342 }
343
344 doActions();
thatd4725ca2016-01-19 00:15:21 +0100345 return 0;
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100346 }
347
thatd4725ca2016-01-19 00:15:21 +0100348 return 1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400349}
350
Vojtech Bocek07220562014-02-08 02:05:33 +0100351int GUIAction::NotifyVarChange(const std::string& varName, const std::string& value)
Dees_Troy51a0e822012-09-05 15:24:24 -0400352{
Vojtech Bocek07220562014-02-08 02:05:33 +0100353 GUIObject::NotifyVarChange(varName, value);
354
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100355 if (varName.empty() && !isConditionValid() && mKeys.empty() && !mActionW)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200356 doActions();
Matt Mowera8a89d12016-12-30 18:10:37 -0600357 else if ((varName.empty() || IsConditionVariable(varName)) && isConditionValid() && isConditionTrue())
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200358 doActions();
Dees_Troy51a0e822012-09-05 15:24:24 -0400359
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200360 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400361}
362
363void GUIAction::simulate_progress_bar(void)
364{
Ethan Yonker74db1572015-10-28 12:44:49 -0500365 gui_msg("simulating=Simulating actions...");
Dees_Troy51a0e822012-09-05 15:24:24 -0400366 for (int i = 0; i < 5; i++)
367 {
bigbiff7abc5fe2015-01-17 16:53:12 -0500368 if (PartitionManager.stop_backup.get_value()) {
369 DataManager::SetValue("tw_cancel_backup", 1);
Matt Mower3c366972015-12-25 19:28:31 -0600370 gui_msg("backup_cancel=Backup Cancelled");
bigbiff7abc5fe2015-01-17 16:53:12 -0500371 DataManager::SetValue("ui_progress", 0);
372 PartitionManager.stop_backup.set_value(0);
373 return;
374 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400375 usleep(500000);
376 DataManager::SetValue("ui_progress", i * 20);
377 }
378}
379
Ethan Yonker0d47eb52015-01-09 11:23:19 -0600380int GUIAction::flash_zip(std::string filename, int* wipe_cache)
Dees_Troy51a0e822012-09-05 15:24:24 -0400381{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200382 int ret_val = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400383
384 DataManager::SetValue("ui_progress", 0);
Chaosmasterd5364a02020-02-03 15:38:02 +0100385 DataManager::SetValue("ui_portion_size", 0);
386 DataManager::SetValue("ui_portion_start", 0);
Dees_Troy51a0e822012-09-05 15:24:24 -0400387
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200388 if (filename.empty())
389 {
390 LOGERR("No file specified.\n");
391 return -1;
392 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400393
Ethan Yonker9598c072016-01-15 21:54:34 -0600394 if (!TWFunc::Path_Exists(filename)) {
395 if (!PartitionManager.Mount_By_Path(filename, true)) {
396 return -1;
397 }
398 if (!TWFunc::Path_Exists(filename)) {
399 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")(filename));
400 return -1;
401 }
402 }
Dees_Troy657c3092012-09-10 20:32:10 -0400403
Dees_Troy51a0e822012-09-05 15:24:24 -0400404 if (simulate) {
405 simulate_progress_bar();
406 } else {
bigbiffab036612021-06-24 21:31:40 -0400407 char apex_enabled[PROPERTY_VALUE_MAX];
408 property_get("twrp.apex.flattened", apex_enabled, "");
409 if (strcmp(apex_enabled, "true") == 0) {
410 umount("/apex");
411 }
epicX9597b842021-03-20 21:58:17 +0530412 ret_val = TWinstall_zip(filename.c_str(), wipe_cache, (bool) !DataManager::GetIntValue(TW_SKIP_DIGEST_CHECK_ZIP_VAR));
bigbiff1f9e4842020-10-31 11:33:15 -0400413 PartitionManager.Unlock_Block_Partitions();
Dees_Troy51a0e822012-09-05 15:24:24 -0400414 // Now, check if we need to ensure TWRP remains installed...
415 struct stat st;
bigbiffad58e1b2020-07-06 20:24:34 -0400416 if (stat("/system/bin/installTwrp", &st) == 0)
Dees_Troy51a0e822012-09-05 15:24:24 -0400417 {
418 DataManager::SetValue("tw_operation", "Configuring TWRP");
419 DataManager::SetValue("tw_partition", "");
Ethan Yonker74db1572015-10-28 12:44:49 -0500420 gui_msg("config_twrp=Configuring TWRP...");
bigbiffad58e1b2020-07-06 20:24:34 -0400421 if (TWFunc::Exec_Cmd("/system/bin/installTwrp reinstall") < 0)
Dees_Troy51a0e822012-09-05 15:24:24 -0400422 {
Ethan Yonker74db1572015-10-28 12:44:49 -0500423 gui_msg("config_twrp_err=Unable to configure TWRP with this kernel.");
Dees_Troy51a0e822012-09-05 15:24:24 -0400424 }
425 }
426 }
427
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200428 // Done
429 DataManager::SetValue("ui_progress", 100);
430 DataManager::SetValue("ui_progress", 0);
Chaosmasterd5364a02020-02-03 15:38:02 +0100431 DataManager::SetValue("ui_portion_size", 0);
432 DataManager::SetValue("ui_portion_start", 0);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200433 return ret_val;
Dees_Troy51a0e822012-09-05 15:24:24 -0400434}
435
that73a52952015-01-28 23:07:34 +0100436GUIAction::ThreadType GUIAction::getThreadType(const GUIAction::Action& action)
thatc6085482015-01-09 22:12:43 +0100437{
that73a52952015-01-28 23:07:34 +0100438 string func = gui_parse_text(action.mFunction);
439 bool needsThread = setActionsRunningInCallerThread.find(func) == setActionsRunningInCallerThread.end();
440 if (needsThread) {
441 if (func == "cancelbackup")
442 return THREAD_CANCEL;
443 else
444 return THREAD_ACTION;
445 }
446 return THREAD_NONE;
thatc6085482015-01-09 22:12:43 +0100447}
448
Dees_Troy51a0e822012-09-05 15:24:24 -0400449int GUIAction::doActions()
450{
that3f7b1ac2014-12-30 11:30:13 +0100451 if (mActions.size() < 1)
452 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400453
that73a52952015-01-28 23:07:34 +0100454 // Determine in which thread to run the actions.
455 // Do it for all actions at once before starting, so that we can cancel the whole batch if the thread is already busy.
456 ThreadType threadType = THREAD_NONE;
that3f7b1ac2014-12-30 11:30:13 +0100457 std::vector<Action>::iterator it;
that73a52952015-01-28 23:07:34 +0100458 for (it = mActions.begin(); it != mActions.end(); ++it) {
459 ThreadType tt = getThreadType(*it);
460 if (tt == THREAD_NONE)
461 continue;
462 if (threadType == THREAD_NONE)
463 threadType = tt;
464 else if (threadType != tt) {
465 LOGERR("Can't mix normal and cancel actions in the same list.\n"
466 "Running the whole batch in the cancel thread.\n");
467 threadType = THREAD_CANCEL;
thatc6085482015-01-09 22:12:43 +0100468 break;
469 }
that7d3b54f2015-01-09 22:52:51 +0100470 }
that73a52952015-01-28 23:07:34 +0100471
472 // Now run the actions in the desired thread.
473 switch (threadType) {
474 case THREAD_ACTION:
475 action_thread.threadActions(this);
476 break;
477
478 case THREAD_CANCEL:
479 cancel_thread.threadActions(this);
480 break;
481
482 default: {
483 // no iterators here because theme reloading might kill our object
484 const size_t cnt = mActions.size();
485 for (size_t i = 0; i < cnt; ++i)
486 doAction(mActions[i]);
487 }
thatc6085482015-01-09 22:12:43 +0100488 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400489
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200490 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400491}
492
that3f7b1ac2014-12-30 11:30:13 +0100493int GUIAction::doAction(Action action)
Dees_Troy51a0e822012-09-05 15:24:24 -0400494{
that3f7b1ac2014-12-30 11:30:13 +0100495 DataManager::GetValue(TW_SIMULATE_ACTIONS, simulate);
Dees_Troy51a0e822012-09-05 15:24:24 -0400496
that3f7b1ac2014-12-30 11:30:13 +0100497 std::string function = gui_parse_text(action.mFunction);
498 std::string arg = gui_parse_text(action.mArg);
Dees_Troy51a0e822012-09-05 15:24:24 -0400499
that3f7b1ac2014-12-30 11:30:13 +0100500 // find function and execute it
501 mapFunc::const_iterator funcitr = mf.find(function);
502 if (funcitr != mf.end())
503 return (this->*funcitr->second)(arg);
504
505 LOGERR("Unknown action '%s'\n", function.c_str());
506 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400507}
508
509void GUIAction::operation_start(const string operation_name)
510{
that3f7b1ac2014-12-30 11:30:13 +0100511 LOGINFO("operation_start: '%s'\n", operation_name.c_str());
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +0000512 time(&Start);
Dees_Troy51a0e822012-09-05 15:24:24 -0400513 DataManager::SetValue(TW_ACTION_BUSY, 1);
514 DataManager::SetValue("ui_progress", 0);
Chaosmasterd5364a02020-02-03 15:38:02 +0100515 DataManager::SetValue("ui_portion_size", 0);
516 DataManager::SetValue("ui_portion_start", 0);
Dees_Troy51a0e822012-09-05 15:24:24 -0400517 DataManager::SetValue("tw_operation", operation_name);
Dees_Troy51a0e822012-09-05 15:24:24 -0400518 DataManager::SetValue("tw_operation_state", 0);
Ethan Yonkerd83c9ea2015-01-02 15:22:31 -0600519 DataManager::SetValue("tw_operation_status", 0);
bigbiff25d25b92020-06-19 16:07:38 -0400520 bool tw_ab_device = TWFunc::get_log_dir() != CACHE_LOGS_DIR;
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500521 DataManager::SetValue("tw_ab_device", tw_ab_device);
Dees_Troy51a0e822012-09-05 15:24:24 -0400522}
523
that3f7b1ac2014-12-30 11:30:13 +0100524void GUIAction::operation_end(const int operation_status)
Dees_Troy51a0e822012-09-05 15:24:24 -0400525{
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +0000526 time_t Stop;
Dees_Troy51a0e822012-09-05 15:24:24 -0400527 int simulate_fail;
Dees_Troy51a0e822012-09-05 15:24:24 -0400528 DataManager::SetValue("ui_progress", 100);
529 if (simulate) {
530 DataManager::GetValue(TW_SIMULATE_FAIL, simulate_fail);
531 if (simulate_fail != 0)
532 DataManager::SetValue("tw_operation_status", 1);
533 else
534 DataManager::SetValue("tw_operation_status", 0);
535 } else {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500536 if (operation_status != 0) {
Dees_Troy51a0e822012-09-05 15:24:24 -0400537 DataManager::SetValue("tw_operation_status", 1);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500538 }
539 else {
Dees_Troy51a0e822012-09-05 15:24:24 -0400540 DataManager::SetValue("tw_operation_status", 0);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500541 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400542 }
543 DataManager::SetValue("tw_operation_state", 1);
544 DataManager::SetValue(TW_ACTION_BUSY, 0);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500545 blankTimer.resetTimerAndUnblank();
LuK133762326f42015-09-30 19:57:46 +0200546 property_set("twrp.action_complete", "1");
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +0000547 time(&Stop);
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -0400548
549#ifndef TW_NO_HAPTICS
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +0000550 if ((int) difftime(Stop, Start) > 10)
Ethan Yonker03db3262014-02-05 08:02:06 -0600551 DataManager::Vibrate("tw_action_vibrate");
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -0400552#endif
553
that3f7b1ac2014-12-30 11:30:13 +0100554 LOGINFO("operation_end - status=%d\n", operation_status);
Dees_Troy51a0e822012-09-05 15:24:24 -0400555}
556
that3f7b1ac2014-12-30 11:30:13 +0100557int GUIAction::reboot(std::string arg)
Dees_Troy51a0e822012-09-05 15:24:24 -0400558{
that3f7b1ac2014-12-30 11:30:13 +0100559 sync();
560 DataManager::SetValue("tw_gui_done", 1);
561 DataManager::SetValue("tw_reboot_arg", arg);
Dees_Troy51a0e822012-09-05 15:24:24 -0400562
that3f7b1ac2014-12-30 11:30:13 +0100563 return 0;
564}
Dees_Troy51a0e822012-09-05 15:24:24 -0400565
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500566int GUIAction::home(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100567{
that3f7b1ac2014-12-30 11:30:13 +0100568 gui_changePage("main");
569 return 0;
570}
Dees_Troy51a0e822012-09-05 15:24:24 -0400571
that3f7b1ac2014-12-30 11:30:13 +0100572int GUIAction::key(std::string arg)
573{
574 const int key = getKeyByName(arg);
575 PageManager::NotifyKey(key, true);
576 PageManager::NotifyKey(key, false);
577 return 0;
578}
579
580int GUIAction::page(std::string arg)
581{
LuK133762326f42015-09-30 19:57:46 +0200582 property_set("twrp.action_complete", "0");
that3f7b1ac2014-12-30 11:30:13 +0100583 std::string page_name = gui_parse_text(arg);
584 return gui_changePage(page_name);
585}
586
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500587int GUIAction::reload(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100588{
Ethan Yonkere0f1f3b2015-10-27 09:49:01 -0500589 PageManager::RequestReload();
590 // The actual reload is handled in pages.cpp in PageManager::RunReload()
591 // The reload will occur on the next Update or Render call and will
592 // be performed in the rendoer thread instead of the action thread
593 // to prevent crashing which could occur when we start deleting
594 // GUI resources in the action thread while we attempt to render
595 // with those same resources in another thread.
that3f7b1ac2014-12-30 11:30:13 +0100596 return 0;
597}
Dees_Troy51a0e822012-09-05 15:24:24 -0400598
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500599int GUIAction::readBackup(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100600{
601 string Restore_Name;
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400602
that3f7b1ac2014-12-30 11:30:13 +0100603 DataManager::GetValue("tw_restore", Restore_Name);
604 PartitionManager.Set_Restore_Files(Restore_Name);
605 return 0;
606}
607
608int GUIAction::set(std::string arg)
609{
610 if (arg.find('=') != string::npos)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200611 {
that3f7b1ac2014-12-30 11:30:13 +0100612 string varName = arg.substr(0, arg.find('='));
613 string value = arg.substr(arg.find('=') + 1, string::npos);
Dees_Troy51a0e822012-09-05 15:24:24 -0400614
that3f7b1ac2014-12-30 11:30:13 +0100615 DataManager::GetValue(value, value);
616 DataManager::SetValue(varName, value);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200617 }
that3f7b1ac2014-12-30 11:30:13 +0100618 else
619 DataManager::SetValue(arg, "1");
620 return 0;
621}
Dees_Troy51a0e822012-09-05 15:24:24 -0400622
that3f7b1ac2014-12-30 11:30:13 +0100623int GUIAction::clear(std::string arg)
624{
625 DataManager::SetValue(arg, "0");
626 return 0;
627}
Dees_Troy51a0e822012-09-05 15:24:24 -0400628
that3f7b1ac2014-12-30 11:30:13 +0100629int GUIAction::mount(std::string arg)
630{
631 if (arg == "usb") {
632 DataManager::SetValue(TW_ACTION_BUSY, 1);
Dees_Troy51a0e822012-09-05 15:24:24 -0400633 if (!simulate)
that3f7b1ac2014-12-30 11:30:13 +0100634 PartitionManager.usb_storage_enable();
635 else
Ethan Yonker74db1572015-10-28 12:44:49 -0500636 gui_msg("simulating=Simulating actions...");
that3f7b1ac2014-12-30 11:30:13 +0100637 } else if (!simulate) {
638 PartitionManager.Mount_By_Path(arg, true);
639 PartitionManager.Add_MTP_Storage(arg);
640 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500641 gui_msg("simulating=Simulating actions...");
that3f7b1ac2014-12-30 11:30:13 +0100642 return 0;
643}
644
645int GUIAction::unmount(std::string arg)
646{
647 if (arg == "usb") {
648 if (!simulate)
649 PartitionManager.usb_storage_disable();
650 else
Ethan Yonker74db1572015-10-28 12:44:49 -0500651 gui_msg("simulating=Simulating actions...");
that3f7b1ac2014-12-30 11:30:13 +0100652 DataManager::SetValue(TW_ACTION_BUSY, 0);
653 } else if (!simulate) {
654 PartitionManager.UnMount_By_Path(arg, true);
655 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500656 gui_msg("simulating=Simulating actions...");
that3f7b1ac2014-12-30 11:30:13 +0100657 return 0;
658}
659
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500660int GUIAction::restoredefaultsettings(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100661{
662 operation_start("Restore Defaults");
663 if (simulate) // Simulated so that people don't accidently wipe out the "simulation is on" setting
Ethan Yonker74db1572015-10-28 12:44:49 -0500664 gui_msg("simulating=Simulating actions...");
that3f7b1ac2014-12-30 11:30:13 +0100665 else {
666 DataManager::ResetDefaults();
667 PartitionManager.Update_System_Details();
668 PartitionManager.Mount_Current_Storage(true);
669 }
670 operation_end(0);
671 return 0;
672}
673
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500674int GUIAction::copylog(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100675{
676 operation_start("Copy Log");
677 if (!simulate)
678 {
bigbiff bigbiffbad332a2016-07-29 21:18:13 -0400679 string dst, curr_storage;
680 int copy_kernel_log = 0;
Captain Throwback52978932021-09-05 15:11:07 -0400681 int copy_logcat = 1;
bigbiff bigbiffbad332a2016-07-29 21:18:13 -0400682
683 DataManager::GetValue("tw_include_kernel_log", copy_kernel_log);
Captain Throwback52978932021-09-05 15:11:07 -0400684 DataManager::GetValue("tw_include_logcat", copy_logcat);
that3f7b1ac2014-12-30 11:30:13 +0100685 PartitionManager.Mount_Current_Storage(true);
bigbiff bigbiffbad332a2016-07-29 21:18:13 -0400686 curr_storage = DataManager::GetCurrentStoragePath();
687 dst = curr_storage + "/recovery.log";
that3f7b1ac2014-12-30 11:30:13 +0100688 TWFunc::copy_file("/tmp/recovery.log", dst.c_str(), 0755);
689 tw_set_default_metadata(dst.c_str());
bigbiff bigbiffbad332a2016-07-29 21:18:13 -0400690 if (copy_kernel_log)
691 TWFunc::copy_kernel_log(curr_storage);
Captain Throwback52978932021-09-05 15:11:07 -0400692 if (copy_logcat)
693 TWFunc::copy_logcat(curr_storage);
that3f7b1ac2014-12-30 11:30:13 +0100694 sync();
bigbiff bigbiffbad332a2016-07-29 21:18:13 -0400695 gui_msg(Msg("copy_log=Copied recovery log to {1}")(dst));
that3f7b1ac2014-12-30 11:30:13 +0100696 } else
697 simulate_progress_bar();
698 operation_end(0);
699 return 0;
700}
701
702
703int GUIAction::compute(std::string arg)
704{
705 if (arg.find("+") != string::npos)
706 {
707 string varName = arg.substr(0, arg.find('+'));
708 string string_to_add = arg.substr(arg.find('+') + 1, string::npos);
709 int amount_to_add = atoi(string_to_add.c_str());
710 int value;
711
712 DataManager::GetValue(varName, value);
713 DataManager::SetValue(varName, value + amount_to_add);
Dees_Troy51a0e822012-09-05 15:24:24 -0400714 return 0;
715 }
that3f7b1ac2014-12-30 11:30:13 +0100716 if (arg.find("-") != string::npos)
Dees_Troy51a0e822012-09-05 15:24:24 -0400717 {
that3f7b1ac2014-12-30 11:30:13 +0100718 string varName = arg.substr(0, arg.find('-'));
719 string string_to_subtract = arg.substr(arg.find('-') + 1, string::npos);
720 int amount_to_subtract = atoi(string_to_subtract.c_str());
721 int value;
Dees_Troy51a0e822012-09-05 15:24:24 -0400722
that3f7b1ac2014-12-30 11:30:13 +0100723 DataManager::GetValue(varName, value);
724 value -= amount_to_subtract;
725 if (value <= 0)
726 value = 0;
727 DataManager::SetValue(varName, value);
728 return 0;
729 }
730 if (arg.find("*") != string::npos)
731 {
732 string varName = arg.substr(0, arg.find('*'));
733 string multiply_by_str = gui_parse_text(arg.substr(arg.find('*') + 1, string::npos));
734 int multiply_by = atoi(multiply_by_str.c_str());
735 int value;
736
737 DataManager::GetValue(varName, value);
738 DataManager::SetValue(varName, value*multiply_by);
739 return 0;
740 }
741 if (arg.find("/") != string::npos)
742 {
743 string varName = arg.substr(0, arg.find('/'));
744 string divide_by_str = gui_parse_text(arg.substr(arg.find('/') + 1, string::npos));
745 int divide_by = atoi(divide_by_str.c_str());
746 int value;
747
Matt Mowera8a89d12016-12-30 18:10:37 -0600748 if (divide_by != 0)
that3f7b1ac2014-12-30 11:30:13 +0100749 {
Dees_Troy51a0e822012-09-05 15:24:24 -0400750 DataManager::GetValue(varName, value);
that3f7b1ac2014-12-30 11:30:13 +0100751 DataManager::SetValue(varName, value/divide_by);
Dees_Troy51a0e822012-09-05 15:24:24 -0400752 }
753 return 0;
754 }
that3f7b1ac2014-12-30 11:30:13 +0100755 LOGERR("Unable to perform compute '%s'\n", arg.c_str());
756 return -1;
757}
Dees_Troy51a0e822012-09-05 15:24:24 -0400758
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500759int GUIAction::setguitimezone(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100760{
761 string SelectedZone;
762 DataManager::GetValue(TW_TIME_ZONE_GUISEL, SelectedZone); // read the selected time zone into SelectedZone
763 string Zone = SelectedZone.substr(0, SelectedZone.find(';')); // parse to get time zone
764 string DSTZone = SelectedZone.substr(SelectedZone.find(';') + 1, string::npos); // parse to get DST component
765
766 int dst;
767 DataManager::GetValue(TW_TIME_ZONE_GUIDST, dst); // check wether user chose to use DST
768
769 string offset;
770 DataManager::GetValue(TW_TIME_ZONE_GUIOFFSET, offset); // pull in offset
771
772 string NewTimeZone = Zone;
773 if (offset != "0")
774 NewTimeZone += ":" + offset;
775
776 if (dst != 0)
777 NewTimeZone += DSTZone;
778
779 DataManager::SetValue(TW_TIME_ZONE_VAR, NewTimeZone);
780 DataManager::update_tz_environment_variables();
781 return 0;
782}
783
784int GUIAction::overlay(std::string arg)
785{
786 return gui_changeOverlay(arg);
787}
788
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500789int GUIAction::queuezip(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100790{
791 if (zip_queue_index >= 10) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500792 gui_msg("max_queue=Maximum zip queue reached!");
Dees_Troy51a0e822012-09-05 15:24:24 -0400793 return 0;
794 }
that3f7b1ac2014-12-30 11:30:13 +0100795 DataManager::GetValue("tw_filename", zip_queue[zip_queue_index]);
796 if (strlen(zip_queue[zip_queue_index].c_str()) > 0) {
797 zip_queue_index++;
Dees_Troy51a0e822012-09-05 15:24:24 -0400798 DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index);
that3f7b1ac2014-12-30 11:30:13 +0100799 }
800 return 0;
801}
802
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500803int GUIAction::cancelzip(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100804{
805 if (zip_queue_index <= 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500806 gui_msg("min_queue=Minimum zip queue reached!");
Dees_Troy51a0e822012-09-05 15:24:24 -0400807 return 0;
that3f7b1ac2014-12-30 11:30:13 +0100808 } else {
809 zip_queue_index--;
810 DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index);
Dees_Troy51a0e822012-09-05 15:24:24 -0400811 }
that3f7b1ac2014-12-30 11:30:13 +0100812 return 0;
813}
Dees_Troy51a0e822012-09-05 15:24:24 -0400814
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500815int GUIAction::queueclear(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100816{
817 zip_queue_index = 0;
818 DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index);
819 return 0;
820}
Dees_Troy51a0e822012-09-05 15:24:24 -0400821
that3f7b1ac2014-12-30 11:30:13 +0100822int GUIAction::sleep(std::string arg)
823{
824 operation_start("Sleep");
825 usleep(atoi(arg.c_str()));
826 operation_end(0);
827 return 0;
828}
Dees Troyb21cc642013-09-10 17:36:41 +0000829
Matt Mower9a2a2052016-05-31 21:31:22 -0500830int GUIAction::sleepcounter(std::string arg)
831{
832 operation_start("SleepCounter");
833 // Ensure user notices countdown in case it needs to be cancelled
834 blankTimer.resetTimerAndUnblank();
835 int total = atoi(arg.c_str());
836 for (int t = total; t > 0; t--) {
837 int progress = (int)(((float)(total-t)/(float)total)*100.0);
838 DataManager::SetValue("ui_progress", progress);
839 ::sleep(1);
840 DataManager::SetValue("tw_sleep", t-1);
841 }
842 DataManager::SetValue("ui_progress", 100);
843 operation_end(0);
844 return 0;
845}
846
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500847int GUIAction::appenddatetobackupname(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100848{
849 operation_start("AppendDateToBackupName");
850 string Backup_Name;
851 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
852 Backup_Name += TWFunc::Get_Current_Date();
853 if (Backup_Name.size() > MAX_BACKUP_NAME_LEN)
854 Backup_Name.resize(MAX_BACKUP_NAME_LEN);
855 DataManager::SetValue(TW_BACKUP_NAME, Backup_Name);
Matt Mower76b8afc2016-06-24 12:04:27 -0500856 PageManager::NotifyKey(KEY_END, true);
857 PageManager::NotifyKey(KEY_END, false);
that3f7b1ac2014-12-30 11:30:13 +0100858 operation_end(0);
859 return 0;
860}
Ethan Yonker87c7bac2014-05-25 21:41:08 -0500861
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500862int GUIAction::generatebackupname(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100863{
864 operation_start("GenerateBackupName");
865 TWFunc::Auto_Generate_Backup_Name();
866 operation_end(0);
867 return 0;
868}
Ethan Yonker87c7bac2014-05-25 21:41:08 -0500869
Ethan Yonker483e9f42016-01-11 22:21:18 -0600870int GUIAction::checkpartitionlist(std::string arg)
that3f7b1ac2014-12-30 11:30:13 +0100871{
Ethan Yonker483e9f42016-01-11 22:21:18 -0600872 string List, part_path;
that3f7b1ac2014-12-30 11:30:13 +0100873 int count = 0;
Ethan Yonker87c7bac2014-05-25 21:41:08 -0500874
Ethan Yonker483e9f42016-01-11 22:21:18 -0600875 if (arg.empty())
876 arg = "tw_wipe_list";
877 DataManager::GetValue(arg, List);
878 LOGINFO("checkpartitionlist list '%s'\n", List.c_str());
879 if (!List.empty()) {
880 size_t start_pos = 0, end_pos = List.find(";", start_pos);
881 while (end_pos != string::npos && start_pos < List.size()) {
882 part_path = List.substr(start_pos, end_pos - start_pos);
883 LOGINFO("checkpartitionlist part_path '%s'\n", part_path.c_str());
884 if (part_path == "/and-sec" || part_path == "DALVIK" || part_path == "INTERNAL") {
that3f7b1ac2014-12-30 11:30:13 +0100885 // Do nothing
Dees_Troy51a0e822012-09-05 15:24:24 -0400886 } else {
that3f7b1ac2014-12-30 11:30:13 +0100887 count++;
888 }
889 start_pos = end_pos + 1;
Ethan Yonker483e9f42016-01-11 22:21:18 -0600890 end_pos = List.find(";", start_pos);
that3f7b1ac2014-12-30 11:30:13 +0100891 }
892 DataManager::SetValue("tw_check_partition_list", count);
893 } else {
894 DataManager::SetValue("tw_check_partition_list", 0);
895 }
Matt Mowera8a89d12016-12-30 18:10:37 -0600896 return 0;
that3f7b1ac2014-12-30 11:30:13 +0100897}
Dees_Troy51a0e822012-09-05 15:24:24 -0400898
Ethan Yonker483e9f42016-01-11 22:21:18 -0600899int GUIAction::getpartitiondetails(std::string arg)
that3f7b1ac2014-12-30 11:30:13 +0100900{
Ethan Yonker483e9f42016-01-11 22:21:18 -0600901 string List, part_path;
Dees_Troy51a0e822012-09-05 15:24:24 -0400902
Ethan Yonker483e9f42016-01-11 22:21:18 -0600903 if (arg.empty())
904 arg = "tw_wipe_list";
905 DataManager::GetValue(arg, List);
906 LOGINFO("getpartitiondetails list '%s'\n", List.c_str());
907 if (!List.empty()) {
908 size_t start_pos = 0, end_pos = List.find(";", start_pos);
909 part_path = List;
910 while (end_pos != string::npos && start_pos < List.size()) {
911 part_path = List.substr(start_pos, end_pos - start_pos);
912 LOGINFO("getpartitiondetails part_path '%s'\n", part_path.c_str());
913 if (part_path == "/and-sec" || part_path == "DALVIK" || part_path == "INTERNAL") {
that3f7b1ac2014-12-30 11:30:13 +0100914 // Do nothing
915 } else {
Ethan Yonker483e9f42016-01-11 22:21:18 -0600916 DataManager::SetValue("tw_partition_path", part_path);
that3f7b1ac2014-12-30 11:30:13 +0100917 break;
918 }
919 start_pos = end_pos + 1;
Ethan Yonker483e9f42016-01-11 22:21:18 -0600920 end_pos = List.find(";", start_pos);
that3f7b1ac2014-12-30 11:30:13 +0100921 }
Ethan Yonker483e9f42016-01-11 22:21:18 -0600922 if (!part_path.empty()) {
923 TWPartition* Part = PartitionManager.Find_Partition_By_Path(part_path);
that3f7b1ac2014-12-30 11:30:13 +0100924 if (Part) {
925 unsigned long long mb = 1048576;
Dees_Troya13d74f2013-03-24 08:54:55 -0500926
that3f7b1ac2014-12-30 11:30:13 +0100927 DataManager::SetValue("tw_partition_name", Part->Display_Name);
928 DataManager::SetValue("tw_partition_mount_point", Part->Mount_Point);
929 DataManager::SetValue("tw_partition_file_system", Part->Current_File_System);
930 DataManager::SetValue("tw_partition_size", Part->Size / mb);
931 DataManager::SetValue("tw_partition_used", Part->Used / mb);
932 DataManager::SetValue("tw_partition_free", Part->Free / mb);
933 DataManager::SetValue("tw_partition_backup_size", Part->Backup_Size / mb);
934 DataManager::SetValue("tw_partition_removable", Part->Removable);
935 DataManager::SetValue("tw_partition_is_present", Part->Is_Present);
936
937 if (Part->Can_Repair())
938 DataManager::SetValue("tw_partition_can_repair", 1);
939 else
940 DataManager::SetValue("tw_partition_can_repair", 0);
Ethan Yonkera2719152015-05-28 09:44:41 -0500941 if (Part->Can_Resize())
942 DataManager::SetValue("tw_partition_can_resize", 1);
943 else
944 DataManager::SetValue("tw_partition_can_resize", 0);
bigbiffad58e1b2020-07-06 20:24:34 -0400945 if (TWFunc::Path_Exists("/system/bin/mkfs.fat"))
that3f7b1ac2014-12-30 11:30:13 +0100946 DataManager::SetValue("tw_partition_vfat", 1);
947 else
948 DataManager::SetValue("tw_partition_vfat", 0);
bigbiffad58e1b2020-07-06 20:24:34 -0400949 if (TWFunc::Path_Exists("/system/bin/mkexfatfs"))
that3f7b1ac2014-12-30 11:30:13 +0100950 DataManager::SetValue("tw_partition_exfat", 1);
951 else
952 DataManager::SetValue("tw_partition_exfat", 0);
whylef06b1652020-11-22 00:25:18 +0100953 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs") || TWFunc::Path_Exists("/system/bin/make_f2fs"))
that3f7b1ac2014-12-30 11:30:13 +0100954 DataManager::SetValue("tw_partition_f2fs", 1);
955 else
956 DataManager::SetValue("tw_partition_f2fs", 0);
bigbiffad58e1b2020-07-06 20:24:34 -0400957 if (TWFunc::Path_Exists("/system/bin/mke2fs"))
that3f7b1ac2014-12-30 11:30:13 +0100958 DataManager::SetValue("tw_partition_ext", 1);
959 else
960 DataManager::SetValue("tw_partition_ext", 0);
961 return 0;
962 } else {
Ethan Yonker483e9f42016-01-11 22:21:18 -0600963 LOGERR("Unable to locate partition: '%s'\n", part_path.c_str());
that3f7b1ac2014-12-30 11:30:13 +0100964 }
965 }
966 }
967 DataManager::SetValue("tw_partition_name", "");
968 DataManager::SetValue("tw_partition_file_system", "");
Ethan Yonker483e9f42016-01-11 22:21:18 -0600969 // Set this to 0 to prevent trying to partition this device, just in case
970 DataManager::SetValue("tw_partition_removable", 0);
that3f7b1ac2014-12-30 11:30:13 +0100971 return 0;
972}
973
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500974int GUIAction::screenshot(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +0100975{
976 time_t tm;
977 char path[256];
978 int path_len;
Matt Mower0c88b842017-01-15 16:00:49 -0600979 uid_t uid = AID_MEDIA_RW;
980 gid_t gid = AID_MEDIA_RW;
that3f7b1ac2014-12-30 11:30:13 +0100981
982 const std::string storage = DataManager::GetCurrentStoragePath();
Matt Mowera8a89d12016-12-30 18:10:37 -0600983 if (PartitionManager.Is_Mounted_By_Path(storage)) {
that3f7b1ac2014-12-30 11:30:13 +0100984 snprintf(path, sizeof(path), "%s/Pictures/Screenshots/", storage.c_str());
985 } else {
986 strcpy(path, "/tmp/");
987 }
988
Matt Mowera8a89d12016-12-30 18:10:37 -0600989 if (!TWFunc::Create_Dir_Recursive(path, 0775, uid, gid))
that3f7b1ac2014-12-30 11:30:13 +0100990 return 0;
991
992 tm = time(NULL);
993 path_len = strlen(path);
994
995 // Screenshot_2014-01-01-18-21-38.png
996 strftime(path+path_len, sizeof(path)-path_len, "Screenshot_%Y-%m-%d-%H-%M-%S.png", localtime(&tm));
997
998 int res = gr_save_screenshot(path);
Matt Mowera8a89d12016-12-30 18:10:37 -0600999 if (res == 0) {
that3f7b1ac2014-12-30 11:30:13 +01001000 chmod(path, 0666);
1001 chown(path, uid, gid);
1002
that677b13f2015-12-26 23:57:31 +01001003 gui_msg(Msg("screenshot_saved=Screenshot was saved to {1}")(path));
that3f7b1ac2014-12-30 11:30:13 +01001004
VDavid0032034a412019-10-18 22:43:20 +02001005 // blink to notify that the screenshot was taken
that3f7b1ac2014-12-30 11:30:13 +01001006 gr_color(255, 255, 255, 255);
1007 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
1008 gr_flip();
1009 gui_forceRender();
1010 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001011 gui_err("screenshot_err=Failed to take a screenshot!");
that3f7b1ac2014-12-30 11:30:13 +01001012 }
1013 return 0;
1014}
1015
1016int GUIAction::setbrightness(std::string arg)
1017{
1018 return TWFunc::Set_Brightness(arg);
1019}
1020
1021int GUIAction::fileexists(std::string arg)
1022{
1023 struct stat st;
1024 string newpath = arg + "/.";
1025
1026 operation_start("FileExists");
1027 if (stat(arg.c_str(), &st) == 0 || stat(newpath.c_str(), &st) == 0)
1028 operation_end(0);
1029 else
1030 operation_end(1);
1031 return 0;
1032}
1033
thatcc8ddca2015-01-03 01:59:36 +01001034void GUIAction::reinject_after_flash()
1035{
1036 if (DataManager::GetIntValue(TW_HAS_INJECTTWRP) == 1 && DataManager::GetIntValue(TW_INJECT_AFTER_ZIP) == 1) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001037 gui_msg("injecttwrp=Injecting TWRP into boot image...");
thatcc8ddca2015-01-03 01:59:36 +01001038 if (simulate) {
1039 simulate_progress_bar();
1040 } else {
1041 TWPartition* Boot = PartitionManager.Find_Partition_By_Path("/boot");
1042 if (Boot == NULL || Boot->Current_File_System != "emmc")
1043 TWFunc::Exec_Cmd("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash");
1044 else {
1045 string injectcmd = "injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash bd=" + Boot->Actual_Block_Device;
1046 TWFunc::Exec_Cmd(injectcmd);
1047 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001048 gui_msg("done=Done.");
thatcc8ddca2015-01-03 01:59:36 +01001049 }
1050 }
1051}
1052
mauronofrio6d3bf892019-10-26 19:47:55 +02001053int GUIAction::ozip_decrypt(string zip_path)
1054{
bigbiffad58e1b2020-07-06 20:24:34 -04001055 if (!TWFunc::Path_Exists("/system/bin/ozip_decrypt")) {
Captain Throwback8adc6962023-09-15 16:46:50 -04001056 return 1;
1057 }
1058 gui_msg("ozip_decrypt_decryption=Starting Ozip Decryption...");
mauronofrio6d3bf892019-10-26 19:47:55 +02001059 TWFunc::Exec_Cmd("ozip_decrypt " + (string)TW_OZIP_DECRYPT_KEY + " '" + zip_path + "'");
Captain Throwback8adc6962023-09-15 16:46:50 -04001060 gui_msg("ozip_decrypt_finish=Ozip Decryption Finished!");
mauronofrio6d3bf892019-10-26 19:47:55 +02001061 return 0;
1062}
1063
that3f7b1ac2014-12-30 11:30:13 +01001064int GUIAction::flash(std::string arg)
1065{
1066 int i, ret_val = 0, wipe_cache = 0;
Ethan Yonker0d47eb52015-01-09 11:23:19 -06001067 // We're going to jump to this page first, like a loading page
1068 gui_changePage(arg);
that3f7b1ac2014-12-30 11:30:13 +01001069 for (i=0; i<zip_queue_index; i++) {
thatc7b631b2015-06-01 23:36:57 +02001070 string zip_path = zip_queue[i];
1071 size_t slashpos = zip_path.find_last_of('/');
1072 string zip_filename = (slashpos == string::npos) ? zip_path : zip_path.substr(slashpos + 1);
that3f7b1ac2014-12-30 11:30:13 +01001073 operation_start("Flashing");
mauronofrio6d3bf892019-10-26 19:47:55 +02001074 if((zip_path.substr(zip_path.size() - 4, 4)) == "ozip")
1075 {
1076 if((ozip_decrypt(zip_path)) != 0)
1077 {
Captain Throwback8adc6962023-09-15 16:46:50 -04001078 LOGERR("Unable to find ozip_decrypt!");
mauronofrio6d3bf892019-10-26 19:47:55 +02001079 break;
1080 }
1081 zip_filename = (zip_filename.substr(0, zip_filename.size() - 4)).append("zip");
1082 zip_path = (zip_path.substr(0, zip_path.size() - 4)).append("zip");
1083 if (!TWFunc::Path_Exists(zip_path)) {
1084 LOGERR("Unable to find decrypted zip");
1085 break;
1086 }
1087 }
thatc7b631b2015-06-01 23:36:57 +02001088 DataManager::SetValue("tw_filename", zip_path);
1089 DataManager::SetValue("tw_file", zip_filename);
that3f7b1ac2014-12-30 11:30:13 +01001090 DataManager::SetValue(TW_ZIP_INDEX, (i + 1));
1091
1092 TWFunc::SetPerformanceMode(true);
thatc7b631b2015-06-01 23:36:57 +02001093 ret_val = flash_zip(zip_path, &wipe_cache);
that3f7b1ac2014-12-30 11:30:13 +01001094 TWFunc::SetPerformanceMode(false);
1095 if (ret_val != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001096 gui_msg(Msg(msg::kError, "zip_err=Error installing zip file '{1}'")(zip_path));
that3f7b1ac2014-12-30 11:30:13 +01001097 ret_val = 1;
Ethan Yonker0d47eb52015-01-09 11:23:19 -06001098 break;
that3f7b1ac2014-12-30 11:30:13 +01001099 }
1100 }
1101 zip_queue_index = 0;
that3f7b1ac2014-12-30 11:30:13 +01001102
Ethan Yonker0d47eb52015-01-09 11:23:19 -06001103 if (wipe_cache) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001104 gui_msg("zip_wipe_cache=One or more zip requested a cache wipe -- Wiping cache now.");
that3f7b1ac2014-12-30 11:30:13 +01001105 PartitionManager.Wipe_By_Path("/cache");
Ethan Yonker0d47eb52015-01-09 11:23:19 -06001106 }
that3f7b1ac2014-12-30 11:30:13 +01001107
thatcc8ddca2015-01-03 01:59:36 +01001108 reinject_after_flash();
that3f7b1ac2014-12-30 11:30:13 +01001109 PartitionManager.Update_System_Details();
1110 operation_end(ret_val);
bigbiffa869fc72016-03-01 19:40:36 -05001111 // This needs to be after the operation_end call so we change pages before we change variables that we display on the screen
Ethan Yonker0d47eb52015-01-09 11:23:19 -06001112 DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index);
that3f7b1ac2014-12-30 11:30:13 +01001113 return 0;
1114}
1115
1116int GUIAction::wipe(std::string arg)
1117{
1118 operation_start("Format");
1119 DataManager::SetValue("tw_partition", arg);
that3f7b1ac2014-12-30 11:30:13 +01001120 int ret_val = false;
1121
1122 if (simulate) {
1123 simulate_progress_bar();
1124 } else {
1125 if (arg == "data")
1126 ret_val = PartitionManager.Factory_Reset();
1127 else if (arg == "battery")
1128 ret_val = PartitionManager.Wipe_Battery_Stats();
1129 else if (arg == "rotate")
1130 ret_val = PartitionManager.Wipe_Rotate_Data();
1131 else if (arg == "dalvik")
1132 ret_val = PartitionManager.Wipe_Dalvik_Cache();
1133 else if (arg == "DATAMEDIA") {
1134 ret_val = PartitionManager.Format_Data();
1135 } else if (arg == "INTERNAL") {
Matt Mower23d8aae2017-01-06 14:30:33 -06001136 int has_datamedia;
that3f7b1ac2014-12-30 11:30:13 +01001137
1138 DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia);
1139 if (has_datamedia) {
1140 ret_val = PartitionManager.Wipe_Media_From_Data();
1141 } else {
Mohd Farazf9231102022-06-18 22:51:55 +02001142 ret_val = PartitionManager.Wipe_By_Path(DataManager::GetCurrentStoragePath());
that3f7b1ac2014-12-30 11:30:13 +01001143 }
1144 } else if (arg == "EXTERNAL") {
1145 string External_Path;
1146
1147 DataManager::GetValue(TW_EXTERNAL_PATH, External_Path);
1148 ret_val = PartitionManager.Wipe_By_Path(External_Path);
1149 } else if (arg == "ANDROIDSECURE") {
1150 ret_val = PartitionManager.Wipe_Android_Secure();
1151 } else if (arg == "LIST") {
1152 string Wipe_List, wipe_path;
1153 bool skip = false;
1154 ret_val = true;
that3f7b1ac2014-12-30 11:30:13 +01001155
1156 DataManager::GetValue("tw_wipe_list", Wipe_List);
1157 LOGINFO("wipe list '%s'\n", Wipe_List.c_str());
1158 if (!Wipe_List.empty()) {
1159 size_t start_pos = 0, end_pos = Wipe_List.find(";", start_pos);
1160 while (end_pos != string::npos && start_pos < Wipe_List.size()) {
1161 wipe_path = Wipe_List.substr(start_pos, end_pos - start_pos);
1162 LOGINFO("wipe_path '%s'\n", wipe_path.c_str());
1163 if (wipe_path == "/and-sec") {
1164 if (!PartitionManager.Wipe_Android_Secure()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001165 gui_msg("and_sec_wipe_err=Unable to wipe android secure");
that3f7b1ac2014-12-30 11:30:13 +01001166 ret_val = false;
1167 break;
1168 } else {
1169 skip = true;
1170 }
1171 } else if (wipe_path == "DALVIK") {
1172 if (!PartitionManager.Wipe_Dalvik_Cache()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001173 gui_err("dalvik_wipe_err=Failed to wipe dalvik");
that3f7b1ac2014-12-30 11:30:13 +01001174 ret_val = false;
1175 break;
1176 } else {
1177 skip = true;
1178 }
1179 } else if (wipe_path == "INTERNAL") {
1180 if (!PartitionManager.Wipe_Media_From_Data()) {
1181 ret_val = false;
1182 break;
1183 } else {
1184 skip = true;
Dees_Troya13d74f2013-03-24 08:54:55 -05001185 }
1186 }
that3f7b1ac2014-12-30 11:30:13 +01001187 if (!skip) {
1188 if (!PartitionManager.Wipe_By_Path(wipe_path)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001189 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(wipe_path));
that3f7b1ac2014-12-30 11:30:13 +01001190 ret_val = false;
1191 break;
Mohd Farazf9231102022-06-18 22:51:55 +02001192 } else if (wipe_path == DataManager::GetCurrentStoragePath()) {
that3f7b1ac2014-12-30 11:30:13 +01001193 arg = wipe_path;
1194 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001195 } else {
that3f7b1ac2014-12-30 11:30:13 +01001196 skip = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04001197 }
that3f7b1ac2014-12-30 11:30:13 +01001198 start_pos = end_pos + 1;
1199 end_pos = Wipe_List.find(";", start_pos);
Dees_Troy51a0e822012-09-05 15:24:24 -04001200 }
1201 }
that3f7b1ac2014-12-30 11:30:13 +01001202 } else
1203 ret_val = PartitionManager.Wipe_By_Path(arg);
that73a52952015-01-28 23:07:34 +01001204#ifndef TW_OEM_BUILD
that3f7b1ac2014-12-30 11:30:13 +01001205 if (arg == DataManager::GetSettingsStoragePath()) {
1206 // If we wiped the settings storage path, recreate the TWRP folder and dump the settings
1207 string Storage_Path = DataManager::GetSettingsStoragePath();
Dees_Troy51a0e822012-09-05 15:24:24 -04001208
that3f7b1ac2014-12-30 11:30:13 +01001209 if (PartitionManager.Mount_By_Path(Storage_Path, true)) {
1210 LOGINFO("Making TWRP folder and saving settings.\n");
1211 Storage_Path += "/TWRP";
1212 mkdir(Storage_Path.c_str(), 0777);
1213 DataManager::Flush();
Dees_Troy51a0e822012-09-05 15:24:24 -04001214 } else {
that3f7b1ac2014-12-30 11:30:13 +01001215 LOGERR("Unable to recreate TWRP folder and save settings.\n");
1216 }
1217 }
1218#endif
1219 }
1220 PartitionManager.Update_System_Details();
1221 if (ret_val)
1222 ret_val = 0; // 0 is success
1223 else
1224 ret_val = 1; // 1 is failure
1225 operation_end(ret_val);
1226 return 0;
1227}
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +00001228
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001229int GUIAction::refreshsizes(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001230{
1231 operation_start("Refreshing Sizes");
1232 if (simulate) {
1233 simulate_progress_bar();
1234 } else
1235 PartitionManager.Update_System_Details();
1236 operation_end(0);
1237 return 0;
1238}
1239
1240int GUIAction::nandroid(std::string arg)
1241{
that3f7b1ac2014-12-30 11:30:13 +01001242 if (simulate) {
that73a52952015-01-28 23:07:34 +01001243 PartitionManager.stop_backup.set_value(0);
that3f7b1ac2014-12-30 11:30:13 +01001244 DataManager::SetValue("tw_partition", "Simulation");
1245 simulate_progress_bar();
that73a52952015-01-28 23:07:34 +01001246 operation_end(0);
that3f7b1ac2014-12-30 11:30:13 +01001247 } else {
bigbiff7abc5fe2015-01-17 16:53:12 -05001248 operation_start("Nandroid");
1249 int ret = 0;
1250
that3f7b1ac2014-12-30 11:30:13 +01001251 if (arg == "backup") {
1252 string Backup_Name;
1253 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
Ethan Yonker4adc33e2016-01-22 16:07:11 -06001254 string auto_gen = gui_lookup("auto_generate", "(Auto Generate)");
Ethan Yonker53796e72019-01-11 22:49:52 -06001255 if (Backup_Name == auto_gen || Backup_Name == gui_lookup("curr_date", "(Current Date)") || Backup_Name == "0" || Backup_Name == "(" || PartitionManager.Check_Backup_Name(Backup_Name, true, true) == 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05001256 ret = PartitionManager.Run_Backup(false);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001257 DataManager::SetValue("tw_encrypt_backup", 0); // reset value so we don't encrypt every subsequent backup
1258 if (!PartitionManager.stop_backup.get_value()) {
1259 if (ret == false)
1260 ret = 1; // 1 for failure
1261 else
1262 ret = 0; // 0 for success
1263 DataManager::SetValue("tw_cancel_backup", 0);
1264 } else {
1265 DataManager::SetValue("tw_cancel_backup", 1);
1266 gui_msg("backup_cancel=Backup Cancelled");
1267 ret = 0;
1268 }
bigbiffce8f83c2015-12-12 18:30:21 -05001269 } else {
that3f7b1ac2014-12-30 11:30:13 +01001270 operation_end(1);
1271 return -1;
that3f7b1ac2014-12-30 11:30:13 +01001272 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001273 DataManager::SetValue(TW_BACKUP_NAME, auto_gen);
that3f7b1ac2014-12-30 11:30:13 +01001274 } else if (arg == "restore") {
1275 string Restore_Name;
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001276 int gui_adb_backup;
1277
that3f7b1ac2014-12-30 11:30:13 +01001278 DataManager::GetValue("tw_restore", Restore_Name);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001279 DataManager::GetValue("tw_enable_adb_backup", gui_adb_backup);
1280 if (gui_adb_backup) {
1281 DataManager::SetValue("tw_operation_state", 1);
1282 if (TWFunc::stream_adb_backup(Restore_Name) == 0)
1283 ret = 0; // success
1284 else
1285 ret = 1; // failure
1286 DataManager::SetValue("tw_enable_adb_backup", 0);
1287 ret = 0; // assume success???
1288 } else {
1289 if (PartitionManager.Run_Restore(Restore_Name))
1290 ret = 0; // success
1291 else
1292 ret = 1; // failure
1293 }
that3f7b1ac2014-12-30 11:30:13 +01001294 } else {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001295 operation_end(1); // invalid arg specified, fail
bigbiff7abc5fe2015-01-17 16:53:12 -05001296 return -1;
1297 }
that73a52952015-01-28 23:07:34 +01001298 operation_end(ret);
bigbiff7abc5fe2015-01-17 16:53:12 -05001299 return ret;
1300 }
1301 return 0;
1302}
1303
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001304int GUIAction::cancelbackup(std::string arg __unused) {
bigbiff7abc5fe2015-01-17 16:53:12 -05001305 if (simulate) {
bigbiff7abc5fe2015-01-17 16:53:12 -05001306 PartitionManager.stop_backup.set_value(1);
bigbiff7abc5fe2015-01-17 16:53:12 -05001307 }
1308 else {
bigbiff7abc5fe2015-01-17 16:53:12 -05001309 int op_status = PartitionManager.Cancel_Backup();
1310 if (op_status != 0)
1311 op_status = 1; // failure
bigbiff7abc5fe2015-01-17 16:53:12 -05001312 }
1313
1314 return 0;
that3f7b1ac2014-12-30 11:30:13 +01001315}
Dees_Troy51a0e822012-09-05 15:24:24 -04001316
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001317int GUIAction::fixcontexts(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001318{
that73a52952015-01-28 23:07:34 +01001319 int op_status = 0;
1320
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001321 operation_start("Fix Contexts");
1322 LOGINFO("fix contexts started!\n");
that3f7b1ac2014-12-30 11:30:13 +01001323 if (simulate) {
1324 simulate_progress_bar();
1325 } else {
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001326 op_status = PartitionManager.Fix_Contexts();
that3f7b1ac2014-12-30 11:30:13 +01001327 if (op_status != 0)
1328 op_status = 1; // failure
that3f7b1ac2014-12-30 11:30:13 +01001329 }
that73a52952015-01-28 23:07:34 +01001330 operation_end(op_status);
that3f7b1ac2014-12-30 11:30:13 +01001331 return 0;
1332}
1333
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001334int GUIAction::fixpermissions(std::string arg)
1335{
1336 return fixcontexts(arg);
1337}
1338
that3f7b1ac2014-12-30 11:30:13 +01001339int GUIAction::dd(std::string arg)
1340{
1341 operation_start("imaging");
1342
1343 if (simulate) {
1344 simulate_progress_bar();
1345 } else {
1346 string cmd = "dd " + arg;
1347 TWFunc::Exec_Cmd(cmd);
1348 }
1349 operation_end(0);
1350 return 0;
1351}
1352
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001353int GUIAction::partitionsd(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001354{
1355 operation_start("Partition SD Card");
1356 int ret_val = 0;
1357
1358 if (simulate) {
1359 simulate_progress_bar();
1360 } else {
1361 int allow_partition;
1362 DataManager::GetValue(TW_ALLOW_PARTITION_SDCARD, allow_partition);
1363 if (allow_partition == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001364 gui_err("no_real_sdcard=This device does not have a real SD Card! Aborting!");
that3f7b1ac2014-12-30 11:30:13 +01001365 } else {
1366 if (!PartitionManager.Partition_SDCard())
1367 ret_val = 1; // failed
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001368 }
that3f7b1ac2014-12-30 11:30:13 +01001369 }
1370 operation_end(ret_val);
1371 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -04001372
that3f7b1ac2014-12-30 11:30:13 +01001373}
Dees_Troy51a0e822012-09-05 15:24:24 -04001374
that3f7b1ac2014-12-30 11:30:13 +01001375int GUIAction::cmd(std::string arg)
1376{
1377 int op_status = 0;
1378
1379 operation_start("Command");
1380 LOGINFO("Running command: '%s'\n", arg.c_str());
1381 if (simulate) {
1382 simulate_progress_bar();
1383 } else {
1384 op_status = TWFunc::Exec_Cmd(arg);
1385 if (op_status != 0)
1386 op_status = 1;
1387 }
1388
1389 operation_end(op_status);
1390 return 0;
1391}
1392
1393int GUIAction::terminalcommand(std::string arg)
1394{
1395 int op_status = 0;
1396 string cmdpath, command;
1397
1398 DataManager::GetValue("tw_terminal_location", cmdpath);
1399 operation_start("CommandOutput");
1400 gui_print("%s # %s\n", cmdpath.c_str(), arg.c_str());
1401 if (simulate) {
1402 simulate_progress_bar();
1403 operation_end(op_status);
Matt Mower5aa29ab2015-02-25 23:50:55 -06001404 } else if (arg == "exit") {
1405 LOGINFO("Exiting terminal\n");
1406 operation_end(op_status);
1407 page("main");
that3f7b1ac2014-12-30 11:30:13 +01001408 } else {
1409 command = "cd \"" + cmdpath + "\" && " + arg + " 2>&1";;
1410 LOGINFO("Actual command is: '%s'\n", command.c_str());
that3f7b1ac2014-12-30 11:30:13 +01001411 DataManager::SetValue("tw_terminal_state", 1);
1412 DataManager::SetValue("tw_background_thread_running", 1);
thatc6085482015-01-09 22:12:43 +01001413 FILE* fp;
1414 char line[512];
1415
1416 fp = popen(command.c_str(), "r");
1417 if (fp == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001418 LOGERR("Error opening command to run (%s).\n", strerror(errno));
thatc6085482015-01-09 22:12:43 +01001419 } else {
Matt Mower23d8aae2017-01-06 14:30:33 -06001420 int fd = fileno(fp), has_data = 0, check = 0, keep_going = -1;
thatc6085482015-01-09 22:12:43 +01001421 struct timeval timeout;
1422 fd_set fdset;
1423
Matt Mowera8a89d12016-12-30 18:10:37 -06001424 while (keep_going)
thatc6085482015-01-09 22:12:43 +01001425 {
1426 FD_ZERO(&fdset);
1427 FD_SET(fd, &fdset);
1428 timeout.tv_sec = 0;
1429 timeout.tv_usec = 400000;
1430 has_data = select(fd+1, &fdset, NULL, NULL, &timeout);
1431 if (has_data == 0) {
1432 // Timeout reached
1433 DataManager::GetValue("tw_terminal_state", check);
1434 if (check == 0) {
1435 keep_going = 0;
1436 }
1437 } else if (has_data < 0) {
1438 // End of execution
1439 keep_going = 0;
1440 } else {
1441 // Try to read output
Matt Mowera8a89d12016-12-30 18:10:37 -06001442 if (fgets(line, sizeof(line), fp) != NULL)
thatc6085482015-01-09 22:12:43 +01001443 gui_print("%s", line); // Display output
1444 else
1445 keep_going = 0; // Done executing
1446 }
1447 }
1448 fclose(fp);
Dees_Troy51a0e822012-09-05 15:24:24 -04001449 }
thatc6085482015-01-09 22:12:43 +01001450 DataManager::SetValue("tw_operation_status", 0);
1451 DataManager::SetValue("tw_operation_state", 1);
1452 DataManager::SetValue("tw_terminal_state", 0);
1453 DataManager::SetValue("tw_background_thread_running", 0);
1454 DataManager::SetValue(TW_ACTION_BUSY, 0);
that3f7b1ac2014-12-30 11:30:13 +01001455 }
1456 return 0;
1457}
1458
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001459int GUIAction::killterminal(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001460{
that3f7b1ac2014-12-30 11:30:13 +01001461 LOGINFO("Sending kill command...\n");
1462 operation_start("KillCommand");
1463 DataManager::SetValue("tw_operation_status", 0);
1464 DataManager::SetValue("tw_operation_state", 1);
1465 DataManager::SetValue("tw_terminal_state", 0);
1466 DataManager::SetValue("tw_background_thread_running", 0);
1467 DataManager::SetValue(TW_ACTION_BUSY, 0);
1468 return 0;
1469}
1470
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001471int GUIAction::reinjecttwrp(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001472{
1473 int op_status = 0;
1474 operation_start("ReinjectTWRP");
Ethan Yonker74db1572015-10-28 12:44:49 -05001475 gui_msg("injecttwrp=Injecting TWRP into boot image...");
that3f7b1ac2014-12-30 11:30:13 +01001476 if (simulate) {
1477 simulate_progress_bar();
1478 } else {
1479 TWFunc::Exec_Cmd("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash");
Ethan Yonker74db1572015-10-28 12:44:49 -05001480 gui_msg("done=Done.");
that3f7b1ac2014-12-30 11:30:13 +01001481 }
1482
1483 operation_end(op_status);
1484 return 0;
1485}
1486
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001487int GUIAction::checkbackupname(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001488{
1489 int op_status = 0;
1490
1491 operation_start("CheckBackupName");
1492 if (simulate) {
1493 simulate_progress_bar();
1494 } else {
Ethan Yonker53796e72019-01-11 22:49:52 -06001495 string Backup_Name;
1496 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
1497 op_status = PartitionManager.Check_Backup_Name(Backup_Name, true, true);
that3f7b1ac2014-12-30 11:30:13 +01001498 if (op_status != 0)
1499 op_status = 1;
1500 }
1501
1502 operation_end(op_status);
1503 return 0;
1504}
1505
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001506int GUIAction::decrypt(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001507{
1508 int op_status = 0;
1509
1510 operation_start("Decrypt");
1511 if (simulate) {
1512 simulate_progress_bar();
1513 } else {
1514 string Password;
Noah Jacobson81d638d2019-04-28 00:10:07 -04001515 string userID;
that3f7b1ac2014-12-30 11:30:13 +01001516 DataManager::GetValue("tw_crypto_password", Password);
Noah Jacobson81d638d2019-04-28 00:10:07 -04001517
1518 if (DataManager::GetIntValue(TW_IS_FBE)) { // for FBE
1519 DataManager::GetValue("tw_crypto_user_id", userID);
1520 if (userID != "") {
1521 op_status = PartitionManager.Decrypt_Device(Password, atoi(userID.c_str()));
1522 if (userID != "0") {
1523 if (op_status != 0)
1524 op_status = 1;
1525 operation_end(op_status);
1526 return 0;
1527 }
1528 } else {
1529 LOGINFO("User ID not found\n");
1530 op_status = 1;
1531 }
1532 ::sleep(1);
1533 } else { // for FDE
1534 op_status = PartitionManager.Decrypt_Device(Password);
1535 }
1536
that3f7b1ac2014-12-30 11:30:13 +01001537 if (op_status != 0)
1538 op_status = 1;
1539 else {
that3f7b1ac2014-12-30 11:30:13 +01001540 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1541
Ethan Yonkercf50da52015-01-12 21:59:07 -06001542 int has_datamedia;
that3f7b1ac2014-12-30 11:30:13 +01001543
Ethan Yonkercf50da52015-01-12 21:59:07 -06001544 // Check for a custom theme and load it if exists
1545 DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia);
1546 if (has_datamedia != 0) {
nielsdbed9852023-03-14 18:54:34 +01001547 if (tw_get_default_metadata(DataManager::GetCurrentStoragePath().c_str()) != 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06001548 LOGINFO("Failed to get default contexts and file mode for storage files.\n");
Ethan Yonkercf50da52015-01-12 21:59:07 -06001549 } else {
1550 LOGINFO("Got default contexts and file mode for storage files.\n");
that3f7b1ac2014-12-30 11:30:13 +01001551 }
1552 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001553 PartitionManager.Decrypt_Adopted();
that3f7b1ac2014-12-30 11:30:13 +01001554 }
1555 }
1556
1557 operation_end(op_status);
1558 return 0;
1559}
1560
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001561int GUIAction::adbsideload(std::string arg __unused)
thatcc8ddca2015-01-03 01:59:36 +01001562{
1563 operation_start("Sideload");
1564 if (simulate) {
1565 simulate_progress_bar();
1566 operation_end(0);
1567 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001568 gui_msg("start_sideload=Starting ADB sideload feature...");
thatc6085482015-01-09 22:12:43 +01001569 bool mtp_was_enabled = TWFunc::Toggle_MTP(false);
1570
1571 // wait for the adb connection
bigbiffd58ba182020-03-23 10:02:29 -04001572 Device::BuiltinAction reboot_action = Device::REBOOT_BOOTLOADER;
bigbiff1f9e4842020-10-31 11:33:15 -04001573 int ret = twrp_sideload("/", &reboot_action);
1574 sideload_child_pid = GetMiniAdbdPid();
thatc6085482015-01-09 22:12:43 +01001575 DataManager::SetValue("tw_has_cancel", 0); // Remove cancel button from gui now that the zip install is going to start
1576
1577 if (ret != 0) {
1578 if (ret == -2)
Ethan Yonker74db1572015-10-28 12:44:49 -05001579 gui_msg("need_new_adb=You need adb 1.0.32 or newer to sideload to this device.");
thatc6085482015-01-09 22:12:43 +01001580 ret = 1; // failure
1581 } else {
1582 int wipe_cache = 0;
1583 int wipe_dalvik = 0;
1584 DataManager::GetValue("tw_wipe_dalvik", wipe_dalvik);
bigbiff1f9e4842020-10-31 11:33:15 -04001585 if (wipe_cache || DataManager::GetIntValue("tw_wipe_cache"))
1586 PartitionManager.Wipe_By_Path("/cache");
1587 if (wipe_dalvik)
1588 PartitionManager.Wipe_Dalvik_Cache();
thatcc8ddca2015-01-03 01:59:36 +01001589 }
thatc6085482015-01-09 22:12:43 +01001590 TWFunc::Toggle_MTP(mtp_was_enabled);
1591 reinject_after_flash();
1592 operation_end(ret);
thatcc8ddca2015-01-03 01:59:36 +01001593 }
that3f7b1ac2014-12-30 11:30:13 +01001594 return 0;
1595}
1596
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001597int GUIAction::adbsideloadcancel(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001598{
that3f7b1ac2014-12-30 11:30:13 +01001599 struct stat st;
1600 DataManager::SetValue("tw_has_cancel", 0); // Remove cancel button from gui
Ethan Yonker74db1572015-10-28 12:44:49 -05001601 gui_msg("cancel_sideload=Cancelling ADB sideload...");
thatcc8ddca2015-01-03 01:59:36 +01001602 LOGINFO("Signaling child sideload process to exit.\n");
1603 // Calling stat() on this magic filename signals the minadbd
1604 // subprocess to shut down.
1605 stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
bigbiff1f9e4842020-10-31 11:33:15 -04001606 sideload_child_pid = GetMiniAdbdPid();
thatcc8ddca2015-01-03 01:59:36 +01001607 if (!sideload_child_pid) {
1608 LOGERR("Unable to get child ID\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001609 return 0;
1610 }
thatcc8ddca2015-01-03 01:59:36 +01001611 ::sleep(1);
1612 LOGINFO("Killing child sideload process.\n");
1613 kill(sideload_child_pid, SIGTERM);
1614 int status;
1615 LOGINFO("Waiting for child sideload process to exit.\n");
1616 waitpid(sideload_child_pid, &status, 0);
1617 sideload_child_pid = 0;
that3f7b1ac2014-12-30 11:30:13 +01001618 DataManager::SetValue("tw_page_done", "1"); // For OpenRecoveryScript support
1619 return 0;
1620}
1621
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001622int GUIAction::openrecoveryscript(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001623{
1624 operation_start("OpenRecoveryScript");
1625 if (simulate) {
1626 simulate_progress_bar();
Ethan Yonker24e7eb72015-01-03 16:13:06 -06001627 operation_end(0);
that3f7b1ac2014-12-30 11:30:13 +01001628 } else {
that10ae24f2015-12-26 20:53:51 +01001629 int op_status = OpenRecoveryScript::Run_OpenRecoveryScript_Action();
Ethan Yonkere1abe612015-06-09 11:09:32 -05001630 operation_end(op_status);
that3f7b1ac2014-12-30 11:30:13 +01001631 }
1632 return 0;
1633}
1634
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001635int GUIAction::installsu(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001636{
1637 int op_status = 0;
1638
1639 operation_start("Install SuperSU");
1640 if (simulate) {
1641 simulate_progress_bar();
1642 } else {
Ethan Yonkerfa67cbf2018-07-20 12:22:33 -05001643 LOGERR("Installing SuperSU was deprecated from TWRP.\n");
that3f7b1ac2014-12-30 11:30:13 +01001644 }
1645
1646 operation_end(op_status);
1647 return 0;
1648}
1649
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001650int GUIAction::fixsu(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001651{
1652 int op_status = 0;
1653
1654 operation_start("Fixing Superuser Permissions");
1655 if (simulate) {
1656 simulate_progress_bar();
1657 } else {
1658 LOGERR("Fixing su permissions was deprecated from TWRP.\n");
1659 LOGERR("4.3+ ROMs with SELinux will always lose su perms.\n");
1660 }
1661
1662 operation_end(op_status);
1663 return 0;
1664}
1665
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001666int GUIAction::decrypt_backup(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001667{
1668 int op_status = 0;
1669
1670 operation_start("Try Restore Decrypt");
1671 if (simulate) {
1672 simulate_progress_bar();
1673 } else {
1674 string Restore_Path, Filename, Password;
1675 DataManager::GetValue("tw_restore", Restore_Path);
1676 Restore_Path += "/";
1677 DataManager::GetValue("tw_restore_password", Password);
1678 TWFunc::SetPerformanceMode(true);
1679 if (TWFunc::Try_Decrypting_Backup(Restore_Path, Password))
1680 op_status = 0; // success
1681 else
1682 op_status = 1; // fail
1683 TWFunc::SetPerformanceMode(false);
1684 }
1685
1686 operation_end(op_status);
1687 return 0;
1688}
1689
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001690int GUIAction::repair(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001691{
1692 int op_status = 0;
1693
1694 operation_start("Repair Partition");
1695 if (simulate) {
1696 simulate_progress_bar();
1697 } else {
1698 string part_path;
1699 DataManager::GetValue("tw_partition_mount_point", part_path);
1700 if (PartitionManager.Repair_By_Path(part_path, true)) {
1701 op_status = 0; // success
1702 } else {
that3f7b1ac2014-12-30 11:30:13 +01001703 op_status = 1; // fail
1704 }
1705 }
1706
1707 operation_end(op_status);
1708 return 0;
1709}
1710
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001711int GUIAction::resize(std::string arg __unused)
Ethan Yonkera2719152015-05-28 09:44:41 -05001712{
1713 int op_status = 0;
1714
1715 operation_start("Resize Partition");
1716 if (simulate) {
1717 simulate_progress_bar();
1718 } else {
1719 string part_path;
1720 DataManager::GetValue("tw_partition_mount_point", part_path);
1721 if (PartitionManager.Resize_By_Path(part_path, true)) {
1722 op_status = 0; // success
1723 } else {
Ethan Yonkera2719152015-05-28 09:44:41 -05001724 op_status = 1; // fail
1725 }
1726 }
1727
1728 operation_end(op_status);
1729 return 0;
1730}
1731
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001732int GUIAction::changefilesystem(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001733{
1734 int op_status = 0;
1735
1736 operation_start("Change File System");
1737 if (simulate) {
1738 simulate_progress_bar();
1739 } else {
1740 string part_path, file_system;
1741 DataManager::GetValue("tw_partition_mount_point", part_path);
1742 DataManager::GetValue("tw_action_new_file_system", file_system);
1743 if (PartitionManager.Wipe_By_Path(part_path, file_system)) {
1744 op_status = 0; // success
1745 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001746 gui_err("change_fs_err=Error changing file system.");
that3f7b1ac2014-12-30 11:30:13 +01001747 op_status = 1; // fail
1748 }
1749 }
1750 PartitionManager.Update_System_Details();
1751 operation_end(op_status);
1752 return 0;
1753}
1754
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001755int GUIAction::startmtp(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001756{
1757 int op_status = 0;
1758
1759 operation_start("Start MTP");
1760 if (PartitionManager.Enable_MTP())
1761 op_status = 0; // success
1762 else
1763 op_status = 1; // fail
1764
1765 operation_end(op_status);
1766 return 0;
1767}
1768
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001769int GUIAction::stopmtp(std::string arg __unused)
that3f7b1ac2014-12-30 11:30:13 +01001770{
1771 int op_status = 0;
1772
1773 operation_start("Stop MTP");
1774 if (PartitionManager.Disable_MTP())
1775 op_status = 0; // success
1776 else
1777 op_status = 1; // fail
1778
1779 operation_end(op_status);
1780 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -04001781}
1782
Ethan Yonkerd0514ba2015-10-22 14:17:47 -05001783int GUIAction::flashimage(std::string arg __unused)
Ethan Yonker96af84a2015-01-05 14:58:36 -06001784{
1785 int op_status = 0;
epicX8f52c0a2021-02-24 23:12:08 +05301786 bool flag = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001787
1788 operation_start("Flash Image");
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001789 string path, filename;
1790 DataManager::GetValue("tw_zip_location", path);
1791 DataManager::GetValue("tw_file", filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06001792
epicX8f52c0a2021-02-24 23:12:08 +05301793#ifdef AB_OTA_UPDATER
1794 string target = DataManager::GetStrValue("tw_flash_partition");
1795 unsigned int pos = target.find_last_of(';');
1796 string mount_point = pos != string::npos ? target.substr(0, pos) : "";
1797 TWPartition* t_part = PartitionManager.Find_Partition_By_Path(mount_point);
1798 bool flash_in_both_slots = DataManager::GetIntValue("tw_flash_both_slots") ? true : false;
1799
1800 if (t_part != NULL && (flash_in_both_slots && t_part->SlotSelect))
1801 {
1802 string current_slot = PartitionManager.Get_Active_Slot_Display();
1803 bool pre_op_status = PartitionManager.Flash_Image(path, filename);
1804
Captain Throwback9b5a17f2022-05-26 14:14:12 -04001805 PartitionManager.Override_Active_Slot(current_slot == "A" ? "B" : "A");
epicX8f52c0a2021-02-24 23:12:08 +05301806 op_status = (int) !(pre_op_status && PartitionManager.Flash_Image(path, filename));
Captain Throwback9b5a17f2022-05-26 14:14:12 -04001807 PartitionManager.Override_Active_Slot(current_slot);
epicX8f52c0a2021-02-24 23:12:08 +05301808
1809 DataManager::SetValue("tw_flash_both_slots", 0);
1810 flag = false;
1811 }
1812#endif
1813 if (flag)
1814 {
1815 if (PartitionManager.Flash_Image(path, filename))
1816 op_status = 0; // success
1817 else
1818 op_status = 1; // fail
1819 }
1820
Ethan Yonker96af84a2015-01-05 14:58:36 -06001821 operation_end(op_status);
1822 return 0;
1823}
1824
that10ae24f2015-12-26 20:53:51 +01001825int GUIAction::twcmd(std::string arg)
1826{
1827 operation_start("TWRP CLI Command");
1828 if (simulate)
1829 simulate_progress_bar();
1830 else
1831 OpenRecoveryScript::Run_CLI_Command(arg.c_str());
1832 operation_end(0);
1833 return 0;
1834}
1835
Dees_Troy51a0e822012-09-05 15:24:24 -04001836int GUIAction::getKeyByName(std::string key)
1837{
that8834a0f2016-01-05 23:29:30 +01001838 if (key == "home") return KEY_HOMEPAGE; // note: KEY_HOME is cursor movement (like KEY_END)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001839 else if (key == "menu") return KEY_MENU;
1840 else if (key == "back") return KEY_BACK;
1841 else if (key == "search") return KEY_SEARCH;
1842 else if (key == "voldown") return KEY_VOLUMEDOWN;
1843 else if (key == "volup") return KEY_VOLUMEUP;
1844 else if (key == "power") {
Dees_Troy51a0e822012-09-05 15:24:24 -04001845 int ret_val;
1846 DataManager::GetValue(TW_POWER_BUTTON, ret_val);
1847 if (!ret_val)
1848 return KEY_POWER;
1849 else
1850 return ret_val;
1851 }
1852
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001853 return atol(key.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -04001854}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001855
1856int GUIAction::checkpartitionlifetimewrites(std::string arg)
1857{
1858 int op_status = 0;
1859 TWPartition* sys = PartitionManager.Find_Partition_By_Path(arg);
1860
1861 operation_start("Check Partition Lifetime Writes");
1862 if (sys) {
1863 if (sys->Check_Lifetime_Writes() != 0)
1864 DataManager::SetValue("tw_lifetime_writes", 1);
1865 else
1866 DataManager::SetValue("tw_lifetime_writes", 0);
1867 op_status = 0; // success
1868 } else {
1869 DataManager::SetValue("tw_lifetime_writes", 1);
1870 op_status = 1; // fail
1871 }
1872
1873 operation_end(op_status);
1874 return 0;
1875}
1876
1877int GUIAction::mountsystemtoggle(std::string arg)
1878{
1879 int op_status = 0;
Captain Throwback9d6feb52018-07-27 10:05:24 -04001880 bool remount_system = PartitionManager.Is_Mounted_By_Path(PartitionManager.Get_Android_Root_Path());
Ethan Yonker1673e3d2015-10-26 21:51:58 -05001881 bool remount_vendor = PartitionManager.Is_Mounted_By_Path("/vendor");
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001882
1883 operation_start("Toggle System Mount");
Captain Throwback9d6feb52018-07-27 10:05:24 -04001884 if (!PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), true)) {
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001885 op_status = 1; // fail
1886 } else {
Captain Throwback9d6feb52018-07-27 10:05:24 -04001887 TWPartition* Part = PartitionManager.Find_Partition_By_Path(PartitionManager.Get_Android_Root_Path());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001888 if (Part) {
Ethan Yonkerd6966f42015-05-30 14:52:16 -05001889 if (arg == "0") {
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001890 DataManager::SetValue("tw_mount_system_ro", 0);
1891 Part->Change_Mount_Read_Only(false);
1892 } else {
1893 DataManager::SetValue("tw_mount_system_ro", 1);
1894 Part->Change_Mount_Read_Only(true);
1895 }
1896 if (remount_system) {
1897 Part->Mount(true);
1898 }
1899 op_status = 0; // success
1900 } else {
1901 op_status = 1; // fail
1902 }
Ethan Yonker1673e3d2015-10-26 21:51:58 -05001903 Part = PartitionManager.Find_Partition_By_Path("/vendor");
1904 if (Part) {
1905 if (arg == "0") {
1906 Part->Change_Mount_Read_Only(false);
1907 } else {
1908 Part->Change_Mount_Read_Only(true);
1909 }
1910 if (remount_vendor) {
1911 Part->Mount(true);
1912 }
1913 op_status = 0; // success
1914 } else {
1915 op_status = 1; // fail
1916 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001917 }
1918
1919 operation_end(op_status);
1920 return 0;
1921}
Ethan Yonker74db1572015-10-28 12:44:49 -05001922
1923int GUIAction::setlanguage(std::string arg __unused)
1924{
1925 int op_status = 0;
1926
1927 operation_start("Set Language");
1928 PageManager::LoadLanguage(DataManager::GetStrValue("tw_language"));
1929 PageManager::RequestReload();
1930 op_status = 0; // success
1931
1932 operation_end(op_status);
1933 return 0;
1934}
Ethan Yonker1b190162016-12-05 15:25:19 -06001935
Matt Mower9472ba12016-01-20 18:12:47 -06001936int GUIAction::togglebacklight(std::string arg __unused)
1937{
1938 blankTimer.toggleBlank();
1939 return 0;
1940}
1941
Ethan Yonker1b190162016-12-05 15:25:19 -06001942int GUIAction::setbootslot(std::string arg)
1943{
1944 operation_start("Set Boot Slot");
Captain Throwbackb60a2732020-10-13 17:55:43 -04001945 if (!simulate) {
LinkBoi000a542992021-11-16 08:56:12 +02001946 if (PartitionManager.Find_Partition_By_Path("/vendor")) {
1947 if (!PartitionManager.UnMount_By_Path("/vendor", false)) {
1948 // PartitionManager failed to unmount /vendor, this should not happen,
1949 // but in case it does, do a lazy unmount
1950 LOGINFO("WARNING: vendor partition could not be unmounted normally!\n");
1951 umount2("/vendor", MNT_DETACH);
1952 }
Captain Throwbackb60a2732020-10-13 17:55:43 -04001953 }
LinkBoi000a542992021-11-16 08:56:12 +02001954 PartitionManager.Set_Active_Slot(arg);
Captain Throwbackb60a2732020-10-13 17:55:43 -04001955 } else {
Ethan Yonker1b190162016-12-05 15:25:19 -06001956 simulate_progress_bar();
Captain Throwbackb60a2732020-10-13 17:55:43 -04001957 }
Ethan Yonker1b190162016-12-05 15:25:19 -06001958 operation_end(0);
1959 return 0;
1960}
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06001961
1962int GUIAction::checkforapp(std::string arg __unused)
1963{
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06001964 operation_start("Check for TWRP App");
1965 if (!simulate)
1966 {
epicX271bb3a2020-12-30 01:03:18 +05301967 TWFunc::checkforapp();
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06001968 } else
1969 simulate_progress_bar();
epicX271bb3a2020-12-30 01:03:18 +05301970
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06001971 operation_end(0);
1972 return 0;
1973}
1974
1975int GUIAction::installapp(std::string arg __unused)
1976{
1977 int op_status = 1;
1978 operation_start("Install TWRP App");
1979 if (!simulate)
1980 {
1981 if (DataManager::GetIntValue("tw_mount_system_ro") > 0 || DataManager::GetIntValue("tw_app_install_system") == 0) {
1982 if (PartitionManager.Mount_By_Path("/data", true)) {
1983 string install_path = "/data/app";
1984 string context = "u:object_r:apk_data_file:s0";
1985 if (!TWFunc::Path_Exists(install_path)) {
1986 if (mkdir(install_path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) {
1987 LOGERR("Error making %s directory: %s\n", install_path.c_str(), strerror(errno));
1988 goto exit;
1989 }
1990 if (chown(install_path.c_str(), 1000, 1000)) {
1991 LOGERR("chown %s error: %s\n", install_path.c_str(), strerror(errno));
1992 goto exit;
1993 }
Ethan Yonker4767caf2017-01-11 10:45:04 -06001994 if (setfilecon(install_path.c_str(), (security_context_t)context.c_str()) < 0) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06001995 LOGERR("setfilecon %s error: %s\n", install_path.c_str(), strerror(errno));
1996 goto exit;
1997 }
1998 }
1999 install_path += "/me.twrp.twrpapp-1";
2000 if (mkdir(install_path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) {
2001 LOGERR("Error making %s directory: %s\n", install_path.c_str(), strerror(errno));
2002 goto exit;
2003 }
2004 if (chown(install_path.c_str(), 1000, 1000)) {
2005 LOGERR("chown %s error: %s\n", install_path.c_str(), strerror(errno));
2006 goto exit;
2007 }
Ethan Yonker4767caf2017-01-11 10:45:04 -06002008 if (setfilecon(install_path.c_str(), (security_context_t)context.c_str()) < 0) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002009 LOGERR("setfilecon %s error: %s\n", install_path.c_str(), strerror(errno));
2010 goto exit;
2011 }
2012 install_path += "/base.apk";
bigbiffad58e1b2020-07-06 20:24:34 -04002013 if (TWFunc::copy_file("/system/bin/me.twrp.twrpapp.apk", install_path, 0644)) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002014 LOGERR("Error copying apk file\n");
2015 goto exit;
2016 }
2017 if (chown(install_path.c_str(), 1000, 1000)) {
2018 LOGERR("chown %s error: %s\n", install_path.c_str(), strerror(errno));
2019 goto exit;
2020 }
Ethan Yonker4767caf2017-01-11 10:45:04 -06002021 if (setfilecon(install_path.c_str(), (security_context_t)context.c_str()) < 0) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002022 LOGERR("setfilecon %s error: %s\n", install_path.c_str(), strerror(errno));
2023 goto exit;
2024 }
2025 sync();
2026 sync();
2027 }
2028 } else {
Captain Throwback9d6feb52018-07-27 10:05:24 -04002029 if (PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), true)) {
2030 string base_path = PartitionManager.Get_Android_Root_Path();
2031 if (TWFunc::Path_Exists(PartitionManager.Get_Android_Root_Path() + "/system"))
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002032 base_path += "/system"; // For devices with system as a root file system (e.g. Pixel)
2033 string install_path = base_path + "/priv-app";
2034 string context = "u:object_r:system_file:s0";
2035 if (!TWFunc::Path_Exists(install_path))
2036 install_path = base_path + "/app";
2037 if (TWFunc::Path_Exists(install_path)) {
2038 install_path += "/twrpapp";
2039 LOGINFO("Installing app to '%s'\n", install_path.c_str());
2040 if (mkdir(install_path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0) {
Ethan Yonker4767caf2017-01-11 10:45:04 -06002041 if (setfilecon(install_path.c_str(), (security_context_t)context.c_str()) < 0) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002042 LOGERR("setfilecon %s error: %s\n", install_path.c_str(), strerror(errno));
2043 goto exit;
2044 }
2045 install_path += "/me.twrp.twrpapp.apk";
bigbiffad58e1b2020-07-06 20:24:34 -04002046 if (TWFunc::copy_file("/system/bin/me.twrp.twrpapp.apk", install_path, 0644)) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002047 LOGERR("Error copying apk file\n");
2048 goto exit;
2049 }
Ethan Yonker4767caf2017-01-11 10:45:04 -06002050 if (setfilecon(install_path.c_str(), (security_context_t)context.c_str()) < 0) {
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002051 LOGERR("setfilecon %s error: %s\n", install_path.c_str(), strerror(errno));
2052 goto exit;
2053 }
Stefan Tauner6ad14572020-01-11 22:28:53 +01002054
2055 // System apps require their permissions to be pre-set via an XML file in /etc/permissions
2056 string permission_path = base_path + "/etc/permissions/privapp-permissions-twrpapp.xml";
bigbiffad58e1b2020-07-06 20:24:34 -04002057 if (TWFunc::copy_file("/system/bin/privapp-permissions-twrpapp.xml", permission_path, 0644)) {
Stefan Tauner6ad14572020-01-11 22:28:53 +01002058 LOGERR("Error copying permission file\n");
2059 goto exit;
2060 }
2061 if (chown(permission_path.c_str(), 1000, 1000)) {
2062 LOGERR("chown %s error: %s\n", permission_path.c_str(), strerror(errno));
2063 goto exit;
2064 }
2065 if (setfilecon(permission_path.c_str(), (security_context_t)context.c_str()) < 0) {
2066 LOGERR("setfilecon %s error: %s\n", permission_path.c_str(), strerror(errno));
2067 goto exit;
2068 }
2069
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002070 sync();
2071 sync();
Captain Throwback9d6feb52018-07-27 10:05:24 -04002072 PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), true);
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002073 op_status = 0;
2074 } else {
2075 LOGERR("Error making app directory '%s': %s\n", strerror(errno));
2076 }
2077 }
2078 }
2079 }
2080 } else
2081 simulate_progress_bar();
2082exit:
epicX271bb3a2020-12-30 01:03:18 +05302083 TWFunc::checkforapp();
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -06002084 operation_end(0);
2085 return 0;
2086}
Ethan Yonker53796e72019-01-11 22:49:52 -06002087
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05002088int GUIAction::uninstalltwrpsystemapp(std::string arg __unused)
2089{
2090 int op_status = 1;
2091 operation_start("Uninstall TWRP System App");
2092 if (!simulate)
2093 {
2094 int Mount_System_RO = DataManager::GetIntValue("tw_mount_system_ro");
2095 TWPartition* Part = PartitionManager.Find_Partition_By_Path(PartitionManager.Get_Android_Root_Path());
2096 if (!Part) {
2097 LOGERR("Unabled to find system partition.\n");
2098 goto exit;
2099 }
2100 if (!Part->UnMount(true)) {
2101 goto exit;
2102 }
2103 if (Mount_System_RO > 0) {
2104 DataManager::SetValue("tw_mount_system_ro", 0);
2105 Part->Change_Mount_Read_Only(false);
2106 }
2107 if (Part->Mount(true)) {
2108 string base_path = PartitionManager.Get_Android_Root_Path();
2109 if (TWFunc::Path_Exists(PartitionManager.Get_Android_Root_Path() + "/system"))
2110 base_path += "/system"; // For devices with system as a root file system (e.g. Pixel)
2111 string uninstall_path = base_path + "/priv-app";
2112 if (!TWFunc::Path_Exists(uninstall_path))
2113 uninstall_path = base_path + "/app";
2114 uninstall_path += "/twrpapp";
2115 if (TWFunc::Path_Exists(uninstall_path)) {
2116 LOGINFO("Uninstalling TWRP App from '%s'\n", uninstall_path.c_str());
2117 if (TWFunc::removeDir(uninstall_path, false) == 0) {
2118 sync();
2119 op_status = 0;
2120 DataManager::SetValue("tw_app_installed_in_system", 0);
2121 DataManager::SetValue("tw_app_install_status", 0);
2122 } else {
2123 LOGERR("Unable to remove TWRP app from system.\n");
2124 }
2125 } else {
2126 LOGINFO("didn't find TWRP app in '%s'\n", uninstall_path.c_str());
2127 }
2128 }
2129 Part->UnMount(true);
2130 if (Mount_System_RO > 0) {
2131 DataManager::SetValue("tw_mount_system_ro", Mount_System_RO);
2132 Part->Change_Mount_Read_Only(true);
2133 }
2134 } else
2135 simulate_progress_bar();
2136exit:
epicX271bb3a2020-12-30 01:03:18 +05302137 TWFunc::checkforapp();
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05002138 operation_end(0);
2139 return 0;
2140}
2141
Ethan Yonker53796e72019-01-11 22:49:52 -06002142int GUIAction::repackimage(std::string arg __unused)
2143{
2144 int op_status = 1;
bigbiffad58e1b2020-07-06 20:24:34 -04002145 twrpRepacker repacker;
2146
Ethan Yonker53796e72019-01-11 22:49:52 -06002147 operation_start("Repack Image");
2148 if (!simulate)
2149 {
2150 std::string path = DataManager::GetStrValue("tw_filename");
2151 Repack_Options_struct Repack_Options;
2152 Repack_Options.Disable_Verity = false;
2153 Repack_Options.Disable_Force_Encrypt = false;
2154 Repack_Options.Backup_First = DataManager::GetIntValue("tw_repack_backup_first") != 0;
2155 if (DataManager::GetIntValue("tw_repack_kernel") == 1)
2156 Repack_Options.Type = REPLACE_KERNEL;
2157 else
2158 Repack_Options.Type = REPLACE_RAMDISK;
bigbiffad58e1b2020-07-06 20:24:34 -04002159 if (!repacker.Repack_Image_And_Flash(path, Repack_Options))
Ethan Yonker53796e72019-01-11 22:49:52 -06002160 goto exit;
2161 } else
2162 simulate_progress_bar();
2163 op_status = 0;
2164exit:
2165 operation_end(op_status);
2166 return 0;
2167}
2168
nebrassyac29e692021-05-20 13:03:30 +02002169int GUIAction::reflashtwrp(std::string arg __unused)
2170{
2171 int op_status = 1;
2172 twrpRepacker repacker;
2173
2174 operation_start("Repack Image");
2175 if (!simulate)
2176 {
2177 if (!repacker.Flash_Current_Twrp())
2178 goto exit;
2179 } else
2180 simulate_progress_bar();
2181 op_status = 0;
2182exit:
2183 operation_end(op_status);
2184 return 0;
2185}
Ethan Yonker53796e72019-01-11 22:49:52 -06002186int GUIAction::fixabrecoverybootloop(std::string arg __unused)
2187{
2188 int op_status = 1;
bigbiffad58e1b2020-07-06 20:24:34 -04002189 twrpRepacker repacker;
2190
Ethan Yonker53796e72019-01-11 22:49:52 -06002191 operation_start("Repack Image");
2192 if (!simulate)
2193 {
bigbiffad58e1b2020-07-06 20:24:34 -04002194 if (!TWFunc::Path_Exists("/system/bin/magiskboot")) {
Ethan Yonker53796e72019-01-11 22:49:52 -06002195 LOGERR("Image repacking tool not present in this TWRP build!");
2196 goto exit;
2197 }
2198 DataManager::SetProgress(0);
2199 TWPartition* part = PartitionManager.Find_Partition_By_Path("/boot");
2200 if (part)
2201 gui_msg(Msg("unpacking_image=Unpacking {1}...")(part->Display_Name));
2202 else {
2203 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")("/boot"));
2204 goto exit;
2205 }
bigbiffad58e1b2020-07-06 20:24:34 -04002206 if (!repacker.Backup_Image_For_Repack(part, REPACK_ORIG_DIR, DataManager::GetIntValue("tw_repack_backup_first") != 0, gui_lookup("repack", "Repack")))
Ethan Yonker53796e72019-01-11 22:49:52 -06002207 goto exit;
2208 DataManager::SetProgress(.25);
2209 gui_msg("fixing_recovery_loop_patch=Patching kernel...");
bigbiffad58e1b2020-07-06 20:24:34 -04002210 std::string command = "cd " REPACK_ORIG_DIR " && /system/bin/magiskboot hexpatch kernel 77616E745F696E697472616D667300 736B69705F696E697472616D667300";
Ethan Yonker53796e72019-01-11 22:49:52 -06002211 if (TWFunc::Exec_Cmd(command) != 0) {
2212 gui_msg(Msg(msg::kError, "fix_recovery_loop_patch_error=Error patching kernel."));
2213 goto exit;
2214 }
2215 std::string header_path = REPACK_ORIG_DIR;
2216 header_path += "header";
2217 if (TWFunc::Path_Exists(header_path)) {
2218 command = "cd " REPACK_ORIG_DIR " && sed -i \"s|$(grep '^cmdline=' header | cut -d= -f2-)|$(grep '^cmdline=' header | cut -d= -f2- | sed -e 's/skip_override//' -e 's/ */ /g' -e 's/[ \t]*$//')|\" header";
2219 if (TWFunc::Exec_Cmd(command) != 0) {
2220 gui_msg(Msg(msg::kError, "fix_recovery_loop_patch_error=Error patching kernel."));
2221 goto exit;
2222 }
2223 }
2224 DataManager::SetProgress(.5);
2225 gui_msg(Msg("repacking_image=Repacking {1}...")(part->Display_Name));
bigbiffad58e1b2020-07-06 20:24:34 -04002226 command = "cd " REPACK_ORIG_DIR " && /system/bin/magiskboot repack " REPACK_ORIG_DIR "boot.img";
Ethan Yonker53796e72019-01-11 22:49:52 -06002227 if (TWFunc::Exec_Cmd(command) != 0) {
2228 gui_msg(Msg(msg::kError, "repack_error=Error repacking image."));
2229 goto exit;
2230 }
2231 DataManager::SetProgress(.75);
2232 std::string path = REPACK_ORIG_DIR;
2233 std::string file = "new-boot.img";
2234 DataManager::SetValue("tw_flash_partition", "/boot;");
2235 if (!PartitionManager.Flash_Image(path, file)) {
2236 LOGINFO("Error flashing new image\n");
2237 goto exit;
2238 }
2239 DataManager::SetProgress(1);
2240 TWFunc::removeDir(REPACK_ORIG_DIR, false);
2241 } else
2242 simulate_progress_bar();
2243 op_status = 0;
2244exit:
2245 operation_end(op_status);
2246 return 0;
2247}
bigbiffdf8436b2020-08-30 16:22:34 -04002248
2249
2250int GUIAction::enableadb(std::string arg __unused) {
2251 android::base::SetProperty("sys.usb.config", "none");
2252 android::base::SetProperty("sys.usb.config", "adb");
2253 return 0;
2254}
2255
2256int GUIAction::enablefastboot(std::string arg __unused) {
2257 android::base::SetProperty("sys.usb.config", "none");
2258 android::base::SetProperty("sys.usb.config", "fastboot");
2259 return 0;
2260}
Mohd Faraz77bbeb02020-08-12 12:29:42 +00002261
2262int GUIAction::changeterminal(std::string arg) {
2263 bool res = true;
2264 std::string resp, cmd = "cd " + arg;
2265 DataManager::GetValue("tw_terminal_location", resp);
2266 if (arg.empty() && !resp.empty()) {
2267 cmd = "cd /";
2268 for (uint8_t iter = 0; iter < cmd.size(); iter++)
2269 term->NotifyCharInput(cmd.at(iter));
2270 term->NotifyCharInput(13);
2271 DataManager::SetValue("tw_terminal_location", "");
2272 return 0;
2273 }
2274 if (term != NULL && !arg.empty()) {
2275 DataManager::SetValue("tw_terminal_location", arg);
2276 if (term->status()) {
2277 for (uint8_t iter = 0; iter < cmd.size(); iter++)
2278 term->NotifyCharInput(cmd.at(iter));
2279 term->NotifyCharInput(13);
2280 }
2281 else if (chdir(arg.c_str()) != 0) {
2282 LOGINFO("Unable to change dir to %s\n", arg.c_str());
2283 res = false;
2284 }
2285 }
2286 else {
2287 res = false;
2288 LOGINFO("Unable to switch to Terminal\n");
2289 }
2290 if (res)
2291 gui_changePage("terminalcommand");
2292 return 0;
2293}
bigbiffcfa875c2021-06-20 16:20:27 -04002294
2295int GUIAction::unmapsuperdevices(std::string arg __unused) {
2296 int op_status = 1;
2297
2298 operation_start("Remove Super Devices");
2299 if (simulate) {
2300 simulate_progress_bar();
2301 } else {
2302 if (PartitionManager.Unmap_Super_Devices()) {
2303 op_status = 0;
2304 }
2305 }
2306
2307 operation_end(op_status);
2308 return 0;
2309}
2310
Captain Throwback16dd81b2021-02-12 19:32:36 -05002311#ifndef TW_EXCLUDE_NANO
2312int GUIAction::editfile(std::string arg) {
2313 if (term != NULL) {
2314 for (uint8_t iter = 0; iter < arg.size(); iter++)
2315 term->NotifyCharInput(arg.at(iter));
2316 term->NotifyCharInput(13);
2317 }
2318 else
2319 LOGINFO("Unable to switch to Terminal\n");
2320 return 0;
2321}
2322#endif
epicXa721f952021-01-04 13:01:31 +05302323
2324int GUIAction::applycustomtwrpfolder(string arg __unused)
2325{
2326 operation_start("ChangingTWRPFolder");
Mohd Farazf9231102022-06-18 22:51:55 +02002327 string storageFolder = DataManager::GetCurrentStoragePath();
epicXa721f952021-01-04 13:01:31 +05302328 string newFolder = storageFolder + '/' + arg;
2329 string newBackupFolder = newFolder + "/BACKUPS/" + DataManager::GetStrValue("device_id");
2330 string prevFolder = storageFolder + DataManager::GetStrValue(TW_RECOVERY_FOLDER_VAR);
2331 bool ret = false;
2332
2333 if (TWFunc::Path_Exists(newFolder)) {
2334 gui_msg(Msg(msg::kError, "tw_folder_exists=A folder with that name already exists!"));
2335 } else {
2336 ret = true;
2337 }
2338
2339 if (newFolder != prevFolder && ret) {
2340 ret = TWFunc::Exec_Cmd("mv -f \"" + prevFolder + "\" \"" + newFolder + '\"') != 0 ? false : true;
2341 } else {
2342 gui_msg(Msg(msg::kError, "tw_folder_exists=A folder with that name already exists!"));
2343 }
2344
epicX11e90832021-03-01 00:02:57 +05302345 if (ret) ret = TWFunc::Recursive_Mkdir(newBackupFolder) ? true : false;
epicXa721f952021-01-04 13:01:31 +05302346
2347
2348 if (ret) {
2349 DataManager::SetValue(TW_RECOVERY_FOLDER_VAR, '/' + arg);
2350 DataManager::SetValue(TW_BACKUPS_FOLDER_VAR, newBackupFolder);
Fernando Oliveira25062d72023-02-01 12:52:32 -03002351 //Creates an empty file that marks which folder is TWRP with the renamed new name, after reboot.
2352 string path= newFolder + "/.twrpcf";
2353 std::ofstream twrpcf(path);
2354 twrpcf.close();
epicXa721f952021-01-04 13:01:31 +05302355 }
2356 operation_end((int)!ret);
2357 return 0;
2358}
bigbiffd21252f2021-09-18 15:56:32 -04002359
2360int GUIAction::mergesnapshots(string arg __unused) {
2361 int op_status = 1;
2362 if (PartitionManager.Check_Pending_Merges()) {
2363 op_status = 0;
2364 }
2365 operation_end(op_status);
2366 return 0;
Captain Throwback9b5a17f2022-05-26 14:14:12 -04002367}