A cross platform Audiobookshelf client for Android and iOS
Dart
Add iOS streaming cache, fix proxy crash and cache clear crash
Nathan Poulson8af7cdd6ba37
diff --git a/lib/providers/auth_provider.dart b/lib/providers/auth_provider.dartindex 77db64ab..bae33e34 100644--- a/lib/providers/auth_provider.dart+++ b/lib/providers/auth_provider.dart@@ -134,6 +134,8 @@ class AuthProvider extends ChangeNotifier {if (me != null) {_userJson = me;_userId = me['id'] as String?;+ } else {+ debugPrint('[Auth] /me returned null (token may be invalid)');}debugPrint('[Auth] /me done (${sw.elapsedMilliseconds}ms)');} catch (_) {}diff --git a/lib/providers/library_provider.dart b/lib/providers/library_provider.dartindex 9e37d1a3..fa5dfe38 100644--- a/lib/providers/library_provider.dart+++ b/lib/providers/library_provider.dart@@ -1063,6 +1063,7 @@ class LibraryProvider extends ChangeNotifier {try {_libraries = await _api!.getLibraries();+ debugPrint('[Library] loadLibraries: got ${_libraries.length} libraries');if (_libraries.isNotEmpty) {// Prefer last user-selected library, then server default, then first book library@@ -1399,13 +1400,13 @@ class LibraryProvider extends ChangeNotifier {debugPrint('[Progress] Keeping local finished (no server data): $key');return false;});- _localProgressOverrides.removeWhere((key, _) {- if (!_locallyFinishedItems.contains(key)) {- debugPrint('[Progress] Clearing override for $key');- return true;- }- return false;- });+ final overridesBefore = _localProgressOverrides.length;+ _localProgressOverrides.removeWhere((key, _) =>+ !_locallyFinishedItems.contains(key));+ final cleared = overridesBefore - _localProgressOverrides.length;+ if (cleared > 0) {+ debugPrint('[Progress] Cleared $cleared overrides');+ }}}} catch (_) {}diff --git a/lib/screens/app_shell.dart b/lib/screens/app_shell.dartindex d3955eef..2e47c5da 100644--- a/lib/screens/app_shell.dart+++ b/lib/screens/app_shell.dart@@ -164,6 +164,7 @@ class _AppShellState extends State<AppShell> with WidgetsBindingObserver, Ticker}void _onLibraryChanged() {+ if (!mounted) return;// Once absorbing list loads, derive cover scheme if we haven't yetif (coverSchemeNotifier.value == null) {_deriveCoverScheme();@@ -172,6 +173,7 @@ class _AppShellState extends State<AppShell> with WidgetsBindingObserver, Ticker/// Attempt to derive cover scheme. Returns true if successful.bool _deriveCoverScheme() {+ if (!mounted) return false;// Use player's current item, or fall back to absorbing list's first itemvar itemId = _player.currentItemId;if (itemId == null) {diff --git a/lib/screens/library_screen.dart b/lib/screens/library_screen.dartindex 66ae5c5c..2b187f00 100644--- a/lib/screens/library_screen.dart+++ b/lib/screens/library_screen.dart@@ -316,6 +316,7 @@ class LibraryScreenState extends State<LibraryScreen> with TickerProviderStateMi}void _onLibraryChanged() {+ if (!mounted) return;final lib = context.read<LibraryProvider>();if (lib.selectedLibraryId != null && _items.isEmpty && !_isLoadingPage) {lib.removeListener(_onLibraryChanged);diff --git a/lib/screens/settings_screen.dart b/lib/screens/settings_screen.dartindex dd1ebb91..2b087258 100644--- a/lib/screens/settings_screen.dart+++ b/lib/screens/settings_screen.dart@@ -1577,7 +1577,9 @@ class _SettingsScreenState extends State<SettingsScreen> {icon: const Icon(Icons.delete_sweep_outlined, size: 18),label: const Text('Clear cache'),onPressed: () async {- await AudioPlayer.clearStreamingCache();+ try {+ await AudioPlayer.clearStreamingCache();+ } catch (_) {}if (mounted) {ScaffoldMessenger.of(context).showSnackBar(const SnackBar(content: Text('Streaming cache cleared')));diff --git a/lib/services/api_service.dart b/lib/services/api_service.dartindex 911620f7..6aef856b 100644--- a/lib/services/api_service.dart+++ b/lib/services/api_service.dart@@ -130,10 +130,14 @@ class ApiService {if (response.statusCode == 200) {final data = jsonDecode(response.body);- return (data['libraries'] as List?) ?? [];+ final libs = (data['libraries'] as List?) ?? [];+ debugPrint('[API] getLibraries: ${libs.length} libraries');+ return libs;+ } else {+ debugPrint('[API] getLibraries failed: ${response.statusCode}');}} catch (e) {- // ignore+ debugPrint('[API] getLibraries error: $e');}return [];}@@ -228,7 +232,10 @@ class ApiService {if (response.statusCode == 200) {return jsonDecode(response.body) as Map<String, dynamic>;}- } catch (_) {}+ debugPrint('[API] getMe failed: ${response.statusCode}');+ } catch (e) {+ debugPrint('[API] getMe error: $e');+ }return null;}diff --git a/lib/services/audio_player_service.dart b/lib/services/audio_player_service.dartindex 1294b736..524226ae 100644--- a/lib/services/audio_player_service.dart+++ b/lib/services/audio_player_service.dart@@ -239,7 +239,7 @@ class PlayerSettings {static Future<void> setStreamingCacheSizeMb(int value) async {debugPrint('[Settings] Streaming cache set to: $value MB');await _set('streamingCacheSizeMb', value);- // Reconfigure the native cache immediately+ // Reconfigure the cache immediatelytry {await AudioPlayer.configureStreamingCache(value);debugPrint('[Settings] Streaming cache configured on native side');diff --git a/lib/services/log_service.dart b/lib/services/log_service.dartindex 613b68ca..653abe47 100644--- a/lib/services/log_service.dart+++ b/lib/services/log_service.dart@@ -61,8 +61,9 @@ class LogService {_originalDebugPrint?.call(message, wrapWidth: wrapWidth);if (_logFile != null && message != null) {final ts = DateTime.now().toIso8601String();+ final sanitized = _sanitize(message);_logFile!.writeAsStringSync(- '[$ts] $message\n',+ '[$ts] $sanitized\n',mode: FileMode.append,);_maybeRotate();@@ -73,8 +74,9 @@ class LogService {void log(String message) {if (_logFile != null) {final ts = DateTime.now().toIso8601String();+ final sanitized = _sanitize(message);_logFile!.writeAsStringSync(- '[$ts] $message\n',+ '[$ts] $sanitized\n',mode: FileMode.append,);_maybeRotate();@@ -133,6 +135,25 @@ class LogService {return buf.toString();}+ /// Params whose values should be masked in logged URLs.+ static final _sensitiveParamPattern = RegExp(+ r'token|code|secret|password|key|verifier|challenge|state|cookie|auth|bearer',+ caseSensitive: false,+ );++ /// Sanitize a single log message: mask URLs, sensitive query params, and+ /// bare key=value pairs that look like credentials.+ static String _sanitize(String message) {+ var result = _sanitizeUrls(message);+ // Mask standalone sensitive key=value pairs not inside URLs+ // (e.g. "token=abc123" in non-URL context)+ result = result.replaceAllMapped(+ RegExp(r'(token|secret|password|authorization|bearer|\w*key)\s*[=:]\s*(?!null\b|\*\*\*|true\b|false\b)\S+', caseSensitive: false),+ (m) => '${m.group(1)}=***',+ );+ return result;+ }+/// Sanitize URLs in log content, replacing server hosts with a connection/// type label (e.g. [local-ip], [tailscale], [reverse-proxy]) while keeping/// API paths intact for debugging.@@ -160,7 +181,8 @@ class LogService {label = '[remote-http]';}final path = uri.path.isNotEmpty ? uri.path : '';- return '$label$path';+ final query = _maskQuery(uri);+ return '$label$path$query';} catch (_) {return '[url-redacted]';}@@ -175,6 +197,18 @@ class LogService {return result;}+ /// Keep query param names but mask values of sensitive ones.+ static String _maskQuery(Uri uri) {+ if (uri.queryParameters.isEmpty) return '';+ final masked = uri.queryParameters.entries.map((e) {+ if (_sensitiveParamPattern.hasMatch(e.key)) {+ return '${e.key}=***';+ }+ return '${e.key}=${e.value}';+ }).join('&');+ return '?$masked';+ }+static bool _isPrivateIp(String host) {final parts = host.split('.');if (parts.length != 4) return false;diff --git a/packages/just_audio/lib/just_audio.dart b/packages/just_audio/lib/just_audio.dartindex f4c454ea..6abae1d4 100644--- a/packages/just_audio/lib/just_audio.dart+++ b/packages/just_audio/lib/just_audio.dart@@ -58,15 +58,28 @@ class AudioPlayer {static const MethodChannel _mainChannel =MethodChannel('com.ryanheise.just_audio.methods');- /// Configure the Android streaming disk cache.+ /// Dart-level streaming disk cache (used on platforms without native cache).+ static final _dartStreamingCache = _StreamingDiskCache();++ /// Configure the streaming disk cache./// [sizeMb] = 0 disables the cache. Values > 0 enable LRU caching.+ /// On Android this configures ExoPlayer's native cache; on other platforms+ /// a Dart-level disk cache is used instead.static Future<void> configureStreamingCache(int sizeMb) async {- await _mainChannel.invokeMethod('configureStreamingCache', {'sizeMb': sizeMb});+ if (Platform.isAndroid) {+ await _mainChannel.invokeMethod('configureStreamingCache', {'sizeMb': sizeMb});+ } else {+ await _dartStreamingCache.configure(sizeMb);+ }}/// Clear all cached streaming data without disabling the cache.static Future<void> clearStreamingCache() async {- await _mainChannel.invokeMethod('clearStreamingCache');+ if (Platform.isAndroid) {+ await _mainChannel.invokeMethod('clearStreamingCache');+ } else {+ await _dartStreamingCache.clear();+ }}/// The user agent to set on all HTTP requests.@@ -3370,7 +3383,27 @@ _ProxyHandler _proxyHandlerForUri(// Keep redirected [Uri] to speed-up requestsUri? redirectedUri;Future<void> handler(_ProxyHttpServer server, HttpRequest request) async {+ // ── Dart streaming disk cache ──+ final cache = AudioPlayer._dartStreamingCache;+ if (cache.isEnabled) {+ final cachedFile = cache.getCachedFile(uri);+ if (cachedFile != null) {+ debugPrint('[StreamCache] HIT ${uri.path} (${cachedFile.lengthSync()} bytes)');+ await _serveCachedFile(+ request, cachedFile, cache.getCachedHeaders(uri));+ return;+ }+ }+final client = _createHttpClient(userAgent: userAgent);+ IOSink? cacheWriter;+ int bytesWritten = 0;+ final isRangeRequest =+ request.headers[HttpHeaders.rangeHeader]?.isNotEmpty == true;+ if (cache.isEnabled && !isRangeRequest) {+ cacheWriter = cache.createWriter(uri);+ }+// Try to make normal requestString? host;try {@@ -3388,18 +3421,33 @@ _ProxyHandler _proxyHandlerForUri(}request.response.headers.clear();+ final responseHeaders = <String, String>{};originResponse.headers.forEach((name, value) {final filteredValue = value.map((e) => e.replaceAll(RegExp(r'[^\x09\x20-\x7F]'), '?')).toList();request.response.headers.set(name, filteredValue);+ responseHeaders[name] = filteredValue.join(', ');});request.response.statusCode = originResponse.statusCode;+ // Only cache successful full responses+ if (cacheWriter != null && originResponse.statusCode != 200) {+ try { await cacheWriter.close(); } catch (_) {}+ cache.removeIncomplete(uri);+ cacheWriter = null;+ }+// Send responseif (headers != null && request.uri.path.toLowerCase().endsWith('.m3u8') ||['application/x-mpegURL', 'application/vnd.apple.mpegurl'].contains(request.headers.value(HttpHeaders.contentTypeHeader))) {+ // Don't cache playlist files+ if (cacheWriter != null) {+ try { await cacheWriter.close(); } catch (_) {}+ cache.removeIncomplete(uri);+ cacheWriter = null;+ }// If this is an m3u8 file with headers, prepare the nested URIs.// TODO: Handle other playlist formats similarly?final m3u8 = await originResponse.transform(utf8.decoder).join();@@ -3436,6 +3484,18 @@ _ProxyHandler _proxyHandlerForUri(if (done) break;request.response.add(chunk);await request.response.flush();+ if (cacheWriter != null) {+ cacheWriter.add(chunk);+ bytesWritten += chunk.length;+ }+ }+ // Finalize cache only if we got the complete response+ if (cacheWriter != null && !done) {+ await cacheWriter.flush();+ await cacheWriter.close();+ cache.markComplete(uri, bytesWritten, headers: responseHeaders);+ cacheWriter = null;+ debugPrint('[StreamCache] STORED ${uri.path} ($bytesWritten bytes)');}}await request.response.flush();@@ -3446,8 +3506,14 @@ _ProxyHandler _proxyHandlerForUri(// Try parsing HTTP 0.9 response//request.response.headers.clear();final socket = await Socket.connect(uri.host, uri.port);- final clientSocket =- await request.response.detachSocket(writeHeaders: false);+ Socket clientSocket;+ try {+ clientSocket =+ await request.response.detachSocket(writeHeaders: false);+ } catch (_) {+ socket.close();+ return;+ }final done = Completer<dynamic>();socket.listen(clientSocket.add,@@ -3479,6 +3545,12 @@ _ProxyHandler _proxyHandlerForUri(await socket.flush();await done.future;}+ } finally {+ // Clean up incomplete cache entry on any failure+ if (cacheWriter != null) {+ try { await cacheWriter.close(); } catch (_) {}+ cache.removeIncomplete(uri);+ }}}@@ -4093,3 +4165,264 @@ HttpClient _createHttpClient({String? userAgent}) {}return client;}++// ── Dart-level streaming disk cache (used on iOS/macOS where no native+// ExoPlayer cache exists) ──────────────────────────────────────────────++/// Serves a fully-cached audio file from disk, supporting Range requests.+Future<void> _serveCachedFile(HttpRequest request, File cachedFile,+ Map<String, String>? storedHeaders) async {+ final fileLength = cachedFile.lengthSync();+ final rangeHeader = request.headers[HttpHeaders.rangeHeader];++ int start = 0;+ int end = fileLength - 1;++ // Copy original response headers if we stored them+ request.response.headers.clear();+ if (storedHeaders != null) {+ storedHeaders.forEach((name, value) {+ // Skip content-length / content-range — we'll set our own+ final lower = name.toLowerCase();+ if (lower == 'content-length' ||+ lower == 'content-range' ||+ lower == 'transfer-encoding') return;+ try {+ request.response.headers.set(name, value);+ } catch (_) {}+ });+ }+ request.response.headers.set(HttpHeaders.acceptRangesHeader, 'bytes');+ request.response.headers.set(HttpHeaders.contentLengthHeader, fileLength);++ if (rangeHeader != null && rangeHeader.isNotEmpty) {+ final match =+ RegExp(r'bytes=(\d*)-(\d*)').firstMatch(rangeHeader.first);+ if (match != null) {+ if (match.group(1)!.isNotEmpty) start = int.parse(match.group(1)!);+ if (match.group(2)!.isNotEmpty) end = int.parse(match.group(2)!);+ if (end >= fileLength) end = fileLength - 1;+ request.response.statusCode = HttpStatus.partialContent;+ request.response.headers+ .set(HttpHeaders.contentRangeHeader, 'bytes $start-$end/$fileLength');+ request.response.headers+ .set(HttpHeaders.contentLengthHeader, end - start + 1);+ }+ }++ request.response.bufferOutput = false;++ final raf = cachedFile.openSync();+ try {+ raf.setPositionSync(start);+ var remaining = end - start + 1;+ while (remaining > 0) {+ final chunkSize = remaining > 65536 ? 65536 : remaining;+ final chunk = raf.readSync(chunkSize);+ if (chunk.isEmpty) break;+ request.response.add(chunk);+ remaining -= chunk.length;+ }+ await request.response.flush();+ await request.response.close();+ } finally {+ raf.closeSync();+ }+}++/// Simple LRU streaming disk cache.+///+/// Audio data is written to files keyed by a hash of the request URI path.+/// A JSON manifest tracks size and last-access time for LRU eviction.+class _StreamingDiskCache {+ int _maxSizeBytes = 0;+ Directory? _cacheDir;+ File? _manifestFile;+ Map<String, _CacheEntry> _entries = {};+ bool _manifestDirty = false;++ bool get isEnabled => _maxSizeBytes > 0 && _cacheDir != null;++ Future<void> configure(int sizeMb) async {+ _maxSizeBytes = sizeMb * 1024 * 1024;+ if (sizeMb <= 0) {+ _maxSizeBytes = 0;+ return;+ }+ final appDir = await getTemporaryDirectory();+ _cacheDir = Directory(p.join(appDir.path, 'just_audio_streaming_cache'));+ if (!_cacheDir!.existsSync()) {+ _cacheDir!.createSync(recursive: true);+ }+ _manifestFile = File(p.join(_cacheDir!.path, '_manifest.json'));+ await _loadManifest();+ }++ Future<void> clear() async {+ if (_cacheDir != null && _cacheDir!.existsSync()) {+ _cacheDir!.deleteSync(recursive: true);+ _cacheDir!.createSync(recursive: true);+ }+ _entries.clear();+ await _saveManifest();+ }++ Future<void> release() async {+ _maxSizeBytes = 0;+ _entries.clear();+ _cacheDir = null;+ _manifestFile = null;+ }++ /// Deterministic cache key from a URI (uses path only so token/host changes+ /// don't invalidate the cache).+ String _keyForUri(Uri uri) {+ final bytes = utf8.encode(uri.path);+ return md5.convert(bytes).toString();+ }++ /// Returns the cached file for [uri] if it exists and is complete.+ File? getCachedFile(Uri uri) {+ if (!isEnabled) return null;+ final key = _keyForUri(uri);+ final entry = _entries[key];+ if (entry == null || !entry.complete) return null;+ final file = File(p.join(_cacheDir!.path, key));+ if (!file.existsSync()) {+ _entries.remove(key);+ _scheduleSave();+ return null;+ }+ entry.lastAccess = DateTime.now().millisecondsSinceEpoch;+ _scheduleSave();+ return file;+ }++ /// Returns stored response headers for a cached [uri], or null.+ Map<String, String>? getCachedHeaders(Uri uri) {+ final entry = _entries[_keyForUri(uri)];+ return entry?.headers;+ }++ /// Open a cache file writer for [uri]. Returns null if caching is disabled.+ IOSink? createWriter(Uri uri) {+ if (!isEnabled) return null;+ final key = _keyForUri(uri);+ // Don't overwrite a complete entry+ if (_entries[key]?.complete == true) return null;+ final file = File(p.join(_cacheDir!.path, key));+ _entries[key] = _CacheEntry(+ size: 0,+ lastAccess: DateTime.now().millisecondsSinceEpoch,+ complete: false,+ );+ return file.openWrite();+ }++ /// Mark [uri] as fully cached with the given byte size and response headers.+ void markComplete(Uri uri, int size, {Map<String, String>? headers}) {+ final key = _keyForUri(uri);+ final entry = _entries[key];+ if (entry != null) {+ entry.size = size;+ entry.complete = true;+ entry.headers = headers;+ _scheduleSave();+ _evictIfNeeded();+ }+ }++ /// Remove an incomplete cache entry (e.g. after a failed download).+ void removeIncomplete(Uri uri) {+ final key = _keyForUri(uri);+ final entry = _entries[key];+ if (entry != null && !entry.complete) {+ _entries.remove(key);+ final file = File(p.join(_cacheDir!.path, key));+ try {+ file.deleteSync();+ } catch (_) {}+ _scheduleSave();+ }+ }++ void _evictIfNeeded() {+ var totalSize = _entries.values.fold<int>(0, (sum, e) => sum + e.size);+ if (totalSize <= _maxSizeBytes) return;++ final sorted = _entries.entries.toList()+ ..sort((a, b) => a.value.lastAccess.compareTo(b.value.lastAccess));++ for (final entry in sorted) {+ if (totalSize <= _maxSizeBytes) break;+ final file = File(p.join(_cacheDir!.path, entry.key));+ try {+ file.deleteSync();+ } catch (_) {}+ totalSize -= entry.value.size;+ _entries.remove(entry.key);+ }+ _scheduleSave();+ }++ // ── Manifest persistence ──++ Future<void> _loadManifest() async {+ if (_manifestFile == null || !_manifestFile!.existsSync()) return;+ try {+ final raw =+ jsonDecode(await _manifestFile!.readAsString()) as Map<String, dynamic>;+ _entries = raw.map((k, v) =>+ MapEntry(k, _CacheEntry.fromJson(v as Map<String, dynamic>)));+ } catch (_) {+ _entries = {};+ }+ }++ Timer? _saveTimer;+ void _scheduleSave() {+ _manifestDirty = true;+ _saveTimer?.cancel();+ _saveTimer = Timer(const Duration(seconds: 2), () async {+ if (_manifestDirty) await _saveManifest();+ });+ }++ Future<void> _saveManifest() async {+ _manifestDirty = false;+ if (_manifestFile == null) return;+ try {+ await _manifestFile!+ .writeAsString(jsonEncode(_entries.map((k, v) => MapEntry(k, v.toJson()))));+ } catch (_) {}+ }+}++class _CacheEntry {+ int size;+ int lastAccess;+ bool complete;+ Map<String, String>? headers;++ _CacheEntry({+ required this.size,+ required this.lastAccess,+ required this.complete,+ this.headers,+ });++ factory _CacheEntry.fromJson(Map<String, dynamic> json) => _CacheEntry(+ size: json['size'] as int? ?? 0,+ lastAccess: json['lastAccess'] as int? ?? 0,+ complete: json['complete'] as bool? ?? false,+ headers: (json['headers'] as Map<String, dynamic>?)+ ?.map((k, v) => MapEntry(k, v as String)),+ );++ Map<String, dynamic> toJson() => {+ 'size': size,+ 'lastAccess': lastAccess,+ 'complete': complete,+ if (headers != null) 'headers': headers,+ };+}diff --git a/pubspec.yaml b/pubspec.yamlindex 0ffaf5b2..652759d2 100644--- a/pubspec.yaml+++ b/pubspec.yaml@@ -1,7 +1,7 @@name: absorbdescription: An Audiobookshelf Clientpublish_to: 'none'-version: 1.8.35+58+version: 1.8.36+59environment:sdk: '>=3.1.0 <4.0.0'