rustdesk/flutter/lib/models/chat_model.dart

400 lines
10 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';
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/models/platform_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';
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 'model.dart';
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();
@override
void dispose() {
textController.dispose();
super.dispose();
}
final ChatUser me = ChatUser(
2022-08-04 17:24:02 +08:00
id: "",
2023-03-14 03:43:03 +08:00
firstName: translate("Me"),
);
late final Map<int, MessageBody> _messages = {}..[clientModeID] =
MessageBody(me, []);
2022-05-16 00:01:27 +08:00
var _currentID = clientModeID;
late bool _isShowCMChatPage = false;
2022-05-16 00:01:27 +08:00
Map<int, MessageBody> get messages => _messages;
2022-03-25 16:34:27 +08:00
int get currentID => _currentID;
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(
onKey: (node, event) {
bool isShiftPressed = event.isKeyPressed(LogicalKeyboardKey.shiftLeft);
bool isEnterPressed = event.isKeyPressed(LogicalKeyboardKey.enter);
String trimmedText = textController.text.trim();
// don't send empty message
if (trimmedText.isEmpty) {
textController.text = trimmedText;
}
if (isEnterPressed && !isShiftPressed) {
final ChatMessage message = ChatMessage(
text: trimmedText,
user: me,
createdAt: DateTime.now(),
);
send(message);
textController.text = "";
}
return KeyEventResult.ignored;
},
);
}
2022-05-16 00:01:27 +08:00
ChatUser get currentUser {
final user = messages[currentID]?.chatUser;
if (user == null) {
_currentID = clientModeID;
return me;
} else {
return user;
}
}
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;
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(int id) async {
if (isConnManager) {
if (!_isShowCMChatPage) {
await toggleCMChatPage(id);
}
} else {
if (_isChatOverlayHide()) {
await toggleChatOverlay();
}
}
}
2022-08-22 20:12:58 +08:00
toggleCMChatPage(int id) async {
if (gFFI.chatModel.currentID != id) {
gFFI.chatModel.changeCurrentID(id);
}
if (_isShowCMChatPage) {
_isShowCMChatPage = !_isShowCMChatPage;
2022-08-22 20:12:58 +08:00
notifyListeners();
await windowManager.show();
await windowManager.setSizeAlignment(
2023-05-18 17:41:16 +08:00
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();
}
}
2022-04-05 00:51:47 +08:00
changeCurrentID(int id) {
if (_messages.containsKey(id)) {
2022-03-25 16:34:27 +08:00
_currentID = id;
notifyListeners();
} else {
2022-09-27 20:35:02 +08:00
final client = parent.target?.serverModel.clients
2022-08-22 20:12:58 +08:00
.firstWhere((client) => client.id == id);
2022-05-16 00:01:27 +08:00
if (client == null) {
2022-04-05 00:51:47 +08:00
return debugPrint(
"Failed to changeCurrentID,remote user doesn't exist");
}
2022-05-16 00:01:27 +08:00
final chatUser = ChatUser(
2022-08-04 17:24:02 +08:00
id: client.peerId,
firstName: client.name,
2022-05-16 00:01:27 +08:00
);
_messages[id] = MessageBody(chatUser, []);
_currentID = id;
2022-05-16 00:01:27 +08:00
notifyListeners();
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;
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(id);
2022-08-22 20:12:58 +08:00
int toId = currentID;
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: session.id,
2022-03-25 16:34:27 +08:00
);
toId = id;
2022-04-05 00:51:47 +08:00
} else {
final client =
session.serverModel.clients.firstWhere((client) => client.id == id);
if (isDesktop) {
window_on_top(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.hasUnreadChatMessage.value = true;
} else {
parent.target?.serverModel.jumpTo(id);
toId = id;
}
} else {
toId = id;
}
2022-08-04 17:24:02 +08:00
chatUser = ChatUser(id: client.peerId, firstName: client.name);
2022-03-25 16:34:27 +08:00
}
2022-05-16 00:01:27 +08:00
2022-04-05 00:51:47 +08:00
if (!_messages.containsKey(id)) {
2022-05-16 00:01:27 +08:00
_messages[id] = MessageBody(chatUser, []);
}
2022-08-04 17:24:02 +08:00
_messages[id]!.insert(
ChatMessage(text: text, user: chatUser, createdAt: DateTime.now()));
_currentID = toId;
notifyListeners();
}
send(ChatMessage message) {
2022-08-04 17:24:02 +08:00
if (message.text.isNotEmpty) {
_messages[_currentID]?.insert(message);
if (_currentID == clientModeID) {
2022-09-27 20:35:02 +08:00
if (parent.target != null) {
bind.sessionSendChat(sessionId: sessionId, text: message.text);
}
} else {
2022-08-17 17:23:55 +08:00
bind.cmSendChat(connId: _currentID, msg: message.text);
}
}
notifyListeners();
inputNode.requestFocus();
}
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
}