flutter-freaccess-hub/lib/app_state.dart

import 'package:flutter/material.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:csv/csv.dart';
import 'package:synchronized/synchronized.dart';

class FFAppState extends ChangeNotifier {
  static FFAppState _instance = FFAppState._internal();

  factory FFAppState() {
    return _instance;
  }

  FFAppState._internal();

  static void reset() {
    _instance = FFAppState._internal();
  }

  Future initializePersistedState() async {
    secureStorage = const FlutterSecureStorage();
    await _safeInitAsync(() async {
      _cliUUID = await secureStorage.getString('ff_cliUUID') ?? _cliUUID;
    });
    await _safeInitAsync(() async {
      _ownerUUID = await secureStorage.getString('ff_ownerUUID') ?? _ownerUUID;
    });
    await _safeInitAsync(() async {
      _userUUID = await secureStorage.getString('ff_userUUID') ?? _userUUID;
    });
    await _safeInitAsync(() async {
      _devUUID = await secureStorage.getString('ff_devUUID') ?? _devUUID;
    });
    await _safeInitAsync(() async {
      _email = await secureStorage.getString('ff_email') ?? _email;
    });
    await _safeInitAsync(() async {
      _passwd = await secureStorage.getString('ff_passwd') ?? _passwd;
    });
    await _safeInitAsync(() async {
      _device = await secureStorage.getString('ff_device') ?? _device;
    });
    await _safeInitAsync(() async {
      _isLogged = await secureStorage.getBool('ff_isLogged') ?? _isLogged;
    });
    await _safeInitAsync(() async {
      _local = await secureStorage.getString('ff_local') ?? _local;
    });
    await _safeInitAsync(() async {
      _token = await secureStorage.getString('ff_token') ?? _token;
    });
    await _safeInitAsync(() async {
      _createdAt = await secureStorage.getString('ff_createdAt') ?? _createdAt;
    });
    await _safeInitAsync(() async {
      _updatedAt = await secureStorage.getString('ff_updatedAt') ?? _updatedAt;
    });
    await _safeInitAsync(() async {
      _status = await secureStorage.getString('ff_status') ?? _status;
    });
  }

  void update(VoidCallback callback) {
    callback();
    notifyListeners();
  }

  late FlutterSecureStorage secureStorage;

  String _cliUUID = '';
  String get cliUUID => _cliUUID;
  set cliUUID(String value) {
    _cliUUID = value;
    secureStorage.setString('ff_cliUUID', value);
  }

  void deleteCliUUID() {
    secureStorage.delete(key: 'ff_cliUUID');
  }

  String _ownerUUID = '';
  String get ownerUUID => _ownerUUID;
  set ownerUUID(String value) {
    _ownerUUID = value;
    secureStorage.setString('ff_ownerUUID', value);
  }

  void deleteOwnerUUID() {
    secureStorage.delete(key: 'ff_ownerUUID');
  }

  String _userUUID = '';
  String get userUUID => _userUUID;
  set userUUID(String value) {
    _userUUID = value;
    secureStorage.setString('ff_userUUID', value);
  }

  void deleteUserUUID() {
    secureStorage.delete(key: 'ff_userUUID');
  }

  String _devUUID = '';
  String get devUUID => _devUUID;
  set devUUID(String value) {
    _devUUID = value;
    secureStorage.setString('ff_devUUID', value);
  }

  void deleteDevUUID() {
    secureStorage.delete(key: 'ff_devUUID');
  }

  String _email = '';
  String get email => _email;
  set email(String value) {
    _email = value;
    secureStorage.setString('ff_email', value);
  }

  void deleteEmail() {
    secureStorage.delete(key: 'ff_email');
  }

  String _passwd = '';
  String get passwd => _passwd;
  set passwd(String value) {
    _passwd = value;
    secureStorage.setString('ff_passwd', value);
  }

  void deletePasswd() {
    secureStorage.delete(key: 'ff_passwd');
  }

  String _device = '';
  String get device => _device;
  set device(String value) {
    _device = value;
    secureStorage.setString('ff_device', value);
  }

  void deleteDevice() {
    secureStorage.delete(key: 'ff_device');
  }

  bool _isLogged = false;
  bool get isLogged => _isLogged;
  set isLogged(bool value) {
    _isLogged = value;
    secureStorage.setBool('ff_isLogged', value);
  }

  void deleteIsLogged() {
    secureStorage.delete(key: 'ff_isLogged');
  }

  String _local = '';
  String get local => _local;
  set local(String value) {
    _local = value;
    secureStorage.setString('ff_local', value);
  }

  void deleteLocal() {
    secureStorage.delete(key: 'ff_local');
  }

  String _token = '';
  String get token => _token;
  set token(String value) {
    _token = value;
    secureStorage.setString('ff_token', value);
  }

  void deleteToken() {
    secureStorage.delete(key: 'ff_token');
  }

  String _createdAt = '';
  String get createdAt => _createdAt;
  set createdAt(String value) {
    _createdAt = value;
    secureStorage.setString('ff_createdAt', value);
  }

  void deleteCreatedAt() {
    secureStorage.delete(key: 'ff_createdAt');
  }

  String _updatedAt = '';
  String get updatedAt => _updatedAt;
  set updatedAt(String value) {
    _updatedAt = value;
    secureStorage.setString('ff_updatedAt', value);
  }

  void deleteUpdatedAt() {
    secureStorage.delete(key: 'ff_updatedAt');
  }

  String _status = '';
  String get status => _status;
  set status(String value) {
    _status = value;
    secureStorage.setString('ff_status', value);
  }

  void deleteStatus() {
    secureStorage.delete(key: 'ff_status');
  }
}

void _safeInit(Function() initializeField) {
  try {
    initializeField();
  } catch (_) {}
}

Future _safeInitAsync(Function() initializeField) async {
  try {
    await initializeField();
  } catch (_) {}
}

extension FlutterSecureStorageExtensions on FlutterSecureStorage {
  static final _lock = Lock();

  Future<void> writeSync({required String key, String? value}) async =>
      await _lock.synchronized(() async {
        await write(key: key, value: value);
      });

  void remove(String key) => delete(key: key);

  Future<String?> getString(String key) async => await read(key: key);
  Future<void> setString(String key, String value) async =>
      await writeSync(key: key, value: value);

  Future<bool?> getBool(String key) async => (await read(key: key)) == 'true';
  Future<void> setBool(String key, bool value) async =>
      await writeSync(key: key, value: value.toString());

  Future<int?> getInt(String key) async =>
      int.tryParse(await read(key: key) ?? '');
  Future<void> setInt(String key, int value) async =>
      await writeSync(key: key, value: value.toString());

  Future<double?> getDouble(String key) async =>
      double.tryParse(await read(key: key) ?? '');
  Future<void> setDouble(String key, double value) async =>
      await writeSync(key: key, value: value.toString());

  Future<List<String>?> getStringList(String key) async =>
      await read(key: key).then((result) {
        if (result == null || result.isEmpty) {
          return null;
        }
        return const CsvToListConverter()
            .convert(result)
            .first
            .map((e) => e.toString())
            .toList();
      });
  Future<void> setStringList(String key, List<String> value) async =>
      await writeSync(key: key, value: const ListToCsvConverter().convert([value]));
}