11 posts tagged with "api"

class User {
  final int id;
  final String name;
  final String email;

  User({
    required this.id,
    required this.name,
    required this.email,
  });

  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
}

class ApiService {
  final client = http.Client();
  final baseUrl = 'https://api.example.com';

  Future<List<User>> getUsers() async {
    try {
      final response = await client.get(
        Uri.parse('$baseUrl/users'),
        headers: {'Authorization': 'Bearer token'},
      );
      
      if (response.statusCode == 200) {
        final List<dynamic> data = json.decode(response.body);
        return data.map((json) => User.fromJson(json)).toList();
      } else {
        throw Exception('Lỗi lấy dữ liệu: ${response.statusCode}');
      }
    } catch (e) {
      throw Exception('Lỗi kết nối: $e');
    }
  }
}

class UserProvider extends ChangeNotifier {
  final _apiService = ApiService();
  List<User> _users = [];
  bool _loading = false;
  String? _error;

  Future<void> fetchUsers() async {
    try {
      _loading = true;
      notifyListeners();
      
      _users = await _apiService.getUsers();
      _error = null;
    } catch (e) {
      _error = e.toString();
    } finally {
      _loading = false;
      notifyListeners();
    }
  }
}

class UsersScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Consumer<UserProvider>(
      builder: (context, provider, child) {
        if (provider._loading) {
          return CircularProgressIndicator();
        }
        
        if (provider._error != null) {
          return Text('Lỗi: ${provider._error}');
        }

        return ListView.builder(
          itemCount: provider._users.length,
          itemBuilder: (context, index) {
            final user = provider._users[index];
            return ListTile(
              title: Text(user.name),
              subtitle: Text(user.email),
            );
          },
        );
      },
    );
  }
}

import 'package:dio/dio.dart';

import 'package:http/http.dart' as http;
import 'dart:convert';

// Gọi API với http package
Future<void> fetchData() async {
  final response = await http.get(
    Uri.parse('https://api.example.com/data'),
    headers: {'Content-Type': 'application/json'},
  );
  
  if (response.statusCode == 200) {
    final data = json.decode(response.body);
    print(data);
  } else {
    print('Error: ${response.statusCode}');
  }
}

import 'package:dio/dio.dart';

// Gọi API với Dio
Future<void> fetchData() async {
  final dio = Dio();
  
  try {
    final response = await dio.get('https://api.example.com/data');
    print(response.data);
  } catch (e) {
    print('Error: $e');
  }
}

final dio = Dio();

// Thêm interceptor để log requests
dio.interceptors.add(LogInterceptor(
  requestBody: true,
  responseBody: true,
));

// Thêm interceptor tùy chỉnh
dio.interceptors.add(InterceptorsWrapper(
  onRequest: (options, handler) {
    // Thêm token vào header
    options.headers['Authorization'] = 'Bearer your_token';
    return handler.next(options);
  },
  onResponse: (response, handler) {
    // Xử lý response
    return handler.next(response);
  },
  onError: (error, handler) {
    // Xử lý lỗi
    return handler.next(error);
  },
));

import 'package:dio/retry.dart';

final dio = Dio();

dio.interceptors.add(
  RetryInterceptor(
    dio: dio,
    options: const RetryOptions(
      retries: 3,
      retryInterval: Duration(seconds: 2),
    ),
  ),
);

final dio = Dio();

dio.transformer = BackgroundTransformer()..jsonDecodeCallback = parseJson;

// Custom JSON parser
Map<String, dynamic> parseJson(String text) {
  // Custom parsing logic
  return jsonDecode(text);
}

final dio = Dio(BaseOptions(
  connectTimeout: Duration(seconds: 5),
  receiveTimeout: Duration(seconds: 3),
  sendTimeout: Duration(seconds: 3),
));

final cancelToken = CancelToken();

// Gọi API với cancel token
dio.get(
  'https://api.example.com/data',
  cancelToken: cancelToken,
);

// Hủy request
cancelToken.cancel('Request cancelled');

// Upload file
FormData formData = FormData.fromMap({
  'file': await MultipartFile.fromFile('/path/to/file'),
});

await dio.post(
  'https://api.example.com/upload',
  data: formData,
  onSendProgress: (sent, total) {
    print('Progress: ${(sent / total * 100).toStringAsFixed(0)}%');
  },
);

// Download file
await dio.download(
  'https://api.example.com/file',
  '/path/to/save/file',
  onReceiveProgress: (received, total) {
    print('Progress: ${(received / total * 100).toStringAsFixed(0)}%');
  },
);

Future<Map<String, dynamic>> fetchUser(int userId) async {
  final uri = Uri.parse('https://api.example.com/users/$userId');
  final response = await http.get(
    uri,
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $token',
    },
  );
  
  if (response.statusCode == 200) {
    return json.decode(response.body);
  } else if (response.statusCode == 401) {
    throw UnauthorizedException();
  } else if (response.statusCode == 404) {
    throw NotFoundException();
  } else {
    throw ServerException();
  }
}

Future<Map<String, dynamic>> fetchUser(int userId) async {
  try {
    final response = await dio.get('/users/$userId');
    return response.data;
  } on DioException catch (e) {
    if (e.response?.statusCode == 401) {
      throw UnauthorizedException();
    } else if (e.response?.statusCode == 404) {
      throw NotFoundException();
    } else {
      throw ServerException();
    }
  }
}

try {
  await dio.get('/api/data');
} on DioException catch (e) {
  switch (e.type) {
    case DioExceptionType.connectionTimeout:
      print('Connection timeout');
      break;
    case DioExceptionType.sendTimeout:
      print('Send timeout');
      break;
    case DioExceptionType.receiveTimeout:
      print('Receive timeout');
      break;
    case DioExceptionType.badResponse:
      print('Bad response: ${e.response?.statusCode}');
      break;
    case DioExceptionType.cancel:
      print('Request cancelled');
      break;
    default:
      print('Other error: ${e.message}');
  }
}

class ApiClient {
  static final Dio _dio = Dio(BaseOptions(
    baseUrl: 'https://api.example.com',
    headers: {'Content-Type': 'application/json'},
  ));

  static void init() {
    // Thêm token vào mọi request
    _dio.interceptors.add(InterceptorsWrapper(
      onRequest: (options, handler) {
        final token = TokenManager.getToken();
        if (token != null) {
          options.headers['Authorization'] = 'Bearer $token';
        }
        return handler.next(options);
      },
    ));

    // Log requests
    _dio.interceptors.add(LogInterceptor(
      requestBody: true,
      responseBody: true,
    ));

    // Retry logic
    _dio.interceptors.add(
      RetryInterceptor(
        dio: _dio,
        options: const RetryOptions(retries: 3),
      ),
    );
  }

  static Dio get dio => _dio;
}

// Định nghĩa model
class User {
  final int id;
  final String name;
  final String email;

  User({required this.id, required this.name, required this.email});

  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
}

// Sử dụng với Dio
Future<User> fetchUser(int id) async {
  final response = await dio.get<Map<String, dynamic>>('/users/$id');
  return User.fromJson(response.data!);
}

// JSON (mặc định)
await dio.post('/api/data', data: {'key': 'value'});

// FormData
await dio.post('/api/upload', data: FormData.fromMap({
  'file': multipartFile,
  'name': 'filename',
}));

// URL encoded
await dio.post(
  '/api/data',
  data: {'key': 'value'},
  options: Options(contentType: Headers.formUrlEncodedContentType),
);

import 'package:dio/dio.dart';

class ApiService {
  late Dio _dio;

  ApiService() {
    _dio = Dio(BaseOptions(
      baseUrl: 'https://api.example.com',
      connectTimeout: Duration(seconds: 5),
      receiveTimeout: Duration(seconds: 3),
      headers: {
        'Content-Type': 'application/json',
      },
    ));

    _setupInterceptors();
  }

  void _setupInterceptors() {
    // Log interceptor
    _dio.interceptors.add(LogInterceptor(
      requestBody: true,
      responseBody: true,
      error: true,
    ));

    // Auth interceptor
    _dio.interceptors.add(InterceptorsWrapper(
      onRequest: (options, handler) {
        final token = _getToken();
        if (token != null) {
          options.headers['Authorization'] = 'Bearer $token';
        }
        return handler.next(options);
      },
      onError: (error, handler) {
        if (error.response?.statusCode == 401) {
          // Refresh token hoặc đăng nhập lại
          _handleUnauthorized();
        }
        return handler.next(error);
      },
    ));
  }

  String? _getToken() {
    // Lấy token từ storage
    return 'your_token_here';
  }

  void _handleUnauthorized() {
    // Xử lý khi unauthorized
  }

  // GET request
  Future<Response> get(String path, {Map<String, dynamic>? queryParameters}) async {
    try {
      return await _dio.get(path, queryParameters: queryParameters);
    } on DioException catch (e) {
      throw _handleError(e);
    }
  }

  // POST request
  Future<Response> post(String path, {dynamic data}) async {
    try {
      return await _dio.post(path, data: data);
    } on DioException catch (e) {
      throw _handleError(e);
    }
  }

  // PUT request
  Future<Response> put(String path, {dynamic data}) async {
    try {
      return await _dio.put(path, data: data);
    } on DioException catch (e) {
      throw _handleError(e);
    }
  }

  // DELETE request
  Future<Response> delete(String path) async {
    try {
      return await _dio.delete(path);
    } on DioException catch (e) {
      throw _handleError(e);
    }
  }

  Exception _handleError(DioException error) {
    switch (error.type) {
      case DioExceptionType.connectionTimeout:
      case DioExceptionType.sendTimeout:
      case DioExceptionType.receiveTimeout:
        return TimeoutException('Request timeout');
      case DioExceptionType.badResponse:
        return ServerException('Server error: ${error.response?.statusCode}');
      case DioExceptionType.cancel:
        return CancelException('Request cancelled');
      default:
        return NetworkException('Network error: ${error.message}');
    }
  }
}

// Custom exceptions
class TimeoutException implements Exception {
  final String message;
  TimeoutException(this.message);
}

class ServerException implements Exception {
  final String message;
  ServerException(this.message);
}

class CancelException implements Exception {
  final String message;
  CancelException(this.message);
}

class NetworkException implements Exception {
  final String message;
  NetworkException(this.message);
}

import 'package:dio/dio.dart';

class ApiClient {
  late Dio _dio;

  ApiClient() {
    _dio = Dio(BaseOptions(
      baseUrl: 'https://api.example.com',
      connectTimeout: Duration(seconds: 5),
      receiveTimeout: Duration(seconds: 3),
      sendTimeout: Duration(seconds: 3),
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
    ));
  }

  Dio get dio => _dio;
}

import 'package:dio/dio.dart';

void setupLogInterceptor(Dio dio) {
  dio.interceptors.add(LogInterceptor(
    request: true,
    requestHeader: true,
    requestBody: true,
    responseHeader: true,
    responseBody: true,
    error: true,
    logPrint: (obj) {
      // Sử dụng logger của bạn (ví dụ: logger package)
      print(obj);
    },
  ));
}

class AuthInterceptor extends Interceptor {
  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    // Lấy token từ storage
    final token = TokenStorage.getToken();
    
    if (token != null) {
      options.headers['Authorization'] = 'Bearer $token';
    }
    
    handler.next(options);
  }
}

// Sử dụng
dio.interceptors.add(AuthInterceptor());

class RefreshTokenInterceptor extends Interceptor {
  final Dio refreshDio;

  RefreshTokenInterceptor(this.refreshDio);

  @override
  void onError(DioException err, ErrorInterceptorHandler handler) async {
    // Nếu lỗi 401 (Unauthorized)
    if (err.response?.statusCode == 401) {
      try {
        // Refresh token
        final newToken = await _refreshToken();
        
        if (newToken != null) {
          // Lưu token mới
          TokenStorage.saveToken(newToken);
          
          // Retry request với token mới
          final opts = err.requestOptions;
          opts.headers['Authorization'] = 'Bearer $newToken';
          
          final response = await refreshDio.request(
            opts.path,
            options: Options(
              method: opts.method,
              headers: opts.headers,
            ),
            data: opts.data,
            queryParameters: opts.queryParameters,
          );
          
          return handler.resolve(response);
        }
      } catch (e) {
        // Nếu refresh token thất bại, đăng xuất
        await AuthService.logout();
        return handler.reject(err);
      }
    }
    
    return handler.next(err);
  }

  Future<String?> _refreshToken() async {
    try {
      final refreshToken = TokenStorage.getRefreshToken();
      final response = await refreshDio.post(
        '/auth/refresh',
        data: {'refresh_token': refreshToken},
      );
      
      return response.data['access_token'];
    } catch (e) {
      return null;
    }
  }
}

// Sử dụng
final refreshDio = Dio();
dio.interceptors.add(RefreshTokenInterceptor(refreshDio));

class ErrorInterceptor extends Interceptor {
  @override
  void onError(DioException err, ErrorInterceptorHandler handler) {
    String errorMessage = 'Đã xảy ra lỗi';

    switch (err.type) {
      case DioExceptionType.connectionTimeout:
      case DioExceptionType.sendTimeout:
      case DioExceptionType.receiveTimeout:
        errorMessage = 'Kết nối timeout. Vui lòng thử lại.';
        break;
      case DioExceptionType.badResponse:
        final statusCode = err.response?.statusCode;
        switch (statusCode) {
          case 400:
            errorMessage = 'Yêu cầu không hợp lệ';
            break;
          case 401:
            errorMessage = 'Chưa đăng nhập hoặc token đã hết hạn';
            break;
          case 403:
            errorMessage = 'Không có quyền truy cập';
            break;
          case 404:
            errorMessage = 'Không tìm thấy tài nguyên';
            break;
          case 500:
            errorMessage = 'Lỗi server. Vui lòng thử lại sau.';
            break;
          default:
            errorMessage = 'Lỗi server: $statusCode';
        }
        break;
      case DioExceptionType.cancel:
        errorMessage = 'Request đã bị hủy';
        break;
      case DioExceptionType.unknown:
        errorMessage = 'Không có kết nối internet';
        break;
      default:
        errorMessage = err.message ?? 'Đã xảy ra lỗi';
    }

    // Hiển thị thông báo lỗi (sử dụng snackbar, dialog, etc.)
    ErrorHandler.showError(errorMessage);

    handler.next(err);
  }
}

// Sử dụng
dio.interceptors.add(ErrorInterceptor());

class DataTransformerInterceptor extends Interceptor {
  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    // Transform request data
    if (options.data is Map) {
      // Thêm timestamp, device info, etc.
      options.data = {
        ...options.data as Map,
        'timestamp': DateTime.now().toIso8601String(),
        'device_id': DeviceInfo.getDeviceId(),
      };
    }
    
    handler.next(options);
  }

  @override
  void onResponse(Response response, ResponseInterceptorHandler handler) {
    // Transform response data
    if (response.data is Map) {
      final data = response.data as Map;
      
      // Unwrap nested data nếu cần
      if (data.containsKey('data')) {
        response.data = data['data'];
      }
    }
    
    handler.next(response);
  }
}

// Sử dụng
dio.interceptors.add(DataTransformerInterceptor());

import 'package:dio/dio.dart';
import 'package:dio_retry/dio_retry.dart';

void setupRetryInterceptor(Dio dio) {
  dio.interceptors.add(
    RetryInterceptor(
      dio: dio,
      options: RetryOptions(
        retries: 3, // Số lần retry
        retryInterval: Duration(seconds: 2), // Khoảng thời gian giữa các lần retry
        exponentialBackoff: true, // Tăng dần thời gian chờ
        retryableExtraStatuses: [401, 403], // Retry với các status code này
      ),
    ),
  );
}

class RetryInterceptor extends Interceptor {
  final int maxRetries;
  final Duration retryDelay;

  RetryInterceptor({
    this.maxRetries = 3,
    this.retryDelay = const Duration(seconds: 2),
  });

  @override
  void onError(DioException err, ErrorInterceptorHandler handler) async {
    if (_shouldRetry(err)) {
      final retryCount = err.requestOptions.extra['retryCount'] ?? 0;
      
      if (retryCount < maxRetries) {
        // Tăng retry count
        err.requestOptions.extra['retryCount'] = retryCount + 1;
        
        // Đợi trước khi retry
        await Future.delayed(retryDelay * (retryCount + 1));
        
        try {
          // Retry request
          final response = await dio.request(
            err.requestOptions.path,
            options: Options(
              method: err.requestOptions.method,
              headers: err.requestOptions.headers,
            ),
            data: err.requestOptions.data,
            queryParameters: err.requestOptions.queryParameters,
            extra: err.requestOptions.extra,
          );
          
          return handler.resolve(response);
        } catch (e) {
          // Nếu vẫn lỗi, tiếp tục retry hoặc reject
          if (retryCount + 1 < maxRetries) {
            return onError(err, handler);
          }
        }
      }
    }
    
    handler.next(err);
  }

  bool _shouldRetry(DioException err) {
    // Chỉ retry với một số loại lỗi nhất định
    return err.type == DioExceptionType.connectionTimeout ||
           err.type == DioExceptionType.receiveTimeout ||
           err.type == DioExceptionType.sendTimeout ||
           (err.response?.statusCode != null && 
            err.response!.statusCode! >= 500);
  }
}

// Sử dụng
dio.interceptors.add(RetryInterceptor(maxRetries: 3));

import 'package:dio/dio.dart';
import 'package:dio_retry/dio_retry.dart';

class ApiService {
  late Dio _dio;
  static final ApiService _instance = ApiService._internal();

  factory ApiService() => _instance;

  ApiService._internal() {
    _dio = Dio(BaseOptions(
      baseUrl: 'https://api.example.com',
      connectTimeout: Duration(seconds: 5),
      receiveTimeout: Duration(seconds: 3),
      sendTimeout: Duration(seconds: 3),
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
    ));

    _setupInterceptors();
  }

  void _setupInterceptors() {
    // 1. Log Interceptor
    _dio.interceptors.add(LogInterceptor(
      requestBody: true,
      responseBody: true,
      error: true,
    ));

    // 2. Auth Interceptor
    _dio.interceptors.add(InterceptorsWrapper(
      onRequest: (options, handler) {
        final token = _getToken();
        if (token != null) {
          options.headers['Authorization'] = 'Bearer $token';
        }
        return handler.next(options);
      },
    ));

    // 3. Retry Interceptor
    _dio.interceptors.add(
      RetryInterceptor(
        dio: _dio,
        options: RetryOptions(
          retries: 3,
          retryInterval: Duration(seconds: 2),
          exponentialBackoff: true,
        ),
      ),
    );

    // 4. Error Interceptor
    _dio.interceptors.add(InterceptorsWrapper(
      onError: (error, handler) {
        _handleError(error);
        return handler.next(error);
      },
    ));
  }

  String? _getToken() {
    // Lấy token từ secure storage
    // return SecureStorage.getToken();
    return null;
  }

  void _handleError(DioException error) {
    // Xử lý lỗi tập trung
    // Có thể hiển thị snackbar, log, etc.
    print('API Error: ${error.message}');
  }

  // GET request
  Future<Response<T>> get<T>(
    String path, {
    Map<String, dynamic>? queryParameters,
    Options? options,
    CancelToken? cancelToken,
  }) async {
    try {
      return await _dio.get<T>(
        path,
        queryParameters: queryParameters,
        options: options,
        cancelToken: cancelToken,
      );
    } on DioException catch (e) {
      throw _mapException(e);
    }
  }

  // POST request
  Future<Response<T>> post<T>(
    String path, {
    dynamic data,
    Map<String, dynamic>? queryParameters,
    Options? options,
    CancelToken? cancelToken,
  }) async {
    try {
      return await _dio.post<T>(
        path,
        data: data,
        queryParameters: queryParameters,
        options: options,
        cancelToken: cancelToken,
      );
    } on DioException catch (e) {
      throw _mapException(e);
    }
  }

  // PUT request
  Future<Response<T>> put<T>(
    String path, {
    dynamic data,
    Map<String, dynamic>? queryParameters,
    Options? options,
    CancelToken? cancelToken,
  }) async {
    try {
      return await _dio.put<T>(
        path,
        data: data,
        queryParameters: queryParameters,
        options: options,
        cancelToken: cancelToken,
      );
    } on DioException catch (e) {
      throw _mapException(e);
    }
  }

  // DELETE request
  Future<Response<T>> delete<T>(
    String path, {
    dynamic data,
    Map<String, dynamic>? queryParameters,
    Options? options,
    CancelToken? cancelToken,
  }) async {
    try {
      return await _dio.delete<T>(
        path,
        data: data,
        queryParameters: queryParameters,
        options: options,
        cancelToken: cancelToken,
      );
    } on DioException catch (e) {
      throw _mapException(e);
    }
  }

  Exception _mapException(DioException error) {
    switch (error.type) {
      case DioExceptionType.connectionTimeout:
      case DioExceptionType.sendTimeout:
      case DioExceptionType.receiveTimeout:
        return TimeoutException('Request timeout');
      case DioExceptionType.badResponse:
        return ServerException(
          'Server error: ${error.response?.statusCode}',
          error.response?.statusCode,
        );
      case DioExceptionType.cancel:
        return CancelException('Request cancelled');
      default:
        return NetworkException('Network error: ${error.message}');
    }
  }
}

// Custom exceptions
class TimeoutException implements Exception {
  final String message;
  TimeoutException(this.message);
}

class ServerException implements Exception {
  final String message;
  final int? statusCode;
  ServerException(this.message, this.statusCode);
}

class CancelException implements Exception {
  final String message;
  CancelException(this.message);
}

class NetworkException implements Exception {
  final String message;
  NetworkException(this.message);
}

// Trong repository hoặc service
class UserRepository {
  final ApiService _apiService = ApiService();

  Future<User> getUser(int id) async {
    try {
      final response = await _apiService.get<Map<String, dynamic>>('/users/$id');
      return User.fromJson(response.data!);
    } catch (e) {
      throw Exception('Failed to get user: $e');
    }
  }

  Future<List<User>> getUsers() async {
    try {
      final response = await _apiService.get<List<dynamic>>('/users');
      return (response.data as List)
          .map((json) => User.fromJson(json))
          .toList();
    } catch (e) {
      throw Exception('Failed to get users: $e');
    }
  }

  Future<User> createUser(User user) async {
    try {
      final response = await _apiService.post<Map<String, dynamic>>(
        '/users',
        data: user.toJson(),
      );
      return User.fromJson(response.data!);
    } catch (e) {
      throw Exception('Failed to create user: $e');
    }
  }
}

// 1. Log interceptor (đầu tiên để log tất cả)
dio.interceptors.add(LogInterceptor());

// 2. Auth interceptor (thêm token)
dio.interceptors.add(AuthInterceptor());

// 3. Retry interceptor (retry khi lỗi)
dio.interceptors.add(RetryInterceptor());

// 4. Error interceptor (xử lý lỗi cuối cùng)
dio.interceptors.add(ErrorInterceptor());

class ApiService {
  static final ApiService _instance = ApiService._internal();
  factory ApiService() => _instance;
  ApiService._internal();
}

final cancelToken = CancelToken();

// Gọi API
_apiService.get('/data', cancelToken: cancelToken);

// Hủy khi không cần thiết (ví dụ: khi widget dispose)
@override
void dispose() {
  cancelToken.cancel('Widget disposed');
  super.dispose();
}

// ❌ Không tốt: State management thủ công
class UserScreen extends StatefulWidget {
  @override
  _UserScreenState createState() => _UserScreenState();
}

class _UserScreenState extends State<UserScreen> {
  User? user;
  bool isLoading = false;
  String? error;

  @override
  void initState() {
    super.initState();
    _loadUser();
  }

  Future<void> _loadUser() async {
    setState(() => isLoading = true);
    try {
      final response = await api.getUser(1);
      setState(() {
        user = response;
        isLoading = false;
      });
    } catch (e) {
      setState(() {
        error = e.toString();
        isLoading = false;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    // Phải xử lý loading, error, data trong mọi widget
    if (isLoading) return CircularProgressIndicator();
    if (error != null) return Text('Error: $error');
    if (user == null) return Text('No data');
    return UserWidget(user: user!);
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:dio/dio.dart';

// API Service
final apiServiceProvider = Provider<Dio>((ref) {
  return Dio(BaseOptions(
    baseUrl: 'https://api.example.com',
  ));
});

// User Repository
final userRepositoryProvider = Provider<UserRepository>((ref) {
  final dio = ref.watch(apiServiceProvider);
  return UserRepository(dio);
});

import 'package:flutter_riverpod/flutter_riverpod.dart';

// User Provider với async state
final userProvider = FutureProvider.family<User, int>((ref, userId) async {
  final repository = ref.watch(userRepositoryProvider);
  return await repository.getUser(userId);
});

// Users List Provider
final usersProvider = FutureProvider<List<User>>((ref) async {
  final repository = ref.watch(userRepositoryProvider);
  return await repository.getUsers();
});

import 'package:flutter_riverpod/flutter_riverpod.dart';

class UserScreen extends ConsumerWidget {
  final int userId;

  const UserScreen({Key? key, required this.userId}) : super(key: key);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userProvider(userId));

    return Scaffold(
      appBar: AppBar(title: Text('User')),
      body: userAsync.when(
        data: (user) => UserDetailsWidget(user: user),
        loading: () => Center(child: CircularProgressIndicator()),
        error: (error, stack) => ErrorWidget(
          error: error,
          onRetry: () => ref.refresh(userProvider(userId)),
        ),
      ),
    );
  }
}

// User State
class UserState {
  final User? user;
  final bool isLoading;
  final String? error;

  UserState({
    this.user,
    this.isLoading = false,
    this.error,
  });

  UserState copyWith({
    User? user,
    bool? isLoading,
    String? error,
  }) {
    return UserState(
      user: user ?? this.user,
      isLoading: isLoading ?? this.isLoading,
      error: error,
    );
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';

class UserNotifier extends StateNotifier<UserState> {
  final UserRepository repository;

  UserNotifier(this.repository) : super(UserState());

  Future<void> loadUser(int userId) async {
    state = state.copyWith(isLoading: true, error: null);

    try {
      final user = await repository.getUser(userId);
      state = state.copyWith(user: user, isLoading: false);
    } catch (e) {
      state = state.copyWith(
        error: e.toString(),
        isLoading: false,
      );
    }
  }

  Future<void> updateUser(User user) async {
    state = state.copyWith(isLoading: true, error: null);

    try {
      final updatedUser = await repository.updateUser(user);
      state = state.copyWith(user: updatedUser, isLoading: false);
    } catch (e) {
      state = state.copyWith(
        error: e.toString(),
        isLoading: false,
      );
    }
  }

  void clearError() {
    state = state.copyWith(error: null);
  }
}

// Provider
final userNotifierProvider = StateNotifierProvider<UserNotifier, UserState>((ref) {
  final repository = ref.watch(userRepositoryProvider);
  return UserNotifier(repository);
});

class UserScreen extends ConsumerWidget {
  final int userId;

  const UserScreen({Key? key, required this.userId}) : super(key: key);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userState = ref.watch(userNotifierProvider);

    // Load user khi widget được build
    ref.listen(userNotifierProvider.notifier, (previous, next) {
      next.loadUser(userId);
    });

    if (userState.isLoading) {
      return Scaffold(
        body: Center(child: CircularProgressIndicator()),
      );
    }

    if (userState.error != null) {
      return Scaffold(
        body: ErrorWidget(
          error: userState.error!,
          onRetry: () => ref.read(userNotifierProvider.notifier).loadUser(userId),
        ),
      );
    }

    if (userState.user == null) {
      return Scaffold(
        body: Center(child: Text('No data')),
      );
    }

    return Scaffold(
      appBar: AppBar(title: Text('User')),
      body: UserDetailsWidget(user: userState.user!),
    );
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';

class UserAsyncNotifier extends AsyncNotifier<User> {
  @override
  Future<User> build() async {
    // Load initial data
    final userId = ref.watch(selectedUserIdProvider);
    final repository = ref.watch(userRepositoryProvider);
    return await repository.getUser(userId);
  }

  Future<void> refresh() async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      final userId = ref.read(selectedUserIdProvider);
      final repository = ref.read(userRepositoryProvider);
      return await repository.getUser(userId);
    });
  }

  Future<void> updateUser(User user) async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      final repository = ref.read(userRepositoryProvider);
      return await repository.updateUser(user);
    });
  }
}

// Provider
final userAsyncNotifierProvider = 
    AsyncNotifierProvider<UserAsyncNotifier, User>(() {
  return UserAsyncNotifier();
});

class UserScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userAsyncNotifierProvider);

    return Scaffold(
      appBar: AppBar(
        title: Text('User'),
        actions: [
          IconButton(
            icon: Icon(Icons.refresh),
            onPressed: () => ref.read(userAsyncNotifierProvider.notifier).refresh(),
          ),
        ],
      ),
      body: userAsync.when(
        data: (user) => UserDetailsWidget(user: user),
        loading: () => Center(child: CircularProgressIndicator()),
        error: (error, stack) => ErrorWidget(
          error: error,
          onRetry: () => ref.read(userAsyncNotifierProvider.notifier).refresh(),
        ),
      ),
    );
  }
}

import 'package:flutter/foundation.dart';

class UserProvider extends ChangeNotifier {
  final UserRepository repository;

  User? _user;
  bool _isLoading = false;
  String? _error;

  User? get user => _user;
  bool get isLoading => _isLoading;
  String? get error => _error;

  UserProvider(this.repository);

  Future<void> loadUser(int userId) async {
    _isLoading = true;
    _error = null;
    notifyListeners();

    try {
      _user = await repository.getUser(userId);
      _error = null;
    } catch (e) {
      _error = e.toString();
      _user = null;
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }

  Future<void> refresh() async {
    if (_user != null) {
      await loadUser(_user!.id);
    }
  }
}

import 'package:provider/provider.dart';

class UserScreen extends StatelessWidget {
  final int userId;

  const UserScreen({Key? key, required this.userId}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => UserProvider(UserRepository())..loadUser(userId),
      child: Consumer<UserProvider>(
        builder: (context, provider, child) {
          if (provider.isLoading) {
            return Scaffold(
              body: Center(child: CircularProgressIndicator()),
            );
          }

          if (provider.error != null) {
            return Scaffold(
              body: ErrorWidget(
                error: provider.error!,
                onRetry: () => provider.loadUser(userId),
              ),
            );
          }

          if (provider.user == null) {
            return Scaffold(
              body: Center(child: Text('No data')),
            );
          }

          return Scaffold(
            appBar: AppBar(title: Text('User')),
            body: UserDetailsWidget(user: provider.user!),
          );
        },
      ),
    );
  }
}

// Provider với cache
final cachedUserProvider = FutureProvider.family<User, int>((ref, userId) async {
  final repository = ref.watch(userRepositoryProvider);
  
  // Cache sẽ tự động được quản lý bởi Riverpod
  return await repository.getUser(userId);
});

// Auto refresh khi dependency thay đổi
final userWithAutoRefreshProvider = FutureProvider.family<User, int>((ref, userId) async {
  // Watch một provider khác để trigger refresh
  ref.watch(refreshTriggerProvider);
  
  final repository = ref.watch(userRepositoryProvider);
  return await repository.getUser(userId);
});

class UserScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userProvider(1));

    return Scaffold(
      appBar: AppBar(
        title: Text('User'),
        actions: [
          IconButton(
            icon: Icon(Icons.refresh),
            onPressed: () {
              // Invalidate và reload
              ref.invalidate(userProvider(1));
            },
          ),
        ],
      ),
      body: userAsync.when(
        data: (user) => UserDetailsWidget(user: user),
        loading: () => Center(child: CircularProgressIndicator()),
        error: (error, stack) => ErrorWidget(error: error),
      ),
    );
  }
}

final userProvider = FutureProvider.family<User, int>((ref, userId) async {
  try {
    final repository = ref.watch(userRepositoryProvider);
    return await repository.getUser(userId);
  } on AppException catch (e) {
    // Handle specific exceptions
    throw e;
  } catch (e) {
    throw UnknownException('Failed to load user');
  }
});

// Sử dụng
class UserScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userProvider(1));

    // Listen to errors
    ref.listen(userProvider(1), (previous, next) {
      next.whenOrNull(
        error: (error, stack) {
          if (error is AppException) {
            ErrorHandler.handleError(error);
          }
        },
      );
    });

    return userAsync.when(
      data: (user) => UserDetailsWidget(user: user),
      loading: () => CircularProgressIndicator(),
      error: (error, stack) => ErrorWidget(error: error),
    );
  }
}

class UserRepository {
  final Dio dio;

  UserRepository(this.dio);

  Future<User> getUser(int id) async {
    final response = await dio.get('/users/$id');
    return User.fromJson(response.data as Map<String, dynamic>);
  }

  Future<List<User>> getUsers() async {
    final response = await dio.get('/users');
    return (response.data as List<dynamic>)
        .map((json) => User.fromJson(json as Map<String, dynamic>))
        .toList();
  }

  Future<User> createUser(User user) async {
    final response = await dio.post('/users', data: user.toJson());
    return User.fromJson(response.data as Map<String, dynamic>);
  }
}

// API Service
final apiServiceProvider = Provider<Dio>((ref) {
  return Dio(BaseOptions(baseUrl: 'https://api.example.com'));
});

// Repository
final userRepositoryProvider = Provider<UserRepository>((ref) {
  final dio = ref.watch(apiServiceProvider);
  return UserRepository(dio);
});

// User Provider
final userProvider = FutureProvider.family<User, int>((ref, userId) async {
  final repository = ref.watch(userRepositoryProvider);
  return await repository.getUser(userId);
});

// Users List Provider
final usersProvider = FutureProvider<List<User>>((ref) async {
  final repository = ref.watch(userRepositoryProvider);
  return await repository.getUsers();
});

// User List Screen
class UserListScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final usersAsync = ref.watch(usersProvider);

    return Scaffold(
      appBar: AppBar(
        title: Text('Users'),
        actions: [
          IconButton(
            icon: Icon(Icons.refresh),
            onPressed: () => ref.invalidate(usersProvider),
          ),
        ],
      ),
      body: usersAsync.when(
        data: (users) => ListView.builder(
          itemCount: users.length,
          itemBuilder: (context, index) {
            return ListTile(
              title: Text(users[index].name),
              onTap: () {
                Navigator.push(
                  context,
                  MaterialPageRoute(
                    builder: (_) => UserScreen(userId: users[index].id),
                  ),
                );
              },
            );
          },
        ),
        loading: () => Center(child: CircularProgressIndicator()),
        error: (error, stack) => ErrorWidget(
          error: error,
          onRetry: () => ref.invalidate(usersProvider),
        ),
      ),
    );
  }
}

// User Detail Screen
class UserScreen extends ConsumerWidget {
  final int userId;

  const UserScreen({Key? key, required this.userId}) : super(key: key);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userProvider(userId));

    return Scaffold(
      appBar: AppBar(title: Text('User')),
      body: userAsync.when(
        data: (user) => UserDetailsWidget(user: user),
        loading: () => Center(child: CircularProgressIndicator()),
        error: (error, stack) => ErrorWidget(
          error: error,
          onRetry: () => ref.invalidate(userProvider(userId)),
        ),
      ),
    );
  }
}

// Test provider
void main() {
  test('userProvider loads user correctly', () async {
    final container = ProviderContainer();
    final user = await container.read(userProvider(1).future);
    expect(user.id, 1);
  });
}