395 lines
16 KiB
C++
395 lines
16 KiB
C++
#include "SettingsActivity.h"
|
|
|
|
#include <GfxRenderer.h>
|
|
#include <Logging.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
|
|
#include "ButtonRemapActivity.h"
|
|
#include "ClearCacheActivity.h"
|
|
#include "CrossPointSettings.h"
|
|
#include "FontDownloadActivity.h"
|
|
#include "FontSelectionActivity.h"
|
|
#include "KOReaderSettingsActivity.h"
|
|
#include "LanguageSelectActivity.h"
|
|
#include "MappedInputManager.h"
|
|
#include "OpdsServerListActivity.h"
|
|
#include "OtaUpdateActivity.h"
|
|
#include "SdCardFontSystem.h"
|
|
#include "SdFirmwareUpdateActivity.h"
|
|
#include "SettingsList.h"
|
|
#include "StatusBarSettingsActivity.h"
|
|
#include "activities/network/WifiSelectionActivity.h"
|
|
#include "activities/util/IntervalSelectionActivity.h"
|
|
#include "components/UITheme.h"
|
|
#include "fontIds.h"
|
|
|
|
const StrId SettingsActivity::categoryNames[categoryCount] = {StrId::STR_CAT_DISPLAY, StrId::STR_CAT_READER,
|
|
StrId::STR_CAT_CONTROLS, StrId::STR_CAT_SYSTEM};
|
|
|
|
void SettingsActivity::rebuildSettingsLists() {
|
|
displaySettings.clear();
|
|
readerSettings.clear();
|
|
controlsSettings.clear();
|
|
systemSettings.clear();
|
|
|
|
// Pick up any fonts uploaded/deleted over the web server since the last
|
|
// reader activity ran — otherwise the font-family picker shows stale list.
|
|
sdFontSystem.refreshIfDirty();
|
|
|
|
for (auto& setting : getSettingsList(&sdFontSystem.registry())) {
|
|
if (setting.category == StrId::STR_NONE_OPT) continue;
|
|
if (setting.category == StrId::STR_CAT_DISPLAY) {
|
|
displaySettings.push_back(setting);
|
|
} else if (setting.category == StrId::STR_CAT_READER) {
|
|
readerSettings.push_back(setting);
|
|
} else if (setting.category == StrId::STR_CAT_CONTROLS) {
|
|
if (setting.valuePtr == &CrossPointSettings::pwrBtnFootnoteBack &&
|
|
SETTINGS.shortPwrBtn != CrossPointSettings::SHORT_PWRBTN::FOOTNOTES) {
|
|
continue;
|
|
}
|
|
controlsSettings.push_back(setting);
|
|
} else if (setting.category == StrId::STR_CAT_SYSTEM) {
|
|
systemSettings.push_back(setting);
|
|
}
|
|
}
|
|
|
|
// Append device-only ACTION items
|
|
controlsSettings.insert(controlsSettings.begin(),
|
|
SettingInfo::Action(StrId::STR_REMAP_FRONT_BUTTONS, SettingAction::RemapFrontButtons));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_WIFI_NETWORKS, SettingAction::Network));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_KOREADER_SYNC, SettingAction::KOReaderSync));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_OPDS_SERVERS, SettingAction::OPDSBrowser));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_CLEAR_READING_CACHE, SettingAction::ClearCache));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_CHECK_UPDATES, SettingAction::CheckForUpdates));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_SD_FIRMWARE_UPDATE, SettingAction::SdFirmwareUpdate));
|
|
systemSettings.push_back(SettingInfo::Action(StrId::STR_LANGUAGE, SettingAction::Language));
|
|
// Insert "Manage Fonts" right after the font family setting so users discover it naturally
|
|
readerSettings.insert(readerSettings.begin() + 1,
|
|
SettingInfo::Action(StrId::STR_MANAGE_FONTS, SettingAction::DownloadFonts));
|
|
readerSettings.push_back(SettingInfo::Action(StrId::STR_CUSTOMISE_STATUS_BAR, SettingAction::CustomiseStatusBar));
|
|
|
|
// Update currentSettings pointer and count for the active category
|
|
switch (selectedCategoryIndex) {
|
|
case 0:
|
|
currentSettings = &displaySettings;
|
|
break;
|
|
case 1:
|
|
currentSettings = &readerSettings;
|
|
break;
|
|
case 2:
|
|
currentSettings = &controlsSettings;
|
|
break;
|
|
case 3:
|
|
currentSettings = &systemSettings;
|
|
break;
|
|
}
|
|
settingsCount = static_cast<int>(currentSettings->size());
|
|
}
|
|
|
|
void SettingsActivity::onEnter() {
|
|
Activity::onEnter();
|
|
|
|
// Reset selection to first category
|
|
selectedCategoryIndex = 0;
|
|
selectedSettingIndex = 0;
|
|
preserveQuickResumeTimeoutOn =
|
|
SETTINGS.quickResumeSleepScreen == CrossPointSettings::QUICK_RESUME_SLEEP_SCREEN::QUICK_RESUME_AFTER_TIMEOUT;
|
|
quickResumeTimeoutAutoEnabled = false;
|
|
syncQuickResumeTimeoutForSleepScreen(/*sleepScreenChanged=*/true, /*quickResumeTimeoutChanged=*/false);
|
|
|
|
rebuildSettingsLists();
|
|
|
|
// Trigger first update
|
|
requestUpdate();
|
|
}
|
|
|
|
void SettingsActivity::onExit() {
|
|
Activity::onExit();
|
|
|
|
UITheme::getInstance().reload(); // Re-apply theme in case it was changed
|
|
}
|
|
|
|
void SettingsActivity::loop() {
|
|
bool hasChangedCategory = false;
|
|
|
|
// Handle actions with early return
|
|
if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
|
|
if (selectedSettingIndex == 0) {
|
|
selectedCategoryIndex = (selectedCategoryIndex < categoryCount - 1) ? (selectedCategoryIndex + 1) : 0;
|
|
hasChangedCategory = true;
|
|
requestUpdate();
|
|
} else {
|
|
toggleCurrentSetting();
|
|
requestUpdate();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
|
|
if (selectedSettingIndex > 0) {
|
|
selectedSettingIndex = 0;
|
|
requestUpdate();
|
|
} else {
|
|
SETTINGS.saveToFile();
|
|
onGoHome();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Handle navigation
|
|
buttonNavigator.onNextRelease([this] {
|
|
selectedSettingIndex = ButtonNavigator::nextIndex(selectedSettingIndex, settingsCount + 1);
|
|
requestUpdate();
|
|
});
|
|
|
|
buttonNavigator.onPreviousRelease([this] {
|
|
selectedSettingIndex = ButtonNavigator::previousIndex(selectedSettingIndex, settingsCount + 1);
|
|
requestUpdate();
|
|
});
|
|
|
|
buttonNavigator.onNextContinuous([this, &hasChangedCategory] {
|
|
hasChangedCategory = true;
|
|
selectedCategoryIndex = ButtonNavigator::nextIndex(selectedCategoryIndex, categoryCount);
|
|
requestUpdate();
|
|
});
|
|
|
|
buttonNavigator.onPreviousContinuous([this, &hasChangedCategory] {
|
|
hasChangedCategory = true;
|
|
selectedCategoryIndex = ButtonNavigator::previousIndex(selectedCategoryIndex, categoryCount);
|
|
requestUpdate();
|
|
});
|
|
|
|
if (hasChangedCategory) {
|
|
selectedSettingIndex = (selectedSettingIndex == 0) ? 0 : 1;
|
|
switch (selectedCategoryIndex) {
|
|
case 0:
|
|
currentSettings = &displaySettings;
|
|
break;
|
|
case 1:
|
|
currentSettings = &readerSettings;
|
|
break;
|
|
case 2:
|
|
currentSettings = &controlsSettings;
|
|
break;
|
|
case 3:
|
|
currentSettings = &systemSettings;
|
|
break;
|
|
}
|
|
settingsCount = static_cast<int>(currentSettings->size());
|
|
}
|
|
}
|
|
|
|
void SettingsActivity::toggleCurrentSetting() {
|
|
int selectedSetting = selectedSettingIndex - 1;
|
|
if (selectedSetting < 0 || selectedSetting >= settingsCount) {
|
|
return;
|
|
}
|
|
|
|
const auto& setting = (*currentSettings)[selectedSetting];
|
|
const bool sleepScreenChanged = setting.valuePtr == &CrossPointSettings::sleepScreen;
|
|
const bool quickResumeTimeoutChanged = setting.valuePtr == &CrossPointSettings::quickResumeSleepScreen;
|
|
|
|
if (setting.nameId == StrId::STR_TIME_TO_SLEEP) {
|
|
openSleepTimeoutPicker();
|
|
return;
|
|
}
|
|
|
|
if (setting.type == SettingType::TOGGLE && setting.valuePtr != nullptr) {
|
|
// Toggle the boolean value using the member pointer
|
|
const bool currentValue = SETTINGS.*(setting.valuePtr);
|
|
SETTINGS.*(setting.valuePtr) = !currentValue;
|
|
} else if (setting.type == SettingType::ENUM && setting.valuePtr != nullptr) {
|
|
const uint8_t currentValue = SETTINGS.*(setting.valuePtr);
|
|
SETTINGS.*(setting.valuePtr) = (currentValue + 1) % static_cast<uint8_t>(setting.enumValues.size());
|
|
} else if (setting.type == SettingType::ENUM && setting.valueGetter && setting.valueSetter) {
|
|
if (setting.nameId == StrId::STR_FONT_FAMILY) {
|
|
// Launch font selection submenu instead of cycling
|
|
startActivityForResult(std::make_unique<FontSelectionActivity>(renderer, mappedInput, &sdFontSystem.registry()),
|
|
[this](const ActivityResult&) {
|
|
SETTINGS.saveToFile();
|
|
rebuildSettingsLists();
|
|
});
|
|
return;
|
|
}
|
|
const uint8_t totalValues = setting.enumStringValues.empty()
|
|
? static_cast<uint8_t>(setting.enumValues.size())
|
|
: static_cast<uint8_t>(setting.enumStringValues.size());
|
|
const uint8_t cur = setting.valueGetter();
|
|
setting.valueSetter((cur + 1) % totalValues);
|
|
} else if (setting.type == SettingType::VALUE && setting.valuePtr != nullptr) {
|
|
const int8_t currentValue = SETTINGS.*(setting.valuePtr);
|
|
if (currentValue + setting.valueRange.step > setting.valueRange.max) {
|
|
SETTINGS.*(setting.valuePtr) = setting.valueRange.min;
|
|
} else {
|
|
SETTINGS.*(setting.valuePtr) = currentValue + setting.valueRange.step;
|
|
}
|
|
} else if (setting.type == SettingType::ACTION) {
|
|
auto resultHandler = [this](const ActivityResult&) { SETTINGS.saveToFile(); };
|
|
|
|
switch (setting.action) {
|
|
case SettingAction::RemapFrontButtons:
|
|
startActivityForResult(std::make_unique<ButtonRemapActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::CustomiseStatusBar:
|
|
startActivityForResult(std::make_unique<StatusBarSettingsActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::KOReaderSync:
|
|
startActivityForResult(std::make_unique<KOReaderSettingsActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::OPDSBrowser:
|
|
startActivityForResult(std::make_unique<OpdsServerListActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::Network:
|
|
startActivityForResult(std::make_unique<WifiSelectionActivity>(renderer, mappedInput, false), resultHandler);
|
|
break;
|
|
case SettingAction::ClearCache:
|
|
startActivityForResult(std::make_unique<ClearCacheActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::CheckForUpdates:
|
|
startActivityForResult(std::make_unique<OtaUpdateActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::SdFirmwareUpdate:
|
|
startActivityForResult(std::make_unique<SdFirmwareUpdateActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::DownloadFonts:
|
|
startActivityForResult(std::make_unique<FontDownloadActivity>(renderer, mappedInput),
|
|
[this](const ActivityResult&) {
|
|
SETTINGS.saveToFile();
|
|
rebuildSettingsLists();
|
|
});
|
|
break;
|
|
case SettingAction::Language:
|
|
startActivityForResult(std::make_unique<LanguageSelectActivity>(renderer, mappedInput), resultHandler);
|
|
break;
|
|
case SettingAction::None:
|
|
// Do nothing
|
|
break;
|
|
}
|
|
return; // Results will be handled in the result handler, so we can return early here
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
syncQuickResumeTimeoutForSleepScreen(sleepScreenChanged, quickResumeTimeoutChanged);
|
|
SETTINGS.saveToFile();
|
|
rebuildSettingsLists();
|
|
selectedSettingIndex = std::min(selectedSettingIndex, settingsCount);
|
|
}
|
|
|
|
void SettingsActivity::syncQuickResumeTimeoutForSleepScreen(bool sleepScreenChanged, bool quickResumeTimeoutChanged) {
|
|
if (quickResumeTimeoutChanged) {
|
|
preserveQuickResumeTimeoutOn =
|
|
SETTINGS.quickResumeSleepScreen == CrossPointSettings::QUICK_RESUME_SLEEP_SCREEN::QUICK_RESUME_AFTER_TIMEOUT;
|
|
quickResumeTimeoutAutoEnabled = false;
|
|
}
|
|
|
|
if (SETTINGS.sleepScreen == CrossPointSettings::SLEEP_SCREEN_MODE::QUICK_RESUME) {
|
|
if (SETTINGS.quickResumeSleepScreen != CrossPointSettings::QUICK_RESUME_SLEEP_SCREEN::QUICK_RESUME_AFTER_TIMEOUT) {
|
|
SETTINGS.quickResumeSleepScreen = CrossPointSettings::QUICK_RESUME_SLEEP_SCREEN::QUICK_RESUME_AFTER_TIMEOUT;
|
|
quickResumeTimeoutAutoEnabled = !preserveQuickResumeTimeoutOn;
|
|
} else if (sleepScreenChanged && !preserveQuickResumeTimeoutOn) {
|
|
quickResumeTimeoutAutoEnabled = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (sleepScreenChanged && quickResumeTimeoutAutoEnabled && !preserveQuickResumeTimeoutOn) {
|
|
SETTINGS.quickResumeSleepScreen = CrossPointSettings::QUICK_RESUME_SLEEP_SCREEN::QUICK_RESUME_NEVER;
|
|
quickResumeTimeoutAutoEnabled = false;
|
|
}
|
|
}
|
|
|
|
void SettingsActivity::openSleepTimeoutPicker() {
|
|
startActivityForResult(
|
|
std::make_unique<IntervalSelectionActivity>(
|
|
renderer, mappedInput, "SleepTimeoutInterval", StrId::STR_TIME_TO_SLEEP, StrId::STR_SLEEP_TIMER_STEP_HINT,
|
|
SETTINGS.sleepTimeoutMinutes, CrossPointSettings::MIN_SLEEP_TIMEOUT_MINUTES,
|
|
CrossPointSettings::MAX_SLEEP_TIMEOUT_MINUTES, 1, 5, StrId::STR_SLEEP_TIMER_VALUE_FORMAT, false, true,
|
|
StrId::STR_SLEEP_NEVER),
|
|
[this](const ActivityResult& result) {
|
|
if (!result.isCancelled) {
|
|
SETTINGS.sleepTimeoutMinutes = static_cast<uint8_t>(std::get<IntervalResult>(result.data).value);
|
|
SETTINGS.saveToFile();
|
|
}
|
|
requestUpdate();
|
|
});
|
|
}
|
|
|
|
void SettingsActivity::render(RenderLock&&) {
|
|
renderer.clearScreen();
|
|
|
|
const auto pageWidth = renderer.getScreenWidth();
|
|
const auto pageHeight = renderer.getScreenHeight();
|
|
|
|
const auto& metrics = UITheme::getInstance().getMetrics();
|
|
|
|
GUI.drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight}, tr(STR_SETTINGS_TITLE),
|
|
CROSSPOINT_VERSION);
|
|
|
|
std::vector<TabInfo> tabs;
|
|
tabs.reserve(categoryCount);
|
|
for (int i = 0; i < categoryCount; i++) {
|
|
tabs.push_back({I18N.get(categoryNames[i]), selectedCategoryIndex == i});
|
|
}
|
|
GUI.drawTabBar(renderer, Rect{0, metrics.topPadding + metrics.headerHeight, pageWidth, metrics.tabBarHeight}, tabs,
|
|
selectedSettingIndex == 0);
|
|
|
|
const auto& settings = *currentSettings;
|
|
GUI.drawList(
|
|
renderer,
|
|
Rect{0, metrics.topPadding + metrics.headerHeight + metrics.tabBarHeight + metrics.verticalSpacing, pageWidth,
|
|
pageHeight - (metrics.topPadding + metrics.headerHeight + metrics.tabBarHeight + metrics.buttonHintsHeight +
|
|
metrics.verticalSpacing * 2)},
|
|
settingsCount, selectedSettingIndex - 1,
|
|
[&settings](int index) { return std::string(I18N.get(settings[index].nameId)); }, nullptr, nullptr,
|
|
[&settings](int i) {
|
|
const auto& setting = settings[i];
|
|
std::string valueText = "";
|
|
if (setting.type == SettingType::TOGGLE && setting.valuePtr != nullptr) {
|
|
const bool value = SETTINGS.*(setting.valuePtr);
|
|
valueText = value ? tr(STR_STATE_ON) : tr(STR_STATE_OFF);
|
|
} else if (setting.type == SettingType::ENUM && setting.valuePtr != nullptr) {
|
|
const uint8_t value = SETTINGS.*(setting.valuePtr);
|
|
valueText = I18N.get(setting.enumValues[value]);
|
|
} else if (setting.type == SettingType::ENUM && setting.valueGetter) {
|
|
const uint8_t value = setting.valueGetter();
|
|
if (!setting.enumStringValues.empty() && value < setting.enumStringValues.size()) {
|
|
valueText = setting.enumStringValues[value];
|
|
} else if (value < setting.enumValues.size()) {
|
|
valueText = I18N.get(setting.enumValues[value]);
|
|
}
|
|
} else if (setting.type == SettingType::VALUE && setting.valuePtr != nullptr) {
|
|
if (setting.nameId == StrId::STR_TIME_TO_SLEEP) {
|
|
char valueBuffer[32];
|
|
if (SETTINGS.sleepTimeoutMinutes >= CrossPointSettings::SLEEP_TIMEOUT_NEVER_MINUTES) {
|
|
valueText = tr(STR_SLEEP_NEVER);
|
|
} else {
|
|
snprintf(valueBuffer, sizeof(valueBuffer), tr(STR_SLEEP_TIMER_VALUE_FORMAT),
|
|
static_cast<unsigned int>(SETTINGS.*(setting.valuePtr)));
|
|
valueText = valueBuffer;
|
|
}
|
|
} else {
|
|
valueText = std::to_string(SETTINGS.*(setting.valuePtr));
|
|
}
|
|
}
|
|
return valueText;
|
|
},
|
|
true);
|
|
|
|
// Draw help text
|
|
const auto confirmLabel =
|
|
(selectedSettingIndex == 0)
|
|
? I18N.get(categoryNames[(selectedCategoryIndex + 1) % categoryCount])
|
|
: (selectedSettingIndex > 0 && (*currentSettings)[selectedSettingIndex - 1].nameId == StrId::STR_TIME_TO_SLEEP
|
|
? tr(STR_SELECT)
|
|
: tr(STR_TOGGLE));
|
|
const auto labels = mappedInput.mapLabels(tr(STR_BACK), confirmLabel, tr(STR_DIR_UP), tr(STR_DIR_DOWN));
|
|
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
|
|
|
|
// Always use standard refresh for settings screen
|
|
renderer.displayBuffer();
|
|
}
|