evmux-app-framework 0.0.53 → 0.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evmux-app-framework",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/AppsObserver/AppsObserver.js

@@ -35,7 +35,9 @@ export const availableRequests = {
     displayRichTextEditor: "displayRichTextEditor",
     displayToast: "displayToast",
     isSudioMode: "isSudioMode",
-    getStudioParams: "getStudioParams"
+    getStudioParams: "getStudioParams",
+    getSoundRtc: "getSoundRtc",
+    signal: "signal",
 
 
 }
@@ -135,6 +137,14 @@ let createEventResultObject = (requestName, eventName, result) => {
          })
 
      }
+
+     signalApp(userAppInstanceId, data){
+         let theApp = this._userAppInstances[userAppInstanceId]
+         if(theApp && theApp.events[availableEvents.signalingEvent]){
+             let eventObj = createEventResultObject("EvEvent", availableEvents.signalingEvent, data)
+             this._sendPostMessageToUsrAppInstancesComponents(userAppInstanceId, eventObj, null)
+         }
+     }
       
      async onPostMessage(evt) {
         let requestObj = {};

package/src/AppsObserver/AppsObserverStudioHandler.js

@@ -7,7 +7,7 @@ import  {availableRequests} from './AppsObserver'
   
     canHandleRequest(requestObj)
     {
-        const supportedRequests = [availableRequests.getStudioParams];
+        const supportedRequests = [availableRequests.getStudioParams, availableRequests.getSoundRtc, availableRequests.signal];
         return supportedRequests.includes(requestObj.request);
     }
 
@@ -17,4 +17,13 @@ import  {availableRequests} from './AppsObserver'
             antiScaleValue2: 1.0,
         }
     }
+
+    async signal(requestObj) {
+        return null
+    }
+
+
+    async getSoundRtc(requestObj) {
+        return "webrtc-mock-channel"
+    }
  }

package/src/EvmuxAppsApi/EvmuxAppsApi.js

@@ -20,7 +20,8 @@ export const availableEvents = {
   doubleClickOnWidget: "doubleClickOnWidget",
   widgetOnFocus: "widgetGotFocus",
   widgetOnBlur: "widgetOnBlur",
-    studioParamsUpdated: "studioParamsUpdated",
+  studioParamsUpdated: "studioParamsUpdated",
+  signalingEvent: "signalingEvent",
 }
 
 export const layerTypes = {

package/src/EvmuxAppsApi/EvmuxAppsApiStudio.js

@@ -20,4 +20,30 @@ export default class EvmuxAppsApiStudio {
   }
 
 
+  async signal(data){
+    let reqObj = {
+      request: availableRequests.signal,
+      userAppInstanceId: this.evmuxAppsApi._userAppInstanceId,
+      componentId: this.evmuxAppsApi._componentId,
+      data
+    }
+    return this.evmuxAppsApi._postMessageManager.sendRequestAsync(reqObj);
+  }
+
+  async getSoundRtc(userId, userType, preferedCodecs){ // userType: 'editor' | 'speaker' | 'guest'
+    let reqObj = {
+      request: availableRequests.getSoundRtc,
+      userAppInstanceId: this.evmuxAppsApi._userAppInstanceId,
+      componentId: this.evmuxAppsApi._componentId,
+      data: {
+        userId,
+        userType,
+        preferedCodecs
+      }
+    }
+    let res = this.evmuxAppsApi._postMessageManager.sendRequestAsync(reqObj);
+    return res
+  }
+
+
 }

package/src/system/EvWebrtc.js

@@ -0,0 +1,163 @@
+
+
+
+export class EvWebrtc{
+
+  constructor(component, channelName = 'webrtc', codecPreferences = null, postSignaligMessageFunc = null, endedCallback = null) {
+
+    this.component = component
+    this.channelName = channelName
+    this.codecPreferences = codecPreferences
+    this.postSignaligMessageFunc = postSignaligMessageFunc
+    this.pc = null
+    this.endedCallback = endedCallback
+    this.localStream = null
+    this.remoteStream = null
+    this.signaling = new BroadcastChannel(this.channelName);
+    this.signaling.onmessage = (e) => this.signalingMessageHandler(e);
+  }
+
+  postSignaligMessage(message){
+    message.channelName = this.channelName
+    if(this.postSignaligMessageFunc){
+      this.postSignaligMessageFunc(message)
+    }else{
+      this.signaling.postMessage(message);
+    }
+  }
+
+  signalingMessageHandler(e) {
+    if (!this.localStream) {
+      console.log('not ready yet', this.component);
+      return;
+    }
+    switch (e.type) {
+      case 'offer':
+        this.handleOffer(e);
+        break;
+      case 'answer':
+        this.handleAnswer(e);
+        break;
+      case 'candidate':
+        this.handleCandidate(e);
+        break;
+      case 'ready':
+        // A second tab joined. This tab will initiate a call unless in a call already.
+        if (this.pc) {
+          console.log('already in call, ignoring');
+          return;
+        }
+        this.makeCall();
+        break;
+      case 'bye':
+        if (this.pc) {
+          this.hangup();
+        }
+        if(this.endedCallback){
+            this.endedCallback()
+        }
+        break;
+      default:
+        console.log('unhandled', e);
+        break;
+    }
+  }
+
+  onconnectionstatechange(e){
+    console.log('connection state change', e);
+  }
+
+  oniceconnectionstatechange(e){
+    console.log('ice connection state change', e);
+  }
+
+  async hangup() {
+    if (this.pc) {
+      this.pc.close();
+      this.pc = null;
+    this.postSignaligMessage({type: 'bye'});
+    }
+    // this.localStream.getTracks().forEach(track => track.stop());
+    // this.localStream = null;
+  };
+
+  ready(){
+    this.postSignaligMessage({type: 'ready'});
+  }
+
+
+  createPeerConnection() {
+    this.pc = new RTCPeerConnection();
+    this.pc.onconnectionstatechange = e => this.onconnectionstatechange(e);
+    this.pc.oniceconnectionstatechange = e => this.oniceconnectionstatechange(e);
+    this.pc.onicecandidate = e => {
+      console.log('onicecandidate', this.component, e);
+      const message = {
+        type: 'candidate',
+        candidate: null,
+      };
+      if (e.candidate) {
+        message.candidate = e.candidate.candidate;
+        message.sdpMid = e.candidate.sdpMid;
+        message.sdpMLineIndex = e.candidate.sdpMLineIndex;
+      }
+      this.postSignaligMessage(message);
+    };
+    this.pc.ontrack = e => this.remoteStream = e.streams[0];
+    this.localStream.getTracks().forEach(track => this.pc.addTrack(track, this.localStream));
+  }
+
+  async makeCall() {
+    console.log('make call', this.component);
+    await this.createPeerConnection();
+    let transceivers = this.pc.getTransceivers()
+    if(this.codecPreferences){
+      transceivers.forEach(t => {
+        t.setCodecPreferences(this.codecPreferences)
+      })
+
+    }
+
+
+    const offer = await this.pc.createOffer();
+    this.postSignaligMessage({type: 'offer', sdp: offer.sdp});
+    await this.pc.setLocalDescription(offer);
+  }
+
+  async handleOffer(offer) {
+    console.log('handle offer', this.component);
+    if (this.pc) {
+      console.error('existing peerconnection');
+      return;
+    }
+    await this.createPeerConnection();
+    await this.pc.setRemoteDescription(offer);
+
+    const answer = await this.pc.createAnswer();
+    this.postSignaligMessage({type: 'answer', sdp: answer.sdp});
+    await this.pc.setLocalDescription(answer);
+  }
+
+  async handleAnswer(answer) {
+    console.log('handle answer', this.component);
+    if (!this.pc) {
+      console.error('no peerconnection');
+      return;
+    }
+    await this.pc.setRemoteDescription(answer);
+  }
+
+  async handleCandidate(candidate) {
+    console.log('handle candidate', this.component);
+    if (!this.pc) {
+      console.error('no peerconnection');
+      return;
+    }
+    if (!candidate.candidate) {
+      await this.pc.addIceCandidate(null);
+    } else {
+      await this.pc.addIceCandidate(candidate);
+    }
+  }
+
+}