Quickstart

cd ios && pod install   # iOS only

dependencies:
  livqeno_rtc: ^0.2.2

import { Livqeno } from '@livqeno/server';
 
const livqeno = new Livqeno({
  apiKey: process.env.LIVQENO_API_KEY!,
  baseUrl: process.env.LIVQENO_API_URL!, // https://api.livqeno.com
});
 
app.post('/join-room', async (req, res) => {
  // Every participant calls this. getOrCreate returns the existing room
  // to the second caller instead of a 409.
  const room = await livqeno.rooms.create({ name: 'demo-room', getOrCreate: true });
 
  const grant = await livqeno.tokens.create({
    room: room.id,
    identity: req.user.id, // from your session, never from req.body
    permissions: { join: true, subscribe: true, publish: true },
    expiresIn: 600,
  });
 
  res.json(grant); // forward the whole object
});

import os
from livqeno import Livqeno, CreateTokenParams, TokenPermissions
 
livqeno = Livqeno(
    api_key=os.environ["LIVQENO_API_KEY"],
    base_url=os.environ["LIVQENO_API_URL"],  # https://api.livqeno.com
)
 
@app.post("/join-room")
def join_room(request):
    # get_or_create needs livqeno 0.2.0 (see the Changelog).
    room = livqeno.rooms.create(name="demo-room", get_or_create=True)
 
    grant = livqeno.tokens.create(
        CreateTokenParams(
            room=room["id"],
            identity=request.user.id,  # from your session, never the body
            permissions=TokenPermissions(join=True, subscribe=True, publish=True),
            expires_in=600,
        )
    )
    return grant  # forward the whole object

client := livqeno.New(
	os.Getenv("LIVQENO_API_KEY"),
	livqeno.WithBaseURL(os.Getenv("LIVQENO_API_URL")), // https://api.livqeno.com
)
 
http.HandleFunc("POST /join-room", func(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	// Every participant calls this. GetOrCreate returns the existing room
	// to the second caller instead of a 409.
	room, err := client.Rooms.Create(ctx, livqeno.CreateRoomParams{Name: "demo-room", GetOrCreate: true})
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadGateway)
		return
	}
 
	grant, err := client.Tokens.Create(ctx, livqeno.CreateTokenParams{
		Room:     room.ID,
		Identity: currentUser(r).ID, // from your session, never the body
		Permissions: &livqeno.TokenPermissions{
			Join: livqeno.Bool(true), Subscribe: livqeno.Bool(true), Publish: livqeno.Bool(true),
		},
		ExpiresIn: 600,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadGateway)
		return
	}
 
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(grant) // forward the whole object
})

import com.livqeno.server.Livqeno;
import com.livqeno.server.model.*;
 
Livqeno livqeno = Livqeno.builder()
        .apiKey(System.getenv("LIVQENO_API_KEY"))
        .baseUrl(System.getenv("LIVQENO_API_URL"))   // https://api.livqeno.com
        .build();
 
@PostMapping("/join-room")
IssuedToken joinRoom(@AuthenticationPrincipal User user) {
    // Every participant calls this. getOrCreate returns the existing room
    // to the second caller instead of a 409.
    Room room = livqeno.rooms().create(CreateRoomParams.builder().name("demo-room").getOrCreate(true).build());
 
    return livqeno.tokens().create(CreateTokenParams.builder()
            .room(room.id())
            .identity(user.getId())                  // from your session, never the body
            .permissions(TokenPermissions.builder().join(true).subscribe(true).publish(true).build())
            .expiresIn(600)
            .build());                               // forward the whole object
}

$client = new \Livqeno\Client(
    apiKey: getenv('LIVQENO_API_KEY'),
    baseUrl: getenv('LIVQENO_API_URL'), // https://api.livqeno.com
);
 
// Every participant calls this. getOrCreate returns the existing room
// to the second caller instead of a 409.
$room = $client->rooms->create(['name' => 'demo-room', 'getOrCreate' => true]);
 
$grant = $client->tokens->create([
    'room' => $room->id,
    'identity' => $currentUser->id, // from your session, never the body
    'permissions' => ['join' => true, 'subscribe' => true, 'publish' => true],
    'expiresIn' => 600,
]);
 
header('Content-Type: application/json');
echo json_encode($grant); // forward the whole object

import { createRTCClient } from '@livqeno/rtc';
 
const grant = await fetch('/join-room', { method: 'POST' }).then((r) => r.json());
 
// createRTCClient reads token, endpoint, iceServers and telemetryUrl from the grant.
const client = createRTCClient(grant);
const room = await client.join(grant.roomName);
 
await room.enableCamera();
await room.enableMicrophone();

'use client';
import { LivqenoRoom, useCamera, useConnectionState, useMicrophone } from '@livqeno/react';
 
export function CallPage({ grant }) {
  // <LivqenoRoom> joins on mount and leaves on unmount.
  return (
    <LivqenoRoom
      token={grant.token}
      endpoint={grant.endpoint}
      iceServers={grant.iceServers}
      telemetryUrl={grant.telemetryUrl}
      room={grant.roomName}
      fallback={<p>Connecting…</p>}
    >
      <Controls />
      <RemoteGrid />
    </LivqenoRoom>
  );
}
 
function Controls() {
  const state = useConnectionState(); // 'connecting' | 'connected' | 'reconnecting' | ...
  const camera = useCamera();
  const microphone = useMicrophone();
  return (
    <>
      <p>Status: {state}</p>
      <button onClick={() => (camera.enabled ? camera.disable() : camera.enable())}>
        Camera: {camera.enabled ? 'on' : 'off'}
      </button>
      <button onClick={() => (microphone.enabled ? microphone.disable() : microphone.enable())}>
        Mic: {microphone.enabled ? 'on' : 'off'}
      </button>
    </>
  );
}

import { Livqeno } from '@livqeno/react-native';
 
const grant = await fetch('https://your-backend.example/join-room', { method: 'POST' })
  .then((r) => r.json());
 
// Registers the WebRTC globals and asks for camera/mic permission on join.
const livqeno = new Livqeno(grant);
const room = await livqeno.join(grant.roomName);
 
await room.enableCamera();
await room.enableMicrophone();

import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:livqeno_rtc/livqeno_rtc.dart';
 
final res = await http.post(Uri.parse('https://your-backend.example/join-room'));
final grant = jsonDecode(res.body) as Map<String, dynamic>;
 
final livqeno = Livqeno(
  token: grant['token'] as String,
  endpoint: grant['endpoint'] as String,
  // Without iceServers there is no TURN relay, and most NATed devices fail.
  iceServers: (grant['iceServers'] as List)
      .map((s) => LivqenoIceServer.fromJson(s as Map<String, dynamic>))
      .toList(),
);
final room = await livqeno.join(grant['roomName'] as String);
 
await room.enableCamera();
await room.enableMicrophone();

const grid = document.getElementById('grid')!;
 
for (const participant of room.remoteParticipants) {
  for (const track of participant.tracks) grid.append(track.attach());
}
 
room.on('participantJoined', (participant) => console.log(`${participant.identity} joined`));
 
// Fires when a remote track is actually playable — the one to render on.
room.on('trackSubscribed', (track, participant) => grid.append(track.attach()));
 
room.on('participantLeft', (participant) => console.log(`${participant.identity} left`));

import { ParticipantView, useRemoteParticipants } from '@livqeno/react';
 
function RemoteGrid() {
  // Re-renders on participant and track events: no listeners to wire up.
  const remote = useRemoteParticipants();
  return remote.map((p) => <ParticipantView key={p.identity} participant={p} />);
}

import { LivqenoVideoView, useRemoteParticipants } from '@livqeno/react-native';
 
function RemoteGrid({ room }) {
  const remote = useRemoteParticipants(room);
  return remote.map((p) => (
    <LivqenoVideoView key={p.identity} participant={p} room={room} style={{ flex: 1 }} />
  ));
}

// In a widget: one LivqenoVideoView per remote participant.
for (final participant in room.remoteParticipants) {
  LivqenoVideoView(participant: participant, room: room);
}
 
room.participantChanges.listen((participants) {
  // The full current roster: rebuild your grid with setState.
});

await room.leave(); // stops local tracks, closes the connection, tells the room

const { leave } = useLivqeno();
<button onClick={() => leave()}>Leave</button>;

await livqeno.leave();   // leaves the room
await livqeno.dispose(); // tears down everything, including chat

await livqeno.leave();