flutter-freaccess-hub/lib/shared/helpers/secure_storage_helper.dart

import 'package:flutter/material.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:hub/shared/utils/storage_util.dart';
import 'package:synchronized/synchronized.dart';

class SecureStorageHelper extends ChangeNotifier implements Storage {
  static final SecureStorageHelper _instance = SecureStorageHelper._internal();
  final FlutterSecureStorage _secureStorage = const FlutterSecureStorage();
  static final _lock = Lock();

  factory SecureStorageHelper() => _instance;

  SecureStorageHelper._internal();

  Future<void> initializePersistedState() async {
    await _safeInitAsync(() async {
      _email = await _getString('ff_email');
      _passwd = await _getString('ff_passwd');
      _deviceType = await _getString('ff_deviceType');
      _isLogged = await _getBool('ff_isLogged');
      _tokenAPNS = await _getString('ff_tokenAPNS');
      _accessPass = await _getString('accessPass');
      _panicPass = await _getString('panicPass');
      _fingerprintPass = await _getString('fingerprintPass');
      _context = await _getObject('ff_context');
      _haveLocal = await _getBool('ff_have_local');
      _deviceDescription = await _getString('deviceDescription');
    });
  }

  Future<void> _safeInitAsync(Future<void> Function() initFunction) async {
    await _lock.synchronized(() async {
      try {
        await initFunction();
      } catch (e) {
        // Log or handle the error
      }
    });
  }

  Future<String> _getString(String key) async {
    return await _secureStorage.read(key: key) ?? '';
  }

  Future<bool> _getBool(String key) async {
    return (await _secureStorage.read(key: key))?.toLowerCase() == 'true';
  }

  Future<dynamic> _getObject(String key) async {
    // Implement your object retrieval logic here
    return null;
  }

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

  String _deviceDescription = '';
  String get deviceDescription => _deviceDescription;
  set deviceDescription(String value) => _setString('deviceDescription', value);

  BuildContext? _context;
  BuildContext? get context => _context;
  set context(BuildContext? value) =>
      _setString('ff_context', value.toString());

  bool? _haveLocal;
  bool? get haveLocal => _haveLocal;
  set haveLocal(bool? value) => _setBool('ff_have_local', value);

  String _fingerprintPass = '';
  String get fingerprintPass => _fingerprintPass;
  set fingerprintPass(String value) => _setString('fingerprintPass', value);

  String _accessPass = '';
  String get accessPass => _accessPass;
  set accessPass(String value) => _setString('accessPass', value);

  String _panicPass = '';
  String get panicPass => _panicPass;
  set panicPass(String value) => _setString('panicPass', value);

  String? _tokenAPNS = '';
  String? get tokenAPNS => _tokenAPNS;
  set tokenAPNS(String? value) => _setString('ff_tokenAPNS', value ?? '');

  String _email = '';
  String get email => _email;
  set email(String value) => _setString('ff_email', value);

  String _passwd = '';
  String get passwd => _passwd;
  set passwd(String value) => _setString('ff_passwd', value);

  String _deviceType = '';
  String get deviceType => _deviceType;
  set deviceType(String value) => _setString('ff_deviceType', value);

  bool _isLogged = false;
  bool get isLogged => _isLogged;
  set isLogged(bool value) => _setBool('ff_isLogged', value);

  String _token = '';
  String get token => _token;
  set token(String value) => _setString('ff_token', value);

  Future<void> _setString(String key, String value) async {
    await _secureStorage.write(key: key, value: value);
  }

  Future<void> _setBool(String key, bool? value) async {
    await _secureStorage.write(key: key, value: value.toString());
  }

  Future<void> purge() async {
    _secureStorage.deleteAll();
  }

  @override
  Future<void> set(String key, dynamic value) async {
    if (value is String) {
      await _setString(key, value);
    } else if (value is bool) {
      await _setBool(key, value);
    } else if (value is int || value is double) {
      await _setString(key, value.toString());
    }
  }

  @override
  Future<dynamic> get(String key) async {
    return await _secureStorage.read(key: key);
  }

  @override
  Future<void> delete(String key) async {
    await _secureStorage.delete(key: key);
  }
}