Skip to content

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

27.0 KB
Raw Blame
// https://syncplay.pl/about/protocol/

import 'dart:async';
import 'dart:convert';
import 'dart:io';

const double _pingMovingAverageWeight = 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 {
  SyncplayConnectionException(super.message);
}

class SyncplayProtocolException extends SyncplayException {
  SyncplayProtocolException(super.message);
}

abstract class SyncplayMessage {
  Map<String, dynamic> toJson();
}

class HelloMessage extends SyncplayMessage {
  final String username;
  final String version;
  final String room;

  HelloMessage({
    required this.username,
    required this.version,
    required this.room,
  });

  @override
  Map<String, dynamic> toJson() => {
        'Hello': {
          'username': username,
          'room': {
            'name': room,
          },
          'version': version,
          'features': {
            'sharedPlaylists': true,
            'chat': true,
            'featureList': true,
            'readiness': true,
            'managedRooms': false,
          }
        },
      };
}

class StateMessage extends SyncplayMessage {
  final double position;
  final bool paused;
  final bool? doSeek;
  final String? setBy;

  // Syncplay control message.
  final int? clientAck;
  final int? serverAck;

  // latency calculation
  double clientLatencyCalculation;
  double? latencyCalculation;
  final double clientRtt;

  StateMessage({
    required this.position,
    required this.paused,
    this.setBy,
    this.doSeek,
    this.clientAck,
    this.serverAck,
    required this.clientLatencyCalculation,
    this.latencyCalculation,
    this.clientRtt = 0.0,
  });

  @override
  Map<String, dynamic> toJson() => {
        'State': {
          if (clientAck != null || serverAck != null)
            'ignoringOnTheFly': {
              if (clientAck != null) 'client': clientAck,
              if (serverAck != null) 'server': serverAck,
            },
          'ping': {
            'clientRtt': clientRtt,
            'clientLatencyCalculation': clientLatencyCalculation,
            if (latencyCalculation != null)
              'latencyCalculation': latencyCalculation,
          },
          'playstate': {
            'position': position,
            'paused': paused,
            if (setBy != null) 'setBy': setBy,
            'doSeek': doSeek,
          },
        },
      };
}

class SetMessage extends SyncplayMessage {
  final double? duration;
  final String? fileName;
  final String? username;
  final int? size;
  final String? setBy;
  final String? room;
  final bool? setJoined;
  final bool? setReady;

  SetMessage({
    this.duration,
    this.fileName,
    this.username,
    this.size,
    this.setBy,
    this.room,
    this.setJoined,
    this.setReady,
  });

  @override
  Map<String, dynamic> toJson() {
    if (setJoined != null && room != null && username != null) {
      return {
        "Set": {
          room: {
            "room": {"name": room},
            "event": {"joined": true}
          },
        }
      };
    }
    if (setReady != null) {
      return {
        'Set': {
          "ready": {"isReady": true, "manuallyInitiated": false}
        }
      };
    }
    return {
      'Set': {
        if (fileName != null)
          'file': {
            'duration': duration,
            'name': fileName,
            'size': size,
          },
        if (room != null)
          "user": {
            setBy: {
              "room": {"name": room},
            },
          },
      },
    };
  }
}

class ChatMessage extends SyncplayMessage {
  final String message;

  ChatMessage({
    required this.message,
  });

  @override
  Map<String, dynamic> toJson() => {'Chat': message};
}

class _TLSMessage extends SyncplayMessage {
  final String message;

  _TLSMessage({
    required this.message,
  });

  @override
  Map<String, dynamic> toJson() => {
        'TLS': {
          'startTLS': message,
        },
      };
}

/// 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;
  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;
  double _currentPositon = 0.0;
  bool _isPaused = true;
  StreamController<Map<String, dynamic>>? _generalMessageController =
      StreamController.broadcast();
  StreamController<Map<String, dynamic>>? _roomMessageController =
      StreamController.broadcast();
  StreamController<Map<String, dynamic>>? _chatMessageController =
      StreamController.broadcast();
  StreamController<Map<String, dynamic>>? _flieChangedMessageController =
      StreamController.broadcast();
  StreamController<Map<String, dynamic>>? _positionChangedMessageController =
      StreamController.broadcast();
  double? _lastLatencyCalculation;

  // Network status
  double _clientRtt = 0.0;
  double _serverRtt = 0.0;
  double _avrRtt = 0.0;
  double _fd = 0.0;

  // IgnoringOnTheFly
  int _clientIgnoringOnTheFly = 0;
  int _serverIgnoringOnTheFly = 0;

  bool get isConnected =>
      !_closed && _socket != null && (_tlsHandshakeCompleter == null || _isTLS);
  String? get username => _username;
  String? get currentFileName => _currentFileName;

  Stream<Map<String, dynamic>> get onGeneralMessage {
    _generalMessageController ??= StreamController.broadcast();
    return _generalMessageController!.stream;
  }

  Stream<Map<String, dynamic>> get onRoomMessage {
    _roomMessageController ??= StreamController.broadcast();
    return _roomMessageController!.stream;
  }

  Stream<Map<String, dynamic>> get onChatMessage {
    _chatMessageController ??= StreamController.broadcast();
    return _chatMessageController!.stream;
  }

  Stream<Map<String, dynamic>> get onFileChangedMessage {
    _flieChangedMessageController ??= StreamController.broadcast();
    return _flieChangedMessageController!.stream;
  }

  Stream<Map<String, dynamic>> get onPositionChangedMessage {
    _positionChangedMessageController ??= StreamController.broadcast();
    return _positionChangedMessageController!.stream;
  }

  SyncplayClient({required String host, required int port})
      : _host = host,
        _port = port;

  /// Opens the connection using the TLS policy selected by the caller.
  Future<void> connect({required bool enableTLS}) async {
    if (_closed) {
      throw StateError('SyncplayClient cannot connect after disconnect');
    }
    if (_connectCalled) {
      throw StateError('SyncplayClient.connect may only be called once');
    }
    _connectCalled = true;
    try {
      final socket = await RawSocket.connect(_host, _port);
      if (_closed) {
        await _forceCloseSocket(socket);
        throw SyncplayConnectionException('SyncPlay: connection closed');
      }
      _socket = socket;
      _transportSocket = socket;
      _setupSocketHandlers(socket);
      if (enableTLS) {
        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;
        }
      }
    } 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',
      );
    }
    await _sendMessage(_TLSMessage(message: 'send'));
  }

  Future<void> joinRoom(String room, String username) async {
    await _sendMessage(HelloMessage(
      username: username,
      version: '1.7.0',
      room: room,
    ));
  }

  Future<void> sendChatMessage(String message) async {
    if (_currentRoom == null || _username == null) {
      _generalMessageController?.addError(
        SyncplayProtocolException(
            'SyncPlay: send chat message failed, not in a room'),
      );
      return;
    }
    await _sendMessage(ChatMessage(
      message: message,
    ));
  }

  Future<void> setSyncPlayPlaying(
      String bangumiName, double duration, int size) async {
    if (_currentRoom == null || _username == null) {
      _generalMessageController?.addError(
        SyncplayProtocolException(
            'SyncPlay: set playing bangumi failed, not in a room'),
      );
      return;
    }
    await _sendMessage(SetMessage(
        duration: duration,
        fileName: bangumiName,
        size: size,
        setBy: _username ?? '',
        room: _currentRoom ?? ''));
  }

  Future<void> sendSyncPlaySyncRequest({bool? doSeek}) {
    return _sendState(
      position: _currentPositon,
      paused: _isPaused,
      doSeek: doSeek,
      stateChange: true,
    );
  }

  Future<void> disconnect() async {
    if (_closed) {
      return;
    }
    _closed = true;
    final exception =
        SyncplayConnectionException('SyncPlay: connection closed');
    _completeTLSHandshakeError(exception);
    await _closeSockets(pendingWriteError: exception);
    await _generalMessageController?.close();
    _generalMessageController = null;
    await _roomMessageController?.close();
    _roomMessageController = null;
    await _chatMessageController?.close();
    _chatMessageController = null;
    await _flieChangedMessageController?.close();
    _flieChangedMessageController = null;
    await _positionChangedMessageController?.close();
    _positionChangedMessageController = null;
    _currentRoom = null;
    _username = null;
    _currentFileName = null;
    _currentPositon = 0.0;
    _isPaused = true;
    _lastLatencyCalculation = null;
    _clientIgnoringOnTheFly = 0;
    _serverIgnoringOnTheFly = 0;
    _clientRtt = 0.0;
    _serverRtt = 0.0;
    _avrRtt = 0.0;
    _fd = 0.0;
  }

  void setPosition(double position) {
    _currentPositon = position;
  }

  void setPaused(bool paused) {
    _isPaused = paused;
  }

  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 (_) {}

    // 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 (_) {}
  }

  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;
              }
            }
          }
        }
      },
      onError: (error, stackTrace) =>
          _handleSocketError(socket, error, stackTrace),
      onDone: () => _handleSocketClosed(socket),
    );
    socket.readEventsEnabled = true;
    _flushPendingWrites(socket);
  }

  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')) {
      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;
    }
    if (json.containsKey('Hello')) {
      if (json['Hello'].containsKey('room') &&
          json['Hello']['room'].containsKey('name')) {
        _username = json['Hello']['username'];
        _currentRoom = json['Hello']['room']['name'];
        _runInBackground(_setReady());
      }
      _generalMessageController?.add({
        'username': json['Hello']['username'],
        'room': json['Hello']['room']['name'],
      });
      return;
    }
    if (json.containsKey('State')) {
      if (json['State'].containsKey('ping')) {
        _lastLatencyCalculation =
            json['State']['ping']['latencyCalculation']?.toDouble();
        if (json['State']['ping'].containsKey('serverRtt')) {
          _serverRtt = json['State']['ping']['serverRtt']?.toDouble() ?? 0.0;
        }
        _updateClientRttAndFd(
            json['State']["ping"]["clientLatencyCalculation"], _serverRtt);
      }
      if (json['State'].containsKey('ignoringOnTheFly')) {
        var ignoringOnTheFly = json['State']['ignoringOnTheFly'];
        if (ignoringOnTheFly.containsKey('server')) {
          _serverIgnoringOnTheFly = ignoringOnTheFly['server'];
          _clientIgnoringOnTheFly = 0;
        } else if (ignoringOnTheFly.containsKey('client')) {
          if (ignoringOnTheFly['client'] == _clientIgnoringOnTheFly) {
            _clientIgnoringOnTheFly = 0;
          }
        }
      }
      if (_clientIgnoringOnTheFly == 0) {
        _currentPositon = (json['State']['playstate']['paused'] ?? true)
            ? (json['State']['playstate']['position']?.toDouble() ?? 0.0)
            : ((json['State']['playstate']['position']?.toDouble() ?? 0.0) +
                _fd);
        _isPaused = json['State']['playstate']['paused'] ?? true;
        _positionChangedMessageController?.add({
          'calculatedPositon': (json['State']['playstate']['paused'] ?? true)
              ? (json['State']['playstate']['position']?.toDouble() ?? 0.0)
              : ((json['State']['playstate']['position']?.toDouble() ?? 0.0) +
                  _fd),
          'position': json['State']['playstate']['position']?.toDouble() ?? 0.0,
          'paused': json['State']['playstate']['paused'] ?? true,
          'doSeek': json['State']['playstate']['doSeek'] ?? false,
          'setBy': json['State']['playstate']['setBy'] ?? '',
          'clientRtt': _clientRtt,
          'serverRtt': _serverRtt,
          'avrRtt': _avrRtt,
          'fd': _fd,
        });
      }
      _runInBackground(
        _sendState(
          position: _currentPositon,
          paused: _isPaused,
        ),
      );
      return;
    }
    if (json.containsKey('Set')) {
      if (json['Set'].containsKey('playlistIndex')) {
        _roomMessageController?.add({
          'type': 'init',
          'username': json['Set']['playlistIndex']['user'] ?? '',
        });
        return;
      }
      if (json['Set'].containsKey('user')) {
        Map<String, dynamic> userMap = data['Set']['user'];
        userMap.forEach((username, details) {
          if (!details.containsKey('event')) {
            return;
          }
          var event = details['event'].keys.first ?? 'unknown';
          _roomMessageController?.add({
            'type': event,
            'username': username,
          });
        });
        for (var username in userMap.keys) {
          var userData = userMap[username];
          if (userData is Map && userData.containsKey('file')) {
            var fileData = userData['file'];
            var fileName = fileData['name'];
            _currentFileName = fileName;
            _flieChangedMessageController?.add({
              'name': fileName,
              'setBy': username,
            });
          }
        }
      }
      return;
    }
    if (json.containsKey('Chat')) {
      if (json['Chat'].containsKey('message') &&
          json['Chat'].containsKey('username')) {
        _chatMessageController?.add({
          'message': json['Chat']['message'],
          'username': json['Chat']['username'],
        });
      }
      return;
    }
    _generalMessageController?.addError(
      SyncplayProtocolException('SyncPlay: unknown message type'),
    );
  }

  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);
      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',
      );
      _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(
        SyncplayProtocolException('SyncPlay: set ready failed, not in a room'),
      );
      return;
    }
    await _sendMessage(
      SetMessage(
        setJoined: true,
        username: _username,
        room: _currentRoom,
      ),
    );
    await _sendMessage(
      SetMessage(
        setReady: true,
      ),
    );
  }

  Future<void> _sendMessage(SyncplayMessage message) async {
    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 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 _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,
      bool stateChange = false}) {
    int? clientArck;
    int? serverAck;
    if (stateChange) {
      _clientIgnoringOnTheFly = _clientIgnoringOnTheFly + 1;
    }
    if (_serverIgnoringOnTheFly > 0) {
      serverAck = _serverIgnoringOnTheFly;
      _serverIgnoringOnTheFly = 0;
    }
    if (_clientIgnoringOnTheFly > 0) {
      clientArck = _clientIgnoringOnTheFly;
    }
    return _sendMessage(StateMessage(
      position: position ?? _currentPositon,
      paused: paused ?? _isPaused,
      latencyCalculation: _lastLatencyCalculation,
      clientLatencyCalculation: DateTime.now().millisecondsSinceEpoch / 1000.0,
      clientRtt: _clientRtt,
      setBy: _username,
      clientAck: clientArck,
      serverAck: serverAck,
      doSeek: doSeek,
    ));
  }

  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;

    // Calculate RTT: current time minus the passed timestamp
    double newClientRtt =
        DateTime.now().millisecondsSinceEpoch / 1000.0 - timestamp;

    // If the new RTT is less than 0, it means the server is not responding
    if (newClientRtt < 0 || senderRtt < 0) return;
    _clientRtt = newClientRtt;

    // If it's the first time calculating, initialize the average RTT
    if (_avrRtt == 0) {
      _avrRtt = _clientRtt;
    }

    // Use moving average to update RTT, smooth the delay data
    _avrRtt = _avrRtt * _pingMovingAverageWeight +
        _clientRtt * (1 - _pingMovingAverageWeight);

    // Calculate the forward delay based on the sender's RTT
    if (senderRtt < _clientRtt) {
      _fd = _avrRtt / 2 + (_clientRtt - senderRtt);
    } else {
      _fd = _avrRtt / 2;
    }
  }
}