mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-11-21 20:00:49 +01:00
fix(ios): preserve NAS streaming format hints and native errors
This commit is contained in:
1 parent
4dcedf80eb
commit
24f7d4c355
7 files changed
+272
-8
No files matched your search
@@ -646,7 +646,7 @@ class NetworkStorageService {
|
||||
if (virtualFor(host) case final virtual?) {
|
||||
return virtual.resolve(host, path);
|
||||
}
|
||||
await _readyConnection(host, path);
|
||||
final c = await _readyConnection(host, path);
|
||||
_server ??= HttpServer.bind(InternetAddress.loopbackIPv4, 0).then((server) {
|
||||
server.listen((request) => unawaited(_serve(request)));
|
||||
return server;
|
||||
@@ -658,7 +658,14 @@ class NetworkStorageService {
|
||||
_server = null;
|
||||
rethrow;
|
||||
}
|
||||
final token = newId();
|
||||
final name = _networkFileName(c, path);
|
||||
final dot = name.lastIndexOf('.');
|
||||
final suffix = dot < 0 ? '' : name.substring(dot + 1).toLowerCase();
|
||||
// AVPlayer needs a file-type hint even when a NAS serves generic bytes.
|
||||
// Keep names and credentials private behind the unguessable route.
|
||||
final token = RegExp(r'^[a-z0-9]{1,10}$').hasMatch(suffix)
|
||||
? '${newId()}.$suffix'
|
||||
: newId();
|
||||
while (_routes.length >= 256) {
|
||||
_routes.remove(_routes.keys.first);
|
||||
}
|
||||
@@ -1420,8 +1427,9 @@ class NetworkStorageService {
|
||||
request.response.statusCode = HttpStatus.notFound;
|
||||
return;
|
||||
}
|
||||
final c = await connection(route.id);
|
||||
read = await _openRead(
|
||||
await connection(route.id),
|
||||
c,
|
||||
route.path,
|
||||
method: request.method,
|
||||
range: request.headers.value(HttpHeaders.rangeHeader),
|
||||
@@ -1430,6 +1438,21 @@ class NetworkStorageService {
|
||||
? HttpStatus.badGateway
|
||||
: read.status;
|
||||
read.headers.forEach(request.response.headers.set);
|
||||
final mime = read.headers[HttpHeaders.contentTypeHeader]
|
||||
?.split(';')
|
||||
.first
|
||||
.trim()
|
||||
.toLowerCase();
|
||||
if (read.status >= 200 &&
|
||||
read.status < 300 &&
|
||||
(mime == null ||
|
||||
mime == 'application/octet-stream' ||
|
||||
mime == 'binary/octet-stream')) {
|
||||
request.response.headers.set(
|
||||
HttpHeaders.contentTypeHeader,
|
||||
networkContentType(_networkFileName(c, route.path)),
|
||||
);
|
||||
}
|
||||
consumed = true;
|
||||
if (request.method == 'GET') {
|
||||
await request.response.addStream(read.bytes);
|
||||
@@ -1520,6 +1543,9 @@ class NetworkStorageService {
|
||||
}
|
||||
}
|
||||
|
||||
String _networkFileName(NetworkConnection connection, String path) =>
|
||||
networkTarget(connection, path).pathSegments.lastOrNull ?? '';
|
||||
|
||||
String networkContentType(String name) =>
|
||||
switch (name.split('.').last.toLowerCase()) {
|
||||
'mp3' => 'audio/mpeg',
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:mornye/services/network_storage_service.dart';
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
HttpOverrides.global = null;
|
||||
final nativeTest = Platform.environment['MORNYE_DARWIN_SOURCE_TEST'];
|
||||
|
||||
test(
|
||||
'native AVPlayer prepares audio through the real NAS playback proxy',
|
||||
() async {
|
||||
// One second of mono PCM, served as generic bytes by a NAS with Range.
|
||||
final wave = Uint8List(44 + 44100 * 2);
|
||||
final header = ByteData.sublistView(wave);
|
||||
wave.setRange(0, 4, ascii.encode('RIFF'));
|
||||
header.setUint32(4, wave.length - 8, Endian.little);
|
||||
wave.setRange(8, 16, ascii.encode('WAVEfmt '));
|
||||
header.setUint32(16, 16, Endian.little);
|
||||
header.setUint16(20, 1, Endian.little);
|
||||
header.setUint16(22, 1, Endian.little);
|
||||
header.setUint32(24, 44100, Endian.little);
|
||||
header.setUint32(28, 44100 * 2, Endian.little);
|
||||
header.setUint16(32, 2, Endian.little);
|
||||
header.setUint16(34, 16, Endian.little);
|
||||
wave.setRange(36, 40, ascii.encode('data'));
|
||||
header.setUint32(40, wave.length - 44, Endian.little);
|
||||
|
||||
final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
|
||||
addTearDown(() => server.close(force: true));
|
||||
final ranges = <String>[];
|
||||
server.listen((request) async {
|
||||
final range = request.headers.value(HttpHeaders.rangeHeader);
|
||||
if (range != null) ranges.add(range);
|
||||
final part = networkByteRange(range, wave.length);
|
||||
final response = request.response;
|
||||
response.statusCode = range == null ? 200 : 206;
|
||||
response.headers.contentType = ContentType.binary;
|
||||
response.headers.set(HttpHeaders.acceptRangesHeader, 'bytes');
|
||||
response.contentLength = part.end - part.start + 1;
|
||||
if (range != null) {
|
||||
response.headers.set(
|
||||
HttpHeaders.contentRangeHeader,
|
||||
'bytes ${part.start}-${part.end}/${wave.length}',
|
||||
);
|
||||
}
|
||||
if (request.method != 'HEAD') {
|
||||
response.add(Uint8List.sublistView(wave, part.start, part.end + 1));
|
||||
}
|
||||
await response.close();
|
||||
});
|
||||
final storage = NetworkStorageService(
|
||||
read: () async => null,
|
||||
write: (_) async {},
|
||||
ensureAccess: (_) async {},
|
||||
);
|
||||
addTearDown(storage.dispose);
|
||||
await storage.save(
|
||||
NetworkConnection(
|
||||
id: 'nas',
|
||||
name: 'NAS',
|
||||
protocol: NetworkProtocol.webdav,
|
||||
address: 'http://127.0.0.1:${server.port}/music/',
|
||||
),
|
||||
);
|
||||
final url = await storage.resolve(
|
||||
NetworkStorageService.source('nas', '日本語 #1.WAV'),
|
||||
);
|
||||
final result = await Process.run(nativeTest!, [url]);
|
||||
expect(result.exitCode, 0, reason: '${result.stdout}\n${result.stderr}');
|
||||
expect(
|
||||
result.stdout,
|
||||
contains('PASS: native AVPlayer prepares the HTTP proxy source'),
|
||||
);
|
||||
expect(ranges, isNotEmpty);
|
||||
},
|
||||
skip: !Platform.isMacOS || nativeTest == null
|
||||
? 'Set MORNYE_DARWIN_SOURCE_TEST to the compiled SourceLifecycleTests binary'
|
||||
: false,
|
||||
timeout: const Timeout(Duration(seconds: 30)),
|
||||
);
|
||||
}
|
||||
@@ -558,7 +558,18 @@ void main() {
|
||||
} else {
|
||||
final part = networkByteRange(r.headers.value('range'), 10);
|
||||
r.response.statusCode = r.headers.value('range') == null ? 200 : 206;
|
||||
r.response.headers.set('content-type', 'audio/flac');
|
||||
final mime = switch (r.uri.pathSegments.last.toLowerCase()) {
|
||||
'generic.flac' || 'generic.m4a' => 'application/octet-stream',
|
||||
'untyped.mp3' => null,
|
||||
'transcoded.flac' => 'audio/mpeg',
|
||||
'login.flac' => 'text/html',
|
||||
_ => 'audio/flac',
|
||||
};
|
||||
if (mime == null) {
|
||||
r.response.headers.removeAll(HttpHeaders.contentTypeHeader);
|
||||
} else {
|
||||
r.response.headers.set(HttpHeaders.contentTypeHeader, mime);
|
||||
}
|
||||
r.response.headers.set('accept-ranges', 'bytes');
|
||||
r.response.headers.set(
|
||||
'content-range',
|
||||
@@ -724,6 +735,7 @@ void main() {
|
||||
NetworkStorageService.source(c.id, 'A B.flac'),
|
||||
);
|
||||
expect(url, isNot(contains('secret')));
|
||||
expect(Uri.parse(url).path, endsWith('.flac'));
|
||||
final client = HttpClient();
|
||||
addTearDown(() => client.close(force: true));
|
||||
final request = await client.getUrl(Uri.parse(url));
|
||||
@@ -745,6 +757,71 @@ void main() {
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'proxy keeps private file-type hints and fills generic MIME types',
|
||||
() async {
|
||||
final c = connection(
|
||||
'$origin/music/',
|
||||
user: 'test',
|
||||
password: 'secret',
|
||||
);
|
||||
await service.save(c);
|
||||
final client = HttpClient();
|
||||
addTearDown(() => client.close(force: true));
|
||||
for (final (name, suffix, mime) in [
|
||||
('generic.FLAC', 'flac', 'audio/flac'),
|
||||
('untyped.mp3', 'mp3', 'audio/mpeg'),
|
||||
('transcoded.flac', 'flac', 'audio/mpeg'),
|
||||
('login.flac', 'flac', 'text/html'),
|
||||
]) {
|
||||
final url = Uri.parse(
|
||||
await service.resolve(
|
||||
NetworkStorageService.source(c.id, '日本語 #100%/$name'),
|
||||
),
|
||||
);
|
||||
expect(url.path, endsWith('.$suffix'));
|
||||
expect(url.path, isNot(contains(name.toLowerCase())));
|
||||
expect(url.pathSegments, hasLength(1));
|
||||
expect(url.userInfo, isEmpty);
|
||||
expect(url.query, isEmpty);
|
||||
final request = await client.getUrl(url);
|
||||
request.headers.set(HttpHeaders.rangeHeader, 'bytes=4-7');
|
||||
final response = await request.close();
|
||||
expect(response.statusCode, HttpStatus.partialContent);
|
||||
expect(response.headers.contentType?.mimeType, mime);
|
||||
expect(
|
||||
response.headers.value(HttpHeaders.contentRangeHeader),
|
||||
'bytes 4-7/10',
|
||||
);
|
||||
expect(await response.expand((chunk) => chunk).toList(), [
|
||||
4,
|
||||
5,
|
||||
6,
|
||||
7,
|
||||
]);
|
||||
final head = await (await client.headUrl(url)).close();
|
||||
expect(head.headers.contentType?.mimeType, mime);
|
||||
expect(head.contentLength, 10);
|
||||
expect(await head.expand((chunk) => chunk).toList(), isEmpty);
|
||||
}
|
||||
|
||||
final direct = connection(
|
||||
'$origin/generic.m4a',
|
||||
id: 'direct',
|
||||
user: 'test',
|
||||
password: 'secret',
|
||||
);
|
||||
await service.save(direct);
|
||||
final url = Uri.parse(
|
||||
await service.resolve(NetworkStorageService.source(direct.id, '')),
|
||||
);
|
||||
expect(url.path, endsWith('.m4a'));
|
||||
final response = await (await client.headUrl(url)).close();
|
||||
expect(response.headers.contentType?.mimeType, 'audio/mp4');
|
||||
await response.drain<void>();
|
||||
},
|
||||
);
|
||||
|
||||
test('WebDAV and direct HTTP file validation use real requests', () async {
|
||||
final dav = connection(
|
||||
'$origin/music/',
|
||||
@@ -1082,6 +1159,7 @@ void main() {
|
||||
final url = await service.resolve(
|
||||
NetworkStorageService.source(c.id, 'A B.wav'),
|
||||
);
|
||||
expect(Uri.parse(url).path, endsWith('.wav'));
|
||||
final client = HttpClient();
|
||||
addTearDown(() => client.close(force: true));
|
||||
final request = await client.getUrl(Uri.parse(url));
|
||||
|
||||
@@ -364,6 +364,7 @@ void main() {
|
||||
final restored = PlayableMedia.fromJson(saved)!;
|
||||
final url = await storage.resolve(restored.source);
|
||||
expect(Uri.parse(url).query, isEmpty);
|
||||
expect(Uri.parse(url).path, endsWith('.${song.format}'));
|
||||
final http = HttpClient();
|
||||
addTearDown(() => http.close(force: true));
|
||||
final request = await http.getUrl(Uri.parse(url));
|
||||
|
||||
@@ -14,6 +14,13 @@ vendored.
|
||||
|
||||
## Patches
|
||||
|
||||
### Source failure diagnostics
|
||||
|
||||
Failed preparation preserves the native NSError domains and codes, including
|
||||
the underlying chain (five causes at most), instead of replacing every failure
|
||||
with the same message. It logs the same bounded cause chain. URLs, headers and
|
||||
other userInfo values are omitted so playback errors cannot expose NAS credentials.
|
||||
|
||||
### Per-player equalizer
|
||||
|
||||
- AudioplayersDarwinPlugin.swift handles a `setEqualizer` method with a
|
||||
@@ -125,6 +132,13 @@ swiftc darwin/audioplayers_darwin/Sources/audioplayers_darwin/{WrappedMediaPlaye
|
||||
/tmp/source_lifecycle_tests
|
||||
```
|
||||
|
||||
Optional URL arguments also exercise real AVPlayer HTTP preparation. From the
|
||||
application root, set `MORNYE_DARWIN_SOURCE_TEST` to that compiled binary and run
|
||||
`flutter test test/network_storage_darwin_test.dart` to check the complete NAS
|
||||
proxy route. The fixture serves generated WAV audio as generic bytes and checks
|
||||
that the native player can prepare it through the proxy with byte-range reads.
|
||||
This host check does not replace testing on a physical iPhone.
|
||||
|
||||
## Changed Files
|
||||
|
||||
Compared against the pub.dev 6.5.0 package in the local pub cache:
|
||||
|
||||
+17
-2
@@ -266,8 +266,9 @@ enum ReleaseMode: String {
|
||||
case .readyToPlay:
|
||||
self.finishPlayerItemPreparation(.success(()))
|
||||
case .failed:
|
||||
self.finishPlayerItemPreparation(
|
||||
.failure(AudioPlayerError.error("Failed to set playerItem")))
|
||||
let failure = Self.sourceError(playerItem.error)
|
||||
self.eventHandler.onLog(message: "AVPlayer preparation failed: \(failure)")
|
||||
self.finishPlayerItemPreparation(.failure(failure))
|
||||
self.reset()
|
||||
default:
|
||||
// Do not resume continuation yet.
|
||||
@@ -280,6 +281,20 @@ enum ReleaseMode: String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Preserve the native cause without exposing URLs, headers or credentials
|
||||
/// from NSError.userInfo in the player error or exported logs.
|
||||
static func sourceError(_ error: Error?) -> AudioPlayerError {
|
||||
var causes: [String] = []
|
||||
var current = error as NSError?
|
||||
for _ in 0..<5 {
|
||||
guard let cause = current else { break }
|
||||
causes.append("\(cause.domain) (\(cause.code))")
|
||||
current = cause.userInfo[NSUnderlyingErrorKey] as? NSError
|
||||
}
|
||||
let detail = causes.isEmpty ? "" : " [\(causes.joined(separator: "; "))]"
|
||||
return .error("Failed to set playerItem\(detail)")
|
||||
}
|
||||
|
||||
private func finishPlayerItemPreparation(_ result: Result<Void, Error>) {
|
||||
playerItemStatusObservation?.invalidate()
|
||||
playerItemStatusObservation = nil
|
||||
|
||||
@@ -54,10 +54,10 @@ final class DeferredSeekItem: AVPlayerItem {
|
||||
@MainActor final class Preparation {
|
||||
var result: Result<Void, Error>?
|
||||
|
||||
init(_ wrapper: WrappedMediaPlayer, url: String) {
|
||||
init(_ wrapper: WrappedMediaPlayer, url: String, isLocal: Bool = true) {
|
||||
Task { @MainActor in
|
||||
do {
|
||||
try await wrapper.setSourceUrl(url: url, isLocal: true)
|
||||
try await wrapper.setSourceUrl(url: url, isLocal: isLocal)
|
||||
result = .success(())
|
||||
} catch {
|
||||
result = .failure(error)
|
||||
@@ -130,6 +130,45 @@ final class DeferredSeekItem: AVPlayerItem {
|
||||
else {
|
||||
throw Failure.message("Missing native source was not reported as a preparation failure")
|
||||
}
|
||||
guard case AudioPlayerError.error(let message) = error,
|
||||
message.contains("ErrorDomain")
|
||||
else {
|
||||
throw Failure.message("Native preparation failure lost its NSError domain and code")
|
||||
}
|
||||
await wrapper.dispose()
|
||||
}
|
||||
|
||||
@MainActor static func testSourceDiagnostics() throws {
|
||||
let cause = NSError(
|
||||
domain: NSURLErrorDomain, code: NSURLErrorCannotConnectToHost,
|
||||
userInfo: [
|
||||
NSURLErrorFailingURLErrorKey: URL(string: "https://user:secret@nas.test/private.flac")!
|
||||
])
|
||||
let error = NSError(
|
||||
domain: AVFoundationErrorDomain, code: -11800,
|
||||
userInfo: [NSUnderlyingErrorKey: cause, NSLocalizedDescriptionKey: "secret URL"])
|
||||
guard case .error(let message) = WrappedMediaPlayer.sourceError(error),
|
||||
message.contains("\(AVFoundationErrorDomain) (-11800)"),
|
||||
message.contains("\(NSURLErrorDomain) (\(NSURLErrorCannotConnectToHost))"),
|
||||
!message.contains("secret"), !message.contains("nas.test")
|
||||
else {
|
||||
throw Failure.message("Source diagnostics lost the native cause or exposed private userInfo")
|
||||
}
|
||||
}
|
||||
|
||||
@MainActor static func testNetworkPreparation(_ url: String) async throws {
|
||||
let native = AVPlayer()
|
||||
let events = AudioPlayersStreamHandler()
|
||||
let wrapper = WrappedMediaPlayer(
|
||||
reference: AudioplayersDarwinPlugin(), eventHandler: events, player: native)
|
||||
let preparation = Preparation(wrapper, url: url, isLocal: false)
|
||||
try await waitFor("HTTP source preparation did not finish") { preparation.result != nil }
|
||||
guard case .success = preparation.result, events.preparedCount == 1,
|
||||
native.currentItem?.status == .readyToPlay
|
||||
else {
|
||||
throw Failure.message(
|
||||
"HTTP source failed to prepare: \(String(describing: preparation.result))")
|
||||
}
|
||||
await wrapper.dispose()
|
||||
}
|
||||
|
||||
@@ -213,6 +252,8 @@ final class DeferredSeekItem: AVPlayerItem {
|
||||
|
||||
@MainActor static func main() async {
|
||||
do {
|
||||
try testSourceDiagnostics()
|
||||
print("PASS: source errors retain native causes without leaking private userInfo")
|
||||
let native = DeferredPlayer()
|
||||
let events = AudioPlayersStreamHandler()
|
||||
let wrapper = WrappedMediaPlayer(
|
||||
@@ -243,6 +284,10 @@ final class DeferredSeekItem: AVPlayerItem {
|
||||
print("PASS: a linked next player starts as the current one completes")
|
||||
try await testSeekCompletionBelongsToCurrentSource()
|
||||
print("PASS: replaced, disposed and cancelled seeks cannot affect the current source")
|
||||
for url in CommandLine.arguments.dropFirst() {
|
||||
try await testNetworkPreparation(url)
|
||||
print("PASS: native AVPlayer prepares the HTTP proxy source")
|
||||
}
|
||||
} catch {
|
||||
print("FAIL: \(error)")
|
||||
exit(1)
|
||||
|
||||
Reference in new issue
Block a user