Inject script only once

[rbdr/junction] / extension / content_script.js

diff --git a/extension/content_script.js b/extension/content_script.js
index 6785a6556427ab48b49495eda7f51fc907717465..9d4666931b9fae6702c31a0dedda56e55d51ecff 100644 (file)
--- a/extension/content_script.js
+++ b/extension/content_script.js
@@ -1,136 +1,100 @@
-import { io } from 'socket.io-client';
-import Peers from './peers';
-import Media from './media';
+import { io } from "socket.io-client";
+import { initializeTada } from "./tada";
+import {
+  addPeer,
+  addIceCandidate,
+  answerPeerOffer,
+  processPeerAnswer,
+  removePeer,
+  resetPeers,
+} from "./peers";
+import { startMedia, stopMedia } from "./media";
 
 const internals = {
-
-  kSocketUrl: 'https://junction.tranquil.services',
-       kIceServers: [
-               {url:"stun:stun.l.google.com:19302"}
-       ],
+  kSocketUrl: "https://junction.tranquil.services",
+  kIceServers: [{ urls: "stun:stun.l.google.com:19302" }],
 
   port: null,
   socket: null,
-  peers: {},
 
   onMessage(message) {
     internals[message.action](message.data);
   },
 
-  async joinAudioCall(data) {
+  onError(error) {
+    // TODO: How do we want to handle errors?
+    console.error(error.stack || error);
+  },
 
-    internals.tada = data.tada; // Keeping for fun
+  connect() {
+    internals.port = chrome.runtime.connect({ name: "content" });
+    internals.port.onMessage.addListener(internals.onMessage);
+  },
 
+  async joinAudioCall({ currentUrl, tada }) {
     try {
-      const mediaStream = await Media.start();
-
-      internals.socket = io(internals.kSocketUrl, {
-        transports: ['websocket']
-      });
-
-      internals.socket.on('error', function(error) {
-
-        console.error('GENERAL ERROR', error);
-      });
+      const mediaStream = await startMedia();
+      const playTada = initializeTada(tada);
 
-      internals.socket.on('connect_error', function(error) {
+      const socket = (internals.socket = io(internals.kSocketUrl, {
+        transports: ["websocket"],
+      }));
 
-        console.error('CONNNECT ERROR', error);
-      });
-
-      internals.socket.on('connect', function() {
+      socket.on("error", internals.handleError);
+      socket.on("connect_error", internals.handleError);
 
-        console.log("Connected to signaling server, group: ", data.currentUrl);
-        internals.socket.emit('join', {
-          'url': data.currentUrl,
+      socket.on("connect", () => {
+        console.debug("Connected to signaling server, group: ", currentUrl);
+        playTada();
+        socket.emit("join", {
+          room: currentUrl,
         });
       });
 
-      internals.socket.on('disconnect', function() {
-
-        console.log("disconnected from signaling server");
+      socket.on("disconnect", () => {
+        console.debug("disconnected from signaling server");
       });
 
-      internals.socket.on('addPeer', function(data) {
-
-        console.log(data);
-        Peers.add(data.peer_id, internals.tada);
-          const peerId = data.peer_id;
-
-          const peerConn = new RTCPeerConnection(
-              {"iceServers": internals.kIceServers},
-              {"optional": [{"DtlsSrtpKeyAgreement": true}]}
-          );
-
-          internals.peers[peerId] = peerConn;
-
-          peerConn.onicecandidate = (event) => {
-            if (event.candidate) {
-              internals.socket.emit('relayICECandidate', {
-                'peer_id': peerId,
-                'ice_candidate': {
-                  'sdpMLineIndex': event.candidate.sdpMLineIndex,
-                  'candidate': event.candidate.candidate
-                }
-              });
-            }
-          }
-
-          peerConn.onaddstream = (stream) => {
-            console.log(`Received stream for peer ${peerId}`);
-            console.log(stream);
-          }
-
-          peerConn.addStream(mediaStream);
-
-          if (data.should_create_offer) {
-            console.log("Creating RTC offer to ", peerId);
-            peerConn.createOffer((local_description) => {
-                  console.log("Local offer description is: ", local_description);
-                  peerConn.setLocalDescription(local_description, () => {
-                        internals.socket.emit('relaySessionDescription', {
-                          'peer_id': peerId,
-                          'session_description': local_description
-                        });
-
-                        console.log("Offer setLocalDescription succeeded");
-                      }, () => { console.log("Offer setLocalDescription failed!"); }
-                  );
-                },
-                (error) => { console.log("Error sending offer: ", error) }
-            );
-          }
-        console.log(`There are now ${Peers.count()} participants`);
+      socket.on("addPeer", ({ peerId, shouldCreateOffer }) => {
+        addPeer({
+          peerId,
+          shouldCreateOffer,
+          mediaStream,
+          onOffer: (data) => socket.emit("relayOffer", data),
+          socket
+        });
+        playTada();
       });
 
-      internals.socket.on('removePeer', function() {
-
-        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`);
+      socket.on("offerReceived", async ({ peerId, offer }) => {
+        socket.emit("relayAnswer", await answerPeerOffer({ peerId, offer }));
       });
-    }
-    catch (err) {
 
+      socket.on("answerReceived", (data) => processPeerAnswer(data));
+      socket.on("ICECandidateReceived", (data) => addIceCandidate(data));
+      socket.on("removePeer", (data) => removePeer(data));
+    } catch (err) {
       internals.port.postMessage({
-        action: 'error'
+        action: "error",
       });
       internals.port.disconnect();
     }
   },
 
   hangUp() {
-
-    Peers.reset();
-    Media.stop();
+    resetPeers();
+    stopMedia();
     internals.socket.close();
     internals.port.disconnect();
-  }
+  },
 };
 
-internals.port = chrome.runtime.connect({ name:"content" });
-internals.port.onMessage.addListener(internals.onMessage);
+internals.connect();
+chrome.runtime.onConnect.addListener(() => {
+  internals.connect();
+});
 
-console.log('Content Script Loaded');
+console.debug("Content Script Loaded");
 
 // Indicates to the background script that we executed correctly
 true;