X-Git-Url: https://git.r.bdr.sh/rbdr/junction/blobdiff_plain/4757c4616d5d7106cd023f06e5e5ba04d01bbb07..284fc661dc7f18aa32d0dbcd8e7f98cb16af4bb7:/extension/content_script.js

diff --git a/extension/content_script.js b/extension/content_script.js
index 4a6c7e6..8ca721a 100644
--- a/extension/content_script.js
+++ b/extension/content_script.js
@@ -1,47 +1,158 @@
-(() => {
+import { io } from 'socket.io-client';
+import Peers from './peers';
+import Media from './media';
 
-  const internals = {
-    port: null,
+const internals = {
 
-    onMessage(message) {
-      internals[message.action](message.data);
-    },
+  kSocketUrl: 'https://junction.tranquil.services',
+	kIceServers: [
+		{url:"stun:stun.l.google.com:19302"}
+	],
 
-    async joinAudioCall(data) {
+  port: null,
+  socket: null,
+  peers: {},
 
-      try {
-        const mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-        internals.createAudioElement(data.tada);
-      }
-      catch (err) {
+  onMessage(message) {
+    internals[message.action](message.data);
+  },
 
-        internals.port.postMessage({
-          action: 'error'
+  async joinAudioCall(data) {
+
+    internals.tada = data.tada; // Keeping for fun
+
+    try {
+      const mediaStream = await Media.start();
+
+      internals.socket = io(internals.kSocketUrl, {
+        transports: ['websocket']
+      });
+
+      internals.socket.on('error', function(error) {
+
+        console.error('GENERAL ERROR', error);
+      });
+
+      internals.socket.on('connect_error', function(error) {
+
+        console.error('CONNNECT ERROR', error);
+      });
+
+      internals.socket.on('connect', function() {
+
+        console.log('Connected to signaling server, group: ', data.currentUrl);
+        internals.socket.emit('join', {
+          room: data.currentUrl,
         });
-        internals.port.disconnect();
-        internals.createAudioElement(data.tada);
-      }
-    },
+      });
 
-    hangUp() {
-      document.querySelectorAll('.junction-call-audio').forEach((audioElement) => audioElement.remove());
-      internals.port.disconnect();
-    },
+      internals.socket.on('disconnect', function() {
+
+        console.log("disconnected from signaling server");
+      });
+
+      internals.socket.on('addPeer', function(data) {
+
+          Peers.add(data.peerId, internals.tada);
+          const peerId = data.peerId;
+
+          const peerConnection = new RTCPeerConnection(
+              { iceServers: internals.kIceServers },
+              { optional: [{ DtlsSrtpKeyAgreement: true }] }
+          );
+
+          internals.peers[peerId] = peerConnection;
+          mediaStream.getTracks().forEach((track) => {
+            peerConnection.addTrack(track, localStream);
+          });
+
+          peerConnection.onicecandidate = (event) => {
+            if (event.candidate) {
+              internals.socket.emit('relayICECandidate', {
+                peerId: peerId,
+                candidate: event.candidate
+              });
+            }
+          }
+
+        const remoteStream = new MediaStream();
+        peerConnection.ontrack = (event) => {
+          remoteStream.addTrack(event.track);
+          const remoteAudioElement = new Audio();
+          remoteAudioElement.srcObject = remoteStream;
+          remoteAudioElement.play();
+        };
+
+        peerConnection.onnegotiationneeded = async () => {
+          console.log("Creating RTC offer to ", peerId);
+          const offer = await peerConnection.createOffer();
+          await peerConnection.setLocalDescription(offer);
 
-    createAudioElement(source, type = 'audio/wav') {
+          // Emit the offer to the peer
+          socket.emit('relayOffer', { offer, peerId });
+        };
 
-      const audioElement = document.createElement('audio');
-      audioElement.setAttribute('class', 'junction-call-audio');
-      audioElement.src = source;
-      audioElement.autoplay = 'autoplay';
-      audioElement.type = type;
-      document.querySelector('body').appendChild(audioElement);
+        console.log(`There are now ${Peers.count()} participants`);
+      });
+
+      socket.on('offerReceived', async (data) => {
+
+				const peerConnection = internals.peers[data.peerId];
+
+        const offer = new RTCSessionDescription(data.offer);
+        await peerConnection.setRemoteDescription(offer);
+
+        const answer = await peerConnection.createAnswer();
+        await peerConnection.setLocalDescription(answer);
+
+        // Send the answer to the peer
+        socket.emit('relayAnswer', { answer, peerId: data.peerId });
+      });
+
+      socket.on('answerReceived', async (data) => {
+
+				const peerConnection = internals.peers[data.peerId];
+        const answer = new RTCSessionDescription(data.answer);
+				await peerConnection.setRemoteDescription(answer);
+      });
+
+      socket.on('ICECandidateReceived', async (data) => {
+
+				const peerConnection = internals.peers[data.peerId];
+        const candidate = new RTCIceCandidate(data.candidate);
+        await peerConnection.addIceCandidate(candidate);
+		  });
+
+
+      internals.socket.on('removePeer', function() {
+
+				delete internals.peers[data.peerId];
+        Peers.remove('id-'+(Peers.count() - 1)); // This is only for testing, don't use count to remove ids.
+        console.log(`There are now ${Peers.count()} participants`);
+      });
     }
-  };
+    catch (err) {
+
+      internals.port.postMessage({
+        action: 'error'
+      });
+      internals.port.disconnect();
+    }
+  },
+
+  hangUp() {
+
+    Peers.reset();
+    Media.stop();
+    internals.socket.close();
+    internals.port.disconnect();
+  }
+};
+
+internals.port = chrome.runtime.connect({ name:"content" });
+internals.port.onMessage.addListener(internals.onMessage);
 
-  internals.port = chrome.runtime.connect({ name:"content" });
-  internals.port.onMessage.addListener(internals.onMessage);
-})();
+console.log('Content Script Loaded');
 
 // Indicates to the background script that we executed correctly
 true;