815 lines
27 KiB
Dart
815 lines
27 KiB
Dart
part of 'api_service.dart';
|
||
|
||
extension ApiServiceConnection on ApiService {
|
||
Future<void> _connectWithFallback() async {
|
||
_log('Начало подключения...');
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.connecting,
|
||
message: 'Поиск доступного сервера',
|
||
);
|
||
|
||
while (_currentUrlIndex < _wsUrls.length) {
|
||
final currentUrl = _wsUrls[_currentUrlIndex];
|
||
final logMessage =
|
||
'Попытка ${_currentUrlIndex + 1}/${_wsUrls.length}: $currentUrl';
|
||
_log(logMessage);
|
||
_connectionLogController.add(logMessage);
|
||
|
||
try {
|
||
await _connectToUrl(currentUrl);
|
||
final successMessage = _currentUrlIndex == 0
|
||
? 'Подключено к основному серверу'
|
||
: 'Подключено через резервный сервер';
|
||
_connectionLogController.add('✅ $successMessage');
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.connecting,
|
||
message: 'Соединение установлено, ожидание handshake',
|
||
metadata: {'server': currentUrl},
|
||
);
|
||
if (_currentUrlIndex > 0) {
|
||
_connectionStatusController.add('Подключено через резервный сервер');
|
||
}
|
||
return;
|
||
} catch (e) {
|
||
final errorMessage = '❌ Ошибка: ${e.toString().split(':').first}';
|
||
print('Ошибка подключения к $currentUrl: $e');
|
||
_connectionLogController.add(errorMessage);
|
||
_healthMonitor.onError(errorMessage);
|
||
_currentUrlIndex++;
|
||
|
||
if (_currentUrlIndex < _wsUrls.length) {
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
}
|
||
}
|
||
}
|
||
|
||
_log('❌ Все серверы недоступны');
|
||
_connectionStatusController.add('Все серверы недоступны');
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.error,
|
||
message: 'Все серверы недоступны',
|
||
);
|
||
_stopHealthMonitoring();
|
||
throw Exception('Не удалось подключиться ни к одному серверу');
|
||
}
|
||
|
||
Future<void> _connectToUrl(String url) async {
|
||
_isSessionOnline = false;
|
||
_onlineCompleter = Completer<void>();
|
||
_currentServerUrl = url;
|
||
final bool hadChatsFetched = _chatsFetchedInThisSession;
|
||
final bool hasValidToken = authToken != null;
|
||
|
||
if (!hasValidToken) {
|
||
_chatsFetchedInThisSession = false;
|
||
} else {
|
||
_chatsFetchedInThisSession = hadChatsFetched;
|
||
}
|
||
|
||
_connectionStatusController.add('connecting');
|
||
|
||
final uri = Uri.parse(url);
|
||
print(
|
||
'Parsed URI: host=${uri.host}, port=${uri.port}, scheme=${uri.scheme}',
|
||
);
|
||
|
||
final spoofedData = await SpoofingService.getSpoofedSessionData();
|
||
final userAgent =
|
||
spoofedData?['useragent'] as String? ??
|
||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
|
||
|
||
final headers = <String, String>{
|
||
'Origin': 'https://web.max.ru',
|
||
'User-Agent': userAgent,
|
||
'Sec-WebSocket-Extensions': 'permessage-deflate',
|
||
};
|
||
|
||
final proxySettings = await ProxyService.instance.loadProxySettings();
|
||
|
||
if (proxySettings.isEnabled && proxySettings.host.isNotEmpty) {
|
||
print(
|
||
'Используем ${proxySettings.protocol.name.toUpperCase()} прокси ${proxySettings.host}:${proxySettings.port}',
|
||
);
|
||
final customHttpClient = await ProxyService.instance
|
||
.getHttpClientWithProxy();
|
||
_channel = IOWebSocketChannel.connect(
|
||
uri,
|
||
headers: headers,
|
||
customClient: customHttpClient,
|
||
);
|
||
} else {
|
||
print('Подключение без прокси');
|
||
_channel = IOWebSocketChannel.connect(uri, headers: headers);
|
||
}
|
||
|
||
await _channel!.ready;
|
||
_listen();
|
||
await _sendHandshake();
|
||
_startPinging();
|
||
}
|
||
|
||
void _handleSessionTerminated() {
|
||
print("Сессия была завершена сервером");
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_stopHealthMonitoring();
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.disconnected,
|
||
message: 'Сессия завершена сервером',
|
||
);
|
||
|
||
authToken = null;
|
||
|
||
clearAllCaches();
|
||
|
||
_messageController.add({
|
||
'type': 'session_terminated',
|
||
'message': 'Твоя сессия больше не активна, войди снова',
|
||
});
|
||
}
|
||
|
||
void _handleInvalidToken() async {
|
||
print("Обработка недействительного токена");
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_stopHealthMonitoring();
|
||
_healthMonitor.onError('invalid_token');
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.error,
|
||
message: 'Недействительный токен',
|
||
);
|
||
|
||
authToken = null;
|
||
final prefs = await SharedPreferences.getInstance();
|
||
await prefs.remove('authToken');
|
||
|
||
clearAllCaches();
|
||
|
||
_channel?.sink.close();
|
||
_channel = null;
|
||
_pingTimer?.cancel();
|
||
|
||
_messageController.add({
|
||
'type': 'invalid_token',
|
||
'message': 'Токен недействителен, требуется повторная авторизация',
|
||
});
|
||
}
|
||
|
||
Future<void> _sendHandshake() async {
|
||
if (_handshakeSent) {
|
||
print('Handshake уже отправлен, пропускаем...');
|
||
return;
|
||
}
|
||
|
||
print('Отправляем handshake...');
|
||
|
||
final userAgentPayload = await _buildUserAgentPayload();
|
||
|
||
final prefs = await SharedPreferences.getInstance();
|
||
final deviceId =
|
||
prefs.getString('spoof_deviceid') ?? generateRandomDeviceId();
|
||
|
||
if (prefs.getString('spoof_deviceid') == null) {
|
||
await prefs.setString('spoof_deviceid', deviceId);
|
||
}
|
||
|
||
final payload = {'deviceId': deviceId, 'userAgent': userAgentPayload};
|
||
|
||
print('Отправляем handshake с payload: $payload');
|
||
_sendMessage(6, payload);
|
||
_handshakeSent = true;
|
||
print('Handshake отправлен, ожидаем ответ...');
|
||
}
|
||
|
||
void _startPinging() {
|
||
_pingTimer?.cancel();
|
||
_pingTimer = Timer.periodic(const Duration(seconds: 25), (timer) {
|
||
if (_isSessionOnline && _isSessionReady && _isAppInForeground) {
|
||
print("Отправляем Ping для поддержания сессии...");
|
||
_sendMessage(1, {"interactive": true});
|
||
} else {
|
||
print("Сессия не готова, пропускаем ping");
|
||
}
|
||
});
|
||
}
|
||
|
||
Future<void> connect() async {
|
||
if (_channel != null && _isSessionOnline) {
|
||
print("WebSocket уже подключен, пропускаем подключение");
|
||
return;
|
||
}
|
||
|
||
print("Запускаем подключение к WebSocket...");
|
||
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
|
||
_connectionStatusController.add("connecting");
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.connecting,
|
||
message: 'Инициализация подключения',
|
||
);
|
||
await _connectWithFallback();
|
||
}
|
||
|
||
Future<void> reconnect() async {
|
||
_reconnectAttempts = 0;
|
||
_currentUrlIndex = 0;
|
||
|
||
_connectionStatusController.add("connecting");
|
||
await _connectWithFallback();
|
||
}
|
||
|
||
void sendFullJsonRequest(String jsonString) {
|
||
if (_channel == null) {
|
||
throw Exception('WebSocket is not connected. Connect first.');
|
||
}
|
||
_log('➡️ SEND (raw): $jsonString');
|
||
_channel!.sink.add(jsonString);
|
||
}
|
||
|
||
int sendRawRequest(int opcode, Map<String, dynamic> payload) {
|
||
if (_channel == null) {
|
||
print('WebSocket не подключен!');
|
||
throw Exception('WebSocket is not connected. Connect first.');
|
||
}
|
||
|
||
return _sendMessage(opcode, payload);
|
||
}
|
||
|
||
int sendAndTrackFullJsonRequest(String jsonString) {
|
||
if (_channel == null) {
|
||
throw Exception('WebSocket is not connected. Connect first.');
|
||
}
|
||
|
||
final message = jsonDecode(jsonString) as Map<String, dynamic>;
|
||
|
||
final int currentSeq = _seq++;
|
||
|
||
message['seq'] = currentSeq;
|
||
|
||
final encodedMessage = jsonEncode(message);
|
||
|
||
_log('➡️ SEND (custom): $encodedMessage');
|
||
print('Отправляем кастомное сообщение (seq: $currentSeq): $encodedMessage');
|
||
|
||
_channel!.sink.add(encodedMessage);
|
||
|
||
return currentSeq;
|
||
}
|
||
|
||
int _sendMessage(int opcode, Map<String, dynamic> payload) {
|
||
if (_channel == null) {
|
||
print('WebSocket не подключен!');
|
||
return -1;
|
||
}
|
||
final message = {
|
||
"ver": 11,
|
||
"cmd": 0,
|
||
"seq": _seq,
|
||
"opcode": opcode,
|
||
"payload": payload,
|
||
};
|
||
final encodedMessage = jsonEncode(message);
|
||
if (opcode == 1) {
|
||
_log('➡️ SEND (ping) seq: $_seq');
|
||
} else if (opcode == 18 || opcode == 19) {
|
||
Map<String, dynamic> loggablePayload = Map.from(payload);
|
||
if (loggablePayload.containsKey('token')) {
|
||
String token = loggablePayload['token'] as String;
|
||
|
||
loggablePayload['token'] = token.length > 8
|
||
? '${token.substring(0, 4)}...${token.substring(token.length - 4)}'
|
||
: '***';
|
||
}
|
||
final loggableMessage = {...message, 'payload': loggablePayload};
|
||
_log('➡️ SEND: ${jsonEncode(loggableMessage)}');
|
||
} else {
|
||
_log('➡️ SEND: $encodedMessage');
|
||
}
|
||
print('Отправляем сообщение (seq: $_seq): $encodedMessage');
|
||
_channel!.sink.add(encodedMessage);
|
||
return _seq++;
|
||
}
|
||
|
||
void _listen() async {
|
||
_streamSubscription?.cancel();
|
||
_streamSubscription = _channel?.stream.listen(
|
||
(message) {
|
||
if (message == null) return;
|
||
if (message is String && message.trim().isEmpty) {
|
||
return;
|
||
}
|
||
|
||
String loggableMessage = message;
|
||
try {
|
||
final decoded = jsonDecode(message) as Map<String, dynamic>;
|
||
if (decoded['opcode'] == 2) {
|
||
_healthMonitor.onPongReceived();
|
||
loggableMessage = '⬅️ RECV (pong) seq: ${decoded['seq']}';
|
||
} else {
|
||
Map<String, dynamic> loggableDecoded = Map.from(decoded);
|
||
bool wasModified = false;
|
||
if (loggableDecoded.containsKey('payload') &&
|
||
loggableDecoded['payload'] is Map) {
|
||
Map<String, dynamic> payload = Map.from(
|
||
loggableDecoded['payload'],
|
||
);
|
||
if (payload.containsKey('token')) {
|
||
String token = payload['token'] as String;
|
||
payload['token'] = token.length > 8
|
||
? '${token.substring(0, 4)}...${token.substring(token.length - 4)}'
|
||
: '***';
|
||
loggableDecoded['payload'] = payload;
|
||
wasModified = true;
|
||
}
|
||
}
|
||
if (wasModified) {
|
||
loggableMessage = '⬅️ RECV: ${jsonEncode(loggableDecoded)}';
|
||
} else {
|
||
loggableMessage = '⬅️ RECV: $message';
|
||
}
|
||
}
|
||
} catch (_) {
|
||
loggableMessage = '⬅️ RECV (raw): $message';
|
||
}
|
||
_log(loggableMessage);
|
||
|
||
try {
|
||
final decodedMessage = message is String
|
||
? jsonDecode(message)
|
||
: message;
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 97 &&
|
||
decodedMessage['cmd'] == 1 &&
|
||
decodedMessage['payload'] != null &&
|
||
decodedMessage['payload']['token'] != null) {
|
||
_handleSessionTerminated();
|
||
return;
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 6 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
print("Handshake успешен. Сессия ONLINE.");
|
||
_isSessionOnline = true;
|
||
_isSessionReady = false;
|
||
_reconnectDelaySeconds = 2;
|
||
_connectionStatusController.add("authorizing");
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.connected,
|
||
message: 'Handshake успешен',
|
||
);
|
||
_startHealthMonitoring();
|
||
|
||
_startPinging();
|
||
_processMessageQueue();
|
||
|
||
if (authToken != null && !_chatsFetchedInThisSession) {
|
||
print(
|
||
"Токен найден, автоматически запускаем авторизацию (opcode 19)...",
|
||
);
|
||
unawaited(_sendAuthRequestAfterHandshake());
|
||
} else if (authToken == null) {
|
||
print(
|
||
"Токен не найден, завершаем ожидание для неавторизованной сессии",
|
||
);
|
||
_isSessionReady = true;
|
||
if (_onlineCompleter != null && !_onlineCompleter!.isCompleted) {
|
||
_onlineCompleter!.complete();
|
||
}
|
||
}
|
||
}
|
||
|
||
if (decodedMessage is Map && decodedMessage['cmd'] == 3) {
|
||
final error = decodedMessage['payload'];
|
||
print('Ошибка сервера: $error');
|
||
_healthMonitor.onError(error?['message'] ?? 'server_error');
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.error,
|
||
message: error?['message'],
|
||
);
|
||
|
||
if (error != null && error['localizedMessage'] != null) {
|
||
_errorController.add(error['localizedMessage']);
|
||
} else if (error != null && error['message'] != null) {
|
||
_errorController.add(error['message']);
|
||
}
|
||
|
||
if (error != null && error['message'] == 'FAIL_WRONG_PASSWORD') {
|
||
_errorController.add('FAIL_WRONG_PASSWORD');
|
||
}
|
||
|
||
if (error != null && error['error'] == 'password.invalid') {
|
||
_errorController.add('Неверный пароль');
|
||
}
|
||
|
||
if (error != null && error['error'] == 'proto.state') {
|
||
print('Ошибка состояния сессии, переподключаемся...');
|
||
_chatsFetchedInThisSession = false;
|
||
_reconnect();
|
||
return;
|
||
}
|
||
|
||
if (error != null && error['error'] == 'login.token') {
|
||
print('Токен недействителен, очищаем и завершаем сессию...');
|
||
_handleInvalidToken();
|
||
return;
|
||
}
|
||
|
||
if (error != null && error['message'] == 'FAIL_WRONG_PASSWORD') {
|
||
print('Неверный токен авторизации, очищаем токен...');
|
||
_clearAuthToken().then((_) {
|
||
_chatsFetchedInThisSession = false;
|
||
_messageController.add({
|
||
'type': 'invalid_token',
|
||
'message':
|
||
'Токен авторизации недействителен. Требуется повторная авторизация.',
|
||
});
|
||
_reconnect();
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 18 &&
|
||
decodedMessage['cmd'] == 1 &&
|
||
decodedMessage['payload'] != null) {
|
||
final payload = decodedMessage['payload'];
|
||
if (payload['passwordChallenge'] != null) {
|
||
final challenge = payload['passwordChallenge'];
|
||
_currentPasswordTrackId = challenge['trackId'];
|
||
_currentPasswordHint = challenge['hint'];
|
||
_currentPasswordEmail = challenge['email'];
|
||
|
||
print(
|
||
'Получен запрос на ввод пароля: trackId=${challenge['trackId']}, hint=${challenge['hint']}, email=${challenge['email']}',
|
||
);
|
||
|
||
_messageController.add({
|
||
'type': 'password_required',
|
||
'trackId': _currentPasswordTrackId,
|
||
'hint': _currentPasswordHint,
|
||
'email': _currentPasswordEmail,
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 22 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Настройки приватности успешно обновлены: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'privacy_settings_updated',
|
||
'settings': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 116 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Пароль успешно установлен: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'password_set_success',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 57 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Успешно присоединились к группе: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'group_join_success',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 46 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Контакт найден: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'contact_found',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 46 &&
|
||
decodedMessage['cmd'] == 3) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Контакт не найден: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'contact_not_found',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 32 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Каналы найдены: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channels_found',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 32 &&
|
||
decodedMessage['cmd'] == 3) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Каналы не найдены: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channels_not_found',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 89 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Вход в канал успешен: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channel_entered',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 89 &&
|
||
decodedMessage['cmd'] == 3) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Ошибка входа в канал: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channel_error',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 57 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Подписка на канал успешна: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channel_subscribed',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 57 &&
|
||
decodedMessage['cmd'] == 3) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Ошибка подписки на канал: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'channel_error',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 59 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Получены участники группы: $payload');
|
||
|
||
_messageController.add({
|
||
'type': 'group_members',
|
||
'payload': payload,
|
||
});
|
||
}
|
||
|
||
if (decodedMessage is Map &&
|
||
decodedMessage['opcode'] == 162 &&
|
||
decodedMessage['cmd'] == 1) {
|
||
final payload = decodedMessage['payload'];
|
||
print('Получены данные жалоб: $payload');
|
||
|
||
try {
|
||
final complaintData = ComplaintData.fromJson(payload);
|
||
_messageController.add({
|
||
'type': 'complaints_data',
|
||
'complaintData': complaintData,
|
||
});
|
||
} catch (e) {
|
||
print('Ошибка парсинга данных жалоб: $e');
|
||
}
|
||
}
|
||
|
||
if (decodedMessage is Map<String, dynamic>) {
|
||
_messageController.add(decodedMessage);
|
||
}
|
||
} catch (e) {
|
||
print('Невалидное сообщение от сервера, пропускаем: $e');
|
||
}
|
||
},
|
||
onError: (error) {
|
||
print('Ошибка WebSocket: $error');
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_healthMonitor.onError(error.toString());
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.error,
|
||
message: error.toString(),
|
||
);
|
||
_reconnect();
|
||
},
|
||
onDone: () {
|
||
print('WebSocket соединение закрыто. Попытка переподключения...');
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_stopHealthMonitoring();
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.disconnected,
|
||
message: 'Соединение закрыто',
|
||
);
|
||
|
||
if (!_isSessionReady) {
|
||
_reconnect();
|
||
}
|
||
},
|
||
cancelOnError: true,
|
||
);
|
||
}
|
||
|
||
void _reconnect() {
|
||
if (_isReconnecting) return;
|
||
|
||
_isReconnecting = true;
|
||
_reconnectAttempts++;
|
||
_healthMonitor.onReconnect();
|
||
|
||
if (_reconnectAttempts > ApiService._maxReconnectAttempts) {
|
||
print(
|
||
"Превышено максимальное количество попыток переподключения (${ApiService._maxReconnectAttempts}). Останавливаем попытки.",
|
||
);
|
||
_connectionStatusController.add("disconnected");
|
||
_isReconnecting = false;
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.error,
|
||
message: 'Превышено число попыток переподключения',
|
||
);
|
||
return;
|
||
}
|
||
|
||
_pingTimer?.cancel();
|
||
_reconnectTimer?.cancel();
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_handshakeSent = false;
|
||
_onlineCompleter = Completer<void>();
|
||
_chatsFetchedInThisSession = false;
|
||
|
||
_currentUrlIndex = 0;
|
||
|
||
_reconnectDelaySeconds = (_reconnectDelaySeconds * 2).clamp(1, 30);
|
||
final jitter = (DateTime.now().millisecondsSinceEpoch % 1000) / 1000.0;
|
||
final delay = Duration(seconds: _reconnectDelaySeconds + jitter.round());
|
||
|
||
_reconnectTimer = Timer(delay, () {
|
||
print(
|
||
"Переподключаемся после ${delay.inSeconds}s... (попытка $_reconnectAttempts/${ApiService._maxReconnectAttempts})",
|
||
);
|
||
_isReconnecting = false;
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.reconnecting,
|
||
attemptNumber: _reconnectAttempts,
|
||
reconnectDelay: delay,
|
||
);
|
||
_connectWithFallback();
|
||
});
|
||
}
|
||
|
||
void _processMessageQueue() {
|
||
if (_messageQueue.isEmpty) return;
|
||
print("Отправка ${_messageQueue.length} сообщений из очереди...");
|
||
for (var message in _messageQueue) {
|
||
_sendMessage(message['opcode'], message['payload']);
|
||
}
|
||
_messageQueue.clear();
|
||
}
|
||
|
||
void forceReconnect() {
|
||
print("Принудительное переподключение...");
|
||
|
||
_pingTimer?.cancel();
|
||
_reconnectTimer?.cancel();
|
||
if (_channel != null) {
|
||
print("Закрываем существующее соединение...");
|
||
_channel!.sink.close(status.goingAway);
|
||
_channel = null;
|
||
}
|
||
|
||
_isReconnecting = false;
|
||
_reconnectAttempts = 0;
|
||
_reconnectDelaySeconds = 2;
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_chatsFetchedInThisSession = false;
|
||
_currentUrlIndex = 0;
|
||
_onlineCompleter = Completer<void>();
|
||
|
||
_messageQueue.clear();
|
||
_presenceData.clear();
|
||
|
||
_connectionStatusController.add("connecting");
|
||
_log("Запускаем новую сессию подключения...");
|
||
|
||
_connectWithFallback();
|
||
}
|
||
|
||
Future<void> performFullReconnection() async {
|
||
print("🔄 Начинаем полное переподключение...");
|
||
try {
|
||
_pingTimer?.cancel();
|
||
_reconnectTimer?.cancel();
|
||
_streamSubscription?.cancel();
|
||
|
||
if (_channel != null) {
|
||
_channel!.sink.close();
|
||
_channel = null;
|
||
}
|
||
|
||
_isReconnecting = false;
|
||
_reconnectAttempts = 0;
|
||
_reconnectDelaySeconds = 2;
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_handshakeSent = false;
|
||
_chatsFetchedInThisSession = false;
|
||
_currentUrlIndex = 0;
|
||
_onlineCompleter = Completer<void>();
|
||
_seq = 0;
|
||
|
||
_lastChatsPayload = null;
|
||
_lastChatsAt = null;
|
||
|
||
print(
|
||
" Кэш чатов очищен: _lastChatsPayload = $_lastChatsPayload, _chatsFetchedInThisSession = $_chatsFetchedInThisSession",
|
||
);
|
||
|
||
_connectionStatusController.add("disconnected");
|
||
|
||
await connect();
|
||
|
||
print(" Полное переподключение завершено");
|
||
|
||
await Future.delayed(const Duration(milliseconds: 1500));
|
||
|
||
if (!_reconnectionCompleteController.isClosed) {
|
||
print(" Отправляем уведомление о завершении переподключения");
|
||
_reconnectionCompleteController.add(null);
|
||
}
|
||
} catch (e) {
|
||
print("Ошибка полного переподключения: $e");
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
void disconnect() {
|
||
print("Отключаем WebSocket...");
|
||
_pingTimer?.cancel();
|
||
_reconnectTimer?.cancel();
|
||
_streamSubscription?.cancel();
|
||
_isSessionOnline = false;
|
||
_isSessionReady = false;
|
||
_handshakeSent = false;
|
||
_onlineCompleter = Completer<void>();
|
||
_chatsFetchedInThisSession = false;
|
||
_stopHealthMonitoring();
|
||
_updateConnectionState(
|
||
conn_state.ConnectionState.disconnected,
|
||
message: 'Отключено пользователем',
|
||
);
|
||
|
||
_channel?.sink.close(status.goingAway);
|
||
_channel = null;
|
||
_streamSubscription = null;
|
||
|
||
_connectionStatusController.add("disconnected");
|
||
}
|
||
}
|