Skip to content

基于自定义规则的番剧采集APP,支持流媒体在线观看,支持弹幕,支持实时超分辨率。

fix(syncplay): wait for STARTTLS before joining rooms (#2339)

ChEnylntif92cf819ca22
diff --git a/lib/pages/player/controller/player_syncplay_controller.dart b/lib/pages/player/controller/player_syncplay_controller.dart
index 79c094a1..121310cd 100644
--- a/lib/pages/player/controller/player_syncplay_controller.dart
+++ b/lib/pages/player/controller/player_syncplay_controller.dart
@@ -8,6 +8,7 @@ import 'package:kazumi/services/logging/logger.dart';
import 'package:kazumi/services/storage/storage.dart';
import 'package:kazumi/services/player/syncplay_client.dart';
import 'package:kazumi/services/player/syncplay_endpoint.dart';
+import 'package:kazumi/utils/async_session.dart';
import 'package:mobx/mobx.dart';
part 'player_syncplay_controller.g.dart';
@@ -41,6 +42,7 @@ abstract class _PlayerSyncPlayController with Store {
final Future<void> Function(Duration duration, {bool enableSync}) seek;
SyncplayClient? syncplayController;
+ final AsyncSessionOwner _connectionSessions = AsyncSessionOwner();
@observable
String syncplayRoom = '';
@observable
@@ -72,7 +74,18 @@ abstract class _PlayerSyncPlayController with Store {
Future<void> Function(int episode, {int currentRoad, int offset})
changeEpisode,
{bool enableTLS = true}) async {
- await syncplayController?.disconnect();
+ if (_connectionSessions.isClosed) {
+ return;
+ }
+ final session = _connectionSessions.begin();
+ final previousClient = syncplayController;
+ syncplayController = null;
+ syncplayRoom = '';
+ syncplayClientRtt = 0;
+ await previousClient?.disconnect();
+ if (session.isStale) {
+ return;
+ }
final String syncPlayEndPoint =
GStorage.getSetting(SettingsKeys.syncPlayEndPoint);
String syncPlayEndPointHost = '';
@@ -92,32 +105,46 @@ abstract class _PlayerSyncPlayController with Store {
KazumiLogger().e('SyncPlay: invalid server address $syncPlayEndPoint');
return;
}
- syncplayController =
+ final client =
SyncplayClient(host: syncPlayEndPointHost, port: syncPlayEndPointPort);
+ syncplayController = client;
try {
- await syncplayController!.connect(enableTLS: enableTLS);
+ await client.connect(enableTLS: enableTLS);
+ if (!_isCurrentConnection(session, client)) {
+ await client.disconnect();
+ return;
+ }
KazumiLogger().i(
'SyncPlay: connected to $syncPlayEndPointHost:$syncPlayEndPointPort');
- syncplayController!.onGeneralMessage.listen(
+ client.onGeneralMessage.listen(
(message) {
// print('SyncPlay: general message: ${message.toString()}');
},
onError: (error) {
- KazumiLogger().e('SyncPlay: error ${error.message}', error: error);
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
+ final message =
+ error is SyncplayException ? error.message : error.toString();
+ KazumiLogger().e('SyncPlay: error $message', error: error);
if (error is SyncplayConnectionException) {
exitRoom();
KazumiDialog.showToast(
- message: 'SyncPlay: 同步中断 ${error.message}',
+ message: 'SyncPlay: 同步中断 $message',
duration: const Duration(seconds: 5),
showActionButton: true,
actionLabel: '重新连接',
- onActionPressed: () => createRoom(room, username, changeEpisode),
+ onActionPressed: () => createRoom(room, username, changeEpisode,
+ enableTLS: enableTLS),
);
}
},
);
- syncplayController!.onRoomMessage.listen(
+ client.onRoomMessage.listen(
(message) {
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
if (message['type'] == 'init') {
if (message['username'] == '') {
KazumiDialog.showToast(
@@ -142,8 +169,11 @@ abstract class _PlayerSyncPlayController with Store {
}
},
);
- syncplayController!.onFileChangedMessage.listen(
+ client.onFileChangedMessage.listen(
(message) {
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
KazumiLogger().i(
'SyncPlay: file changed by ${message['setBy']}: ${message['name']}');
RegExp regExp = RegExp(r'(\d+)\[(\d+)\]');
@@ -161,8 +191,11 @@ abstract class _PlayerSyncPlayController with Store {
}
},
);
- syncplayController!.onChatMessage.listen(
+ client.onChatMessage.listen(
(message) {
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
final String sender = (message['username'] ?? '').toString();
final String text = (message['message'] ?? '').toString();
final bool fromRemote = message['username'] != username;
@@ -174,11 +207,19 @@ abstract class _PlayerSyncPlayController with Store {
);
},
onError: (error) {
- KazumiLogger().e('SyncPlay: error ${error.message}', error: error);
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
+ final message =
+ error is SyncplayException ? error.message : error.toString();
+ KazumiLogger().e('SyncPlay: error $message', error: error);
},
);
- syncplayController!.onPositionChangedMessage.listen(
+ client.onPositionChangedMessage.listen(
(message) {
+ if (!_isCurrentConnection(session, client)) {
+ return;
+ }
syncplayClientRtt = (message['clientRtt'].toDouble() * 1000).toInt();
KazumiLogger().i(
'SyncPlay: position changed by ${message['setBy']}: [${DateTime.now().millisecondsSinceEpoch / 1000.0}] calculatedPosition ${message['calculatedPositon']} position: ${message['position']} doSeek: ${message['doSeek']} paused: ${message['paused']} clientRtt: ${message['clientRtt']} serverRtt: ${message['serverRtt']} fd: ${message['fd']}');
@@ -215,13 +256,34 @@ abstract class _PlayerSyncPlayController with Store {
}
},
);
- await syncplayController!.joinRoom(room, username);
+ await client.joinRoom(room, username);
+ if (!_isCurrentConnection(session, client)) {
+ await client.disconnect();
+ return;
+ }
syncplayRoom = room;
} catch (e) {
KazumiLogger().e('SyncPlay: error', error: e);
+ if (!_isCurrentConnection(session, client)) {
+ await client.disconnect();
+ return;
+ }
+ syncplayController = null;
+ syncplayRoom = '';
+ syncplayClientRtt = 0;
+ await client.disconnect();
+ final message = e is SyncplayException ? e.message : e.toString();
+ KazumiDialog.showToast(
+ message: 'SyncPlay: 连接失败 $message',
+ duration: const Duration(seconds: 5),
+ );
}
}
+ bool _isCurrentConnection(AsyncSession session, SyncplayClient client) {
+ return session.isActive && identical(syncplayController, client);
+ }
+
void setCurrentPosition({bool? forceSyncPlaying, double? forceSyncPosition}) {
if (syncplayController == null) {
return;
@@ -238,27 +300,51 @@ abstract class _PlayerSyncPlayController with Store {
Future<void> setPlayingBangumi(
{bool? forceSyncPlaying, double? forceSyncPosition}) async {
- await syncplayController!.setSyncPlayPlaying(
- "${bangumiId()}[${currentEpisode()}]", 10800, 220514438);
- setCurrentPosition(
- forceSyncPlaying: forceSyncPlaying,
- forceSyncPosition: forceSyncPosition);
- await requestSync(doSeek: null);
+ final client = syncplayController;
+ if (client == null) {
+ return;
+ }
+ await _runBestEffortSync(() async {
+ await client.setSyncPlayPlaying(
+ "${bangumiId()}[${currentEpisode()}]", 10800, 220514438);
+ if (!identical(syncplayController, client)) {
+ return;
+ }
+ setCurrentPosition(
+ forceSyncPlaying: forceSyncPlaying,
+ forceSyncPosition: forceSyncPosition);
+ await client.sendSyncPlaySyncRequest(doSeek: null);
+ });
}
Future<void> requestSync({bool? doSeek}) async {
- await syncplayController!.sendSyncPlaySyncRequest(doSeek: doSeek);
+ final client = syncplayController;
+ if (client == null) {
+ return;
+ }
+ await _runBestEffortSync(
+ () => client.sendSyncPlaySyncRequest(doSeek: doSeek));
}
Future<void> sendChatMessage(String message) async {
- if (syncplayController == null) {
+ final client = syncplayController;
+ if (client == null) {
return;
}
- await syncplayController!.sendChatMessage(message);
+ await _runBestEffortSync(() => client.sendChatMessage(message));
+ }
+
+ Future<void> _runBestEffortSync(Future<void> Function() operation) async {
+ try {
+ await operation();
+ } on SyncplayConnectionException {
+ // Socket handlers report active connection failures.
+ }
}
@action
Future<void> exitRoom() async {
+ _connectionSessions.cancel();
final controller = syncplayController;
syncplayController = null;
syncplayRoom = '';
@@ -270,6 +356,7 @@ abstract class _PlayerSyncPlayController with Store {
}
Future<void> dispose() async {
+ _connectionSessions.close();
await exitRoom();
await _chatStreamController.close();
}
diff --git a/lib/services/player/syncplay_client.dart b/lib/services/player/syncplay_client.dart
index d31ca3fe..d7e59d13 100644
--- a/lib/services/player/syncplay_client.dart
+++ b/lib/services/player/syncplay_client.dart
@@ -5,10 +5,15 @@ import 'dart:convert';
import 'dart:io';
const double PING_MOVING_AVERAGE_WEIGHT = 0.85;
+const Duration _tlsHandshakeTimeout = Duration(seconds: 10);
+const Duration _socketWriteTimeout = Duration(seconds: 10);
class SyncplayException implements Exception {
final String message;
SyncplayException(this.message);
+
+ @override
+ String toString() => message;
}
class SyncplayConnectionException extends SyncplayException {
@@ -189,11 +194,23 @@ class TLSMessage extends SyncplayMessage {
};
}
+/// Single-use connection to a Syncplay server: [connect] may be called once,
+/// and [disconnect] permanently closes the client. Callers create a new
+/// instance for every connection attempt.
class SyncplayClient {
final String _host;
final int _port;
+ bool _connectCalled = false;
+ bool _closed = false;
bool _isTLS = false;
- Socket? _socket;
+ RawSocket? _socket;
+ // Retained across STARTTLS so a stalled RawSecureSocket can be force-closed.
+ RawSocket? _transportSocket;
+ StreamSubscription<RawSocketEvent>? _socketSubscription;
+ Completer<void>? _tlsHandshakeCompleter;
+ final List<int> _pendingWrites = [];
+ Completer<void>? _pendingWriteCompleter;
+ Timer? _pendingWriteTimer;
String? _username;
String? _currentRoom;
String? _currentFileName;
@@ -221,7 +238,10 @@ class SyncplayClient {
int _clientIgnoringOnTheFly = 0;
int _serverIgnoringOnTheFly = 0;
- bool get isConnected => _socket != null;
+ bool get isConnected =>
+ !_closed &&
+ _socket != null &&
+ (_tlsHandshakeCompleter == null || _isTLS);
bool get isTLS => _isTLS;
String? get username => _username;
String? get currentRoom => _currentRoom;
@@ -261,34 +281,79 @@ class SyncplayClient {
_port = port;
Future<void> connect({bool enableTLS = true}) async {
- if (_generalMessageController?.isClosed ?? true) {
- _generalMessageController = StreamController.broadcast();
+ if (_closed) {
+ throw StateError('SyncplayClient cannot connect after disconnect');
}
- if (_flieChangedMessageController?.isClosed ?? true) {
- _flieChangedMessageController = StreamController.broadcast();
- }
- if (_positionChangedMessageController?.isClosed ?? true) {
- _positionChangedMessageController = StreamController.broadcast();
+ if (_connectCalled) {
+ throw StateError('SyncplayClient.connect may only be called once');
}
+ _connectCalled = true;
try {
- await _socket?.close();
- _socket = null;
print('SyncPlay: connecting to Syncplay server: $_host:$_port');
- _socket = await Socket.connect(_host, _port);
+ final socket = await RawSocket.connect(_host, _port);
+ if (_closed) {
+ await _forceCloseSocket(socket);
+ throw SyncplayConnectionException('SyncPlay: connection closed');
+ }
+ _socket = socket;
+ _transportSocket = socket;
print('SyncPlay: connected to Syncplay server: $_host:$_port');
- _setupSocketHandlers();
+ _setupSocketHandlers(socket);
if (enableTLS) {
- requestTLS();
+ final handshakeCompleter = Completer<void>();
+ _tlsHandshakeCompleter = handshakeCompleter;
+ try {
+ await Future.wait<void>(
+ [
+ requestTLS(),
+ handshakeCompleter.future,
+ ],
+ eagerError: true,
+ ).timeout(_tlsHandshakeTimeout);
+ if (_socket == null || !_isTLS) {
+ throw SyncplayConnectionException(
+ 'SyncPlay: TLS connection closed during upgrade',
+ );
+ }
+ } on TimeoutException {
+ throw SyncplayConnectionException(
+ 'SyncPlay: TLS connection upgrade timed out',
+ );
+ } finally {
+ _tlsHandshakeCompleter = null;
+ }
}
- } on SocketException catch (e) {
- _generalMessageController?.addError(
- SyncplayConnectionException(
- 'SyncPlay: connection failed: ${e.message}'),
+ } catch (error, stackTrace) {
+ if (!_closed) {
+ await _closeSockets(
+ pendingWriteError: error,
+ stackTrace: stackTrace,
+ );
+ }
+ if (error is SyncplayException) {
+ Error.throwWithStackTrace(error, stackTrace);
+ }
+ if (error is SocketException) {
+ Error.throwWithStackTrace(
+ SyncplayConnectionException(
+ 'SyncPlay: connection failed: ${error.message}',
+ ),
+ stackTrace,
+ );
+ }
+ Error.throwWithStackTrace(
+ SyncplayConnectionException('SyncPlay: connection failed: $error'),
+ stackTrace,
);
}
}
Future<void> requestTLS() async {
+ if (_socket == null) {
+ throw SyncplayConnectionException(
+ 'SyncPlay: cannot request TLS before connecting',
+ );
+ }
print('SyncPlay: requesting TLS connection upgrade');
await _sendMessage(TLSMessage(message: 'send'));
}
@@ -332,8 +397,8 @@ class SyncplayClient {
room: _currentRoom ?? ''));
}
- Future<void> sendSyncPlaySyncRequest({bool? doSeek}) async {
- _sendState(
+ Future<void> sendSyncPlaySyncRequest({bool? doSeek}) {
+ return _sendState(
position: _currentPositon,
paused: _isPaused,
doSeek: doSeek,
@@ -342,7 +407,15 @@ class SyncplayClient {
}
Future<void> disconnect() async {
+ if (_closed) {
+ return;
+ }
+ _closed = true;
print('SyncPlay: disconnecting from Syncplay server: $_host:$_port');
+ final exception =
+ SyncplayConnectionException('SyncPlay: connection closed');
+ _completeTLSHandshakeError(exception);
+ await _closeSockets(pendingWriteError: exception);
await _generalMessageController?.close();
_generalMessageController = null;
await _roomMessageController?.close();
@@ -353,16 +426,11 @@ class SyncplayClient {
_flieChangedMessageController = null;
await _positionChangedMessageController?.close();
_positionChangedMessageController = null;
- try {
- await _socket?.close();
- } catch (_) {}
- _socket = null;
_currentRoom = null;
_username = null;
_currentFileName = null;
_currentPositon = 0.0;
_isPaused = true;
- _isTLS = false;
_lastLatencyCalculation = null;
_clientIgnoringOnTheFly = 0;
_serverIgnoringOnTheFly = 0;
@@ -380,77 +448,173 @@ class SyncplayClient {
_isPaused = paused;
}
- void _setupSocketHandlers() {
- String buffer = '';
+ Future<void> _closeSockets({
+ Object? pendingWriteError,
+ StackTrace? stackTrace,
+ }) async {
+ final socket = _socket;
+ final transportSocket = _transportSocket;
+ final subscription = _socketSubscription;
+ _socket = null;
+ _transportSocket = null;
+ _socketSubscription = null;
+ _isTLS = false;
+ _failPendingWrites(
+ pendingWriteError ??
+ SyncplayConnectionException('SyncPlay: connection closed'),
+ stackTrace,
+ );
+ try {
+ await subscription?.cancel();
+ } catch (_) {}
- _socket?.listen(
- (data) {
- final dataStr = utf8.decode(data);
- buffer += dataStr;
- while (true) {
- final startIndex = buffer.indexOf('{');
- if (startIndex == -1) {
- break;
- }
+ // RawSecureSocket.close() can wait for buffered TLS writes indefinitely.
+ // Closing its retained transport is the force-close path in that case.
+ if (transportSocket != null) {
+ await _forceCloseSocket(transportSocket);
+ }
+ if (socket != null &&
+ !identical(socket, transportSocket) &&
+ socket is! RawSecureSocket) {
+ await _forceCloseSocket(socket);
+ }
+ }
+
+ Future<void> _forceCloseSocket(RawSocket socket) async {
+ try {
+ socket.shutdown(SocketDirection.both);
+ } catch (_) {}
+ try {
+ await socket.close();
+ } catch (_) {}
+ }
- int braceCount = 0;
- int? endIndex;
- for (int i = startIndex; i < buffer.length; i++) {
- if (buffer[i] == '{') {
- braceCount++;
- } else if (buffer[i] == '}') {
- braceCount--;
- if (braceCount == 0) {
- endIndex = i;
+ void _setupSocketHandlers(RawSocket socket) {
+ String buffer = '';
+
+ _socketSubscription = socket.listen(
+ (event) {
+ if (!identical(socket, _socket)) {
+ return;
+ }
+ if (event == RawSocketEvent.write) {
+ _flushPendingWrites(socket);
+ return;
+ }
+ if (event == RawSocketEvent.readClosed ||
+ event == RawSocketEvent.closed) {
+ _handleSocketClosed(socket);
+ return;
+ }
+ if (event == RawSocketEvent.read) {
+ while (true) {
+ final data = socket.read();
+ if (data == null || data.isEmpty) {
+ break;
+ }
+ buffer += utf8.decode(data);
+ while (true) {
+ final startIndex = buffer.indexOf('{');
+ if (startIndex == -1) {
break;
}
+
+ int braceCount = 0;
+ int? endIndex;
+ for (int i = startIndex; i < buffer.length; i++) {
+ if (buffer[i] == '{') {
+ braceCount++;
+ } else if (buffer[i] == '}') {
+ braceCount--;
+ if (braceCount == 0) {
+ endIndex = i;
+ break;
+ }
+ }
+ }
+ if (endIndex == null) break;
+
+ final jsonStr = buffer.substring(startIndex, endIndex + 1);
+ try {
+ _handleMessage(json.decode(jsonStr), socket);
+ } catch (e) {
+ _generalMessageController?.addError(
+ SyncplayProtocolException(
+ 'SyncPlay: received data parse failed: $e'),
+ );
+ }
+ buffer = buffer.substring(endIndex + 1);
+ if (!identical(socket, _socket)) {
+ return;
+ }
}
}
- if (endIndex == null) break;
-
- final jsonStr = buffer.substring(startIndex, endIndex + 1);
- try {
- // print(
- // 'SyncPlay: [${DateTime.now().millisecondsSinceEpoch / 1000.0}] received message: $jsonStr');
- _handleMessage(json.decode(jsonStr));
- } catch (e) {
- _generalMessageController?.addError(
- SyncplayProtocolException(
- 'SyncPlay: received data parse failed: $e'),
- );
- }
- buffer = buffer.substring(endIndex + 1);
}
},
- onError: (error) => _generalMessageController?.addError(
- SyncplayConnectionException('SyncPlay: socket error: $error'),
- ),
- onDone: () => _generalMessageController?.addError(
- SyncplayConnectionException('SyncPlay: connection closed'),
- ),
+ onError: (error, stackTrace) =>
+ _handleSocketError(socket, error, stackTrace),
+ onDone: () => _handleSocketClosed(socket),
);
+ socket.readEventsEnabled = true;
+ _flushPendingWrites(socket);
}
- void _handleMessage(dynamic data) async {
+ void _handleSocketError(
+ RawSocket socket,
+ Object error,
+ StackTrace stackTrace,
+ ) {
+ _failCurrentSocket(
+ socket,
+ SyncplayConnectionException('SyncPlay: socket error: $error'),
+ stackTrace,
+ );
+ }
+
+ void _handleSocketClosed(RawSocket socket) {
+ _failCurrentSocket(
+ socket,
+ SyncplayConnectionException('SyncPlay: connection closed'),
+ );
+ }
+
+ void _failCurrentSocket(
+ RawSocket socket,
+ SyncplayConnectionException exception, [
+ StackTrace? stackTrace,
+ ]) {
+ if (!identical(socket, _socket)) {
+ return;
+ }
+ final handshakePending =
+ !(_tlsHandshakeCompleter?.isCompleted ?? true);
+ final closeFuture = _closeSockets(
+ pendingWriteError: exception,
+ stackTrace: stackTrace,
+ );
+ _completeTLSHandshakeError(exception, stackTrace);
+ if (!handshakePending) {
+ _generalMessageController?.addError(exception, stackTrace);
+ }
+ unawaited(closeFuture);
+ }
+
+ void _handleMessage(dynamic data, RawSocket sourceSocket) {
final json = data as Map<String, dynamic>;
if (json.containsKey('TLS')) {
- if (json['TLS'].containsKey('startTLS')) {
- if (json['TLS']['startTLS'] == 'true') {
- var plainSocket = _socket;
- try {
- _socket = await SecureSocket.secure(plainSocket!);
- _setupSocketHandlers();
- _isTLS = true;
- print('SyncPlay: TLS connection established');
- try {
- plainSocket.close();
- } catch (_) {}
- } catch (e) {
- print('SyncPlay: TLS connection upgrade failed: $e');
- _socket = plainSocket;
- _isTLS = false;
- }
- }
+ final tlsData = json['TLS'];
+ if (tlsData is! Map || !tlsData.containsKey('startTLS')) {
+ _completeTLSHandshakeError(
+ SyncplayProtocolException('SyncPlay: invalid TLS response'),
+ );
+ } else if (tlsData['startTLS'] == 'true') {
+ unawaited(_upgradeToTLS(sourceSocket));
+ } else {
+ _completeTLSHandshakeError(
+ SyncplayConnectionException(
+ 'SyncPlay: server rejected TLS connection upgrade',
+ ),
+ );
}
return;
}
@@ -461,7 +625,7 @@ class SyncplayClient {
_currentRoom = json['Hello']['room']['name'];
print(
'SyncPlay: joined room: $_currentRoom as $_username, version: ${json['Hello']['version']}');
- _setReady();
+ _runInBackground(_setReady());
}
_generalMessageController?.add({
'username': json['Hello']['username'],
@@ -511,9 +675,11 @@ class SyncplayClient {
'fd': _fd,
});
}
- _sendState(
- position: _currentPositon,
- paused: _isPaused,
+ _runInBackground(
+ _sendState(
+ position: _currentPositon,
+ paused: _isPaused,
+ ),
);
return;
}
@@ -567,6 +733,61 @@ class SyncplayClient {
);
}
+ Future<void> _upgradeToTLS(RawSocket plainSocket) async {
+ if (!identical(plainSocket, _socket)) {
+ return;
+ }
+ final subscription = _socketSubscription;
+ if (subscription == null) {
+ _completeTLSHandshakeError(
+ SyncplayConnectionException(
+ 'SyncPlay: TLS connection upgrade lost its socket subscription',
+ ),
+ );
+ return;
+ }
+ _socketSubscription = null;
+ _socket = null;
+ try {
+ final secureSocket = await RawSecureSocket.secure(
+ plainSocket,
+ subscription: subscription,
+ host: _host,
+ );
+ if (!identical(_transportSocket, plainSocket)) {
+ await _forceCloseSocket(secureSocket);
+ return;
+ }
+ _socket = secureSocket;
+ _isTLS = true;
+ _setupSocketHandlers(secureSocket);
+ print('SyncPlay: TLS connection established');
+ final handshakeCompleter = _tlsHandshakeCompleter;
+ if (handshakeCompleter != null && !handshakeCompleter.isCompleted) {
+ handshakeCompleter.complete();
+ }
+ } catch (error, stackTrace) {
+ await _forceCloseSocket(plainSocket);
+ if (!identical(_transportSocket, plainSocket)) {
+ return;
+ }
+ _transportSocket = null;
+ final exception = SyncplayConnectionException(
+ 'SyncPlay: TLS connection upgrade failed: $error',
+ );
+ print(exception.message);
+ _completeTLSHandshakeError(exception, stackTrace);
+ }
+ }
+
+ void _completeTLSHandshakeError(Object error, [StackTrace? stackTrace]) {
+ final handshakeCompleter = _tlsHandshakeCompleter;
+ if (handshakeCompleter == null || handshakeCompleter.isCompleted) {
+ return;
+ }
+ handshakeCompleter.completeError(error, stackTrace ?? StackTrace.current);
+ }
+
Future<void> _setReady() async {
if (_currentRoom == null || _username == null) {
_generalMessageController?.addError(
@@ -589,20 +810,95 @@ class SyncplayClient {
}
Future<void> _sendMessage(SyncplayMessage message) async {
- if (_socket == null) {
- _generalMessageController?.addError(
- SyncplayConnectionException('SyncPlay: not connected to server'),
- );
+ final socket = _socket;
+ if (_closed || socket == null) {
+ throw SyncplayConnectionException('SyncPlay: not connected to server');
+ }
+ final jsonStr = jsonEncode(message.toJson());
+ _pendingWrites.addAll(utf8.encode('$jsonStr\r\n'));
+ var completer = _pendingWriteCompleter;
+ if (completer == null) {
+ completer = Completer<void>();
+ _pendingWriteCompleter = completer;
+ _restartPendingWriteTimer(socket, completer);
+ }
+ _flushPendingWrites(socket);
+ await completer.future;
+ }
+
+ void _flushPendingWrites(RawSocket socket) {
+ if (!identical(socket, _socket)) {
return;
}
- final json = message.toJson();
- final jsonStr = jsonEncode(json);
- // print(
- // 'SyncPlay: [${DateTime.now().millisecondsSinceEpoch / 1000.0}] sending message: $jsonStr');
- _socket?.write('$jsonStr\r\n');
+ final completer = _pendingWriteCompleter;
+ if (completer == null) {
+ socket.writeEventsEnabled = false;
+ return;
+ }
+ var madeProgress = false;
+ try {
+ while (_pendingWrites.isNotEmpty) {
+ final written = socket.write(_pendingWrites);
+ if (written <= 0) {
+ if (madeProgress) {
+ _restartPendingWriteTimer(socket, completer);
+ }
+ socket.writeEventsEnabled = true;
+ return;
+ }
+ _pendingWrites.removeRange(0, written);
+ madeProgress = true;
+ }
+ socket.writeEventsEnabled = false;
+ _completePendingWrites();
+ } catch (error, stackTrace) {
+ final exception = SyncplayConnectionException(
+ 'SyncPlay: socket write failed: $error',
+ );
+ _failCurrentSocket(socket, exception, stackTrace);
+ }
}
- void _sendState(
+ void _restartPendingWriteTimer(RawSocket socket, Completer<void> completer) {
+ _pendingWriteTimer?.cancel();
+ _pendingWriteTimer = Timer(_socketWriteTimeout, () {
+ if (!identical(socket, _socket) ||
+ !identical(completer, _pendingWriteCompleter) ||
+ _pendingWrites.isEmpty) {
+ return;
+ }
+ _failCurrentSocket(
+ socket,
+ SyncplayConnectionException('SyncPlay: socket write timed out'),
+ StackTrace.current,
+ );
+ });
+ }
+
+ void _completePendingWrites() {
+ final completer = _pendingWriteCompleter;
+ _clearPendingWriteState();
+ if (completer != null && !completer.isCompleted) {
+ completer.complete();
+ }
+ }
+
+ void _failPendingWrites(Object error, [StackTrace? stackTrace]) {
+ _pendingWrites.clear();
+ final completer = _pendingWriteCompleter;
+ _clearPendingWriteState();
+ if (completer != null && !completer.isCompleted) {
+ completer.completeError(error, stackTrace ?? StackTrace.current);
+ }
+ }
+
+ void _clearPendingWriteState() {
+ _pendingWriteTimer?.cancel();
+ _pendingWriteTimer = null;
+ _pendingWriteCompleter = null;
+ }
+
+ Future<void> _sendState(
{double? position,
bool? paused,
bool? doSeek,
@@ -619,7 +915,7 @@ class SyncplayClient {
if (_clientIgnoringOnTheFly > 0) {
clientArck = _clientIgnoringOnTheFly;
}
- _sendMessage(StateMessage(
+ return _sendMessage(StateMessage(
position: position ?? _currentPositon,
paused: paused ?? _isPaused,
latencyCalculation: _lastLatencyCalculation,
@@ -632,6 +928,16 @@ class SyncplayClient {
));
}
+ void _runInBackground(Future<void> future) {
+ unawaited(
+ future.catchError((Object error, StackTrace stackTrace) {
+ if (error is! SyncplayConnectionException) {
+ Error.throwWithStackTrace(error, stackTrace);
+ }
+ }),
+ );
+ }
+
void _updateClientRttAndFd(double? timestamp, double senderRtt) {
if (timestamp == null) return;