Migrate from Twilio Video

const twilio = require('twilio');
const { AccessToken } = twilio.jwt;
const { VideoGrant } = AccessToken;
 
const token = new AccessToken(
  process.env.TWILIO_ACCOUNT_SID,
  process.env.TWILIO_API_KEY_SID,
  process.env.TWILIO_API_KEY_SECRET,
  { identity: user.id, ttl: 3600 },
);
token.addGrant(new VideoGrant({ room: roomName }));
res.json({ token: token.toJwt() });

from twilio.jwt.access_token import AccessToken
from twilio.jwt.access_token.grants import VideoGrant
 
token = AccessToken(account_sid, api_key_sid, api_key_secret, identity=user_id, ttl=3600)
token.add_grant(VideoGrant(room=room_name))
jwt = token.to_jwt()

import { Livqeno } from '@livqeno/server';
 
const livqeno = new Livqeno({ apiKey: process.env.LIVQENO_API_KEY, baseUrl: process.env.LIVQENO_API_URL });
 
// Rooms are explicit. getOrCreate makes concurrent joins safe.
const room = await livqeno.rooms.create({ name: roomName, getOrCreate: true });
 
const grant = await livqeno.tokens.create({
  room: room.id, // the id, not the name
  identity: user.id,
  permissions: { join: true, subscribe: true, publish: true, publishData: true },
  expiresIn: 600,
});
res.json(grant); // forward the whole grant: token, endpoint, iceServers

import os
from livqeno import Livqeno, CreateTokenParams, TokenPermissions
 
livqeno = Livqeno(api_key=os.environ["LIVQENO_API_KEY"], base_url=os.environ["LIVQENO_API_URL"])
 
room = livqeno.rooms.create(room_name, get_or_create=True)
grant = livqeno.tokens.create(
    CreateTokenParams(
        room=room["id"],
        identity=user_id,
        permissions=TokenPermissions(join=True, subscribe=True, publish=True, publish_data=True),
        expires_in=600,
    )
)

client := livqeno.New(os.Getenv("LIVQENO_API_KEY"), livqeno.WithBaseURL(os.Getenv("LIVQENO_API_URL")))
 
room, err := client.Rooms.Create(ctx, livqeno.CreateRoomParams{Name: roomName, GetOrCreate: true})
if err != nil {
	return err
}
grant, err := client.Tokens.Create(ctx, livqeno.CreateTokenParams{
	Room:     room.ID,
	Identity: userID,
	Permissions: &livqeno.TokenPermissions{
		Join: livqeno.Bool(true), Subscribe: livqeno.Bool(true),
		Publish: livqeno.Bool(true), PublishData: livqeno.Bool(true),
	},
	ExpiresIn: 600,
})

import com.livqeno.server.model.*;
 
Room room = livqeno.rooms().create(CreateRoomParams.builder().name(roomName).getOrCreate(true).build());
 
IssuedToken grant = livqeno.tokens().create(CreateTokenParams.builder()
        .room(room.id())
        .identity(userId)
        .permissions(TokenPermissions.builder().join(true).subscribe(true).publish(true).publishData(true).build())
        .expiresIn(600)
        .build());

$room = $client->rooms->create(['name' => $roomName, 'getOrCreate' => true]);
 
$grant = $client->tokens->create([
    'room' => $room->id,
    'identity' => $userId,
    'permissions' => ['join' => true, 'subscribe' => true, 'publish' => true, 'publishData' => true],
    'expiresIn' => 600,
]);

import { connect } from 'twilio-video';
 
const room = await connect(token, { name: roomName, audio: true, video: true });
 
function onParticipant(participant) {
  participant.on('trackSubscribed', (track) => grid.appendChild(track.attach()));
  participant.on('trackUnsubscribed', (track) => track.detach().forEach((el) => el.remove()));
}
room.participants.forEach(onParticipant);
room.on('participantConnected', onParticipant);

import { createRTCClient } from '@livqeno/rtc';
 
const grant = await fetch('/join-room', { method: 'POST' }).then((r) => r.json());
const client = createRTCClient(grant); // reads token, endpoint and iceServers
const room = await client.join(); // the room comes from the token
 
room.on('trackSubscribed', (track, participant) => {
  const el = track.attach();
  el.dataset.identity = participant.identity;
  grid.appendChild(el);
});
room.on('trackUnsubscribed', (track) => track.detach().forEach((el) => el.remove()));
 
await room.enableCamera();
await room.enableMicrophone();

room.localParticipant.audioTracks.forEach((pub) => pub.track.disable());
room.localParticipant.audioTracks.forEach((pub) => pub.track.enable());

const mic = await room.enableMicrophone();
await mic?.mute();
await mic?.unmute();
 
// Or turn the device off entirely (the mic light goes off):
await room.disableMicrophone();

import { LocalVideoTrack } from 'twilio-video';
 
const stream = await navigator.mediaDevices.getDisplayMedia();
const screenTrack = new LocalVideoTrack(stream.getVideoTracks()[0], { name: 'screen' });
await room.localParticipant.publishTrack(screenTrack);
// stop:
room.localParticipant.unpublishTrack(screenTrack);
screenTrack.stop();

await room.enableScreenShare(); // opens the browser's picker and publishes
await room.disableScreenShare();
 
// Remote side: a screen share arrives as a track whose kind is 'screenShare'.
room.on('trackSubscribed', (track) => {
  if (track.kind === 'screenShare') stage.appendChild(track.attach());
});

import { LocalDataTrack } from 'twilio-video';
 
const dataTrack = new LocalDataTrack();
await room.localParticipant.publishTrack(dataTrack);
dataTrack.send(JSON.stringify({ type: 'raise-hand' }));
 
// Receiving: a RemoteDataTrack fires 'message'
track.on('message', (data) => console.log(data));

// Ephemeral messages to everyone in the call. Needs publishData in the token.
await room.sendData(JSON.stringify({ type: 'raise-hand' }));
 
room.on('dataReceived', (payload, participant) => {
  console.log(participant?.identity, new TextDecoder().decode(payload));
});

const twilioClient = require('twilio')(apiKeySid, apiKeySecret, { accountSid });
 
// Record everyone in the room
await twilioClient.video.v1.rooms(roomSid).recordingRules.update({
  rules: [{ type: 'include', all: true }],
});
 
// Later: compose the recordings into one file
await twilioClient.video.v1.compositions.create({
  roomSid,
  audioSources: ['*'],
  videoLayout: { grid: { video_sources: ['*'] } },
  format: 'mp4',
});

// There is no recording for calls. The only recording is the HLS replay of a
// broadcast-mode live stream, announced by a webhook when the stream ends:
//
// { "type": "live_stream.recording_ready",
//   "data": { "streamId": "stream_…", "recordingUrl": "https://…/vod.m3u8", "durationSec": 3600, "at": "…" } }
const stream = await livqeno.liveStreams.create({
  title: 'Town hall',
  hostIdentity: 'alice',
  deliveryMode: 'BROADCAST',
});

const twilio = require('twilio');
 
// Status callbacks are form-encoded and signed over the full URL + params.
const ok = twilio.validateRequest(
  process.env.TWILIO_AUTH_TOKEN,
  req.header('X-Twilio-Signature'),
  'https://example.com/twilio/status',
  req.body,
);
if (ok && req.body.StatusCallbackEvent === 'participant-connected') {
  // ...
}

import { createHmac, timingSafeEqual } from 'node:crypto';
 
// JSON body, signed over `<t>.<raw body>`. Read the RAW body, not parsed JSON.
function verify(rawBody: string, header: string, secret: string): boolean {
  const parts = Object.fromEntries(header.split(',').map((p) => p.trim().split('=')));
  if (Math.abs(Date.now() / 1000 - Number(parts.t)) > 300) return false;
  const expected = createHmac('sha256', secret).update(`${parts.t}.${rawBody}`).digest('hex');
  const a = Buffer.from(parts.v1 ?? '');
  const b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}
 
if (verify(rawBody, req.header('Swalvo-Signature') ?? '', process.env.LIVQENO_WEBHOOK_SECRET!)) {
  const event = JSON.parse(rawBody);
  if (event.type === 'room.participant_joined') {
    // event.data: { roomId, identity, connectionId, at }
  }
}

import hashlib, hmac, os, time
 
def verify(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.strip().split("=", 1) for p in header.split(",") if "=" in p)
    t = parts.get("t", "")
    if not t.isdigit() or abs(time.time() - int(t)) > 300:
        return False
    expected = hmac.new(secret.encode(), t.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(parts.get("v1", ""), expected)