recordingUrl

.m3u8

playlist.m3u8

playlist-live.m3u8

.mp4

.m3u8

.ts

window.livekitReady = true

@Override
    public String startCustomCompositeEgress(String roomName, String recordingUrl, String hlsKeyPrefix, String mp4Filepath) throws IOException {
        LivekitEgress.S3Upload hlsS3UploadConfiguration = buildS3Upload(hlsBucketName);
        LivekitEgress.S3Upload mp4S3UploadConfiguration = buildS3Upload(mp4BucketName);
        LOGGER.info("Starting Custom Composite Egress for room: {}. Capture URL: {}", roomName, recordingUrl);
        LivekitEgress.SegmentedFileOutput hlsOutputConfiguration = LivekitEgress.SegmentedFileOutput.newBuilder()
                .setFilenamePrefix(hlsKeyPrefix)
                .setPlaylistName("playlist.m3u8")
                .setLivePlaylistName("playlist-live.m3u8")
                .setSegmentDuration(2)
                .setProtocol(LivekitEgress.SegmentedFileProtocol.HLS_PROTOCOL)
                .setS3(hlsS3UploadConfiguration)
                .build();

        LivekitEgress.EncodedFileOutput mp4OutputConfiguration = LivekitEgress.EncodedFileOutput.newBuilder()
                .setFileType(LivekitEgress.EncodedFileType.MP4)
                .setFilepath(mp4Filepath)
                .setS3(mp4S3UploadConfiguration)
                .build();

        EncodedOutputs egressOutputsWrapper = new EncodedOutputs(
                mp4OutputConfiguration,
                null,
                hlsOutputConfiguration,
                null
        );

        Call<LivekitEgress.EgressInfo> egressCall = egressClient.startRoomCompositeEgress(
                roomName,
                egressOutputsWrapper,
                "custom",
                LivekitEgress.EncodingOptionsPreset.H264_720P_30,
                null,
                false,
                false,
                recordingUrl,
                AudioMixing.DEFAULT_MIXING
        );

        LivekitEgress.EgressInfo egressInformation = executeCall(egressCall);
        if (egressInformation == null) {
            throw new IOException("LiveKit startCustomCompositeEgress returned empty body");
        }

        LOGGER.info("Custom Egress successfully initiated with ID: {} and status: {}",
                egressInformation.getEgressId(), egressInformation.getStatus());
        return egressInformation.getEgressId();
    }

egress_ended

status

details

empty_timeout

egress_ended

window.livekitReady

window.livekitReady = true

window.livekitReady

canSubscribe

S3Upload

customUrl

details

egress_ended

egress_ended

egress_ended

status

details

window.livekitReady = true

customUrl

egress_ended

egress_ended

details

window.livekitReady

egress_ended

status

details

error

manifestLocation

backupStorageUsed

window.livekitReady = true

console.log("custom layout ready - setting window.livekitReady = true");
     window.livekitReady = true;

window.addEventListener('error', e => console.error('Layout error', e));

customUrl

curl -I <https://your-custom-url>

S3Upload

s3:PutObject

PutObjectAcl

StopEgress

deleteRoom

egress_ended

window.__egressLogs

manifestLocation

egress_ended

egress_ended

customUrl

egress_ended

egress_started

egress_ended

egress_ended.details

error

customUrl

customUrl

window.livekitReady = true

window.livekitReady = true

console.log("connected, rendering tracks, setting window.livekitReady = true");
     window.livekitReady = true;

window.addEventListener('error', e => console.error('layout error', e));

egress_started

egress_ended

status

details

manifestLocation

backupStorageUsed

egress_ended

egress_ended

window.livekitReady

egress_ended

details

egress_ended

window.livekitReady = true

participant_left

console.log("custom layout: setting window.livekitReady = true");
     window.livekitReady = true;

window.addEventListener('error', e => console.error('layout uncaught error', e.message, e.filename, e.lineno));
     window.addEventListener('unhandledrejection', e => console.error('layout promise rejection', e.reason));

customUrl

window.livekitReady = true

loadedmetadata

playing

window.livekitReady = true

egress_started

egress_ended

window.livekitReady

egress_ended

import type { TrackReference } from '@livekit/components-react';
import {
  AudioTrack,
  LiveKitRoom,
  RoomAudioRenderer,
  useParticipants,
  useRoomContext,
  useTracks,
  VideoTrack,
} from '@livekit/components-react';
import { useEffect, useMemo, useRef, useState, useCallback } from 'react';
import { useSearchParams } from 'react-router-dom';
import { isTrackReference } from '@livekit/components-core';
import { RoomEvent, Track } from 'livekit-client';

/**
 * Utilitaire : Envoi des logs au backend pour le monitoring à distance du bot.
 */
const sendRemoteLog = async (message: string, level: 'INFO' | 'ERROR' = 'INFO') => {
  const apiUrl = import.meta.env.VITE_API_URL;
  try {
    await fetch(`${apiUrl}/public/debug/logs`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        level,
        message,
        url: window.location.href,
      }),
    });
  } catch (e) {
    console.warn('Failed to send remote log:', e);
  }
};

/**
 * Composant Stage : Gère le rendu des flux média et détecte le démarrage effectif de la vidéo.
 */
const RecordingStage = ({ onVideoStarted }: { onVideoStarted: () => void }) => {
  const room = useRoomContext();
  const participants = useParticipants();
  const screenShareTracks = useTracks([Track.Source.ScreenShare]);
  const screenShareAudioTracks = useTracks([Track.Source.ScreenShareAudio]);

  const [layoutConfig, setLayoutConfig] = useState<{
    layout: 'grid' | 'presentation';
    activeAsset: any;
  }>({ layout: 'grid', activeAsset: null });

  useEffect(() => {
    const handleMetadataUpdate = (metadata?: string) => {
      if (!metadata) return;
      try {
        const data = JSON.parse(metadata);
        setLayoutConfig({
          layout: data.layout || 'grid',
          activeAsset: data.activeAsset || null,
        });
      } catch (e) {
        sendRemoteLog(`Error parsing metadata: ${e}`, 'ERROR');
      }
    };

    handleMetadataUpdate(room.metadata);
    room.on(RoomEvent.RoomMetadataChanged, handleMetadataUpdate);
    return () => {
      room.off(RoomEvent.RoomMetadataChanged, handleMetadataUpdate);
    };
  }, [room]);

  /**
   * Sélection du présentateur : on exclut le bot (isLocal) pour éviter l'écran noir.
   * On utilise getTrackPublications().length pour le typage correct.
   */
  const mainSpeaker = useMemo(() => {
    return participants.find(
      (p) => !p.isLocal && (p.permissions?.canPublish || p.getTrackPublications().length > 0),
    );
  }, [participants]);

  const speakerTrack: TrackReference | undefined = useMemo(() => {
    if (!mainSpeaker) return undefined;
    const publication = mainSpeaker.getTrackPublication(Track.Source.Camera);
    return publication
      ? { participant: mainSpeaker, source: Track.Source.Camera, publication }
      : undefined;
  }, [mainSpeaker]);

  const presentationTrackRef = useMemo(() => {
    const ref = screenShareTracks.find(
      (t) => isTrackReference(t) && t.publication.trackName === 'presentation',
    );
    return isTrackReference(ref) ? ref : null;
  }, [screenShareTracks]);

  const presentationAudioTrackRef = useMemo(() => {
    const ref = screenShareAudioTracks.find(
      (t) => isTrackReference(t) && t.publication.trackName === 'presentation_audio',
    );
    return isTrackReference(ref) ? ref : null;
  }, [screenShareAudioTracks]);

  const isPresentation = layoutConfig.layout === 'presentation' && layoutConfig.activeAsset;

  return (
    <div className="w-full h-full bg-black overflow-hidden relative border-none select-none">
      <div id="egress-status" style={{ display: 'none' }}>
        {mainSpeaker ? 'connected_to_speaker' : 'waiting_for_speaker'}
      </div>

      {/* Calque Présentation */}
      <div
        className={`absolute inset-0 transition-opacity duration-700 ${
          isPresentation ? 'opacity-100 z-10' : 'opacity-0 z-0'
        }`}
      >
        {isPresentation && presentationTrackRef?.publication.isSubscribed && (
          <>
            <VideoTrack
              trackRef={presentationTrackRef}
              className="w-full h-full object-contain"
              onLoadedMetadata={onVideoStarted}
            />
            {presentationAudioTrackRef?.publication.isSubscribed && (
              <AudioTrack trackRef={presentationAudioTrackRef} />
            )}
          </>
        )}
      </div>

      {/* Calque Speaker */}
      <div
        className={`transition-all duration-700 ease-in-out ${
          isPresentation
            ? 'absolute top-4 right-4 w-80 aspect-video z-50 rounded-2xl shadow-2xl overflow-hidden border-2 border-white/20'
            : 'relative w-full h-full z-20 flex items-center justify-center p-4'
        }`}
      >
        {speakerTrack ? (
          <VideoTrack
            trackRef={speakerTrack}
            className="w-full h-full object-cover rounded-xl"
            onLoadedMetadata={onVideoStarted}
          />
        ) : (
          <div className="text-gray-500 font-medium text-sm">Attente du flux caméra...</div>
        )}
      </div>
    </div>
  );
};

/**
 * Page de vue pour l'enregistrement LiveKit.
 */
export default function LiveKitRecordingViewPage() {
  const [searchParams] = useSearchParams();
  const token = searchParams.get('token');

  // On priorise l'URL passée par LiveKit Cloud dans la query string
  const serverUrl = searchParams.get('url') || import.meta.env.VITE_LIVEKIT_WS_URL;

  const signaled = useRef(false);
  const signalIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);

  /**
   * Fonction "Nucleaire" : Déclenche et maintient le signal READY pour le moteur d'Egress.
   */
  const startPersistentSignal = useCallback(() => {
    if (signaled.current) return;
    signaled.current = true;

    // Log explicite pour les outils internes de LiveKit Cloud
    console.log('custom layout: setting window.livekitReady = true');
    sendRemoteLog('RECORDER_EVENT: Signal loop started.');

    signalIntervalRef.current = setInterval(() => {
      (window as any).livekitReady = true;
      (globalThis as any).livekitReady = true;
      // Signal via attribut DOM pour une détection maximale
      document.body.setAttribute('data-livekit-ready', 'true');
    }, 500);

    console.log('BOT_SIGNAL: READY');
  }, []);

  useEffect(() => {
    (window as any).livekitReady = false;
    sendRemoteLog('RECORDER_EVENT: Component mounted.');

    // Capture des erreurs recommandée par l'IA LiveKit Assistant
    const handleGlobalError = (e: ErrorEvent) => {
      console.error('layout uncaught error', e.message, e.filename, e.lineno);
      sendRemoteLog(`JS_CRITICAL_ERROR: ${e.message}`, 'ERROR');
    };

    const handlePromiseRejection = (e: PromiseRejectionEvent) => {
      console.error('layout promise rejection', e.reason);
      sendRemoteLog(`PROMISE_REJECTION: ${e.reason}`, 'ERROR');
    };

    window.addEventListener('error', handleGlobalError);
    window.addEventListener('unhandledrejection', handlePromiseRejection);

    // Parachute de sécurité après 15s : on force le signal si aucun média n'est détecté
    const safetyTimeout = setTimeout(() => {
      if (!signaled.current) {
        sendRemoteLog('RECORDER_WARN: 15s Safety timeout. Forcing readiness signal.', 'ERROR');
        startPersistentSignal();
      }
    }, 15000);

    return () => {
      window.removeEventListener('error', handleGlobalError);
      window.removeEventListener('unhandledrejection', handlePromiseRejection);
      clearTimeout(safetyTimeout);
      if (signalIntervalRef.current) clearInterval(signalIntervalRef.current);
    };
  }, [startPersistentSignal]);

  const handleOnConnected = () => {
    sendRemoteLog('RECORDER_EVENT: WebRTC Connected.');
    // On peut aussi déclencher ici si on veut un signal dès la connexion réseau
  };

  if (!token) {
    return (
      <div className="bg-black text-white h-screen flex items-center justify-center">
        Démarrage de l'enregistreur : Token manquant.
      </div>
    );
  }

  return (
    <LiveKitRoom
      token={token}
      serverUrl={serverUrl}
      connect={true}
      audio={false}
      video={false}
      onConnected={handleOnConnected}
      onDisconnected={() => {
        sendRemoteLog('RECORDER_ERROR: WebRTC Disconnected.', 'ERROR');
        if (signalIntervalRef.current) clearInterval(signalIntervalRef.current);
      }}
    >
      <div
        id="capture-area"
        style={{
          width: '1280px',
          height: '720px',
          backgroundColor: '#000',
          position: 'relative',
          overflow: 'hidden',
        }}
      >
        <RoomAudioRenderer />
        <RecordingStage onVideoStarted={startPersistentSignal} />
      </div>
    </LiveKitRoom>
  );
}

window.livekitReady

globalThis

onLoadedMetadata

onLoadedMetadata

playing

requestVideoFrameCallback

window.notifyLivekitEgressReady = () => { window.livekitReady = true; };

playing

custom_base_url

recorder: true

canSubscribe: true

roomJoin: true

BOT_SIGNAL: READY

egress_ended

custom_base_url

onLoadedMetadata

startPersistentSignal

playing

egress_ended

package io.welya.api.service.livekit;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import io.livekit.server.AudioMixing;
import io.livekit.server.EgressServiceClient;
import io.livekit.server.EncodedOutputs;
import io.livekit.server.RoomServiceClient;
import io.welya.api.config.LiveKitProperties;
import io.welya.api.config.R2Properties;
import io.welya.api.exception.WelyaException;
import livekit.LivekitEgress;
import livekit.LivekitModels;
import livekit.LivekitRoom;
import okhttp3.ResponseBody;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import retrofit2.Call;
import retrofit2.Response;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.*;

@Service
@Profile("!test")
public class LiveKitGatewayImpl implements LiveKitGateway {

    private static final Logger LOGGER = LoggerFactory.getLogger(LiveKitGatewayImpl.class);
    private static final String LAYOUT_SCREEN_SHARE = "screen-share";
    private static final String CAN_SUBSCRIBE = "canSubscribe";
    private static final String CAN_PUBLISH = "canPublish";
    private static final String CAN_PUBLISH_DATA = "canPublishData";
    private static final String ROOM_ADMIN = "roomAdmin";

    private final RoomServiceClient roomServiceClient;
    private final EgressServiceClient egressClient;
    private final LiveKitProperties liveKitProperties;
    private final R2Properties r2Properties;
    private final String hlsBucketName;
    private final String mp4BucketName;
    private final ObjectMapper objectMapper;


    public LiveKitGatewayImpl(RoomServiceClient roomServiceClient,
                              EgressServiceClient egressClient,
                              LiveKitProperties liveKitProperties,
                              R2Properties r2Properties,
                              @Value("${cloudflare.r2.buckets.hls-bucket-name}") String hlsBucketName,
                              @Value("${cloudflare.r2.buckets.mp4-bucket-name}") String mp4BucketName,
                              ObjectMapper objectMapper) {
        this.roomServiceClient = roomServiceClient;
        this.egressClient = egressClient;
        this.liveKitProperties = liveKitProperties;
        this.r2Properties = r2Properties;
        this.hlsBucketName = hlsBucketName;
        this.mp4BucketName = mp4BucketName;
        this.objectMapper = objectMapper;
    }

    @Override
    public String generateToken(String roomName, String identity, Role role, Map<String, String> metadata) {
        Map<String, Object> videoGrantMap = getRolesMap(roomName, role);
        Instant nowInstant = Instant.now();
        Instant expirationInstant = nowInstant.plusSeconds(2L * 60L * 60L);

        String metadataJson;
        try {
            metadataJson = objectMapper.writeValueAsString(metadata);
        } catch (JsonProcessingException exception) {
            throw new WelyaException("Failed to serialize token metadata", exception);
        }

        return Jwts.builder()
                .header().add("typ", "JWT")
                .and()
                .issuer(liveKitProperties.getApiKey())
                .subject(identity)
                .issuedAt(Date.from(nowInstant))
                .notBefore(Date.from(nowInstant.minusSeconds(5)))
                .id(UUID.randomUUID().toString())
                .expiration(Date.from(expirationInstant))
                .claim("video", videoGrantMap)
                .claim("metadata", metadataJson)
                .claim("name", metadata.getOrDefault("displayName", identity))
                .signWith(Keys.hmacShaKeyFor(liveKitProperties.getApiSecret().getBytes(StandardCharsets.UTF_8)))
                .compact();
    }

    @Override
    public void createRoom(String roomName) throws IOException {
        Call<LivekitModels.Room> call = roomServiceClient.createRoom(roomName);
        LivekitModels.Room body = executeCall(call);
        if (body == null) {
            throw new IOException("LiveKit createRoom returned empty body");
        }
    }

    @Override
    public List<LivekitModels.ParticipantInfo> listParticipants(String roomName) throws IOException {
        Call<List<LivekitModels.ParticipantInfo>> call = roomServiceClient.listParticipants(roomName);
        List<LivekitModels.ParticipantInfo> body = executeCall(call);
        if (body == null) {
            return List.of();
        }
        return body.stream()
                .sorted(Comparator.comparing(LivekitModels.ParticipantInfo::getIdentity, Comparator.nullsLast(String::compareTo)))
                .toList();
    }

    @Override
    public void removeParticipant(String roomName, String participantIdentity) throws IOException {
        Call<Void> call = roomServiceClient.removeParticipant(roomName, participantIdentity);
        executeExpectNoBody(call);
    }

    @Override
    public void muteTrack(String roomName, String participantIdentity, String trackSid, boolean muted) throws IOException {
        Call<LivekitModels.TrackInfo> call = roomServiceClient.mutePublishedTrack(roomName, participantIdentity, trackSid, muted);
        executeCall(call);
    }

   
    private static <T> T executeCall(Call<T> call) throws IOException {
        Response<T> response = call.execute();
        if (!response.isSuccessful()) {
            String errorBodyContent = null;
            try (ResponseBody errorBody = response.errorBody()) {
                if (errorBody != null) {
                    errorBodyContent = errorBody.string();
                }
            } catch (IOException exception) {
                LOGGER.warn("Failed to read error body during LiveKit API call");
            }
            StringBuilder messageBuilder = new StringBuilder("LiveKit API error: HTTP ")
                    .append(response.code())
                    .append(" - ");
            messageBuilder.append(response.message());
            if (errorBodyContent != null && !errorBodyContent.isBlank()) {
                messageBuilder.append(" | body=").append(errorBodyContent);
            }
            throw new IOException(messageBuilder.toString());
        }
        return response.body();
    }

    private static void executeExpectNoBody(Call<Void> call) throws IOException {
        Response<Void> response = call.execute();
        if (!response.isSuccessful()) {
            String errorBodyContent = null;
            try (ResponseBody errorBody = response.errorBody()) {
                if (errorBody != null) {
                    errorBodyContent = errorBody.string();
                }
            } catch (IOException exception) {
                LOGGER.warn("Failed to read error body during LiveKit API call (expect no body)");
            }
            StringBuilder messageBuilder = new StringBuilder("LiveKit API error on removeParticipant: HTTP ")
                    .append(response.code())
                    .append(" - ");
            messageBuilder.append(response.message());
            if (errorBodyContent != null && !errorBodyContent.isBlank()) {
                messageBuilder.append(" | body=").append(errorBodyContent);
            }
            throw new IOException(messageBuilder.toString());
        }
    }

    private static Map<String, Object> getRolesMap(String roomName, Role role) {
        Map<String, Object> videoGrantMap = new HashMap<>();
        videoGrantMap.put("room", roomName);
        videoGrantMap.put("roomJoin", true);
        switch (role) {
            case VIEWER -> {
                videoGrantMap.put(CAN_SUBSCRIBE, true);
                videoGrantMap.put(CAN_PUBLISH, false);
                videoGrantMap.put(CAN_PUBLISH_DATA, false);
            }
            case SPEAKER -> {
                videoGrantMap.put(CAN_SUBSCRIBE, true);
                videoGrantMap.put(CAN_PUBLISH, true);
                videoGrantMap.put(CAN_PUBLISH_DATA, true);
            }
            case MODERATOR -> {
                videoGrantMap.put(CAN_SUBSCRIBE, true);
                videoGrantMap.put(CAN_PUBLISH, false);
                videoGrantMap.put(CAN_PUBLISH_DATA, false);
                videoGrantMap.put(ROOM_ADMIN, true);
            }
            case ADMIN -> {
                videoGrantMap.put(CAN_SUBSCRIBE, true);
                videoGrantMap.put(CAN_PUBLISH, true);
                videoGrantMap.put(CAN_PUBLISH_DATA, true);
                videoGrantMap.put(ROOM_ADMIN, true);
            }
        }
        return videoGrantMap;
    }

    @Override
    public void updateRoomMetadata(String roomName, String metadata) throws IOException {
        var request = LivekitRoom.UpdateRoomMetadataRequest.newBuilder()
                .setRoom(roomName)
                .setMetadata(metadata)
                .build();
        Call<LivekitModels.Room> call = roomServiceClient.updateRoomMetadata(request.getRoom(), request.getMetadata());
        executeCall(call);
    }

    @Override
    public String generateRecorderToken(String roomName) {
        Map<String, Object> videoGrantMap = new HashMap<>();
        videoGrantMap.put("room", roomName);
        videoGrantMap.put("roomJoin", true);
        videoGrantMap.put("recorder", true);
        videoGrantMap.put(ROOM_ADMIN, true);
        videoGrantMap.put(CAN_PUBLISH, false);
        videoGrantMap.put(CAN_SUBSCRIBE, true);
        videoGrantMap.put(CAN_PUBLISH_DATA, false);

        Instant nowInstant = Instant.now();
        Instant expirationInstant = nowInstant.plusSeconds(14400);

        Map<String, String> metadataMap = new HashMap<>();
        metadataMap.put("displayName", "Welya Recorder");
        metadataMap.put("is_recorder", "true");
        metadataMap.put("role", "RECORDER");

        String metadataJson;
        try {
            metadataJson = objectMapper.writeValueAsString(metadataMap);
        } catch (JsonProcessingException exception) {
            throw new WelyaException("Failed to serialize recorder metadata", exception);
        }
        return Jwts.builder()
                .header().add("typ", "JWT")
                .and()
                .issuer(liveKitProperties.getApiKey())
                .subject("RECORDER_BOT")
                .issuedAt(Date.from(nowInstant))
                .notBefore(Date.from(nowInstant.minusSeconds(5)))
                .id(UUID.randomUUID().toString())
                .expiration(Date.from(expirationInstant))
                .claim("video", videoGrantMap)
                .claim("metadata", metadataJson)
                .claim("name", "Welya Recorder")
                .signWith(Keys.hmacShaKeyFor(liveKitProperties.getApiSecret().getBytes(StandardCharsets.UTF_8)))
                .compact();
    }
}