_respondHtml(HttpResponse res, String html) async {
+ try {
+ res
+ ..statusCode = HttpStatus.ok
+ ..headers.contentType = ContentType.html
+ ..write(html);
+ await res.close();
+ } catch (e) {
+ appLogger.d('LoopbackAuthServer: response write failed', error: e);
+ }
+ }
+
+ /// One page for all three flows. Code-grant and polling flows (MAL, Simkl)
+ /// render it as a plain success page. Implicit-grant flows (AniList) put
+ /// the access token in the URL fragment — the inline script in ``
+ /// rewrites that into a query string and redirects before the body paints,
+ /// so users never see a success page flash before the real capture.
+ static const String _pageHtml = ''
+ ''
+ ''
+ 'Signed in'
+ ''
+ ''
+ ''
+ ''
+ 'Signed in to Plezy
'
+ 'You can close this tab and return to the app.
'
+ '';
+}
+
+class LoopbackBindException implements Exception {
+ final String message;
+ const LoopbackBindException(this.message);
+ @override
+ String toString() => 'LoopbackBindException: $message';
+}
diff --git a/lib/services/trackers/mal/mal_account_store.dart b/lib/services/trackers/mal/mal_account_store.dart
new file mode 100644
index 00000000..4d409cfc
--- /dev/null
+++ b/lib/services/trackers/mal/mal_account_store.dart
@@ -0,0 +1,8 @@
+import '../tracker_account_store.dart';
+import 'mal_session.dart';
+
+final TrackerAccountStore malAccountStore = TrackerAccountStore(
+ baseKey: 'mal_session',
+ decode: MalSession.decode,
+ encode: (s) => s.encode(),
+);
diff --git a/lib/services/trackers/mal/mal_auth_service.dart b/lib/services/trackers/mal/mal_auth_service.dart
new file mode 100644
index 00000000..04223ae4
--- /dev/null
+++ b/lib/services/trackers/mal/mal_auth_service.dart
@@ -0,0 +1,111 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:math';
+
+import 'package:http/http.dart' as http;
+
+import '../../../utils/app_logger.dart';
+import '../../../utils/platform_http_client_stub.dart'
+ if (dart.library.io) '../../../utils/platform_http_client_io.dart'
+ as platform;
+import '../loopback_auth_server.dart';
+import 'mal_constants.dart';
+import 'mal_session.dart';
+
+/// MyAnimeList OAuth 2.0 PKCE flow via RFC 8252 loopback redirect.
+///
+/// **Quirk**: MAL requires `code_challenge_method=plain` — it rejects `S256`
+/// despite RFC 7636.
+class MalAuthService {
+ static const String _callbackPath = '/mal-oauth';
+
+ final http.Client _http;
+
+ MalAuthService({http.Client? httpClient}) : _http = httpClient ?? platform.createPlatformClient();
+
+ void dispose() => _http.close();
+
+ /// Drive the full flow: build the authorize URL, start a loopback server
+ /// for the redirect, launch the browser, exchange the code for tokens.
+ /// Returns `null` if the user closes the browser before completing.
+ Future authorize() async {
+ final verifier = _randomVerifier();
+ final state = _randomVerifier(length: 16);
+ final redirectUri = LoopbackAuthServer.redirectUri(_callbackPath);
+
+ final authorizeUri = Uri.parse(MalConstants.authorizeUrl).replace(
+ queryParameters: {
+ 'response_type': 'code',
+ 'client_id': MalConstants.clientId,
+ 'code_challenge': verifier, // plain method → challenge == verifier
+ 'code_challenge_method': 'plain',
+ 'redirect_uri': redirectUri,
+ 'state': state,
+ },
+ );
+
+ final callback = await LoopbackAuthServer.launchAndWait(authorizeUri, path: _callbackPath);
+ if (callback == null) return null;
+
+ final code = callback.queryParameters['code'];
+ final returnedState = callback.queryParameters['state'];
+ if (code == null) {
+ throw MalAuthFlowException('MAL redirect missing code: $callback');
+ }
+ if (returnedState != state) {
+ throw const MalAuthFlowException('MAL state mismatch (possible CSRF)');
+ }
+
+ final res = await _http
+ .post(
+ Uri.parse(MalConstants.tokenUrl),
+ body: {
+ 'client_id': MalConstants.clientId,
+ 'code': code,
+ 'code_verifier': verifier,
+ 'grant_type': 'authorization_code',
+ 'redirect_uri': redirectUri,
+ },
+ )
+ .timeout(const Duration(seconds: 20));
+
+ if (res.statusCode != 200) {
+ throw MalAuthFlowException('Token exchange failed: HTTP ${res.statusCode}: ${res.body}');
+ }
+ return MalSession.fromTokenResponse(json.decode(res.body) as Map);
+ }
+
+ Future refresh(MalSession current) async {
+ final res = await _http
+ .post(
+ Uri.parse(MalConstants.tokenUrl),
+ body: {
+ 'client_id': MalConstants.clientId,
+ 'grant_type': 'refresh_token',
+ 'refresh_token': current.refreshToken,
+ },
+ )
+ .timeout(const Duration(seconds: 20));
+
+ if (res.statusCode != 200) {
+ appLogger.w('MAL: refresh failed (${res.statusCode}): ${res.body}');
+ throw MalAuthFlowException('Refresh failed: HTTP ${res.statusCode}');
+ }
+ final fresh = MalSession.fromTokenResponse(json.decode(res.body) as Map);
+ return fresh.copyWith(username: current.username);
+ }
+
+ /// MAL requires 43–128 chars from the unreserved URL-safe set.
+ String _randomVerifier({int length = 64}) {
+ const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
+ final rand = Random.secure();
+ return List.generate(length, (_) => alphabet[rand.nextInt(alphabet.length)]).join();
+ }
+}
+
+class MalAuthFlowException implements Exception {
+ final String message;
+ const MalAuthFlowException(this.message);
+ @override
+ String toString() => 'MalAuthFlowException: $message';
+}
diff --git a/lib/services/trackers/mal/mal_client.dart b/lib/services/trackers/mal/mal_client.dart
new file mode 100644
index 00000000..efa96ab1
--- /dev/null
+++ b/lib/services/trackers/mal/mal_client.dart
@@ -0,0 +1,157 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+import '../../../utils/app_logger.dart';
+import '../../../utils/platform_http_client_stub.dart'
+ if (dart.library.io) '../../../utils/platform_http_client_io.dart'
+ as platform;
+import 'mal_auth_service.dart';
+import 'mal_constants.dart';
+import 'mal_session.dart';
+
+/// HTTP wrapper for the MAL REST API.
+///
+/// Refreshes the access token 5 minutes before expiry or on 401. Concurrent
+/// 401s are coalesced via [_refreshLock] (same pattern as `TraktClient`).
+class MalClient {
+ static const Duration _requestTimeout = Duration(seconds: 20);
+
+ MalSession _session;
+ final http.Client _http;
+ final MalAuthService _auth;
+ final void Function() onSessionInvalidated;
+ final void Function(MalSession)? onSessionUpdated;
+
+ Future? _refreshLock;
+
+ MalClient(
+ MalSession session, {
+ required this.onSessionInvalidated,
+ this.onSessionUpdated,
+ http.Client? httpClient,
+ MalAuthService? authService,
+ }) : _session = session,
+ _http = httpClient ?? platform.createPlatformClient(),
+ _auth = authService ?? MalAuthService();
+
+ MalSession get session => _session;
+
+ void dispose() {
+ _http.close();
+ _auth.dispose();
+ }
+
+ /// Fetch basic user info to get the display name.
+ Future?> getMyUser() async {
+ final res = await _request('GET', '/users/@me');
+ return res is Map ? res.cast() : null;
+ }
+
+ /// Update the user's list entry for an anime. Body shape:
+ /// ```
+ /// {"status": "watching", "num_watched_episodes": 5}
+ /// ```
+ Future updateMyListStatus(int animeId, Map fields) async {
+ // MAL's list-status endpoint is form-encoded (not JSON).
+ await _request('PATCH', '/anime/$animeId/my_list_status', formBody: fields);
+ }
+
+ Future _refresh() {
+ final existing = _refreshLock;
+ if (existing != null) return existing;
+ final lock = _doRefresh();
+ _refreshLock = lock;
+ return lock.whenComplete(() => _refreshLock = null);
+ }
+
+ Future _doRefresh() async {
+ try {
+ final fresh = await _auth.refresh(_session);
+ _session = fresh;
+ onSessionUpdated?.call(fresh);
+ return fresh;
+ } catch (e) {
+ appLogger.w('MAL: refresh failed', error: e);
+ onSessionInvalidated();
+ rethrow;
+ }
+ }
+
+ Future _request(
+ String method,
+ String path, {
+ Map? body,
+ Map? formBody,
+ }) async {
+ if (_session.needsRefresh) {
+ try {
+ await _refresh();
+ } catch (_) {
+ // Fall through; the request will hit 401 naturally and re-try.
+ }
+ }
+
+ var res = await _send(method, path, body: body, formBody: formBody);
+
+ if (res.statusCode == 401) {
+ try {
+ await _refresh();
+ } catch (_) {
+ throw MalApiException(statusCode: 401, body: res.body);
+ }
+ res = await _send(method, path, body: body, formBody: formBody);
+ }
+
+ if (res.statusCode >= 200 && res.statusCode < 300) {
+ if (res.body.isEmpty) return null;
+ try {
+ return json.decode(res.body);
+ } catch (_) {
+ return null;
+ }
+ }
+ throw MalApiException(statusCode: res.statusCode, body: res.body);
+ }
+
+ Future _send(
+ String method,
+ String path, {
+ Map? body,
+ Map? formBody,
+ }) async {
+ final uri = Uri.parse('${MalConstants.apiBase}$path');
+ final headers = MalConstants.headers(accessToken: _session.accessToken);
+
+ String? encoded;
+ if (formBody != null) {
+ headers['Content-Type'] = 'application/x-www-form-urlencoded';
+ encoded = formBody.entries.map((e) => '${Uri.encodeQueryComponent(e.key)}=${Uri.encodeQueryComponent(e.value)}').join('&');
+ } else if (body != null) {
+ headers['Content-Type'] = 'application/json';
+ encoded = json.encode(body);
+ }
+
+ final sw = Stopwatch()..start();
+ final res = await switch (method) {
+ 'GET' => _http.get(uri, headers: headers),
+ 'POST' => _http.post(uri, headers: headers, body: encoded),
+ 'PATCH' => _http.patch(uri, headers: headers, body: encoded),
+ 'PUT' => _http.put(uri, headers: headers, body: encoded),
+ 'DELETE' => _http.delete(uri, headers: headers),
+ _ => throw ArgumentError('Unsupported HTTP method: $method'),
+ }.timeout(_requestTimeout);
+ sw.stop();
+ appLogger.d('MAL $method ${uri.path} → ${res.statusCode} (${sw.elapsedMilliseconds}ms)');
+ return res;
+ }
+}
+
+class MalApiException implements Exception {
+ final int statusCode;
+ final String body;
+ const MalApiException({required this.statusCode, required this.body});
+ @override
+ String toString() => 'MalApiException(HTTP $statusCode): $body';
+}
diff --git a/lib/services/trackers/mal/mal_constants.dart b/lib/services/trackers/mal/mal_constants.dart
new file mode 100644
index 00000000..19d5df61
--- /dev/null
+++ b/lib/services/trackers/mal/mal_constants.dart
@@ -0,0 +1,24 @@
+/// Bundled MyAnimeList API credentials and endpoints.
+///
+/// Register at https://myanimelist.net/apiconfig — "App type: Other", redirect
+/// URI `http://127.0.0.1:53682/mal-oauth` (RFC 8252 loopback). PKCE-only
+/// (no client secret).
+///
+/// **MAL quirk**: `code_challenge_method` must be `plain` — MAL rejects `S256`
+/// despite RFC 7636. See [MalAuthService.authorize].
+class MalConstants {
+ MalConstants._();
+
+ static const String clientId = '463b1c92992505e4bdfcef6aab3aedbe';
+
+ static const String apiBase = 'https://api.myanimelist.net/v2';
+ static const String oauthBase = 'https://myanimelist.net/v1/oauth2';
+
+ static const String authorizeUrl = '$oauthBase/authorize';
+ static const String tokenUrl = '$oauthBase/token';
+
+ static Map headers({String? accessToken}) => {
+ 'Accept': 'application/json',
+ if (accessToken != null) 'Authorization': 'Bearer $accessToken',
+ };
+}
diff --git a/lib/services/trackers/mal/mal_session.dart b/lib/services/trackers/mal/mal_session.dart
new file mode 100644
index 00000000..d32f98b0
--- /dev/null
+++ b/lib/services/trackers/mal/mal_session.dart
@@ -0,0 +1,65 @@
+import 'dart:convert';
+
+/// Immutable MyAnimeList OAuth session.
+///
+/// Access tokens expire in ~31 days. Refresh token rotates with each refresh
+/// (rare but documented in MAL's API contract).
+class MalSession {
+ final String accessToken;
+ final String refreshToken;
+ final int expiresAt;
+ final String? username;
+ final int createdAt;
+
+ const MalSession({
+ required this.accessToken,
+ required this.refreshToken,
+ required this.expiresAt,
+ required this.createdAt,
+ this.username,
+ });
+
+ bool get isExpired => DateTime.now().millisecondsSinceEpoch ~/ 1000 >= expiresAt;
+ bool get needsRefresh => DateTime.now().millisecondsSinceEpoch ~/ 1000 >= expiresAt - 300;
+
+ MalSession copyWith({String? accessToken, String? refreshToken, int? expiresAt, String? username, int? createdAt}) {
+ return MalSession(
+ accessToken: accessToken ?? this.accessToken,
+ refreshToken: refreshToken ?? this.refreshToken,
+ expiresAt: expiresAt ?? this.expiresAt,
+ username: username ?? this.username,
+ createdAt: createdAt ?? this.createdAt,
+ );
+ }
+
+ Map toJson() => {
+ 'access_token': accessToken,
+ 'refresh_token': refreshToken,
+ 'expires_at': expiresAt,
+ 'username': username,
+ 'created_at': createdAt,
+ };
+
+ factory MalSession.fromJson(Map json) => MalSession(
+ accessToken: json['access_token'] as String,
+ refreshToken: json['refresh_token'] as String,
+ expiresAt: (json['expires_at'] as num).toInt(),
+ username: json['username'] as String?,
+ createdAt: (json['created_at'] as num).toInt(),
+ );
+
+ /// Build a session from MAL's `/oauth2/token` response.
+ factory MalSession.fromTokenResponse(Map json) {
+ final createdAt = DateTime.now().millisecondsSinceEpoch ~/ 1000;
+ final expiresIn = (json['expires_in'] as num).toInt();
+ return MalSession(
+ accessToken: json['access_token'] as String,
+ refreshToken: json['refresh_token'] as String,
+ expiresAt: createdAt + expiresIn,
+ createdAt: createdAt,
+ );
+ }
+
+ String encode() => json.encode(toJson());
+ static MalSession decode(String raw) => MalSession.fromJson(json.decode(raw) as Map);
+}
diff --git a/lib/services/trackers/mal/mal_tracker.dart b/lib/services/trackers/mal/mal_tracker.dart
new file mode 100644
index 00000000..b8cf39c5
--- /dev/null
+++ b/lib/services/trackers/mal/mal_tracker.dart
@@ -0,0 +1,60 @@
+import '../../../models/trackers/tracker_context.dart';
+import '../../../utils/app_logger.dart';
+import '../../settings_service.dart';
+import '../tracker.dart';
+import 'mal_client.dart';
+import 'mal_session.dart';
+
+/// MyAnimeList scrobble tracker. Marks `num_watched_episodes` on the user's
+/// list entry once playback crosses the watched threshold.
+///
+/// MAL is anime-only: no-op when [TrackerContext.anime] is null.
+///
+/// For split-cour shows Fribb maps each cour to a distinct MAL ID; the
+/// episode number sent here is the Plex episode index within the current
+/// season, which is usually what MAL expects for the mapped entry. Episode
+/// offsets for irregular cuts aren't in the mini mapping — known v1 gap.
+class MalTracker extends TrackerBase {
+ static MalTracker? _instance;
+ static MalTracker get instance => _instance ??= MalTracker._();
+ MalTracker._();
+
+ @override
+ String get name => 'mal';
+
+ @override
+ bool get needsFribb => true;
+
+ MalClient? _client;
+
+ @override
+ bool get hasActiveClient => _client != null;
+
+ @override
+ bool readEnabledSetting(SettingsService settings) => settings.getEnableMalScrobble();
+
+ void rebindSession(
+ MalSession? session, {
+ required void Function() onSessionInvalidated,
+ void Function(MalSession)? onSessionUpdated,
+ }) {
+ _client?.dispose();
+ _client = session == null
+ ? null
+ : MalClient(session, onSessionInvalidated: onSessionInvalidated, onSessionUpdated: onSessionUpdated);
+ }
+
+ @override
+ Future markWatched(TrackerContext ctx) async {
+ final client = _client;
+ final malId = ctx.anime?.mal;
+ if (client == null || malId == null) return;
+
+ final fields = ctx.isMovie
+ ? {'status': 'completed', 'num_watched_episodes': '1'}
+ : {'status': 'watching', 'num_watched_episodes': '${ctx.episodeNumber}'};
+
+ await client.updateMyListStatus(malId, fields);
+ appLogger.d('MAL: updated list status (mal=$malId, fields=$fields)');
+ }
+}
diff --git a/lib/services/trackers/simkl/simkl_account_store.dart b/lib/services/trackers/simkl/simkl_account_store.dart
new file mode 100644
index 00000000..4fd1f8cb
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_account_store.dart
@@ -0,0 +1,8 @@
+import '../tracker_account_store.dart';
+import 'simkl_session.dart';
+
+final TrackerAccountStore simklAccountStore = TrackerAccountStore(
+ baseKey: 'simkl_session',
+ decode: SimklSession.decode,
+ encode: (s) => s.encode(),
+);
diff --git a/lib/services/trackers/simkl/simkl_auth_service.dart b/lib/services/trackers/simkl/simkl_auth_service.dart
new file mode 100644
index 00000000..ca7fa7fe
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_auth_service.dart
@@ -0,0 +1,101 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+import '../../../models/trackers/device_code.dart';
+import '../../../utils/app_logger.dart';
+import '../../../utils/platform_http_client_stub.dart'
+ if (dart.library.io) '../../../utils/platform_http_client_io.dart'
+ as platform;
+import '../device_code_poller.dart' as poller;
+import '../loopback_auth_server.dart';
+import 'simkl_constants.dart';
+
+/// Simkl OAuth PIN (device-code) flow.
+///
+/// `GET /oauth/pin?client_id=...&redirect=http://127.0.0.1:53682/simkl-oauth`
+/// returns a PIN the user enters at https://simkl.com/pin. After entry Simkl
+/// redirects the browser to our loopback callback (where we show a friendly
+/// "close this tab" page). The app polls `/oauth/pin/?client_id=...`
+/// until `result == "OK"`.
+class SimklAuthService {
+ /// Redirect path Simkl bounces the browser to after PIN entry. Must match
+ /// the URL registered at simkl.com/settings/developer for this client.
+ static const String _callbackPath = '/simkl-oauth';
+
+ final http.Client _http;
+
+ SimklAuthService({http.Client? httpClient}) : _http = httpClient ?? platform.createPlatformClient();
+
+ void dispose() => _http.close();
+
+ Future createDeviceCode() async {
+ final uri = Uri.parse(SimklConstants.pinUrl).replace(
+ queryParameters: {
+ 'client_id': SimklConstants.clientId,
+ 'redirect': LoopbackAuthServer.redirectUri(_callbackPath),
+ },
+ );
+ final res = await _http.get(uri, headers: SimklConstants.headers()).timeout(const Duration(seconds: 15));
+ if (res.statusCode != 200) {
+ throw SimklAuthFlowException('PIN request failed: HTTP ${res.statusCode}: ${res.body}');
+ }
+ final body = json.decode(res.body) as Map;
+ final expiresIn = (body['expires_in'] as num?)?.toInt() ?? 900;
+
+ // Serve the "close this tab" success page when Simkl redirects the
+ // browser back after PIN entry. Fire-and-forget — the PIN poll captures
+ // the token; this listener is purely cosmetic.
+ unawaited(
+ LoopbackAuthServer.listenOnce(
+ path: _callbackPath,
+ timeout: Duration(seconds: expiresIn),
+ ).catchError((Object _) => Uri()),
+ );
+
+ return DeviceCode(
+ deviceCode: body['device_code'] as String,
+ userCode: body['user_code'] as String,
+ verificationUrl: body['verification_url'] as String? ?? SimklConstants.verificationUrl,
+ // Simkl doesn't expose a prefilled URL; the user manually enters the code.
+ verificationUrlComplete: null,
+ expiresIn: expiresIn,
+ interval: (body['interval'] as num?)?.toInt() ?? 5,
+ );
+ }
+
+ Stream pollDeviceCode(DeviceCode code, {bool Function()? shouldCancel}) {
+ return poller.pollDeviceCode(code, shouldCancel: shouldCancel, probe: () => _probe(code));
+ }
+
+ Future _probe(DeviceCode code) async {
+ final pollUri = Uri.parse(
+ SimklConstants.pinPollUrl(code.userCode),
+ ).replace(queryParameters: {'client_id': SimklConstants.clientId});
+ final http.Response res;
+ try {
+ res = await _http.get(pollUri, headers: SimklConstants.headers()).timeout(const Duration(seconds: 15));
+ } catch (e) {
+ appLogger.d('Simkl device-code poll error (transient)', error: e);
+ return const DevicePollPending();
+ }
+
+ // Simkl returns 200 for both pending and success; anything else is
+ // effectively expired/denied.
+ if (res.statusCode != 200) return const DevicePollExpired();
+
+ final body = json.decode(res.body) as Map;
+ if (body['result'] == 'OK' && body['access_token'] != null) {
+ return DevicePollSuccess(body);
+ }
+ return const DevicePollPending();
+ }
+}
+
+class SimklAuthFlowException implements Exception {
+ final String message;
+ const SimklAuthFlowException(this.message);
+ @override
+ String toString() => 'SimklAuthFlowException: $message';
+}
diff --git a/lib/services/trackers/simkl/simkl_client.dart b/lib/services/trackers/simkl/simkl_client.dart
new file mode 100644
index 00000000..157787ce
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_client.dart
@@ -0,0 +1,85 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+import '../../../utils/app_logger.dart';
+import '../../../utils/platform_http_client_stub.dart'
+ if (dart.library.io) '../../../utils/platform_http_client_io.dart'
+ as platform;
+import 'simkl_constants.dart';
+import 'simkl_session.dart';
+
+/// HTTP wrapper for the Simkl REST API.
+///
+/// Simkl tokens don't expire; a 401 is terminal (user revoked access at
+/// simkl.com/settings/apps). [onSessionInvalidated] clears the local session
+/// in that case.
+class SimklClient {
+ static const Duration _requestTimeout = Duration(seconds: 20);
+
+ final SimklSession session;
+ final http.Client _http;
+ final void Function() onSessionInvalidated;
+
+ SimklClient(this.session, {required this.onSessionInvalidated, http.Client? httpClient})
+ : _http = httpClient ?? platform.createPlatformClient();
+
+ void dispose() => _http.close();
+
+ /// Fetch current user info. Used to populate the display name.
+ Future?> getUserSettings() async {
+ final res = await _request('GET', '/users/settings');
+ return res is Map ? res.cast() : null;
+ }
+
+ /// Mark one or more items as watched. Body shape:
+ /// ```
+ /// {"movies": [{"ids": {"simkl": 123}}], "shows": [...]}
+ /// ```
+ Future addToHistory(Map body) => _request('POST', '/sync/history', body: body);
+
+ Future _request(String method, String path, {Map? body}) async {
+ final uri = Uri.parse('${SimklConstants.apiBase}$path');
+ final headers = SimklConstants.headers(accessToken: session.accessToken);
+ final encoded = body == null ? null : json.encode(body);
+
+ final sw = Stopwatch()..start();
+ final res = await switch (method) {
+ 'GET' => _http.get(uri, headers: headers),
+ 'POST' => _http.post(uri, headers: headers, body: encoded),
+ _ => throw ArgumentError('Unsupported HTTP method: $method'),
+ }.timeout(_requestTimeout);
+ sw.stop();
+ appLogger.d('Simkl $method ${uri.path} → ${res.statusCode} (${sw.elapsedMilliseconds}ms)');
+
+ if (res.statusCode == 401) {
+ onSessionInvalidated();
+ throw SimklAuthException('Session invalidated (401)');
+ }
+ if (res.statusCode < 200 || res.statusCode >= 300) {
+ throw SimklApiException(statusCode: res.statusCode, body: res.body);
+ }
+ if (res.body.isEmpty) return null;
+ try {
+ return json.decode(res.body);
+ } catch (_) {
+ return null;
+ }
+ }
+}
+
+class SimklApiException implements Exception {
+ final int statusCode;
+ final String body;
+ const SimklApiException({required this.statusCode, required this.body});
+ @override
+ String toString() => 'SimklApiException(HTTP $statusCode): $body';
+}
+
+class SimklAuthException implements Exception {
+ final String message;
+ const SimklAuthException(this.message);
+ @override
+ String toString() => 'SimklAuthException: $message';
+}
diff --git a/lib/services/trackers/simkl/simkl_constants.dart b/lib/services/trackers/simkl/simkl_constants.dart
new file mode 100644
index 00000000..22ebd7ce
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_constants.dart
@@ -0,0 +1,32 @@
+/// Bundled Simkl API credentials and endpoints.
+///
+/// Register at https://simkl.com/settings/developer — app type should be
+/// "Commandline / Console / Device code" (the same flow Trakt uses).
+/// Replace [clientId] with the registered client ID before shipping.
+class SimklConstants {
+ SimklConstants._();
+
+ /// Registered Simkl app client ID. Extractable from the binary; same threat
+ /// model as the Plex token already in SharedPreferences.
+ static const String clientId = 'ac97718a469c33eab948b63f92226106157e58fdcdd70c1b5857f1779b1d3a6a';
+
+ static const String apiBase = 'https://api.simkl.com';
+
+ // OAuth (device-code / PIN) endpoints
+ static const String pinUrl = '$apiBase/oauth/pin';
+
+ /// Poll URL for a given user code. Append `/?client_id=...`.
+ static String pinPollUrl(String userCode) => '$apiBase/oauth/pin/$userCode';
+
+ /// Web page the user visits to enter the code.
+ static const String verificationUrl = 'https://simkl.com/pin';
+
+ /// Headers on every Simkl request. `simkl-api-key` is required on all
+ /// endpoints, authed or not.
+ static Map headers({String? accessToken}) => {
+ 'Content-Type': 'application/json',
+ 'Accept': 'application/json',
+ 'simkl-api-key': clientId,
+ if (accessToken != null) 'Authorization': 'Bearer $accessToken',
+ };
+}
diff --git a/lib/services/trackers/simkl/simkl_session.dart b/lib/services/trackers/simkl/simkl_session.dart
new file mode 100644
index 00000000..fbf424ca
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_session.dart
@@ -0,0 +1,34 @@
+import 'dart:convert';
+
+/// Immutable Simkl OAuth session.
+///
+/// Simkl access tokens don't expire (per their docs), so there's no
+/// refresh_token — just the bearer and a display name for the settings UI.
+class SimklSession {
+ final String accessToken;
+ final String? username;
+ final int createdAt;
+
+ const SimklSession({required this.accessToken, required this.createdAt, this.username});
+
+ SimklSession copyWith({String? accessToken, String? username, int? createdAt}) => SimklSession(
+ accessToken: accessToken ?? this.accessToken,
+ username: username ?? this.username,
+ createdAt: createdAt ?? this.createdAt,
+ );
+
+ Map toJson() => {
+ 'access_token': accessToken,
+ 'username': username,
+ 'created_at': createdAt,
+ };
+
+ factory SimklSession.fromJson(Map json) => SimklSession(
+ accessToken: json['access_token'] as String,
+ username: json['username'] as String?,
+ createdAt: (json['created_at'] as num).toInt(),
+ );
+
+ String encode() => json.encode(toJson());
+ static SimklSession decode(String raw) => SimklSession.fromJson(json.decode(raw) as Map);
+}
diff --git a/lib/services/trackers/simkl/simkl_tracker.dart b/lib/services/trackers/simkl/simkl_tracker.dart
new file mode 100644
index 00000000..275cd714
--- /dev/null
+++ b/lib/services/trackers/simkl/simkl_tracker.dart
@@ -0,0 +1,87 @@
+import '../../../models/trackers/tracker_context.dart';
+import '../../../utils/app_logger.dart';
+import '../../settings_service.dart';
+import '../tracker.dart';
+import 'simkl_client.dart';
+import 'simkl_session.dart';
+
+/// Simkl scrobble tracker. Fires `POST /sync/history` once playback crosses
+/// the watched threshold (Simkl has no real-time `/scrobble/*` endpoints).
+///
+/// General-purpose: accepts any Plex external ID (tvdb/imdb/tmdb) directly,
+/// so it fires for non-anime TV and movies too. Prefers Fribb's simkl_id
+/// when present for stricter anime match, otherwise falls back to whatever
+/// Plex exposes.
+class SimklTracker extends TrackerBase {
+ static SimklTracker? _instance;
+ static SimklTracker get instance => _instance ??= SimklTracker._();
+ SimklTracker._();
+
+ @override
+ String get name => 'simkl';
+
+ @override
+ bool get needsFribb => false;
+
+ SimklClient? _client;
+
+ @override
+ bool get hasActiveClient => _client != null;
+
+ @override
+ bool readEnabledSetting(SettingsService settings) => settings.getEnableSimklScrobble();
+
+ void rebindSession(SimklSession? session, {required void Function() onSessionInvalidated}) {
+ _client?.dispose();
+ _client = session != null ? SimklClient(session, onSessionInvalidated: onSessionInvalidated) : null;
+ }
+
+ @override
+ Future markWatched(TrackerContext ctx) async {
+ final client = _client;
+ if (client == null) return;
+
+ final ids = _buildIds(ctx);
+ if (ids.isEmpty) return;
+
+ final body = ctx.isMovie
+ ? {
+ 'movies': [
+ {'ids': ids},
+ ],
+ }
+ : {
+ 'shows': [
+ {
+ 'ids': ids,
+ 'seasons': [
+ {
+ 'number': ctx.season,
+ 'episodes': [
+ {'number': ctx.episodeNumber},
+ ],
+ },
+ ],
+ },
+ ],
+ };
+
+ await client.addToHistory(body);
+ appLogger.d('Simkl: marked watched (ids=$ids, isMovie=${ctx.isMovie})');
+ }
+
+ /// Prefer Fribb's simkl_id for precision; otherwise send whatever Plex
+ /// exposes. Simkl accepts tvdb/imdb/tmdb in both movie and show shapes.
+ Map _buildIds(TrackerContext ctx) {
+ final ids = {};
+ final simklId = ctx.anime?.simkl;
+ if (simklId != null) ids['simkl'] = simklId;
+ final tvdb = ctx.external.tvdb;
+ if (tvdb != null) ids['tvdb'] = tvdb;
+ final tmdb = ctx.external.tmdb;
+ if (tmdb != null) ids['tmdb'] = tmdb;
+ final imdb = ctx.external.imdb;
+ if (imdb != null) ids['imdb'] = imdb;
+ return ids;
+ }
+}
diff --git a/lib/services/trackers/tracker.dart b/lib/services/trackers/tracker.dart
new file mode 100644
index 00000000..9f8b510d
--- /dev/null
+++ b/lib/services/trackers/tracker.dart
@@ -0,0 +1,48 @@
+import '../../models/trackers/tracker_context.dart';
+import '../settings_service.dart';
+
+/// Abstract tracker contract: the coordinator calls [markWatched] once per
+/// playback when progress crosses the watched threshold. Enabled/auth gating
+/// lives in [TrackerBase].
+abstract class Tracker {
+ String get name;
+
+ bool get canScrobble;
+
+ /// True if this tracker's IDs only come from the Fribb anime mapping
+ /// (MAL, AniList). Simkl returns false because it accepts Plex tvdb/imdb/
+ /// tmdb directly; when Simkl is the only active tracker we skip the 5.6 MB
+ /// Fribb download entirely.
+ bool get needsFribb;
+
+ Future initialize();
+ Future setEnabled(bool enabled);
+
+ Future markWatched(TrackerContext ctx);
+}
+
+/// Shared enabled-state bookkeeping. Subclasses override [hasActiveClient],
+/// [readEnabledSetting], and [markWatched].
+abstract class TrackerBase implements Tracker {
+ bool _isInitialized = false;
+ bool _isEnabled = false;
+
+ bool get hasActiveClient;
+
+ bool readEnabledSetting(SettingsService settings);
+
+ @override
+ bool get canScrobble => _isEnabled && hasActiveClient;
+
+ @override
+ Future initialize() async {
+ if (_isInitialized) return;
+ _isInitialized = true;
+ _isEnabled = readEnabledSetting(await SettingsService.getInstance());
+ }
+
+ @override
+ Future setEnabled(bool enabled) async {
+ _isEnabled = enabled;
+ }
+}
diff --git a/lib/services/trackers/tracker_account_store.dart b/lib/services/trackers/tracker_account_store.dart
new file mode 100644
index 00000000..61c24dda
--- /dev/null
+++ b/lib/services/trackers/tracker_account_store.dart
@@ -0,0 +1,46 @@
+import 'package:shared_preferences/shared_preferences.dart';
+
+/// Per-Plex-profile session persistence for any tracker service.
+///
+/// Keyed by `user_{uuid}_{baseKey}` so each Plex Home profile gets its own
+/// stored session. Generic over the session type [T] — callers supply
+/// encode/decode functions.
+///
+/// Pass an empty `userUuid` to fall back to a single global slot (used
+/// before a profile has been selected).
+class TrackerAccountStore {
+ final String _baseKey;
+ final T Function(String raw) _decode;
+ final String Function(T session) _encode;
+
+ const TrackerAccountStore({
+ required String baseKey,
+ required T Function(String raw) decode,
+ required String Function(T session) encode,
+ }) : _baseKey = baseKey,
+ _decode = decode,
+ _encode = encode;
+
+ String _scopedKey(String userUuid) => userUuid.isEmpty ? _baseKey : 'user_${userUuid}_$_baseKey';
+
+ Future load(String userUuid) async {
+ final prefs = await SharedPreferences.getInstance();
+ final raw = prefs.getString(_scopedKey(userUuid));
+ if (raw == null) return null;
+ try {
+ return _decode(raw);
+ } catch (_) {
+ return null;
+ }
+ }
+
+ Future save(String userUuid, T session) async {
+ final prefs = await SharedPreferences.getInstance();
+ await prefs.setString(_scopedKey(userUuid), _encode(session));
+ }
+
+ Future clear(String userUuid) async {
+ final prefs = await SharedPreferences.getInstance();
+ await prefs.remove(_scopedKey(userUuid));
+ }
+}
diff --git a/lib/services/trackers/tracker_constants.dart b/lib/services/trackers/tracker_constants.dart
new file mode 100644
index 00000000..4c39bcc9
--- /dev/null
+++ b/lib/services/trackers/tracker_constants.dart
@@ -0,0 +1,8 @@
+/// Shared constants for non-Trakt tracker integrations (MAL, AniList, Simkl).
+class TrackerConstants {
+ TrackerConstants._();
+
+ /// Progress percent at which an episode/movie counts as watched and is
+ /// pushed to each tracker.
+ static const double watchedThresholdPercent = 80.0;
+}
diff --git a/lib/services/trackers/tracker_coordinator.dart b/lib/services/trackers/tracker_coordinator.dart
new file mode 100644
index 00000000..487239b0
--- /dev/null
+++ b/lib/services/trackers/tracker_coordinator.dart
@@ -0,0 +1,154 @@
+import 'dart:async';
+
+import '../../models/plex_metadata.dart';
+import '../../models/trackers/tracker_context.dart';
+import '../../utils/app_logger.dart';
+import '../plex_client.dart';
+import 'anilist/anilist_tracker.dart';
+import 'mal/mal_tracker.dart';
+import 'simkl/simkl_tracker.dart';
+import 'tracker.dart';
+import 'tracker_constants.dart';
+import 'tracker_id_resolver.dart';
+
+/// Fan-out for non-Trakt trackers (MAL, AniList, Simkl). Owns the per-playback
+/// threshold state: each connected tracker is notified exactly once when
+/// progress crosses the watched threshold, with a safety-net fire on stop if
+/// the crossing was missed (e.g. user stopped between ticks).
+class TrackerCoordinator {
+ static TrackerCoordinator? _instance;
+ static TrackerCoordinator get instance => _instance ??= TrackerCoordinator._();
+
+ TrackerCoordinator._();
+
+ late final List _trackers = [
+ MalTracker.instance,
+ AnilistTracker.instance,
+ SimklTracker.instance,
+ ];
+
+ /// Resolver persists across episode swaps so back-to-back episodes of the
+ /// same show reuse the cached IDs. Cleared only on profile switch.
+ TrackerIdResolver? _resolver;
+
+ TrackerContext? _ctx;
+ Duration _duration = Duration.zero;
+ Duration _lastPosition = Duration.zero;
+ bool _thresholdCrossed = false;
+
+ Future initialize() async {
+ await Future.wait(_trackers.map((t) => t.initialize()));
+ }
+
+ Future startPlayback(PlexMetadata metadata, PlexClient plexClient, {bool isLive = false}) async {
+ if (isLive) return;
+ final mediaType = metadata.mediaType;
+ if (mediaType != PlexMediaType.movie && mediaType != PlexMediaType.episode) return;
+ if (!_trackers.any((t) => t.canScrobble)) return;
+
+ _resolver ??= TrackerIdResolver(plexClient, needsFribb: _anyTrackerNeedsFribb);
+ final ctx = await _buildContext(metadata);
+ if (ctx == null) {
+ appLogger.d('Trackers: no external IDs for ${metadata.ratingKey}');
+ _reset();
+ return;
+ }
+ _reset();
+ _ctx = ctx;
+ }
+
+ bool _anyTrackerNeedsFribb() => _trackers.any((t) => t.canScrobble && t.needsFribb);
+
+ Future stopPlayback() async {
+ final ctx = _ctx;
+ if (ctx == null) {
+ _reset();
+ return;
+ }
+ // Safety net: fire if we passed the threshold but missed the tick.
+ if (!_thresholdCrossed && _crossed(_duration, _lastPosition)) {
+ await _dispatchMarkWatched(ctx);
+ }
+ _reset();
+ }
+
+ void updatePosition(Duration position) {
+ _lastPosition = position;
+ final ctx = _ctx;
+ if (ctx == null || _thresholdCrossed) return;
+ if (!_crossed(_duration, position)) return;
+ _thresholdCrossed = true;
+ unawaited(_dispatchMarkWatched(ctx));
+ }
+
+ void updateDuration(Duration duration) {
+ if (duration == _duration) return;
+ _duration = duration;
+ }
+
+ /// Called on Plex profile switch — drops in-flight state across all
+ /// trackers and invalidates the resolver so a fresh Plex client is used.
+ void cancelInFlight() {
+ _reset();
+ _resolver?.clearCache();
+ _resolver = null;
+ }
+
+ /// Drop the resolver's ID cache without touching in-flight playback state.
+ /// Called after a tracker is connected/disconnected so cached lookups
+ /// re-evaluate the `needsFribb` predicate.
+ void invalidateResolverCache() => _resolver?.clearCache();
+
+ void _reset() {
+ _ctx = null;
+ _duration = Duration.zero;
+ _lastPosition = Duration.zero;
+ _thresholdCrossed = false;
+ }
+
+ static bool _crossed(Duration duration, Duration position) {
+ final dMs = duration.inMilliseconds;
+ if (dMs == 0) return false;
+ return position.inMilliseconds * 100 >= dMs * TrackerConstants.watchedThresholdPercent;
+ }
+
+ Future _dispatchMarkWatched(TrackerContext ctx) async {
+ final active = _trackers.where((t) => t.canScrobble);
+ await Future.wait(active.map((t) async {
+ try {
+ await t.markWatched(ctx);
+ } catch (e) {
+ appLogger.d('${t.name}: markWatched failed', error: e);
+ }
+ }));
+ }
+
+ Future _buildContext(PlexMetadata metadata) async {
+ final resolver = _resolver;
+ if (resolver == null) return null;
+
+ if (metadata.mediaType == PlexMediaType.movie) {
+ final ids = await resolver.resolveForMovie(metadata.ratingKey);
+ if (ids == null) return null;
+ return TrackerContext.movie(
+ external: ids.external,
+ anime: ids.anime,
+ ratingKey: metadata.ratingKey,
+ );
+ }
+
+ final season = metadata.parentIndex;
+ final number = metadata.index;
+ if (season == null || number == null) return null;
+
+ final ids = await resolver.resolveShowForEpisode(metadata);
+ if (ids == null) return null;
+ return TrackerContext.episode(
+ external: ids.external,
+ anime: ids.anime,
+ ratingKey: metadata.ratingKey,
+ season: season,
+ episodeNumber: number,
+ );
+ }
+}
diff --git a/lib/services/trackers/tracker_id_resolver.dart b/lib/services/trackers/tracker_id_resolver.dart
new file mode 100644
index 00000000..db2cf70c
--- /dev/null
+++ b/lib/services/trackers/tracker_id_resolver.dart
@@ -0,0 +1,115 @@
+import '../../models/plex_metadata.dart';
+import '../../models/trackers/anime_ids.dart';
+import '../../models/trackers/fribb_mapping_row.dart';
+import '../../utils/plex_external_ids.dart';
+import '../plex_client.dart';
+import 'fribb_mapping_store.dart';
+
+/// Paired ID output: always-present Plex external IDs (tvdb/imdb/tmdb) plus
+/// optional Fribb-sourced anime IDs (mal/anilist/simkl). Simkl uses [external]
+/// directly for non-anime titles; MAL/AniList no-op when [anime] is null.
+class TrackerIds {
+ final PlexExternalIds external;
+ final AnimeIds? anime;
+
+ const TrackerIds({required this.external, required this.anime});
+}
+
+/// Resolves Plex ratingKeys → tracker external IDs. Returns both Plex
+/// external IDs (used by Trakt and by Simkl for non-anime matches) and Fribb
+/// anime IDs (used by MAL/AniList, and by Simkl for anime precision).
+/// Episodes resolve against the show's GUIDs because Fribb only maps
+/// show-level external IDs; split-cour disambiguation uses the Plex season
+/// number.
+///
+/// The Fribb lookup is skipped when [needsFribb] returns false — set this way
+/// for Trakt (which never uses anime IDs) and for a Simkl-only configuration,
+/// so those users don't pay the 5.6 MB mapping download they'll never need.
+class TrackerIdResolver {
+ final PlexClient _client;
+ final FribbMappingStore _store;
+ final bool Function() _needsFribb;
+
+ /// Null entries mean "Plex had no GUIDs" — cached so scrubbing on an
+ /// un-matched item doesn't re-hit Plex every position update.
+ final Map _cache = {};
+
+ TrackerIdResolver(
+ this._client, {
+ bool Function()? needsFribb,
+ FribbMappingStore? store,
+ }) : _needsFribb = needsFribb ?? _returnTrue,
+ _store = store ?? FribbMappingStore.instance;
+
+ static bool _returnTrue() => true;
+
+ /// Resolve IDs for a movie.
+ Future resolveForMovie(String ratingKey) async {
+ if (_cache.containsKey(ratingKey)) return _cache[ratingKey];
+
+ final external = PlexExternalIds.fromGuids(await _client.fetchExternalGuids(ratingKey));
+ final ids = await _build(external, isEpisodeSeason: null, isMovie: true);
+ _cache[ratingKey] = ids;
+ return ids;
+ }
+
+ /// Resolve IDs for an episode. Looks up the *show's* external IDs (via
+ /// `grandparentRatingKey`), then disambiguates among candidate Fribb rows
+ /// using the episode's season number.
+ Future resolveShowForEpisode(PlexMetadata episode) async {
+ final showRatingKey = episode.grandparentRatingKey;
+ if (showRatingKey == null || showRatingKey.isEmpty) return null;
+
+ final season = episode.parentIndex;
+ // Cache under the (showRatingKey, season) pair so a show with multiple
+ // Fribb rows caches each season separately during a marathon.
+ final cacheKey = season != null ? '$showRatingKey#s$season' : showRatingKey;
+ if (_cache.containsKey(cacheKey)) return _cache[cacheKey];
+
+ final external = PlexExternalIds.fromGuids(await _client.fetchExternalGuids(showRatingKey));
+ final ids = await _build(external, isEpisodeSeason: season, isMovie: false);
+ _cache[cacheKey] = ids;
+ return ids;
+ }
+
+ void clearCache() => _cache.clear();
+
+ Future _build(PlexExternalIds external, {int? isEpisodeSeason, required bool isMovie}) async {
+ if (!external.hasAny) return null;
+ if (!_needsFribb()) return TrackerIds(external: external, anime: null);
+ final rows = await _store.lookup(tvdbId: external.tvdb, tmdbId: external.tmdb, imdbId: external.imdb);
+ final row = isMovie ? _pickMovieRow(rows) : _pickShowRow(rows, season: isEpisodeSeason);
+ final anime = row == null ? null : AnimeIds.fromFribb(row);
+ return TrackerIds(external: external, anime: anime);
+ }
+
+ /// Pick the best row for a movie lookup — prefer rows marked `type: MOVIE`.
+ FribbMappingRow? _pickMovieRow(List rows) {
+ if (rows.isEmpty) return null;
+ final movies = rows.where((r) => r.isMovie);
+ if (movies.isNotEmpty) return movies.first;
+ // Fall back to any row if no explicit MOVIE row matches — some rows have
+ // no type field.
+ return rows.first;
+ }
+
+ /// Pick the best row for a show lookup. When Fribb has multiple rows
+ /// sharing the same show-level external ID (split-cour anime), prefer the
+ /// one whose `season.tvdb` matches the Plex episode's season; otherwise
+ /// the first non-MOVIE row.
+ FribbMappingRow? _pickShowRow(List rows, {int? season}) {
+ if (rows.isEmpty) return null;
+
+ if (season != null) {
+ for (final row in rows) {
+ if (row.tvdbSeason == season || row.tmdbSeason == season) return row;
+ }
+ }
+
+ // No season match — fall back to the first non-MOVIE row (prefer series).
+ for (final row in rows) {
+ if (!row.isMovie) return row;
+ }
+ return rows.first;
+ }
+}
diff --git a/lib/services/trakt/trakt_account_store.dart b/lib/services/trakt/trakt_account_store.dart
index 12a5079e..008eeace 100644
--- a/lib/services/trakt/trakt_account_store.dart
+++ b/lib/services/trakt/trakt_account_store.dart
@@ -1,37 +1,9 @@
-import 'package:shared_preferences/shared_preferences.dart';
-
-import 'trakt_constants.dart';
+import '../trackers/tracker_account_store.dart';
import 'trakt_session.dart';
/// Per-Plex-profile persistence of Trakt OAuth sessions.
-///
-/// Each Plex Home user can link a different Trakt account. Pass an empty
-/// `userUuid` to fall back to a single global slot (used before the user has
-/// selected a profile).
-class TraktAccountStore {
- static const String _baseKey = 'trakt_session';
-
- TraktAccountStore._();
- static final TraktAccountStore instance = TraktAccountStore._();
-
- Future load(String userUuid) async {
- final prefs = await SharedPreferences.getInstance();
- final raw = prefs.getString(traktUserKey(userUuid, _baseKey));
- if (raw == null) return null;
- try {
- return TraktSession.decode(raw);
- } catch (_) {
- return null;
- }
- }
-
- Future save(String userUuid, TraktSession session) async {
- final prefs = await SharedPreferences.getInstance();
- await prefs.setString(traktUserKey(userUuid, _baseKey), session.encode());
- }
-
- Future clear(String userUuid) async {
- final prefs = await SharedPreferences.getInstance();
- await prefs.remove(traktUserKey(userUuid, _baseKey));
- }
-}
+final TrackerAccountStore traktAccountStore = TrackerAccountStore(
+ baseKey: 'trakt_session',
+ decode: TraktSession.decode,
+ encode: (s) => s.encode(),
+);
diff --git a/lib/services/trakt/trakt_auth_service.dart b/lib/services/trakt/trakt_auth_service.dart
index de6b1cc1..2e96a418 100644
--- a/lib/services/trakt/trakt_auth_service.dart
+++ b/lib/services/trakt/trakt_auth_service.dart
@@ -3,11 +3,12 @@ import 'dart:convert';
import 'package:http/http.dart' as http;
-import '../../models/trakt/trakt_device_code.dart';
+import '../../models/trackers/device_code.dart';
import '../../utils/app_logger.dart';
import '../../utils/platform_http_client_stub.dart'
if (dart.library.io) '../../utils/platform_http_client_io.dart'
as platform;
+import '../trackers/device_code_poller.dart' as poller;
import 'trakt_constants.dart';
/// Trakt OAuth Device Authorization Grant flow (RFC 8628).
@@ -22,9 +23,9 @@ class TraktAuthService {
void dispose() => _http.close();
- /// Request a device code. The returned [TraktDeviceCode.userCode] is what
- /// the user must enter at [TraktDeviceCode.verificationUrl].
- Future createDeviceCode() async {
+ /// Request a device code. The returned [DeviceCode.userCode] is what the
+ /// user must enter at [DeviceCode.verificationUrl].
+ Future createDeviceCode() async {
final uri = Uri.parse(TraktConstants.deviceCodeUrl);
final sw = Stopwatch()..start();
final res = await _http
@@ -37,86 +38,61 @@ class TraktAuthService {
throw TraktAuthFlowException('Device code request failed: HTTP ${res.statusCode}: ${res.body}');
}
- return TraktDeviceCode.fromJson(json.decode(res.body) as Map);
+ final body = json.decode(res.body) as Map;
+ final verificationUrl = body['verification_url'] as String;
+ final userCode = body['user_code'] as String;
+ return DeviceCode(
+ deviceCode: body['device_code'] as String,
+ userCode: userCode,
+ verificationUrl: verificationUrl,
+ verificationUrlComplete: '$verificationUrl/$userCode',
+ expiresIn: (body['expires_in'] as num).toInt(),
+ interval: (body['interval'] as num).toInt(),
+ );
}
/// Poll the device-token endpoint until the user authorizes, denies, or the
- /// code expires. Yields one event per poll attempt; the stream completes
- /// after the first terminal event ([TraktDevicePollSuccess],
- /// [TraktDevicePollDenied], [TraktDevicePollExpired]).
- ///
- /// Pass [shouldCancel] to abort polling early (e.g. user dismissed the
- /// dialog).
- Stream pollDeviceCode(TraktDeviceCode code, {bool Function()? shouldCancel}) async* {
- var interval = Duration(seconds: code.interval);
- final deadline = DateTime.now().add(Duration(seconds: code.expiresIn));
+ /// code expires. Pass [shouldCancel] to abort early.
+ Stream pollDeviceCode(DeviceCode code, {bool Function()? shouldCancel}) {
+ return poller.pollDeviceCode(code, shouldCancel: shouldCancel, probe: () => _probe(code));
+ }
- while (DateTime.now().isBefore(deadline)) {
- if (shouldCancel != null && shouldCancel()) return;
-
- await Future.delayed(interval);
-
- if (shouldCancel != null && shouldCancel()) return;
-
- http.Response res;
- final tokenUri = Uri.parse(TraktConstants.deviceTokenUrl);
- final sw = Stopwatch()..start();
- try {
- res = await _http
- .post(
- tokenUri,
- headers: TraktConstants.headers(),
- body: json.encode({
- 'code': code.deviceCode,
- 'client_id': TraktConstants.clientId,
- 'client_secret': TraktConstants.clientSecret,
- }),
- )
- .timeout(const Duration(seconds: 15));
- sw.stop();
- appLogger.d('Trakt POST ${tokenUri.path} → ${res.statusCode} (${sw.elapsedMilliseconds}ms)');
- } catch (e) {
- appLogger.d('Trakt device-code poll error (transient)', error: e);
- yield const TraktDevicePollPending();
- continue;
- }
-
- switch (res.statusCode) {
- case 200:
- final body = json.decode(res.body) as Map;
- yield TraktDevicePollSuccess(body);
- return;
- case 400:
- // Pending — keep polling
- yield const TraktDevicePollPending();
- break;
- case 404:
- // Code not found / expired
- yield const TraktDevicePollExpired();
- return;
- case 409:
- // Already used
- yield const TraktDevicePollDenied();
- return;
- case 410:
- yield const TraktDevicePollExpired();
- return;
- case 418:
- // Denied
- yield const TraktDevicePollDenied();
- return;
- case 429:
- // Slow down — increase interval by 5s
- interval += const Duration(seconds: 5);
- yield const TraktDevicePollSlowDown();
- break;
- default:
- appLogger.w('Trakt device-code unexpected HTTP ${res.statusCode}: ${res.body}');
- yield const TraktDevicePollPending();
- }
+ Future _probe(DeviceCode code) async {
+ final tokenUri = Uri.parse(TraktConstants.deviceTokenUrl);
+ final http.Response res;
+ try {
+ res = await _http
+ .post(
+ tokenUri,
+ headers: TraktConstants.headers(),
+ body: json.encode({
+ 'code': code.deviceCode,
+ 'client_id': TraktConstants.clientId,
+ 'client_secret': TraktConstants.clientSecret,
+ }),
+ )
+ .timeout(const Duration(seconds: 15));
+ appLogger.d('Trakt POST ${tokenUri.path} → ${res.statusCode}');
+ } catch (e) {
+ appLogger.d('Trakt device-code poll error (transient)', error: e);
+ return const DevicePollPending();
}
- yield const TraktDevicePollExpired();
+ switch (res.statusCode) {
+ case 200:
+ return DevicePollSuccess(json.decode(res.body) as Map);
+ case 400:
+ return const DevicePollPending();
+ case 404 || 410:
+ return const DevicePollExpired();
+ case 409 || 418:
+ return const DevicePollDenied();
+ case 429:
+ return const DevicePollSlowDown();
+ default:
+ appLogger.w('Trakt device-code unexpected HTTP ${res.statusCode}: ${res.body}');
+ return const DevicePollPending();
+ }
}
}
diff --git a/lib/services/trakt/trakt_guid_resolver.dart b/lib/services/trakt/trakt_guid_resolver.dart
deleted file mode 100644
index bf9b9fa8..00000000
--- a/lib/services/trakt/trakt_guid_resolver.dart
+++ /dev/null
@@ -1,51 +0,0 @@
-import '../../models/plex_metadata.dart';
-import '../../models/trakt/trakt_ids.dart';
-import '../plex_client.dart';
-
-/// Resolves Plex rating keys to external IDs (imdb/tmdb/tvdb) for Trakt
-/// matching. Caches per ratingKey for the duration of a play session.
-///
-/// Trakt prefers a show-IDs-plus-season/episode shape for episode scrobbles
-/// rather than episode-IDs alone, so episode resolution requires a separate
-/// fetch on `grandparentRatingKey` to get the show's GUIDs.
-class TraktGuidResolver {
- final PlexClient _client;
-
- /// Cache of `ratingKey → TraktIds`. Holds both movies and shows.
- final Map _cache = {};
-
- TraktGuidResolver(this._client);
-
- /// Resolve external IDs for a movie rating key.
- Future resolveForMovie(String ratingKey) async {
- final cached = _cache[ratingKey];
- if (cached != null) return cached;
-
- final guids = await _client.fetchExternalGuids(ratingKey);
- final ids = TraktIds.fromPlexGuids(guids);
- _cache[ratingKey] = ids;
- return ids;
- }
-
- /// Resolve external IDs for an episode. Returns the show's GUIDs (Trakt's
- /// preferred shape); season/episode index live on the [PlexMetadata] itself.
- ///
- /// Returns null if the episode is missing `grandparentRatingKey` (in which
- /// case Trakt has no way to match the show).
- Future resolveShowForEpisode(PlexMetadata episode) async {
- final showRatingKey = episode.grandparentRatingKey;
- if (showRatingKey == null || showRatingKey.isEmpty) return null;
-
- final cached = _cache[showRatingKey];
- if (cached != null) return cached;
-
- final guids = await _client.fetchExternalGuids(showRatingKey);
- final ids = TraktIds.fromPlexGuids(guids);
- _cache[showRatingKey] = ids;
- return ids;
- }
-
- /// Drop all cached IDs. Called on stopPlayback / profile switch so a
- /// re-matched item gets fresh GUIDs the next time around.
- void clearCache() => _cache.clear();
-}
diff --git a/lib/services/trakt/trakt_scrobble_service.dart b/lib/services/trakt/trakt_scrobble_service.dart
index 27868165..199821e4 100644
--- a/lib/services/trakt/trakt_scrobble_service.dart
+++ b/lib/services/trakt/trakt_scrobble_service.dart
@@ -1,13 +1,14 @@
import 'dart:async';
import '../../models/plex_metadata.dart';
+import '../../models/trakt/trakt_ids.dart';
import '../../models/trakt/trakt_scrobble_request.dart';
import '../../utils/app_logger.dart';
import '../plex_client.dart';
import '../settings_service.dart';
+import '../trackers/tracker_id_resolver.dart';
import 'trakt_client.dart';
import 'trakt_constants.dart';
-import 'trakt_guid_resolver.dart';
import 'trakt_session.dart';
/// Real-time scrobble service for Trakt.
@@ -41,7 +42,7 @@ class TraktScrobbleService {
bool _isEnabled = false;
TraktClient? _client;
- TraktGuidResolver? _resolver;
+ TrackerIdResolver? _resolver;
TraktScrobbleRequest? _currentBody;
Duration _currentPosition = Duration.zero;
Duration _currentDuration = Duration.zero;
@@ -95,7 +96,7 @@ class TraktScrobbleService {
_currentPosition = metadata.viewOffset != null ? Duration(milliseconds: metadata.viewOffset!) : Duration.zero;
_currentDuration = metadata.duration != null ? Duration(milliseconds: metadata.duration!) : Duration.zero;
_lastSeekCheckpointAt = null;
- _resolver = TraktGuidResolver(plexClient);
+ _resolver = TrackerIdResolver(plexClient, needsFribb: () => false);
final body = await _buildBody(metadata);
if (body == null) {
@@ -153,8 +154,8 @@ class TraktScrobbleService {
if (metadata.mediaType == PlexMediaType.movie) {
final ids = await resolver.resolveForMovie(metadata.ratingKey);
- if (!ids.hasAny) return null;
- return TraktScrobbleRequest.movie(ids: ids);
+ if (ids == null) return null;
+ return TraktScrobbleRequest.movie(ids: TraktIds.fromExternal(ids.external));
}
final season = metadata.parentIndex;
@@ -162,9 +163,13 @@ class TraktScrobbleService {
if (season == null || number == null) return null;
final showIds = await resolver.resolveShowForEpisode(metadata);
- if (showIds == null || !showIds.hasAny) return null;
+ if (showIds == null) return null;
- return TraktScrobbleRequest.episode(showIds: showIds, season: season, number: number);
+ return TraktScrobbleRequest.episode(
+ showIds: TraktIds.fromExternal(showIds.external),
+ season: season,
+ number: number,
+ );
}
double _progressPercent() {
diff --git a/lib/services/trakt/trakt_sync_service.dart b/lib/services/trakt/trakt_sync_service.dart
index ce23dca2..6a8fcb62 100644
--- a/lib/services/trakt/trakt_sync_service.dart
+++ b/lib/services/trakt/trakt_sync_service.dart
@@ -7,9 +7,9 @@ import '../../utils/app_logger.dart';
import '../../utils/watch_state_notifier.dart';
import '../multi_server_manager.dart';
import '../settings_service.dart';
+import '../trackers/tracker_id_resolver.dart';
import 'trakt_client.dart';
import 'trakt_constants.dart';
-import 'trakt_guid_resolver.dart';
import 'trakt_session.dart';
import 'trakt_sync_queue.dart';
@@ -39,7 +39,7 @@ class TraktSyncService {
/// One resolver per Plex server, kept alive across events so the per-rating-
/// key GUID cache survives a binge-watch session.
- final Map _resolvers = {};
+ final Map _resolvers = {};
/// Fallback buffer for items that failed to persist to the on-disk queue
/// (e.g. SharedPreferences write threw). Retried on next `flushQueue`.
@@ -90,14 +90,14 @@ class TraktSyncService {
bool get _canPush => _isEnabled && _client != null;
- TraktGuidResolver? _resolverFor(String serverId) {
+ TrackerIdResolver? _resolverFor(String serverId) {
final cached = _resolvers[serverId];
if (cached != null) return cached;
final plexClient = _serverManager?.getClient(serverId);
if (plexClient == null) return null;
- final resolver = TraktGuidResolver(plexClient);
+ final resolver = TrackerIdResolver(plexClient, needsFribb: () => false);
_resolvers[serverId] = resolver;
return resolver;
}
@@ -132,12 +132,12 @@ class TraktSyncService {
return;
}
- TraktIds? ids;
+ TrackerIds? resolved;
int? season;
int? number;
if (kind == TraktMediaKind.movie) {
- ids = await resolver.resolveForMovie(ratingKey);
+ resolved = await resolver.resolveForMovie(ratingKey);
} else {
// Episode — need show IDs + season/episode index. The WatchStateEvent
// doesn't carry the index, so fetch episode metadata.
@@ -148,14 +148,15 @@ class TraktSyncService {
season = episodeMeta.parentIndex;
number = episodeMeta.index;
if (season == null || number == null) return;
- ids = await resolver.resolveShowForEpisode(episodeMeta);
+ resolved = await resolver.resolveShowForEpisode(episodeMeta);
}
- if (ids == null || !ids.hasAny) {
+ if (resolved == null) {
appLogger.d('Trakt sync: no IDs for ${kind.name} $ratingKey, dropping');
return;
}
+ final ids = TraktIds.fromExternal(resolved.external);
final body = kind == TraktMediaKind.movie
? TraktScrobbleRequest.movie(ids: ids)
: TraktScrobbleRequest.episode(showIds: ids, season: season!, number: number!);
diff --git a/lib/utils/plex_external_ids.dart b/lib/utils/plex_external_ids.dart
new file mode 100644
index 00000000..3fa855ce
--- /dev/null
+++ b/lib/utils/plex_external_ids.dart
@@ -0,0 +1,33 @@
+/// External IDs parsed from a Plex `Guid` array (as returned by
+/// `?includeGuids=1`). Shared by the Trakt and tracker resolvers.
+///
+/// Plex GUIDs look like `imdb://tt123`, `tmdb://456`, `tvdb://789`. Callers
+/// fetch the raw array via [PlexClient.fetchExternalGuids] and pass it here.
+class PlexExternalIds {
+ final String? imdb;
+ final int? tmdb;
+ final int? tvdb;
+
+ const PlexExternalIds({this.imdb, this.tmdb, this.tvdb});
+
+ bool get hasAny => imdb != null || tmdb != null || tvdb != null;
+
+ factory PlexExternalIds.fromGuids(List guids) {
+ String? imdb;
+ int? tmdb;
+ int? tvdb;
+ for (final g in guids) {
+ if (g is! Map) continue;
+ final id = g['id'];
+ if (id is! String) continue;
+ if (id.startsWith('imdb://')) {
+ imdb = id.substring(7);
+ } else if (id.startsWith('tmdb://')) {
+ tmdb = int.tryParse(id.substring(7));
+ } else if (id.startsWith('tvdb://')) {
+ tvdb = int.tryParse(id.substring(7));
+ }
+ }
+ return PlexExternalIds(imdb: imdb, tmdb: tmdb, tvdb: tvdb);
+ }
+}
diff --git a/lib/widgets/device_code_dialog.dart b/lib/widgets/device_code_dialog.dart
new file mode 100644
index 00000000..1fdda095
--- /dev/null
+++ b/lib/widgets/device_code_dialog.dart
@@ -0,0 +1,99 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+import '../i18n/strings.g.dart';
+import '../models/trackers/device_code.dart';
+import '../utils/snackbar_helper.dart';
+import 'dialog_action_button.dart';
+
+/// Shared device-code activation dialog for Trakt and Simkl (RFC 8628).
+///
+/// Shows the `userCode` with copy-to-clipboard, a button to launch the
+/// verification URL in the browser, and a "waiting for authorization…" spinner
+/// while the poll loop runs. Dismissing calls [onCancel] so the provider can
+/// abort the poll.
+class DeviceCodeDialog extends StatelessWidget {
+ final DeviceCode code;
+ final String serviceName;
+ final VoidCallback onCancel;
+
+ const DeviceCodeDialog({
+ super.key,
+ required this.code,
+ required this.serviceName,
+ required this.onCancel,
+ });
+
+ Future _open() async {
+ final url = code.verificationUrlComplete ?? code.verificationUrl;
+ await launchUrl(Uri.parse(url), mode: LaunchMode.externalApplication);
+ }
+
+ Future _copy(BuildContext context) async {
+ await Clipboard.setData(ClipboardData(text: code.userCode));
+ if (!context.mounted) return;
+ showAppSnackBar(context, t.trackers.deviceCode.codeCopied);
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ final theme = Theme.of(context);
+ return AlertDialog(
+ title: Text(t.trackers.deviceCode.title(service: serviceName)),
+ content: Column(
+ mainAxisSize: MainAxisSize.min,
+ crossAxisAlignment: CrossAxisAlignment.start,
+ children: [
+ Text(t.trackers.deviceCode.body(url: code.verificationUrl), style: theme.textTheme.bodyMedium),
+ const SizedBox(height: 16),
+ Center(
+ child: InkWell(
+ onTap: () => _copy(context),
+ borderRadius: BorderRadius.circular(8),
+ child: Padding(
+ padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+ child: Text(
+ code.userCode,
+ style: theme.textTheme.displaySmall?.copyWith(
+ fontFeatures: const [FontFeature.tabularFigures()],
+ letterSpacing: 4,
+ fontWeight: FontWeight.w600,
+ ),
+ ),
+ ),
+ ),
+ ),
+ const SizedBox(height: 16),
+ SizedBox(
+ width: double.infinity,
+ child: FilledButton.icon(
+ icon: const Icon(Icons.open_in_new),
+ label: Text(t.trackers.deviceCode.openToActivate(service: serviceName)),
+ onPressed: _open,
+ ),
+ ),
+ const SizedBox(height: 16),
+ Row(
+ children: [
+ const SizedBox(width: 16, height: 16, child: CircularProgressIndicator(strokeWidth: 2)),
+ const SizedBox(width: 12),
+ Expanded(
+ child: Text(t.trackers.deviceCode.waitingForAuthorization, style: theme.textTheme.bodySmall),
+ ),
+ ],
+ ),
+ ],
+ ),
+ actions: [
+ DialogActionButton(
+ onPressed: () {
+ onCancel();
+ Navigator.of(context, rootNavigator: true).pop();
+ },
+ label: t.common.cancel,
+ ),
+ ],
+ );
+ }
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index ab9a7447..7b8b2e11 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -117,6 +117,9 @@ flutter:
- assets/plezy.png
- assets/plezy_adaptive_foreground.svg
- assets/trakt_circlemark.svg
+ - assets/mal_mark.svg
+ - assets/anilist_mark.svg
+ - assets/simkl_mark.svg
- assets/go-noto-current-regular.ttf
- assets/shaders/nvscaler/
- assets/shaders/anime4k/