kasy-cli 1.2.1

package/templates/firebase/lib/core/security/biometric_service.dart

@@ -0,0 +1,79 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/security/biometric_copy_slot.dart';
+import 'package:local_auth/local_auth.dart';
+
+final biometricServiceProvider = Provider<BiometricService>(
+  (_) => BiometricService(),
+);
+
+class BiometricService {
+  final LocalAuthentication _auth = LocalAuthentication();
+
+  /// Maps enrolled biometrics ([getAvailableBiometrics]) to UX copy buckets.
+  Future<BiometricCopySlot> resolveCopySlot(TargetPlatform platform) async {
+    if (kIsWeb) return BiometricCopySlot.unsupported;
+    try {
+      if (!(await _auth.isDeviceSupported() && await _auth.canCheckBiometrics)) {
+        return BiometricCopySlot.unsupported;
+      }
+      final types = await _auth.getAvailableBiometrics();
+      final hasFace = types.contains(BiometricType.face);
+      final hasFinger = types.contains(BiometricType.fingerprint);
+      final hasIris = types.contains(BiometricType.iris);
+      final vague = types.any(
+        (t) => t == BiometricType.weak || t == BiometricType.strong,
+      );
+
+      if (platform == TargetPlatform.iOS ||
+          platform == TargetPlatform.macOS) {
+        if (hasFace && hasFinger) {
+          return BiometricCopySlot.iosFaceAndFingerprint;
+        }
+        if (hasFace) return BiometricCopySlot.iosFaceOnly;
+        if (hasFinger || hasIris) return BiometricCopySlot.iosFingerprintOnly;
+        if (types.isEmpty && vague) return BiometricCopySlot.iosUndetermined;
+        return BiometricCopySlot.iosUndetermined;
+      }
+
+      if (hasFace && hasFinger) {
+        return BiometricCopySlot.androidFaceAndFingerprint;
+      }
+      if (hasFace) return BiometricCopySlot.androidFaceOnly;
+      if (hasFinger || hasIris) {
+        return BiometricCopySlot.androidFingerprintOnly;
+      }
+      if (vague) return BiometricCopySlot.androidUndetermined;
+      return BiometricCopySlot.androidUndetermined;
+    } catch (_) {
+      return BiometricCopySlot.unsupported;
+    }
+  }
+
+  Future<bool> isAvailable() async {
+    try {
+      return await _auth.isDeviceSupported() && await _auth.canCheckBiometrics;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  Future<List<BiometricType>> availableTypes() async {
+    try {
+      return await _auth.getAvailableBiometrics();
+    } catch (_) {
+      return [];
+    }
+  }
+
+  Future<bool> authenticate({required String localizedReason}) async {
+    try {
+      return await _auth.authenticate(
+        localizedReason: localizedReason,
+        persistAcrossBackgrounding: true,
+      );
+    } catch (_) {
+      return false;
+    }
+  }
+}

package/templates/firebase/lib/core/security/biometric_ui_bundle.dart

@@ -0,0 +1,136 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/security/biometric_copy_slot.dart';
+import 'package:kasy_kit/core/security/biometric_service.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+
+/// Resolved copy on this device (`getAvailableBiometrics`), per language bundle.
+final biometricCopySlotFamily =
+    FutureProvider.family<BiometricCopySlot, TargetPlatform>(
+  (ref, platform) =>
+      ref.read(biometricServiceProvider).resolveCopySlot(platform),
+);
+
+/// UI strings tuned to [BiometricCopySlot] plus [biometric_prompt] variants.
+final class BioBundle {
+  BioBundle({
+    required this.settingsSubtitle,
+    required this.loginReason,
+    required this.enableReason,
+    required this.unavailableMessage,
+    required this.promptTitle,
+    required this.promptMessage,
+    required this.notNowLabel,
+    required this.enableLabel,
+  });
+
+  final String settingsSubtitle;
+  final String loginReason;
+  final String enableReason;
+  final String unavailableMessage;
+  final String promptTitle;
+  final String promptMessage;
+  final String notNowLabel;
+  final String enableLabel;
+
+  factory BioBundle.fromSlot(BuildContext context, BiometricCopySlot slot) {
+    final s = context.t.settings;
+    final bp = context.t.biometric_prompt;
+
+    switch (slot) {
+      case BiometricCopySlot.iosFaceOnly:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_ios_face,
+          loginReason: s.biometric_login_reason_ios_face,
+          enableReason: s.biometric_enable_reason_ios_face,
+          unavailableMessage: s.biometric_unavailable_message_ios_face,
+          promptTitle: bp.title_ios_face,
+          promptMessage: bp.message_ios_face,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.iosFingerprintOnly:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_ios_touch,
+          loginReason: s.biometric_login_reason_ios_touch,
+          enableReason: s.biometric_enable_reason_ios_touch,
+          unavailableMessage: s.biometric_unavailable_message_ios_touch,
+          promptTitle: bp.title_ios_touch,
+          promptMessage: bp.message_ios_touch,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.iosFaceAndFingerprint:
+      case BiometricCopySlot.iosUndetermined:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_ios,
+          loginReason: s.biometric_login_reason_ios,
+          enableReason: s.biometric_enable_reason_ios,
+          unavailableMessage: s.biometric_unavailable_message_ios,
+          promptTitle: bp.title_ios_mixed,
+          promptMessage: bp.message_ios_mixed,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.androidFaceOnly:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_android_face,
+          loginReason: s.biometric_login_reason_android_face,
+          enableReason: s.biometric_enable_reason_android_face,
+          unavailableMessage: s.biometric_unavailable_message_android_face,
+          promptTitle: bp.title_android_face,
+          promptMessage: bp.message_android_face,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.androidFingerprintOnly:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_android_fingerprint,
+          loginReason: s.biometric_login_reason_android_fingerprint,
+          enableReason: s.biometric_enable_reason_android_fingerprint,
+          unavailableMessage: s.biometric_unavailable_message_android_fingerprint,
+          promptTitle: bp.title_android_fingerprint,
+          promptMessage: bp.message_android_fingerprint,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.androidFaceAndFingerprint:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_android_face_and_fingerprint,
+          loginReason: s.biometric_login_reason_android_face_and_fingerprint,
+          enableReason: s.biometric_enable_reason_android_face_and_fingerprint,
+          unavailableMessage:
+              s.biometric_unavailable_message_android_face_and_fingerprint,
+          promptTitle: bp.title_android_face_and_fingerprint,
+          promptMessage: bp.message_android_face_and_fingerprint,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+      case BiometricCopySlot.androidUndetermined:
+      case BiometricCopySlot.unsupported:
+        return BioBundle(
+          settingsSubtitle: s.biometric_subtitle_android,
+          loginReason: s.biometric_login_reason_android,
+          enableReason: s.biometric_enable_reason_android,
+          unavailableMessage: s.biometric_unavailable_message_android,
+          promptTitle: bp.title_android_mixed,
+          promptMessage: bp.message_android_mixed,
+          notNowLabel: bp.not_now,
+          enableLabel: bp.enable,
+        );
+    }
+  }
+
+  /// Broad copy while biometric types are still loading (safe default).
+  factory BioBundle.fallbackForPlatform(BuildContext context) {
+    final isApple =
+        Theme.of(context).platform == TargetPlatform.iOS ||
+        Theme.of(context).platform == TargetPlatform.macOS;
+    return BioBundle.fromSlot(
+      context,
+      isApple
+          ? BiometricCopySlot.iosUndetermined
+          : BiometricCopySlot.androidUndetermined,
+    );
+  }
+}

package/templates/firebase/lib/core/security/secured_storage.dart

@@ -0,0 +1,46 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+
+const _kTokenKey = "token";
+const _kUserIdKey = "userId";
+
+final authSecuredStorageProvider = Provider<AuthSecuredStorage>(
+  (ref) => AuthSecuredStorage.fromEnv(),
+);
+
+class AuthSecuredStorage {
+  final FlutterSecureStorage _storage;
+
+  AuthSecuredStorage({
+    required FlutterSecureStorage storage,
+  }) : _storage = storage;
+
+  factory AuthSecuredStorage.fromEnv() => AuthSecuredStorage(
+        storage: const FlutterSecureStorage(),
+      );
+
+  Future<void> write({
+    required Credentials value,
+  }) async {
+    await _storage.write(key: _kUserIdKey, value: value.id);
+    await _storage.write(key: _kTokenKey, value: value.token);
+  }
+
+  Future<Credentials?> read() async {
+    final userId = await _storage.read(key: _kUserIdKey);
+    final token = await _storage.read(key: _kTokenKey);
+    if (userId != null && token != null) {
+      return Credentials(
+        id: userId,
+        token: token,
+      );
+    }
+    return null;
+  }
+
+  Future<void> clear() async {
+    await _storage.delete(key: _kUserIdKey);
+    await _storage.delete(key: _kTokenKey);
+  }
+}

package/templates/firebase/lib/core/shared_preferences/shared_preferences.dart

@@ -0,0 +1,70 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+final sharedPreferencesProvider = Provider<SharedPreferencesBuilder>(
+  (ref) => SharedPreferencesBuilder(),
+);
+
+class SharedPreferencesBuilder implements OnStartService {
+  SharedPreferences? _sharedPreferences;
+
+  @override
+  Future<void> init() async {
+    if (_sharedPreferences != null) {
+      return;
+    }
+    _sharedPreferences = await SharedPreferences.getInstance();
+  }
+
+  SharedPreferences get prefs {
+    if (_sharedPreferences == null) {
+      throw Exception('SharedPreferences not loaded');
+    }
+    return _sharedPreferences!;
+  }
+
+  /// Save the latest seen update version
+  Future<void> setLastSeenUpdateVersion(String version) async {
+    await prefs.setString('last_seen_update_version', version);
+  }
+
+  /// Get the latest seen update version
+  String? getLastSeenUpdateVersion() {
+    return prefs.getString('last_seen_update_version');
+  }
+
+  /// Save the user's preferred locale language code (e.g. 'en', 'pt', 'es')
+  Future<void> setAppLocale(String languageCode) async {
+    await prefs.setString('app_locale', languageCode);
+  }
+
+  /// Get the saved locale language code, or null if none saved
+  String? getAppLocale() {
+    return prefs.getString('app_locale');
+  }
+
+  Future<void> setHapticFeedbackEnabled(bool enabled) async {
+    await prefs.setBool('haptic_feedback_enabled', enabled);
+  }
+
+  bool getHapticFeedbackEnabled() {
+    return prefs.getBool('haptic_feedback_enabled') ?? true;
+  }
+
+  Future<void> setBiometricEnabled(bool enabled) async {
+    await prefs.setBool('biometric_enabled', enabled);
+  }
+
+  bool getBiometricEnabled() {
+    return prefs.getBool('biometric_enabled') ?? false;
+  }
+
+  Future<void> setBiometricPromptShown(bool shown) async {
+    await prefs.setBool('biometric_prompt_shown', shown);
+  }
+
+  bool getBiometricPromptShown() {
+    return prefs.getBool('biometric_prompt_shown') ?? false;
+  }
+}