Encryption Sent, Encrpytion Decoded, Offer Sent, Offer Recieved, JS -> C# / C# -> JS Broke (some disconnect here) SendRtcSignalToJsAsync

RelayClient/MainPage.xaml.cs

@@ -189,6 +189,20 @@ public partial class MainPage : ContentPage
                     },
                     privateKey
                 );
+                
+                var rtcSignal = JsonSerializer.Deserialize<RtcSignalMessage>(decryptedJson);
+
+                if (rtcSignal is null)
+                    return;
+
+                if (!string.IsNullOrWhiteSpace(rtcSignal.To) &&
+                    !string.Equals(rtcSignal.To, _username, StringComparison.OrdinalIgnoreCase))
+                {
+                    SafeSendRawToWebView($"Ignoring RTC signal meant for {rtcSignal.To}");
+                    return;
+                }
+
+                SafeSendRawToWebView("Received encrypted RTC signal: " + decryptedJson);
 
                 MainThread.BeginInvokeOnMainThread(async () =>
                 {
@@ -438,20 +452,20 @@ public partial class MainPage : ContentPage
     }
 
     #region RTC Functions
-    public async Task<bool> JoinRtcChannel()
+    public async Task JoinRtcChannel()
     {
         if (string.IsNullOrWhiteSpace(_currentChannelId))
-            return false;
+            return; //false;
 
         _wsc.Send($"RTC_JOIN_CHANNEL|{_username}|{_currentChannelId}");
 
         // SafeSendRawToWebView($"Attempting to join RTC Channel {_currentChannelName} | {_currentChannelId} ");
 
-        bool active = await ServerAPI.GetIsChannelActiveAsync(_currentChannelId);
+        //bool active = await ServerAPI.GetIsChannelActiveAsync(_currentChannelId);
 
-        SafeSendRawToWebView($"Rtc Channel {_currentChannelName} | {_currentChannelId} is active: {active}");
+        //SafeSendRawToWebView($"Rtc Channel {_currentChannelName} | {_currentChannelId} is active: {active}");
 
-        return active;
+        return; //active;
     }
     
     public void LeaveRtcChannel()
@@ -566,10 +580,36 @@ public partial class MainPage : ContentPage
         }
     }
     
-    private async Task SendRtcSignalToJsAsync(string rawJson)
+    private Task SendRtcSignalToJsAsync(string rawJson)
     {
-        var jsArg = JsonSerializer.Serialize(rawJson);
-        await hybridWebView.EvaluateJavaScriptAsync($"window.handleRtcSignal({jsArg})");
+        MainThread.BeginInvokeOnMainThread(async () =>
+        {
+            try
+            {
+                SafeSendRawToWebView("Dispatching RTC signal to JS");
+
+                var jsArg = JsonSerializer.Serialize(rawJson);
+
+                await hybridWebView.EvaluateJavaScriptAsync($@"
+                window.HybridWebView.SendRawMessage('JS dispatch wrapper hit');
+                const fn = window.handleRtcSignal || window.dispatchRtcSignal;
+                if (!fn) {{
+                    window.HybridWebView.SendRawMessage('No RTC signal handler found on window');
+                }} else {{
+                    window.HybridWebView.SendRawMessage('Calling RTC signal handler');
+                    fn({jsArg});
+                }}
+            ");
+
+                SafeSendRawToWebView("RTC signal dispatched to JS");
+            }
+            catch (Exception ex)
+            {
+                SafeSendRawToWebView("SendRtcSignalToJsAsync failed: " + ex.Message);
+            }
+        });
+
+        return Task.CompletedTask;
     } //Remove?
     
     private async Task PushRtcContextToJsAsync()
@@ -585,41 +625,63 @@ public partial class MainPage : ContentPage
     
     public void SendRtcSignal(string json)
     {
+        SafeSendRawToWebView("SendRtcSignal entered: " + json);
+
         if (string.IsNullOrWhiteSpace(_serverPublicKey))
         {
-            Console.WriteLine("Server public key not loaded yet.");
+            SafeSendRawToWebView("SendRtcSignal failed: server public key not loaded.");
             return;
         }
 
         RtcSignalMessage? rtcSignal;
+
         try
         {
             rtcSignal = JsonSerializer.Deserialize<RtcSignalMessage>(json);
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Failed to parse RTC signal from JS: {ex.Message}");
+            SafeSendRawToWebView("SendRtcSignal failed to parse RTC signal: " + ex.Message);
             return;
         }
 
         if (rtcSignal is null)
-            return;
-
-        var encrypted = E2EeHelper.EncryptForRecipient(json, _serverPublicKey);
-
-        var payload = new SocketRtcSignalMessage
         {
-            Type = SignalType.EncryptedSignal,
-            SenderUsername = _username,
-            ChannelId = rtcSignal.ChannelId,
-            CipherText = encrypted.CipherText,
-            Nonce = encrypted.Nonce,
-            Tag = encrypted.Tag,
-            EncryptedKey = encrypted.EncryptedKey
-        };
+            SafeSendRawToWebView("SendRtcSignal failed: rtcSignal was null.");
+            return;
+        }
 
-        _wsc.Send(JsonSerializer.Serialize(payload));
-        Console.WriteLine($"[{_username}] sent RTC signal: {rtcSignal.Type} -> {rtcSignal.ChannelId}");
+        if (string.IsNullOrWhiteSpace(rtcSignal.ChannelId))
+        {
+            SafeSendRawToWebView("SendRtcSignal failed: channelId was empty.");
+            return;
+        }
+
+        try
+        {
+            var encrypted = E2EeHelper.EncryptForRecipient(json, _serverPublicKey);
+
+            var payload = new SocketRtcSignalMessage
+            {
+                Type = SignalType.EncryptedSignal,
+                SenderUsername = _username,
+                ChannelId = rtcSignal.ChannelId,
+                CipherText = encrypted.CipherText,
+                Nonce = encrypted.Nonce,
+                Tag = encrypted.Tag,
+                EncryptedKey = encrypted.EncryptedKey
+            };
+
+            var socketJson = JsonSerializer.Serialize(payload);
+            _wsc.Send(socketJson);
+
+            SafeSendRawToWebView($"SendRtcSignal sent: {rtcSignal.Type} -> {rtcSignal.ChannelId}");
+            Console.WriteLine($"[{_username}] sent RTC signal: {rtcSignal.Type} -> {rtcSignal.ChannelId}");
+        }
+        catch (Exception ex)
+        {
+            SafeSendRawToWebView("SendRtcSignal websocket/encrypt failed: " + ex.Message);
+        }
     } //Remove?
     
     public async Task<string> GetRtcParticipants()

RelayClient/Resources/Raw/wwwroot/index.js

@@ -164,58 +164,43 @@ async function joinChannelCall() {
     LogMessage("Current username: " + currentUsername);
     LogMessage("Current channel: " + currentChannelId);
 
-    const isActive = await window.HybridWebView.InvokeDotNet("JoinRtcChannel");
-    const peerConnection = await ensurePeerConnectionForUser(currentUsername);
+    await window.HybridWebView.InvokeDotNet("JoinRtcChannel");
     await ensureLocalMedia();
 
-    if (isActive) {
-        
-        const rawJson = await window.HybridWebView.InvokeDotNet("GetRtcOffer");
-        const offer = typeof rawJson === "string" ? JSON.parse(rawJson) : rawJson;
-        await peerConnection.setRemoteDescription(offer);
-        const answer = await peerConnection.createAnswer();
-        await peerConnection.setRemoteDescription(answer);
-        await window.HybridWebView.InvokeDotNet("WriteRtcAnswer", [JSON.stringify(answer)])
+    const rawParticipants = await window.HybridWebView.InvokeDotNet("GetRtcParticipants");
+    const participants = typeof rawParticipants === "string"
+        ? JSON.parse(rawParticipants)
+        : rawParticipants;
 
-        const rawParticipants = await window.HybridWebView.InvokeDotNet("GetRtcParticipants");
-        const participants = typeof rawParticipants === "string" ? JSON.parse(rawParticipants) : rawParticipants;
+    LogMessage("Participants: " + JSON.stringify(participants));
 
-        LogMessage("Participants: " + JSON.stringify(participants)); // TODO: Remove
+    const otherUsers = participants.filter(username => username !== currentUsername);
 
-        for (const username of participants) {
-            if (username === currentUsername) continue;
-
-            const pc = await ensurePeerConnectionForUser(username);
-
-            const offer = await pc.createOffer();
-            await pc.setLocalDescription(offer);
-
-            const payload = {
-                type: "rtc_offer",
-                from: currentUsername,
-                to: username,
-                channelId: currentChannelId,
-                sdp: offer.sdp
-            };
-
-            await window.HybridWebView.InvokeDotNet("SendRtcSignal", [JSON.stringify(payload)]);
-            LogMessage(`Sent offer to ${username}`);
-        }
+    if (otherUsers.length === 0) {
+        LogMessage("Joined call as first participant. Waiting for others...");
+        return;
     }
-    else
-    {
-        try {
-            LogMessage(currentUsername + " attempted to join inactive channel. Making new call.")
-            const offer = await peerConnection.createOffer();
-            await peerConnection.setLocalDescription(offer);
-            await window.HybridWebView.InvokeDotNet("WriteRtcOffer", [JSON.stringify(offer)]);
-            LogMessage(`Joining call with media offer: ${JSON.stringify(offer)}`);
-        }
-        catch (error) {
-            LogMessage(error)
-        }
+
+    for (const username of otherUsers) {
+        const pc = await ensurePeerConnectionForUser(username);
+
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+
+        const payload = {
+            type: "rtc_offer",
+            from: currentUsername,
+            to: username,
+            channelId: currentChannelId,
+            sdp: offer.sdp,
+            isInitiator: true
+        };
+
+        await window.HybridWebView.InvokeDotNet("SendRtcSignal", [JSON.stringify(payload)]);
+        LogMessage(`Sent offer to ${username}`);
     }
 }
+
 async function channelCallJoin(activeCall)
 {
     // LogMessage("Active call: " + activeCall);        
@@ -337,6 +322,11 @@ async function handleRtcSignal(rawJson) {
 
         if (!msg.from || msg.from === currentUsername) return;
 
+        if (msg.to && msg.to !== currentUsername) {
+            LogMessage(`Ignoring signal meant for ${msg.to}`);
+            return;
+        }
+
         const pc = await ensurePeerConnectionForUser(msg.from);
 
         if (msg.type === "rtc_offer") {
@@ -390,6 +380,8 @@ async function handleRtcSignal(rawJson) {
     }
 }
 
+window.handleRtcSignal = handleRtcSignal;
+
 async function loadDevices() {
     try {
         const devices = await navigator.mediaDevices.enumerateDevices();
@@ -510,8 +502,6 @@ function removeRemoteTile(username) {
     }
 }
 
-window.handleRtcSignal = handleRtcSignal;
-
 window.addEventListener("HybridWebViewMessageReceived", function (e) {
     LogMessage("Raw message: " + e.detail.message);
 });