blob: 22efb18dba0d0b2b96b32697cd29ed25c99a60c4 [file] [log] [blame]
Dees_Troy51a0e822012-09-05 15:24:24 -04001/*
bigbiffab76bd72021-10-11 10:17:48 -04002 Copyright 2012 to 2021 TeamWin
Dees Troy3be70a82013-10-22 14:25:12 +00003 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
Dees_Troy51a0e822012-09-05 15:24:24 -040019#include <pthread.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040020#include <time.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040021#include <string>
Dees_Troy51a0e822012-09-05 15:24:24 -040022#include <sstream>
Ethan Yonker3fdcda42016-11-30 12:29:37 -060023#include <fstream>
Ethan Yonkerfe916112016-03-14 14:54:37 -050024#include <cctype>
25#include <cutils/properties.h>
Ethan Yonker34ae4832016-08-24 15:32:18 -050026#include <unistd.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040027
28#include "variables.h"
29#include "data.hpp"
30#include "partitions.hpp"
Dees_Troy01a9b7a2012-10-01 09:01:03 -040031#include "twrp-functions.hpp"
Ricardo Gomezc9ecd442013-07-05 16:13:52 -070032#ifndef TW_NO_SCREEN_TIMEOUT
Dees_Troy2f9117a2013-02-17 19:52:09 -060033#include "gui/blanktimer.hpp"
Ricardo Gomezc9ecd442013-07-05 16:13:52 -070034#endif
Ethan Yonker00028b42014-04-09 14:29:02 -050035#include "find_file.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060036#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050037#include "gui/gui.hpp"
Ethan Yonkerfe916112016-03-14 14:54:37 -050038#include "infomanager.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040039
Matt Mowere9260742015-02-22 20:20:18 -060040#define DEVID_MAX 64
41#define HWID_MAX 32
Anatoly Smaznov10c11f62013-02-12 13:33:40 +070042
Dees_Troy51a0e822012-09-05 15:24:24 -040043extern "C"
44{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020045 #include "twcommon.h"
Dees_Troy7d15c252012-09-05 20:47:21 -040046 #include "gui/pages.h"
Dees_Troy7d15c252012-09-05 20:47:21 -040047 void gui_notifyVarChange(const char *name, const char* value);
Dees_Troy51a0e822012-09-05 15:24:24 -040048}
Ethan Yonkerfbb43532015-12-28 21:54:50 +010049#include "minuitwrp/minui.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040050
Ethan Yonkerfe916112016-03-14 14:54:37 -050051#define FILE_VERSION 0x00010010 // Do not set to 0
Dees_Troy51a0e822012-09-05 15:24:24 -040052
53using namespace std;
54
Ricardo Gomezc9ecd442013-07-05 16:13:52 -070055string DataManager::mBackingFile;
56int DataManager::mInitialized = 0;
Ethan Yonkerfe916112016-03-14 14:54:37 -050057InfoManager DataManager::mPersist; // Data that that is not constant and will be saved to the settings file
58InfoManager DataManager::mData; // Data that is not constant and will not be saved to settings file
59InfoManager DataManager::mConst; // Data that is constant and will not be saved to settings file
Jenkins1710bf22014-10-02 20:22:21 -040060
Ethan Yonker6277c792014-09-15 14:54:30 -050061extern bool datamedia;
Dees_Troy51a0e822012-09-05 15:24:24 -040062
Ethan Yonkerc798c9c2015-10-09 11:15:26 -050063#ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
Vojtech Bocekfda239b2015-01-07 22:55:13 +010064pthread_mutex_t DataManager::m_valuesLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
Ethan Yonkerc798c9c2015-10-09 11:15:26 -050065#else
66pthread_mutex_t DataManager::m_valuesLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
67#endif
Vojtech Bocekfda239b2015-01-07 22:55:13 +010068
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040069// Device ID functions
70void DataManager::sanitize_device_id(char* device_id) {
Matt Mowere9260742015-02-22 20:20:18 -060071 const char* whitelist ="-._";
72 char str[DEVID_MAX];
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040073 char* c = str;
74
Matt Mowere9260742015-02-22 20:20:18 -060075 snprintf(str, DEVID_MAX, "%s", device_id);
76 memset(device_id, 0, strlen(device_id));
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040077 while (*c) {
Matt Mowere9260742015-02-22 20:20:18 -060078 if (isalnum(*c) || strchr(whitelist, *c))
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040079 strncat(device_id, c, 1);
80 c++;
81 }
82 return;
83}
84
Vojtech Bocekfafb0c52013-07-25 22:53:02 +020085#define CMDLINE_SERIALNO "androidboot.serialno="
86#define CMDLINE_SERIALNO_LEN (strlen(CMDLINE_SERIALNO))
87#define CPUINFO_SERIALNO "Serial"
88#define CPUINFO_SERIALNO_LEN (strlen(CPUINFO_SERIALNO))
89#define CPUINFO_HARDWARE "Hardware"
90#define CPUINFO_HARDWARE_LEN (strlen(CPUINFO_HARDWARE))
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040091
92void DataManager::get_device_id(void) {
93 FILE *fp;
94 char line[2048];
Matt Mowere9260742015-02-22 20:20:18 -060095 char hardware_id[HWID_MAX] = { 0 };
96 char device_id[DEVID_MAX] = { 0 };
Dees_Troyfdf5fcc2012-09-11 10:27:01 -040097 char* token;
98
Anatoly Smaznov10c11f62013-02-12 13:33:40 +070099#ifdef TW_USE_MODEL_HARDWARE_ID_FOR_DEVICE_ID
Matt Mowere9260742015-02-22 20:20:18 -0600100 // Use (product_model)_(hardware_id) as device id
Anatoly Smaznov10c11f62013-02-12 13:33:40 +0700101 char model_id[PROPERTY_VALUE_MAX];
102 property_get("ro.product.model", model_id, "error");
Matt Mowere9260742015-02-22 20:20:18 -0600103 if (strcmp(model_id, "error") != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000104 LOGINFO("=> product model: '%s'\n", model_id);
Anatoly Smaznov10c11f62013-02-12 13:33:40 +0700105 // Replace spaces with underscores
Matt Mower23d8aae2017-01-06 14:30:33 -0600106 for (size_t i = 0; i < strlen(model_id); i++) {
Matt Mowere9260742015-02-22 20:20:18 -0600107 if (model_id[i] == ' ')
108 model_id[i] = '_';
Anatoly Smaznov10c11f62013-02-12 13:33:40 +0700109 }
Matt Mowere9260742015-02-22 20:20:18 -0600110 snprintf(device_id, DEVID_MAX, "%s", model_id);
111
112 if (strlen(device_id) < DEVID_MAX) {
113 fp = fopen("proc_cpuinfo.txt", "rt");
114 if (fp != NULL) {
115 while (fgets(line, sizeof(line), fp) != NULL) {
116 if (memcmp(line, CPUINFO_HARDWARE,
117 CPUINFO_HARDWARE_LEN) == 0) {
118 // skip past "Hardware", spaces, and colon
119 token = line + CPUINFO_HARDWARE_LEN;
120 while (*token && (!isgraph(*token) || *token == ':'))
121 token++;
122
123 if (*token && *token != '\n'
124 && strcmp("UNKNOWN\n", token)) {
125 snprintf(hardware_id, HWID_MAX, "%s", token);
126 if (hardware_id[strlen(hardware_id)-1] == '\n')
127 hardware_id[strlen(hardware_id)-1] = 0;
128 LOGINFO("=> hardware id from cpuinfo: '%s'\n",
129 hardware_id);
130 }
131 break;
132 }
133 }
134 fclose(fp);
135 }
Anatoly Smaznov10c11f62013-02-12 13:33:40 +0700136 }
Matt Mowere9260742015-02-22 20:20:18 -0600137
138 if (hardware_id[0] != 0)
139 snprintf(device_id, DEVID_MAX, "%s_%s", model_id, hardware_id);
140
141 sanitize_device_id(device_id);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500142 mConst.SetValue("device_id", device_id);
Dees_Troy2673cec2013-04-02 20:22:16 +0000143 LOGINFO("=> using device id: '%s'\n", device_id);
Anatoly Smaznov10c11f62013-02-12 13:33:40 +0700144 return;
145 }
146#endif
147
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400148#ifndef TW_FORCE_CPUINFO_FOR_DEVICE_ID
lambdadroidfc0b16d2017-08-04 17:16:53 +0200149#ifdef TW_USE_SERIALNO_PROPERTY_FOR_DEVICE_ID
150 // Check serial number system property
151 if (property_get("ro.serialno", line, "")) {
152 snprintf(device_id, DEVID_MAX, "%s", line);
153 sanitize_device_id(device_id);
154 mConst.SetValue("device_id", device_id);
155 return;
156 }
157#endif
158
Matt Mowere9260742015-02-22 20:20:18 -0600159 // Check the cmdline to see if the serial number was supplied
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400160 fp = fopen("/proc/cmdline", "rt");
Matt Mowere9260742015-02-22 20:20:18 -0600161 if (fp != NULL) {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200162 fgets(line, sizeof(line), fp);
Matt Mowere9260742015-02-22 20:20:18 -0600163 fclose(fp); // cmdline is only one line long
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400164
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200165 token = strtok(line, " ");
Matt Mowere9260742015-02-22 20:20:18 -0600166 while (token) {
167 if (memcmp(token, CMDLINE_SERIALNO, CMDLINE_SERIALNO_LEN) == 0) {
168 token += CMDLINE_SERIALNO_LEN;
169 snprintf(device_id, DEVID_MAX, "%s", token);
170 sanitize_device_id(device_id); // also removes newlines
Ethan Yonkerfe916112016-03-14 14:54:37 -0500171 mConst.SetValue("device_id", device_id);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200172 return;
173 }
174 token = strtok(NULL, " ");
175 }
176 }
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400177#endif
Matt Mowere9260742015-02-22 20:20:18 -0600178 // Check cpuinfo for serial number; if found, use as device_id
179 // If serial number is not found, fallback to hardware_id for the device_id
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400180 fp = fopen("/proc/cpuinfo", "rt");
Matt Mowere9260742015-02-22 20:20:18 -0600181 if (fp != NULL) {
182 while (fgets(line, sizeof(line), fp) != NULL) {
183 if (memcmp(line, CPUINFO_SERIALNO, CPUINFO_SERIALNO_LEN) == 0) {
184 // skip past "Serial", spaces, and colon
185 token = line + CPUINFO_SERIALNO_LEN;
186 while (*token && (!isgraph(*token) || *token == ':'))
187 token++;
188
189 if (*token && *token != '\n') {
190 snprintf(device_id, DEVID_MAX, "%s", token);
191 sanitize_device_id(device_id); // also removes newlines
Dees_Troy2673cec2013-04-02 20:22:16 +0000192 LOGINFO("=> serial from cpuinfo: '%s'\n", device_id);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500193 mConst.SetValue("device_id", device_id);
Matt Mowere9260742015-02-22 20:20:18 -0600194 fclose(fp);
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400195 return;
196 }
Matt Mowere9260742015-02-22 20:20:18 -0600197 } else if (memcmp(line, CPUINFO_HARDWARE,
198 CPUINFO_HARDWARE_LEN) == 0) {
199 // skip past "Hardware", spaces, and colon
200 token = line + CPUINFO_HARDWARE_LEN;
201 while (*token && (!isgraph(*token) || *token == ':'))
202 token++;
203
204 if (*token && *token != '\n') {
205 snprintf(hardware_id, HWID_MAX, "%s", token);
206 if (hardware_id[strlen(hardware_id)-1] == '\n')
207 hardware_id[strlen(hardware_id)-1] = 0;
Dees_Troy2673cec2013-04-02 20:22:16 +0000208 LOGINFO("=> hardware id from cpuinfo: '%s'\n", hardware_id);
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400209 }
210 }
211 }
212 fclose(fp);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200213 }
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400214
215 if (hardware_id[0] != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000216 LOGINFO("\nusing hardware id for device id: '%s'\n", hardware_id);
Matt Mowere9260742015-02-22 20:20:18 -0600217 snprintf(device_id, DEVID_MAX, "%s", hardware_id);
218 sanitize_device_id(device_id);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500219 mConst.SetValue("device_id", device_id);
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400220 return;
221 }
222
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200223 strcpy(device_id, "serialno");
Ethan Yonker74db1572015-10-28 12:44:49 -0500224 LOGINFO("=> device id not found, using '%s'\n", device_id);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500225 mConst.SetValue("device_id", device_id);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200226 return;
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400227}
228
Dees_Troy51a0e822012-09-05 15:24:24 -0400229int DataManager::ResetDefaults()
230{
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100231 pthread_mutex_lock(&m_valuesLock);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500232 mPersist.Clear();
233 mData.Clear();
234 mConst.Clear();
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100235 pthread_mutex_unlock(&m_valuesLock);
236
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200237 SetDefaultValues();
238 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400239}
240
Ethan Yonkerfe916112016-03-14 14:54:37 -0500241int DataManager::LoadValues(const string& filename)
Dees_Troy51a0e822012-09-05 15:24:24 -0400242{
nkk7198fc3992017-12-16 16:26:42 +0200243 string dev_id;
Dees_Troy51a0e822012-09-05 15:24:24 -0400244
245 if (!mInitialized)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200246 SetDefaultValues();
Dees_Troy51a0e822012-09-05 15:24:24 -0400247
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200248 GetValue("device_id", dev_id);
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400249 // Save off the backing file for set operations
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200250 mBackingFile = filename;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500251 mPersist.SetFile(filename);
252 mPersist.SetFileVersion(FILE_VERSION);
Dees_Troy51a0e822012-09-05 15:24:24 -0400253
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200254 // Read in the file, if possible
Ethan Yonkerfe916112016-03-14 14:54:37 -0500255 pthread_mutex_lock(&m_valuesLock);
256 mPersist.LoadValues();
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100257
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700258#ifndef TW_NO_SCREEN_TIMEOUT
Ethan Yonkerfe916112016-03-14 14:54:37 -0500259 blankTimer.setTime(mPersist.GetIntValue("tw_screen_timeout_secs"));
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700260#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500261
262 pthread_mutex_unlock(&m_valuesLock);
Dees_Troya13d74f2013-03-24 08:54:55 -0500263 string current = GetCurrentStoragePath();
Ethan Yonkereeed3c52014-04-16 11:49:02 -0500264 TWPartition* Part = PartitionManager.Find_Partition_By_Path(current);
Matt Mowera8a89d12016-12-30 18:10:37 -0600265 if (!Part)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +0200266 Part = PartitionManager.Get_Default_Storage_Partition();
267 if (Part && current != Part->Storage_Path && Part->Mount(false)) {
Ethan Yonkereeed3c52014-04-16 11:49:02 -0500268 LOGINFO("LoadValues setting storage path to '%s'\n", Part->Storage_Path.c_str());
269 SetValue("tw_storage_path", Part->Storage_Path);
Dees_Troya13d74f2013-03-24 08:54:55 -0500270 } else {
271 SetBackupFolder();
272 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200273 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400274}
275
276int DataManager::Flush()
277{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200278 return SaveValues();
Dees_Troy51a0e822012-09-05 15:24:24 -0400279}
280
281int DataManager::SaveValues()
282{
Ethan Yonker83e82572014-04-04 10:59:28 -0500283#ifndef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200284 if (mBackingFile.empty())
285 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400286
287 string mount_path = GetSettingsStoragePath();
Dees_Troy5bf43922012-09-07 16:07:55 -0400288 PartitionManager.Mount_By_Path(mount_path.c_str(), 1);
Dees_Troy51a0e822012-09-05 15:24:24 -0400289
Ethan Yonkerfe916112016-03-14 14:54:37 -0500290 mPersist.SetFile(mBackingFile);
291 mPersist.SetFileVersion(FILE_VERSION);
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100292 pthread_mutex_lock(&m_valuesLock);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500293 mPersist.SaveValues();
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100294 pthread_mutex_unlock(&m_valuesLock);
295
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600296 tw_set_default_metadata(mBackingFile.c_str());
nkk7198fc3992017-12-16 16:26:42 +0200297 LOGINFO("Saved settings file values to '%s'\n", mBackingFile.c_str());
Ethan Yonker83e82572014-04-04 10:59:28 -0500298#endif // ifdef TW_OEM_BUILD
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200299 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400300}
301
Ethan Yonkerfe916112016-03-14 14:54:37 -0500302int DataManager::GetValue(const string& varName, string& value)
Dees_Troy51a0e822012-09-05 15:24:24 -0400303{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200304 string localStr = varName;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500305 int ret = 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400306
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200307 if (!mInitialized)
308 SetDefaultValues();
Dees_Troy51a0e822012-09-05 15:24:24 -0400309
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200310 // Strip off leading and trailing '%' if provided
311 if (localStr.length() > 2 && localStr[0] == '%' && localStr[localStr.length()-1] == '%')
312 {
313 localStr.erase(0, 1);
314 localStr.erase(localStr.length() - 1, 1);
315 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400316
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200317 // Handle magic values
318 if (GetMagicValue(localStr, value) == 0)
319 return 0;
Xuefera163f152015-03-26 22:45:04 +0800320
321 // Handle property
322 if (localStr.length() > 9 && localStr.substr(0, 9) == "property.") {
323 char property_value[PROPERTY_VALUE_MAX];
324 property_get(localStr.substr(9).c_str(), property_value, "");
325 value = property_value;
326 return 0;
327 }
328
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100329 pthread_mutex_lock(&m_valuesLock);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500330 ret = mConst.GetValue(localStr, value);
331 if (ret == 0)
332 goto exit;
Dees_Troy51a0e822012-09-05 15:24:24 -0400333
Ethan Yonkerfe916112016-03-14 14:54:37 -0500334 ret = mPersist.GetValue(localStr, value);
335 if (ret == 0)
336 goto exit;
337
338 ret = mData.GetValue(localStr, value);
339exit:
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100340 pthread_mutex_unlock(&m_valuesLock);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500341 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -0400342}
343
Ethan Yonkerfe916112016-03-14 14:54:37 -0500344int DataManager::GetValue(const string& varName, int& value)
Dees_Troy51a0e822012-09-05 15:24:24 -0400345{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200346 string data;
Dees_Troy51a0e822012-09-05 15:24:24 -0400347
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200348 if (GetValue(varName,data) != 0)
349 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400350
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200351 value = atoi(data.c_str());
352 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400353}
354
Ethan Yonkerfe916112016-03-14 14:54:37 -0500355int DataManager::GetValue(const string& varName, float& value)
Dees_Troy2673cec2013-04-02 20:22:16 +0000356{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200357 string data;
Dees_Troy2673cec2013-04-02 20:22:16 +0000358
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200359 if (GetValue(varName,data) != 0)
360 return -1;
Dees_Troy2673cec2013-04-02 20:22:16 +0000361
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200362 value = atof(data.c_str());
363 return 0;
Dees_Troy2673cec2013-04-02 20:22:16 +0000364}
365
nkk7198fc3992017-12-16 16:26:42 +0200366int DataManager::GetValue(const string& varName, unsigned long long& value)
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500367{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200368 string data;
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500369
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200370 if (GetValue(varName,data) != 0)
371 return -1;
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500372
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200373 value = strtoull(data.c_str(), NULL, 10);
374 return 0;
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500375}
376
Dees_Troy51a0e822012-09-05 15:24:24 -0400377// This function will return an empty string if the value doesn't exist
Ethan Yonkerfe916112016-03-14 14:54:37 -0500378string DataManager::GetStrValue(const string& varName)
Dees_Troy51a0e822012-09-05 15:24:24 -0400379{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200380 string retVal;
Dees_Troy51a0e822012-09-05 15:24:24 -0400381
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200382 GetValue(varName, retVal);
383 return retVal;
Dees_Troy51a0e822012-09-05 15:24:24 -0400384}
385
386// This function will return 0 if the value doesn't exist
Ethan Yonkerfe916112016-03-14 14:54:37 -0500387int DataManager::GetIntValue(const string& varName)
Dees_Troy51a0e822012-09-05 15:24:24 -0400388{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200389 string retVal;
Dees_Troy51a0e822012-09-05 15:24:24 -0400390
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200391 GetValue(varName, retVal);
392 return atoi(retVal.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400393}
394
Ethan Yonkerfe916112016-03-14 14:54:37 -0500395int DataManager::SetValue(const string& varName, const string& value, const int persist /* = 0 */)
Dees_Troy51a0e822012-09-05 15:24:24 -0400396{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200397 if (!mInitialized)
398 SetDefaultValues();
Dees_Troy51a0e822012-09-05 15:24:24 -0400399
Xuefera163f152015-03-26 22:45:04 +0800400 // Handle property
401 if (varName.length() > 9 && varName.substr(0, 9) == "property.") {
402 int ret = property_set(varName.substr(9).c_str(), value.c_str());
403 if (ret)
404 LOGERR("Error setting property '%s' to '%s'\n", varName.substr(9).c_str(), value.c_str());
405 return ret;
406 }
407
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200408 // Don't allow empty values or numerical starting values
409 if (varName.empty() || (varName[0] >= '0' && varName[0] <= '9'))
410 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400411
Ethan Yonkerfe916112016-03-14 14:54:37 -0500412 string test;
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100413 pthread_mutex_lock(&m_valuesLock);
Ethan Yonkerfe916112016-03-14 14:54:37 -0500414 int constChk = mConst.GetValue(varName, test);
415 if (constChk == 0) {
416 pthread_mutex_unlock(&m_valuesLock);
417 return -1;
418 }
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100419
Ethan Yonkerfe916112016-03-14 14:54:37 -0500420 if (persist) {
421 mPersist.SetValue(varName, value);
422 } else {
423 int persistChk = mPersist.GetValue(varName, test);
424 if (persistChk == 0) {
425 mPersist.SetValue(varName, value);
426 } else {
427 mData.SetValue(varName, value);
428 }
429 }
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700430
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100431 pthread_mutex_unlock(&m_valuesLock);
432
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700433#ifndef TW_NO_SCREEN_TIMEOUT
bigbiff bigbifff8e2f372013-02-27 20:50:43 -0500434 if (varName == "tw_screen_timeout_secs") {
Dees_Troy2f9117a2013-02-17 19:52:09 -0600435 blankTimer.setTime(atoi(value.c_str()));
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700436 } else
437#endif
438 if (varName == "tw_storage_path") {
Dees_Troya13d74f2013-03-24 08:54:55 -0500439 SetBackupFolder();
bigbiff bigbifff8e2f372013-02-27 20:50:43 -0500440 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500441 gui_notifyVarChange(varName.c_str(), value.c_str());
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200442 return 0;
Dees_Troy51a0e822012-09-05 15:24:24 -0400443}
444
Ethan Yonkerfe916112016-03-14 14:54:37 -0500445int DataManager::SetValue(const string& varName, const int value, const int persist /* = 0 */)
Dees_Troy51a0e822012-09-05 15:24:24 -0400446{
447 ostringstream valStr;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200448 valStr << value;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200449 return SetValue(varName, valStr.str(), persist);
Dees_Troy51a0e822012-09-05 15:24:24 -0400450}
451
Ethan Yonkerfe916112016-03-14 14:54:37 -0500452int DataManager::SetValue(const string& varName, const float value, const int persist /* = 0 */)
Dees_Troy51a0e822012-09-05 15:24:24 -0400453{
454 ostringstream valStr;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200455 valStr << value;
456 return SetValue(varName, valStr.str(), persist);;
Dees_Troy51a0e822012-09-05 15:24:24 -0400457}
458
Ethan Yonkerfe916112016-03-14 14:54:37 -0500459int DataManager::SetValue(const string& varName, const unsigned long long& value, const int persist /* = 0 */)
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500460{
461 ostringstream valStr;
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200462 valStr << value;
463 return SetValue(varName, valStr.str(), persist);
bigbiff bigbiff2c57d782013-02-19 10:09:21 -0500464}
465
Chaosmasterd5364a02020-02-03 15:38:02 +0100466// For legacy code that doesn't set a scope
Ethan Yonkerfe916112016-03-14 14:54:37 -0500467int DataManager::SetProgress(const float Fraction) {
Chaosmasterd5364a02020-02-03 15:38:02 +0100468 if (SetValue("ui_portion_size", 0) != 0)
469 return -1;
470 if (SetValue("ui_portion_start", 0) != 0)
471 return -1;
472 ShowProgress(1, 0);
473 int res = _SetProgress(Fraction);
474 if (SetValue("ui_portion_size", 0) != 0)
475 return -1;
476 if (SetValue("ui_portion_start", 0) != 0)
477 return -1;
478 return res;
Dees_Troy2673cec2013-04-02 20:22:16 +0000479}
480
Chaosmasterd5364a02020-02-03 15:38:02 +0100481int DataManager::_SetProgress(float Fraction) {
482 float Portion_Start, Portion_Size;
483 GetValue("ui_portion_size", Portion_Size);
484 GetValue("ui_portion_start", Portion_Start);
485 //LOGINFO("SetProgress(%.2lf): Portion_Size: %.2lf Portion_Start: %.2lf\n", Fraction, Portion_Size, Portion_Start);
486 if (Fraction < 0.0)
487 Fraction = 0;
488 if (Fraction > 1.0)
489 Fraction = 1;
490 if (SetValue("ui_progress", (float) ((Portion_Start + (Portion_Size * Fraction)) * 100.0)) != 0)
491 return -1;
492 return (SetValue("ui_progress_portion", 0) != 0);
493}
494
495int DataManager::ShowProgress(float Portion, const float Seconds)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200496{
Chaosmasterd5364a02020-02-03 15:38:02 +0100497 float Portion_Start, Portion_Size;
498 GetValue("ui_portion_size", Portion_Size);
499 GetValue("ui_portion_start", Portion_Start);
500 Portion_Start += Portion_Size;
501 if(Portion + Portion_Start > 1.0)
502 Portion = 1.0 - Portion_Start;
503 //LOGINFO("ShowProgress(%.2lf, %.2lf): Portion_Start: %.2lf\n", Portion, Seconds, Portion_Start);
504 if (SetValue("ui_portion_start", Portion_Start) != 0)
Dees_Troy2673cec2013-04-02 20:22:16 +0000505 return -1;
Chaosmasterd5364a02020-02-03 15:38:02 +0100506 if (SetValue("ui_portion_size", Portion) != 0)
Dees_Troy2673cec2013-04-02 20:22:16 +0000507 return -1;
Chaosmasterd5364a02020-02-03 15:38:02 +0100508 if (SetValue("ui_progress", (float)(Portion_Start * 100.0)) != 0)
509 return -1;
510 if(Seconds) {
511 if (SetValue("ui_progress_portion", (float)((Portion * 100.0) + Portion_Start)) != 0)
512 return -1;
513 if (SetValue("ui_progress_frames", Seconds * 48) != 0)
514 return -1;
515 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000516 return 0;
517}
518
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200519void DataManager::update_tz_environment_variables(void)
520{
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100521 setenv("TZ", GetStrValue(TW_TIME_ZONE_VAR).c_str(), 1);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200522 tzset();
Dees_Troy8170a922012-09-18 15:40:25 -0400523}
524
Dees_Troy16b74352012-11-14 22:27:31 +0000525void DataManager::SetBackupFolder()
526{
527 string str = GetCurrentStoragePath();
Dees_Troya13d74f2013-03-24 08:54:55 -0500528 TWPartition* partition = PartitionManager.Find_Partition_By_Path(str);
epicXa721f952021-01-04 13:01:31 +0530529 str += TWFunc::Check_For_TwrpFolder() + "/BACKUPS/";
Dees_Troy16b74352012-11-14 22:27:31 +0000530
531 string dev_id;
532 GetValue("device_id", dev_id);
533
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200534 str += dev_id;
Dees_Troy2673cec2013-04-02 20:22:16 +0000535 LOGINFO("Backup folder set to '%s'\n", str.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +0000536 SetValue(TW_BACKUPS_FOLDER_VAR, str, 0);
Dees_Troya13d74f2013-03-24 08:54:55 -0500537 if (partition != NULL) {
538 SetValue("tw_storage_display_name", partition->Storage_Name);
539 char free_space[255];
540 sprintf(free_space, "%llu", partition->Free / 1024 / 1024);
541 SetValue("tw_storage_free_size", free_space);
542 string zip_path, zip_root, storage_path;
543 GetValue(TW_ZIP_LOCATION_VAR, zip_path);
Ethan Yonkereadfd2e2016-02-18 22:04:18 -0600544 if (partition->Has_Data_Media && !partition->Symlink_Mount_Point.empty())
Dees_Troya13d74f2013-03-24 08:54:55 -0500545 storage_path = partition->Symlink_Mount_Point;
546 else
547 storage_path = partition->Storage_Path;
548 if (zip_path.size() < storage_path.size()) {
549 SetValue(TW_ZIP_LOCATION_VAR, storage_path);
550 } else {
Dees Troyc2e9bc72013-09-10 00:16:24 +0000551 zip_root = TWFunc::Get_Root_Path(zip_path);
Dees_Troy18727952013-06-20 15:24:48 -0500552 if (zip_root != storage_path) {
553 LOGINFO("DataManager::SetBackupFolder zip path was %s changing to %s, %s\n", zip_path.c_str(), storage_path.c_str(), zip_root.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500554 SetValue(TW_ZIP_LOCATION_VAR, storage_path);
Dees_Troy18727952013-06-20 15:24:48 -0500555 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500556 }
557 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500558 if (PartitionManager.Fstab_Processed() != 0) {
559 LOGINFO("Storage partition '%s' not found\n", str.c_str());
560 gui_err("unable_locate_storage=Unable to locate storage device.");
561 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500562 }
Dees_Troy16b74352012-11-14 22:27:31 +0000563}
564
Dees_Troy51a0e822012-09-05 15:24:24 -0400565void DataManager::SetDefaultValues()
566{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200567 string str, path;
Dees_Troy51a0e822012-09-05 15:24:24 -0400568
Ethan Yonkerfe916112016-03-14 14:54:37 -0500569 mConst.SetConst();
570
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200571 get_device_id();
Dees_Troy51a0e822012-09-05 15:24:24 -0400572
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100573 pthread_mutex_lock(&m_valuesLock);
574
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200575 mInitialized = 1;
Dees_Troy51a0e822012-09-05 15:24:24 -0400576
Ethan Yonkerfe916112016-03-14 14:54:37 -0500577 mConst.SetValue("true", "1");
578 mConst.SetValue("false", "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400579
Ethan Yonkerfe916112016-03-14 14:54:37 -0500580 mConst.SetValue(TW_VERSION_VAR, TW_VERSION_STR);
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -0400581
582#ifndef TW_NO_HAPTICS
Ethan Yonkerfe916112016-03-14 14:54:37 -0500583 mPersist.SetValue("tw_button_vibrate", "80");
584 mPersist.SetValue("tw_keyboard_vibrate", "40");
585 mPersist.SetValue("tw_action_vibrate", "160");
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -0400586 mConst.SetValue("tw_disable_haptics", "0");
587#else
588 LOGINFO("TW_NO_HAPTICS := true\n");
589 mConst.SetValue("tw_disable_haptics", "1");
590#endif
Dees_Troy51a0e822012-09-05 15:24:24 -0400591
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +0200592 TWPartition *store = PartitionManager.Get_Default_Storage_Partition();
Matt Mowera8a89d12016-12-30 18:10:37 -0600593 if (store)
Ethan Yonkerfe916112016-03-14 14:54:37 -0500594 mPersist.SetValue("tw_storage_path", store->Storage_Path);
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +0200595 else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500596 mPersist.SetValue("tw_storage_path", "/");
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +0200597
Dees_Troyf4499812013-01-23 19:07:38 +0000598#ifdef TW_FORCE_CPUINFO_FOR_DEVICE_ID
599 printf("TW_FORCE_CPUINFO_FOR_DEVICE_ID := true\n");
600#endif
601
Dees_Troy51a0e822012-09-05 15:24:24 -0400602#ifdef BOARD_HAS_NO_REAL_SDCARD
Dees_Troyf4499812013-01-23 19:07:38 +0000603 printf("BOARD_HAS_NO_REAL_SDCARD := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500604 mConst.SetValue(TW_ALLOW_PARTITION_SDCARD, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400605#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500606 mConst.SetValue(TW_ALLOW_PARTITION_SDCARD, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400607#endif
608
609#ifdef TW_INCLUDE_DUMLOCK
Dees_Troyf4499812013-01-23 19:07:38 +0000610 printf("TW_INCLUDE_DUMLOCK := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500611 mConst.SetValue(TW_SHOW_DUMLOCK, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400612#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500613 mConst.SetValue(TW_SHOW_DUMLOCK, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400614#endif
615
epicXa721f952021-01-04 13:01:31 +0530616 mData.SetValue(TW_RECOVERY_FOLDER_VAR, TW_DEFAULT_RECOVERY_FOLDER);
617
Dees_Troy51a0e822012-09-05 15:24:24 -0400618 str = GetCurrentStoragePath();
Ethan Yonkerfe916112016-03-14 14:54:37 -0500619 mPersist.SetValue(TW_ZIP_LOCATION_VAR, str);
epicXa721f952021-01-04 13:01:31 +0530620 str += DataManager::GetStrValue(TW_RECOVERY_FOLDER_VAR) + "/BACKUPS/";
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400621
622 string dev_id;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500623 mConst.GetValue("device_id", dev_id);
Dees_Troyfdf5fcc2012-09-11 10:27:01 -0400624
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200625 str += dev_id;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500626 mData.SetValue(TW_BACKUPS_FOLDER_VAR, str);
Dees_Troy51a0e822012-09-05 15:24:24 -0400627
Ethan Yonkerfe916112016-03-14 14:54:37 -0500628 mConst.SetValue(TW_REBOOT_SYSTEM, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400629#ifdef TW_NO_REBOOT_RECOVERY
Talustus33ebf932013-02-02 14:11:14 +0100630 printf("TW_NO_REBOOT_RECOVERY := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500631 mConst.SetValue(TW_REBOOT_RECOVERY, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400632#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500633 mConst.SetValue(TW_REBOOT_RECOVERY, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400634#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500635 mConst.SetValue(TW_REBOOT_POWEROFF, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400636#ifdef TW_NO_REBOOT_BOOTLOADER
Talustus33ebf932013-02-02 14:11:14 +0100637 printf("TW_NO_REBOOT_BOOTLOADER := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500638 mConst.SetValue(TW_REBOOT_BOOTLOADER, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400639#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500640 mConst.SetValue(TW_REBOOT_BOOTLOADER, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400641#endif
642#ifdef RECOVERY_SDCARD_ON_DATA
Dees_Troyf4499812013-01-23 19:07:38 +0000643 printf("RECOVERY_SDCARD_ON_DATA := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500644 mConst.SetValue(TW_HAS_DATA_MEDIA, "1");
Ethan Yonker6277c792014-09-15 14:54:30 -0500645 datamedia = true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400646#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500647 mData.SetValue(TW_HAS_DATA_MEDIA, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400648#endif
649#ifdef TW_NO_BATT_PERCENT
Dees_Troyf4499812013-01-23 19:07:38 +0000650 printf("TW_NO_BATT_PERCENT := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500651 mConst.SetValue(TW_NO_BATTERY_PERCENT, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400652#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500653 mConst.SetValue(TW_NO_BATTERY_PERCENT, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400654#endif
Jenkins1710bf22014-10-02 20:22:21 -0400655#ifdef TW_NO_CPU_TEMP
656 printf("TW_NO_CPU_TEMP := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500657 mConst.SetValue("tw_no_cpu_temp", "1");
Jenkins1710bf22014-10-02 20:22:21 -0400658#else
659 string cpu_temp_file;
660#ifdef TW_CUSTOM_CPU_TEMP_PATH
661 cpu_temp_file = EXPAND(TW_CUSTOM_CPU_TEMP_PATH);
662#else
663 cpu_temp_file = "/sys/class/thermal/thermal_zone0/temp";
664#endif
665 if (TWFunc::Path_Exists(cpu_temp_file)) {
Ethan Yonkerfe916112016-03-14 14:54:37 -0500666 mConst.SetValue("tw_no_cpu_temp", "0");
Jenkins1710bf22014-10-02 20:22:21 -0400667 } else {
668 LOGINFO("CPU temperature file '%s' not found, disabling CPU temp.\n", cpu_temp_file.c_str());
Ethan Yonkerfe916112016-03-14 14:54:37 -0500669 mConst.SetValue("tw_no_cpu_temp", "1");
Jenkins1710bf22014-10-02 20:22:21 -0400670 }
671#endif
Dees_Troy51a0e822012-09-05 15:24:24 -0400672#ifdef TW_CUSTOM_POWER_BUTTON
Dees_Troyf4499812013-01-23 19:07:38 +0000673 printf("TW_POWER_BUTTON := %s\n", EXPAND(TW_CUSTOM_POWER_BUTTON));
Ethan Yonkerfe916112016-03-14 14:54:37 -0500674 mConst.SetValue(TW_POWER_BUTTON, EXPAND(TW_CUSTOM_POWER_BUTTON));
Dees_Troy51a0e822012-09-05 15:24:24 -0400675#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500676 mConst.SetValue(TW_POWER_BUTTON, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400677#endif
678#ifdef TW_ALWAYS_RMRF
Dees_Troyf4499812013-01-23 19:07:38 +0000679 printf("TW_ALWAYS_RMRF := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500680 mConst.SetValue(TW_RM_RF_VAR, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400681#endif
682#ifdef TW_NEVER_UNMOUNT_SYSTEM
Dees_Troyf4499812013-01-23 19:07:38 +0000683 printf("TW_NEVER_UNMOUNT_SYSTEM := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500684 mConst.SetValue(TW_DONT_UNMOUNT_SYSTEM, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400685#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500686 mConst.SetValue(TW_DONT_UNMOUNT_SYSTEM, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400687#endif
688#ifdef TW_NO_USB_STORAGE
Dees_Troy6a042c82013-01-23 18:50:52 +0000689 printf("TW_NO_USB_STORAGE := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500690 mConst.SetValue(TW_HAS_USB_STORAGE, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400691#else
Dees_Troy6a042c82013-01-23 18:50:52 +0000692 char lun_file[255];
693 string Lun_File_str = CUSTOM_LUN_FILE;
694 size_t found = Lun_File_str.find("%");
695 if (found != string::npos) {
696 sprintf(lun_file, CUSTOM_LUN_FILE, 0);
697 Lun_File_str = lun_file;
698 }
699 if (!TWFunc::Path_Exists(Lun_File_str)) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000700 LOGINFO("Lun file '%s' does not exist, USB storage mode disabled\n", Lun_File_str.c_str());
Ethan Yonkerfe916112016-03-14 14:54:37 -0500701 mConst.SetValue(TW_HAS_USB_STORAGE, "0");
Dees_Troy6a042c82013-01-23 18:50:52 +0000702 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000703 LOGINFO("Lun file '%s'\n", Lun_File_str.c_str());
Ethan Yonkerfe916112016-03-14 14:54:37 -0500704 mData.SetValue(TW_HAS_USB_STORAGE, "1");
Dees_Troy6a042c82013-01-23 18:50:52 +0000705 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400706#endif
707#ifdef TW_INCLUDE_INJECTTWRP
Dees_Troyf4499812013-01-23 19:07:38 +0000708 printf("TW_INCLUDE_INJECTTWRP := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500709 mConst.SetValue(TW_HAS_INJECTTWRP, "1");
710 mPersist(TW_INJECT_AFTER_ZIP, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400711#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500712 mConst.SetValue(TW_HAS_INJECTTWRP, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400713#endif
Dees_Troy51a0e822012-09-05 15:24:24 -0400714#ifdef TW_HAS_DOWNLOAD_MODE
Dees_Troyf4499812013-01-23 19:07:38 +0000715 printf("TW_HAS_DOWNLOAD_MODE := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500716 mConst.SetValue(TW_DOWNLOAD_MODE, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400717#endif
mauronofrioe9a49ef2018-10-03 13:38:16 +0200718#ifdef TW_HAS_EDL_MODE
719 printf("TW_HAS_EDL_MODE := true\n");
720 mConst.SetValue(TW_EDL_MODE, "1");
721#endif
me-cafebabe97be4322022-08-14 05:57:16 +0800722#ifdef TW_INCLUDE_FASTBOOTD
723 printf("TW_INCLUDE_FASTBOOTD := true\n");
724 mConst.SetValue(TW_FASTBOOT_MODE, "1");
725#endif
bigbiffdf8436b2020-08-30 16:22:34 -0400726#ifdef PRODUCT_USE_DYNAMIC_PARTITIONS
727 printf("PRODUCT_USE_DYNAMIC_PARTITIONS := true\n");
728 mConst.SetValue(TW_FASTBOOT_MODE, "1");
bigbiffb640d972021-10-12 19:08:10 -0400729 mConst.SetValue(TW_IS_SUPER, "1");
730#else
731 mConst.SetValue(TW_IS_SUPER, "0");
bigbiffdf8436b2020-08-30 16:22:34 -0400732#endif
Dees_Troy51a0e822012-09-05 15:24:24 -0400733#ifdef TW_INCLUDE_CRYPTO
Ethan Yonkerfe916112016-03-14 14:54:37 -0500734 mConst.SetValue(TW_HAS_CRYPTO, "1");
Dees_Troyf4499812013-01-23 19:07:38 +0000735 printf("TW_INCLUDE_CRYPTO := true\n");
Dees_Troy51a0e822012-09-05 15:24:24 -0400736#endif
737#ifdef TW_SDEXT_NO_EXT4
Dees_Troyf4499812013-01-23 19:07:38 +0000738 printf("TW_SDEXT_NO_EXT4 := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500739 mConst.SetValue(TW_SDEXT_DISABLE_EXT4, "1");
Dees_Troy51a0e822012-09-05 15:24:24 -0400740#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500741 mConst.SetValue(TW_SDEXT_DISABLE_EXT4, "0");
Dees_Troy51a0e822012-09-05 15:24:24 -0400742#endif
743
Dees_Troya13d74f2013-03-24 08:54:55 -0500744#ifdef TW_HAS_NO_BOOT_PARTITION
Ethan Yonkerfe916112016-03-14 14:54:37 -0500745 mPersist.SetValue("tw_backup_list", "/system;/data;");
Dees_Troya13d74f2013-03-24 08:54:55 -0500746#else
bigbiffee7b7ff2020-03-23 15:08:27 -0400747#ifdef PRODUCT_USE_DYNAMIC_PARTITIONS
748 mPersist.SetValue("tw_backup_list", "/data;");
749#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500750 mPersist.SetValue("tw_backup_list", "/system;/data;/boot;");
Dees_Troya13d74f2013-03-24 08:54:55 -0500751#endif
bigbiffee7b7ff2020-03-23 15:08:27 -0400752#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500753 mConst.SetValue(TW_MIN_SYSTEM_VAR, TW_MIN_SYSTEM_SIZE);
754 mData.SetValue(TW_BACKUP_NAME, "(Auto Generate)");
bigbiff bigbiff7ce7f0c2013-01-25 09:54:04 -0500755
Matt Mower8dc25b72016-04-25 23:06:53 -0500756 mPersist.SetValue(TW_INSTALL_REBOOT_VAR, "0");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500757 mPersist.SetValue(TW_SIGNED_ZIP_VERIFY_VAR, "0");
Matt Mowerbfccfb82016-04-25 23:22:31 -0500758 mPersist.SetValue(TW_DISABLE_FREE_SPACE_VAR, "0");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400759 mPersist.SetValue(TW_FORCE_DIGEST_CHECK_VAR, "0");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500760 mPersist.SetValue(TW_USE_COMPRESSION_VAR, "0");
761 mPersist.SetValue(TW_TIME_ZONE_VAR, "CST6CDT,M3.2.0,M11.1.0");
762 mPersist.SetValue(TW_GUI_SORT_ORDER, "1");
763 mPersist.SetValue(TW_RM_RF_VAR, "0");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400764 mPersist.SetValue(TW_SKIP_DIGEST_CHECK_VAR, "0");
epicX9597b842021-03-20 21:58:17 +0530765 mPersist.SetValue(TW_SKIP_DIGEST_CHECK_ZIP_VAR, "1");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400766 mPersist.SetValue(TW_SKIP_DIGEST_GENERATE_VAR, "0");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500767 mPersist.SetValue(TW_SDEXT_SIZE, "0");
768 mPersist.SetValue(TW_SWAP_SIZE, "0");
769 mPersist.SetValue(TW_SDPART_FILE_SYSTEM, "ext3");
770 mPersist.SetValue(TW_TIME_ZONE_GUISEL, "CST6;CDT,M3.2.0,M11.1.0");
771 mPersist.SetValue(TW_TIME_ZONE_GUIOFFSET, "0");
772 mPersist.SetValue(TW_TIME_ZONE_GUIDST, "1");
bigbiffab76bd72021-10-11 10:17:48 -0400773 mPersist.SetValue(TW_AUTO_REFLASHTWRP_VAR, "0");
Captain Throwback02647a92023-01-11 13:46:30 -0500774#ifdef TW_NO_FLASH_CURRENT_TWRP
775 mConst.SetValue("tw_no_flash_current_twrp", "1");
776#else
777 mConst.SetValue("tw_no_flash_current_twrp", "0");
778#endif
nebrassyac29e692021-05-20 13:03:30 +0200779
Ethan Yonkerfe916112016-03-14 14:54:37 -0500780 mData.SetValue(TW_ACTION_BUSY, "0");
781 mData.SetValue("tw_wipe_cache", "0");
782 mData.SetValue("tw_wipe_dalvik", "0");
783 mData.SetValue(TW_ZIP_INDEX, "0");
784 mData.SetValue(TW_ZIP_QUEUE_COUNT, "0");
785 mData.SetValue(TW_FILENAME, "/sdcard");
786 mData.SetValue(TW_SIMULATE_ACTIONS, "0");
787 mData.SetValue(TW_SIMULATE_FAIL, "0");
788 mData.SetValue(TW_IS_ENCRYPTED, "0");
789 mData.SetValue(TW_IS_DECRYPTED, "0");
790 mData.SetValue(TW_CRYPTO_PASSWORD, "0");
Captain Throwbackccc18d42022-01-10 13:15:53 -0500791 mData.SetValue(TW_CRYPTO_PWTYPE, "0"); // Set initial value so that recovery will not be confused when using unencrypted data or failed to decrypt data
Ethan Yonkerfe916112016-03-14 14:54:37 -0500792 mData.SetValue("tw_terminal_state", "0");
793 mData.SetValue("tw_background_thread_running", "0");
794 mData.SetValue(TW_RESTORE_FILE_DATE, "0");
795 mPersist.SetValue("tw_military_time", "0");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400796
797#ifdef TW_INCLUDE_CRYPTO
bigbiff bigbiff9ee4a852018-09-19 19:13:19 -0400798 mPersist.SetValue(TW_USE_SHA2, "1");
799 mPersist.SetValue(TW_NO_SHA2, "0");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400800#else
bigbiff bigbiff9ee4a852018-09-19 19:13:19 -0400801 mPersist.SetValue(TW_NO_SHA2, "1");
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400802#endif
bigbiffcfa875c2021-06-20 16:20:27 -0400803#ifdef AB_OTA_UPDATER
804 mPersist.SetValue(TW_UNMOUNT_SYSTEM, "0");
805#else
Chaosmasterff4f9582020-01-26 15:38:11 +0100806 mPersist.SetValue(TW_UNMOUNT_SYSTEM, "1");
bigbiffcfa875c2021-06-20 16:20:27 -0400807#endif
Captain Throwbackbc2cfa32021-09-16 10:04:26 -0400808#if defined BOARD_USES_RECOVERY_AS_BOOT && defined BOARD_BUILD_SYSTEM_ROOT_IMAGE
809 mConst.SetValue("tw_uses_initramfs", "1");
810#else
811 mConst.SetValue("tw_uses_initramfs", "0");
812#endif
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700813#ifdef TW_NO_SCREEN_TIMEOUT
Ethan Yonkerfe916112016-03-14 14:54:37 -0500814 mConst.SetValue("tw_screen_timeout_secs", "0");
815 mConst.SetValue("tw_no_screen_timeout", "1");
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700816#else
Ethan Yonkerfe916112016-03-14 14:54:37 -0500817 mPersist.SetValue("tw_screen_timeout_secs", "60");
818 mPersist.SetValue("tw_no_screen_timeout", "0");
Ricardo Gomezc9ecd442013-07-05 16:13:52 -0700819#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500820 mData.SetValue("tw_gui_done", "0");
821 mData.SetValue("tw_encrypt_backup", "0");
Matt Mower9a2a2052016-05-31 21:31:22 -0500822 mData.SetValue("tw_sleep_total", "5");
823 mData.SetValue("tw_sleep", "5");
bigbiffdf8436b2020-08-30 16:22:34 -0400824 mData.SetValue("tw_enable_fastboot", "0");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500825
bigbiffab76bd72021-10-11 10:17:48 -0400826
827 if (android::base::GetBoolProperty("ro.virtual_ab.enabled", false))
828 mConst.SetValue("tw_virtual_ab.enabled", "1");
829 else
830 mConst.SetValue("tw_virtual_ab.enabled", "0");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500831 // Brightness handling
Ethan Yonker00028b42014-04-09 14:29:02 -0500832 string findbright;
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900833#ifdef TW_BRIGHTNESS_PATH
834 findbright = EXPAND(TW_BRIGHTNESS_PATH);
835 LOGINFO("TW_BRIGHTNESS_PATH := %s\n", findbright.c_str());
836 if (!TWFunc::Path_Exists(findbright)) {
837 LOGINFO("Specified brightness file '%s' not found.\n", findbright.c_str());
838 findbright = "";
Ethan Yonker00028b42014-04-09 14:29:02 -0500839 }
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900840#endif
Ethan Yonker00028b42014-04-09 14:29:02 -0500841 if (findbright.empty()) {
842 // Attempt to locate the brightness file
843 findbright = Find_File::Find("brightness", "/sys/class/backlight");
Ethan Yonker9c102b52014-04-15 11:06:18 -0500844 if (findbright.empty()) findbright = Find_File::Find("brightness", "/sys/class/leds/lcd-backlight");
Ethan Yonker00028b42014-04-09 14:29:02 -0500845 }
846 if (findbright.empty()) {
847 LOGINFO("Unable to locate brightness file\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500848 mConst.SetValue("tw_has_brightnesss_file", "0");
Ethan Yonker00028b42014-04-09 14:29:02 -0500849 } else {
850 LOGINFO("Found brightness file at '%s'\n", findbright.c_str());
Ethan Yonkerfe916112016-03-14 14:54:37 -0500851 mConst.SetValue("tw_has_brightnesss_file", "1");
852 mConst.SetValue("tw_brightness_file", findbright);
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900853 string maxBrightness;
854#ifdef TW_MAX_BRIGHTNESS
Vojtech Bocek85932342013-04-01 22:11:33 +0200855 ostringstream maxVal;
856 maxVal << TW_MAX_BRIGHTNESS;
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900857 maxBrightness = maxVal.str();
858#else
859 // Attempt to locate the max_brightness file
860 string maxbrightpath = findbright.insert(findbright.rfind('/') + 1, "max_");
861 if (TWFunc::Path_Exists(maxbrightpath)) {
Ethan Yonker72a85202016-01-22 11:45:06 -0600862 ifstream maxVal(maxbrightpath.c_str());
Matt Mowera8a89d12016-12-30 18:10:37 -0600863 if (maxVal >> maxBrightness) {
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900864 LOGINFO("Got max brightness %s from '%s'\n", maxBrightness.c_str(), maxbrightpath.c_str());
865 } else {
866 // Something went wrong, set that to indicate error
867 maxBrightness = "-1";
868 }
869 }
Ethan Yonker72a85202016-01-22 11:45:06 -0600870 if (atoi(maxBrightness.c_str()) <= 0)
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900871 {
872 // Fallback into default
873 ostringstream maxVal;
874 maxVal << 255;
875 maxBrightness = maxVal.str();
876 }
877#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500878 mConst.SetValue("tw_brightness_max", maxBrightness);
879 mPersist.SetValue("tw_brightness", maxBrightness);
880 mPersist.SetValue("tw_brightness_pct", "100");
xNUTxe85f02d2014-07-18 01:30:58 +0200881#ifdef TW_SECONDARY_BRIGHTNESS_PATH
882 string secondfindbright = EXPAND(TW_SECONDARY_BRIGHTNESS_PATH);
883 if (secondfindbright != "" && TWFunc::Path_Exists(secondfindbright)) {
884 LOGINFO("Will use a second brightness file at '%s'\n", secondfindbright.c_str());
Ethan Yonkerfe916112016-03-14 14:54:37 -0500885 mConst.SetValue("tw_secondary_brightness_file", secondfindbright);
xNUTxe85f02d2014-07-18 01:30:58 +0200886 } else {
887 LOGINFO("Specified secondary brightness file '%s' not found.\n", secondfindbright.c_str());
888 }
889#endif
Greg Wallace36ade452015-11-08 13:54:25 -0500890#ifdef TW_DEFAULT_BRIGHTNESS
891 int defValInt = TW_DEFAULT_BRIGHTNESS;
Ethan Yonker72a85202016-01-22 11:45:06 -0600892 int maxValInt = atoi(maxBrightness.c_str());
Greg Wallace36ade452015-11-08 13:54:25 -0500893 // Deliberately int so the % is always a whole number
894 int defPctInt = ( ( (double)defValInt / maxValInt ) * 100 );
895 ostringstream defPct;
896 defPct << defPctInt;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500897 mPersist.SetValue("tw_brightness_pct", defPct.str());
Greg Wallace36ade452015-11-08 13:54:25 -0500898
899 ostringstream defVal;
900 defVal << TW_DEFAULT_BRIGHTNESS;
Ethan Yonkerfe916112016-03-14 14:54:37 -0500901 mPersist.SetValue("tw_brightness", defVal.str());
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900902 TWFunc::Set_Brightness(defVal.str());
Greg Wallace36ade452015-11-08 13:54:25 -0500903#else
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +0900904 TWFunc::Set_Brightness(maxBrightness);
Greg Wallace36ade452015-11-08 13:54:25 -0500905#endif
Dees_Troy2f9117a2013-02-17 19:52:09 -0600906 }
Ethan Yonkerfe916112016-03-14 14:54:37 -0500907
Dees_Troy83bd4832013-05-04 12:39:56 +0000908#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonkerfe916112016-03-14 14:54:37 -0500909 mConst.SetValue("tw_include_encrypted_backup", "1");
Dees_Troy83bd4832013-05-04 12:39:56 +0000910#else
911 LOGINFO("TW_EXCLUDE_ENCRYPTED_BACKUPS := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500912 mConst.SetValue("tw_include_encrypted_backup", "0");
Dees_Troy83bd4832013-05-04 12:39:56 +0000913#endif
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -0400914#ifdef TW_HAS_MTP
Ethan Yonkerfe916112016-03-14 14:54:37 -0500915 mConst.SetValue("tw_has_mtp", "1");
916 mPersist.SetValue("tw_mtp_enabled", "1");
917 mPersist.SetValue("tw_mtp_debug", "0");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -0400918#else
919 LOGINFO("TW_EXCLUDE_MTP := true\n");
Ethan Yonkerfe916112016-03-14 14:54:37 -0500920 mConst.SetValue("tw_has_mtp", "0");
921 mConst.SetValue("tw_mtp_enabled", "0");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -0400922#endif
Ethan Yonkerfe916112016-03-14 14:54:37 -0500923 mPersist.SetValue("tw_mount_system_ro", "2");
924 mPersist.SetValue("tw_never_show_system_ro_page", "0");
925 mPersist.SetValue("tw_language", EXPAND(TW_DEFAULT_LANGUAGE));
Ethan Yonker74db1572015-10-28 12:44:49 -0500926 LOGINFO("LANG: %s\n", EXPAND(TW_DEFAULT_LANGUAGE));
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100927
Ethan Yonkerfe916112016-03-14 14:54:37 -0500928 mData.SetValue("tw_has_adopted_storage", "0");
Ethan Yonker66a19492015-12-10 10:19:45 -0600929
Ethan Yonker1b190162016-12-05 15:25:19 -0600930#ifdef AB_OTA_UPDATER
931 LOGINFO("AB_OTA_UPDATER := true\n");
932 mConst.SetValue("tw_has_boot_slots", "1");
933#else
934 mConst.SetValue("tw_has_boot_slots", "0");
935#endif
nkk71b4c35912017-10-11 23:39:10 +0300936
Ethan Yonker75aa6152017-09-08 12:17:03 -0500937#ifdef TW_NO_LEGACY_PROPS
938 LOGINFO("TW_NO_LEGACY_PROPS := true\n");
Ethan Yonker75aa6152017-09-08 12:17:03 -0500939#endif
nkk71b4c35912017-10-11 23:39:10 +0300940
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600941#ifdef TW_OEM_BUILD
942 LOGINFO("TW_OEM_BUILD := true\n");
943 mConst.SetValue("tw_oem_build", "1");
Ethan Yonker76bbd3a2019-05-10 10:50:04 -0500944 mConst.SetValue("tw_app_installed_in_system", "0");
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600945#else
946 mConst.SetValue("tw_oem_build", "0");
947 mPersist.SetValue("tw_app_prompt", "1");
948 mPersist.SetValue("tw_app_install_system", "1");
949 mData.SetValue("tw_app_install_status", "0"); // 0 = no status, 1 = not installed, 2 = already installed
Ethan Yonker76bbd3a2019-05-10 10:50:04 -0500950 mData.SetValue("tw_app_installed_in_system", "0");
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600951#endif
Captain Throwback16dd81b2021-02-12 19:32:36 -0500952#ifndef TW_EXCLUDE_NANO
953 mConst.SetValue("tw_include_nano", "1");
954#else
955 LOGINFO("TW_EXCLUDE_NANO := true\n");
956 mConst.SetValue("tw_include_nano", "0");
957#endif
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600958
epicX8f52c0a2021-02-24 23:12:08 +0530959 mData.SetValue("tw_flash_both_slots", "0");
960 mData.SetValue("tw_is_slot_part", "0");
961
Ethan Yonker53796e72019-01-11 22:49:52 -0600962 mData.SetValue("tw_enable_adb_backup", "0");
963
Captain Throwback52978932021-09-05 15:11:07 -0400964 if (TWFunc::Path_Exists("/system/bin/logcat"))
965 mConst.SetValue("tw_logcat_exists", "1");
966 else
967 mConst.SetValue("tw_logcat_exists", "0");
968
bigbiffad58e1b2020-07-06 20:24:34 -0400969 if (TWFunc::Path_Exists("/system/bin/magiskboot"))
Ethan Yonker53796e72019-01-11 22:49:52 -0600970 mConst.SetValue("tw_has_repack_tools", "1");
971 else
972 mConst.SetValue("tw_has_repack_tools", "0");
jason972000adae3362017-12-08 09:08:45 -0600973
Vojtech Bocekfda239b2015-01-07 22:55:13 +0100974 pthread_mutex_unlock(&m_valuesLock);
Dees_Troy51a0e822012-09-05 15:24:24 -0400975}
976
977// Magic Values
Ethan Yonkerfe916112016-03-14 14:54:37 -0500978int DataManager::GetMagicValue(const string& varName, string& value)
Dees_Troy51a0e822012-09-05 15:24:24 -0400979{
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200980 // Handle special dynamic cases
981 if (varName == "tw_time")
982 {
983 char tmp[32];
Dees_Troy51a0e822012-09-05 15:24:24 -0400984
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200985 struct tm *current;
986 time_t now;
987 int tw_military_time;
988 now = time(0);
989 current = localtime(&now);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500990 GetValue(TW_MILITARY_TIME, tw_military_time);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200991 if (current->tm_hour >= 12)
992 {
993 if (tw_military_time == 1)
994 sprintf(tmp, "%d:%02d", current->tm_hour, current->tm_min);
995 else
996 sprintf(tmp, "%d:%02d PM", current->tm_hour == 12 ? 12 : current->tm_hour - 12, current->tm_min);
bigbiff bigbiff4efe9c32013-02-20 18:58:11 -0500997 }
bigbiff bigbiff4efe9c32013-02-20 18:58:11 -0500998 else
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200999 {
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001000 if (tw_military_time == 1)
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001001 sprintf(tmp, "%d:%02d", current->tm_hour, current->tm_min);
1002 else
1003 sprintf(tmp, "%d:%02d AM", current->tm_hour == 0 ? 12 : current->tm_hour, current->tm_min);
1004 }
1005 value = tmp;
1006 return 0;
bigbiff bigbiff4efe9c32013-02-20 18:58:11 -05001007 }
Jenkins1710bf22014-10-02 20:22:21 -04001008 else if (varName == "tw_cpu_temp")
1009 {
Matt Mowera8a89d12016-12-30 18:10:37 -06001010 int tw_no_cpu_temp;
1011 GetValue("tw_no_cpu_temp", tw_no_cpu_temp);
1012 if (tw_no_cpu_temp == 1) return -1;
Agontuka29361a2015-04-22 14:42:59 +06001013
Matt Mowera8a89d12016-12-30 18:10:37 -06001014 string cpu_temp_file;
1015 static unsigned long convert_temp = 0;
1016 static time_t cpuSecCheck = 0;
Matt Mowera8a89d12016-12-30 18:10:37 -06001017 struct timeval curTime;
1018 string results;
Jenkins1710bf22014-10-02 20:22:21 -04001019
Matt Mowera8a89d12016-12-30 18:10:37 -06001020 gettimeofday(&curTime, NULL);
1021 if (curTime.tv_sec > cpuSecCheck)
1022 {
Jenkins1710bf22014-10-02 20:22:21 -04001023#ifdef TW_CUSTOM_CPU_TEMP_PATH
Matt Mowera8a89d12016-12-30 18:10:37 -06001024 cpu_temp_file = EXPAND(TW_CUSTOM_CPU_TEMP_PATH);
1025 if (TWFunc::read_file(cpu_temp_file, results) != 0)
1026 return -1;
Jenkins1710bf22014-10-02 20:22:21 -04001027#else
Matt Mowera8a89d12016-12-30 18:10:37 -06001028 cpu_temp_file = "/sys/class/thermal/thermal_zone0/temp";
1029 if (TWFunc::read_file(cpu_temp_file, results) != 0)
1030 return -1;
Jenkins1710bf22014-10-02 20:22:21 -04001031#endif
Matt Mowera8a89d12016-12-30 18:10:37 -06001032 convert_temp = strtoul(results.c_str(), NULL, 0) / 1000;
1033 if (convert_temp <= 0)
1034 convert_temp = strtoul(results.c_str(), NULL, 0);
1035 if (convert_temp >= 150)
1036 convert_temp = strtoul(results.c_str(), NULL, 0) / 10;
1037 cpuSecCheck = curTime.tv_sec + 5;
1038 }
1039 value = TWFunc::to_string(convert_temp);
1040 return 0;
Jenkins1710bf22014-10-02 20:22:21 -04001041 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001042 else if (varName == "tw_battery")
1043 {
1044 char tmp[16];
Dees_Troy38bd7602012-09-14 13:33:53 -04001045 static char charging = ' ';
1046 static int lastVal = -1;
1047 static time_t nextSecCheck = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001048 struct timeval curTime;
1049 gettimeofday(&curTime, NULL);
1050 if (curTime.tv_sec > nextSecCheck)
1051 {
1052 char cap_s[4];
Dees_Troyf33b4902013-03-01 00:51:39 +00001053#ifdef TW_CUSTOM_BATTERY_PATH
1054 string capacity_file = EXPAND(TW_CUSTOM_BATTERY_PATH);
1055 capacity_file += "/capacity";
1056 FILE * cap = fopen(capacity_file.c_str(),"rt");
1057#else
Dees_Troy38bd7602012-09-14 13:33:53 -04001058 FILE * cap = fopen("/sys/class/power_supply/battery/capacity","rt");
Dees_Troyf33b4902013-03-01 00:51:39 +00001059#endif
Matt Mowera8a89d12016-12-30 18:10:37 -06001060 if (cap) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001061 fgets(cap_s, 4, cap);
1062 fclose(cap);
1063 lastVal = atoi(cap_s);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001064 if (lastVal > 100) lastVal = 101;
1065 if (lastVal < 0) lastVal = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001066 }
Dees_Troyf33b4902013-03-01 00:51:39 +00001067#ifdef TW_CUSTOM_BATTERY_PATH
1068 string status_file = EXPAND(TW_CUSTOM_BATTERY_PATH);
1069 status_file += "/status";
1070 cap = fopen(status_file.c_str(),"rt");
1071#else
Dees_Troy38bd7602012-09-14 13:33:53 -04001072 cap = fopen("/sys/class/power_supply/battery/status","rt");
Dees_Troyf33b4902013-03-01 00:51:39 +00001073#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001074 if (cap) {
1075 fgets(cap_s, 2, cap);
1076 fclose(cap);
1077 if (cap_s[0] == 'C')
1078 charging = '+';
1079 else
1080 charging = ' ';
1081 }
1082 nextSecCheck = curTime.tv_sec + 60;
1083 }
1084
1085 sprintf(tmp, "%i%%%c", lastVal, charging);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001086 value = tmp;
1087 return 0;
1088 }
1089 return -1;
Dees_Troy51a0e822012-09-05 15:24:24 -04001090}
1091
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001092void DataManager::Output_Version(void)
1093{
Ethan Yonker89583ef2015-08-26 09:01:59 -05001094#ifndef TW_OEM_BUILD
Dees_Troy1c1ac442013-01-17 21:42:14 +00001095 string Path;
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001096 char version[255];
1097
bigbiff25d25b92020-06-19 16:07:38 -04001098 std::string logDir = TWFunc::get_log_dir();
1099 if (logDir.empty()) {
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -04001100 LOGINFO("Unable to find cache directory\n");
1101 return;
1102 }
1103
bigbiff25d25b92020-06-19 16:07:38 -04001104 std::string recoveryLogDir = logDir + "recovery/";
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001105
bigbiff25d25b92020-06-19 16:07:38 -04001106 if (logDir == CACHE_LOGS_DIR) {
1107 if (!PartitionManager.Mount_By_Path(CACHE_LOGS_DIR, false)) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001108 LOGINFO("Unable to mount '%s' to write version number.\n", Path.c_str());
Dees_Troy1c1ac442013-01-17 21:42:14 +00001109 return;
1110 }
Mohd Farazf9ded062020-06-06 20:50:57 +05301111
bigbiff25d25b92020-06-19 16:07:38 -04001112 if (!TWFunc::Path_Exists(recoveryLogDir)) {
1113 LOGINFO("Recreating %s folder.\n", recoveryLogDir.c_str());
1114 if (!TWFunc::Create_Dir_Recursive(recoveryLogDir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP, 0, 0)) {
1115 LOGERR("DataManager::Output_Version -- Unable to make %s: %s\n", recoveryLogDir.c_str(), strerror(errno));
Mohd Farazf9ded062020-06-06 20:50:57 +05301116 return;
1117 }
1118 }
Dees_Troy1c1ac442013-01-17 21:42:14 +00001119 }
bigbiff7ba75002020-04-11 20:47:09 -04001120
bigbiff25d25b92020-06-19 16:07:38 -04001121 std::string verPath = recoveryLogDir + ".version";
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001122 if (TWFunc::Path_Exists(verPath)) {
1123 unlink(verPath.c_str());
1124 }
1125 FILE *fp = fopen(verPath.c_str(), "w");
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001126 if (fp == NULL) {
bigbiff13017c62021-09-29 19:04:31 -04001127 LOGINFO("Unable to open: %s. Data may be unmounted. Error: %s\n", verPath.c_str(), strerror(errno));
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001128 return;
1129 }
1130 strcpy(version, TW_VERSION_STR);
1131 fwrite(version, sizeof(version[0]), strlen(version) / sizeof(version[0]), fp);
1132 fclose(fp);
bigbiff25d25b92020-06-19 16:07:38 -04001133 TWFunc::copy_file("/etc/recovery.fstab", recoveryLogDir + "recovery.fstab", 0644);
Dees_Troyd93bda52013-07-03 19:55:19 +00001134 PartitionManager.Output_Storage_Fstab();
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001135 sync();
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001136 LOGINFO("Version number saved to '%s'\n", verPath.c_str());
Ethan Yonker89583ef2015-08-26 09:01:59 -05001137#endif
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001138}
1139
Dees_Troy51a0e822012-09-05 15:24:24 -04001140void DataManager::ReadSettingsFile(void)
1141{
Ethan Yonker83e82572014-04-04 10:59:28 -05001142#ifndef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -04001143 // Load up the values for TWRP - Sleep to let the card be ready
1144 char mkdir_path[255], settings_file[255];
Matt Mower23d8aae2017-01-06 14:30:33 -06001145 int is_enc, has_data_media;
Dees_Troy51a0e822012-09-05 15:24:24 -04001146
1147 GetValue(TW_IS_ENCRYPTED, is_enc);
1148 GetValue(TW_HAS_DATA_MEDIA, has_data_media);
Dees_Troy51a0e822012-09-05 15:24:24 -04001149
1150 memset(mkdir_path, 0, sizeof(mkdir_path));
1151 memset(settings_file, 0, sizeof(settings_file));
Mohd Faraz36072652022-06-18 22:51:55 +02001152 sprintf(mkdir_path, "%s%s", GetSettingsStoragePath().c_str(), GetStrValue(TW_RECOVERY_NAME).c_str());
epicXa721f952021-01-04 13:01:31 +05301153 sprintf(settings_file, "%s/%s", mkdir_path, TW_SETTINGS_FILE);
Dees_Troy51a0e822012-09-05 15:24:24 -04001154
Dees_Troy5bf43922012-09-07 16:07:55 -04001155 if (!PartitionManager.Mount_Settings_Storage(false))
Dees_Troy51a0e822012-09-05 15:24:24 -04001156 {
1157 usleep(500000);
Dees_Troy5bf43922012-09-07 16:07:55 -04001158 if (!PartitionManager.Mount_Settings_Storage(false))
Ethan Yonker74db1572015-10-28 12:44:49 -05001159 gui_msg(Msg(msg::kError, "unable_to_mount=Unable to mount {1}")(settings_file));
Dees_Troy51a0e822012-09-05 15:24:24 -04001160 }
1161
1162 mkdir(mkdir_path, 0777);
1163
Dees_Troy2673cec2013-04-02 20:22:16 +00001164 LOGINFO("Attempt to load settings from settings file...\n");
Dees_Troy51a0e822012-09-05 15:24:24 -04001165 LoadValues(settings_file);
Dees_Troy01a9b7a2012-10-01 09:01:03 -04001166 Output_Version();
Ethan Yonker83e82572014-04-04 10:59:28 -05001167#endif // ifdef TW_OEM_BUILD
Ethan Yonker7af51ce2014-04-04 13:33:30 -05001168 PartitionManager.Mount_All_Storage();
Dees_Troy8170a922012-09-18 15:40:25 -04001169 update_tz_environment_variables();
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001170 TWFunc::Set_Brightness(GetStrValue("tw_brightness"));
Dees_Troy51a0e822012-09-05 15:24:24 -04001171}
1172
1173string DataManager::GetCurrentStoragePath(void)
1174{
Dees_Troya13d74f2013-03-24 08:54:55 -05001175 return GetStrValue("tw_storage_path");
Dees_Troy51a0e822012-09-05 15:24:24 -04001176}
1177
Dees_Troy51a0e822012-09-05 15:24:24 -04001178string DataManager::GetSettingsStoragePath(void)
1179{
Dees_Troya13d74f2013-03-24 08:54:55 -05001180 return GetStrValue("tw_settings_path");
Dees_Troy51a0e822012-09-05 15:24:24 -04001181}
1182
Ethan Yonkerfe916112016-03-14 14:54:37 -05001183void DataManager::Vibrate(const string& varName)
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +00001184{
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -04001185#ifndef TW_NO_HAPTICS
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +00001186 int vib_value = 0;
1187 GetValue(varName, vib_value);
1188 if (vib_value) {
1189 vibrate(vib_value);
1190 }
bigbiff bigbiff3ed778a2019-03-12 19:28:31 -04001191#endif
Samer Diab (S.a.M.e.R_d)71e9b042014-01-07 20:18:47 +00001192}
epicXa721f952021-01-04 13:01:31 +05301193
1194
1195void DataManager::LoadTWRPFolderInfo(void)
1196{
epicXa721f952021-01-04 13:01:31 +05301197 SetValue(TW_RECOVERY_FOLDER_VAR, TWFunc::Check_For_TwrpFolder());
Mohd Faraz36072652022-06-18 22:51:55 +02001198 mBackingFile = GetSettingsStoragePath() + GetStrValue(TW_RECOVERY_NAME) + '/' + TW_SETTINGS_FILE;
nebrassyac29e692021-05-20 13:03:30 +02001199}