1134 lines
40 KiB
C#
1134 lines
40 KiB
C#
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
using RelayClient.Crypto;
|
|
using RelayClient.Helpers;
|
|
using RelayClient.Services;
|
|
using RelayShared.Rtc;
|
|
using RelayShared.Services;
|
|
|
|
namespace RelayClient;
|
|
|
|
public partial class MainPage : ContentPage
|
|
{
|
|
public static string _username = string.Empty;
|
|
private readonly RelaySocketClient _socket;
|
|
private readonly RtcBridgeService _rtc;
|
|
|
|
public static string? _userToken;
|
|
|
|
private string? _currentChannelId;
|
|
private string? _currentChannelName;
|
|
private ChannelType _currentChannelType = ChannelType.Text;
|
|
|
|
private readonly Dictionary<string, List<ChatMessage>> _messagesByChannel = new();
|
|
private readonly List<ChannelItem> _channels = [];
|
|
private readonly Dictionary<string, ChatMessage> _messagesById = new();
|
|
private readonly Dictionary<string, Border> _messageBubbles = new();
|
|
|
|
private ChatMessage? _replyingToMessage;
|
|
private string? _editingMessageId;
|
|
|
|
private string? _pendingAttachmentBase64;
|
|
private string? _pendingAttachmentMimeType;
|
|
private string? _pendingAttachmentFileName;
|
|
|
|
private CancellationTokenSource? _typingDebounce;
|
|
private readonly Dictionary<string, CancellationTokenSource> _typingClearTimers = new();
|
|
|
|
private bool _channelsInitialized;
|
|
|
|
private readonly Dictionary<string, int> _mentionCounts = new();
|
|
|
|
private static readonly Regex MentionExtract =
|
|
new(@"@(\w+)", RegexOptions.Compiled);
|
|
|
|
public MainPage(string username)
|
|
{
|
|
InitializeComponent();
|
|
|
|
_username = username;
|
|
UserLabel.Text = $"Logged in as: {_username}";
|
|
|
|
if (!KeyStorage.HasKeys(_username))
|
|
{
|
|
var keys = E2EeHelper.GenerateRsaKeyPair();
|
|
KeyStorage.SavePrivateKey(_username, keys.privateKey);
|
|
KeyStorage.SavePublicKey(_username, keys.publicKey);
|
|
}
|
|
|
|
_ = ServerAPI.setupClient();
|
|
|
|
_socket = new RelaySocketClient(_username);
|
|
_rtc = new RtcBridgeService(
|
|
_username, _socket, hybridWebView,
|
|
() => _currentChannelId,
|
|
SafeSendRawToWebView);
|
|
|
|
hybridWebView.SetInvokeJavaScriptTarget(_rtc);
|
|
|
|
_socket.Log += Console.WriteLine;
|
|
_socket.ChannelListReceived += HandleChannelList;
|
|
_socket.EncryptedChatReceived += HandleEncryptedChat;
|
|
_socket.MessageEdited += HandleMessageEdited;
|
|
_socket.MessageDeleted += HandleMessageDeleted;
|
|
_socket.TypingReceived += HandleTyping;
|
|
_socket.EditHistoryReceived += HandleEditHistory;
|
|
_socket.EncryptedRtcSignalReceived += payload =>
|
|
MainThread.BeginInvokeOnMainThread(async () => await _rtc.HandleIncomingRtcSignalAsync(payload));
|
|
|
|
_socket.Connect();
|
|
SetupEditorKeyHandler();
|
|
SetupFileDragAndDrop();
|
|
}
|
|
|
|
private void SetupFileDragAndDrop()
|
|
{
|
|
#if WINDOWS
|
|
MessagesView.HandlerChanged += (s, e) =>
|
|
{
|
|
if (MessagesView.Handler?.PlatformView is not Microsoft.UI.Xaml.UIElement el) return;
|
|
|
|
el.AllowDrop = true;
|
|
|
|
el.DragOver += (_, args) =>
|
|
{
|
|
args.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy;
|
|
args.DragUIOverride.Caption = "Attach to message";
|
|
args.DragUIOverride.IsCaptionVisible = true;
|
|
args.DragUIOverride.IsGlyphVisible = true;
|
|
args.Handled = true;
|
|
};
|
|
|
|
el.Drop += async (_, args) =>
|
|
{
|
|
args.Handled = true;
|
|
try
|
|
{
|
|
if (!args.DataView.Contains(Windows.ApplicationModel.DataTransfer.StandardDataFormats.StorageItems))
|
|
return;
|
|
|
|
var items = await args.DataView.GetStorageItemsAsync();
|
|
var file = items.OfType<Windows.Storage.StorageFile>().FirstOrDefault();
|
|
if (file is null) return;
|
|
|
|
await IngestPickedFileAsync(file.Path, file.Name);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Drop failed: {ex.Message}");
|
|
}
|
|
};
|
|
};
|
|
#endif
|
|
}
|
|
|
|
private void SetupEditorKeyHandler()
|
|
{
|
|
#if WINDOWS
|
|
MessageEntry.HandlerChanged += (s, e) =>
|
|
{
|
|
if (MessageEntry.Handler?.PlatformView is not Microsoft.UI.Xaml.Controls.TextBox tb)
|
|
return;
|
|
|
|
// CRITICAL: with AcceptsReturn = true, the TextBox inserts the newline *before*
|
|
// KeyDown fires for us, so args.Handled = true is too late. Turn it off and
|
|
// handle Enter ourselves — bare Enter sends, Shift+Enter inserts \n manually.
|
|
tb.AcceptsReturn = false;
|
|
|
|
// PreviewKeyDown is exposed in WinUI via AddHandler with handledEventsToo: true.
|
|
tb.AddHandler(
|
|
Microsoft.UI.Xaml.UIElement.KeyDownEvent,
|
|
new Microsoft.UI.Xaml.Input.KeyEventHandler((sender, args) =>
|
|
{
|
|
if (args.Key != Windows.System.VirtualKey.Enter) return;
|
|
|
|
var shift = Microsoft.UI.Input.InputKeyboardSource
|
|
.GetKeyStateForCurrentThread(Windows.System.VirtualKey.Shift);
|
|
bool shiftHeld = shift.HasFlag(Windows.UI.Core.CoreVirtualKeyStates.Down);
|
|
|
|
args.Handled = true;
|
|
|
|
if (shiftHeld)
|
|
{
|
|
// Shift+Enter → insert a newline at the caret.
|
|
int caret = tb.SelectionStart;
|
|
var text = tb.Text ?? string.Empty;
|
|
tb.Text = text.Insert(caret, Environment.NewLine);
|
|
tb.SelectionStart = caret + Environment.NewLine.Length;
|
|
}
|
|
else
|
|
{
|
|
// Bare Enter → send the message.
|
|
MainThread.BeginInvokeOnMainThread(SendMessage);
|
|
}
|
|
}),
|
|
handledEventsToo: true);
|
|
};
|
|
#endif
|
|
}
|
|
|
|
private void SendButton_OnClicked(object? sender, EventArgs e) => SendMessage();
|
|
|
|
private void MessageEntry_OnTextChanged(object? sender, TextChangedEventArgs e)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(_currentChannelId)) return;
|
|
|
|
_typingDebounce?.Cancel();
|
|
_typingDebounce = new CancellationTokenSource();
|
|
var token = _typingDebounce.Token;
|
|
|
|
_ = Task.Run(async () =>
|
|
{
|
|
await Task.Delay(400, token);
|
|
if (!token.IsCancellationRequested)
|
|
_socket.SendTyping(_currentChannelId!);
|
|
}, token);
|
|
}
|
|
|
|
private void SendMessage()
|
|
{
|
|
if (!MessageEntry.IsEnabled) return;
|
|
|
|
var text = MessageEntry.Text?.Trim();
|
|
if (string.IsNullOrWhiteSpace(text) && _pendingAttachmentBase64 is null) return;
|
|
|
|
if (string.IsNullOrWhiteSpace(_socket.ServerPublicKey) ||
|
|
string.IsNullOrWhiteSpace(_currentChannelId)) return;
|
|
|
|
if (_editingMessageId is not null)
|
|
{
|
|
var editContent = new ChatMessageContent { Text = text ?? string.Empty };
|
|
var editEncrypted = E2EeHelper.EncryptForRecipient(
|
|
JsonSerializer.Serialize(editContent), _socket.ServerPublicKey);
|
|
_socket.SendEditMessage(_editingMessageId, _currentChannelId!, editEncrypted);
|
|
CancelContext();
|
|
return;
|
|
}
|
|
|
|
var mentions = MentionExtract
|
|
.Matches(text ?? string.Empty)
|
|
.Select(m => m.Groups[1].Value)
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToList();
|
|
|
|
if (_replyingToMessage is not null &&
|
|
!mentions.Contains(_replyingToMessage.SenderUsername, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
mentions.Add(_replyingToMessage.SenderUsername);
|
|
}
|
|
|
|
var content = new ChatMessageContent
|
|
{
|
|
Text = text ?? string.Empty,
|
|
ReplyToId = _replyingToMessage?.MessageId,
|
|
ReplyToSenderUsername = _replyingToMessage?.SenderUsername,
|
|
ReplyPreview = _replyingToMessage is null ? null
|
|
: (_replyingToMessage.Text.Length > 100
|
|
? _replyingToMessage.Text[..100] + "…"
|
|
: _replyingToMessage.Text),
|
|
Mentions = mentions.Count > 0 ? mentions : null,
|
|
AttachmentBase64 = _pendingAttachmentBase64,
|
|
AttachmentMimeType = _pendingAttachmentMimeType,
|
|
AttachmentFileName = _pendingAttachmentFileName
|
|
};
|
|
|
|
var channelId = _currentChannelId!;
|
|
var serverPublicKey = _socket.ServerPublicKey!;
|
|
var attachmentName = _pendingAttachmentFileName;
|
|
|
|
CancelContext();
|
|
ClearPendingAttachment();
|
|
MessageEntry.Text = string.Empty;
|
|
|
|
_ = Task.Run(() =>
|
|
{
|
|
try
|
|
{
|
|
var contentJson = JsonSerializer.Serialize(content);
|
|
var encrypted = E2EeHelper.EncryptForRecipient(contentJson, serverPublicKey);
|
|
|
|
_socket.SendJson(new SocketEncryptedMessage
|
|
{
|
|
ChannelId = channelId,
|
|
Type = SignalType.ClientEncryptedChat,
|
|
SenderUsername = _username,
|
|
CipherText = encrypted.CipherText,
|
|
Nonce = encrypted.Nonce,
|
|
Tag = encrypted.Tag,
|
|
EncryptedKey = encrypted.EncryptedKey
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Send failed: {ex}");
|
|
MainThread.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
await DisplayAlert("Send failed",
|
|
attachmentName is null
|
|
? $"Could not send message: {ex.Message}"
|
|
: $"Could not send {attachmentName}: {ex.Message}",
|
|
"OK");
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
private async void AttachFile_OnClicked(object? sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
var result = await FilePicker.Default.PickAsync(new PickOptions
|
|
{
|
|
PickerTitle = "Attach a file"
|
|
});
|
|
|
|
if (result is null) return;
|
|
await IngestPickedFileAsync(result.FullPath, result.FileName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"File attach failed: {ex.Message}");
|
|
await DisplayAlert("Attach failed", ex.Message, "OK");
|
|
}
|
|
}
|
|
|
|
private async Task IngestPickedFileAsync(string fullPath, string fileName)
|
|
{
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
await DisplayAlert("Attach failed", $"File not found:\n{fullPath}", "OK");
|
|
return;
|
|
}
|
|
|
|
var bytes = await File.ReadAllBytesAsync(fullPath);
|
|
|
|
const long maxBytes = 50L * 1024 * 1024;
|
|
|
|
if (bytes.Length > maxBytes)
|
|
{
|
|
await DisplayAlert("File too large",
|
|
$"'{fileName}' is {bytes.Length / (1024.0 * 1024.0):F1} MB. " +
|
|
"Attachments must be under 50 MB.",
|
|
"OK");
|
|
return;
|
|
}
|
|
|
|
_pendingAttachmentBase64 = Convert.ToBase64String(bytes);
|
|
_pendingAttachmentFileName = fileName;
|
|
_pendingAttachmentMimeType = GetMimeType(fileName);
|
|
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
ContextBarLabel.Text = $"📎 {fileName} attached — Send or press ✕ to remove";
|
|
ContextBar.IsVisible = true;
|
|
MessageEntry.Focus();
|
|
});
|
|
}
|
|
|
|
private void ClearPendingAttachment()
|
|
{
|
|
_pendingAttachmentBase64 = null;
|
|
_pendingAttachmentMimeType = null;
|
|
_pendingAttachmentFileName = null;
|
|
}
|
|
|
|
private static string GetMimeType(string fileName)
|
|
{
|
|
var ext = Path.GetExtension(fileName).ToLowerInvariant();
|
|
return ext switch
|
|
{
|
|
".jpg" or ".jpeg" => "image/jpeg",
|
|
".png" => "image/png",
|
|
".gif" => "image/gif",
|
|
".webp" => "image/webp",
|
|
".bmp" => "image/bmp",
|
|
".pdf" => "application/pdf",
|
|
".zip" => "application/zip",
|
|
".txt" => "text/plain",
|
|
_ => "application/octet-stream"
|
|
};
|
|
}
|
|
|
|
private void CancelContext_OnClicked(object? sender, EventArgs e) => CancelContext();
|
|
|
|
private void CancelContext()
|
|
{
|
|
_replyingToMessage = null;
|
|
_editingMessageId = null;
|
|
ClearPendingAttachment();
|
|
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
ContextBar.IsVisible = false;
|
|
ContextBarLabel.Text = string.Empty;
|
|
MessageEntry.Text = string.Empty;
|
|
});
|
|
}
|
|
|
|
private void StartReply(ChatMessage message)
|
|
{
|
|
_replyingToMessage = message;
|
|
_editingMessageId = null;
|
|
var preview = message.Text.Length > 80 ? message.Text[..80] + "…" : message.Text;
|
|
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
ContextBarLabel.Text = $"↩ {message.SenderUsername}: {preview}";
|
|
ContextBar.IsVisible = true;
|
|
MessageEntry.Focus();
|
|
});
|
|
}
|
|
|
|
private void StartEdit(ChatMessage message)
|
|
{
|
|
_editingMessageId = message.MessageId;
|
|
_replyingToMessage = null;
|
|
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
ContextBarLabel.Text = "✏ Editing message — Enter to save, ✕ to cancel";
|
|
ContextBar.IsVisible = true;
|
|
MessageEntry.Text = message.Text;
|
|
MessageEntry.Focus();
|
|
});
|
|
}
|
|
|
|
private void ConfirmDelete(ChatMessage message) =>
|
|
_socket.SendDeleteMessage(message.MessageId, _currentChannelId ?? string.Empty);
|
|
|
|
private void CopyMessageLink(ChatMessage message)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(message.MessageId)) return;
|
|
var link = $"relay://jump/{_currentChannelId}/{message.MessageId}";
|
|
_ = Clipboard.Default.SetTextAsync(link);
|
|
SafeSendRawToWebView($"Link copied: {link}");
|
|
}
|
|
|
|
private void AttachMessageContextMenu(Border bubble, ChatMessage message)
|
|
{
|
|
#if WINDOWS
|
|
bubble.HandlerChanged += (s, e) =>
|
|
{
|
|
if (bubble.Handler?.PlatformView is not Microsoft.UI.Xaml.FrameworkElement fe) return;
|
|
fe.RightTapped += async (_, args) =>
|
|
{
|
|
args.Handled = true;
|
|
await ShowMessageContextMenuAsync(message);
|
|
};
|
|
};
|
|
#else
|
|
var longPress = new TapGestureRecognizer { NumberOfTapsRequired = 2 };
|
|
longPress.Tapped += async (_, _) => await ShowMessageContextMenuAsync(message);
|
|
bubble.GestureRecognizers.Add(longPress);
|
|
#endif
|
|
}
|
|
|
|
private async Task ShowMessageContextMenuAsync(ChatMessage message)
|
|
{
|
|
if (message.IsDeleted) return;
|
|
|
|
bool isOwn = message.SenderUsername.Equals(_username, StringComparison.OrdinalIgnoreCase);
|
|
|
|
var options = new List<string> { "↩ Reply", "🔗 Copy Message Link" };
|
|
if (isOwn)
|
|
{
|
|
options.Add("✏ Edit");
|
|
options.Add("🗑 Delete");
|
|
}
|
|
|
|
var action = await DisplayActionSheet(null, "Cancel", null, [.. options]);
|
|
switch (action)
|
|
{
|
|
case "↩ Reply": StartReply(message); break;
|
|
case "🔗 Copy Message Link": CopyMessageLink(message); break;
|
|
case "✏ Edit": StartEdit(message); break;
|
|
case "🗑 Delete": ConfirmDelete(message); break;
|
|
}
|
|
}
|
|
|
|
private void AttachChannelContextMenu(View target, ChannelItem channel)
|
|
{
|
|
#if WINDOWS
|
|
target.HandlerChanged += (s, e) =>
|
|
{
|
|
if (target.Handler?.PlatformView is not Microsoft.UI.Xaml.FrameworkElement fe) return;
|
|
fe.RightTapped += async (_, args) =>
|
|
{
|
|
args.Handled = true;
|
|
await ShowChannelContextMenuAsync(channel);
|
|
};
|
|
};
|
|
#else
|
|
var longPress = new TapGestureRecognizer { NumberOfTapsRequired = 2 };
|
|
longPress.Tapped += async (_, _) => await ShowChannelContextMenuAsync(channel);
|
|
target.GestureRecognizers.Add(longPress);
|
|
#endif
|
|
}
|
|
|
|
private async Task ShowChannelContextMenuAsync(ChannelItem channel)
|
|
{
|
|
var options = new List<string> { "⚙ View Permissions" };
|
|
if (channel.CanManage)
|
|
options.Add("🗑 Delete Channel");
|
|
|
|
var action = await DisplayActionSheet($"#{channel.Name}", "Cancel", null, [.. options]);
|
|
|
|
switch (action)
|
|
{
|
|
case "⚙ View Permissions":
|
|
await ShowChannelPermissionsAsync(channel);
|
|
break;
|
|
case "🗑 Delete Channel":
|
|
await ConfirmDeleteChannelAsync(channel);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private async Task ShowChannelPermissionsAsync(ChannelItem channel)
|
|
{
|
|
var lines = new List<string>
|
|
{
|
|
$"Channel: #{channel.Name}",
|
|
$"Type: {channel.Type}",
|
|
$"Read-only: {(channel.IsReadOnly ? "Yes (only admins can post)" : "No")}",
|
|
"",
|
|
"Working channel permissions:",
|
|
" • Visibility — who can see the channel",
|
|
" • Speak — who can talk (voice channels)",
|
|
" • Edit — rename / reconfigure",
|
|
" • Delete — remove the channel",
|
|
"",
|
|
"Your access here:",
|
|
$" Post: {(channel.CanPost ? "Yes" : "No")}",
|
|
$" Manage: {(channel.CanManage ? "Yes" : "No")}",
|
|
};
|
|
|
|
await DisplayAlert("Channel Permissions", string.Join("\n", lines), "Close");
|
|
}
|
|
|
|
private async Task ConfirmDeleteChannelAsync(ChannelItem channel)
|
|
{
|
|
bool ok = await DisplayAlert(
|
|
"Delete Channel",
|
|
$"Delete #{channel.Name}? This cannot be undone.",
|
|
"Delete", "Cancel");
|
|
|
|
if (ok) _socket.SendDeleteChannel(channel.ChannelId);
|
|
}
|
|
|
|
private async void AddChannel_OnClicked(object? sender, EventArgs e)
|
|
{
|
|
var name = await DisplayPromptAsync("New Channel", "Channel name:", "Create", "Cancel",
|
|
placeholder: "channel-name", maxLength: 32);
|
|
if (string.IsNullOrWhiteSpace(name)) return;
|
|
|
|
var typeStr = await DisplayActionSheet("Channel Type", "Cancel", null,
|
|
"Text", "Voice", "Forum", "Stage", "File");
|
|
if (typeStr is null or "Cancel") return;
|
|
|
|
var channelType = typeStr switch
|
|
{
|
|
"Voice" => ChannelType.Voice,
|
|
"Forum" => ChannelType.Forum,
|
|
"Stage" => ChannelType.Stage,
|
|
"File" => ChannelType.File,
|
|
_ => ChannelType.Text
|
|
};
|
|
|
|
var group = await DisplayPromptAsync("Group / Category",
|
|
"Optional group label (e.g. General):", "OK", "Skip",
|
|
placeholder: "General") ?? string.Empty;
|
|
|
|
_socket.SendCreateChannel(
|
|
name.Trim().ToLower().Replace(" ", "-"),
|
|
channelType,
|
|
group);
|
|
}
|
|
|
|
private void HandleChannelList(SocketChannelList channelList)
|
|
{
|
|
_channels.Clear();
|
|
_channels.AddRange(channelList.Channels.OrderBy(c => c.CreatedAt));
|
|
|
|
if (!_channelsInitialized)
|
|
{
|
|
_channelsInitialized = true;
|
|
|
|
var defaultChannel = _channels
|
|
.FirstOrDefault(c => c.Name.Equals("welcome", StringComparison.OrdinalIgnoreCase))
|
|
?? _channels.FirstOrDefault();
|
|
|
|
if (defaultChannel is null) return;
|
|
|
|
_currentChannelId = defaultChannel.ChannelId;
|
|
_currentChannelName = defaultChannel.Name;
|
|
_currentChannelType = defaultChannel.Type;
|
|
|
|
MainThread.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
ChannelLabel.Text = $"#{_currentChannelName}";
|
|
RenderChannelList();
|
|
UpdateInputForCurrentChannel();
|
|
await _rtc.PushRtcContextToJsAsync();
|
|
});
|
|
|
|
_socket.SendGetHistory(_currentChannelId);
|
|
}
|
|
else
|
|
{
|
|
MainThread.BeginInvokeOnMainThread(RenderChannelList);
|
|
}
|
|
}
|
|
|
|
private void HandleEncryptedChat(SocketEncryptedMessage payload)
|
|
{
|
|
if (!payload.RecipientUsername.Equals(_username, StringComparison.OrdinalIgnoreCase)) return;
|
|
|
|
ChatMessage message;
|
|
|
|
if (payload.IsDeleted)
|
|
{
|
|
message = new ChatMessage
|
|
{
|
|
MessageId = payload.MessageId,
|
|
SenderUsername = payload.SenderUsername,
|
|
Timestamp = DateTime.MinValue,
|
|
IsDeleted = true
|
|
};
|
|
}
|
|
else
|
|
{
|
|
if (!TryDecryptAndParseContent(payload, out var content)) return;
|
|
|
|
message = new ChatMessage
|
|
{
|
|
MessageId = payload.MessageId,
|
|
SenderUsername = payload.SenderUsername,
|
|
Text = content.Text,
|
|
Timestamp = DateTime.Now,
|
|
ReplyToId = content.ReplyToId,
|
|
ReplyToSenderUsername = content.ReplyToSenderUsername,
|
|
ReplyPreview = content.ReplyPreview,
|
|
Mentions = content.Mentions,
|
|
AttachmentBase64 = content.AttachmentBase64,
|
|
AttachmentMimeType = content.AttachmentMimeType,
|
|
AttachmentFileName = content.AttachmentFileName,
|
|
IsEdited = payload.IsEdited
|
|
};
|
|
}
|
|
|
|
if (!_messagesByChannel.ContainsKey(payload.ChannelId))
|
|
_messagesByChannel[payload.ChannelId] = [];
|
|
|
|
_messagesByChannel[payload.ChannelId].Add(message);
|
|
|
|
if (!string.IsNullOrWhiteSpace(message.MessageId))
|
|
_messagesById[message.MessageId] = message;
|
|
|
|
if (payload.ChannelId == _currentChannelId)
|
|
{
|
|
MainThread.BeginInvokeOnMainThread(() => RenderSingleMessage(message));
|
|
}
|
|
else if (MessageMentionsMe(message) &&
|
|
!message.SenderUsername.Equals(_username, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_mentionCounts.TryGetValue(payload.ChannelId, out var n);
|
|
_mentionCounts[payload.ChannelId] = n + 1;
|
|
MainThread.BeginInvokeOnMainThread(RenderChannelList);
|
|
}
|
|
}
|
|
|
|
private static bool MessageMentionsMe(ChatMessage message) =>
|
|
message.Mentions is not null &&
|
|
message.Mentions.Any(m =>
|
|
string.Equals(m, _username, StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(m, "here", StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(m, "everyone", StringComparison.OrdinalIgnoreCase));
|
|
|
|
private void HandleMessageEdited(SocketEncryptedMessage payload)
|
|
{
|
|
if (!payload.RecipientUsername.Equals(_username, StringComparison.OrdinalIgnoreCase)) return;
|
|
if (!TryDecryptAndParseContent(payload, out var content)) return;
|
|
if (!_messagesById.TryGetValue(payload.MessageId, out var message)) return;
|
|
|
|
message.Text = content.Text;
|
|
message.IsEdited = true;
|
|
|
|
if (_messageBubbles.TryGetValue(payload.MessageId, out var bubble))
|
|
MainThread.BeginInvokeOnMainThread(() => RebuildBubbleContent(bubble, message));
|
|
}
|
|
|
|
private void HandleMessageDeleted(SocketMessageDeletedEvent payload)
|
|
{
|
|
if (!_messagesById.TryGetValue(payload.MessageId, out var message)) return;
|
|
message.IsDeleted = true;
|
|
|
|
if (_messageBubbles.TryGetValue(payload.MessageId, out var bubble))
|
|
MainThread.BeginInvokeOnMainThread(() => RebuildBubbleContent(bubble, message));
|
|
}
|
|
|
|
private void HandleTyping(SocketTypingEvent payload)
|
|
{
|
|
if (payload.ChannelId != _currentChannelId) return;
|
|
if (payload.Username.Equals(_username, StringComparison.OrdinalIgnoreCase)) return;
|
|
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
TypingLabel.Text = $"{payload.Username} is typing…";
|
|
TypingLabel.IsVisible = true;
|
|
});
|
|
|
|
if (_typingClearTimers.TryGetValue(payload.Username, out var existing))
|
|
existing.Cancel();
|
|
|
|
var cts = new CancellationTokenSource();
|
|
_typingClearTimers[payload.Username] = cts;
|
|
|
|
_ = Task.Run(async () =>
|
|
{
|
|
await Task.Delay(3000, cts.Token);
|
|
if (!cts.Token.IsCancellationRequested)
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
TypingLabel.IsVisible = false;
|
|
TypingLabel.Text = string.Empty;
|
|
});
|
|
}, cts.Token);
|
|
}
|
|
|
|
private void HandleEditHistory(SocketEditHistoryResponse response)
|
|
{
|
|
var entries = new List<(string Text, DateTime At)>();
|
|
|
|
foreach (var entry in response.Entries)
|
|
{
|
|
try
|
|
{
|
|
var pk = KeyStorage.LoadPrivateKey(_username);
|
|
var plainText = E2EeHelper.DecryptForRecipient(
|
|
new EncryptedPayload
|
|
{
|
|
CipherText = entry.CipherText,
|
|
Nonce = entry.Nonce,
|
|
Tag = entry.Tag,
|
|
EncryptedKey = entry.EncryptedKey
|
|
}, pk);
|
|
|
|
ChatMessageContent? parsed = null;
|
|
try { parsed = JsonSerializer.Deserialize<ChatMessageContent>(plainText); } catch { }
|
|
entries.Add((parsed?.Text ?? plainText, entry.EditedAt));
|
|
}
|
|
catch (Exception ex) { Console.WriteLine($"Edit history decrypt: {ex.Message}"); }
|
|
}
|
|
|
|
MainThread.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
if (entries.Count == 0)
|
|
{
|
|
await DisplayAlert("Edit History", "No previous versions found.", "OK");
|
|
return;
|
|
}
|
|
|
|
var text = string.Join("\n\n", entries.Select(e => $"[{e.At:g}]\n{e.Text}"));
|
|
await DisplayAlert($"Edit History ({entries.Count} versions)", text, "Close");
|
|
});
|
|
}
|
|
|
|
private bool TryDecryptAndParseContent(SocketEncryptedMessage payload, out ChatMessageContent content)
|
|
{
|
|
content = new ChatMessageContent();
|
|
|
|
string decryptedText;
|
|
try
|
|
{
|
|
var pk = KeyStorage.LoadPrivateKey(_username);
|
|
decryptedText = E2EeHelper.DecryptForRecipient(
|
|
new EncryptedPayload
|
|
{
|
|
CipherText = payload.CipherText,
|
|
Nonce = payload.Nonce,
|
|
Tag = payload.Tag,
|
|
EncryptedKey = payload.EncryptedKey
|
|
}, pk);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[{_username}] decrypt failed: {ex.Message}");
|
|
return false;
|
|
}
|
|
|
|
try { content = JsonSerializer.Deserialize<ChatMessageContent>(decryptedText) ?? new ChatMessageContent { Text = decryptedText }; }
|
|
catch { content = new ChatMessageContent { Text = decryptedText }; }
|
|
|
|
return true;
|
|
}
|
|
|
|
protected override void OnDisappearing()
|
|
{
|
|
_socket.Disconnect();
|
|
base.OnDisappearing();
|
|
}
|
|
|
|
private void RenderChannelList()
|
|
{
|
|
SidebarList.Children.Clear();
|
|
|
|
var grouped = _channels
|
|
.OrderBy(c => c.CreatedAt)
|
|
.GroupBy(c => string.IsNullOrWhiteSpace(c.Group) ? "Channels" : c.Group);
|
|
|
|
foreach (var group in grouped)
|
|
{
|
|
SidebarList.Children.Add(new Label
|
|
{
|
|
Text = group.Key.ToUpper(),
|
|
FontSize = 10,
|
|
FontAttributes = FontAttributes.Bold,
|
|
TextColor = Colors.Gray,
|
|
Margin = new Thickness(0, 6, 0, 2)
|
|
});
|
|
|
|
foreach (var channel in group)
|
|
{
|
|
bool isSelected = channel.ChannelId == _currentChannelId;
|
|
|
|
var prefix = channel.Type switch
|
|
{
|
|
ChannelType.Voice => "🔊",
|
|
ChannelType.Forum => "📋",
|
|
ChannelType.Stage => "🎤",
|
|
ChannelType.File => "📁",
|
|
_ => "#"
|
|
};
|
|
|
|
var lockSuffix = channel.IsReadOnly ? " 🔒" : string.Empty;
|
|
|
|
_mentionCounts.TryGetValue(channel.ChannelId, out var mentionCount);
|
|
var pingSuffix = (mentionCount > 0 && !isSelected) ? $" 🔔{mentionCount}" : string.Empty;
|
|
|
|
var btn = new ChannelButton
|
|
{
|
|
Text = $"{prefix} {channel.Name}{lockSuffix}{pingSuffix}",
|
|
Type = channel.Type,
|
|
Group = channel.Group,
|
|
HorizontalOptions = LayoutOptions.Fill,
|
|
BackgroundColor = isSelected ? Color.FromArgb("#3A3A3A") : Colors.Transparent,
|
|
FontAttributes = (isSelected || mentionCount > 0) ? FontAttributes.Bold : FontAttributes.None
|
|
};
|
|
|
|
btn.Clicked += (_, _) => OnChannelSelected(channel);
|
|
|
|
AttachChannelContextMenu(btn, channel);
|
|
|
|
SidebarList.Children.Add(btn);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnChannelSelected(ChannelItem channel)
|
|
{
|
|
_currentChannelId = channel.ChannelId;
|
|
_currentChannelName = channel.Name;
|
|
_currentChannelType = channel.Type;
|
|
|
|
_mentionCounts.Remove(channel.ChannelId);
|
|
|
|
ClearTypingIndicator();
|
|
CancelContext();
|
|
|
|
ChannelLabel.Text = $"#{_currentChannelName}";
|
|
|
|
MainThread.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
await _rtc.PushRtcContextToJsAsync();
|
|
|
|
if (channel.Type == ChannelType.Voice)
|
|
{
|
|
MessagesView.IsVisible = false;
|
|
RtcView.IsVisible = true;
|
|
InputArea.IsVisible = false;
|
|
_ = _rtc.JoinRtcChannel();
|
|
}
|
|
else
|
|
{
|
|
if (RtcView.IsVisible) _rtc.LeaveRtcChannel();
|
|
|
|
RtcView.IsVisible = false;
|
|
MessagesView.IsVisible = true;
|
|
InputArea.IsVisible = true;
|
|
|
|
UpdateInputForCurrentChannel();
|
|
RenderCurrentChannelMessages();
|
|
|
|
if (!_messagesByChannel.ContainsKey(channel.ChannelId))
|
|
_socket.SendGetHistory(channel.ChannelId);
|
|
}
|
|
|
|
RenderChannelList();
|
|
});
|
|
}
|
|
|
|
private void UpdateInputForCurrentChannel()
|
|
{
|
|
var channel = _channels.FirstOrDefault(c => c.ChannelId == _currentChannelId);
|
|
if (channel is null) return;
|
|
|
|
bool canPost = channel.CanPost;
|
|
MessageEntry.IsEnabled = canPost;
|
|
SendButton.IsEnabled = canPost;
|
|
MessageEntry.Placeholder = canPost
|
|
? "Type a message… (Shift+Enter for newline)"
|
|
: "This channel is read-only — you don't have permission to post here.";
|
|
}
|
|
|
|
private void ClearTypingIndicator()
|
|
{
|
|
foreach (var cts in _typingClearTimers.Values) cts.Cancel();
|
|
_typingClearTimers.Clear();
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
TypingLabel.IsVisible = false;
|
|
TypingLabel.Text = string.Empty;
|
|
});
|
|
}
|
|
|
|
private void RenderCurrentChannelMessages()
|
|
{
|
|
MessagesLayout.Children.Clear();
|
|
if (_currentChannelId is null) return;
|
|
if (!_messagesByChannel.TryGetValue(_currentChannelId, out var messages)) return;
|
|
foreach (var m in messages.OrderBy(m => m.Timestamp))
|
|
RenderSingleMessage(m);
|
|
}
|
|
|
|
private void SwapView_OnClicked(object? sender, EventArgs e) { }
|
|
|
|
private async void RenderSingleMessage(ChatMessage message)
|
|
{
|
|
bool isOwn = message.SenderUsername.Equals(_username, StringComparison.OrdinalIgnoreCase);
|
|
|
|
bool mentionsMe = MessageMentionsMe(message);
|
|
|
|
var bubble = new Border
|
|
{
|
|
StrokeThickness = mentionsMe ? 2 : 1,
|
|
Stroke = mentionsMe ? new SolidColorBrush(Color.FromArgb("#9EA8FF")) : null,
|
|
Padding = new Thickness(10),
|
|
Margin = isOwn ? new Thickness(40, 0, 0, 0) : new Thickness(0, 0, 40, 0),
|
|
HorizontalOptions = isOwn ? LayoutOptions.End : LayoutOptions.Start,
|
|
Content = BuildBubbleContent(message)
|
|
};
|
|
|
|
AttachMessageContextMenu(bubble, message);
|
|
|
|
if (!string.IsNullOrWhiteSpace(message.MessageId))
|
|
_messageBubbles[message.MessageId] = bubble;
|
|
|
|
MessagesLayout.Children.Add(bubble);
|
|
await MessagesScrollView.ScrollToAsync(MessagesLayout, ScrollToPosition.End, animated: true);
|
|
}
|
|
|
|
private void RebuildBubbleContent(Border bubble, ChatMessage message)
|
|
{
|
|
bubble.Content = BuildBubbleContent(message);
|
|
}
|
|
|
|
private View BuildBubbleContent(ChatMessage message)
|
|
{
|
|
if (message.IsDeleted)
|
|
{
|
|
return new Label
|
|
{
|
|
Text = "🗑 This message was deleted.",
|
|
FontAttributes = FontAttributes.Italic,
|
|
TextColor = Colors.Gray,
|
|
FontSize = 13
|
|
};
|
|
}
|
|
|
|
var stack = new VerticalStackLayout { Spacing = 4 };
|
|
|
|
if (message.ReplyToId is not null && message.ReplyPreview is not null)
|
|
{
|
|
var quoteTap = new TapGestureRecognizer();
|
|
quoteTap.Tapped += (_, _) => ScrollToMessage(message.ReplyToId);
|
|
|
|
var quote = new Border
|
|
{
|
|
StrokeThickness = 0,
|
|
BackgroundColor = Color.FromArgb("#333333"),
|
|
Padding = new Thickness(8, 4),
|
|
Margin = new Thickness(0, 0, 0, 2),
|
|
Content = new VerticalStackLayout
|
|
{
|
|
Spacing = 2,
|
|
Children =
|
|
{
|
|
new Label
|
|
{
|
|
Text = $"↩ {message.ReplyToSenderUsername}",
|
|
FontSize = 11,
|
|
FontAttributes = FontAttributes.Bold,
|
|
TextColor = Color.FromArgb("#9ECEFF")
|
|
},
|
|
new Label
|
|
{
|
|
Text = message.ReplyPreview,
|
|
FontSize = 12,
|
|
TextColor = Colors.LightGray,
|
|
LineBreakMode = LineBreakMode.TailTruncation,
|
|
MaxLines = 2
|
|
}
|
|
}
|
|
}
|
|
};
|
|
quote.GestureRecognizers.Add(quoteTap);
|
|
stack.Children.Add(quote);
|
|
}
|
|
|
|
stack.Children.Add(new Label
|
|
{
|
|
Text = message.SenderUsername,
|
|
FontAttributes = FontAttributes.Bold,
|
|
FontSize = 12
|
|
});
|
|
|
|
if (!string.IsNullOrWhiteSpace(message.Text))
|
|
stack.Children.Add(MarkdownHelper.Render(message.Text));
|
|
|
|
if (!string.IsNullOrWhiteSpace(message.AttachmentBase64))
|
|
{
|
|
bool isImage = message.AttachmentMimeType?.StartsWith("image/") == true;
|
|
stack.Children.Add(isImage
|
|
? EmbedHelper.BuildBase64ImageEmbed(message.AttachmentBase64, message.AttachmentFileName ?? "image")
|
|
: EmbedHelper.BuildFileCard(message.AttachmentBase64, message.AttachmentFileName ?? "file", message.AttachmentMimeType ?? "application/octet-stream"));
|
|
}
|
|
|
|
foreach (var embed in EmbedHelper.BuildEmbeds(message.Text))
|
|
{
|
|
WireJumpLinks(embed);
|
|
stack.Children.Add(embed);
|
|
}
|
|
|
|
var footer = new HorizontalStackLayout { Spacing = 6 };
|
|
footer.Children.Add(new Label
|
|
{
|
|
Text = message.Timestamp > DateTime.MinValue ? message.Timestamp.ToString("h:mm tt") : string.Empty,
|
|
FontSize = 10,
|
|
TextColor = Colors.Gray
|
|
});
|
|
|
|
if (message.IsEdited)
|
|
{
|
|
var editedLabel = new Label
|
|
{
|
|
Text = "(edited)",
|
|
FontSize = 10,
|
|
FontAttributes = FontAttributes.Italic,
|
|
TextColor = Colors.Gray,
|
|
TextDecorations = TextDecorations.Underline
|
|
};
|
|
var editedTap = new TapGestureRecognizer();
|
|
editedTap.Tapped += (_, _) => RequestEditHistory(message);
|
|
editedLabel.GestureRecognizers.Add(editedTap);
|
|
footer.Children.Add(editedLabel);
|
|
}
|
|
|
|
stack.Children.Add(footer);
|
|
return stack;
|
|
}
|
|
|
|
private void WireJumpLinks(View view)
|
|
{
|
|
if (view is Label lbl)
|
|
{
|
|
var jumpUrl = (string?)lbl.GetValue(EmbedHelper.JumpUrlProperty);
|
|
if (!string.IsNullOrWhiteSpace(jumpUrl))
|
|
{
|
|
var m = Regex.Match(jumpUrl, @"relay://jump/[^/]+/(.+)");
|
|
if (m.Success)
|
|
{
|
|
var msgId = m.Groups[1].Value;
|
|
var tap = new TapGestureRecognizer();
|
|
tap.Tapped += (_, _) => ScrollToMessage(msgId);
|
|
lbl.GestureRecognizers.Clear();
|
|
lbl.GestureRecognizers.Add(tap);
|
|
}
|
|
}
|
|
}
|
|
else if (view is Layout layout)
|
|
{
|
|
foreach (var child in layout.Children.OfType<View>())
|
|
WireJumpLinks(child);
|
|
}
|
|
else if (view is Border border && border.Content is View borderContent)
|
|
{
|
|
WireJumpLinks(borderContent);
|
|
}
|
|
}
|
|
|
|
private void ScrollToMessage(string messageId)
|
|
{
|
|
if (!_messageBubbles.TryGetValue(messageId, out var bubble)) return;
|
|
MainThread.BeginInvokeOnMainThread(async () =>
|
|
await MessagesScrollView.ScrollToAsync(bubble, ScrollToPosition.Start, animated: true));
|
|
}
|
|
|
|
private void RequestEditHistory(ChatMessage message)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(message.MessageId)) return;
|
|
_socket.SendGetEditHistory(message.MessageId, _currentChannelId ?? string.Empty);
|
|
}
|
|
|
|
private async void OnHybridWebViewRawMessageReceived(object sender, HybridWebViewRawMessageReceivedEventArgs e)
|
|
{
|
|
if (e.Message == "rtc_page_ready")
|
|
{
|
|
await _rtc.PushRtcContextToJsAsync();
|
|
return;
|
|
}
|
|
SafeSendRawToWebView($"JS → C#: {e.Message}");
|
|
}
|
|
|
|
private void SafeSendRawToWebView(string message)
|
|
{
|
|
MainThread.BeginInvokeOnMainThread(() =>
|
|
{
|
|
try { hybridWebView.SendRawMessage(message); }
|
|
catch (Exception ex) { Console.WriteLine($"[{_username}] WebView send failed: {ex.Message}"); }
|
|
});
|
|
}
|
|
|
|
public class ChatMessage
|
|
{
|
|
public string MessageId { get; set; } = string.Empty;
|
|
public string SenderUsername { get; set; } = string.Empty;
|
|
public string Text { get; set; } = string.Empty;
|
|
public DateTime Timestamp { get; set; }
|
|
public string? ReplyToId { get; set; }
|
|
public string? ReplyToSenderUsername { get; set; }
|
|
public string? ReplyPreview { get; set; }
|
|
public List<string>? Mentions { get; set; }
|
|
public string? AttachmentBase64 { get; set; }
|
|
public string? AttachmentMimeType { get; set; }
|
|
public string? AttachmentFileName { get; set; }
|
|
public bool IsEdited { get; set; }
|
|
public bool IsDeleted { get; set; }
|
|
}
|
|
|
|
public class ChannelButton : Button
|
|
{
|
|
public ChannelType Type { get; set; }
|
|
public string Group { get; set; } = string.Empty;
|
|
}
|
|
|
|
[JsonSourceGenerationOptions(WriteIndented = false)]
|
|
[JsonSerializable(typeof(RtcDescription))]
|
|
[JsonSerializable(typeof(List<RtcSignalMessage>))]
|
|
[JsonSerializable(typeof(IceCandidate))]
|
|
[JsonSerializable(typeof(List<IceCandidate>))]
|
|
[JsonSerializable(typeof(string))]
|
|
internal partial class HybridJSType : JsonSerializerContext { }
|
|
}
|