1841 lines
62 KiB
Dart
1841 lines
62 KiB
Dart
import 'dart:async';
|
||
import 'dart:io';
|
||
import 'dart:typed_data';
|
||
import 'package:flutter/material.dart';
|
||
import 'package:cryptography/cryptography.dart';
|
||
import '/data/models/message_model.dart';
|
||
import '/data/models/contact_model.dart';
|
||
import 'package:chepuhagram/presentation/widgets/message_bubble.dart';
|
||
import 'package:gal/gal.dart';
|
||
import 'package:chepuhagram/data/repositories/contact_repository.dart';
|
||
import 'package:chepuhagram/domain/services/crypto_service.dart';
|
||
import 'package:chepuhagram/data/datasources/ws_client.dart';
|
||
import 'package:provider/provider.dart';
|
||
import '/logic/contact_provider.dart';
|
||
import '../../domain/services/api_service.dart';
|
||
import 'dart:math';
|
||
import 'package:chepuhagram/data/datasources/local_db_service.dart';
|
||
import 'package:chepuhagram/main.dart';
|
||
import 'package:shared_preferences/shared_preferences.dart';
|
||
import 'contacts_screen.dart';
|
||
import 'package:flutter/services.dart';
|
||
import 'user_profile_screen.dart';
|
||
import 'package:image_picker/image_picker.dart';
|
||
import '/core/theme_manager.dart';
|
||
|
||
class ChatScreen extends StatefulWidget {
|
||
final Contact contact;
|
||
|
||
const ChatScreen({super.key, required this.contact});
|
||
|
||
@override
|
||
State<ChatScreen> createState() => _ChatScreenState();
|
||
}
|
||
|
||
class _ChatScreenState extends State<ChatScreen> with RouteAware {
|
||
static const String _notificationLaunchKey = 'notification_launch_data';
|
||
int myId = 0;
|
||
late Contact _currentContact;
|
||
bool _isKeyLoading = true;
|
||
final TextEditingController _controller = TextEditingController();
|
||
final FocusNode _inputFocusNode = FocusNode();
|
||
final ContactRepository _contactRepository = ContactRepository();
|
||
final apiService = ApiService();
|
||
final CryptoService _cryptoService = CryptoService();
|
||
List<MessageModel> messages = [];
|
||
StreamSubscription<dynamic>? _socketSubscription;
|
||
final Set<int> _sentReadReceipts = <int>{};
|
||
final LocalDbService _localDbService = LocalDbService();
|
||
final ScrollController _scrollController = ScrollController();
|
||
final Map<int, GlobalKey> _messageKeys = {};
|
||
bool _showScrollToEnd = false;
|
||
Uint8List? _pendingImageBytes;
|
||
MessageModel? _replyTo;
|
||
bool _isOnline = false;
|
||
DateTime? _lastOnline;
|
||
Timer? _onlineTimer;
|
||
DateTime? _lastTypingSent;
|
||
bool _isTyping = false;
|
||
Timer? _typingTimer;
|
||
late SocketService _socketService;
|
||
|
||
@override
|
||
void initState() {
|
||
super.initState();
|
||
_currentContact = widget.contact;
|
||
_socketService = Provider.of<SocketService>(context, listen: false);
|
||
currentActiveChatContactId =
|
||
_currentContact.id; // Устанавливаем активный чат
|
||
flutterLocalNotificationsPlugin.cancel(currentActiveChatContactId!);
|
||
final contactProvider = context.read<ContactProvider>();
|
||
myId = contactProvider.getCurrentUserId() ?? 0;
|
||
// Если ключа нет, загружаем его при входе
|
||
_loadLocalName();
|
||
if (_currentContact.publicKey == null) {
|
||
_loadContactKey();
|
||
}
|
||
_loadHistory();
|
||
_loadOnlineStatus();
|
||
startOnlineUpdates();
|
||
_controller.addListener(_sendTypingStatus);
|
||
|
||
_scrollController.addListener(_updateScrollButtonVisibility);
|
||
|
||
final socketService = Provider.of<SocketService>(context, listen: false);
|
||
_socketSubscription = socketService.messages.listen(_handleIncomingMessage);
|
||
}
|
||
|
||
@override
|
||
void didChangeDependencies() {
|
||
super.didChangeDependencies();
|
||
routeObserver.subscribe(this, ModalRoute.of(context) as PageRoute);
|
||
}
|
||
|
||
@override
|
||
void didPopNext() {
|
||
print("Пользователь вернулся на этот экран!");
|
||
_loadLocalName();
|
||
flutterLocalNotificationsPlugin.cancel(currentActiveChatContactId!);
|
||
}
|
||
|
||
Future<void> _loadLocalName() async {
|
||
final prefs = await SharedPreferences.getInstance();
|
||
|
||
final String? savedName = prefs.getString(
|
||
'firstname_${_currentContact.id}',
|
||
);
|
||
final String? savedSurname = prefs.getString(
|
||
'lastname_${_currentContact.id}',
|
||
);
|
||
print('Загружены имя $savedName, $savedSurname');
|
||
if (mounted) {
|
||
setState(() {
|
||
if (savedName != null) {
|
||
_currentContact.name = savedName;
|
||
}
|
||
if (savedSurname != null) {
|
||
_currentContact.surname = savedSurname;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
void _sendTypingStatus() {
|
||
final now = DateTime.now();
|
||
if (_lastTypingSent == null ||
|
||
now.difference(_lastTypingSent!) > const Duration(seconds: 3)) {
|
||
_lastTypingSent = now;
|
||
final socketService = Provider.of<SocketService>(context, listen: false);
|
||
socketService.sendMessage({
|
||
'type': 'typing',
|
||
'receiver_id': _currentContact.id,
|
||
});
|
||
}
|
||
}
|
||
|
||
void _sendStopTypingStatus() {
|
||
_socketService.sendMessage({
|
||
'type': 'stop_typing',
|
||
'receiver_id': _currentContact.id,
|
||
});
|
||
}
|
||
|
||
Future<void> _loadOnlineStatus() async {
|
||
flutterLocalNotificationsPlugin.cancel(currentActiveChatContactId!);
|
||
try {
|
||
print(
|
||
"🔍 Загружаем онлайн статус для контакта ${_currentContact.name} (ID: ${_currentContact.id})",
|
||
);
|
||
final data = await apiService.getUserById(_currentContact.id);
|
||
if (!mounted) return;
|
||
DateTime now = DateTime.now();
|
||
|
||
Duration offset = now.timeZoneOffset;
|
||
print(
|
||
"✅ Получен онлайн статус: ${data['online']}, last_online: ${data['last_online'] != null ? DateTime.tryParse(data['last_online']!)?.add(offset) : null}",
|
||
);
|
||
|
||
setState(() {
|
||
_isOnline = data['online'] ?? false;
|
||
if (data['last_online'] != null)
|
||
_lastOnline = DateTime.parse(data['last_online']).add(offset);
|
||
else
|
||
_lastOnline = null;
|
||
});
|
||
} catch (e) {
|
||
print("❌ ОШИБКА ПРИ ЗАГРУЗКЕ СТАТУСА ОНЛАЙН: $e");
|
||
// Игнорируем ошибки при загрузке статуса
|
||
}
|
||
}
|
||
|
||
void startOnlineUpdates() {
|
||
_onlineTimer = Timer.periodic(const Duration(minutes: 1), (_) {
|
||
_loadOnlineStatus();
|
||
});
|
||
}
|
||
|
||
Future<void> _loadContactKey() async {
|
||
if (!mounted) return;
|
||
setState(() => _isKeyLoading = true);
|
||
try {
|
||
final updatedContact = await _contactRepository.fetchContactById(
|
||
_currentContact.id,
|
||
);
|
||
if (!mounted) return;
|
||
setState(() {
|
||
_currentContact = updatedContact;
|
||
_isKeyLoading = false;
|
||
});
|
||
print(updatedContact.publicKey);
|
||
} catch (e) {
|
||
if (!mounted) return;
|
||
setState(() => _isKeyLoading = false);
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text("Не удалось получить ключ шифрования собеседника"),
|
||
behavior: SnackBarBehavior.floating, // Обязательно для margin
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
duration: Duration(seconds: 3),
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
@override
|
||
void dispose() {
|
||
currentActiveChatContactId = null;
|
||
_socketSubscription?.cancel();
|
||
_scrollController.removeListener(_updateScrollButtonVisibility);
|
||
_scrollController.dispose();
|
||
_controller.dispose();
|
||
routeObserver.unsubscribe(this);
|
||
_inputFocusNode.dispose();
|
||
_onlineTimer?.cancel();
|
||
_typingTimer?.cancel();
|
||
_controller.removeListener(_sendTypingStatus);
|
||
_sendStopTypingStatus();
|
||
super.dispose();
|
||
}
|
||
|
||
@override
|
||
Widget build(BuildContext context) {
|
||
final themeProv = context.watch<ThemeProvider>();
|
||
return Scaffold(
|
||
appBar: AppBar(
|
||
leading: IconButton(
|
||
icon: const Icon(Icons.arrow_back),
|
||
onPressed: () {
|
||
if (Navigator.canPop(context)) {
|
||
Navigator.pop(context);
|
||
} else {
|
||
Navigator.of(context).pushReplacement(
|
||
MaterialPageRoute(builder: (_) => const ContactsScreen()),
|
||
);
|
||
}
|
||
},
|
||
),
|
||
title: GestureDetector(
|
||
onTap: () {
|
||
Navigator.push(
|
||
context,
|
||
MaterialPageRoute(
|
||
builder: (_) => UserProfileScreen(
|
||
userId: _currentContact.id,
|
||
username: _currentContact.username,
|
||
name: _currentContact.name,
|
||
),
|
||
),
|
||
);
|
||
},
|
||
child: Column(
|
||
crossAxisAlignment: CrossAxisAlignment.start,
|
||
children: [
|
||
Text(
|
||
'${_currentContact.name} ${_currentContact.surname != 'Unknown' ? _currentContact.surname : ''}',
|
||
),
|
||
if (_isKeyLoading == true)
|
||
const Text(
|
||
'загрузка...',
|
||
style: const TextStyle(
|
||
fontSize: 12,
|
||
color: Color.fromARGB(255, 219, 219, 219),
|
||
),
|
||
)
|
||
else if (_isTyping)
|
||
Row(
|
||
crossAxisAlignment: CrossAxisAlignment.center,
|
||
children: [
|
||
const Text(
|
||
'печатает',
|
||
style: TextStyle(fontSize: 12, color: Colors.greenAccent),
|
||
),
|
||
const SizedBox(width: 4),
|
||
TypingIndicator(),
|
||
],
|
||
)
|
||
else if (_isOnline)
|
||
const Text(
|
||
'онлайн',
|
||
style: TextStyle(fontSize: 12, color: Colors.greenAccent),
|
||
)
|
||
else if (_lastOnline != null)
|
||
Text(
|
||
'был(а) в сети ${_formatLastOnline(_lastOnline!)}',
|
||
style: const TextStyle(
|
||
fontSize: 12,
|
||
color: Color.fromARGB(255, 219, 219, 219),
|
||
),
|
||
)
|
||
else
|
||
const Text(
|
||
'был(а) недавно',
|
||
style: TextStyle(
|
||
fontSize: 12,
|
||
color: Color.fromARGB(255, 219, 219, 219),
|
||
),
|
||
),
|
||
],
|
||
),
|
||
),
|
||
),
|
||
body: Column(
|
||
children: [
|
||
Expanded(
|
||
child: Container(
|
||
decoration: themeProv.wallpaperPath != null
|
||
? BoxDecoration(
|
||
image: DecorationImage(
|
||
image: FileImage(File(themeProv.wallpaperPath!)),
|
||
fit: BoxFit.cover,
|
||
),
|
||
)
|
||
: null,
|
||
child: ListView.builder(
|
||
controller: _scrollController,
|
||
reverse: true, // Сообщения растут снизу вверх
|
||
itemCount: messages.length,
|
||
itemBuilder: (context, index) {
|
||
final msg = messages[messages.length - 1 - index];
|
||
final keyId = msg.id ?? msg.tempId ?? index;
|
||
final itemKey = _messageKeys.putIfAbsent(
|
||
keyId,
|
||
() => GlobalKey(),
|
||
);
|
||
return MessageBubble(
|
||
key: itemKey,
|
||
message: msg,
|
||
onTap: () => _showMessageActions(msg),
|
||
onReplyTap: msg.replyToId != null
|
||
? () => _scrollToMessage(msg.replyToId)
|
||
: null,
|
||
onImageTap: msg.messageType == MessageType.image
|
||
? () => _openFullScreenImage(msg)
|
||
: null,
|
||
onImageNeeded: _loadImageBytesForMessage,
|
||
);
|
||
},
|
||
),
|
||
),
|
||
),
|
||
_buildMessageInput(),
|
||
],
|
||
),
|
||
floatingActionButton: _showScrollToEnd
|
||
? FloatingActionButton(
|
||
onPressed: _scrollToBottom,
|
||
child: const Icon(Icons.keyboard_arrow_down),
|
||
tooltip: 'Перейти к последнему сообщению',
|
||
)
|
||
: null,
|
||
);
|
||
}
|
||
|
||
String _formatLastOnline(DateTime lastOnline) {
|
||
final now = DateTime.now();
|
||
final difference = now.difference(lastOnline);
|
||
|
||
if (difference.inSeconds < 60) {
|
||
return 'только что';
|
||
} else if (difference.inMinutes < 60) {
|
||
return '${difference.inMinutes} минут${_pluralize(difference.inMinutes, "у", "ы", "")} назад';
|
||
} else if (difference.inHours < 24) {
|
||
return '${difference.inHours} час${_pluralize(difference.inHours, "", "а", "ов")} назад';
|
||
} else if (difference.inDays < 7) {
|
||
return '${difference.inDays} ${_pluralize(difference.inDays, "день", "дня", "дней")} назад';
|
||
} else {
|
||
return 'давно';
|
||
}
|
||
}
|
||
|
||
String _pluralize(int count, String form1, String form2, String form5) {
|
||
final mod10 = count % 10;
|
||
final mod100 = count % 100;
|
||
if (mod10 == 1 && mod100 != 11) {
|
||
return form1;
|
||
} else if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) {
|
||
return form2;
|
||
} else {
|
||
return form5;
|
||
}
|
||
}
|
||
|
||
Future<void> _showMessageActions(MessageModel msg) async {
|
||
if (!mounted) return;
|
||
|
||
await showModalBottomSheet<void>(
|
||
context: context,
|
||
showDragHandle: true,
|
||
builder: (ctx) {
|
||
return SafeArea(
|
||
child: Column(
|
||
mainAxisSize: MainAxisSize.min,
|
||
children: [
|
||
ListTile(
|
||
leading: const Icon(Icons.reply),
|
||
title: const Text('Ответить'),
|
||
onTap: () {
|
||
Navigator.of(ctx).pop();
|
||
String text = msg.text;
|
||
if (msg.text.isEmpty && msg.messageType == MessageType.image) {
|
||
text = "[Фото]";
|
||
}
|
||
setState(() => _replyTo = msg.copyWith(text: text));
|
||
},
|
||
),
|
||
if (msg.isMe)
|
||
ListTile(
|
||
leading: const Icon(Icons.edit),
|
||
title: const Text('Изменить'),
|
||
onTap: () {
|
||
Navigator.of(ctx).pop();
|
||
_editMessage(msg);
|
||
},
|
||
),
|
||
ListTile(
|
||
leading: const Icon(Icons.copy),
|
||
title: const Text('Скопировать'),
|
||
onTap: () async {
|
||
Navigator.of(ctx).pop();
|
||
await Clipboard.setData(ClipboardData(text: msg.text));
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Скопировано'),
|
||
behavior:
|
||
SnackBarBehavior.floating, // Обязательно для margin
|
||
margin: EdgeInsets.only(
|
||
bottom:
|
||
80.0 +
|
||
10.0, // 20px + стандартный отступ (по желанию)
|
||
left: 10.0,
|
||
right: 10.0,
|
||
),
|
||
duration: Duration(seconds: 2),
|
||
),
|
||
);
|
||
},
|
||
),
|
||
if (msg.messageType == MessageType.image)
|
||
ListTile(
|
||
leading: const Icon(Icons.save_alt),
|
||
title: const Text('Сохранить в галерею'),
|
||
onTap: () {
|
||
Navigator.of(ctx).pop();
|
||
_saveImageToGallery(msg);
|
||
},
|
||
),
|
||
ListTile(
|
||
leading: const Icon(Icons.forward),
|
||
title: const Text('Переслать'),
|
||
onTap: () {
|
||
Navigator.of(ctx).pop();
|
||
_showForwardContactPicker(msg);
|
||
},
|
||
),
|
||
if (msg.isMe)
|
||
ListTile(
|
||
leading: const Icon(Icons.delete_outline),
|
||
title: const Text('Удалить'),
|
||
textColor: Colors.red,
|
||
iconColor: Colors.red,
|
||
onTap: () async {
|
||
Navigator.of(ctx).pop();
|
||
await _deleteMessage(msg);
|
||
},
|
||
),
|
||
const SizedBox(height: 8),
|
||
],
|
||
),
|
||
);
|
||
},
|
||
);
|
||
}
|
||
|
||
Future<void> _editMessage(MessageModel msg) async {
|
||
final controller = TextEditingController(text: msg.text);
|
||
final result = await showDialog<bool>(
|
||
context: context,
|
||
builder: (ctx) => AlertDialog(
|
||
title: const Text('Изменить сообщение'),
|
||
content: TextField(
|
||
controller: controller,
|
||
minLines: 1,
|
||
maxLines: 5,
|
||
autofocus: true,
|
||
decoration: const InputDecoration(hintText: 'Новый текст сообщения'),
|
||
),
|
||
actions: [
|
||
TextButton(
|
||
onPressed: () => Navigator.of(ctx).pop(false),
|
||
child: const Text('Отмена'),
|
||
),
|
||
ElevatedButton(
|
||
onPressed: () => Navigator.of(ctx).pop(true),
|
||
child: const Text('Сохранить'),
|
||
),
|
||
],
|
||
),
|
||
);
|
||
|
||
if (result != true || controller.text.trim().isEmpty) return;
|
||
|
||
final newText = controller.text.trim();
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
if (myPrivKey == null) return;
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey,
|
||
_currentContact.publicKey!,
|
||
);
|
||
final encryptedContent = await _cryptoService.encryptMessage(
|
||
newText,
|
||
sharedSecret,
|
||
);
|
||
|
||
final content50 = newText.length > 50 ? newText.substring(0, 50) : newText;
|
||
final encryptedContent50 = await _cryptoService.encryptMessage(
|
||
content50,
|
||
sharedSecret,
|
||
);
|
||
|
||
setState(() {
|
||
messages = messages.map((m) {
|
||
if (m.id != null && m.id == msg.id) {
|
||
return m.copyWith(text: newText, editedAt: DateTime.now());
|
||
}
|
||
return m;
|
||
}).toList();
|
||
});
|
||
|
||
if (msg.id != null) {
|
||
try {
|
||
await _localDbService.updateMessageContent(
|
||
msg.id!,
|
||
encryptedContent,
|
||
DateTime.now(),
|
||
);
|
||
} catch (_) {}
|
||
Provider.of<SocketService>(context, listen: false).sendMessage({
|
||
'type': 'edit_message',
|
||
'message_id': msg.id,
|
||
'content': encryptedContent,
|
||
'content50': encryptedContent50,
|
||
});
|
||
}
|
||
}
|
||
|
||
Future<void> _deleteMessage(MessageModel msg) async {
|
||
setState(() {
|
||
messages.removeWhere(
|
||
(m) =>
|
||
(m.id != null && m.id == msg.id) ||
|
||
(m.tempId != null && m.tempId == msg.tempId),
|
||
);
|
||
});
|
||
|
||
final id = msg.id;
|
||
if (id != null) {
|
||
try {
|
||
await _localDbService.deleteMessage(id);
|
||
} catch (_) {}
|
||
Provider.of<SocketService>(
|
||
context,
|
||
listen: false,
|
||
).sendMessage({'type': 'delete_message', 'message_id': id});
|
||
}
|
||
}
|
||
|
||
Future<void> _showForwardContactPicker(MessageModel msg) async {
|
||
final contactProvider = context.read<ContactProvider>();
|
||
contactProvider.setCurrentUserId(myId);
|
||
await contactProvider.loadAllContactsForNewChat();
|
||
if (!mounted) return;
|
||
|
||
final selectedContact = await showModalBottomSheet<Contact?>(
|
||
context: context,
|
||
isScrollControlled: true,
|
||
builder: (ctx) {
|
||
final provider = context.watch<ContactProvider>();
|
||
if (provider.isLoading) {
|
||
return const SizedBox(
|
||
height: 150,
|
||
child: Center(child: CircularProgressIndicator()),
|
||
);
|
||
}
|
||
if (provider.error != null) {
|
||
return Padding(
|
||
padding: const EdgeInsets.all(16.0),
|
||
child: Text('Ошибка загрузки контактов: ${provider.error}'),
|
||
);
|
||
}
|
||
if (provider.allContacts.isEmpty) {
|
||
return const Padding(
|
||
padding: EdgeInsets.all(16.0),
|
||
child: Text('Нет доступных контактов для пересылки.'),
|
||
);
|
||
}
|
||
return SafeArea(
|
||
child: ListView.builder(
|
||
shrinkWrap: true,
|
||
itemCount: provider.allContacts.length,
|
||
itemBuilder: (ctx2, index) {
|
||
final contact = provider.allContacts[index];
|
||
return ListTile(
|
||
leading: CircleAvatar(
|
||
child: Text(contact.name.isNotEmpty ? contact.name[0] : '?'),
|
||
),
|
||
title: Text(contact.name),
|
||
subtitle: Text(contact.username),
|
||
onTap: () => Navigator.of(ctx).pop(contact),
|
||
);
|
||
},
|
||
),
|
||
);
|
||
},
|
||
);
|
||
|
||
if (selectedContact != null) {
|
||
await _forwardMessage(msg, selectedContact);
|
||
}
|
||
}
|
||
|
||
Future<void> _forwardMessage(MessageModel msg, Contact targetContact) async {
|
||
final forwardText = msg.text.trim();
|
||
final isImage = msg.messageType == MessageType.image;
|
||
if (forwardText.isEmpty && !isImage) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Нечего пересылать.'),
|
||
behavior: SnackBarBehavior.floating, // Обязательно для margin
|
||
margin: EdgeInsets.only(
|
||
bottom: 80.0 + 10.0, // 20px + стандартный отступ (по желанию)
|
||
left: 10.0,
|
||
right: 10.0,
|
||
),
|
||
duration: Duration(seconds: 5),
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
|
||
if (targetContact.publicKey == null) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
SnackBar(
|
||
content: Text(
|
||
'Публичный ключ контакта ${targetContact.name} не найден.',
|
||
),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
duration: const Duration(seconds: 3),
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
if (myPrivKey == null) {
|
||
throw Exception('Не найден приватный ключ.');
|
||
}
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey,
|
||
targetContact.publicKey!,
|
||
);
|
||
|
||
String contentToEncrypt = forwardText;
|
||
if (contentToEncrypt.isEmpty && isImage) {
|
||
contentToEncrypt = "";
|
||
}
|
||
final encryptedContent = await _cryptoService.encryptMessage(
|
||
contentToEncrypt,
|
||
sharedSecret,
|
||
);
|
||
final String previewText = forwardText.isNotEmpty
|
||
? (forwardText.length > 50
|
||
? forwardText.substring(0, 50)
|
||
: forwardText)
|
||
: (isImage ? "[Фото]" : "");
|
||
final encryptedContent50 = await _cryptoService.encryptMessage(
|
||
previewText,
|
||
sharedSecret,
|
||
);
|
||
|
||
String? fileIdToSend;
|
||
String? encryptedFileKeyToSend;
|
||
Uint8List? localImageBytes = msg.localFileBytes;
|
||
|
||
if (isImage) {
|
||
if (msg.fileId != null &&
|
||
msg.encryptedFileKey != null &&
|
||
_currentContact.publicKey != null) {
|
||
final currentChatSharedSecret = await _cryptoService
|
||
.deriveSharedSecret(myPrivKey, _currentContact.publicKey!);
|
||
final originalFileKeyBytes = await _cryptoService.decryptAesKey(
|
||
msg.encryptedFileKey!,
|
||
currentChatSharedSecret,
|
||
);
|
||
if (originalFileKeyBytes != null) {
|
||
final reencryptedKey = await _cryptoService.encryptAesKey(
|
||
originalFileKeyBytes,
|
||
sharedSecret,
|
||
);
|
||
if (reencryptedKey != null) {
|
||
fileIdToSend = msg.fileId;
|
||
encryptedFileKeyToSend = reencryptedKey;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (fileIdToSend == null || encryptedFileKeyToSend == null) {
|
||
if (msg.localFileBytes != null) {
|
||
final imageEncryptResult = await _cryptoService.encryptImage(
|
||
msg.localFileBytes!,
|
||
sharedSecret,
|
||
);
|
||
if (imageEncryptResult == null) {
|
||
throw Exception('Ошибка шифрования пересылаемой картинки');
|
||
}
|
||
fileIdToSend = await apiService.uploadMedia(imageEncryptResult.$1);
|
||
if (fileIdToSend == null) {
|
||
throw Exception(
|
||
'Не удалось загрузить пересылаемое изображение на сервер',
|
||
);
|
||
}
|
||
encryptedFileKeyToSend = imageEncryptResult.$2;
|
||
}
|
||
}
|
||
|
||
if (fileIdToSend == null || encryptedFileKeyToSend == null) {
|
||
throw Exception(
|
||
'Невозможно переслать изображение: отсутствует шифрованный ключ или файл.',
|
||
);
|
||
}
|
||
}
|
||
|
||
final tempId = DateTime.now().microsecondsSinceEpoch;
|
||
final localMessage = MessageModel(
|
||
tempId: tempId,
|
||
text: forwardText.isNotEmpty ? forwardText : (isImage ? "[Фото]" : ""),
|
||
isMe: true,
|
||
senderId: myId,
|
||
receiverId: targetContact.id,
|
||
createdAt: DateTime.now(),
|
||
status: MessageStatus.sending,
|
||
localFileBytes: isImage ? localImageBytes : null,
|
||
messageType: isImage ? MessageType.image : MessageType.text,
|
||
fileId: fileIdToSend,
|
||
encryptedFileKey: encryptedFileKeyToSend,
|
||
);
|
||
if (_currentContact.id == targetContact.id) {
|
||
setState(() {
|
||
messages.add(localMessage);
|
||
_pendingImageBytes = null;
|
||
});
|
||
}
|
||
|
||
final payload = {
|
||
'type': 'private_message',
|
||
'receiver_id': targetContact.id,
|
||
'message_type': isImage ? 'image' : 'text',
|
||
'content': encryptedContent,
|
||
'content50': encryptedContent50,
|
||
'temp_id': tempId,
|
||
if (isImage) ...{
|
||
'file_id': fileIdToSend,
|
||
'encrypted_key': encryptedFileKeyToSend,
|
||
},
|
||
};
|
||
|
||
final ok = Provider.of<SocketService>(
|
||
context,
|
||
listen: false,
|
||
).sendMessage(payload);
|
||
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
SnackBar(
|
||
content: Text(
|
||
ok
|
||
? 'Сообщение переслано контакту ${targetContact.name}.'
|
||
: 'Не удалось переслать сообщение.',
|
||
),
|
||
behavior: SnackBarBehavior.floating, // Обязательно для margin
|
||
margin: const EdgeInsets.only(
|
||
bottom: 80.0 + 10.0, // 20px + стандартный отступ (по желанию)
|
||
left: 10.0,
|
||
right: 10.0,
|
||
),
|
||
duration: const Duration(seconds: 3),
|
||
),
|
||
);
|
||
|
||
setState(() {
|
||
final idx = messages.indexWhere((m) => m.tempId == tempId);
|
||
if (idx != -1) {
|
||
messages[idx] = messages[idx].copyWith(
|
||
status: ok ? MessageStatus.sent : MessageStatus.failed,
|
||
);
|
||
}
|
||
_replyTo = null;
|
||
});
|
||
Navigator.push(
|
||
context,
|
||
MaterialPageRoute(
|
||
builder: (context) => ChatScreen(contact: targetContact),
|
||
),
|
||
);
|
||
} catch (e) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
SnackBar(
|
||
content: Text('Ошибка пересылки: $e'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: const EdgeInsets.only(
|
||
bottom: 80.0 + 10.0,
|
||
left: 10.0,
|
||
right: 10.0,
|
||
),
|
||
duration: const Duration(seconds: 5),
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
Widget _buildMessageInput() {
|
||
return SafeArea(
|
||
// Добавляем SafeArea здесь
|
||
child: Container(
|
||
color: Theme.of(context).colorScheme.surfaceVariant,
|
||
padding: const EdgeInsets.all(8.0),
|
||
child: Column(
|
||
mainAxisSize: MainAxisSize.min,
|
||
children: [
|
||
if (_replyTo != null)
|
||
Container(
|
||
padding: const EdgeInsets.symmetric(
|
||
horizontal: 12,
|
||
vertical: 8,
|
||
),
|
||
margin: const EdgeInsets.only(bottom: 8),
|
||
decoration: BoxDecoration(
|
||
color: Theme.of(context).colorScheme.surface,
|
||
borderRadius: BorderRadius.circular(12),
|
||
),
|
||
child: Row(
|
||
children: [
|
||
const Icon(Icons.reply, size: 18),
|
||
const SizedBox(width: 8),
|
||
Expanded(
|
||
child: Text(
|
||
_replyTo!.text.isNotEmpty
|
||
? _replyTo!.text
|
||
: (_replyTo!.messageType == MessageType.image
|
||
? "[Фото]"
|
||
: ""),
|
||
maxLines: 1,
|
||
overflow: TextOverflow.ellipsis,
|
||
),
|
||
),
|
||
IconButton(
|
||
icon: const Icon(Icons.close, size: 18),
|
||
onPressed: () => setState(() => _replyTo = null),
|
||
),
|
||
],
|
||
),
|
||
),
|
||
if (_pendingImageBytes != null)
|
||
Container(
|
||
margin: const EdgeInsets.only(bottom: 8),
|
||
padding: const EdgeInsets.all(8),
|
||
decoration: BoxDecoration(
|
||
color: Theme.of(context).colorScheme.surface,
|
||
borderRadius: BorderRadius.circular(12),
|
||
),
|
||
child: Row(
|
||
children: [
|
||
Expanded(
|
||
child: ClipRRect(
|
||
borderRadius: BorderRadius.circular(10),
|
||
child: Image.memory(
|
||
_pendingImageBytes!,
|
||
fit: BoxFit.cover,
|
||
height: 120,
|
||
),
|
||
),
|
||
),
|
||
const SizedBox(width: 8),
|
||
IconButton(
|
||
icon: const Icon(Icons.close),
|
||
onPressed: () =>
|
||
setState(() => _pendingImageBytes = null),
|
||
),
|
||
],
|
||
),
|
||
),
|
||
Row(
|
||
crossAxisAlignment: CrossAxisAlignment.end,
|
||
children: [
|
||
IconButton(
|
||
icon: const Icon(Icons.photo),
|
||
onPressed: _pickImage,
|
||
),
|
||
Expanded(
|
||
child: TextField(
|
||
controller: _controller,
|
||
minLines: 1,
|
||
maxLines: 5,
|
||
textInputAction: TextInputAction.newline,
|
||
textCapitalization: TextCapitalization.sentences,
|
||
decoration: const InputDecoration(
|
||
hintText: "Напиши сообщение...",
|
||
),
|
||
),
|
||
),
|
||
IconButton(
|
||
icon: const Icon(Icons.send),
|
||
onPressed: () {
|
||
_sendMessage();
|
||
},
|
||
),
|
||
],
|
||
),
|
||
],
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
Future<void> _pickImage() async {
|
||
final ImagePicker _picker = ImagePicker();
|
||
final XFile? image = await _picker.pickImage(
|
||
source: ImageSource.gallery,
|
||
maxWidth: 1280,
|
||
maxHeight: 1280,
|
||
imageQuality: 80,
|
||
);
|
||
if (image != null) {
|
||
final Uint8List fileBytes = await image.readAsBytes();
|
||
if (!mounted) return;
|
||
setState(() {
|
||
_pendingImageBytes = fileBytes;
|
||
});
|
||
}
|
||
}
|
||
|
||
Future<void> _sendMessage() async {
|
||
_sendStopTypingStatus();
|
||
final rawText = _controller.text.trim();
|
||
final hasImage = _pendingImageBytes != null;
|
||
|
||
// Если и текст пустой, и картинки нет — выходим
|
||
if (rawText.isEmpty && !hasImage) return;
|
||
|
||
// Блокируем UI на время загрузки
|
||
_controller.clear();
|
||
|
||
try {
|
||
// 1. Подготовка ключей
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey!,
|
||
_currentContact.publicKey!,
|
||
);
|
||
|
||
String? fileId;
|
||
String? encryptedFileKey;
|
||
String encryptedContent;
|
||
String encryptedContent50;
|
||
String? encryptedReplyToText;
|
||
|
||
// 2. Если есть изображение — сначала загружаем его
|
||
if (hasImage) {
|
||
final encryptionResult = await _cryptoService.encryptImage(
|
||
_pendingImageBytes!,
|
||
sharedSecret,
|
||
);
|
||
if (encryptionResult == null) {
|
||
throw Exception("Ошибка шифрования медиа");
|
||
}
|
||
final encryptedFileData = encryptionResult.$1;
|
||
final fileKeyForServer = encryptionResult.$2;
|
||
|
||
fileId = await apiService.uploadMedia(encryptedFileData);
|
||
|
||
if (fileId == null) throw Exception("Ошибка загрузки файла на сервер");
|
||
|
||
encryptedFileKey = fileKeyForServer;
|
||
}
|
||
|
||
// 3. Шифруем текст сообщения (даже если там пусто, или есть подпись к фото)
|
||
// Если текста нет, но есть фото, отправим пустую строку или "[Фото]"
|
||
final String textToEncrypt = rawText.isNotEmpty
|
||
? rawText
|
||
: (hasImage ? "" : "");
|
||
|
||
encryptedContent = await _cryptoService.encryptMessage(
|
||
textToEncrypt,
|
||
sharedSecret,
|
||
);
|
||
|
||
String previewText = rawText.isNotEmpty ? rawText : "[Фото]";
|
||
if (previewText.length > 50) previewText = previewText.substring(0, 50);
|
||
encryptedContent50 = await _cryptoService.encryptMessage(
|
||
previewText,
|
||
sharedSecret,
|
||
);
|
||
|
||
if (_replyTo?.id != null && _replyTo!.text.trim().isNotEmpty) {
|
||
encryptedReplyToText = await _cryptoService.encryptMessage(
|
||
_replyTo!.text,
|
||
sharedSecret,
|
||
);
|
||
}
|
||
|
||
// 4. Создаем локальную модель для мгновенного отображения
|
||
final tempId = DateTime.now().microsecondsSinceEpoch;
|
||
final localMessage = MessageModel(
|
||
tempId: tempId,
|
||
text: rawText,
|
||
isMe: true,
|
||
senderId: myId,
|
||
receiverId: _currentContact.id,
|
||
createdAt: DateTime.now(),
|
||
status: MessageStatus.sending,
|
||
localFileBytes: _pendingImageBytes,
|
||
messageType: hasImage ? MessageType.image : MessageType.text,
|
||
fileId: fileId,
|
||
encryptedFileKey: encryptedFileKey,
|
||
replyToId: _replyTo?.id,
|
||
replyToText: _replyTo?.text,
|
||
);
|
||
|
||
setState(() {
|
||
messages.add(localMessage);
|
||
_pendingImageBytes = null; // Очищаем черновик
|
||
});
|
||
|
||
// 5. Формируем финальный payload для сокета
|
||
final payload = {
|
||
"type": "private_message",
|
||
"receiver_id": _currentContact.id,
|
||
"message_type": hasImage ? "image" : "text",
|
||
"content": encryptedContent, // Шифрованный текст (подпись)
|
||
"content50": encryptedContent50, // Шифрованное превью
|
||
"temp_id": tempId,
|
||
if (hasImage) ...{
|
||
"file_id": fileId,
|
||
"encrypted_key": encryptedFileKey, // Зашифрованный AES-ключ файла
|
||
},
|
||
if (_replyTo?.id != null) ...{
|
||
"reply_to_id": _replyTo!.id,
|
||
if (encryptedReplyToText != null)
|
||
"reply_to_text": encryptedReplyToText,
|
||
},
|
||
};
|
||
|
||
// 6. Отправка через сокет
|
||
final ok = Provider.of<SocketService>(
|
||
context,
|
||
listen: false,
|
||
).sendMessage(payload);
|
||
|
||
// Обновляем статус
|
||
setState(() {
|
||
final idx = messages.indexWhere((m) => m.tempId == tempId);
|
||
if (idx != -1) {
|
||
messages[idx] = messages[idx].copyWith(
|
||
status: ok ? MessageStatus.sent : MessageStatus.failed,
|
||
);
|
||
}
|
||
_replyTo = null;
|
||
});
|
||
} catch (e) {
|
||
// В случае ошибки возвращаем текст в контроллер
|
||
_controller.text = rawText;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
SnackBar(
|
||
content: Text("Ошибка отправки: $e"),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
duration: Duration(seconds: 5),
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
void _handleIncomingMessage(Map<String, dynamic> data) async {
|
||
DateTime now = DateTime.now();
|
||
|
||
Duration offset = now.timeZoneOffset;
|
||
// ACK от сервера: сообщение сохранено и получило server_id
|
||
if (data['type'] == 'message_sent') {
|
||
final tempId = int.tryParse(data['temp_id']?.toString() ?? '');
|
||
final serverId = int.tryParse(data['server_id']?.toString() ?? '');
|
||
var ts = DateTime.tryParse(
|
||
data['timestamp']?.toString() ?? '',
|
||
)?.add(offset);
|
||
|
||
if (tempId == null) return;
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
final idx = messages.indexWhere((m) => m.tempId == tempId);
|
||
if (idx == -1) return;
|
||
messages[idx] = messages[idx].copyWith(
|
||
id: serverId ?? messages[idx].id,
|
||
createdAt: ts ?? messages[idx].createdAt,
|
||
status: MessageStatus.sent,
|
||
);
|
||
});
|
||
return;
|
||
}
|
||
|
||
// Backward compatibility: старый ack мог приходить как message_delivered с temp_id/server_id
|
||
if (data['type'] == 'message_delivered' && data.containsKey('temp_id')) {
|
||
final tempId = int.tryParse(data['temp_id']?.toString() ?? '');
|
||
final serverId = int.tryParse(data['server_id']?.toString() ?? '');
|
||
var ts = DateTime.tryParse(
|
||
data['timestamp']?.toString() ?? '',
|
||
)?.add(offset);
|
||
|
||
if (tempId == null) return;
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
final idx = messages.indexWhere((m) => m.tempId == tempId);
|
||
if (idx == -1) return;
|
||
messages[idx] = messages[idx].copyWith(
|
||
id: serverId ?? messages[idx].id,
|
||
createdAt: ts ?? messages[idx].createdAt,
|
||
status: MessageStatus.sent,
|
||
);
|
||
});
|
||
return;
|
||
}
|
||
|
||
// Доставка онлайн (получатель был в сети)
|
||
if (data['type'] == 'message_delivered') {
|
||
final messageId = int.tryParse(data['message_id']?.toString() ?? '');
|
||
var ts = DateTime.tryParse(
|
||
data['timestamp']?.toString() ?? '',
|
||
)?.add(offset);
|
||
if (messageId == null) return;
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
for (int i = 0; i < messages.length; i++) {
|
||
if (messages[i].id == messageId) {
|
||
messages[i] = messages[i].copyWith(status: MessageStatus.delivered);
|
||
}
|
||
}
|
||
});
|
||
|
||
if (ts != null) {
|
||
try {
|
||
await _localDbService.updateDeliveredAt(messageId, ts);
|
||
} catch (_) {}
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (data['type'] == 'message_edited') {
|
||
final messageId = int.tryParse(data['message_id']?.toString() ?? '');
|
||
var ts = DateTime.tryParse(
|
||
data['edited_at']?.toString() ?? '',
|
||
)?.add(offset);
|
||
if (messageId == null) return;
|
||
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
if (myPrivKey == null) return;
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey,
|
||
_currentContact.publicKey!,
|
||
);
|
||
final decryptedText = await _cryptoService.decryptMessage(
|
||
data['content'],
|
||
sharedSecret,
|
||
);
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
messages = messages.map((m) {
|
||
if (m.id != null && m.id == messageId) {
|
||
return m.copyWith(text: decryptedText, editedAt: ts);
|
||
}
|
||
return m;
|
||
}).toList();
|
||
});
|
||
|
||
try {
|
||
await _localDbService.updateMessageContent(
|
||
messageId,
|
||
data['content'].toString(),
|
||
ts,
|
||
);
|
||
} catch (_) {}
|
||
return;
|
||
}
|
||
|
||
if (data['type'] == 'message_deleted') {
|
||
final messageId = int.tryParse(data['message_id']?.toString() ?? '');
|
||
if (messageId == null) return;
|
||
if (!mounted) return;
|
||
setState(() {
|
||
messages.removeWhere((m) => m.id != null && m.id == messageId);
|
||
});
|
||
try {
|
||
await _localDbService.deleteMessage(messageId);
|
||
} catch (_) {}
|
||
return;
|
||
}
|
||
|
||
if (data['type'] == 'message_read') {
|
||
final messageId = int.tryParse(data['message_id'].toString());
|
||
if (messageId == null) return;
|
||
var ts = DateTime.tryParse(
|
||
data['timestamp']?.toString() ?? '',
|
||
)?.add(offset);
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
for (int i = 0; i < messages.length; i++) {
|
||
if (messages[i].id == messageId) {
|
||
messages[i] = messages[i].copyWith(status: MessageStatus.read);
|
||
}
|
||
}
|
||
});
|
||
|
||
if (ts != null) {
|
||
try {
|
||
await _localDbService.updateReadAt(messageId, ts);
|
||
} catch (_) {}
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (data['type'] == 'private_message') {
|
||
print('DEBUG incoming private_message raw: $data');
|
||
setState(() {
|
||
_typingTimer?.cancel();
|
||
_isTyping = false;
|
||
});
|
||
final senderId = int.tryParse(data['sender_id']?.toString() ?? '');
|
||
final receiverId = int.tryParse(
|
||
(data['receiver_id'] ?? data['recipient_id'])?.toString() ?? '',
|
||
);
|
||
if (senderId == null || receiverId == null) {
|
||
print(
|
||
'Invalid private_message ids: sender_id=${data['sender_id']} receiver_id=${data['receiver_id'] ?? data['recipient_id']}',
|
||
);
|
||
return;
|
||
}
|
||
|
||
// 1. Проверяем, что сообщение именно от того, с кем мы сейчас общаемся
|
||
final isFromPartnerToMe =
|
||
senderId == widget.contact.id && receiverId == myId;
|
||
if (isFromPartnerToMe) {
|
||
try {
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
|
||
// 2. Вычисляем общий секрет для расшифровки
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey!,
|
||
widget.contact.publicKey!,
|
||
);
|
||
|
||
// 3. Расшифровываем контент
|
||
final decryptedText = await _cryptoService.decryptMessage(
|
||
data['content'],
|
||
sharedSecret,
|
||
);
|
||
|
||
// 4. Добавляем в список и обновляем экран
|
||
String? encryptedFileKey = data['encrypted_key']?.toString();
|
||
Uint8List? decryptedImageBytes;
|
||
// Lazy load images later
|
||
|
||
if (!mounted) return;
|
||
|
||
final serverMessageId = int.tryParse(data['id']?.toString() ?? '');
|
||
if (serverMessageId != null &&
|
||
!_sentReadReceipts.contains(serverMessageId)) {
|
||
Provider.of<SocketService>(
|
||
context,
|
||
listen: false,
|
||
).sendReadReceipt(serverMessageId);
|
||
_sentReadReceipts.add(serverMessageId);
|
||
}
|
||
|
||
final replyToText = await _decryptReplyText(
|
||
data['reply_to_text']?.toString(),
|
||
sharedSecret,
|
||
);
|
||
|
||
setState(() {
|
||
messages.add(
|
||
MessageModel(
|
||
id: int.tryParse(data['id']?.toString() ?? ''),
|
||
text: decryptedText,
|
||
isMe: false,
|
||
senderId: senderId,
|
||
receiverId: myId,
|
||
createdAt: DateTime.parse(data['timestamp']).add(offset),
|
||
status: MessageStatus.delivered,
|
||
replyToId: data['reply_to_id'] == null
|
||
? null
|
||
: int.tryParse(data['reply_to_id'].toString()),
|
||
replyToText: replyToText,
|
||
messageType: data['message_type'] == 'image'
|
||
? MessageType.image
|
||
: MessageType.text,
|
||
fileId: data['file_id']?.toString(),
|
||
encryptedFileKey: encryptedFileKey,
|
||
localFileBytes: decryptedImageBytes,
|
||
),
|
||
);
|
||
});
|
||
// Save to local DB with cached image bytes
|
||
try {
|
||
await _localDbService.saveMessages([messages.last]);
|
||
} catch (e) {
|
||
print('Error saving incoming message to DB: $e');
|
||
}
|
||
} catch (e) {
|
||
print("Ошибка расшифровки входящего сообщения: $e");
|
||
}
|
||
} else {
|
||
print(
|
||
"Сообщение от другого пользователя (ID: $senderId), игнорируем в этом чате",
|
||
);
|
||
}
|
||
}
|
||
if (data['type'] == 'user_online') {
|
||
final userId = int.tryParse(data['user_id']?.toString() ?? '');
|
||
if (userId == widget.contact.id) {
|
||
setState(() => _isOnline = true);
|
||
}
|
||
}
|
||
if (data['type'] == 'user_offline') {
|
||
final userId = int.tryParse(data['user_id']?.toString() ?? '');
|
||
if (userId == widget.contact.id) {
|
||
setState(() {
|
||
_isOnline = false;
|
||
_lastOnline = DateTime.now();
|
||
});
|
||
|
||
_loadOnlineStatus();
|
||
}
|
||
}
|
||
|
||
if (data['type'] == 'typing' && data['sender_id'] == _currentContact.id) {
|
||
if (mounted) {
|
||
setState(() => _isTyping = true);
|
||
|
||
_typingTimer?.cancel();
|
||
_typingTimer = Timer(const Duration(seconds: 4), () {
|
||
if (mounted) setState(() => _isTyping = false);
|
||
});
|
||
}
|
||
}
|
||
if (data['type'] == 'stop_typing' &&
|
||
data['sender_id'] == _currentContact.id) {
|
||
if (mounted) {
|
||
setState(() => _isTyping = false);
|
||
|
||
_typingTimer?.cancel();
|
||
}
|
||
}
|
||
}
|
||
|
||
Future<void> _loadHistory() async {
|
||
DateTime now = DateTime.now();
|
||
|
||
Duration offset = now.timeZoneOffset;
|
||
initialMessage = null; // Сбрасываем данные уведомления при загрузке ключа
|
||
final prefs = await SharedPreferences.getInstance();
|
||
await prefs.remove(_notificationLaunchKey);
|
||
try {
|
||
print('[DEBUG] Начало загрузки истории');
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey!,
|
||
widget.contact.publicKey!,
|
||
);
|
||
print('[DEBUG] Ключи получены');
|
||
final cached = await _localDbService.getChatHistory(
|
||
widget.contact.id,
|
||
myId,
|
||
);
|
||
print('[DEBUG] Локальная история загружена: ${cached.length} сообщений');
|
||
|
||
// Сохраняем кэшированные изображения перед обновлением
|
||
Map<int, Uint8List> cachedImages = {};
|
||
for (var msg in cached) {
|
||
if (msg['id'] != null && msg['local_file_bytes'] != null) {
|
||
cachedImages[msg['id'] as int] = msg['local_file_bytes'] as Uint8List;
|
||
}
|
||
}
|
||
|
||
try {
|
||
List<MessageModel> loadedLocalMessages = [];
|
||
for (var msg in cached) {
|
||
final decrypted = await _cryptoService.decryptMessage(
|
||
msg['content'],
|
||
sharedSecret,
|
||
);
|
||
|
||
final deliveredAt = msg['delivered_at'] == null
|
||
? null
|
||
: DateTime.tryParse(msg['delivered_at'].toString())?.add(offset);
|
||
final readAt = msg['read_at'] == null
|
||
? null
|
||
: DateTime.tryParse(msg['read_at'].toString())?.add(offset);
|
||
|
||
MessageStatus status = (msg['sender_id'] == myId)
|
||
? MessageStatus.sent
|
||
: MessageStatus.delivered;
|
||
if (msg['sender_id'] == myId) {
|
||
if (readAt != null) {
|
||
status = MessageStatus.read;
|
||
} else if (deliveredAt != null) {
|
||
status = MessageStatus.delivered;
|
||
}
|
||
}
|
||
|
||
Uint8List? decryptedImageBytes;
|
||
if (msg['message_type'] == 'image') {
|
||
decryptedImageBytes = msg['local_file_bytes'] as Uint8List?;
|
||
}
|
||
|
||
loadedLocalMessages.add(
|
||
MessageModel(
|
||
id: int.tryParse(msg['id']?.toString() ?? ''),
|
||
text: decrypted,
|
||
isMe: msg['sender_id'] == myId,
|
||
senderId: msg['sender_id'],
|
||
receiverId: msg['receiver_id'],
|
||
createdAt: DateTime.parse(msg['timestamp']).add(offset),
|
||
status: status,
|
||
replyToId: msg['reply_to_id'] == null
|
||
? null
|
||
: int.tryParse(msg['reply_to_id'].toString()),
|
||
replyToText: await _decryptReplyText(
|
||
msg['reply_to_text']?.toString(),
|
||
sharedSecret,
|
||
),
|
||
editedAt: msg['edited_at'] != null
|
||
? DateTime.tryParse(msg['edited_at'].toString())?.add(offset)
|
||
: null,
|
||
messageType: msg['message_type'] == 'image'
|
||
? MessageType.image
|
||
: MessageType.text,
|
||
fileId: msg['file_id']?.toString(),
|
||
encryptedFileKey: msg['encrypted_key']?.toString(),
|
||
localFileBytes: decryptedImageBytes,
|
||
),
|
||
);
|
||
}
|
||
if (cached.isNotEmpty) {
|
||
if (!mounted) return;
|
||
setState(() {
|
||
messages = loadedLocalMessages;
|
||
_isKeyLoading = false;
|
||
});
|
||
}
|
||
} catch (e) {
|
||
print(e);
|
||
}
|
||
|
||
final history = await apiService.getChatHistory(widget.contact.id);
|
||
print('[DEBUG] История с сервера загружена: ${history.length} сообщений');
|
||
print(history);
|
||
final alreadyReadIncomingMessageIds = <int>{};
|
||
List<MessageModel> loadedMessages = [];
|
||
for (var msg in history) {
|
||
final msgId = int.tryParse(msg['id']?.toString() ?? '');
|
||
if (msgId != null &&
|
||
msg['sender_id'] != myId &&
|
||
msg['read_at'] != null) {
|
||
alreadyReadIncomingMessageIds.add(msgId);
|
||
}
|
||
|
||
final decrypted = await _cryptoService.decryptMessage(
|
||
msg['content'],
|
||
sharedSecret,
|
||
);
|
||
|
||
final deliveredAt = msg['delivered_at'] == null
|
||
? null
|
||
: DateTime.tryParse(msg['delivered_at'].toString())?.add(offset);
|
||
final readAt = msg['read_at'] == null
|
||
? null
|
||
: DateTime.tryParse(msg['read_at'].toString())?.add(offset);
|
||
|
||
MessageStatus status = (msg['sender_id'] == myId)
|
||
? MessageStatus.sent
|
||
: MessageStatus.delivered;
|
||
if (msg['sender_id'] == myId) {
|
||
if (readAt != null) {
|
||
status = MessageStatus.read;
|
||
} else if (deliveredAt != null) {
|
||
status = MessageStatus.delivered;
|
||
}
|
||
}
|
||
|
||
Uint8List? decryptedImageBytes;
|
||
// Lazy load images later to avoid downloading all at once
|
||
|
||
loadedMessages.insert(
|
||
0,
|
||
MessageModel(
|
||
id: int.tryParse(msg['id']?.toString() ?? ''),
|
||
text: decrypted,
|
||
isMe: msg['sender_id'] == myId,
|
||
senderId: msg['sender_id'],
|
||
receiverId: msg['receiver_id'],
|
||
createdAt: DateTime.parse(msg['timestamp']).add(offset),
|
||
status: status,
|
||
replyToId: msg['reply_to_id'] == null
|
||
? null
|
||
: int.tryParse(msg['reply_to_id'].toString()),
|
||
replyToText: await _decryptReplyText(
|
||
msg['reply_to_text']?.toString(),
|
||
sharedSecret,
|
||
),
|
||
editedAt: msg['edited_at'] != null
|
||
? DateTime.tryParse(msg['edited_at'].toString())?.add(offset)
|
||
: null,
|
||
messageType: msg['message_type'] == 'image'
|
||
? MessageType.image
|
||
: MessageType.text,
|
||
fileId: msg['file_id']?.toString(),
|
||
encryptedFileKey: msg['encrypted_key']?.toString(),
|
||
localFileBytes: cachedImages[int.tryParse(msg['id']?.toString() ?? '')] ?? decryptedImageBytes,
|
||
),
|
||
);
|
||
}
|
||
try {
|
||
print('[DEBUG] Начинаем очищение и сохранение истории в локальную БД');
|
||
//await _localDbService.deleteChatHistory(widget.contact.id, myId);
|
||
await _localDbService.saveMessages(loadedMessages);
|
||
print('[DEBUG] История успешно сохранена в локальную БД');
|
||
|
||
// Восстанавливаем кэшированные изображения
|
||
for (var entry in cachedImages.entries) {
|
||
await _localDbService.updateMessageLocalFileBytes(entry.key, entry.value);
|
||
}
|
||
} catch (e) {
|
||
print("[ERROR] Ошибка сохранения истории в локальную базу: $e");
|
||
}
|
||
|
||
if (!mounted) return;
|
||
setState(() {
|
||
messages = loadedMessages;
|
||
_isKeyLoading = false;
|
||
});
|
||
|
||
// Отправляем read_receipt для сообщений собеседника, которые уже на экране.
|
||
for (final m in loadedMessages) {
|
||
if (m.isMe) continue;
|
||
final id = m.id;
|
||
if (id == null) continue;
|
||
if (alreadyReadIncomingMessageIds.contains(id)) continue;
|
||
if (_sentReadReceipts.contains(id)) continue;
|
||
Provider.of<SocketService>(context, listen: false).sendReadReceipt(id);
|
||
_sentReadReceipts.add(id);
|
||
}
|
||
} catch (e) {
|
||
print("Ошибка загрузки истории: $e");
|
||
if (!mounted) return;
|
||
setState(() => _isKeyLoading = false);
|
||
}
|
||
}
|
||
|
||
Future<void> _updateScrollButtonVisibility() async {
|
||
if (!mounted) return;
|
||
final shouldShow =
|
||
_scrollController.hasClients && _scrollController.offset > 100;
|
||
if (shouldShow != _showScrollToEnd) {
|
||
setState(() {
|
||
_showScrollToEnd = shouldShow;
|
||
});
|
||
}
|
||
}
|
||
|
||
Future<void> _scrollToBottom() async {
|
||
if (!_scrollController.hasClients) return;
|
||
await _scrollController.animateTo(
|
||
0,
|
||
duration: const Duration(milliseconds: 300),
|
||
curve: Curves.easeInOut,
|
||
);
|
||
}
|
||
|
||
Future<void> _scrollToMessage(int? messageId) async {
|
||
if (messageId == null) return;
|
||
final itemKey = _messageKeys[messageId];
|
||
if (itemKey?.currentContext == null) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Сообщение не найдено для перехода.'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
await Scrollable.ensureVisible(
|
||
itemKey!.currentContext!,
|
||
duration: const Duration(milliseconds: 300),
|
||
alignment: 0.1,
|
||
curve: Curves.easeInOut,
|
||
);
|
||
}
|
||
|
||
Future<Uint8List?> _loadImageBytesForMessage(MessageModel msg) async {
|
||
if (msg.localFileBytes != null) return msg.localFileBytes;
|
||
if (msg.fileId == null || msg.encryptedFileKey == null) return null;
|
||
|
||
final myPrivKey = await _cryptoService.getPrivateKey();
|
||
if (myPrivKey == null) return null;
|
||
final sharedSecret = await _cryptoService.deriveSharedSecret(
|
||
myPrivKey,
|
||
_currentContact.publicKey!,
|
||
);
|
||
final bytes = await _downloadAndDecryptImage(
|
||
msg.fileId!,
|
||
msg.encryptedFileKey!,
|
||
sharedSecret,
|
||
);
|
||
// Cache the downloaded bytes
|
||
if (bytes != null && msg.id != null) {
|
||
try {
|
||
await _localDbService.updateMessageLocalFileBytes(msg.id!, bytes);
|
||
// Update in-memory message
|
||
setState(() {
|
||
final idx = messages.indexWhere((m) => m.id == msg.id);
|
||
if (idx != -1) {
|
||
messages[idx] = messages[idx].copyWith(localFileBytes: bytes);
|
||
}
|
||
});
|
||
} catch (e) {
|
||
print('Error caching image bytes: $e');
|
||
}
|
||
}
|
||
return bytes;
|
||
}
|
||
|
||
Future<void> _openFullScreenImage(MessageModel msg) async {
|
||
final bytes = await _loadImageBytesForMessage(msg);
|
||
if (bytes == null) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Не удалось открыть изображение.'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
if (!mounted) return;
|
||
Navigator.of(context).push(
|
||
MaterialPageRoute(
|
||
builder: (_) => _FullScreenImageScreen(imageBytes: bytes),
|
||
),
|
||
);
|
||
}
|
||
|
||
Future<void> _saveImageToGallery(MessageModel msg) async {
|
||
final bytes = await _loadImageBytesForMessage(msg);
|
||
if (bytes == null) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Не удалось получить изображение для сохранения.'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
await Gal.putImageBytes(bytes);
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
const SnackBar(
|
||
content: Text('Изображение сохранено в галерею.'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
),
|
||
);
|
||
} catch (e) {
|
||
if (!mounted) return;
|
||
ScaffoldMessenger.of(context).showSnackBar(
|
||
SnackBar(
|
||
content: Text('Не удалось сохранить изображение: $e'),
|
||
behavior: SnackBarBehavior.floating,
|
||
margin: const EdgeInsets.only(bottom: 80.0 + 10.0, left: 10.0, right: 10.0),
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
Future<Uint8List?> _downloadAndDecryptImage(
|
||
String fileId,
|
||
String encryptedFileKey,
|
||
SecretKey sharedSecret,
|
||
) async {
|
||
try {
|
||
print('DEBUG downloadMedia(fileId=$fileId)');
|
||
final bytes = await apiService.downloadMedia(fileId);
|
||
if (bytes == null) {
|
||
print('DEBUG downloadMedia returned null for fileId=$fileId');
|
||
return null;
|
||
}
|
||
print(
|
||
'DEBUG downloadMedia bytes length=${bytes.length} for fileId=$fileId',
|
||
);
|
||
final result = await _cryptoService.decryptImage(
|
||
bytes,
|
||
encryptedFileKey,
|
||
sharedSecret,
|
||
);
|
||
print(
|
||
'DEBUG decryptImage result length=${result?.length ?? 'null'} for fileId=$fileId',
|
||
);
|
||
return result;
|
||
} catch (e) {
|
||
print('Ошибка загрузки и дешифровки медиа: $e');
|
||
return null;
|
||
}
|
||
}
|
||
|
||
Future<String?> _decryptReplyText(
|
||
String? encryptedReplyText,
|
||
SecretKey sharedSecret,
|
||
) async {
|
||
if (encryptedReplyText == null) return null;
|
||
try {
|
||
return await _cryptoService.decryptMessage(
|
||
encryptedReplyText,
|
||
sharedSecret,
|
||
);
|
||
} catch (_) {
|
||
return encryptedReplyText;
|
||
}
|
||
}
|
||
}
|
||
|
||
class _FullScreenImageScreen extends StatelessWidget {
|
||
final Uint8List imageBytes;
|
||
|
||
const _FullScreenImageScreen({required this.imageBytes});
|
||
|
||
@override
|
||
Widget build(BuildContext context) {
|
||
return Scaffold(
|
||
backgroundColor: Colors.black,
|
||
appBar: AppBar(
|
||
backgroundColor: Colors.transparent,
|
||
elevation: 0,
|
||
iconTheme: const IconThemeData(color: Colors.white),
|
||
),
|
||
body: Center(child: InteractiveViewer(child: Image.memory(imageBytes))),
|
||
);
|
||
}
|
||
}
|
||
|
||
class TypingIndicator extends StatefulWidget {
|
||
const TypingIndicator({super.key});
|
||
|
||
@override
|
||
State<TypingIndicator> createState() => _TypingIndicatorState();
|
||
}
|
||
|
||
class _TypingIndicatorState extends State<TypingIndicator>
|
||
with SingleTickerProviderStateMixin {
|
||
late AnimationController _controller;
|
||
|
||
@override
|
||
void initState() {
|
||
super.initState();
|
||
_controller = AnimationController(
|
||
vsync: this,
|
||
duration: const Duration(milliseconds: 600),
|
||
)..repeat(reverse: true); // Анимация идет туда-сюда
|
||
}
|
||
|
||
@override
|
||
void dispose() {
|
||
_controller.dispose();
|
||
super.dispose();
|
||
}
|
||
|
||
Widget _buildDot(int index) {
|
||
return AnimatedBuilder(
|
||
animation: _controller,
|
||
builder: (context, child) {
|
||
// Рассчитываем смещение: только отрицательные значения (вверх)
|
||
double delay = index * 0.5; // Увеличили задержку для плавности
|
||
double shift = sin((_controller.value * 2 * pi) + delay);
|
||
|
||
// Используем clamp или abs, чтобы точка не уходила ниже базовой линии
|
||
double yOffset = (shift < 0 ? shift : 0) * 4;
|
||
|
||
return SizedBox(
|
||
width: 4, // Фиксированная зона для одной точки
|
||
height: 5, // Фиксированная высота зоны анимации
|
||
child: Align(
|
||
alignment: Alignment.bottomCenter, // Точка всегда прижата к низу
|
||
child: Container(
|
||
width: 2,
|
||
height: 2,
|
||
decoration: const BoxDecoration(
|
||
color: Colors.greenAccent,
|
||
shape: BoxShape.circle,
|
||
),
|
||
transform: Matrix4.translationValues(0, yOffset, 0),
|
||
),
|
||
),
|
||
);
|
||
},
|
||
);
|
||
}
|
||
|
||
@override
|
||
Widget build(BuildContext context) {
|
||
return SizedBox(
|
||
height: 12,
|
||
child: Row(
|
||
mainAxisSize: MainAxisSize.min,
|
||
crossAxisAlignment: CrossAxisAlignment.end,
|
||
children: List.generate(3, (index) => _buildDot(index)),
|
||
),
|
||
);
|
||
}
|
||
}
|