rustdesk/flutter/lib/models/chat_model.dart

529 lines
15 KiB
Dart
Raw Normal View History

2023-02-02 20:39:25 +08:00
import 'dart:async';
2022-08-04 17:24:02 +08:00
import 'package:dash_chat_2/dash_chat_2.dart';
import 'package:desktop_multi_window/desktop_multi_window.dart';
2022-08-11 10:19:12 +08:00
import 'package:draggable_float_widget/draggable_float_widget.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_hbb/common/shared_state.dart';
import 'package:flutter_hbb/desktop/widgets/tabbar_widget.dart';
import 'package:flutter_hbb/mobile/pages/home_page.dart';
import 'package:flutter_hbb/models/platform_model.dart';
import 'package:flutter_hbb/models/state_model.dart';
import 'package:get/get_rx/src/rx_types/rx_types.dart';
2023-02-06 20:10:39 +08:00
import 'package:get/get.dart';
import 'package:uuid/uuid.dart';
2022-08-22 20:12:58 +08:00
import 'package:window_manager/window_manager.dart';
import 'package:flutter_svg/flutter_svg.dart';
import '../consts.dart';
2022-08-11 10:19:12 +08:00
import '../common.dart';
2022-09-13 09:03:34 +08:00
import '../common/widgets/overlay.dart';
import '../main.dart';
import 'model.dart';
class MessageKey {
final String peerId;
final int connId;
bool get isOut => connId == ChatModel.clientModeID;
MessageKey(this.peerId, this.connId);
@override
bool operator ==(other) {
return other is MessageKey &&
other.peerId == peerId &&
other.isOut == isOut;
}
@override
int get hashCode => peerId.hashCode ^ isOut.hashCode;
}
2022-05-16 00:01:27 +08:00
class MessageBody {
ChatUser chatUser;
List<ChatMessage> chatMessages;
MessageBody(this.chatUser, this.chatMessages);
2022-08-04 17:24:02 +08:00
void insert(ChatMessage cm) {
chatMessages.insert(0, cm);
2022-05-16 00:01:27 +08:00
}
void clear() {
chatMessages.clear();
2022-05-16 00:01:27 +08:00
}
}
class ChatModel with ChangeNotifier {
static final clientModeID = -1;
2022-08-11 10:19:12 +08:00
OverlayEntry? chatIconOverlayEntry;
OverlayEntry? chatWindowOverlayEntry;
2023-02-06 20:10:39 +08:00
bool isConnManager = false;
2022-08-11 10:19:12 +08:00
RxBool isWindowFocus = true.obs;
BlockableOverlayState? _blockableOverlayState;
2023-02-06 20:10:39 +08:00
final Rx<VoiceCallStatus> _voiceCallStatus = Rx(VoiceCallStatus.notStarted);
Rx<VoiceCallStatus> get voiceCallStatus => _voiceCallStatus;
TextEditingController textController = TextEditingController();
RxInt mobileUnreadSum = 0.obs;
MessageKey? latestReceivedKey;
@override
void dispose() {
textController.dispose();
super.dispose();
}
final ChatUser me = ChatUser(
id: Uuid().v4().toString(),
2023-03-14 03:43:03 +08:00
firstName: translate("Me"),
);
late final Map<MessageKey, MessageBody> _messages = {};
2022-05-16 00:01:27 +08:00
MessageKey _currentKey = MessageKey('', -2); // -2 is invalid value
late bool _isShowCMChatPage = false;
Map<MessageKey, MessageBody> get messages => _messages;
2022-03-25 16:34:27 +08:00
MessageKey get currentKey => _currentKey;
bool get isShowCMChatPage => _isShowCMChatPage;
2022-08-22 20:12:58 +08:00
void setOverlayState(BlockableOverlayState blockableOverlayState) {
_blockableOverlayState = blockableOverlayState;
_blockableOverlayState!.addMiddleBlockedListener((v) {
if (!v) {
isWindowFocus.value = false;
if (isWindowFocus.value) {
isWindowFocus.toggle();
}
}
});
}
2022-09-27 20:35:02 +08:00
final WeakReference<FFI> parent;
late final SessionID sessionId;
late FocusNode inputNode;
ChatModel(this.parent) {
sessionId = parent.target!.sessionId;
inputNode = FocusNode(
2023-06-09 16:07:27 +08:00
onKey: (_, event) {
bool isShiftPressed = event.isKeyPressed(LogicalKeyboardKey.shiftLeft);
bool isEnterPressed = event.isKeyPressed(LogicalKeyboardKey.enter);
2023-06-09 16:07:27 +08:00
// don't send empty messages
if (isEnterPressed && isEnterPressed && textController.text.isEmpty) {
return KeyEventResult.handled;
}
if (isEnterPressed && !isShiftPressed) {
final ChatMessage message = ChatMessage(
2023-06-09 16:07:27 +08:00
text: textController.text,
user: me,
createdAt: DateTime.now(),
);
send(message);
2023-06-09 16:07:27 +08:00
textController.clear();
return KeyEventResult.handled;
}
return KeyEventResult.ignored;
},
);
}
ChatUser? get currentUser => _messages[_currentKey]?.chatUser;
2022-08-11 10:19:12 +08:00
showChatIconOverlay({Offset offset = const Offset(200, 50)}) {
if (chatIconOverlayEntry != null) {
chatIconOverlayEntry!.remove();
}
// mobile check navigationBar
final bar = navigationBarKey.currentWidget;
if (bar != null) {
if ((bar as BottomNavigationBar).currentIndex == 1) {
return;
}
}
final overlayState = _blockableOverlayState?.state;
2022-08-11 10:19:12 +08:00
if (overlayState == null) return;
final overlay = OverlayEntry(builder: (context) {
return DraggableFloatWidget(
2023-05-20 21:12:52 +08:00
config: DraggableFloatWidgetBaseConfig(
initPositionYInTop: false,
initPositionYMarginBorder: 100,
borderTopContainTopBar: true,
),
child: FloatingActionButton(
onPressed: () {
if (chatWindowOverlayEntry == null) {
showChatWindowOverlay();
} else {
hideChatWindowOverlay();
}
},
backgroundColor: Theme.of(context).colorScheme.primary,
2023-05-24 14:18:42 +08:00
child: SvgPicture.asset('assets/chat2.svg'),
2023-05-20 21:12:52 +08:00
),
);
2022-08-11 10:19:12 +08:00
});
overlayState.insert(overlay);
chatIconOverlayEntry = overlay;
}
hideChatIconOverlay() {
if (chatIconOverlayEntry != null) {
chatIconOverlayEntry!.remove();
chatIconOverlayEntry = null;
}
}
showChatWindowOverlay({Offset? chatInitPos}) {
2022-08-11 10:19:12 +08:00
if (chatWindowOverlayEntry != null) return;
isWindowFocus.value = true;
_blockableOverlayState?.setMiddleBlocked(true);
final overlayState = _blockableOverlayState?.state;
2022-08-11 10:19:12 +08:00
if (overlayState == null) return;
if (isMobile &&
!gFFI.chatModel.currentKey.isOut && // not in remote page
gFFI.chatModel.latestReceivedKey != null) {
gFFI.chatModel.changeCurrentKey(gFFI.chatModel.latestReceivedKey!);
gFFI.chatModel.mobileClearClientUnread(gFFI.chatModel.currentKey.connId);
}
2022-08-11 10:19:12 +08:00
final overlay = OverlayEntry(builder: (context) {
return Listener(
onPointerDown: (_) {
if (!isWindowFocus.value) {
isWindowFocus.value = true;
_blockableOverlayState?.setMiddleBlocked(true);
}
},
child: DraggableChatWindow(
position: chatInitPos ?? Offset(20, 80),
width: 250,
height: 350,
chatModel: this));
2022-08-11 10:19:12 +08:00
});
overlayState.insert(overlay);
chatWindowOverlayEntry = overlay;
2023-02-02 20:39:25 +08:00
requestChatInputFocus();
2022-08-11 10:19:12 +08:00
}
hideChatWindowOverlay() {
if (chatWindowOverlayEntry != null) {
_blockableOverlayState?.setMiddleBlocked(false);
2022-08-11 10:19:12 +08:00
chatWindowOverlayEntry!.remove();
chatWindowOverlayEntry = null;
return;
}
}
_isChatOverlayHide() => ((!isDesktop && chatIconOverlayEntry == null) ||
chatWindowOverlayEntry == null);
toggleChatOverlay({Offset? chatInitPos}) {
if (_isChatOverlayHide()) {
2022-08-11 10:19:12 +08:00
gFFI.invokeMethod("enable_soft_keyboard", true);
if (!isDesktop) {
showChatIconOverlay();
}
showChatWindowOverlay(chatInitPos: chatInitPos);
2022-08-11 10:19:12 +08:00
} else {
hideChatIconOverlay();
hideChatWindowOverlay();
}
}
hideChatOverlay() {
if (!_isChatOverlayHide()) {
hideChatIconOverlay();
hideChatWindowOverlay();
}
}
showChatPage(MessageKey key) async {
if (isDesktop) {
if (isConnManager) {
if (!_isShowCMChatPage) {
await toggleCMChatPage(key);
}
} else {
if (_isChatOverlayHide()) {
await toggleChatOverlay();
}
}
} else {
if (key.connId == clientModeID) {
if (_isChatOverlayHide()) {
await toggleChatOverlay();
}
}
}
}
toggleCMChatPage(MessageKey key) async {
if (gFFI.chatModel.currentKey != key) {
gFFI.chatModel.changeCurrentKey(key);
2022-08-22 20:12:58 +08:00
}
if (_isShowCMChatPage) {
_isShowCMChatPage = !_isShowCMChatPage;
notifyListeners();
await windowManager.show();
await windowManager.setSizeAlignment(
kConnectionManagerWindowSizeClosedChat, Alignment.topRight);
2022-08-22 20:12:58 +08:00
} else {
2023-02-02 20:39:25 +08:00
requestChatInputFocus();
await windowManager.show();
2023-05-18 17:41:16 +08:00
await windowManager.setSizeAlignment(
kConnectionManagerWindowSizeOpenChat, Alignment.topRight);
_isShowCMChatPage = !_isShowCMChatPage;
2022-08-22 20:12:58 +08:00
notifyListeners();
}
}
changeCurrentKey(MessageKey key) {
updateConnIdOfKey(key);
String? peerName;
if (key.connId == clientModeID) {
peerName = parent.target?.ffiModel.pi.username;
} else {
peerName = parent.target?.serverModel.clients
.firstWhereOrNull((client) => client.peerId == key.peerId)
?.name;
}
if (!_messages.containsKey(key)) {
2022-05-16 00:01:27 +08:00
final chatUser = ChatUser(
id: key.peerId,
firstName: peerName,
2022-05-16 00:01:27 +08:00
);
_messages[key] = MessageBody(chatUser, []);
} else {
if (peerName != null && peerName.isNotEmpty) {
_messages[key]?.chatUser.firstName = peerName;
}
2022-03-25 16:34:27 +08:00
}
_currentKey = key;
notifyListeners();
mobileClearClientUnread(key.connId);
2022-03-25 16:34:27 +08:00
}
receive(int id, String text) async {
final session = parent.target;
if (session == null) {
debugPrint("Failed to receive msg, session state is null");
return;
}
if (text.isEmpty) return;
if (desktopType == DesktopType.cm) {
await showCmWindow();
}
String? peerId;
if (id == clientModeID) {
peerId = session.id;
} else {
peerId = session.serverModel.clients
.firstWhereOrNull((e) => e.id == id)
?.peerId;
}
if (peerId == null) {
debugPrint("Failed to receive msg, peerId is null");
return;
}
final messagekey = MessageKey(peerId, id);
2022-08-22 20:12:58 +08:00
// mobile: first message show overlay icon
if (!isDesktop && chatIconOverlayEntry == null) {
showChatIconOverlay();
2022-08-22 20:12:58 +08:00
}
// show chat page
await showChatPage(messagekey);
late final ChatUser chatUser;
2022-04-05 00:51:47 +08:00
if (id == clientModeID) {
2022-03-25 16:34:27 +08:00
chatUser = ChatUser(
firstName: session.ffiModel.pi.username,
id: peerId,
2022-03-25 16:34:27 +08:00
);
if (isDesktop) {
if (Get.isRegistered<DesktopTabController>()) {
DesktopTabController tabController = Get.find<DesktopTabController>();
var index = tabController.state.value.tabs
.indexWhere((e) => e.key == session.id);
final notSelected =
index >= 0 && tabController.state.value.selected != index;
// minisized: top and switch tab
// not minisized: add count
if (await WindowController.fromWindowId(stateGlobal.windowId)
.isMinimized()) {
windowOnTop(stateGlobal.windowId);
if (notSelected) {
tabController.jumpTo(index);
}
} else {
if (notSelected) {
UnreadChatCountState.find(peerId).value += 1;
}
}
}
}
2022-04-05 00:51:47 +08:00
} else {
final client = session.serverModel.clients
.firstWhereOrNull((client) => client.id == id);
if (client == null) {
debugPrint("Failed to receive msg, client is null");
return;
}
if (isDesktop) {
windowOnTop(null);
// disable auto jumpTo other tab when hasFocus, and mark unread message
final currentSelectedTab =
session.serverModel.tabController.state.value.selectedTabInfo;
if (currentSelectedTab.key != id.toString() && inputNode.hasFocus) {
client.unreadChatMessageCount.value += 1;
} else {
parent.target?.serverModel.jumpTo(id);
}
} else {
if (HomePage.homeKey.currentState?.selectedIndex != 1 ||
_currentKey != messagekey) {
client.unreadChatMessageCount.value += 1;
mobileUpdateUnreadSum();
}
}
2022-08-04 17:24:02 +08:00
chatUser = ChatUser(id: client.peerId, firstName: client.name);
2022-03-25 16:34:27 +08:00
}
insertMessage(messagekey,
2022-08-04 17:24:02 +08:00
ChatMessage(text: text, user: chatUser, createdAt: DateTime.now()));
if (id == clientModeID || _currentKey.peerId.isEmpty) {
// client or invalid
_currentKey = messagekey;
mobileClearClientUnread(messagekey.connId);
}
latestReceivedKey = messagekey;
notifyListeners();
}
send(ChatMessage message) {
2023-06-09 16:07:27 +08:00
String trimmedText = message.text.trim();
if (trimmedText.isEmpty) {
return;
}
message.text = trimmedText;
insertMessage(_currentKey, message);
if (_currentKey.connId == clientModeID && parent.target != null) {
2023-06-09 16:07:27 +08:00
bind.sessionSendChat(sessionId: sessionId, text: message.text);
} else {
bind.cmSendChat(connId: _currentKey.connId, msg: message.text);
}
2023-06-09 16:07:27 +08:00
notifyListeners();
inputNode.requestFocus();
}
insertMessage(MessageKey key, ChatMessage message) {
updateConnIdOfKey(key);
if (!_messages.containsKey(key)) {
_messages[key] = MessageBody(message.user, []);
}
_messages[key]?.insert(message);
}
updateConnIdOfKey(MessageKey key) {
if (_messages.keys
.toList()
.firstWhereOrNull((e) => e == key && e.connId != key.connId) !=
null) {
final value = _messages.remove(key);
if (value != null) {
_messages[key] = value;
}
}
if (_currentKey == key || _currentKey.peerId.isEmpty) {
_currentKey = key; // hash != assign
}
}
void mobileUpdateUnreadSum() {
if (!isMobile) return;
var sum = 0;
parent.target?.serverModel.clients
.map((e) => sum += e.unreadChatMessageCount.value)
.toList();
Future.delayed(Duration.zero, () {
mobileUnreadSum.value = sum;
});
}
void mobileClearClientUnread(int id) {
if (!isMobile) return;
final client = parent.target?.serverModel.clients
.firstWhereOrNull((client) => client.id == id);
if (client != null) {
Future.delayed(Duration.zero, () {
client.unreadChatMessageCount.value = 0;
mobileUpdateUnreadSum();
});
}
}
2022-03-25 16:34:27 +08:00
close() {
hideChatIconOverlay();
hideChatWindowOverlay();
notifyListeners();
}
2022-05-16 00:01:27 +08:00
resetClientMode() {
_messages[clientModeID]?.clear();
}
2023-02-02 20:39:25 +08:00
void requestChatInputFocus() {
Timer(Duration(milliseconds: 100), () {
if (inputNode.hasListeners && inputNode.canRequestFocus) {
inputNode.requestFocus();
}
});
}
2023-02-06 20:10:39 +08:00
void onVoiceCallWaiting() {
_voiceCallStatus.value = VoiceCallStatus.waitingForResponse;
}
void onVoiceCallStarted() {
_voiceCallStatus.value = VoiceCallStatus.connected;
}
void onVoiceCallClosed(String reason) {
_voiceCallStatus.value = VoiceCallStatus.notStarted;
}
void onVoiceCallIncoming() {
if (isConnManager) {
_voiceCallStatus.value = VoiceCallStatus.incoming;
}
}
2023-02-07 16:11:55 +08:00
void closeVoiceCall() {
bind.sessionCloseVoiceCall(sessionId: sessionId);
2023-02-07 16:11:55 +08:00
}
}
2023-02-06 20:10:39 +08:00
enum VoiceCallStatus {
notStarted,
waitingForResponse,
connected,
// Connection manager only.
incoming
}