mirror of
https://github.com/Ujwal223/FocusGram.git
synced 2026-04-01 17:10:23 +02:00
7bb472d212
- Reordered Settings Page. - Added "Click to Unblur" for posts. - Added Persistent Notification - Improved Grayscale Scheduling. and more.
485 lines
17 KiB
Dart
485 lines
17 KiB
Dart
import 'dart:convert';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
/// Stores and retrieves all user-configurable app settings.
|
|
class SettingsService extends ChangeNotifier {
|
|
static const _keyBlurExplore = 'set_blur_explore';
|
|
static const _keyBlurReels = 'set_blur_reels';
|
|
static const _keyTapToUnblur = 'set_tap_to_unblur';
|
|
static const _keyRequireLongPress = 'set_require_long_press';
|
|
static const _keyShowBreathGate = 'set_show_breath_gate';
|
|
static const _keyRequireWordChallenge = 'set_require_word_challenge';
|
|
static const _keyEnableTextSelection = 'set_enable_text_selection';
|
|
static const _keyEnabledTabs = 'set_enabled_tabs';
|
|
static const _keyShowInstaSettings = 'set_show_insta_settings';
|
|
static const _keyIsFirstRun = 'set_is_first_run';
|
|
|
|
// Focus / playback
|
|
static const _keyBlockAutoplay = 'block_autoplay';
|
|
|
|
// Grayscale mode - now supports multiple schedules
|
|
static const _keyGrayscaleEnabled = 'grayscale_enabled';
|
|
static const _keyGrayscaleSchedules = 'grayscale_schedules';
|
|
|
|
// Content filtering / UI hiding
|
|
static const _keyHideSponsoredPosts = 'hide_sponsored_posts';
|
|
static const _keyHideLikeCounts = 'hide_like_counts';
|
|
static const _keyHideFollowerCounts = 'hide_follower_counts';
|
|
static const _keyHideShopTab = 'hide_shop_tab';
|
|
|
|
// Minimal mode
|
|
static const _keyMinimalModeEnabled = 'minimal_mode_enabled';
|
|
|
|
// Minimal mode state tracking for smart restore
|
|
static const _keyMinimalModePrevDisableReels = 'minimal_mode_prev_disable_reels';
|
|
static const _keyMinimalModePrevDisableExplore = 'minimal_mode_prev_disable_explore';
|
|
static const _keyMinimalModePrevBlurExplore = 'minimal_mode_prev_blur_explore';
|
|
|
|
// Reels History
|
|
static const _keyReelsHistoryEnabled = 'reels_history_enabled';
|
|
|
|
// Privacy keys
|
|
static const _keySanitizeLinks = 'set_sanitize_links';
|
|
static const _keyNotifyDMs = 'set_notify_dms';
|
|
static const _keyNotifyActivity = 'set_notify_activity';
|
|
static const _keyNotifySessionEnd = 'set_notify_session_end';
|
|
static const _keyNotifyPersistent = 'set_notify_persistent';
|
|
|
|
SharedPreferences? _prefs;
|
|
|
|
bool _blurExplore = true;
|
|
bool _blurReels = false;
|
|
bool _tapToUnblur = true;
|
|
bool _requireLongPress = true;
|
|
bool _showBreathGate = true;
|
|
bool _requireWordChallenge = true;
|
|
bool _enableTextSelection = false;
|
|
bool _showInstaSettings = true;
|
|
bool _isDarkMode = true; // Default to dark as per existing app theme
|
|
|
|
bool _blockAutoplay = true;
|
|
|
|
bool _grayscaleEnabled = false;
|
|
|
|
// Grayscale schedules - list of {enabled, startTime, endTime}
|
|
// startTime and endTime are in format "HH:MM"
|
|
List<Map<String, dynamic>> _grayscaleSchedules = [];
|
|
|
|
bool _hideSponsoredPosts = false;
|
|
bool _hideLikeCounts = false;
|
|
bool _hideFollowerCounts = false;
|
|
bool _hideShopTab = false;
|
|
|
|
// These are now controlled internally by minimal mode
|
|
bool _disableReelsEntirely = false;
|
|
bool _disableExploreEntirely = false;
|
|
bool _minimalModeEnabled = false;
|
|
|
|
// Tracking for smart restore
|
|
bool _prevDisableReels = false;
|
|
bool _prevDisableExplore = false;
|
|
bool _prevBlurExplore = false;
|
|
|
|
bool _reelsHistoryEnabled = true;
|
|
|
|
// Privacy defaults - notifications OFF by default
|
|
bool _sanitizeLinks = true;
|
|
bool _notifyDMs = false;
|
|
bool _notifyActivity = false;
|
|
bool _notifySessionEnd = false;
|
|
bool _notifyPersistent = false;
|
|
|
|
List<String> _enabledTabs = [
|
|
'Home',
|
|
'Search',
|
|
'Reels',
|
|
'Messages',
|
|
'Profile',
|
|
];
|
|
bool _isFirstRun = true;
|
|
|
|
bool get blurExplore => _blurExplore;
|
|
bool get blurReels => _blurReels;
|
|
bool get tapToUnblur => _tapToUnblur;
|
|
bool get requireLongPress => _requireLongPress;
|
|
bool get showBreathGate => _showBreathGate;
|
|
bool get requireWordChallenge => _requireWordChallenge;
|
|
bool get enableTextSelection => _enableTextSelection;
|
|
bool get showInstaSettings => _showInstaSettings;
|
|
List<String> get enabledTabs => _enabledTabs;
|
|
bool get isFirstRun => _isFirstRun;
|
|
bool get isDarkMode => _isDarkMode;
|
|
bool get blockAutoplay => _blockAutoplay;
|
|
bool get notifyDMs => _notifyDMs;
|
|
bool get notifyActivity => _notifyActivity;
|
|
bool get notifySessionEnd => _notifySessionEnd;
|
|
bool get notifyPersistent => _notifyPersistent;
|
|
|
|
bool get grayscaleEnabled => _grayscaleEnabled;
|
|
List<Map<String, dynamic>> get grayscaleSchedules => _grayscaleSchedules;
|
|
|
|
bool get hideSponsoredPosts => _hideSponsoredPosts;
|
|
bool get hideLikeCounts => _hideLikeCounts;
|
|
bool get hideFollowerCounts => _hideFollowerCounts;
|
|
bool get hideShopTab => _hideShopTab;
|
|
|
|
// These are now controlled by minimal mode only
|
|
bool get disableReelsEntirely => _minimalModeEnabled ? true : _disableReelsEntirely;
|
|
bool get disableExploreEntirely => _minimalModeEnabled ? true : _disableExploreEntirely;
|
|
bool get minimalModeEnabled => _minimalModeEnabled;
|
|
|
|
bool get reelsHistoryEnabled => _reelsHistoryEnabled;
|
|
|
|
/// True if grayscale should currently be applied, considering the manual
|
|
/// toggle and the optional schedules.
|
|
bool get isGrayscaleActiveNow {
|
|
if (_grayscaleEnabled) return true;
|
|
if (_grayscaleSchedules.isEmpty) return false;
|
|
|
|
final now = DateTime.now();
|
|
final currentMinutes = now.hour * 60 + now.minute;
|
|
|
|
for (final schedule in _grayscaleSchedules) {
|
|
if (schedule['enabled'] != true) continue;
|
|
|
|
try {
|
|
final startParts = (schedule['startTime'] as String).split(':');
|
|
final endParts = (schedule['endTime'] as String).split(':');
|
|
|
|
if (startParts.length != 2 || endParts.length != 2) continue;
|
|
|
|
final startMinutes = int.parse(startParts[0]) * 60 + int.parse(startParts[1]);
|
|
final endMinutes = int.parse(endParts[0]) * 60 + int.parse(endParts[1]);
|
|
|
|
// Handle overnight schedules (e.g., 21:00 to 06:00)
|
|
if (endMinutes < startMinutes) {
|
|
// Overnight: active if current time is >= start OR < end
|
|
if (currentMinutes >= startMinutes || currentMinutes < endMinutes) {
|
|
return true;
|
|
}
|
|
} else {
|
|
// Same day: active if current time is between start and end
|
|
if (currentMinutes >= startMinutes && currentMinutes < endMinutes) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (_) {
|
|
continue;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Privacy getters
|
|
bool get sanitizeLinks => _sanitizeLinks;
|
|
|
|
Future<void> init() async {
|
|
_prefs = await SharedPreferences.getInstance();
|
|
_blurExplore = _prefs!.getBool(_keyBlurExplore) ?? true;
|
|
_blurReels = _prefs!.getBool(_keyBlurReels) ?? false;
|
|
_tapToUnblur = _prefs!.getBool(_keyTapToUnblur) ?? true;
|
|
_requireLongPress = _prefs!.getBool(_keyRequireLongPress) ?? true;
|
|
_showBreathGate = _prefs!.getBool(_keyShowBreathGate) ?? true;
|
|
_requireWordChallenge = _prefs!.getBool(_keyRequireWordChallenge) ?? true;
|
|
_enableTextSelection = _prefs!.getBool(_keyEnableTextSelection) ?? false;
|
|
_showInstaSettings = _prefs!.getBool(_keyShowInstaSettings) ?? true;
|
|
_blockAutoplay = _prefs!.getBool(_keyBlockAutoplay) ?? true;
|
|
|
|
_grayscaleEnabled = _prefs!.getBool(_keyGrayscaleEnabled) ?? false;
|
|
|
|
// Load grayscale schedules
|
|
final schedulesJson = _prefs!.getString(_keyGrayscaleSchedules);
|
|
if (schedulesJson != null) {
|
|
try {
|
|
_grayscaleSchedules = List<Map<String, dynamic>>.from(
|
|
(jsonDecode(schedulesJson) as List).map((e) => Map<String, dynamic>.from(e))
|
|
);
|
|
} catch (_) {
|
|
_grayscaleSchedules = [];
|
|
}
|
|
}
|
|
|
|
_hideSponsoredPosts = _prefs!.getBool(_keyHideSponsoredPosts) ?? false;
|
|
_hideLikeCounts = _prefs!.getBool(_keyHideLikeCounts) ?? false;
|
|
_hideFollowerCounts = _prefs!.getBool(_keyHideFollowerCounts) ?? false;
|
|
_hideShopTab = _prefs!.getBool(_keyHideShopTab) ?? false;
|
|
|
|
// Load minimal mode
|
|
_minimalModeEnabled = _prefs!.getBool(_keyMinimalModeEnabled) ?? false;
|
|
|
|
// Load previous states for smart restore
|
|
_prevDisableReels = _prefs!.getBool(_keyMinimalModePrevDisableReels) ?? false;
|
|
_prevDisableExplore = _prefs!.getBool(_keyMinimalModePrevDisableExplore) ?? false;
|
|
_prevBlurExplore = _prefs!.getBool(_keyMinimalModePrevBlurExplore) ?? false;
|
|
|
|
// These are now internal states, not user-facing settings
|
|
_disableReelsEntirely = _prefs!.getBool('internal_disable_reels_entirely') ?? false;
|
|
_disableExploreEntirely = _prefs!.getBool('internal_disable_explore_entirely') ?? false;
|
|
|
|
_reelsHistoryEnabled = _prefs!.getBool(_keyReelsHistoryEnabled) ?? true;
|
|
|
|
_sanitizeLinks = _prefs!.getBool(_keySanitizeLinks) ?? true;
|
|
_notifyDMs = _prefs!.getBool(_keyNotifyDMs) ?? false;
|
|
_notifyActivity = _prefs!.getBool(_keyNotifyActivity) ?? false;
|
|
_notifySessionEnd = _prefs!.getBool(_keyNotifySessionEnd) ?? false;
|
|
_notifyPersistent = _prefs!.getBool(_keyNotifyPersistent) ?? false;
|
|
|
|
_enabledTabs =
|
|
(_prefs!.getStringList(_keyEnabledTabs) ??
|
|
['Home', 'Search', 'Reels', 'Messages', 'Profile'])
|
|
..remove('Create');
|
|
if (!_enabledTabs.contains('Messages') && _enabledTabs.length < 5) {
|
|
// Migration: add Messages if missing
|
|
_enabledTabs.insert(3, 'Messages');
|
|
}
|
|
_isFirstRun = _prefs!.getBool(_keyIsFirstRun) ?? true;
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setFirstRunCompleted() async {
|
|
_isFirstRun = false;
|
|
await _prefs?.setBool(_keyIsFirstRun, false);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setBlurExplore(bool v) async {
|
|
_blurExplore = v;
|
|
// Sync blur explore with blur reels - enabling one enables the other
|
|
if (v && !_blurReels) {
|
|
_blurReels = true;
|
|
await _prefs?.setBool(_keyBlurReels, true);
|
|
}
|
|
await _prefs?.setBool(_keyBlurExplore, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setBlurReels(bool v) async {
|
|
_blurReels = v;
|
|
// Sync blur reels with blur explore - enabling one enables the other
|
|
if (v && !_blurExplore) {
|
|
_blurExplore = true;
|
|
await _prefs?.setBool(_keyBlurExplore, true);
|
|
}
|
|
await _prefs?.setBool(_keyBlurReels, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setTapToUnblur(bool v) async {
|
|
_tapToUnblur = v;
|
|
await _prefs?.setBool(_keyTapToUnblur, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setRequireLongPress(bool v) async {
|
|
_requireLongPress = v;
|
|
await _prefs?.setBool(_keyRequireLongPress, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setShowBreathGate(bool v) async {
|
|
_showBreathGate = v;
|
|
await _prefs?.setBool(_keyShowBreathGate, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setRequireWordChallenge(bool v) async {
|
|
_requireWordChallenge = v;
|
|
await _prefs?.setBool(_keyRequireWordChallenge, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setEnableTextSelection(bool v) async {
|
|
_enableTextSelection = v;
|
|
await _prefs?.setBool(_keyEnableTextSelection, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setShowInstaSettings(bool v) async {
|
|
_showInstaSettings = v;
|
|
await _prefs?.setBool(_keyShowInstaSettings, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setBlockAutoplay(bool v) async {
|
|
_blockAutoplay = v;
|
|
await _prefs?.setBool(_keyBlockAutoplay, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setGrayscaleEnabled(bool v) async {
|
|
_grayscaleEnabled = v;
|
|
await _prefs?.setBool(_keyGrayscaleEnabled, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setGrayscaleSchedules(List<Map<String, dynamic>> schedules) async {
|
|
_grayscaleSchedules = schedules;
|
|
await _prefs?.setString(_keyGrayscaleSchedules, jsonEncode(schedules));
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> addGrayscaleSchedule(Map<String, dynamic> schedule) async {
|
|
_grayscaleSchedules.add(schedule);
|
|
await _prefs?.setString(_keyGrayscaleSchedules, jsonEncode(_grayscaleSchedules));
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> updateGrayscaleSchedule(int index, Map<String, dynamic> schedule) async {
|
|
if (index >= 0 && index < _grayscaleSchedules.length) {
|
|
_grayscaleSchedules[index] = schedule;
|
|
await _prefs?.setString(_keyGrayscaleSchedules, jsonEncode(_grayscaleSchedules));
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
Future<void> removeGrayscaleSchedule(int index) async {
|
|
if (index >= 0 && index < _grayscaleSchedules.length) {
|
|
_grayscaleSchedules.removeAt(index);
|
|
await _prefs?.setString(_keyGrayscaleSchedules, jsonEncode(_grayscaleSchedules));
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
Future<void> setHideSponsoredPosts(bool v) async {
|
|
_hideSponsoredPosts = v;
|
|
await _prefs?.setBool(_keyHideSponsoredPosts, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setHideLikeCounts(bool v) async {
|
|
_hideLikeCounts = v;
|
|
await _prefs?.setBool(_keyHideLikeCounts, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setHideFollowerCounts(bool v) async {
|
|
_hideFollowerCounts = v;
|
|
await _prefs?.setBool(_keyHideFollowerCounts, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setHideShopTab(bool v) async {
|
|
_hideShopTab = v;
|
|
await _prefs?.setBool(_keyHideShopTab, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Setter for internal disable reels state (used by minimal mode submenu)
|
|
Future<void> setDisableReelsEntirelyInternal(bool v) async {
|
|
_disableReelsEntirely = v;
|
|
await _prefs?.setBool('internal_disable_reels_entirely', v);
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Setter for internal disable explore state (used by minimal mode submenu)
|
|
Future<void> setDisableExploreEntirelyInternal(bool v) async {
|
|
_disableExploreEntirely = v;
|
|
await _prefs?.setBool('internal_disable_explore_entirely', v);
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Smart minimal mode toggle with state preservation
|
|
Future<void> setMinimalModeEnabled(bool v) async {
|
|
if (v) {
|
|
// Turning ON - save current states BEFORE enabling minimal mode
|
|
_prevDisableReels = _disableReelsEntirely;
|
|
_prevDisableExplore = _disableExploreEntirely;
|
|
_prevBlurExplore = _blurExplore;
|
|
|
|
await _prefs?.setBool(_keyMinimalModePrevDisableReels, _prevDisableReels);
|
|
await _prefs?.setBool(_keyMinimalModePrevDisableExplore, _prevDisableExplore);
|
|
await _prefs?.setBool(_keyMinimalModePrevBlurExplore, _prevBlurExplore);
|
|
|
|
// Enable all minimal mode settings
|
|
_minimalModeEnabled = true;
|
|
_disableReelsEntirely = true;
|
|
_disableExploreEntirely = true;
|
|
_blurExplore = true;
|
|
|
|
await _prefs?.setBool(_keyMinimalModeEnabled, true);
|
|
await _prefs?.setBool('internal_disable_reels_entirely', true);
|
|
await _prefs?.setBool('internal_disable_explore_entirely', true);
|
|
await _prefs?.setBool(_keyBlurExplore, true);
|
|
} else {
|
|
// Turning OFF - restore to PREVIOUS states (before minimal mode was turned on)
|
|
_minimalModeEnabled = false;
|
|
|
|
// Simply restore to the states that were saved BEFORE minimal mode was enabled
|
|
_disableReelsEntirely = _prevDisableReels;
|
|
_disableExploreEntirely = _prevDisableExplore;
|
|
_blurExplore = _prevBlurExplore;
|
|
|
|
// Save the restored states
|
|
await _prefs?.setBool(_keyMinimalModeEnabled, false);
|
|
await _prefs?.setBool('internal_disable_reels_entirely', _disableReelsEntirely);
|
|
await _prefs?.setBool('internal_disable_explore_entirely', _disableExploreEntirely);
|
|
await _prefs?.setBool(_keyBlurExplore, _blurExplore);
|
|
}
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setReelsHistoryEnabled(bool v) async {
|
|
_reelsHistoryEnabled = v;
|
|
await _prefs?.setBool(_keyReelsHistoryEnabled, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
void setDarkMode(bool dark) {
|
|
if (_isDarkMode != dark) {
|
|
_isDarkMode = dark;
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
Future<void> setSanitizeLinks(bool v) async {
|
|
_sanitizeLinks = v;
|
|
await _prefs?.setBool(_keySanitizeLinks, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setNotifyDMs(bool v) async {
|
|
_notifyDMs = v;
|
|
await _prefs?.setBool(_keyNotifyDMs, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setNotifyActivity(bool v) async {
|
|
_notifyActivity = v;
|
|
await _prefs?.setBool(_keyNotifyActivity, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setNotifySessionEnd(bool v) async {
|
|
_notifySessionEnd = v;
|
|
await _prefs?.setBool(_keyNotifySessionEnd, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> setNotifyPersistent(bool v) async {
|
|
_notifyPersistent = v;
|
|
await _prefs?.setBool(_keyNotifyPersistent, v);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> toggleTab(String tab) async {
|
|
if (_enabledTabs.contains(tab)) {
|
|
if (_enabledTabs.length > 1) {
|
|
_enabledTabs.remove(tab);
|
|
}
|
|
} else {
|
|
_enabledTabs.add(tab);
|
|
}
|
|
await _prefs?.setStringList(_keyEnabledTabs, _enabledTabs);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> reorderTab(int oldIndex, int newIndex) async {
|
|
if (newIndex > oldIndex) newIndex -= 1;
|
|
final String item = _enabledTabs.removeAt(oldIndex);
|
|
_enabledTabs.insert(newIndex, item);
|
|
await _prefs?.setStringList(_keyEnabledTabs, _enabledTabs);
|
|
notifyListeners();
|
|
}
|
|
}
|