Migrate from Agora

const { RtcTokenBuilder, RtcRole } = require('agora-token');
 
const token = RtcTokenBuilder.buildTokenWithUid(
  process.env.AGORA_APP_ID,
  process.env.AGORA_APP_CERTIFICATE,
  channelName,
  uid,
  RtcRole.PUBLISHER,
  3600, // token expiry, seconds
  3600, // privilege expiry, seconds
);

# RtcTokenBuilder2 from Agora's AgoraDynamicKey sources (check their docs
# for the import path in your setup).
from RtcTokenBuilder2 import RtcTokenBuilder, Role_Publisher
 
token = RtcTokenBuilder.build_token_with_uid(
    app_id, app_certificate, channel_name, uid, Role_Publisher, 3600, 3600
)

import { Livqeno } from '@livqeno/server';
 
const livqeno = new Livqeno({ apiKey: process.env.LIVQENO_API_KEY, baseUrl: process.env.LIVQENO_API_URL });
 
// A channel name becomes a room name. getOrCreate makes concurrent joins safe.
const room = await livqeno.rooms.create({ name: channelName, getOrCreate: true });
 
const grant = await livqeno.tokens.create({
  room: room.id, // the id, not the name
  identity: String(uid),
  permissions: { join: true, subscribe: true, publish: true, publishData: true },
  expiresIn: 3600,
});
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(channel_name, get_or_create=True)
grant = livqeno.tokens.create(
    CreateTokenParams(
        room=room["id"],
        identity=str(uid),
        permissions=TokenPermissions(join=True, subscribe=True, publish=True, publish_data=True),
        expires_in=3600,
    )
)

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

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

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

import AgoraRTC from 'agora-rtc-sdk-ng';
 
const client = AgoraRTC.createClient({ mode: 'rtc', codec: 'vp8' });
await client.join(appId, channelName, token, uid);
 
const [micTrack, camTrack] = await AgoraRTC.createMicrophoneAndCameraTracks();
await client.publish([micTrack, camTrack]);
 
client.on('user-published', async (user, mediaType) => {
  await client.subscribe(user, mediaType);
  if (mediaType === 'video') user.videoTrack.play(`tile-${user.uid}`);
  if (mediaType === 'audio') user.audioTrack.play();
});

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
 
// No subscribe call: every published track arrives here.
room.on('trackSubscribed', (track, participant) => {
  const el = track.attach(); // a <video> or <audio> element, autoplaying
  document.getElementById(`tile-${participant.identity}`)?.appendChild(el);
});
room.on('trackUnsubscribed', (track) => track.detach().forEach((el) => el.remove()));
 
await room.enableCamera();
await room.enableMicrophone();

await micTrack.setMuted(true);
await micTrack.setMuted(false);
 
// Or stop capture entirely:
await micTrack.setEnabled(false);

const mic = await room.enableMicrophone();
await mic?.mute();
await mic?.unmute();
 
// Or stop capture and release the device:
await room.disableMicrophone();

const screenTrack = await AgoraRTC.createScreenVideoTrack({ encoderConfig: '1080p_1' });
// The Web SDK publishes one video track per client, so apps usually swap the
// camera out or use a second client for the screen (check Agora's docs).
await client.unpublish(camTrack);
await client.publish(screenTrack);

await room.enableScreenShare(); // camera keeps publishing alongside it
await room.disableScreenShare();
 
room.on('trackSubscribed', (track) => {
  if (track.kind === 'screenShare') stage.appendChild(track.attach());
});

await client.enableDualStream();
client.setRemoteVideoStreamType(remoteUid, 1); // 1 = low-quality stream

// Simulcast is on by default, and adaptiveStream picks a quality from each
// tile's size. To force one:
room.on('trackSubscribed', (track) => {
  if (track.kind === 'camera') track.setLayer('low'); // 'low' | 'medium' | 'high' | 'auto'
});

import AgoraRTM from 'agora-rtm';
 
const rtm = new AgoraRTM.RTM(appId, userId);
await rtm.login({ token: rtmToken });
await rtm.subscribe(channelName);
 
rtm.addEventListener('message', (event) => console.log(event.publisher, event.message));
await rtm.publish(channelName, 'hello');

await room.sendData(JSON.stringify({ type: 'raise-hand' }));
 
room.on('dataReceived', (payload, participant) => {
  console.log(participant?.identity, new TextDecoder().decode(payload));
});

import { createChatClient } from '@livqeno/chat';
 
// chatGrant comes from your backend (below)
const chat = createChatClient(chatGrant);
await chat.connect({ room: conversationId });
 
chat.on('message', (message) => console.log(message.senderId, message.text));
await chat.sendMessage({ text: 'hello' });

// Cloud Recording is a REST flow: acquire a resource, start, later stop.
const base = `https://api.agora.io/v1/apps/${appId}/cloud_recording`;
const headers = { Authorization: `Basic ${restCredential}`, 'Content-Type': 'application/json' };
 
const { resourceId } = await fetch(`${base}/acquire`, {
  method: 'POST', headers,
  body: JSON.stringify({ cname: channelName, uid: recorderUid, clientRequest: {} }),
}).then((r) => r.json());
 
const { sid } = await fetch(`${base}/resourceid/${resourceId}/mode/mix/start`, {
  method: 'POST', headers,
  body: JSON.stringify({ cname: channelName, uid: recorderUid, clientRequest: { token, storageConfig } }),
}).then((r) => r.json());
 
// ...later
await fetch(`${base}/resourceid/${resourceId}/sid/${sid}/mode/mix/stop`, {
  method: 'POST', headers,
  body: JSON.stringify({ cname: channelName, uid: recorderUid, clientRequest: {} }),
});

// No start/stop recording API, and no recording of calls.
// A broadcast-mode live stream is recorded automatically. When it ends you get:
//
// { "type": "live_stream.recording_ready",
//   "data": { "streamId": "stream_…", "recordingUrl": "https://…/vod.m3u8", "durationSec": 3600, "at": "…" } }
const stream = await livqeno.liveStreams.create({
  title: 'Weekly class',
  hostIdentity: 'teacher-1',
  deliveryMode: 'BROADCAST',
});

// Media Push: create a converter that mixes the channel and pushes RTMP.
// Check Agora's docs for the region path and the transcodeOptions fields.
await fetch(`https://api.agora.io/${region}/v1/projects/${appId}/rtmp-converters`, {
  method: 'POST', headers,
  body: JSON.stringify({
    converter: {
      name: 'youtube',
      transcodeOptions: { rtcChannel: channelName /* audioOptions, videoOptions */ },
      rtmpUrl: `rtmp://a.rtmp.youtube.com/live2/${youtubeKey}`,
    },
  }),
});

// Restream belongs to live streams. The stream owns its own room.
const stream = await livqeno.liveStreams.create({ title: 'Launch', hostIdentity: 'host-1' });
const hostGrant = await livqeno.liveStreams.addHost(stream.id, { identity: 'host-1' });
await livqeno.liveStreams.start(stream.id);
 
const destination = await livqeno.liveStreams.restreams.create(stream.id, {
  url: 'rtmps://a.rtmp.youtube.com/live2', // URL and key are separate fields
  streamKey: process.env.YOUTUBE_STREAM_KEY!,
  label: 'YouTube',
});
 
// Pause, resume, remove
await livqeno.liveStreams.restreams.update(stream.id, destination.id, { enabled: false });
await livqeno.liveStreams.restreams.delete(stream.id, destination.id);

import os
from livqeno import CreateLiveStreamParams, AddHostParams, CreateRestreamParams
 
stream = livqeno.live_streams.create(CreateLiveStreamParams(title="Launch", host_identity="host-1"))
host_grant = livqeno.live_streams.add_host(stream["id"], AddHostParams(identity="host-1"))
livqeno.live_streams.start(stream["id"])
 
destination = livqeno.live_streams.restreams.create(
    stream["id"],
    CreateRestreamParams(
        url="rtmps://a.rtmp.youtube.com/live2",
        stream_key=os.environ["YOUTUBE_STREAM_KEY"],
        label="YouTube",
    ),
)

const crypto = require('node:crypto');
 
// NCS signs the raw body with your NCS secret (check their docs for headers).
const expected = crypto.createHmac('sha256', process.env.AGORA_NCS_SECRET).update(rawBody).digest('hex');
if (expected === req.header('Agora-Signature-V2')) {
  const { eventType, payload } = JSON.parse(rawBody);
  // e.g. 103 / 104: a user joined / left the channel
}

import { createHmac, timingSafeEqual } from 'node:crypto';
 
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); // { id, type, data, ... }; dedupe on event.id
}

event, err := livqeno.VerifyWebhookRequest(r, os.Getenv("LIVQENO_WEBHOOK_SECRET"))
if err != nil {
	http.Error(w, "invalid signature", http.StatusBadRequest)
	return
}
// event.ID, event.Type, event.Data

import com.livqeno.server.webhooks.WebhookVerifier;
 
byte[] raw = request.getInputStream().readAllBytes();
String signature = request.getHeader(WebhookVerifier.SIGNATURE_HEADER);
if (!WebhookVerifier.verify(raw, signature, System.getenv("LIVQENO_WEBHOOK_SECRET"))) {
    response.setStatus(400);
    return;
}

use Livqeno\LivqenoException;
use Livqeno\Webhook;
 
$webhook = new Webhook(getenv('LIVQENO_WEBHOOK_SECRET'));
try {
    $event = $webhook->constructEvent(file_get_contents('php://input'), $_SERVER['HTTP_LIVQENO_SIGNATURE'] ?? null);
} catch (LivqenoException $e) {
    http_response_code(400);
    exit;
}