|
|
// ignore_for_file: avoid_catches_without_on_clauses
|
|
|
|
|
|
import 'dart:developer';
|
|
|
|
|
|
import 'package:connectivity_plus/connectivity_plus.dart';
|
|
|
import 'package:dio/dio.dart';
|
|
|
|
|
|
import 'api_response.dart';
|
|
|
import 'http_method.dart';
|
|
|
import 'token_manager.dart';
|
|
|
|
|
|
// ─── Custom exception ──────────────────────────────────────────────────────
|
|
|
|
|
|
/// Thrown **synchronously** when any [ApiClient] call method is invoked before
|
|
|
/// [ApiClient.initialize] has been called.
|
|
|
///
|
|
|
/// This is an exception (not a silent [ApiFailure]) because it represents a
|
|
|
/// **programming error** — the developer forgot to call [ApiClient.initialize]
|
|
|
/// in `main()`. It should crash loudly in development so it is never shipped.
|
|
|
final class ApiClientNotInitializedException implements Exception {
|
|
|
const ApiClientNotInitializedException();
|
|
|
|
|
|
@override
|
|
|
String toString() =>
|
|
|
'ApiClientNotInitializedException: '
|
|
|
'ApiClient.initialize() must be called before making any API calls. '
|
|
|
'Add `ApiClient.initialize(baseUrl: …)` to your main() function.';
|
|
|
}
|
|
|
|
|
|
// ─── ApiClient ─────────────────────────────────────────────────────────────
|
|
|
|
|
|
/// A thin, zero-boilerplate HTTP wrapper around [Dio] for Flutter apps.
|
|
|
///
|
|
|
/// ### Quick start
|
|
|
/// ```dart
|
|
|
/// // 1. Once in main():
|
|
|
/// ApiClient.initialize(baseUrl: 'https://api.example.com');
|
|
|
///
|
|
|
/// // 2. Make a call:
|
|
|
/// final result = await ApiClient.get<User>(
|
|
|
/// url: '/users/me',
|
|
|
/// shouldKeepToken: true,
|
|
|
/// fromJson: (j) => User.fromJson(j as Map<String, dynamic>),
|
|
|
/// );
|
|
|
/// switch (result) {
|
|
|
/// case ApiSuccess(:final data): print(data.name);
|
|
|
/// case ApiFailure(:final message): print('Error: $message');
|
|
|
/// }
|
|
|
///
|
|
|
/// // 3. Cancel all in-flight requests (e.g. from a BLoC's close()):
|
|
|
/// ApiClient.cancel();
|
|
|
/// ```
|
|
|
///
|
|
|
/// ---
|
|
|
/// ### Design decisions
|
|
|
///
|
|
|
/// **Named methods vs. a single `call(HttpMethod, …)`**
|
|
|
/// Separate named methods (`get`, `post`, `put`, `patch`, `delete`) are
|
|
|
/// preferred because:
|
|
|
/// 1. Call sites are instantly readable — `ApiClient.post(url: …)` vs
|
|
|
/// `ApiClient.call(HttpMethod.post, url: …)`.
|
|
|
/// 2. Each method can omit inapplicable parameters (e.g. no `body` on `get`).
|
|
|
/// 3. IDE auto-complete surfaces the right signature without guessing.
|
|
|
/// All named methods delegate to the private [_call] dispatcher so there is
|
|
|
/// zero logic duplication.
|
|
|
///
|
|
|
/// **URL resolution**
|
|
|
/// If [url] already starts with `http://` or `https://`, Dio uses it **as-is**
|
|
|
/// (absolute URL) — the configured [BaseOptions.baseUrl] is _not_ prepended.
|
|
|
/// For relative paths, Dio concatenates `baseUrl + url` automatically.
|
|
|
/// This matches browser / fetch / axios semantics and prevents accidentally
|
|
|
/// double-prepending the base when the caller passes a full URL for a
|
|
|
/// third-party endpoint.
|
|
|
class ApiClient {
|
|
|
ApiClient._();
|
|
|
|
|
|
static Dio? _dio;
|
|
|
static bool _isInitialized = false;
|
|
|
static bool Function(Response<dynamic>)? _globalIsSuccess;
|
|
|
|
|
|
/// Shared cancel token for all in-flight requests.
|
|
|
///
|
|
|
/// After [cancel] is invoked, a fresh [CancelToken] is created immediately
|
|
|
/// so subsequent calls are never pre-cancelled — the client stays usable.
|
|
|
///
|
|
|
/// ### Extension point for per-request cancellation
|
|
|
/// To layer per-request cancellation on in the future, accept an optional
|
|
|
/// `String? requestTag` in every call method and maintain a
|
|
|
/// `static final Map<String, CancelToken> _taggedTokens = {}` registry
|
|
|
/// inside [_call]. No structural rewrite of the existing code is needed.
|
|
|
static CancelToken _cancelToken = CancelToken();
|
|
|
|
|
|
// ── Initialization ────────────────────────────────────────────────────────
|
|
|
|
|
|
/// Configure the global [Dio] instance. **Call exactly once at app startup,
|
|
|
/// before any API call is made.**
|
|
|
///
|
|
|
/// Calling [initialize] again replaces the existing instance (useful in
|
|
|
/// tests that need different base URLs or interceptors).
|
|
|
///
|
|
|
/// Parameters:
|
|
|
/// - [baseUrl] — prepended to every relative URL.
|
|
|
/// - [headers] — merged on top of the default `Content-Type` /
|
|
|
/// `Accept` headers for every request.
|
|
|
/// - [connectTimeout] — how long to wait for a connection; default 30 s.
|
|
|
/// - [receiveTimeout] — how long to wait for a full response; default 30 s.
|
|
|
/// - [isSuccess] — global predicate that decides whether a [Response]
|
|
|
/// is successful. Falls back to HTTP 200–299 when
|
|
|
/// `null`.
|
|
|
/// - [interceptors] — extra [Interceptor]s (logging, auth-refresh, etc.)
|
|
|
/// added to the [Dio] instance.
|
|
|
static void initialize({
|
|
|
required String baseUrl,
|
|
|
Map<String, dynamic>? headers,
|
|
|
Duration connectTimeout = const Duration(seconds: 30),
|
|
|
Duration receiveTimeout = const Duration(seconds: 30),
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
List<Interceptor> interceptors = const [],
|
|
|
}) {
|
|
|
_globalIsSuccess = isSuccess;
|
|
|
_isInitialized = false; // guard against partially-constructed state
|
|
|
|
|
|
_dio = Dio(
|
|
|
BaseOptions(
|
|
|
baseUrl: baseUrl,
|
|
|
connectTimeout: connectTimeout,
|
|
|
receiveTimeout: receiveTimeout,
|
|
|
headers: <String, dynamic>{
|
|
|
'Content-Type': 'application/json',
|
|
|
'Accept': 'application/json',
|
|
|
...?headers,
|
|
|
},
|
|
|
),
|
|
|
);
|
|
|
|
|
|
if (interceptors.isNotEmpty) {
|
|
|
_dio!.interceptors.addAll(interceptors);
|
|
|
}
|
|
|
|
|
|
_isInitialized = true;
|
|
|
}
|
|
|
|
|
|
// ── Cancellation ─────────────────────────────────────────────────────────
|
|
|
|
|
|
/// Cancel **all** currently in-flight requests that were made through
|
|
|
/// [ApiClient].
|
|
|
///
|
|
|
/// A fresh [CancelToken] is created immediately afterward so new requests
|
|
|
/// are never affected — the client remains fully usable after cancellation.
|
|
|
///
|
|
|
/// Cancelled requests resolve as [ApiFailure] with `code: -1` and the
|
|
|
/// provided [reason] as their [ApiFailure.message].
|
|
|
///
|
|
|
/// Typical usage — inside a BLoC's `close()`:
|
|
|
/// ```dart
|
|
|
/// @override
|
|
|
/// Future<void> close() {
|
|
|
/// ApiClient.cancel();
|
|
|
/// return super.close();
|
|
|
/// }
|
|
|
/// ```
|
|
|
static void cancel({String reason = 'Request was cancelled'}) {
|
|
|
_cancelToken.cancel(reason);
|
|
|
// Regenerate immediately so subsequent requests are never pre-cancelled.
|
|
|
_cancelToken = CancelToken();
|
|
|
}
|
|
|
|
|
|
// ── Public call methods ───────────────────────────────────────────────────
|
|
|
|
|
|
/// Perform an HTTP **GET** request.
|
|
|
///
|
|
|
/// - [url] — absolute (`https://…`) or relative path resolved
|
|
|
/// against [baseUrl].
|
|
|
/// - [queryParams] — appended as URL query parameters.
|
|
|
/// - [headers] — per-call headers merged on top of defaults.
|
|
|
/// - [shouldKeepToken] — when `true`, the stored [TokenManager] token is
|
|
|
/// attached as `Authorization: Bearer <token>`, and any
|
|
|
/// `Authorization` header returned in the response is
|
|
|
/// persisted back to [TokenManager].
|
|
|
/// - [isSuccess] — per-call predicate that overrides the global default
|
|
|
/// set in [initialize] for this single call.
|
|
|
/// - [fromJson] — converts the successful response body to [T].
|
|
|
///
|
|
|
/// Returns [ApiSuccess<T>] on success or [ApiFailure<T>] on any error.
|
|
|
/// **Never throws** (except [ApiClientNotInitializedException] if
|
|
|
/// [initialize] was never called — this is a programming error).
|
|
|
static Future<ApiResponse<T>> get<T>({
|
|
|
required String url,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
bool shouldKeepToken = false,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) =>
|
|
|
_call(
|
|
|
method: HttpMethod.get,
|
|
|
url: url,
|
|
|
queryParams: queryParams,
|
|
|
headers: headers,
|
|
|
shouldKeepToken: shouldKeepToken,
|
|
|
isSuccess: isSuccess,
|
|
|
fromJson: fromJson,
|
|
|
);
|
|
|
|
|
|
/// Perform an HTTP **POST** request.
|
|
|
///
|
|
|
/// - [body] — request body; Dio serialises `Map` / `List` to JSON
|
|
|
/// automatically. Pass a [FormData] for multipart uploads.
|
|
|
static Future<ApiResponse<T>> post<T>({
|
|
|
required String url,
|
|
|
dynamic body,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
bool shouldKeepToken = false,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) =>
|
|
|
_call(
|
|
|
method: HttpMethod.post,
|
|
|
url: url,
|
|
|
body: body,
|
|
|
queryParams: queryParams,
|
|
|
headers: headers,
|
|
|
shouldKeepToken: shouldKeepToken,
|
|
|
isSuccess: isSuccess,
|
|
|
fromJson: fromJson,
|
|
|
);
|
|
|
|
|
|
/// Perform an HTTP **PUT** request.
|
|
|
///
|
|
|
/// - [body] — request body (serialised to JSON by Dio).
|
|
|
static Future<ApiResponse<T>> put<T>({
|
|
|
required String url,
|
|
|
dynamic body,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
bool shouldKeepToken = false,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) =>
|
|
|
_call(
|
|
|
method: HttpMethod.put,
|
|
|
url: url,
|
|
|
body: body,
|
|
|
queryParams: queryParams,
|
|
|
headers: headers,
|
|
|
shouldKeepToken: shouldKeepToken,
|
|
|
isSuccess: isSuccess,
|
|
|
fromJson: fromJson,
|
|
|
);
|
|
|
|
|
|
/// Perform an HTTP **PATCH** request.
|
|
|
///
|
|
|
/// - [body] — request body (serialised to JSON by Dio).
|
|
|
static Future<ApiResponse<T>> patch<T>({
|
|
|
required String url,
|
|
|
dynamic body,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
bool shouldKeepToken = false,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) =>
|
|
|
_call(
|
|
|
method: HttpMethod.patch,
|
|
|
url: url,
|
|
|
body: body,
|
|
|
queryParams: queryParams,
|
|
|
headers: headers,
|
|
|
shouldKeepToken: shouldKeepToken,
|
|
|
isSuccess: isSuccess,
|
|
|
fromJson: fromJson,
|
|
|
);
|
|
|
|
|
|
/// Perform an HTTP **DELETE** request.
|
|
|
///
|
|
|
/// - [body] — optional request body (serialised to JSON by Dio).
|
|
|
static Future<ApiResponse<T>> delete<T>({
|
|
|
required String url,
|
|
|
dynamic body,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
bool shouldKeepToken = false,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) =>
|
|
|
_call(
|
|
|
method: HttpMethod.delete,
|
|
|
url: url,
|
|
|
body: body,
|
|
|
queryParams: queryParams,
|
|
|
headers: headers,
|
|
|
shouldKeepToken: shouldKeepToken,
|
|
|
isSuccess: isSuccess,
|
|
|
fromJson: fromJson,
|
|
|
);
|
|
|
|
|
|
// ── Core dispatcher ───────────────────────────────────────────────────────
|
|
|
|
|
|
/// Unified internal dispatcher — every public method delegates here.
|
|
|
///
|
|
|
/// Execution pipeline (in order):
|
|
|
/// 1. **Guard** — throw [ApiClientNotInitializedException] if [initialize]
|
|
|
/// was never called.
|
|
|
/// 2. **Connectivity** — return [ApiFailure] immediately if offline.
|
|
|
/// 3. **Token injection** — if [shouldKeepToken] is `true` and
|
|
|
/// [TokenManager.hasToken], add `Authorization: Bearer …` to headers.
|
|
|
/// 4. **Execute** — fire the Dio call with the shared [_cancelToken].
|
|
|
/// 5. **Token extraction** — if [shouldKeepToken] is `true` and the response
|
|
|
/// contains an `Authorization` header, persist the new token.
|
|
|
/// 6. **Success predicate** — per-call → global → HTTP 200–299 fallback.
|
|
|
/// 7. **Parse** — call [fromJson] → wrap in [ApiSuccess].
|
|
|
/// 8. **Error mapping** — catch [DioException] and any other exception and
|
|
|
/// return an appropriate [ApiFailure].
|
|
|
static Future<ApiResponse<T>> _call<T>({
|
|
|
required HttpMethod method,
|
|
|
required String url,
|
|
|
dynamic body,
|
|
|
Map<String, dynamic>? queryParams,
|
|
|
Map<String, dynamic>? headers,
|
|
|
required bool shouldKeepToken,
|
|
|
bool Function(Response<dynamic>)? isSuccess,
|
|
|
required T Function(dynamic json) fromJson,
|
|
|
}) async {
|
|
|
// ── 1. Guard ─────────────────────────────────────────────────────────────
|
|
|
if (!_isInitialized || _dio == null) {
|
|
|
throw const ApiClientNotInitializedException();
|
|
|
}
|
|
|
|
|
|
// ── 2. Connectivity check ────────────────────────────────────────────────
|
|
|
// We wrap this in its own try/catch: if the connectivity plugin itself
|
|
|
// throws (e.g. on simulator/unknown platform), we proceed and let the
|
|
|
// actual network error surface naturally rather than blocking the call.
|
|
|
try {
|
|
|
final results = await Connectivity().checkConnectivity();
|
|
|
final isOffline = results.isEmpty ||
|
|
|
results.every((r) => r == ConnectivityResult.none);
|
|
|
if (isOffline) {
|
|
|
return ApiFailure<T>(
|
|
|
message:
|
|
|
'No internet connection. Please check your network settings.',
|
|
|
);
|
|
|
}
|
|
|
} catch (_) {
|
|
|
// Connectivity check failed — proceed optimistically.
|
|
|
}
|
|
|
|
|
|
// ── 3. Build headers + optional Bearer token ─────────────────────────────
|
|
|
final mergedHeaders = <String, dynamic>{...?headers};
|
|
|
if (shouldKeepToken && TokenManager.hasToken) {
|
|
|
mergedHeaders['Authorization'] = 'Bearer ${TokenManager.getToken()}';
|
|
|
}
|
|
|
|
|
|
final options = Options(
|
|
|
headers: mergedHeaders.isNotEmpty ? mergedHeaders : null,
|
|
|
);
|
|
|
|
|
|
// ── 4. Execute Dio call ──────────────────────────────────────────────────
|
|
|
try {
|
|
|
late final Response<dynamic> response;
|
|
|
|
|
|
switch (method) {
|
|
|
case HttpMethod.get:
|
|
|
response = await _dio!.get(
|
|
|
url,
|
|
|
queryParameters: queryParams,
|
|
|
options: options,
|
|
|
cancelToken: _cancelToken,
|
|
|
);
|
|
|
case HttpMethod.post:
|
|
|
response = await _dio!.post(
|
|
|
url,
|
|
|
data: body,
|
|
|
queryParameters: queryParams,
|
|
|
options: options,
|
|
|
cancelToken: _cancelToken,
|
|
|
);
|
|
|
case HttpMethod.put:
|
|
|
response = await _dio!.put(
|
|
|
url,
|
|
|
data: body,
|
|
|
queryParameters: queryParams,
|
|
|
options: options,
|
|
|
cancelToken: _cancelToken,
|
|
|
);
|
|
|
case HttpMethod.patch:
|
|
|
response = await _dio!.patch(
|
|
|
url,
|
|
|
data: body,
|
|
|
queryParameters: queryParams,
|
|
|
options: options,
|
|
|
cancelToken: _cancelToken,
|
|
|
);
|
|
|
case HttpMethod.delete:
|
|
|
response = await _dio!.delete(
|
|
|
url,
|
|
|
data: body,
|
|
|
queryParameters: queryParams,
|
|
|
options: options,
|
|
|
cancelToken: _cancelToken,
|
|
|
);
|
|
|
}
|
|
|
log("+++++++++++++++++++++++++++");
|
|
|
|
|
|
log("$body");
|
|
|
log("+++++++++++++++++++++++++++");
|
|
|
|
|
|
log("$response");
|
|
|
log("+++++++++++++++++++++++++++");
|
|
|
|
|
|
// ── 5. Token extraction from response ───────────────────────────────
|
|
|
if (shouldKeepToken) {
|
|
|
// Dio lowercases header names so check both casings for safety.
|
|
|
final raw = response.headers.value('authorization') ??
|
|
|
response.headers.value('Authorization');
|
|
|
if (raw != null && raw.isNotEmpty) {
|
|
|
final token =
|
|
|
raw.startsWith('Bearer ') ? raw.substring(7) : raw;
|
|
|
TokenManager.setToken(token);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// ── 6. Success predicate ────────────────────────────────────────────
|
|
|
// Priority order: per-call → global → HTTP 200–299 fallback.
|
|
|
final succeeded = isSuccess != null
|
|
|
? isSuccess(response)
|
|
|
: _globalIsSuccess != null
|
|
|
? _globalIsSuccess!(response)
|
|
|
: (response.statusCode != null &&
|
|
|
response.statusCode! >= 200 &&
|
|
|
response.statusCode! < 300);
|
|
|
|
|
|
if (!succeeded) {
|
|
|
return ApiFailure<T>(
|
|
|
code: response.statusCode,
|
|
|
message: _extractErrorMessage(response.data) ??
|
|
|
'Request failed with status ${response.statusCode}',
|
|
|
);
|
|
|
}
|
|
|
|
|
|
// ── 7. Parse ────────────────────────────────────────────────────────
|
|
|
try {
|
|
|
return ApiSuccess<T>(fromJson(response.data));
|
|
|
} catch (e) {
|
|
|
return ApiFailure<T>(
|
|
|
code: response.statusCode,
|
|
|
message: 'Response parsing failed: $e',
|
|
|
);
|
|
|
}
|
|
|
} on DioException catch (e) {
|
|
|
return _mapDioException<T>(e);
|
|
|
} catch (e) {
|
|
|
return ApiFailure<T>(message: 'Unexpected error: $e');
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// ── Helpers ───────────────────────────────────────────────────────────────
|
|
|
|
|
|
/// Map a [DioException] to the most descriptive [ApiFailure] available.
|
|
|
///
|
|
|
/// Cancellations are identified by `code: -1` so callers can distinguish
|
|
|
/// them from real HTTP failures without string-matching on [ApiFailure.message].
|
|
|
static ApiFailure<T> _mapDioException<T>(DioException e) {
|
|
|
// Cancelled request — distinct code so BLoCs can decide not to show
|
|
|
// an error dialog when the user navigated away.
|
|
|
if (e.type == DioExceptionType.cancel) {
|
|
|
return ApiFailure<T>(
|
|
|
code: -1,
|
|
|
message: e.message ?? 'Request was cancelled',
|
|
|
);
|
|
|
}
|
|
|
|
|
|
final code = e.response?.statusCode;
|
|
|
|
|
|
switch (e.type) {
|
|
|
case DioExceptionType.connectionTimeout:
|
|
|
case DioExceptionType.sendTimeout:
|
|
|
case DioExceptionType.receiveTimeout:
|
|
|
return ApiFailure<T>(
|
|
|
code: code,
|
|
|
message: 'Connection timed out. Please try again.',
|
|
|
);
|
|
|
|
|
|
case DioExceptionType.connectionError:
|
|
|
return ApiFailure<T>(
|
|
|
code: code,
|
|
|
message: 'Unable to reach the server. Check your connection.',
|
|
|
);
|
|
|
|
|
|
default:
|
|
|
// Try to pull a message out of the error response body first.
|
|
|
final serverMsg =
|
|
|
e.response != null ? _extractErrorMessage(e.response!.data) : null;
|
|
|
return ApiFailure<T>(
|
|
|
code: code,
|
|
|
message: serverMsg ?? e.message ?? 'An unknown error occurred.',
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Attempt to pull a human-readable error string from a response body.
|
|
|
///
|
|
|
/// Handles the three most common API error patterns:
|
|
|
/// ```json
|
|
|
/// { "message": "…" }
|
|
|
/// { "error": "…" }
|
|
|
/// { "error": { "message": "…" } }
|
|
|
/// ```
|
|
|
static String? _extractErrorMessage(dynamic data) {
|
|
|
if (data is! Map<String, dynamic>) return null;
|
|
|
if (data['message'] is String) return data['message'] as String;
|
|
|
if (data['error'] is String) return data['error'] as String;
|
|
|
if (data['error'] is Map) {
|
|
|
final inner = data['error'] as Map;
|
|
|
if (inner['message'] is String) return inner['message'] as String;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// ─── Usage example ─────────────────────────────────────────────────────────
|
|
|
//
|
|
|
// ┌── main.dart ─────────────────────────────────────────────────────────────┐
|
|
|
// │ │
|
|
|
// │ import 'package:your_app/core/network/api_client.dart'; │
|
|
|
// │ import 'package:dio/dio.dart'; │
|
|
|
// │ import 'package:flutter/material.dart'; │
|
|
|
// │ │
|
|
|
// │ void main() { │
|
|
|
// │ // ① Configure once before runApp(). │
|
|
|
// │ ApiClient.initialize( │
|
|
|
// │ baseUrl: 'https://api.example.com', │
|
|
|
// │ connectTimeout: const Duration(seconds: 15), │
|
|
|
// │ receiveTimeout: const Duration(seconds: 15), │
|
|
|
// │ headers: {'X-App-Version': '1.0.0'}, │
|
|
|
// │ // Global rule: treat only status 200 as success. │
|
|
|
// │ isSuccess: (response) => response.statusCode == 200, │
|
|
|
// │ interceptors: [LogInterceptor(requestBody: true)], │
|
|
|
// │ ); │
|
|
|
// │ runApp(const MyApp()); │
|
|
|
// │ } │
|
|
|
// └──────────────────────────────────────────────────────────────────────────┘
|
|
|
//
|
|
|
// ┌── GET with custom isSuccess predicate + shouldKeepToken ─────────────────┐
|
|
|
// │ │
|
|
|
// │ Future<void> fetchProfile() async { │
|
|
|
// │ final result = await ApiClient.get<User>( │
|
|
|
// │ url: '/users/me', // relative → Dio prepends baseUrl │
|
|
|
// │ shouldKeepToken: true, // adds Authorization: Bearer <token> │
|
|
|
// │ // Per-call override: accept both 200 and 201 for this endpoint. │
|
|
|
// │ isSuccess: (r) => r.statusCode == 200 || r.statusCode == 201, │
|
|
|
// │ fromJson: (j) => User.fromJson(j as Map<String, dynamic>), │
|
|
|
// │ ); │
|
|
|
// │ │
|
|
|
// │ switch (result) { │
|
|
|
// │ case ApiSuccess(:final data): │
|
|
|
// │ print('Welcome, ${data.name}'); │
|
|
|
// │ case ApiFailure(:final code, :final message): │
|
|
|
// │ print('Error $code: $message'); │
|
|
|
// │ } │
|
|
|
// │ } │
|
|
|
// └──────────────────────────────────────────────────────────────────────────┘
|
|
|
//
|
|
|
// ┌── Cancel all in-flight requests (e.g. from a BLoC's close()) ────────────┐
|
|
|
// │ │
|
|
|
// │ @override │
|
|
|
// │ Future<void> close() { │
|
|
|
// │ ApiClient.cancel(); // safe — client stays usable for new calls │
|
|
|
// │ return super.close(); │
|
|
|
// │ } │
|
|
|
// └──────────────────────────────────────────────────────────────────────────┘
|