media dev

media.ts

import { Consumer, Producer, Transport } from 'mediasoup/node/lib/types'
import WebSocket from 'ws'
import { createWebrtcTransport } from './createWebrtcTransport'
import { createRouter } from './router'

const WebsocketConnection = async (websocket: WebSocket.Server) => {
  const { router } = await createRouter()
  let producerTransport: Transport
  let consumerTransport: Transport
  let producer: Producer
  let consumer: Consumer

  const getUniqueID = () => {
    const s4 = () => {
      return Math.floor((1 + Math.random()) * 0x10000)
        .toString(16)
        .substring(1)
    }
    return s4() + s4() + '-' + s4()
  }
  websocket.on('connection', async (ws: WebSocket) => {
    console.log('websocket connected')
    let uid = getUniqueID()
    const resp = {
      id: uid,
    }
    send(ws, 'connection event', resp)
    ws.on('message', (json_string: string) => {
      const jsonValidation = IsJsonString(json_string)
      if (!jsonValidation) {
        console.error('not a valid json string')
        return
      }
      const resp = JSON.parse(json_string)
      console.log('from client', resp)
      switch (resp.type) {
        case 'getRtpCapabilities':
          onRtpCapabilities(ws)
          break
        case 'createWebRtcTransport':
          onCreateWebRtcTransport(ws, resp)
          break
        case 'connectProducerTransport':
          onConnectProducerTransport(ws, resp)
          break
        case 'produceMedia':
          onProduceMedia(ws, resp)
          break
        case 'connectConsumerTransport':
          onConnectConsumerTransport(ws, resp)
          break
        case 'consumeMedia':
          onConsumeMedia(ws, resp)
          break
        case 'resumeConsumer':
          onResumeConsumer(ws)
          break
        default:
          break
      }
    })
  })
  const onResumeConsumer = async (ws: WebSocket) => {
    console.log('we called resume here')
    await consumer.resume()
  }
  const onConsumeMedia = async (ws: WebSocket, resp: any) => {
    try {
      if (
        router.canConsume({
          producerId: producer.id,
          rtpCapabilities: resp.rtpCapabilities,
        })
      ) {
        consumer = await consumerTransport.consume({
          producerId: producer.id,
          rtpCapabilities: resp.rtpCapabilities,
          paused: true,
        })
        consumer.on('transportclose', () => {
          console.log('transportclose for consumer')
        })
        consumer.on('producerclose', () => {
          console.log('producerclose for consumer')
        })
        const message = {
          id: consumer.id,
          producerId: producer.id,
          kind: consumer.kind,
          rtpParameters: consumer.rtpParameters,
        }
        send(ws, 'consumerCreated', message)
      }
    } catch (error) {
      const message = {
        params: {
          error: error,
        },
      }
      send(ws, 'consumerCreated', message)
    }
  }
  const onConnectConsumerTransport = async (ws: WebSocket, resp: any) => {
    console.log('DTLS PARAMS', resp.dtlsParameters)
    await consumerTransport.connect({ dtlsParameters: resp.dtlsParameters })
    // send(ws, 'connectedConsumerTransport', {})
  }
  const onProduceMedia = async (ws: WebSocket, resp: any) => {
    console.log('produce transport', resp)
    producer = await producerTransport.produce({
      kind: resp.kind,
      rtpParameters: resp.rtpParameters,
    })
    producer.on('transportclose', () => {
      console.log('transport for this producer closed')
      producer.close()
    })
    const message = {
      id: producer.id,
    }
    send(ws, 'producerCreated', message)
  }
  const onConnectProducerTransport = async (ws: WebSocket, resp: any) => {
    console.log('connect transport', resp)
    const dtlsParameters = resp.dtlsParameters
    await producerTransport.connect({ dtlsParameters })
    send(ws, 'producerTransportConnected', {})
  }

  const onCreateWebRtcTransport = async (ws: WebSocket, msg: any) => {
    if (msg.sender) {
      const { transport, params } = await createWebrtcTransport(router)
      producerTransport = transport
      send(ws, 'producerTransportCreated', params)
    } else {
      const { transport, params } = await createWebrtcTransport(router)
      consumerTransport = transport
      send(ws, 'consumerTransportCreated', params)
    }
  }
  const onRtpCapabilities = (ws: WebSocket) => {
    let rtpCapabilities = router.rtpCapabilities
    const message = {
      rtpCapabilities,
    }
    send(ws, 'rtpCapabilities', message)
  }
  const send = (ws: WebSocket, type: string, data: any) => {
    const message = {
      type,
      data,
    }
    const resp = JSON.stringify(message)
    ws.send(resp)
  }
  const broadcast = (wbsocket: WebSocket.Server, type: string, data: any) => {
    const message = {
      type,
      data,
    }
    const resp = JSON.stringify(message)
    wbsocket.clients.forEach((client) => {
      client.send(resp)
    })
  }
  const IsJsonString = (str: string) => {
    try {
      JSON.parse(str)
    } catch (error) {
      return false
    }
    return true
  }
}
export { WebsocketConnection }