Talon
0dad40c9d7
A Wi-Fi to cellular switch left the session visibly dropping: the media transport rebound itself within a few seconds, but nothing noticed the blackholed control connection until an unanswered keepalive proved it, and the teardown that followed announced a lost connection and waited another second before dialling again. Watch the system path on iOS and fail the control connection the moment the carrying interface changes, which is the only path change TCP cannot survive. Roaming between access points and a link that is merely unusable for a while keep the same interface and the same source address, so ControlPathWatcher reports neither; an unsatisfied path holds the last signature rather than reporting, so a reconnect is never started into a route that cannot carry it. Tighten the keepalive window on the phone as the backstop for what the monitor cannot see, run the first reconnect attempt immediately, and defer the lost-connection announcement until an attempt has actually failed, so a sub-second handover is silent and only a real outage is announced. A control reconnect still re-authenticates and rejoins: the media keys come from the TLS exporter of the connection that was lost, so seamless handover needs control-plane session resumption rather than a faster reconnect.
428 lines
23 KiB
C#
428 lines
23 KiB
C#
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, uint SenderId, uint PeerUserId, string Sender, string Peer, string Text, bool Private);
|
|
internal sealed record ActivityEntry(DateTime Timestamp, string Text);
|
|
|
|
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 readonly List<ActivityEntry> activity = [];
|
|
private readonly IosSettings settings = new();
|
|
private readonly EventFeedback feedback;
|
|
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;
|
|
private Timer? levelTimer;
|
|
private bool lastTalking;
|
|
private bool restoringVoice;
|
|
private uint restoreChannel;
|
|
private bool restoreMuted;
|
|
private bool restoreDeafened;
|
|
private bool backgrounded;
|
|
private int diagnosticPolls;
|
|
private bool announcedConnectionLoss;
|
|
private bool handingOver;
|
|
|
|
internal event Action? Changed;
|
|
// Raised by the 20 Hz level timer only. Subscribers must be cheap and must not reload a list.
|
|
internal event Action? LevelChanged;
|
|
internal event Action<ServerIdentityChallenge>? IdentityRequested;
|
|
internal IReadOnlyList<ServerProfile> Profiles => profiles;
|
|
internal IReadOnlyList<ChatEntry> Messages => messages;
|
|
internal IReadOnlyList<ActivityEntry> Activity => activity;
|
|
internal IosSettings Settings => settings;
|
|
internal VoiceCatClient? Client => client;
|
|
internal bool IsConnected => client?.State == ClientConnectionState.Connected;
|
|
internal bool SupportsAdaptivePacketLoss => client?.SupportsAdaptivePacketLoss == true;
|
|
internal bool IsConnecting { get; private set; }
|
|
internal bool VoiceJoined => microphoneStream != 0;
|
|
internal bool ScreenSharing => broadcast?.IsActive == true;
|
|
internal bool IsBackgrounded => backgrounded;
|
|
internal float MicrophoneLevel { get; private set; }
|
|
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() { feedback = new(settings); IosNetworkPathMonitor.Shared.InterfaceChanged += OnInterfaceChanged; }
|
|
internal void Load() { profiles.Clear(); profiles.AddRange(storage.LoadProfiles()); settings.Load(); IosAudioRouter.Shared.Load(); IosNetworkPathMonitor.Shared.Start(); Notify(); }
|
|
|
|
// A changed interface has already stranded the control socket on a source address that is
|
|
// gone; the media transport rebinds itself, but TCP cannot, and waiting for the keepalive to
|
|
// notice costs the user ten seconds of a session that is already dead. Fail it now so the
|
|
// reconnect runs while the audio session is still up. Raised on the monitor queue.
|
|
private void OnInterfaceChanged(string path)
|
|
{
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(() =>
|
|
{
|
|
VoiceCatClient? owner = client;
|
|
if (owner is null || explicitDisconnect || IsConnecting || owner.State != ClientConnectionState.Connected) return;
|
|
AddActivity("Network changed; reconnecting.");
|
|
handingOver = true; reconnectAttempt = 0;
|
|
owner.DropForReconnect($"The network interface changed to {path}.");
|
|
});
|
|
}
|
|
internal void Save() { storage.SaveProfiles(profiles); settings.Save(); }
|
|
|
|
internal void DidEnterBackground()
|
|
{
|
|
backgrounded = true; Save();
|
|
// Do not stop or rebuild AVAudioEngine here. With the `audio` background mode and an
|
|
// active PlayAndRecord session, capture, playback, media UDP, and screen-ring draining
|
|
// remain live while the scene is backgrounded or the device is locked.
|
|
}
|
|
|
|
internal void WillEnterForeground()
|
|
{
|
|
backgrounded = false;
|
|
IosAudioRouter.Shared.ResumeForeground();
|
|
}
|
|
|
|
internal void DidBecomeActive()
|
|
{
|
|
backgrounded = false;
|
|
IosAudioRouter.Shared.EnsureAudio("active scene");
|
|
Notify();
|
|
}
|
|
|
|
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();
|
|
// The AVAudioSourceNode render callback drives Audio.RunCycle and the 20 ms capture
|
|
// handoff; a sleep-paced audio worker stalls when iOS coalesces backgrounded wakeups and
|
|
// the call glitches after several minutes in the background.
|
|
VoiceCatClient next = new("VoiceCat-iOS", "0.0.1", storage.TofuPath, deviceClockedAudio: true);
|
|
// A phone changes path often and the OS reports a blackholed TCP connection late or never.
|
|
// The path monitor catches a real handover immediately; this is the backstop for the cases
|
|
// it cannot see, such as a NAT rebinding or an upstream route that quietly stops carrying.
|
|
next.ConfigureControlLiveness(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(12));
|
|
next.ConnectionStateChanged += state =>
|
|
{
|
|
if (state == ClientConnectionState.Disconnected && next.ConnectionFailure is { } failure)
|
|
Console.Error.WriteLine($"VoiceCat control connection failed: {failure}");
|
|
if (state == ClientConnectionState.Disconnected)
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
try { await HandleConnectionLostAsync(next); }
|
|
catch (Exception exception) { System.Diagnostics.Debug.WriteLine($"Reconnect cleanup failed: {exception}"); }
|
|
});
|
|
};
|
|
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";
|
|
ApplyAudioSettings(next);
|
|
IosAudioEngine.Shared.StartListening(next);
|
|
broadcast = new(); broadcast.Changed += BroadcastChanged; broadcast.Start(next);
|
|
_ = PumpEventsAsync(next, lifetime.Token);
|
|
levelTimer?.Dispose(); levelTimer = new(_ =>
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(PollAudio), null, 50, 50);
|
|
// A handover that recovers in under a second should read as a hiccup, not a dropped
|
|
// call: announce the return only when the loss itself was announced.
|
|
if (!restoring || announcedConnectionLoss) { feedback.Play(SoundEvent.Login); feedback.Speak(restoring ? "Reconnected" : "Connected"); }
|
|
announcedConnectionLoss = false; handingOver = false;
|
|
if (restoring && restoreChannel != 0) await RestoreSessionAsync(next);
|
|
Notify();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Connection failed: {exception}");
|
|
IsConnecting = false; Status = exception.Message;
|
|
if (ReferenceEquals(client, next)) { client = null; await StopSessionResourcesAsync(releaseAudio: !restoring); }
|
|
await next.DisposeAsync();
|
|
Notify();
|
|
if (restoring && !explicitDisconnect)
|
|
{
|
|
if (!announcedConnectionLoss)
|
|
{
|
|
announcedConnectionLoss = true; handingOver = false;
|
|
feedback.Play(SoundEvent.ConnectionLost); feedback.Speak("Connection lost, reconnecting");
|
|
}
|
|
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.JoinChannelResult is { Ok: false } joinFailure) AddActivity("Join failed: " + joinFailure.Error);
|
|
if (envelope.TextMessage is { } text)
|
|
{
|
|
User? sender = owner.Users.FirstOrDefault(user => user.Id == text.SenderId);
|
|
bool privateMessage = text.Scope == TextScope.TextPrivate;
|
|
uint peerUserId = privateMessage ? text.SenderId == SelfUserId ? text.TargetId : text.SenderId : 0;
|
|
User? peer = privateMessage ? owner.Users.FirstOrDefault(user => user.Id == peerUserId) : null;
|
|
messages.Add(new(DateTime.Now, text.SenderId, peerUserId, sender?.Nickname ?? $"User {text.SenderId}", peer?.Nickname ?? $"User {peerUserId}", text.Body, privateMessage));
|
|
if (messages.Count > 500) messages.RemoveAt(0);
|
|
bool self = text.SenderId == SelfUserId;
|
|
feedback.Play(text.Scope == TextScope.TextPrivate
|
|
? self ? SoundEvent.PrivateSent : SoundEvent.PrivateReceived
|
|
: self ? SoundEvent.ChannelSent : SoundEvent.ChannelReceived);
|
|
if (!self) feedback.Speak(text.Scope == TextScope.TextPrivate ? $"Private message from {sender?.Nickname}: {text.Body}" : $"{sender?.Nickname}: {text.Body}");
|
|
}
|
|
if (envelope.UserEvent is { } userEvent) HandleUserEvent(owner, userEvent);
|
|
if (envelope.StreamState is { } streamState) AddActivity($"{Name(owner, streamState.UserId)} {(streamState.Talking ? "started" : "stopped")} talking");
|
|
if (envelope.StreamAnnounceResult?.Ok == false) AddActivity("Stream failed: " + envelope.StreamAnnounceResult.Error);
|
|
if (envelope.GenericResult is { Ok: false } result) AddActivity("Operation failed: " + result.Message);
|
|
if (envelope.Disconnect is { } disconnected) AddActivity("Disconnected: " + disconnected.Reason);
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(Notify);
|
|
}
|
|
}
|
|
catch (OperationCanceledException) { }
|
|
finally
|
|
{
|
|
await HandleConnectionLostAsync(owner);
|
|
}
|
|
}
|
|
|
|
private async Task HandleConnectionLostAsync(VoiceCatClient owner)
|
|
{
|
|
if (!ReferenceEquals(client, owner) || IsConnecting || explicitDisconnect) return;
|
|
// A failed TLS reader changes State but leaves the event channel open until disposal.
|
|
// Handle that state change directly so a Wi-Fi transition cannot strand this session.
|
|
CaptureRestoreState(owner);
|
|
client = null; Status = "Connection lost";
|
|
try { await StopSessionResourcesAsync(releaseAudio: false); }
|
|
catch (Exception exception) { System.Diagnostics.Debug.WriteLine($"Audio cleanup failed: {exception}"); }
|
|
try { await owner.DisposeAsync(); }
|
|
catch (Exception exception) { System.Diagnostics.Debug.WriteLine($"Connection cleanup failed: {exception}"); }
|
|
// On a handover the reconnect below usually lands within a second, so stay quiet and let
|
|
// the first failed attempt be what tells the user. Any other loss is announced at once.
|
|
if (handingOver) Status = "Reconnecting…";
|
|
else { announcedConnectionLoss = true; feedback.Play(SoundEvent.ConnectionLost); feedback.Speak("Connection lost, reconnecting"); }
|
|
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); MicrophoneLevel = 0; feedback.Play(SoundEvent.VoiceOff); 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); feedback.Play(SoundEvent.VoiceOn); Notify();
|
|
}
|
|
|
|
internal void ToggleScreenAudio()
|
|
{
|
|
if (!OperatingSystem.IsIOSVersionAtLeast(27)) throw new PlatformNotSupportedException("Use the ReplayKit broadcast picker on this iOS version.");
|
|
if (ScreenSharing) { IosScreenCapture.Stop(); broadcast?.RequestStop(); }
|
|
else
|
|
{
|
|
if (!IsConnected || CurrentChannelId == 0) throw new InvalidOperationException("Connect and join a channel before sharing screen audio.");
|
|
IosScreenCapture.Present();
|
|
}
|
|
}
|
|
|
|
internal void SetSelfAudio(bool muted, bool deafened) { client?.SetSelfAudioState(muted, deafened); Notify(); }
|
|
internal void SetPushToTalk(bool active)
|
|
{
|
|
if (client is null) return; client.Audio.PushToTalk = active;
|
|
if (active) feedback.Play(SoundEvent.PushToTalk); Notify();
|
|
}
|
|
internal void ApplyVoiceSettings()
|
|
{
|
|
if (client is { } active) ApplyAudioSettings(active); settings.Save(); Notify();
|
|
}
|
|
|
|
internal async Task<GenericResult> RunAdminAsync(Func<VoiceCatClient, Task<GenericResult>> action)
|
|
{
|
|
GenericResult result = await action(client ?? throw new InvalidOperationException("Not connected."));
|
|
AddActivity(result.Ok ? (string.IsNullOrEmpty(result.Message) ? "Operation completed." : result.Message) : "Operation failed: " + result.Message);
|
|
Notify(); return result;
|
|
}
|
|
|
|
internal async Task DisconnectAsync()
|
|
{
|
|
explicitDisconnect = true; handingOver = false; announcedConnectionLoss = false;
|
|
lifetime?.Cancel(); await StopSessionResourcesAsync(releaseAudio: true);
|
|
VoiceCatClient? old = client; client = null; microphoneStream = 0; IsConnecting = false; Status = "Not connected"; Notify();
|
|
if (old is not null) await old.DisposeAsync(); feedback.Play(SoundEvent.Logout); feedback.Speak("Disconnected");
|
|
}
|
|
|
|
private void ScheduleReconnect()
|
|
{
|
|
ServerProfile? profile = connectedProfile; if (profile is null || explicitDisconnect) return;
|
|
// The first attempt runs immediately: after a handover the new path is already up, and a
|
|
// second of deliberate silence is the difference between a hiccup and a dropped call.
|
|
int delay = reconnectAttempt == 0 ? 0 : Math.Min(1 << Math.Min(reconnectAttempt, 5), 30);
|
|
reconnectAttempt++;
|
|
CancellationToken token = lifetime?.Token ?? default;
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try { await Task.Delay(TimeSpan.FromSeconds(delay), token); }
|
|
catch (OperationCanceledException) { return; }
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(async () =>
|
|
{
|
|
if (token.IsCancellationRequested || explicitDisconnect) return;
|
|
try { await ConnectAsync(profile, restoring: true); }
|
|
catch (Exception exception) { System.Diagnostics.Debug.WriteLine($"Reconnect failed: {exception}"); }
|
|
});
|
|
});
|
|
}
|
|
|
|
private void Notify() => Changed?.Invoke();
|
|
|
|
private void ApplyAudioSettings(VoiceCatClient owner)
|
|
{
|
|
owner.Audio.InputMode = settings.InputMode; owner.Audio.VadThreshold = settings.VadThreshold;
|
|
owner.Audio.InputGain = settings.InputGain; owner.Audio.OutputGain = settings.OutputGain;
|
|
owner.Audio.InputNoiseReduction = settings.InputNoiseReduction;
|
|
owner.Audio.DeviceBufferMilliseconds = settings.AudioBufferMilliseconds;
|
|
IosAudioEngine.Shared.BufferMilliseconds = settings.AudioBufferMilliseconds;
|
|
}
|
|
|
|
private void PollAudio()
|
|
{
|
|
VoiceCatClient? owner = client; uint stream = microphoneStream;
|
|
if (owner is null || owner.State != ClientConnectionState.Connected || stream == 0) return;
|
|
(float level, bool talking) = owner.Audio.GetLocalLevel(stream); MicrophoneLevel = level;
|
|
if (++diagnosticPolls >= 20)
|
|
{
|
|
diagnosticPolls = 0;
|
|
LocalAudioDiagnostics audio = owner.Audio.GetLocalDiagnostics(stream);
|
|
Console.Error.WriteLine($"VC_AUDIO {IosAudioEngine.Shared.CaptureDiagnostics()} cycles={audio.Cycles} starved={audio.StarvedCycles} " +
|
|
$"encoded={audio.EncodedPackets} packetDrops={audio.RejectedPackets} queued={audio.BufferedFrames}");
|
|
}
|
|
if (talking != lastTalking)
|
|
{
|
|
try { owner.PublishStreamState(stream, talking); }
|
|
catch (Exception exception) when (exception is IOException or InvalidOperationException or ObjectDisposedException) { return; }
|
|
lastTalking = talking; feedback.Play(talking ? SoundEvent.VoiceStart : SoundEvent.VoiceStop);
|
|
}
|
|
// Only the voice bar renders the level. Raising the general Changed event at 20 Hz made
|
|
// every list reload itself that often, which tears down VoiceOver's element tree under an
|
|
// exploring finger; keep the fast signal on its own event.
|
|
LevelChanged?.Invoke();
|
|
}
|
|
|
|
private void HandleUserEvent(VoiceCatClient owner, UserEvent value)
|
|
{
|
|
string name = value.User?.Nickname ?? Name(owner, value.LeftId);
|
|
if (value.Kind == UserEvent.Types.Kind.Joined && value.User?.ChannelId == CurrentChannelId && value.User.Id != SelfUserId)
|
|
{ AddActivity($"{name} joined"); feedback.Play(SoundEvent.ChannelJoin); feedback.Speak($"{name} joined"); }
|
|
else if (value.Kind == UserEvent.Types.Kind.Left)
|
|
{ AddActivity($"{name} left"); feedback.Play(SoundEvent.ChannelLeave); feedback.Speak($"{name} left"); }
|
|
User? self = owner.Users.FirstOrDefault(user => user.Id == SelfUserId); if (self is not null) CurrentChannelId = self.ChannelId;
|
|
}
|
|
|
|
private void AddActivity(string text) { activity.Add(new(DateTime.Now, text)); if (activity.Count > 500) activity.RemoveAt(0); }
|
|
private static string Name(VoiceCatClient owner, uint id) => owner.Users.FirstOrDefault(user => user.Id == id)?.Nickname ?? $"User {id}";
|
|
private void BroadcastChanged()
|
|
{
|
|
UIApplication.SharedApplication.BeginInvokeOnMainThread(() =>
|
|
{
|
|
// Presenting either system picker can replace or interrupt the app's audio session.
|
|
// Rebuild after the producer becomes active so playback and an existing mic tap are
|
|
// attached to the session that will remain in use for the broadcast.
|
|
if (ScreenSharing) IosAudioRouter.Shared.Recover("screen sharing started");
|
|
Notify();
|
|
});
|
|
}
|
|
|
|
private void CaptureRestoreState(VoiceCatClient owner)
|
|
{
|
|
restoreChannel = CurrentChannelId; restoringVoice = microphoneStream != 0;
|
|
restoreMuted = owner.Audio.MicMuted; restoreDeafened = owner.Audio.Deafened;
|
|
}
|
|
|
|
private async Task RestoreSessionAsync(VoiceCatClient owner)
|
|
{
|
|
Envelope joined = await owner.RequestAsync(new() { JoinChannel = new() { ChannelId = restoreChannel } });
|
|
if (joined.JoinChannelResult?.Ok != true) { AddActivity("Could not restore the previous channel."); return; }
|
|
CurrentChannelId = restoreChannel;
|
|
if (restoringVoice) await ToggleVoiceAsync();
|
|
owner.SetSelfAudioState(restoreMuted, restoreDeafened); AddActivity($"Restored to channel {restoreChannel}{(restoringVoice ? " with voice" : "")}");
|
|
}
|
|
|
|
// `releaseAudio` distinguishes an ended session from an interrupted one. Ending releases the
|
|
// AVAudioSession, which on Bluetooth drops the HFP link and costs seconds of renegotiation on
|
|
// the way back; a lost connection is a transport event that changed nothing about the audio
|
|
// configuration, so it only unbinds the client and leaves the live route in place.
|
|
private async Task StopSessionResourcesAsync(bool releaseAudio)
|
|
{
|
|
levelTimer?.Dispose(); levelTimer = null;
|
|
if (releaseAudio) IosAudioEngine.Shared.Stop(); else IosAudioEngine.Shared.Detach();
|
|
microphoneStream = 0; MicrophoneLevel = 0; lastTalking = false;
|
|
if (broadcast is { } pump) { broadcast = null; pump.Changed -= BroadcastChanged; await pump.DisposeAsync(); }
|
|
}
|
|
}
|