Add managed UIKit iOS client

2026-09-19 15:43:37 +02:00
parent d0a72176ba
commit c6715028c1
41 changed files with 1110 additions and 40 deletions
@@ -0,0 +1,175 @@
+using UIKit;
+using VoiceCat.Audio;
+using VoiceCat.Core;
+using Voicecat.V1;
+using Channel = Voicecat.V1.Channel;
+
+namespace VoiceCat.iOS;
+
+internal sealed record ChatEntry(DateTime Timestamp, string Sender, string Text, bool Private);
+
+internal sealed class AppModel
+{
+    internal static AppModel Shared { get; } = new();
+    private readonly IosStorage storage = new();
+    private readonly List<ServerProfile> profiles = [];
+    private readonly List<ChatEntry> messages = [];
+    private CancellationTokenSource? lifetime;
+    private VoiceCatClient? client;
+    private TaskCompletionSource<bool>? identityDecision;
+    private ServerProfile? connectedProfile;
+    private int reconnectAttempt;
+    private bool explicitDisconnect;
+    private uint microphoneStream;
+    private BroadcastAudioPump? broadcast;
+
+    internal event Action? Changed;
+    internal event Action<ServerIdentityChallenge>? IdentityRequested;
+    internal IReadOnlyList<ServerProfile> Profiles => profiles;
+    internal IReadOnlyList<ChatEntry> Messages => messages;
+    internal VoiceCatClient? Client => client;
+    internal bool IsConnected => client?.State == ClientConnectionState.Connected;
+    internal bool IsConnecting { get; private set; }
+    internal bool VoiceJoined => microphoneStream != 0;
+    internal string Status { get; private set; } = "Not connected";
+    internal uint CurrentChannelId { get; private set; }
+    internal uint SelfUserId => client?.Authentication?.Self.Id ?? 0;
+    internal IReadOnlyList<Channel> Channels => client?.Channels ?? [];
+    internal IReadOnlyList<User> Users => client?.Users ?? [];
+
+    private AppModel() { }
+    internal void Load() { profiles.Clear(); profiles.AddRange(storage.LoadProfiles()); Notify(); }
+    internal void Save() => storage.SaveProfiles(profiles);
+
+    internal void UpsertProfile(ServerProfile profile, string? password)
+    {
+        int index = profiles.FindIndex(item => item.Id == profile.Id);
+        if (index < 0) profiles.Add(profile); else profiles[index] = profile;
+        if (!string.IsNullOrEmpty(password)) storage.SavePassword(profile.Id, password);
+        Save(); Notify();
+    }
+
+    internal void RemoveProfile(ServerProfile profile)
+    {
+        storage.RemovePassword(profile.Id); profiles.RemoveAll(item => item.Id == profile.Id); Save(); Notify();
+    }
+
+    internal async Task ConnectAsync(ServerProfile profile, string? suppliedPassword = null, bool restoring = false)
+    {
+        if (IsConnecting || IsConnected) return;
+        explicitDisconnect = false; IsConnecting = true; connectedProfile = profile;
+        Status = restoring ? "Reconnecting…" : "Connecting…"; Notify();
+        lifetime?.Cancel(); lifetime?.Dispose(); lifetime = new();
+        VoiceCatClient next = new("VoiceCat-iOS", "0.0.1", storage.TofuPath);
+        client = next;
+        try
+        {
+            await next.ConnectAsync(profile.Host, profile.Port, ConfirmIdentityAsync, lifetime.Token);
+            AuthResult auth = profile.Authentication == ServerAuthentication.Guest
+                ? await next.AuthenticateGuestAsync(profile.Nickname ?? "iOS User", lifetime.Token)
+                : await next.AuthenticateUserAsync(profile.Username!, suppliedPassword ?? storage.LoadPassword(profile) ?? "", lifetime.Token);
+            if (!auth.Ok) throw new InvalidOperationException(auth.Error);
+            CurrentChannelId = auth.Self.ChannelId; reconnectAttempt = 0; IsConnecting = false; Status = "Connected";
+            IosAudioEngine.Shared.StartListening(next);
+            broadcast = new(); broadcast.Start(next);
+            _ = PumpEventsAsync(next, lifetime.Token);
+            Notify();
+        }
+        catch (Exception exception)
+        {
+            IsConnecting = false; Status = exception.Message; Notify();
+            await next.DisposeAsync(); if (ReferenceEquals(client, next)) client = null;
+            if (restoring && !explicitDisconnect) ScheduleReconnect();
+            else throw;
+        }
+    }
+
+    private ValueTask<bool> ConfirmIdentityAsync(ServerIdentityChallenge challenge, CancellationToken token)
+    {
+        identityDecision = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        token.Register(() => identityDecision.TrySetCanceled(token));
+        UIApplication.SharedApplication.BeginInvokeOnMainThread(() => IdentityRequested?.Invoke(challenge));
+        return new(identityDecision.Task);
+    }
+
+    internal void ResolveIdentity(bool accepted) { identityDecision?.TrySetResult(accepted); identityDecision = null; }
+
+    private async Task PumpEventsAsync(VoiceCatClient owner, CancellationToken token)
+    {
+        try
+        {
+            await foreach (Envelope envelope in owner.ReadEventsAsync(token))
+            {
+                if (envelope.JoinChannelResult?.Ok == true) CurrentChannelId = envelope.JoinChannelResult.ChannelId;
+                if (envelope.TextMessage is { } text)
+                {
+                    User? sender = owner.Users.FirstOrDefault(user => user.Id == text.SenderId);
+                    messages.Add(new(DateTime.Now, sender?.Nickname ?? $"User {text.SenderId}", text.Body, text.Scope == TextScope.TextPrivate));
+                    if (messages.Count > 500) messages.RemoveAt(0);
+                }
+                UIApplication.SharedApplication.BeginInvokeOnMainThread(Notify);
+            }
+        }
+        catch (OperationCanceledException) { }
+        finally
+        {
+            if (ReferenceEquals(client, owner) && !explicitDisconnect)
+            {
+                IosAudioEngine.Shared.Stop(); client = null; Status = "Connection lost"; UIApplication.SharedApplication.BeginInvokeOnMainThread(Notify);
+                ScheduleReconnect();
+            }
+        }
+    }
+
+    internal async Task JoinChannelAsync(uint channelId, string password = "")
+    {
+        VoiceCatClient active = client ?? throw new InvalidOperationException("Not connected.");
+        Envelope response = await active.RequestAsync(new() { JoinChannel = new() { ChannelId = channelId, Password = password } });
+        if (response.JoinChannelResult?.Ok != true) throw new InvalidOperationException(response.JoinChannelResult?.Error ?? "Join failed.");
+        CurrentChannelId = channelId; Notify();
+    }
+
+    internal void SendText(string body, uint targetUser = 0)
+    {
+        if (string.IsNullOrWhiteSpace(body)) return;
+        (client ?? throw new InvalidOperationException("Not connected.")).Send(new()
+        {
+            TextMessage = new() { Scope = targetUser == 0 ? TextScope.TextChannel : TextScope.TextPrivate,
+                TargetId = targetUser == 0 ? CurrentChannelId : targetUser, Body = body.Trim(), ClientMsgId = Guid.NewGuid().ToString("N") }
+        });
+    }
+
+    internal async Task ToggleVoiceAsync()
+    {
+        VoiceCatClient active = client ?? throw new InvalidOperationException("Not connected.");
+        if (microphoneStream != 0)
+        {
+            IosAudioEngine.Shared.StopMicrophone(); active.StopStream(microphoneStream); microphoneStream = 0;
+            await active.SubscribeVoiceAsync(false); Notify(); return;
+        }
+        if (AVFoundation.AVCaptureDevice.GetAuthorizationStatus(AVFoundation.AVAuthorizationMediaType.Audio) == AVFoundation.AVAuthorizationStatus.NotDetermined)
+            await AVFoundation.AVCaptureDevice.RequestAccessForMediaTypeAsync(AVFoundation.AVAuthorizationMediaType.Audio);
+        VoiceSubscriptionResult subscribed = await active.SubscribeVoiceAsync();
+        if (!subscribed.Ok) throw new InvalidOperationException(subscribed.Error);
+        int channels = IosAudioRouter.Shared.CaptureChannels;
+        StreamInfo stream = await active.StartStreamAsync(StreamKind.StreamMic, "Microphone", channels);
+        microphoneStream = stream.StreamId; IosAudioEngine.Shared.StartMicrophone(stream.StreamId, channels); Notify();
+    }
+
+    internal async Task DisconnectAsync()
+    {
+        explicitDisconnect = true; lifetime?.Cancel(); IosAudioEngine.Shared.Stop();
+        if (broadcast is { } pump) { broadcast = null; await pump.DisposeAsync(); }
+        VoiceCatClient? old = client; client = null; microphoneStream = 0; IsConnecting = false; Status = "Not connected"; Notify();
+        if (old is not null) await old.DisposeAsync();
+    }
+
+    private void ScheduleReconnect()
+    {
+        ServerProfile? profile = connectedProfile; if (profile is null || explicitDisconnect) return;
+        int delay = Math.Min(1 << Math.Min(reconnectAttempt++, 5), 30);
+        _ = Task.Run(async () => { try { await Task.Delay(TimeSpan.FromSeconds(delay), lifetime?.Token ?? default); await ConnectAsync(profile, restoring: true); } catch { } });
+    }
+
+    private void Notify() => Changed?.Invoke();
+}