Introduce feature flags

packages/uni_app/lib/controller/feature_flags/feature_flag_controller.dart

@@ -0,0 +1,90 @@
+import 'package:uni/controller/feature_flags/feature_flag_info.dart';
+import 'package:uni/controller/feature_flags/feature_flag_state_controller.dart';
+import 'package:uni/model/feature_flags/feature_flag.dart';
+import 'package:uni/model/feature_flags/feature_flag_group.dart';
+import 'package:uni/model/feature_flags/generic_feature_flag.dart';
+
+class FeatureFlagController {
+  static final List<GenericFeatureFlag> _featureFlags = []; // To preserve order
+  static final Map<String, GenericFeatureFlag> _featureFlagsMap =
+      {}; // For fast lookup
+  static FeatureFlagStateController? _stateController;
+
+  static void parseFeatureFlagTable(
+    List<GenericFeatureFlagInfo> featureFlagInfos,
+  ) {
+    for (final featureFlagInfo in featureFlagInfos) {
+      final featureFlag = featureFlagInfo is FeatureFlagInfo
+          ? _createFeatureFlag(featureFlagInfo)
+          : _createFeatureFlagGroup(featureFlagInfo as FeatureFlagGroupInfo);
+
+      _featureFlags.add(featureFlag);
+      _featureFlagsMap[featureFlag.code] = featureFlag;
+
+      if (featureFlag is FeatureFlagGroup) {
+        for (final subFeatureFlag in featureFlag.getFeatureFlags()) {
+          _featureFlagsMap[subFeatureFlag.code] = subFeatureFlag;
+        }
+      }
+    }
+  }
+
+  static bool _isEnabled(String code) {
+    if (_stateController == null) {
+      throw Exception('FeatureFlagStateController is not initialized.');
+    }
+
+    return _stateController!.isEnabled(code);
+  }
+
+  static Future<void> _saveEnabled(String code, {required bool enabled}) async {
+    if (_stateController == null) {
+      throw Exception('FeatureFlagStateController is not initialized.');
+    }
+
+    await _stateController!.saveEnabled(code, enabled: enabled);
+  }
+
+  static FeatureFlag _createFeatureFlag(FeatureFlagInfo featureFlagInfo) {
+    final code = featureFlagInfo.code;
+    final getName = featureFlagInfo.getName;
+
+    return FeatureFlag(
+      code: code,
+      getName: getName,
+      isEnabled: () => _isEnabled(code),
+      saveEnabled: ({required enabled}) => _saveEnabled(code, enabled: enabled),
+    );
+  }
+
+  static GenericFeatureFlag _createFeatureFlagGroup(
+    FeatureFlagGroupInfo featureFlagGroupInfo,
+  ) {
+    final code = featureFlagGroupInfo.code;
+    final getName = featureFlagGroupInfo.getName;
+    final featureFlags =
+        featureFlagGroupInfo.featureFlags.map(_createFeatureFlag).toList();
+
+    final featureFlagGroup = FeatureFlagGroup(
+      code: code,
+      getName: getName,
+      isEnabled: () => _isEnabled(code),
+      saveEnabled: ({required enabled}) => _saveEnabled(code, enabled: enabled),
+      featureFlags: featureFlags,
+    );
+
+    return featureFlagGroup;
+  }
+
+  static GenericFeatureFlag? getFeatureFlag(String code) {
+    return _featureFlagsMap[code];
+  }
+
+  static void setStateController(FeatureFlagStateController stateController) {
+    _stateController = stateController;
+  }
+
+  static List<GenericFeatureFlag> getFeatureFlags() {
+    return _featureFlags;
+  }
+}

packages/uni_app/lib/controller/feature_flags/feature_flag_info.dart

@@ -0,0 +1,28 @@
+import 'package:flutter/material.dart';
+
+abstract class GenericFeatureFlagInfo {
+  const GenericFeatureFlagInfo({
+    required this.code,
+    required this.getName,
+  });
+
+  final String code;
+  final String Function(BuildContext) getName;
+}
+
+class FeatureFlagInfo extends GenericFeatureFlagInfo {
+  const FeatureFlagInfo({
+    required super.code,
+    required super.getName,
+  });
+}
+
+class FeatureFlagGroupInfo extends GenericFeatureFlagInfo {
+  const FeatureFlagGroupInfo({
+    required super.code,
+    required super.getName,
+    required this.featureFlags,
+  });
+
+  final List<FeatureFlagInfo> featureFlags;
+}

packages/uni_app/lib/controller/feature_flags/feature_flag_state_controller.dart

@@ -0,0 +1,18 @@
+import 'package:shared_preferences/shared_preferences.dart';
+
+class FeatureFlagStateController {
+  FeatureFlagStateController(this.preferences);
+
+  final SharedPreferences preferences;
+  static const _flagPrefix = '__feature_flag__';
+
+  String _getKey(String code) => '$_flagPrefix$code';
+
+  bool isEnabled(String code) {
+    return preferences.getBool(_getKey(code)) ?? false;
+  }
+
+  Future<void> saveEnabled(String code, {required bool enabled}) {
+    return preferences.setBool(_getKey(code), enabled);
+  }
+}

packages/uni_app/lib/controller/feature_flags/feature_flag_table.dart

@@ -0,0 +1,23 @@
+import 'package:uni/controller/feature_flags/feature_flag_info.dart';
+import 'package:uni/generated/l10n.dart';
+
+List<GenericFeatureFlagInfo> featureFlagTable = [
+  FeatureFlagInfo(
+    code: 'library_modules',
+    getName: (context) => S.of(context).library_modules,
+  ),
+  FeatureFlagGroupInfo(
+    code: 'library',
+    getName: (context) => S.of(context).library_modules,
+    featureFlags: [
+      FeatureFlagInfo(
+        code: 'library_occupation',
+        getName: (context) => S.of(context).library_modules,
+      ),
+      FeatureFlagInfo(
+        code: 'library_floors',
+        getName: (context) => S.of(context).library_modules,
+      ),
+    ],
+  ),
+];

packages/uni_app/lib/generated/intl/messages_en.dart

@@ -131,6 +131,8 @@ class MessageLookup extends MessageLookupByLibrary {
         "fail_to_authenticate":
             MessageLookupByLibrary.simpleMessage("Failed to authenticate"),
         "failed_login": MessageLookupByLibrary.simpleMessage("Login failed"),
+        "feature_flags":
+            MessageLookupByLibrary.simpleMessage("Experimental features"),
         "fee_date":
             MessageLookupByLibrary.simpleMessage("Deadline for next fee:"),
         "fee_notification":
@@ -157,6 +159,8 @@ class MessageLookup extends MessageLookupByLibrary {
         "language": MessageLookupByLibrary.simpleMessage("Language"),
         "last_refresh_time": m0,
         "last_timestamp": m1,
+        "library_modules":
+            MessageLookupByLibrary.simpleMessage("Library modules"),
         "library_occupation":
             MessageLookupByLibrary.simpleMessage("Library Occupation"),
         "load_error": MessageLookupByLibrary.simpleMessage(

packages/uni_app/lib/generated/intl/messages_pt_PT.dart

@@ -130,6 +130,8 @@ class MessageLookup extends MessageLookupByLibrary {
         "fail_to_authenticate":
             MessageLookupByLibrary.simpleMessage("Falha ao autenticar"),
         "failed_login": MessageLookupByLibrary.simpleMessage("O login falhou"),
+        "feature_flags":
+            MessageLookupByLibrary.simpleMessage("Features experimentais"),
         "fee_date": MessageLookupByLibrary.simpleMessage(
             "Data limite próxima prestação:"),
         "fee_notification":
@@ -156,6 +158,8 @@ class MessageLookup extends MessageLookupByLibrary {
         "language": MessageLookupByLibrary.simpleMessage("Idioma"),
         "last_refresh_time": m0,
         "last_timestamp": m1,
+        "library_modules":
+            MessageLookupByLibrary.simpleMessage("Módulos da biblioteca"),
         "library_occupation":
             MessageLookupByLibrary.simpleMessage("Ocupação da Biblioteca"),
         "load_error": MessageLookupByLibrary.simpleMessage(

packages/uni_app/lib/l10n/intl_en.arb

@@ -333,5 +333,9 @@
   "wrong_credentials_exception": "Invalid credentials",
   "@wrong_credentials_exception": {},
   "internet_status_exception": "Check your internet connection",
-  "@internet_status_exception": {}
+  "@internet_status_exception": {},
+  "feature_flags": "Experimental features",
+  "@feature_flags": {},
+  "library_modules": "Library modules",
+  "@library_modules": {}
 }

packages/uni_app/lib/l10n/intl_pt_PT.arb

@@ -333,5 +333,9 @@
   "wrong_credentials_exception": "Credenciais inválidas",
   "@wrong_credentials_exception": {},
   "internet_status_exception": "Verifique sua conexão com a internet",
-  "@internet_status_exception": {}
+  "@internet_status_exception": {},
+  "feature_flags": "Features experimentais",
+  "@feature_flags": {},
+  "library_modules": "Módulos da biblioteca",
+  "@library_modules": {}
 }

packages/uni_app/lib/main.dart

@@ -14,6 +14,9 @@ import 'package:shared_preferences/shared_preferences.dart';
 import 'package:ua_client_hints/ua_client_hints.dart';
 import 'package:uni/controller/background_workers/background_callback.dart';
 import 'package:uni/controller/cleanup.dart';
+import 'package:uni/controller/feature_flags/feature_flag_controller.dart';
+import 'package:uni/controller/feature_flags/feature_flag_state_controller.dart';
+import 'package:uni/controller/feature_flags/feature_flag_table.dart';
 import 'package:uni/controller/fetchers/terms_and_conditions_fetcher.dart';
 import 'package:uni/controller/local_storage/preferences_controller.dart';
 import 'package:uni/generated/l10n.dart';
@@ -181,6 +184,11 @@ Future<void> main() async {
       );
     },
   );
+
+  final featureFlagStateController =
+      FeatureFlagStateController(PreferencesController.prefs);
+  FeatureFlagController.setStateController(featureFlagStateController);
+  FeatureFlagController.parseFeatureFlagTable(featureFlagTable);
 }
 
 /// Manages the state of the app.

packages/uni_app/lib/model/feature_flags/feature_flag.dart

@@ -0,0 +1,29 @@
+import 'package:flutter/material.dart';
+import 'package:uni/model/feature_flags/generic_feature_flag.dart';
+
+class FeatureFlag extends GenericFeatureFlag {
+  FeatureFlag({
+    required this.code,
+    required String Function(BuildContext) getName,
+    required bool Function() isEnabled,
+    required Future<void> Function({required bool enabled}) saveEnabled,
+  })  : _getName = getName,
+        _isEnabled = isEnabled,
+        _saveEnabled = saveEnabled;
+
+  @override
+  final String code;
+  final String Function(BuildContext) _getName;
+  final bool Function() _isEnabled;
+  final Future<void> Function({required bool enabled}) _saveEnabled;
+
+  @override
+  String getName(BuildContext context) => _getName(context);
+
+  @override
+  bool isEnabled() => _isEnabled();
+
+  @override
+  Future<void> setEnabled({required bool enabled}) =>
+      _saveEnabled(enabled: enabled);
+}

packages/uni_app/lib/model/feature_flags/feature_flag_group.dart

@@ -0,0 +1,42 @@
+import 'package:flutter/material.dart';
+import 'package:uni/model/feature_flags/feature_flag.dart';
+import 'package:uni/model/feature_flags/generic_feature_flag.dart';
+
+class FeatureFlagGroup extends GenericFeatureFlag {
+  FeatureFlagGroup({
+    required this.code,
+    required String Function(BuildContext) getName,
+    required bool Function() isEnabled,
+    required Future<void> Function({required bool enabled}) saveEnabled,
+    required List<FeatureFlag> featureFlags,
+  })  : _getName = getName,
+        _isEnabled = isEnabled,
+        _saveEnabled = saveEnabled,
+        _featureFlags = featureFlags;
+
+  @override
+  final String code;
+  final String Function(BuildContext) _getName;
+  final bool Function() _isEnabled;
+  final Future<void> Function({required bool enabled}) _saveEnabled;
+  final List<FeatureFlag> _featureFlags;
+
+  @override
+  String getName(BuildContext context) => _getName(context);
+
+  @override
+  bool isEnabled() => _isEnabled();
+
+  @override
+  Future<void> setEnabled({required bool enabled}) async {
+    await _saveEnabled(enabled: enabled);
+
+    for (final featureFlag in _featureFlags) {
+      await featureFlag.setEnabled(enabled: enabled);
+    }
+  }
+
+  List<FeatureFlag> getFeatureFlags() {
+    return _featureFlags;
+  }
+}

packages/uni_app/lib/model/feature_flags/generic_feature_flag.dart

@@ -0,0 +1,8 @@
+import 'package:flutter/material.dart';
+
+abstract class GenericFeatureFlag {
+  String get code;
+  String getName(BuildContext context);
+  bool isEnabled();
+  Future<void> setEnabled({required bool enabled});
+}

packages/uni_app/lib/view/common_widgets/experimental_feature_wrapper.dart

@@ -0,0 +1,24 @@
+import 'package:flutter/cupertino.dart';
+import 'package:uni/model/feature_flags/generic_feature_flag.dart';
+
+class ExperimentalFeatureWrapper extends StatelessWidget {
+  const ExperimentalFeatureWrapper({
+    required this.featureFlag,
+    required this.onEnabled,
+    this.onDisabled = _defaultOnDisabled,
+    super.key,
+  });
+
+  final GenericFeatureFlag featureFlag;
+  final Widget Function(BuildContext) onEnabled;
+  final Widget Function(BuildContext) onDisabled;
+
+  static Widget _defaultOnDisabled(BuildContext context) {
+    return Container();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return featureFlag.isEnabled() ? onEnabled(context) : onDisabled(context);
+  }
+}