Skip to content

A cross platform Audiobookshelf client for Android and iOS

Dart
27.4 KB
Raw Blame
import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:home_widget/home_widget.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'android_auto_service.dart';
import 'api_service.dart';
import 'audio_player_service.dart';
import 'download_service.dart';
import 'home_widget_service.dart';
import 'progress_sync_service.dart';
import 'siri_matcher.dart';
import 'sleep_timer_service.dart';

/// Siri on iOS. Native code forwards the media intent ("Play Dune on Absorb")
/// and the App Shortcuts here; this side picks the book, plays it, keeps the
/// list of books Siri can name in the app group, and tells Siri what gets
/// played so it learns the listener's books.
class SiriService {
  static final SiriService _instance = SiriService._();
  factory SiriService() => _instance;
  SiriService._();

  static const _channel = MethodChannel('com.absorb.siri');
  static const _widgetChannel = MethodChannel('com.absorb.widget');
  static const catalogFileName = 'siri_catalog.json';

  /// Items the library screens have loaded (Absorbing, home shelves of every
  /// library opened). Set by LibraryProvider.
  static Iterable<Map<String, dynamic>> Function()? libraryItems;

  bool _initialized = false;
  List<SiriEntry> _catalog = const [];
  bool _catalogLoaded = false;
  Timer? _catalogTimer;
  bool _rebuilding = false;
  bool _askedAutoRefresh = false;
  String? _lastPlayKey;
  Map<String, Map<String, dynamic>> _progress = const {};
  DateTime? _progressAt;

  Future<void> init() async {
    if (_initialized || !Platform.isIOS) return;
    _initialized = true;
    _channel.setMethodCallHandler(_onCall);
    try {
      await _channel.invokeMethod('ready');
    } catch (e) {
      debugPrint('[Siri] ready failed: $e');
    }
    AudioPlayerService().addListener(_onPlayerChanged);
    AndroidAutoService.serverDataListeners.add(scheduleCatalogUpdate);
    scheduleCatalogUpdate(delay: const Duration(seconds: 8));
  }

  Future<dynamic> _onCall(MethodCall call) async {
    final args = (call.arguments as Map?) ?? const {};
    try {
      switch (call.method) {
        case 'resolve':
          return await _resolve(SiriQuery.fromArgs(args));
        case 'play':
          return await _play(args);
        case 'control':
          return await _control(args);
      }
    } catch (e) {
      debugPrint('[Siri] ${call.method} failed: $e');
      return {'ok': false, 'status': 'none', 'items': const []};
    }
    return null;
  }

  // Resolving

  Future<Map<String, dynamic>> _resolve(SiriQuery q) async {
    debugPrint('[Siri] resolve name="${q.name}" artist="${q.artist}" type=${q.type} latest=${q.latest}');
    if (q.isResume) return _resumeTarget();
    await _ensureCatalogLoaded();
    var result = siriMatch(q, _catalog);
    if (result.status != 'ok' || result.score < 85 || result.viaSeries) {
      final found = await _searchServer(q)
          .timeout(const Duration(seconds: 5), onTimeout: () => const <SiriEntry>[]);
      if (found.isNotEmpty) {
        final again = siriMatch(q, _merge(_catalog, found));
        if (again.status != 'none' && (result.status == 'none' || again.score >= result.score)) {
          result = again;
        }
      }
    }
    if (result.status == 'none' && await AndroidAutoService().getApi() == null) {
      return {'status': 'signedOut', 'items': const []};
    }
    debugPrint('[Siri] resolve -> ${result.status}: ${result.items.map((e) => e.title).join(' | ')}');
    return {'status': result.status, 'items': result.items.map(_itemJson).toList()};
  }

  Map<String, dynamic> _itemJson(SiriEntry e) => {
        'id': e.id,
        'kind': e.kind,
        'title': e.title,
        'author': e.author,
        if (e.coverPath != null) 'coverPath': e.coverPath,
      };

  Future<Map<String, dynamic>> _resumeTarget() async {
    final player = AudioPlayerService();
    if (player.hasBook) {
      return {
        'status': 'ok',
        'items': [
          {'id': 'resume', 'kind': 'book', 'title': player.currentTitle ?? '', 'author': player.currentAuthor ?? ''},
        ],
      };
    }
    final prefs = await SharedPreferences.getInstance();
    final itemId = prefs.getString('widget_item_id');
    if (itemId == null) return {'status': 'none', 'items': const []};
    final episodeId = prefs.getString('widget_episode_id');
    final key = episodeId != null ? '$itemId-$episodeId' : itemId;
    if (HomeWidgetService.lastPlayedIsFinished(await ProgressSyncService().getLocal(key))) {
      return {'status': 'none', 'items': const []};
    }
    String? title, author;
    try {
      title = await HomeWidget.getWidgetData<String>('np_title');
      author = await HomeWidget.getWidgetData<String>('np_author');
    } catch (_) {}
    return {
      'status': 'ok',
      'items': [
        {'id': 'resume', 'kind': episodeId != null ? 'episode' : 'book', 'title': title ?? '', 'author': author ?? ''},
      ],
    };
  }

  List<SiriEntry> _merge(List<SiriEntry> known, List<SiriEntry> found) {
    final byId = {for (final e in known) e.id: e};
    for (final e in found) {
      final had = byId[e.id];
      byId[e.id] = had == null
          ? e
          : had.copyWith(series: had.series.isEmpty ? e.series : had.series);
    }
    return byId.values.toList();
  }

  Future<List<SiriEntry>> _searchServer(SiriQuery q) async {
    final text = (q.name?.trim().isNotEmpty == true ? q.name! : q.artist ?? '').trim();
    if (text.isEmpty) return const [];
    final api = await AndroidAutoService().getApi();
    if (api == null) return const [];
    final libraries = await _libraries(api);
    final wantBooks = q.type == 'book' || q.type == 'any';
    final wantPodcasts = q.type != 'book';
    final out = <SiriEntry>[];
    await Future.wait(libraries.where((l) => l.isPodcast ? wantPodcasts : wantBooks).map((lib) async {
      final res = await api.searchLibrary(lib.id, text, limit: 10);
      if (res == null) return;
      for (final key in ['book', 'podcast']) {
        for (final hit in (res[key] as List<dynamic>? ?? const [])) {
          final item = (hit is Map ? hit['libraryItem'] : null) as Map<String, dynamic>?;
          final e = item == null ? null : entryFromItem(item, libraryId: lib.id);
          if (e != null) out.add(e);
        }
      }
      for (final hit in (res['series'] as List<dynamic>? ?? const [])) {
        if (hit is! Map) continue;
        final series = hit['series'] as Map<String, dynamic>?;
        final id = series?['id'] as String?;
        final name = series?['name'] as String?;
        if (id != null && name != null && name.isNotEmpty) {
          out.add(SiriEntry(kind: 'series', itemId: id, libraryId: lib.id, title: name));
        }
        for (final b in (hit['books'] as List<dynamic>? ?? const [])) {
          final e = b is Map<String, dynamic> ? entryFromItem(b, libraryId: lib.id) : null;
          if (e != null) out.add(e);
        }
      }
    }));
    debugPrint('[Siri] server search "$text" -> ${out.length} results');
    return _withProgress(out, api: api);
  }

  Future<List<AutoLibraryEntry>> _libraries(ApiService api) async {
    final known = AndroidAutoService().libraries;
    if (known.isNotEmpty) return known;
    final libs = await api.getLibraries();
    return [
      for (final l in libs.whereType<Map<String, dynamic>>())
        if (l['id'] is String)
          AutoLibraryEntry(
            id: l['id'] as String,
            name: l['name'] as String? ?? '',
            mediaType: l['mediaType'] as String? ?? 'book',
          ),
    ];
  }

  // Playing

  Future<Map<String, dynamic>> _play(Map<dynamic, dynamic> args) async {
    final id = args['id'] as String? ?? 'resume';
    final speed = (args['speed'] as num?)?.toDouble();
    final latest = args['latest'] == true;
    debugPrint('[Siri] play $id speed=$speed latest=$latest');
    final parts = id.split('|');
    String part(int i) => parts.length > i ? parts[i] : '';
    var ok = false;
    switch (parts.first) {
      case 'book':
        ok = await _playItem(part(1), null);
      case 'episode':
        ok = await _playItem(part(1), part(2).isEmpty ? null : part(2));
      case 'podcast':
        ok = await _playPodcast(part(1), latest: latest);
      case 'series':
        ok = await _playSeries(part(1), part(2));
      default:
        ok = await _resume();
    }
    final player = AudioPlayerService();
    if (ok && speed != null && speed > 0) {
      await player.setSpeed(speed.clamp(0.5, 5.0).toDouble());
    }
    debugPrint('[Siri] play $id -> ok=$ok "${player.currentTitle}"');
    return {'ok': ok, 'title': player.currentTitle ?? '', 'author': player.currentAuthor ?? ''};
  }

  Future<bool> _resume() async {
    final player = AudioPlayerService();
    if (player.hasBook) {
      if (!player.isPlaying) await player.play();
      return true;
    }
    await HomeWidgetService().resumeLastPlayedIfAvailable();
    return player.hasBook;
  }

  Future<bool> _playItem(String itemId, String? episodeId) async {
    if (itemId.isEmpty) return false;
    final player = AudioPlayerService();
    if (player.hasBook && player.currentItemId == itemId && player.currentEpisodeId == episodeId) {
      if (!player.isPlaying) await player.play();
      return true;
    }
    final handler = AudioPlayerService.handler;
    if (handler == null) return false;
    final key = episodeId == null ? itemId : '$itemId-$episodeId';
    await handler.playFromMediaId(AutoMediaIds.itemId(key));
    return player.currentItemId == itemId && player.currentEpisodeId == episodeId;
  }

  /// The episode the listener is partway through, or else the newest one
  /// not finished. "The latest episode of" always takes the newest.
  Future<bool> _playPodcast(String showId, {bool latest = false}) async {
    final api = await AndroidAutoService().getApi();
    if (api == null) return false;
    final item = await api.getLibraryItem(showId);
    final episodes = ((item?['media'] as Map<String, dynamic>?)?['episodes'] as List<dynamic>? ?? const [])
        .whereType<Map<String, dynamic>>()
        .toList();
    if (episodes.isEmpty) return false;
    int published(Map<String, dynamic> e) =>
        (e['publishedAt'] as num?)?.toInt() ?? (e['addedAt'] as num?)?.toInt() ?? 0;
    episodes.sort((a, b) => published(b).compareTo(published(a)));
    final progress = await _progressMap(api);
    Map<String, dynamic>? state(Map<String, dynamic> e) => progress['$showId-${e['id']}'];
    var pick = episodes.first;
    if (!latest) {
      final going = episodes.where((e) => _isGoing(state(e))).toList()
        ..sort((a, b) => _lastUpdate(state(b)).compareTo(_lastUpdate(state(a))));
      pick = going.isNotEmpty
          ? going.first
          : episodes.firstWhere((e) => state(e)?['isFinished'] != true, orElse: () => episodes.first);
    }
    final episodeId = pick['id'] as String?;
    if (episodeId == null) return false;
    return _playItem(showId, episodeId);
  }

  /// The book in the series the listener is on, or else the first unfinished.
  Future<bool> _playSeries(String seriesId, String libraryId) async {
    final api = await AndroidAutoService().getApi();
    if (api == null) return false;
    final books = (await api.getAllBooksBySeries(libraryId, seriesId)).whereType<Map<String, dynamic>>().toList();
    if (books.isEmpty) return false;
    final progress = await _progressMap(api);
    Map<String, dynamic>? state(Map<String, dynamic> b) => progress[b['id']];
    final going = books.where((b) => _isGoing(state(b))).toList()
      ..sort((a, b) => _lastUpdate(state(b)).compareTo(_lastUpdate(state(a))));
    final pick = going.isNotEmpty
        ? going.first
        : books.firstWhere((b) => state(b)?['isFinished'] != true, orElse: () => books.first);
    final id = pick['id'] as String?;
    return id != null && await _playItem(id, null);
  }

  static bool _isGoing(Map<String, dynamic>? p) =>
      p != null && p['isFinished'] != true && ((p['progress'] as num?) ?? 0) > 0;

  static int _lastUpdate(Map<String, dynamic>? p) => (p?['lastUpdate'] as num?)?.toInt() ?? 0;

  Future<Map<String, Map<String, dynamic>>> _progressMap(ApiService api) async {
    final at = _progressAt;
    if (at != null && DateTime.now().difference(at) < const Duration(minutes: 2)) return _progress;
    final list = await api.getAllProgress();
    if (list == null) return _progress;
    _progress = {
      for (final p in list)
        if (p['libraryItemId'] is String)
          (p['episodeId'] is String && (p['episodeId'] as String).isNotEmpty)
              ? '${p['libraryItemId']}-${p['episodeId']}'
              : p['libraryItemId'] as String: p,
    };
    _progressAt = DateTime.now();
    return _progress;
  }

  // App Shortcuts

  Future<Map<String, dynamic>> _control(Map<dynamic, dynamic> args) async {
    final action = args['action'] as String? ?? '';
    final player = AudioPlayerService();
    final handler = AudioPlayerService.handler;
    debugPrint('[Siri] control $action hasBook=${player.hasBook}');
    var ok = player.hasBook;
    switch (action) {
      case 'resume':
        ok = await _resume();
      case 'pause':
        if (ok) await player.pause();
      case 'skipBack':
        if (ok) await handler?.rewind();
      case 'skipForward':
        if (ok) await handler?.fastForward();
      case 'nextChapter':
        if (ok) await handler?.customAction('nextChapter');
      case 'previousChapter':
        if (ok) await handler?.customAction('previousChapter');
      case 'sleepMinutes':
        final minutes = (args['minutes'] as num?)?.toInt() ?? 0;
        ok = ok && minutes > 0;
        if (ok) SleepTimerService().setTimeSleep(Duration(minutes: minutes));
      case 'sleepChapterEnd':
        if (ok) SleepTimerService().setChapterSleep(1);
      case 'cancelSleep':
        ok = SleepTimerService().isActive;
        if (ok) SleepTimerService().cancelByUser();
      case 'bookmark':
        ok = ok && (await handler?.customAction('bookmark')) == true;
      case 'status':
        break;
      default:
        ok = false;
    }
    final position = player.position.inSeconds;
    final duration = player.totalDuration.round();
    return {
      'ok': ok,
      'hasBook': player.hasBook,
      'playing': player.isPlaying,
      'title': player.currentTitle ?? '',
      'author': player.currentAuthor ?? '',
      'chapter': player.currentChapter?['title'] as String? ?? '',
      'position': position,
      'duration': duration,
      'speed': player.speed,
    };
  }

  // What Siri learns

  void _onPlayerChanged() {
    final player = AudioPlayerService();
    if (!player.hasBook || !player.isPlaying) return;
    final key = '${player.currentItemId}|${player.currentEpisodeId ?? ''}';
    if (key == _lastPlayKey) return;
    _lastPlayKey = key;
    unawaited(_donate(player));
    scheduleCatalogUpdate(delay: const Duration(seconds: 30));
  }

  Future<void> _donate(AudioPlayerService player) async {
    final itemId = player.currentItemId;
    if (itemId == null) return;
    final episodeId = player.currentEpisodeId;
    final key = episodeId == null ? itemId : '$itemId-$episodeId';
    final download = DownloadService().isDownloaded(key) ? DownloadService().getInfo(key) : null;
    final entry = SiriEntry(
      kind: episodeId == null ? 'book' : 'episode',
      itemId: itemId,
      episodeId: episodeId,
      title: player.currentTitle ?? '',
      author: player.currentAuthor ?? '',
      coverPath: download?.localCoverPath,
    );
    if (entry.title.isEmpty) return;
    try {
      await _channel.invokeMethod('donate', _itemJson(entry));
    } catch (e) {
      debugPrint('[Siri] donate failed: $e');
    }
  }

  // The list of books Siri can name

  void scheduleCatalogUpdate({Duration delay = const Duration(seconds: 5)}) {
    if (!_initialized) return;
    _catalogTimer?.cancel();
    _catalogTimer = Timer(delay, () => unawaited(_rebuildCatalog()));
  }

  Future<void> _ensureCatalogLoaded() async {
    if (_catalogLoaded) return;
    _catalogLoaded = true;
    if (_catalog.isNotEmpty) return;
    try {
      final file = await _catalogFile();
      if (file == null || !file.existsSync()) return;
      final data = jsonDecode(await file.readAsString()) as Map<String, dynamic>;
      _catalog = (data['entries'] as List<dynamic>? ?? const [])
          .whereType<Map<String, dynamic>>()
          .map(SiriEntry.fromJson)
          .toList();
      debugPrint('[Siri] loaded ${_catalog.length} entries from the last run');
    } catch (e) {
      debugPrint('[Siri] catalog read failed: $e');
    }
  }

  Future<File?> _catalogFile() async {
    try {
      final dir = await _widgetChannel.invokeMethod<String>('getGroupContainerPath');
      if (dir == null) return null;
      return File('$dir/$catalogFileName');
    } catch (_) {
      return null;
    }
  }

  Future<void> _rebuildCatalog() async {
    if (_rebuilding) return;
    _rebuilding = true;
    if (!_askedAutoRefresh) {
      // On iOS the car's browse lists only fill when CarPlay connects; one
      // refresh a launch gives Siri every library's Continue and Recent rows.
      // It calls back through serverDataListeners when the server answers.
      _askedAutoRefresh = true;
      unawaited(AndroidAutoService().refresh());
    }
    try {
      final entries = <String, SiriEntry>{};
      void add(SiriEntry? e) {
        if (e == null || e.title.isEmpty) return;
        final had = entries[e.id];
        if (had == null) {
          entries[e.id] = e;
        } else if (had.series.isEmpty && e.series.isNotEmpty) {
          entries[e.id] = had.copyWith(series: e.series);
        }
      }

      for (final item in libraryItems?.call() ?? const <Map<String, dynamic>>[]) {
        if (item['books'] is List && item['name'] is String) {
          final books = (item['books'] as List).whereType<Map<String, dynamic>>().toList();
          final libraryId = item['libraryId'] as String? ??
              (books.isNotEmpty ? books.first['libraryId'] as String? : null);
          if (item['id'] is String && libraryId != null) {
            add(SiriEntry(kind: 'series', itemId: item['id'] as String, libraryId: libraryId, title: item['name'] as String));
          }
          for (final b in books) {
            add(entryFromItem(b));
          }
          continue;
        }
        add(entryFromItem(item));
        add(_episodeFromItem(item));
      }
      final auto = AndroidAutoService();
      for (final e in [...auto.continueListening, ...auto.recentlyAdded, ...auto.downloaded]) {
        add(_entryFromAuto(e));
      }
      final downloads = DownloadService();
      final downloadedKeys = <String>{};
      for (final d in downloads.downloadedItems) {
        downloadedKeys.add(d.itemId);
        add(_entryFromDownload(d));
      }

      var list = entries.values.map((e) {
        final key = e.episodeId == null ? e.itemId : '${e.itemId}-${e.episodeId}';
        if (!downloadedKeys.contains(key)) return e;
        final info = downloads.getInfo(key);
        return e.copyWith(downloaded: true, coverPath: e.coverPath ?? info.localCoverPath);
      }).toList();
      final api = await auto.getApi();
      list = await _withProgress(list, api: api);
      _catalog = list;
      _catalogLoaded = true;
      await _publishCatalog(list);
    } catch (e) {
      debugPrint('[Siri] catalog rebuild failed: $e');
    } finally {
      _rebuilding = false;
    }
  }

  Future<List<SiriEntry>> _withProgress(List<SiriEntry> list, {ApiService? api}) async {
    final progress = api == null ? _progress : await _progressMap(api);
    if (progress.isEmpty) return list;
    final showLatest = <String, Map<String, dynamic>>{};
    for (final p in progress.values) {
      if (p['episodeId'] is! String) continue;
      final show = p['libraryItemId'] as String;
      if (_lastUpdate(p) > _lastUpdate(showLatest[show])) showLatest[show] = p;
    }
    return list.map((e) {
      final key = e.kind == 'episode' ? '${e.itemId}-${e.episodeId}' : e.itemId;
      final p = e.kind == 'podcast' ? showLatest[e.itemId] : progress[key];
      if (p == null) return e;
      return e.copyWith(
        progress: ((p['progress'] as num?) ?? 0).toDouble(),
        finished: e.kind != 'podcast' && p['isFinished'] == true,
        lastPlayed: _lastUpdate(p),
      );
    }).toList();
  }

  Future<void> _publishCatalog(List<SiriEntry> list) async {
    final ordered = [...list]..sort((a, b) {
        final r = (b.inProgress ? 1 : 0).compareTo(a.inProgress ? 1 : 0);
        if (r != 0) return r;
        return b.lastPlayed.compareTo(a.lastPlayed);
      });
    final file = await _catalogFile();
    if (file != null) {
      try {
        await file.writeAsString(jsonEncode({
          'updatedAt': DateTime.now().millisecondsSinceEpoch,
          'entries': ordered.take(20000).map((e) => e.toJson()).toList(),
        }));
      } catch (e) {
        debugPrint('[Siri] catalog write failed: $e');
      }
    }
    List<String> unique(Iterable<String> values, int cap) {
      final seen = <String>{};
      final out = <String>[];
      for (final v in values) {
        final t = v.trim();
        if (t.isEmpty || !seen.add(t.toLowerCase())) continue;
        out.add(t);
        if (out.length == cap) break;
      }
      return out;
    }

    final books = ordered.where((e) => e.kind == 'book');
    final titles = unique(books.map((e) => e.title), 500);
    final authors = unique(books.expand((e) => e.author.split(RegExp(r',|&'))), 200);
    final series = unique(ordered.expand((e) => e.kind == 'series' ? [e.title] : e.series), 200);
    final shows = unique(ordered.where((e) => e.kind == 'podcast').map((e) => e.title), 100);
    final upNext = ordered.where((e) => e.inProgress && e.kind != 'series').take(5).map(_itemJson).toList();
    debugPrint('[Siri] catalog ${ordered.length} entries, ${titles.length} titles, '
        '${authors.length} authors, ${shows.length} shows');
    try {
      await _channel.invokeMethod('catalogUpdated', {
        'count': ordered.length,
        'titles': [...titles, ...series],
        'authors': authors,
        'shows': shows,
        'upNext': upNext,
      });
    } catch (e) {
      debugPrint('[Siri] catalogUpdated failed: $e');
    }
    await _maybeAskForSiri(ordered.isNotEmpty);
  }

  // Siri permission

  Future<String> authorizationStatus() async {
    if (!Platform.isIOS) return 'unsupported';
    try {
      return await _channel.invokeMethod<String>('authorizationStatus') ?? 'notDetermined';
    } catch (_) {
      return 'notDetermined';
    }
  }

  Future<String> requestAuthorization() async {
    if (!Platform.isIOS) return 'unsupported';
    try {
      final status = await _channel.invokeMethod<String>('requestAuthorization') ?? 'notDetermined';
      if (status == 'authorized') scheduleCatalogUpdate(delay: Duration.zero);
      return status;
    } catch (_) {
      return 'notDetermined';
    }
  }

  Future<void> openSystemSettings() async {
    try {
      await _channel.invokeMethod('openSettings');
    } catch (_) {}
  }

  /// One prompt, the first time there is something to ask Siri about and the
  /// listener is looking at the app. Settings has the switch after that.
  Future<void> _maybeAskForSiri(bool hasBooks) async {
    if (!hasBooks) return;
    final prefs = await SharedPreferences.getInstance();
    if (prefs.getBool('siri_auth_asked') == true) return;
    if (WidgetsBinding.instance.lifecycleState != AppLifecycleState.resumed) return;
    if (await authorizationStatus() != 'notDetermined') {
      await prefs.setBool('siri_auth_asked', true);
      return;
    }
    await prefs.setBool('siri_auth_asked', true);
    await requestAuthorization();
  }

  // Item shapes

  /// A book or podcast show from an Audiobookshelf-shaped library item.
  static SiriEntry? entryFromItem(Map<String, dynamic> item, {String? libraryId}) {
    final id = item['id'] as String?;
    final media = item['media'] as Map<String, dynamic>?;
    final meta = media?['metadata'] as Map<String, dynamic>?;
    final title = meta?['title'] as String?;
    if (id == null || media == null || title == null || title.trim().isEmpty) return null;
    final podcast = item['mediaType'] == 'podcast';
    if (!podcast && !_hasAudio(media)) return null;
    return SiriEntry(
      kind: podcast ? 'podcast' : 'book',
      itemId: id,
      libraryId: item['libraryId'] as String? ?? libraryId,
      title: title.trim(),
      author: podcast ? (meta?['author'] as String? ?? '') : _authorOf(meta!),
      series: podcast ? const [] : _seriesOf(meta!),
    );
  }

  static SiriEntry? _episodeFromItem(Map<String, dynamic> item) {
    final ep = item['recentEpisode'] as Map<String, dynamic>?;
    final id = item['id'] as String?;
    final episodeId = ep?['id'] as String?;
    final title = ep?['title'] as String?;
    if (id == null || episodeId == null || title == null || title.isEmpty) return null;
    final show = ((item['media'] as Map<String, dynamic>?)?['metadata'] as Map<String, dynamic>?)?['title'] as String?;
    return SiriEntry(
      kind: 'episode',
      itemId: id,
      episodeId: episodeId,
      libraryId: item['libraryId'] as String?,
      title: title,
      author: show ?? '',
    );
  }

  static bool _hasAudio(Map<String, dynamic> media) {
    if (media['narration'] != null) return true;
    for (final k in ['numTracks', 'numAudioFiles']) {
      final n = media[k];
      if (n is num) return n > 0;
    }
    for (final k in ['tracks', 'audioFiles']) {
      final l = media[k];
      if (l is List) return l.isNotEmpty;
    }
    final d = media['duration'];
    if (d is num) return d > 0;
    return true;
  }

  static String _authorOf(Map<String, dynamic> meta) {
    final name = meta['authorName'] as String?;
    if (name != null && name.isNotEmpty) return name;
    return (meta['authors'] as List<dynamic>? ?? const [])
        .map((a) => a is Map ? a['name'] as String? ?? '' : '$a')
        .where((n) => n.isNotEmpty)
        .join(', ');
  }

  static final _seriesNumber = RegExp(r'\s+#\s*[\d.]+.*$');

  static List<String> _seriesOf(Map<String, dynamic> meta) {
    final list = meta['series'];
    if (list is List) {
      final names = list
          .map((s) => s is Map ? s['name'] as String? ?? '' : '')
          .where((n) => n.isNotEmpty)
          .toList();
      if (names.isNotEmpty) return names;
    }
    final joined = meta['seriesName'] as String?;
    if (joined == null || joined.isEmpty) return const [];
    return joined
        .split(', ')
        .map((s) => s.replaceFirst(_seriesNumber, '').trim())
        .where((s) => s.isNotEmpty)
        .toList();
  }

  static SiriEntry? _entryFromAuto(AutoBookEntry e) {
    if (e.title.isEmpty) return null;
    if (e.mediaType == 'podcast' && e.episodeId != null) {
      final show = e.showId ?? (e.id.length > 36 ? e.id.substring(0, 36) : e.id);
      return SiriEntry(
        kind: 'episode',
        itemId: show,
        episodeId: e.episodeId,
        libraryId: e.libraryId,
        title: e.title,
        author: e.author,
      );
    }
    return SiriEntry(
      kind: e.mediaType == 'podcast' ? 'podcast' : 'book',
      itemId: e.id,
      libraryId: e.libraryId,
      title: e.title,
      author: e.author,
    );
  }

  static SiriEntry? _entryFromDownload(DownloadInfo d) {
    final title = d.title;
    if (title == null || title.isEmpty) return null;
    final key = d.itemId;
    final episode = key.length > 37 && key[36] == '-';
    return SiriEntry(
      kind: episode ? 'episode' : 'book',
      itemId: episode ? key.substring(0, 36) : key,
      episodeId: episode ? key.substring(37) : null,
      libraryId: d.libraryId,
      title: title,
      author: d.author ?? '',
      downloaded: true,
      coverPath: d.localCoverPath,
    );
  }
}