Skip to content

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.dart
index 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.dart
index 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.dart
index 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 yet
if (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 item
var itemId = _player.currentItemId;
if (itemId == null) {
diff --git a/lib/screens/library_screen.dart b/lib/screens/library_screen.dart
index 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.dart
index 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.dart
index 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.dart
index 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 immediately
try {
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.dart
index 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.dart
index 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 requests
Uri? 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 request
String? 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 response
if (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.yaml
index 0ffaf5b2..652759d2 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,7 +1,7 @@
name: absorb
description: An Audiobookshelf Client
publish_to: 'none'
-version: 1.8.35+58
+version: 1.8.36+59
environment:
sdk: '>=3.1.0 <4.0.0'