fix(ios): preserve NAS streaming format hints and native errors

This commit is contained in:
zarzet committed 2026-11-04 01:08:37 +07:00
1 parent 4dcedf80eb
commit 24f7d4c355
7 files changed
+272 -8

No files matched your search

+29 -3
View File
@@ -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',
+85
View File
@@ -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)),
);
}
+79 -1
View File
@@ -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));
+1
View File
@@ -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
View File
@@ -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:
@@ -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)