update fix bug, handle error.

ios/.env_scheme

-dev
+pro

lib/base/app_navigator.dart

@@ -24,7 +24,7 @@ class AppNavigator {
   static BuildContext? get _ctx => key.currentContext;
 
   static Future<void> showAuthAlertAndGoLogin(String message) async {
-    final description = 'Phiên đăng nhập của bạn đã hết hạn. Vui lòng đăng nhập lại để tiếp tục sử dụng ứng dụng.';
+    final description = ErrorCodes.tokenInvalidMessage;
     if (_authDialogShown || _ctx == null) return;
     if (Get.isDialogOpen ?? false) Get.back();
     _authDialogShown = true;

lib/configs/constants.dart

@@ -10,7 +10,7 @@ class Constants {
 
 class ErrorCodes {
   static const List<String> tokenInvalidCodes = [
-    authTokenInvalid, authTokenEmpty
+    authTokenInvalid, authTokenEmpty, authTokenExpired
   ];
   static const String deviceLock = "ERR_DEVICE_LOCK";
   static const String deviceUndefined = "ERR_DEVICE_UNDEFINED";
@@ -18,9 +18,10 @@ class ErrorCodes {
   static const String invalidAccount = "ERR_INVALID_ACCOUNT";
   static const String bioTokenInvalid = "ERR_INVALID_BIO_TOKEN";
   static const String authTokenInvalid = "ERR_AUTH_TOKEN_INVALID";
+  static const String authTokenExpired = "ERR_AUTH_TOKEN_EXPIRED";
   static const String authTokenEmpty = "ERR_AUTH_TOKEN_EMPTY";
   static const String commonError = "Hệ thống không thể xử lý yêu cầu hiện tại. Vui lòng thử lại sau hoặc liên hệ hotline 1900599863 để được trợ giúp.";
   static const String networkError = 'Kết nối mạng không ổn định. Vui lòng thử lại!';
   static const String serverErrorMessage = 'Hệ thống không thể xử lý yêu cầu hiện tại. Vui lòng thử lại sau!';
-  static const String tokenInvalidMessage = 'Phiên đăng nhập đã hết hạn. Vui lòng đăng nhập lại.';
+  static const String tokenInvalidMessage =  'Phiên đăng nhập của bạn đã hết hạn. Vui lòng đăng nhập lại để tiếp tục sử dụng.';
 }
\ No newline at end of file

lib/networking/dio_extra_keys.dart

+const String kExtraSkipApiErrorHandling = '__skip_api_error_handling__';

lib/networking/interceptor/auth_interceptor.dart

+import 'dart:async';
+
 import 'package:dio/dio.dart';
+import '../../base/app_navigator.dart';
 import '../../configs/api_paths.dart';
 import '../../configs/constants.dart';
-import '../../base/app_navigator.dart';
 import '../../services/logout_service.dart';
-import '../dio_http_service.dart';
-import 'package:mypoint_flutter_app/preference/data_preference.dart';
 import '../../services/token_refresh_service.dart';
+import 'package:mypoint_flutter_app/preference/data_preference.dart';
+import '../dio_extra_keys.dart';
+import '../dio_http_service.dart';
 
 class AuthInterceptor extends Interceptor {
-  bool _isHandlingAuth = false;
   static const _kAuthHandledKey = '__auth_handled__';
-  
-  // Danh sách các path không cần refresh token khi gặp lỗi auth
+  static Completer<bool>? _refreshCompleter;
+  static Completer<void>? _logoutCompleter;
+
   static final List<String> _skipRefreshTokenPaths = [
     APIPaths.getUserInfo,
     APIPaths.login,
@@ -21,36 +24,30 @@ class AuthInterceptor extends Interceptor {
   ];
 
   @override
-  Future<void> onResponse(Response response, ResponseInterceptorHandler handler) async {
-    final data = response.data;
-    
-    if (_isTokenInvalid(data)) {
-      response.requestOptions.extra[_kAuthHandledKey] = true;
-      // Kiểm tra xem path này có cần skip refresh token không
-      if (_shouldSkipRefreshToken(response.requestOptions.path)) {
-        handler.reject(
-          DioException(
-            requestOptions: response.requestOptions
-            ..extra['mapped_error'] = ErrorCodes.tokenInvalidMessage,
-            response: response,
-            type: DioExceptionType.badResponse,
-            error: 'ERR_AUTH_TOKEN_INVALID',
-            message: ErrorCodes.tokenInvalidMessage,
-          ),
-        );
+  Future<void> onResponse(
+    Response response,
+    ResponseInterceptorHandler handler,
+  ) async {
+    if (_isTokenInvalid(response.data)) {
+      final request = response.requestOptions;
+      final authException = DioException(
+        requestOptions: request,
+        response: response,
+        type: DioExceptionType.badResponse,
+        error: ErrorCodes.authTokenInvalid,
+        message: ErrorCodes.tokenInvalidMessage,
+      );
+      if (_shouldSkipRefreshToken(request)) {
+        handler.reject(authException);
         return;
       }
-      
-      await _handleAuthError(data);
-      handler.reject(
-        DioException(
-          requestOptions: response.requestOptions
-          ..extra['mapped_error'] = ErrorCodes.tokenInvalidMessage,
-        response: response,
-          type: DioExceptionType.badResponse,
-          error: 'ERR_AUTH_TOKEN_INVALID',
-          message: ErrorCodes.tokenInvalidMessage,
-        ),
+      request.extra[_kAuthHandledKey] = true;
+      await _handleAuthError(
+        response.data,
+        originalRequest: request,
+        resolve: (retried) async => handler.resolve(retried),
+        reject: (error) async => handler.reject(error),
+        originalError: authException,
       );
       return;
     }
@@ -58,21 +55,33 @@ class AuthInterceptor extends Interceptor {
   }
 
   @override
-  Future<void> onError(DioException err, ErrorInterceptorHandler handler) async {
+  Future<void> onError(
+    DioException err,
+    ErrorInterceptorHandler handler,
+  ) async {
     final alreadyHandled = err.requestOptions.extra[_kAuthHandledKey] == true;
     final data = err.response?.data;
     final statusCode = err.response?.statusCode;
-    
-    if (alreadyHandled) return;
-    
-    if (_shouldSkipRefreshToken(err.requestOptions.path) &&
-        (statusCode == 401 || statusCode == 403 || _isTokenInvalid(data))) {
+    final isAuthException = (statusCode == 401 || statusCode == 403 || _isTokenInvalid(data));
+    if (alreadyHandled) {
       handler.next(err);
       return;
     }
-    
-    if (statusCode == 401 || _isTokenInvalid(data)) {
-      await _handleAuthError(data, originalRequest: err.requestOptions, handler: handler, originalError: err);
+
+    if (_shouldSkipRefreshToken(err.requestOptions)) {
+      handler.next(err);
+      return;
+    }
+
+    if (isAuthException) {
+      err.requestOptions.extra[_kAuthHandledKey] = true;
+      await _handleAuthError(
+        data,
+        originalRequest: err.requestOptions,
+        resolve: (retried) async => handler.resolve(retried),
+        reject: (error) async => handler.reject(error),
+        originalError: err,
+      );
       return;
     }
     handler.next(err);
@@ -86,66 +95,134 @@ class AuthInterceptor extends Interceptor {
     return false;
   }
 
-  /// Kiểm tra xem path này có cần skip refresh token không
-  bool _shouldSkipRefreshToken(String path) {
+  bool _shouldSkipRefreshToken(RequestOptions options) {
+    final path = options.path;
     if (path.isEmpty) return false;
-    for (String skipPath in _skipRefreshTokenPaths) {
-      if (path.contains(skipPath)) {
-        print('🔍 Path "$path" matches skip pattern "$skipPath", skipping refresh token.');
+    for (final candidate in _skipRefreshTokenPaths) {
+      if (path.contains(candidate)) {
         return true;
       }
     }
-    print('🔍 Path "$path" does not match any skip patterns, will attempt refresh token if needed.');
     return false;
   }
 
-  Future<void> _handleAuthError(dynamic data, {RequestOptions? originalRequest, ErrorInterceptorHandler? handler, DioException? originalError}) async {
-    if (_isHandlingAuth) return;
-    _isHandlingAuth = true;
+  Future<void> _handleAuthError(
+    dynamic data, {
+    required RequestOptions originalRequest,
+    required Future<void> Function(Response response) resolve,
+    required Future<void> Function(DioException error) reject,
+    required DioException originalError,
+  }) async {
+    final refreshSucceeded = await _ensureTokenRefreshed(data);
+    if (refreshSucceeded) {
+      try {
+        final retryOptions = originalRequest.copyWith();
+        retryOptions.extra.remove(_kAuthHandledKey);
+        final dio = DioHttpService().dio;
+        final Response retried = await dio.fetch(retryOptions);
+        await resolve(retried);
+        return;
+      } catch (e) {
+        if (e is DioException) {
+          if (_isAuthException(e)) {
+            await _ensureLogout(e.response?.data ?? data);
+            _markAuthFailure(e.requestOptions);
+          }
+          e.requestOptions.extra[kExtraSkipApiErrorHandling] = true;
+          await reject(e);
+          return;
+        }
+        await reject(errFrom(e, originalRequest));
+        return;
+      }
+    }
+
+    _markAuthFailure(originalRequest);
+    originalError.requestOptions.extra[kExtraSkipApiErrorHandling] = true;
+    await reject(originalError);
+  }
+
+  Future<bool> _ensureTokenRefreshed(dynamic data) async {
+    if (_logoutCompleter != null) {
+      await _logoutCompleter!.future;
+      return false;
+    }
+    final existing = _refreshCompleter;
+    if (existing != null) {
+      return existing.future;
+    }
+    final completer = Completer<bool>();
+    _refreshCompleter = completer;
     try {
-      // Thử refresh token trước khi logout
       final refreshService = TokenRefreshService();
-      if (!refreshService.isRefreshing) {
-        await refreshService.refreshToken((success) async {
-          if (success && originalRequest != null && handler != null) {
-            try {
-              final RequestOptions retryOptions = originalRequest.copyWith();
-              retryOptions.extra.remove(_kAuthHandledKey);
-              final dio = DioHttpService().dio;
-              final Response retried = await dio.fetch(retryOptions);
-              handler.resolve(retried);
-              return;
-            } catch (e) {
-              handler.reject(errFrom(e, originalRequest));
-            }
-          } else if (!success) {
-            _performLogout(data);
-            if (handler != null && originalError != null) handler.reject(originalError);
-          }
-        });
-      } else {
-        _performLogout(data);
-        if (handler != null && originalError != null) handler.reject(originalError);
+      await refreshService.refreshToken((success) async {
+        if (!success) {
+          await _ensureLogout(data);
+          if (!completer.isCompleted) completer.complete(false);
+          return;
+        }
+        if (!completer.isCompleted) completer.complete(true);
+      });
+      return await completer.future;
+    } catch (_) {
+      await _ensureLogout(data);
+      if (!completer.isCompleted) completer.complete(false);
+      return false;
+    } finally {
+      if (identical(_refreshCompleter, completer)) {
+        _refreshCompleter = null;
       }
+    }
+  }
+
+  Future<void> _ensureLogout(dynamic data) async {
+    final existing = _logoutCompleter;
+    if (existing != null) {
+      await existing.future;
+      return;
+    }
+    final completer = Completer<void>();
+    _logoutCompleter = completer;
+    try {
+      await _performLogout(data);
     } finally {
-      _isHandlingAuth = false;
+      if (!completer.isCompleted) completer.complete();
+      _logoutCompleter = null;
     }
   }
 
+  bool _isAuthException(DioException exception) {
+    final status = exception.response?.statusCode;
+    return status == 401 ||
+        status == 403 ||
+        _isTokenInvalid(exception.response?.data);
+  }
+
   DioException errFrom(Object e, RequestOptions req) {
     if (e is DioException) return e;
     return DioException(requestOptions: req, error: e);
   }
 
   Future<void> _performLogout(dynamic data) async {
-    LogoutService.logout();
-    await DataPreference.instance.clearData();
     String? message;
     if (data is Map<String, dynamic>) {
-      message = data['error_message']?.toString() ??
+      message =
+          data['error_message']?.toString() ??
           data['errorMessage']?.toString() ??
           data['message']?.toString();
     }
-    await AppNavigator.showAuthAlertAndGoLogin(message ?? ErrorCodes.tokenInvalidMessage);
+    final logged = DataPreference.instance.logged;
+    if (logged) {
+      await AppNavigator.showAuthAlertAndGoLogin(
+        message ?? ErrorCodes.tokenInvalidMessage,
+      );
+    }
+    await LogoutService.logout();
+    await DataPreference.instance.clearData();
+  }
+
+  void _markAuthFailure(RequestOptions options) {
+    options.extra[_kAuthHandledKey] = true;
+    options.extra[kExtraSkipApiErrorHandling] = true;
   }
 }