@naviedu/room-platform-react 0.0.35 → 0.0.36

package/README.md

@@ -97,6 +97,9 @@ stage keeps its waiting state and never promotes a student camera. The local
 sidebar preview is hidden only when that selected moderator camera is local;
 its existing desktop breakpoint remains unchanged.
 
+The public room keeps one canonical local camera track. It may be preview-only
+before publication, and preview visibility never grants `media:publish_video`.
+
 ### Error and lifecycle callbacks
 
 ```tsx

package/index.d.ts

@@ -260,7 +260,6 @@ declare type RoomPlatformContextValue = {
     isActionPending: (name: RoomPlatformActionName, payload?: Record<string, string>) => boolean;
     isLocalMediaPending: (kind: RoomPlatformLocalMediaKind) => boolean;
     localCameraTrack: LocalVideoTrack | null;
-    localPreviewTrack: LocalVideoTrack | null;
     localMedia: RoomPlatformLocalMediaState;
     performAction: (name: RoomPlatformActionName, payload?: Record<string, string>) => Promise<void>;
     room: Room | null;
@@ -398,9 +397,9 @@ export declare type RoomPlatformLocalMediaKind = 'microphone' | 'camera' | 'scre
 
 declare type RoomPlatformLocalMediaState = Record<RoomPlatformLocalMediaKind, boolean>;
 
-export declare function RoomPlatformLocalPreview({ trackRef, localPreviewTrack, }: {
+export declare function RoomPlatformLocalPreview({ trackRef, localTrack, }: {
     trackRef?: TrackReference;
-    localPreviewTrack?: LocalVideoTrack | null;
+    localTrack?: LocalVideoTrack | null;
 }): JSX.Element;
 
 export declare function RoomPlatformMediaRuntime({ children }: PropsWithChildren): JSX.Element;

package/index.esm.js

@@ -3,7 +3,7 @@ import * as React from 'react';
 import { Component, useContext, createContext, forwardRef, useState, useRef, useEffect, useLayoutEffect, useMemo, useCallback, useId } from 'react';
 import { Slot, AlertDialog as AlertDialog$1, Dialog as Dialog$1, Select as Select$1, Tabs as Tabs$1, Tooltip as Tooltip$1 } from 'radix-ui';
 import { Minimize2, Maximize2, XIcon, ChevronDownIcon, CheckIcon, ChevronUpIcon, Loader2Icon, PhoneOff, Bell, PhoneCall, Hand, VideoOff, ChevronUp, SunDim, Images, ImageUp, Plus, Trash2, Settings, ArrowLeftRight, Monitor, LogOut, Mic, Camera, X, ChevronLeft, ChevronRight, PanelRightOpen, PanelRightClose, Power, Check } from 'lucide-react';
-import { RoomEvent, Track, createLocalVideoTrack, Room, DataPacket_Kind } from 'livekit-client';
+import { TrackEvent, RoomEvent, createLocalVideoTrack, Track, Room, DataPacket_Kind } from 'livekit-client';
 import { io } from 'socket.io-client';
 import { createPortal } from 'react-dom';
 import { toast, Toaster } from 'sonner';
@@ -13934,6 +13934,9 @@ var localMediaCapabilities = {
     camera: 'media:publish_video',
     screenShare: 'media:share_screen'
 };
+var canPreviewCamera = function(capabilities) {
+    return capabilities.includes('media:publish_video') || capabilities.includes('room:speak_request');
+};
 var RoomPlatformContext = /*#__PURE__*/ createContext(undefined);
 var emptyLocalMediaState = {
     camera: false,
@@ -14041,13 +14044,6 @@ var localMediaStateOf = function(room) {
         screenShare: room.localParticipant.isScreenShareEnabled
     };
 };
-var localCameraTrackOf = function(room) {
-    var _ref;
-    var _getTrackPublication_call;
-    var getTrackPublication = room.localParticipant.getTrackPublication;
-    if (typeof getTrackPublication !== 'function') return null;
-    return (_ref = (_getTrackPublication_call = getTrackPublication.call(room.localParticipant, Track.Source.Camera)) === null || _getTrackPublication_call === void 0 ? void 0 : _getTrackPublication_call.track) !== null && _ref !== void 0 ? _ref : null;
-};
 var roleFromMetadata = function(metadata) {
     try {
         var parsed = JSON.parse(metadata !== null && metadata !== void 0 ? metadata : '{}');
@@ -14080,16 +14076,15 @@ function RoomPlatformProvider(param) {
     var _useState3 = _sliced_to_array$o(useState(), 2), controlState = _useState3[0], setControlState = _useState3[1];
     var _useState4 = _sliced_to_array$o(useState(), 2), error = _useState4[0], setError = _useState4[1];
     var _useState5 = _sliced_to_array$o(useState(null), 2), localCameraTrack = _useState5[0], setLocalCameraTrack = _useState5[1];
-    var _useState6 = _sliced_to_array$o(useState(null), 2), localPreviewTrack = _useState6[0], setLocalPreviewTrack = _useState6[1];
-    var _useState7 = _sliced_to_array$o(useState(emptyLocalMediaState), 2), localMedia = _useState7[0], setLocalMedia = _useState7[1];
-    var _useState8 = _sliced_to_array$o(useState(null), 2), integrations = _useState8[0], setIntegrations = _useState8[1];
-    var _useState9 = _sliced_to_array$o(useState(), 2), privateRoom = _useState9[0], setPrivateRoom = _useState9[1];
-    var _useState10 = _sliced_to_array$o(useState(), 2), privateRoomConnection = _useState10[0], setPrivateRoomConnection = _useState10[1];
-    var _useState11 = _sliced_to_array$o(useState(false), 2), privateMediaRestorePending = _useState11[0], setPrivateMediaRestorePending = _useState11[1];
-    var _useState12 = _sliced_to_array$o(useState([]), 2), pendingActionKeys = _useState12[0], setPendingActionKeys = _useState12[1];
-    var _useState13 = _sliced_to_array$o(useState([]), 2), pendingLocalMediaKinds = _useState13[0], setPendingLocalMediaKinds = _useState13[1];
-    var _useState14 = _sliced_to_array$o(useState(null), 2), room = _useState14[0], setRoom = _useState14[1];
-    var _useState15 = _sliced_to_array$o(useState('connecting'), 2), status = _useState15[0], setStatus = _useState15[1];
+    var _useState6 = _sliced_to_array$o(useState(emptyLocalMediaState), 2), localMedia = _useState6[0], setLocalMedia = _useState6[1];
+    var _useState7 = _sliced_to_array$o(useState(null), 2), integrations = _useState7[0], setIntegrations = _useState7[1];
+    var _useState8 = _sliced_to_array$o(useState(), 2), privateRoom = _useState8[0], setPrivateRoom = _useState8[1];
+    var _useState9 = _sliced_to_array$o(useState(), 2), privateRoomConnection = _useState9[0], setPrivateRoomConnection = _useState9[1];
+    var _useState10 = _sliced_to_array$o(useState(false), 2), privateMediaRestorePending = _useState10[0], setPrivateMediaRestorePending = _useState10[1];
+    var _useState11 = _sliced_to_array$o(useState([]), 2), pendingActionKeys = _useState11[0], setPendingActionKeys = _useState11[1];
+    var _useState12 = _sliced_to_array$o(useState([]), 2), pendingLocalMediaKinds = _useState12[0], setPendingLocalMediaKinds = _useState12[1];
+    var _useState13 = _sliced_to_array$o(useState(null), 2), room = _useState13[0], setRoom = _useState13[1];
+    var _useState14 = _sliced_to_array$o(useState('connecting'), 2), status = _useState14[0], setStatus = _useState14[1];
     var isMountedRef = useRef(false);
     var accessRef = useRef(undefined);
     var controlStateRef = useRef(undefined);
@@ -14099,7 +14094,14 @@ function RoomPlatformProvider(param) {
     var pendingActionsRef = useRef(new Map());
     var pendingLocalMediaRef = useRef(new Map());
     var hasFirstSuccessfulConnectionRef = useRef(false);
-    var localPreviewTrackRef = useRef(null);
+    var cameraDesiredRef = useRef(false);
+    var canonicalCameraTrackRef = useRef(null);
+    var cameraTrackEndedHandlerRef = useRef(undefined);
+    var cameraCreationRef = useRef(undefined);
+    var cameraTransitionRef = useRef(Promise.resolve());
+    var cameraRevisionRef = useRef(0);
+    var accessGenerationRef = useRef(0);
+    var handleCameraEndedRef = useRef(undefined);
     var initialLaunchTokenRef = useRef(launchToken);
     var recoveryRef = useRef(undefined);
     var roomConnectionRef = useRef(null);
@@ -14119,9 +14121,15 @@ function RoomPlatformProvider(param) {
     var onErrorRef = useRef(onError);
     var onLifecycleEventRef = useRef(onLifecycleEvent);
     var onLaunchTicketRequiredRef = useRef(onLaunchTicketRequired);
-    onErrorRef.current = onError;
-    onLifecycleEventRef.current = onLifecycleEvent;
-    onLaunchTicketRequiredRef.current = onLaunchTicketRequired;
+    useEffect(function() {
+        onErrorRef.current = onError;
+        onLifecycleEventRef.current = onLifecycleEvent;
+        onLaunchTicketRequiredRef.current = onLaunchTicketRequired;
+    }, [
+        onError,
+        onLaunchTicketRequired,
+        onLifecycleEvent
+    ]);
     var isLifecycleActive = useCallback(function(lifecycle) {
         return isMountedRef.current && lifecycleRef.current === lifecycle;
     }, []);
@@ -14181,21 +14189,23 @@ function RoomPlatformProvider(param) {
     }, []);
     var syncControlState = useCallback(function() {
         return _async_to_generator$k(function() {
-            var sync;
+            var currentAccess, generation, inFlight, sync, _controlStateSyncRef_current;
             return _ts_generator$k(this, function(_state) {
                 switch(_state.label){
                     case 0:
-                        if (controlStateSyncRef.current !== undefined) return [
+                        currentAccess = accessRef.current;
+                        generation = accessGenerationRef.current;
+                        inFlight = controlStateSyncRef.current;
+                        if ((inFlight === null || inFlight === void 0 ? void 0 : inFlight.generation) === generation) return [
                             2,
-                            controlStateSyncRef.current
+                            inFlight.promise
                         ];
                         sync = function() {
                             return _async_to_generator$k(function() {
-                                var currentAccess, response, body, syncError;
+                                var response, body, syncError;
                                 return _ts_generator$k(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
-                                            currentAccess = accessRef.current;
                                             if (!currentAccess) return [
                                                 2,
                                                 false
@@ -14237,7 +14247,7 @@ function RoomPlatformProvider(param) {
                                             body = unwrapGatewayResponse.apply(void 0, [
                                                 _state.sent()
                                             ]);
-                                            if (body.roomId === currentAccess.roomId) {
+                                            if (accessRef.current === currentAccess && accessGenerationRef.current === generation && body.roomId === currentAccess.roomId) {
                                                 applyPrivateRoomProjection(body, true);
                                                 applyControlState(body.state, true);
                                                 return [
@@ -14251,7 +14261,7 @@ function RoomPlatformProvider(param) {
                                             ];
                                         case 6:
                                             syncError = _state.sent();
-                                            reportError(syncError, {
+                                            if (accessRef.current === currentAccess && accessGenerationRef.current === generation) reportError(syncError, {
                                                 recoverable: true,
                                                 scope: 'connection'
                                             });
@@ -14268,7 +14278,10 @@ function RoomPlatformProvider(param) {
                                 });
                             })();
                         }();
-                        controlStateSyncRef.current = sync;
+                        controlStateSyncRef.current = {
+                            generation: generation,
+                            promise: sync
+                        };
                         _state.label = 1;
                     case 1:
                         _state.trys.push([
@@ -14287,7 +14300,7 @@ function RoomPlatformProvider(param) {
                             _state.sent()
                         ];
                     case 3:
-                        if (controlStateSyncRef.current === sync) controlStateSyncRef.current = undefined;
+                        if (((_controlStateSyncRef_current = controlStateSyncRef.current) === null || _controlStateSyncRef_current === void 0 ? void 0 : _controlStateSyncRef_current.promise) === sync) controlStateSyncRef.current = undefined;
                         return [
                             7
                         ];
@@ -14304,6 +14317,494 @@ function RoomPlatformProvider(param) {
         applyPrivateRoomProjection,
         reportError
     ]);
+    var enqueueCameraTransition = useCallback(function(transition) {
+        var next = cameraTransitionRef.current.then(transition, transition);
+        cameraTransitionRef.current = next.catch(function() {
+            return undefined;
+        });
+        return next;
+    }, []);
+    var cameraRoomIsPrivate = useCallback(function(currentRoom) {
+        var actorId = externalActorIdFromMetadata$2(currentRoom.localParticipant.metadata);
+        var currentPrivateRoom = privateRoomRef.current;
+        return Boolean((currentPrivateRoom === null || currentPrivateRoom === void 0 ? void 0 : currentPrivateRoom.status) === 'active' && actorId && (currentPrivateRoom.callerExternalActorId === actorId || currentPrivateRoom.studentExternalActorId === actorId));
+    }, []);
+    var cameraShouldBeForced = useCallback(function(currentRoom) {
+        var _controlStateRef_current;
+        return ((_controlStateRef_current = controlStateRef.current) === null || _controlStateRef_current === void 0 ? void 0 : _controlStateRef_current.monitorActive) === true && roleFromMetadata(currentRoom.localParticipant.metadata) === 'student';
+    }, []);
+    var cameraCanPublish = useCallback(function(currentRoom, currentAccess) {
+        var _controlStateRef_current;
+        var activeSpeaker = ((_controlStateRef_current = controlStateRef.current) === null || _controlStateRef_current === void 0 ? void 0 : _controlStateRef_current.activeSpeakerParticipantIdentity) === currentAccess.liveKit.participantIdentity;
+        return currentAccess.capabilities.includes(localMediaCapabilities.camera) || activeSpeaker || cameraShouldBeForced(currentRoom);
+    }, [
+        cameraShouldBeForced
+    ]);
+    var cameraShouldCapture = useCallback(function(currentRoom, currentAccess) {
+        return !cameraRoomIsPrivate(currentRoom) && (cameraShouldBeForced(currentRoom) || cameraDesiredRef.current && canPreviewCamera(currentAccess.capabilities));
+    }, [
+        cameraRoomIsPrivate,
+        cameraShouldBeForced
+    ]);
+    var cameraShouldPublish = useCallback(function(currentRoom, currentAccess) {
+        return cameraShouldCapture(currentRoom, currentAccess) && cameraCanPublish(currentRoom, currentAccess);
+    }, [
+        cameraCanPublish,
+        cameraShouldCapture
+    ]);
+    var removeCanonicalCameraTrack = useCallback(function(track, stop) {
+        if (cameraTrackEndedHandlerRef.current) track.off(TrackEvent.Ended, cameraTrackEndedHandlerRef.current);
+        cameraTrackEndedHandlerRef.current = undefined;
+        if (canonicalCameraTrackRef.current === track) canonicalCameraTrackRef.current = null;
+        if (stop) track.stop();
+        if (isMountedRef.current) {
+            setLocalCameraTrack(null);
+            setLocalMedia(function(current) {
+                return _object_spread_props$b(_object_spread$d({}, current), {
+                    camera: false
+                });
+            });
+        }
+    }, []);
+    var ensureLocalCameraTrack = useCallback(function(lifecycle, revision, generation, currentRoom) {
+        var _roomConnectionRef_current;
+        var existing = canonicalCameraTrackRef.current;
+        if (existing) return Promise.resolve(existing);
+        var currentAccess = accessRef.current;
+        if (!isLifecycleActive(lifecycle) || !currentAccess || !cameraShouldCapture(currentRoom, currentAccess) || ((_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.room) !== currentRoom) return Promise.resolve(null);
+        var pendingCreation = cameraCreationRef.current;
+        if (pendingCreation !== undefined) return pendingCreation.then(function(track) {
+            if (track) return track;
+            if (cameraCreationRef.current === pendingCreation) cameraCreationRef.current = undefined;
+            return null;
+        });
+        var creation = function() {
+            return _async_to_generator$k(function() {
+                var _roomConnectionRef_current, created, stillCurrent, ended, creationError;
+                return _ts_generator$k(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                2,
+                                ,
+                                3
+                            ]);
+                            return [
+                                4,
+                                createLocalVideoTrack()
+                            ];
+                        case 1:
+                            created = _state.sent();
+                            stillCurrent = isLifecycleActive(lifecycle) && cameraRevisionRef.current === revision && accessGenerationRef.current === generation && ((_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.room) === currentRoom && accessRef.current !== undefined && cameraShouldCapture(currentRoom, accessRef.current);
+                            if (!stillCurrent) {
+                                created.stop();
+                                return [
+                                    2,
+                                    null
+                                ];
+                            }
+                            ended = function() {
+                                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                                    args[_key] = arguments[_key];
+                                }
+                                if (args.length > 0 && args[0] !== created) return;
+                                void enqueueCameraTransition(function() {
+                                    var _ref;
+                                    var _handleCameraEndedRef_current;
+                                    return (_ref = (_handleCameraEndedRef_current = handleCameraEndedRef.current) === null || _handleCameraEndedRef_current === void 0 ? void 0 : _handleCameraEndedRef_current.call(handleCameraEndedRef, lifecycle, created)) !== null && _ref !== void 0 ? _ref : Promise.resolve();
+                                });
+                            };
+                            canonicalCameraTrackRef.current = created;
+                            cameraTrackEndedHandlerRef.current = ended;
+                            created.on(TrackEvent.Ended, ended);
+                            if (isMountedRef.current) setLocalCameraTrack(created);
+                            return [
+                                2,
+                                created
+                            ];
+                        case 2:
+                            creationError = _state.sent();
+                            reportError(creationError, {
+                                recoverable: true,
+                                scope: 'media'
+                            });
+                            return [
+                                2,
+                                null
+                            ];
+                        case 3:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }();
+        cameraCreationRef.current = creation;
+        void creation.then(function() {
+            if (cameraCreationRef.current === creation) cameraCreationRef.current = undefined;
+        }, function() {
+            if (cameraCreationRef.current === creation) cameraCreationRef.current = undefined;
+        });
+        return creation;
+    }, [
+        cameraShouldCapture,
+        enqueueCameraTransition,
+        isLifecycleActive,
+        reportError
+    ]);
+    var unpublishCanonicalCamera = useCallback(function(retainForPreview) {
+        return _async_to_generator$k(function() {
+            var _roomConnectionRef_current, currentRoom, track, publication, wasPublished, unpublishError;
+            return _ts_generator$k(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        currentRoom = (_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.room;
+                        track = canonicalCameraTrackRef.current;
+                        if (!currentRoom || !track) return [
+                            2
+                        ];
+                        publication = currentRoom.localParticipant.getTrackPublication(Track.Source.Camera);
+                        wasPublished = (publication === null || publication === void 0 ? void 0 : publication.track) === track;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            4,
+                            ,
+                            5
+                        ]);
+                        if (!wasPublished) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            currentRoom.localParticipant.unpublishTrack(track, !retainForPreview)
+                        ];
+                    case 2:
+                        _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            3,
+                            5
+                        ];
+                    case 4:
+                        unpublishError = _state.sent();
+                        if (!retainForPreview) removeCanonicalCameraTrack(track, true);
+                        reportError(unpublishError, {
+                            recoverable: true,
+                            scope: 'media'
+                        });
+                        return [
+                            2
+                        ];
+                    case 5:
+                        if (!retainForPreview) removeCanonicalCameraTrack(track, !wasPublished);
+                        else if (isMountedRef.current) setLocalMedia(function(current) {
+                            return _object_spread_props$b(_object_spread$d({}, current), {
+                                camera: false
+                            });
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, [
+        removeCanonicalCameraTrack,
+        reportError
+    ]);
+    var publishCanonicalCamera = useCallback(function(lifecycle, revision, generation, currentRoom) {
+        return _async_to_generator$k(function() {
+            var _roomConnectionRef_current, currentAccess, track, publication, _roomConnectionRef_current1, latestAccess, canRetainForPreview, publication1, wasPublished, publishError, _roomConnectionRef_current2, latestAccess1, canRetain;
+            return _ts_generator$k(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        currentAccess = accessRef.current;
+                        track = canonicalCameraTrackRef.current;
+                        if (!track || !currentAccess) return [
+                            2
+                        ];
+                        if (!isLifecycleActive(lifecycle) || cameraRevisionRef.current !== revision || accessGenerationRef.current !== generation || ((_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.room) !== currentRoom || !cameraShouldPublish(currentRoom, currentAccess)) return [
+                            2
+                        ];
+                        publication = currentRoom.localParticipant.getTrackPublication(Track.Source.Camera);
+                        if ((publication === null || publication === void 0 ? void 0 : publication.track) === track) return [
+                            2
+                        ];
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            7,
+                            ,
+                            8
+                        ]);
+                        return [
+                            4,
+                            currentRoom.localParticipant.publishTrack(track)
+                        ];
+                    case 2:
+                        _state.sent();
+                        latestAccess = accessRef.current;
+                        canRetainForPreview = Boolean(latestAccess && cameraDesiredRef.current && canPreviewCamera(latestAccess.capabilities) && cameraShouldCapture(currentRoom, latestAccess));
+                        if (!(latestAccess && isLifecycleActive(lifecycle) && cameraRevisionRef.current === revision && accessGenerationRef.current === generation && !cameraShouldPublish(currentRoom, latestAccess))) return [
+                            3,
+                            4
+                        ];
+                        return [
+                            4,
+                            unpublishCanonicalCamera(canRetainForPreview)
+                        ];
+                    case 3:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                    case 4:
+                        if (!(!isLifecycleActive(lifecycle) || cameraRevisionRef.current !== revision || accessGenerationRef.current !== generation || ((_roomConnectionRef_current1 = roomConnectionRef.current) === null || _roomConnectionRef_current1 === void 0 ? void 0 : _roomConnectionRef_current1.room) !== currentRoom)) return [
+                            3,
+                            6
+                        ];
+                        publication1 = currentRoom.localParticipant.getTrackPublication(Track.Source.Camera);
+                        wasPublished = (publication1 === null || publication1 === void 0 ? void 0 : publication1.track) === track;
+                        return [
+                            4,
+                            currentRoom.localParticipant.unpublishTrack(track, !canRetainForPreview)
+                        ];
+                    case 5:
+                        _state.sent();
+                        if (!canRetainForPreview) removeCanonicalCameraTrack(track, !wasPublished);
+                        else if (isMountedRef.current) setLocalMedia(function(current) {
+                            return _object_spread_props$b(_object_spread$d({}, current), {
+                                camera: false
+                            });
+                        });
+                        return [
+                            2
+                        ];
+                    case 6:
+                        if (isMountedRef.current) setLocalMedia(function(current) {
+                            return _object_spread_props$b(_object_spread$d({}, current), {
+                                camera: true
+                            });
+                        });
+                        return [
+                            3,
+                            8
+                        ];
+                    case 7:
+                        publishError = _state.sent();
+                        latestAccess1 = accessRef.current;
+                        canRetain = isLifecycleActive(lifecycle) && latestAccess1 !== undefined && ((_roomConnectionRef_current2 = roomConnectionRef.current) === null || _roomConnectionRef_current2 === void 0 ? void 0 : _roomConnectionRef_current2.room) === currentRoom && cameraDesiredRef.current && canPreviewCamera(latestAccess1.capabilities) && cameraShouldCapture(currentRoom, latestAccess1);
+                        if (!canRetain) removeCanonicalCameraTrack(track, true);
+                        reportError(publishError, {
+                            recoverable: true,
+                            scope: 'media'
+                        });
+                        return [
+                            3,
+                            8
+                        ];
+                    case 8:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, [
+        cameraShouldCapture,
+        cameraShouldPublish,
+        isLifecycleActive,
+        removeCanonicalCameraTrack,
+        reportError,
+        unpublishCanonicalCamera
+    ]);
+    var handleCameraEnded = useCallback(function(lifecycle, endedTrack) {
+        return _async_to_generator$k(function() {
+            var _roomConnectionRef_current, _roomConnectionRef_current1, currentRoom, currentAccess, publication, revision, generation, _roomConnectionRef_current2, latestAccess, canKeepRestartedTrack, latestAccess1;
+            return _ts_generator$k(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (canonicalCameraTrackRef.current !== endedTrack || !isLifecycleActive(lifecycle)) return [
+                            2
+                        ];
+                        currentRoom = (_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.room;
+                        currentAccess = accessRef.current;
+                        if (!currentRoom || !currentAccess) return [
+                            2
+                        ];
+                        publication = currentRoom.localParticipant.getTrackPublication(Track.Source.Camera);
+                        if ((publication === null || publication === void 0 ? void 0 : publication.track) === endedTrack) return [
+                            2
+                        ];
+                        revision = cameraRevisionRef.current;
+                        generation = accessGenerationRef.current;
+                        if (!cameraShouldCapture(currentRoom, currentAccess)) {
+                            removeCanonicalCameraTrack(endedTrack, true);
+                            return [
+                                2
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            endedTrack.restartTrack()
+                        ];
+                    case 2:
+                        _state.sent();
+                        latestAccess = accessRef.current;
+                        canKeepRestartedTrack = canonicalCameraTrackRef.current === endedTrack && isLifecycleActive(lifecycle) && cameraRevisionRef.current === revision && accessGenerationRef.current === generation && ((_roomConnectionRef_current2 = roomConnectionRef.current) === null || _roomConnectionRef_current2 === void 0 ? void 0 : _roomConnectionRef_current2.room) === currentRoom && latestAccess !== undefined && cameraShouldCapture(currentRoom, latestAccess);
+                        if (canKeepRestartedTrack && isMountedRef.current) setLocalCameraTrack(endedTrack);
+                        else if (canonicalCameraTrackRef.current === endedTrack) removeCanonicalCameraTrack(endedTrack, true);
+                        return [
+                            2
+                        ];
+                    case 3:
+                        _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 4:
+                        latestAccess1 = accessRef.current;
+                        if (!(canonicalCameraTrackRef.current === endedTrack && isLifecycleActive(lifecycle) && cameraRevisionRef.current === revision && accessGenerationRef.current === generation && ((_roomConnectionRef_current1 = roomConnectionRef.current) === null || _roomConnectionRef_current1 === void 0 ? void 0 : _roomConnectionRef_current1.room) === currentRoom && latestAccess1 !== undefined && cameraShouldCapture(currentRoom, latestAccess1))) return [
+                            3,
+                            6
+                        ];
+                        removeCanonicalCameraTrack(endedTrack, true);
+                        return [
+                            4,
+                            ensureLocalCameraTrack(lifecycle, revision, generation, currentRoom)
+                        ];
+                    case 5:
+                        _state.sent();
+                        return [
+                            3,
+                            7
+                        ];
+                    case 6:
+                        if (canonicalCameraTrackRef.current === endedTrack) removeCanonicalCameraTrack(endedTrack, true);
+                        _state.label = 7;
+                    case 7:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, [
+        cameraShouldCapture,
+        ensureLocalCameraTrack,
+        isLifecycleActive,
+        removeCanonicalCameraTrack
+    ]);
+    useEffect(function() {
+        handleCameraEndedRef.current = handleCameraEnded;
+    }, [
+        handleCameraEnded
+    ]);
+    var reconcileCanonicalCamera = useCallback(function() {
+        var lifecycle = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : lifecycleRef.current, revision = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : cameraRevisionRef.current, generation = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : accessGenerationRef.current;
+        if (!lifecycle) return Promise.resolve();
+        return enqueueCameraTransition(function() {
+            return _async_to_generator$k(function() {
+                var _canonicalCameraTrackRef_current, connection, currentAccess, shouldCapture, track, _tmp;
+                return _ts_generator$k(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            connection = roomConnectionRef.current;
+                            currentAccess = accessRef.current;
+                            if (!connection || connection.disposed || !currentAccess || cameraRevisionRef.current !== revision || accessGenerationRef.current !== generation) return [
+                                2
+                            ];
+                            shouldCapture = cameraShouldCapture(connection.room, currentAccess);
+                            if (!!shouldCapture) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                unpublishCanonicalCamera(false)
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                        case 2:
+                            if (!((_canonicalCameraTrackRef_current = canonicalCameraTrackRef.current) !== null && _canonicalCameraTrackRef_current !== void 0)) return [
+                                3,
+                                3
+                            ];
+                            _tmp = _canonicalCameraTrackRef_current;
+                            return [
+                                3,
+                                5
+                            ];
+                        case 3:
+                            return [
+                                4,
+                                ensureLocalCameraTrack(lifecycle, revision, generation, connection.room)
+                            ];
+                        case 4:
+                            _tmp = _state.sent();
+                            _state.label = 5;
+                        case 5:
+                            track = _tmp;
+                            if (!track) return [
+                                2
+                            ];
+                            if (!cameraShouldPublish(connection.room, currentAccess)) return [
+                                3,
+                                7
+                            ];
+                            return [
+                                4,
+                                publishCanonicalCamera(lifecycle, revision, generation, connection.room)
+                            ];
+                        case 6:
+                            _state.sent();
+                            return [
+                                3,
+                                9
+                            ];
+                        case 7:
+                            return [
+                                4,
+                                unpublishCanonicalCamera(true)
+                            ];
+                        case 8:
+                            _state.sent();
+                            _state.label = 9;
+                        case 9:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    }, [
+        cameraShouldCapture,
+        cameraShouldPublish,
+        enqueueCameraTransition,
+        ensureLocalCameraTrack,
+        publishCanonicalCamera,
+        unpublishCanonicalCamera
+    ]);
     var disposeRoom = useCallback(function(connection) {
         var reconnectCompleted = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
         if (!connection.disposed) {
@@ -14395,7 +14896,7 @@ function RoomPlatformProvider(param) {
     ]);
     var connectLiveKit = useCallback(function(nextAccess, lifecycle) {
         return _async_to_generator$k(function() {
-            var _nextAccess_integrations, existingConnection, mediaState, createdConnection, nextRoom, connection, connection1, connectError, restorationResults, initialMediaResults, shouldCreateLocalPreview, previewTrack, previewError;
+            var _nextAccess_integrations, existingConnection, mediaState, createdConnection, nextRoom, connection, connection1, connectError, firstSuccessfulConnection, restorationResults, initialMediaResults;
             return _ts_generator$k(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -14435,8 +14936,47 @@ function RoomPlatformProvider(param) {
                                             connection.reconnecting = false;
                                             reportLifecycleEvent('reconnect.succeeded');
                                         }
-                                        void syncControlState();
-                                        if (isMountedRef.current && !connection.disposed) setStatus('connected');
+                                        var _$lifecycle = lifecycleRef.current;
+                                        var generation = accessGenerationRef.current;
+                                        void function() {
+                                            return _async_to_generator$k(function() {
+                                                var _tmp;
+                                                return _ts_generator$k(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            _tmp = !_$lifecycle;
+                                                            if (_tmp) return [
+                                                                3,
+                                                                2
+                                                            ];
+                                                            return [
+                                                                4,
+                                                                syncControlState()
+                                                            ];
+                                                        case 1:
+                                                            _tmp = !_state.sent();
+                                                            _state.label = 2;
+                                                        case 2:
+                                                            if (_tmp) return [
+                                                                2
+                                                            ];
+                                                            if (generation !== accessGenerationRef.current || connection.disposed) return [
+                                                                2
+                                                            ];
+                                                            return [
+                                                                4,
+                                                                reconcileCanonicalCamera(_$lifecycle, cameraRevisionRef.current, generation)
+                                                            ];
+                                                        case 3:
+                                                            _state.sent();
+                                                            if (isMountedRef.current && !connection.disposed) setStatus('connected');
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            })();
+                                        }();
                                     },
                                     disconnected: function() {
                                         for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
@@ -14493,7 +15033,7 @@ function RoomPlatformProvider(param) {
                                     },
                                     localMediaChanged: function() {
                                         if (isMountedRef.current && !connection.disposed) {
-                                            setLocalCameraTrack(localCameraTrackOf(connection.room));
+                                            setLocalCameraTrack(canonicalCameraTrackRef.current);
                                             setLocalMedia(localMediaStateOf(connection.room));
                                         }
                                     },
@@ -14569,7 +15109,13 @@ function RoomPlatformProvider(param) {
                                 2
                             ];
                         }
-                        if (!(hasFirstSuccessfulConnectionRef.current && mediaState)) return [
+                        firstSuccessfulConnection = !hasFirstSuccessfulConnectionRef.current;
+                        accessRef.current = nextAccess;
+                        accessGenerationRef.current += 1;
+                        if (firstSuccessfulConnection) cameraDesiredRef.current = nextAccess.capabilities.includes(localMediaCapabilities.camera) || nextAccess.capabilities.includes('room:speak_request');
+                        setIntegrations((_nextAccess_integrations = nextAccess.integrations) !== null && _nextAccess_integrations !== void 0 ? _nextAccess_integrations : null);
+                        setAccess(nextAccess);
+                        if (!(!firstSuccessfulConnection && mediaState)) return [
                             3,
                             6
                         ];
@@ -14577,7 +15123,6 @@ function RoomPlatformProvider(param) {
                             4,
                             Promise.allSettled([
                                 connection1.room.localParticipant.setMicrophoneEnabled(mediaState.microphone),
-                                connection1.room.localParticipant.setCameraEnabled(mediaState.camera),
                                 connection1.room.localParticipant.setScreenShareEnabled(mediaState.screenShare)
                             ])
                         ];
@@ -14597,8 +15142,7 @@ function RoomPlatformProvider(param) {
                         return [
                             4,
                             Promise.allSettled([
-                                connection1.room.localParticipant.setMicrophoneEnabled(nextAccess.capabilities.includes(localMediaCapabilities.microphone)),
-                                connection1.room.localParticipant.setCameraEnabled(nextAccess.capabilities.includes(localMediaCapabilities.camera))
+                                connection1.room.localParticipant.setMicrophoneEnabled(nextAccess.capabilities.includes(localMediaCapabilities.microphone))
                             ])
                         ];
                     case 7:
@@ -14617,58 +15161,23 @@ function RoomPlatformProvider(param) {
                                 2
                             ];
                         }
-                        shouldCreateLocalPreview = !hasFirstSuccessfulConnectionRef.current && !localPreviewTrackRef.current && nextAccess.capabilities.includes('room:speak_request') && !nextAccess.capabilities.includes(localMediaCapabilities.camera);
-                        if (!shouldCreateLocalPreview) return [
-                            3,
-                            12
+                        hasFirstSuccessfulConnectionRef.current = true;
+                        setActiveDevices(activeDevicesStateOf(connection1.room));
+                        setLocalCameraTrack(canonicalCameraTrackRef.current);
+                        setLocalMedia(mediaState !== null && mediaState !== void 0 ? mediaState : localMediaStateOf(connection1.room));
+                        return [
+                            4,
+                            syncControlState()
                         ];
-                        _state.label = 9;
                     case 9:
-                        _state.trys.push([
-                            9,
-                            11,
-                            ,
-                            12
-                        ]);
+                        _state.sent();
                         return [
                             4,
-                            createLocalVideoTrack()
+                            reconcileCanonicalCamera(lifecycle, cameraRevisionRef.current, accessGenerationRef.current)
                         ];
                     case 10:
-                        previewTrack = _state.sent();
-                        if (!isLifecycleActive(lifecycle) || connection1.disposed) {
-                            previewTrack.stop();
-                            disposeRoom(connection1, true);
-                            return [
-                                2
-                            ];
-                        }
-                        localPreviewTrackRef.current = previewTrack;
-                        setLocalPreviewTrack(previewTrack);
-                        return [
-                            3,
-                            12
-                        ];
-                    case 11:
-                        previewError = _state.sent();
-                        reportError(previewError, {
-                            recoverable: true,
-                            scope: 'media'
-                        });
-                        return [
-                            3,
-                            12
-                        ];
-                    case 12:
-                        accessRef.current = nextAccess;
-                        hasFirstSuccessfulConnectionRef.current = true;
-                        setIntegrations((_nextAccess_integrations = nextAccess.integrations) !== null && _nextAccess_integrations !== void 0 ? _nextAccess_integrations : null);
-                        setAccess(nextAccess);
-                        setActiveDevices(activeDevicesStateOf(connection1.room));
-                        setLocalCameraTrack(localCameraTrackOf(connection1.room));
-                        setLocalMedia(mediaState !== null && mediaState !== void 0 ? mediaState : localMediaStateOf(connection1.room));
+                        _state.sent();
                         setStatus('connected');
-                        void syncControlState();
                         return [
                             2
                         ];
@@ -14679,6 +15188,7 @@ function RoomPlatformProvider(param) {
         applyControlState,
         disposeRoom,
         isLifecycleActive,
+        reconcileCanonicalCamera,
         reportError,
         reportLifecycleEvent,
         syncControlState
@@ -14842,7 +15352,6 @@ function RoomPlatformProvider(param) {
                             errorScopeRef.current = undefined;
                             setError(undefined);
                             setLocalCameraTrack(null);
-                            setLocalPreviewTrack(null);
                             setLocalMedia(emptyLocalMediaState);
                             setPrivateRoom(undefined);
                             setPrivateRoomConnection(undefined);
@@ -14915,17 +15424,20 @@ function RoomPlatformProvider(param) {
             })();
         }();
         return function() {
-            var _localPreviewTrackRef_current;
             if (lifecycleRef.current === lifecycle) lifecycleRef.current = undefined;
             isMountedRef.current = false;
             recoveryRef.current = undefined;
             var connection = roomConnectionRef.current;
             if (connection) disposeRoom(connection);
-            (_localPreviewTrackRef_current = localPreviewTrackRef.current) === null || _localPreviewTrackRef_current === void 0 ? void 0 : _localPreviewTrackRef_current.stop();
-            localPreviewTrackRef.current = null;
+            cameraRevisionRef.current += 1;
+            var canonicalTrack = canonicalCameraTrackRef.current;
+            if (canonicalTrack) removeCanonicalCameraTrack(canonicalTrack, true);
+            cameraCreationRef.current = undefined;
+            cameraTransitionRef.current = Promise.resolve();
             pendingActions.clear();
             pendingLocalMedia.clear();
             accessRef.current = undefined;
+            accessGenerationRef.current += 1;
             controlStateRef.current = undefined;
             controlStateSyncRef.current = undefined;
             setPrivateRoom(undefined);
@@ -14937,6 +15449,7 @@ function RoomPlatformProvider(param) {
         disposeRoom,
         isLifecycleActive,
         recover,
+        removeCanonicalCameraTrack,
         reportError
     ]);
     var hasCapability = useCallback(function(capability) {
@@ -15070,25 +15583,43 @@ function RoomPlatformProvider(param) {
         reportError
     ]);
     var setLocalMediaEnabled = useCallback(function(kind, enabled) {
-        var existingOperation = pendingLocalMediaRef.current.get(kind);
+        var existingOperation = kind === 'camera' ? undefined : pendingLocalMediaRef.current.get(kind);
         if (existingOperation !== undefined) return existingOperation;
         var operation = (function() {
             return _async_to_generator$k(function() {
-                var _controlStateRef_current, _accessRef_current, hasTemporarySpeakerGrant, connection, ringingPrivateRoom, participant, actorId, isRingingForActor, _ref, currentSnapshot, snapshot;
+                var _controlStateRef_current, _accessRef_current, connection, currentAccess, hasTemporarySpeakerGrant, ringingPrivateRoom, participant, actorId, isRingingForActor, _ref, currentSnapshot, snapshot;
                 return _ts_generator$k(this, function(_state) {
                     switch(_state.label){
                         case 0:
+                            connection = roomConnectionRef.current;
+                            if (!(kind === 'camera')) return [
+                                3,
+                                2
+                            ];
+                            cameraDesiredRef.current = enabled;
+                            cameraRevisionRef.current += 1;
+                            if (!connection || connection.disposed) throw new Error('ROOM_PLATFORM_ROOM_UNAVAILABLE');
+                            currentAccess = accessRef.current;
+                            if (enabled && currentAccess && !canPreviewCamera(currentAccess.capabilities) && !cameraShouldBeForced(connection.room)) {
+                                cameraDesiredRef.current = false;
+                                throw new Error('ROOM_PLATFORM_MEDIA_CAPABILITY_DENIED');
+                            }
+                            return [
+                                4,
+                                reconcileCanonicalCamera(lifecycleRef.current, cameraRevisionRef.current, accessGenerationRef.current)
+                            ];
+                        case 1:
+                            _state.sent();
+                            clearMediaError();
+                            return [
+                                2
+                            ];
+                        case 2:
                             hasTemporarySpeakerGrant = kind !== 'screenShare' && ((_controlStateRef_current = controlStateRef.current) === null || _controlStateRef_current === void 0 ? void 0 : _controlStateRef_current.activeSpeakerParticipantIdentity) === ((_accessRef_current = accessRef.current) === null || _accessRef_current === void 0 ? void 0 : _accessRef_current.liveKit.participantIdentity);
                             if (!hasCapability(localMediaCapabilities[kind]) && !hasTemporarySpeakerGrant) throw new Error('ROOM_PLATFORM_MEDIA_CAPABILITY_DENIED');
-                            connection = roomConnectionRef.current;
                             if (!connection || connection.disposed) throw new Error('ROOM_PLATFORM_ROOM_UNAVAILABLE');
                             switch(kind){
                                 case 'microphone':
-                                    return [
-                                        3,
-                                        1
-                                    ];
-                                case 'camera':
                                     return [
                                         3,
                                         3
@@ -15103,21 +15634,10 @@ function RoomPlatformProvider(param) {
                                 3,
                                 7
                             ];
-                        case 1:
-                            return [
-                                4,
-                                connection.room.localParticipant.setMicrophoneEnabled(enabled)
-                            ];
-                        case 2:
-                            _state.sent();
-                            return [
-                                3,
-                                7
-                            ];
                         case 3:
                             return [
                                 4,
-                                connection.room.localParticipant.setCameraEnabled(enabled)
+                                connection.room.localParticipant.setMicrophoneEnabled(enabled)
                             ];
                         case 4:
                             _state.sent();
@@ -15141,16 +15661,17 @@ function RoomPlatformProvider(param) {
                             participant = connection.room.localParticipant;
                             actorId = externalActorIdFromMetadata$2(participant.metadata);
                             isRingingForActor = Boolean((ringingPrivateRoom === null || ringingPrivateRoom === void 0 ? void 0 : ringingPrivateRoom.status) === 'ringing' && actorId && (ringingPrivateRoom.callerExternalActorId === actorId || ringingPrivateRoom.studentExternalActorId === actorId));
-                            if (isRingingForActor && (kind === 'microphone' || kind === 'camera')) {
+                            if (isRingingForActor && kind === 'microphone') {
                                 currentSnapshot = privateMediaSnapshotRef.current;
                                 snapshot = (currentSnapshot === null || currentSnapshot === void 0 ? void 0 : currentSnapshot.room) === connection.room && currentSnapshot.privateRoomId === (ringingPrivateRoom === null || ringingPrivateRoom === void 0 ? void 0 : ringingPrivateRoom.id) ? currentSnapshot : {
-                                    cameraEnabled: participant.isCameraEnabled,
                                     microphoneEnabled: participant.isMicrophoneEnabled,
                                     privateRoomId: (_ref = ringingPrivateRoom === null || ringingPrivateRoom === void 0 ? void 0 : ringingPrivateRoom.id) !== null && _ref !== void 0 ? _ref : '',
                                     room: connection.room,
                                     suppressed: false
                                 };
-                                privateMediaSnapshotRef.current = _object_spread_props$b(_object_spread$d({}, snapshot), _define_property$f({}, kind === 'camera' ? 'cameraEnabled' : 'microphoneEnabled', enabled));
+                                privateMediaSnapshotRef.current = _object_spread_props$b(_object_spread$d({}, snapshot), {
+                                    microphoneEnabled: enabled
+                                });
                             }
                             clearMediaError();
                             if (isMountedRef.current && !connection.disposed) setLocalMedia(function(current) {
@@ -15168,25 +15689,27 @@ function RoomPlatformProvider(param) {
                 scope: 'media'
             });
             throw mediaError;
-        }).finally(function() {
+        });
+        if (kind === 'camera') return operation;
+        var trackedOperation = operation.finally(function() {
             pendingLocalMediaRef.current.delete(kind);
             if (isMountedRef.current) setPendingLocalMediaKinds(_to_consumable_array$7(pendingLocalMediaRef.current.keys()));
         });
-        pendingLocalMediaRef.current.set(kind, operation);
+        pendingLocalMediaRef.current.set(kind, trackedOperation);
         if (isMountedRef.current) setPendingLocalMediaKinds(_to_consumable_array$7(pendingLocalMediaRef.current.keys()));
-        return operation;
+        return trackedOperation;
     }, [
+        cameraShouldBeForced,
         clearMediaError,
         hasCapability,
+        reconcileCanonicalCamera,
         reportError
     ]);
     var currentExternalActorId = externalActorIdFromMetadata$2(room === null || room === void 0 ? void 0 : room.localParticipant.metadata);
     var privateRoomForActor = Boolean(privateRoom && currentExternalActorId && (privateRoom.callerExternalActorId === currentExternalActorId || privateRoom.studentExternalActorId === currentExternalActorId));
     var privateRoomActiveForActor = privateRoomForActor && (privateRoom === null || privateRoom === void 0 ? void 0 : privateRoom.status) === 'active';
     var localParticipantIsActiveSpeaker = Boolean(access && (controlState === null || controlState === void 0 ? void 0 : controlState.activeSpeakerParticipantIdentity) === access.liveKit.participantIdentity);
-    var localParticipantMonitorCamera = (controlState === null || controlState === void 0 ? void 0 : controlState.monitorActive) === true && roleFromMetadata(room === null || room === void 0 ? void 0 : room.localParticipant.metadata) === 'student';
     var canPublishAudioNow = !privateRoomActiveForActor && (hasCapability(localMediaCapabilities.microphone) || localParticipantIsActiveSpeaker);
-    var canPublishCameraNow = !privateRoomActiveForActor && (hasCapability(localMediaCapabilities.camera) || localParticipantIsActiveSpeaker || localParticipantMonitorCamera);
     var canPublishScreenShareNow = hasCapability(localMediaCapabilities.screenShare) && ((_ref = controlState === null || controlState === void 0 ? void 0 : controlState.mode) !== null && _ref !== void 0 ? _ref : 'live') === 'live';
     useEffect(function() {
         if (!room || !privateRoomForActor || (privateRoom === null || privateRoom === void 0 ? void 0 : privateRoom.status) !== 'ringing') return;
@@ -15194,7 +15717,6 @@ function RoomPlatformProvider(param) {
         var snapshot = privateMediaSnapshotRef.current;
         if (!snapshot || snapshot.room !== room || snapshot.privateRoomId !== privateRoom.id) {
             privateMediaSnapshotRef.current = {
-                cameraEnabled: participant.isCameraEnabled,
                 microphoneEnabled: participant.isMicrophoneEnabled,
                 privateRoomId: privateRoom.id,
                 room: room,
@@ -15212,7 +15734,6 @@ function RoomPlatformProvider(param) {
         var snapshot = privateMediaSnapshotRef.current;
         if (privateRoomActiveForActor && privateRoom) {
             privateMediaSnapshotRef.current = !snapshot || snapshot.room !== room || snapshot.privateRoomId !== privateRoom.id ? {
-                cameraEnabled: participant.isCameraEnabled,
                 microphoneEnabled: participant.isMicrophoneEnabled,
                 privateRoomId: privateRoom.id,
                 room: room,
@@ -15222,9 +15743,9 @@ function RoomPlatformProvider(param) {
             });
             void Promise.allSettled([
                 participant.setMicrophoneEnabled(false),
-                participant.setCameraEnabled(false),
                 participant.setScreenShareEnabled(false)
             ]);
+            void reconcileCanonicalCamera();
             return;
         }
         if (!snapshot) return;
@@ -15249,8 +15770,8 @@ function RoomPlatformProvider(param) {
                             _state.trys.push([
                                 0,
                                 ,
-                                3,
-                                4
+                                4,
+                                5
                             ]);
                             return [
                                 4,
@@ -15272,8 +15793,7 @@ function RoomPlatformProvider(param) {
                             return [
                                 4,
                                 Promise.allSettled([
-                                    participant.setMicrophoneEnabled(snapshot.microphoneEnabled),
-                                    participant.setCameraEnabled(snapshot.cameraEnabled)
+                                    participant.setMicrophoneEnabled(snapshot.microphoneEnabled)
                                 ])
                             ];
                         case 2:
@@ -15290,14 +15810,20 @@ function RoomPlatformProvider(param) {
                                 privateMediaSnapshotRef.current = null;
                             }
                             if (isMountedRef.current && !((_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.disposed)) {
-                                setLocalCameraTrack(localCameraTrackOf(snapshot.room));
+                                setLocalCameraTrack(canonicalCameraTrackRef.current);
                                 setLocalMedia(localMediaStateOf(snapshot.room));
                             }
                             return [
-                                3,
-                                4
+                                4,
+                                reconcileCanonicalCamera()
                             ];
                         case 3:
+                            _state.sent();
+                            return [
+                                3,
+                                5
+                            ];
+                        case 4:
                             if (privateMediaRestoreTaskRef.current === snapshot) {
                                 privateMediaRestoreTaskRef.current = null;
                                 if (isMountedRef.current) setPrivateMediaRestorePending(false);
@@ -15305,7 +15831,7 @@ function RoomPlatformProvider(param) {
                             return [
                                 7
                             ];
-                        case 4:
+                        case 5:
                             return [
                                 2
                             ];
@@ -15317,6 +15843,7 @@ function RoomPlatformProvider(param) {
         privateRoom,
         privateRoomActiveForActor,
         privateRoomForActor,
+        reconcileCanonicalCamera,
         reportError,
         room,
         syncControlState
@@ -15326,9 +15853,9 @@ function RoomPlatformProvider(param) {
         if (privateMediaRestorePending || privateMediaRestoreTaskRef.current !== null) return;
         var updates = [
             room.localParticipant.isMicrophoneEnabled === canPublishAudioNow ? undefined : room.localParticipant.setMicrophoneEnabled(canPublishAudioNow),
-            room.localParticipant.isCameraEnabled === canPublishCameraNow ? undefined : room.localParticipant.setCameraEnabled(canPublishCameraNow),
             (!canPublishScreenShareNow || privateRoomActiveForActor) && room.localParticipant.isScreenShareEnabled ? room.localParticipant.setScreenShareEnabled(false) : undefined
         ];
+        void reconcileCanonicalCamera();
         if (!updates.some(Boolean)) return;
         void Promise.allSettled(updates).then(function(results) {
             var _roomConnectionRef_current;
@@ -15339,22 +15866,23 @@ function RoomPlatformProvider(param) {
                 });
             });
             if (isMountedRef.current && !((_roomConnectionRef_current = roomConnectionRef.current) === null || _roomConnectionRef_current === void 0 ? void 0 : _roomConnectionRef_current.disposed)) {
-                setLocalCameraTrack(localCameraTrackOf(room));
+                setLocalCameraTrack(canonicalCameraTrackRef.current);
                 setLocalMedia(localMediaStateOf(room));
             }
         });
     }, [
         canPublishAudioNow,
-        canPublishCameraNow,
         canPublishScreenShareNow,
+        controlState,
         privateMediaRestorePending,
         privateRoomActiveForActor,
+        reconcileCanonicalCamera,
         reportError,
         room
     ]);
     var switchActiveDevice = useCallback(function(kind, deviceId) {
         return _async_to_generator$k(function() {
-            var connection, switched, deviceError;
+            var connection, lifecycle, revision, generation, deviceError;
             return _ts_generator$k(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -15368,13 +15896,56 @@ function RoomPlatformProvider(param) {
                             ,
                             4
                         ]);
+                        lifecycle = lifecycleRef.current;
+                        revision = cameraRevisionRef.current;
+                        generation = accessGenerationRef.current;
                         return [
                             4,
-                            connection.room.switchActiveDevice(kind, deviceId)
+                            enqueueCameraTransition(function() {
+                                return _async_to_generator$k(function() {
+                                    var switched, canonicalTrack, publication;
+                                    return _ts_generator$k(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    connection.room.switchActiveDevice(kind, deviceId)
+                                                ];
+                                            case 1:
+                                                switched = _state.sent();
+                                                if (!switched) throw new Error('ROOM_PLATFORM_DEVICE_SWITCH_FAILED');
+                                                if (!lifecycle || !isLifecycleActive(lifecycle) || cameraRevisionRef.current !== revision || accessGenerationRef.current !== generation || connection !== roomConnectionRef.current) return [
+                                                    2
+                                                ];
+                                                if (kind !== 'videoinput') return [
+                                                    2
+                                                ];
+                                                canonicalTrack = canonicalCameraTrackRef.current;
+                                                publication = connection.room.localParticipant.getTrackPublication(Track.Source.Camera);
+                                                if (!canonicalTrack || (publication === null || publication === void 0 ? void 0 : publication.track) === canonicalTrack) return [
+                                                    2
+                                                ];
+                                                return [
+                                                    4,
+                                                    canonicalTrack.setDeviceId({
+                                                        exact: deviceId
+                                                    })
+                                                ];
+                                            case 2:
+                                                _state.sent();
+                                                if (!isLifecycleActive(lifecycle) || cameraRevisionRef.current !== revision || accessGenerationRef.current !== generation || connection !== roomConnectionRef.current) return [
+                                                    2
+                                                ];
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            })
                         ];
                     case 2:
-                        switched = _state.sent();
-                        if (!switched) throw new Error('ROOM_PLATFORM_DEVICE_SWITCH_FAILED');
+                        _state.sent();
                         clearMediaError();
                         if (isMountedRef.current && !connection.disposed) {
                             setActiveDevices(function(current) {
@@ -15401,6 +15972,8 @@ function RoomPlatformProvider(param) {
         })();
     }, [
         clearMediaError,
+        enqueueCameraTransition,
+        isLifecycleActive,
         reportError
     ]);
     var isActionPending = useCallback(function(name, payload) {
@@ -15427,7 +16000,6 @@ function RoomPlatformProvider(param) {
             isActionPending: isActionPending,
             isLocalMediaPending: isLocalMediaPending,
             localCameraTrack: localCameraTrack,
-            localPreviewTrack: localPreviewTrack,
             localMedia: localMedia,
             performAction: performAction,
             room: room,
@@ -15445,7 +16017,6 @@ function RoomPlatformProvider(param) {
         isActionPending,
         isLocalMediaPending,
         localCameraTrack,
-        localPreviewTrack,
         localMedia,
         performAction,
         room,
@@ -16593,7 +17164,7 @@ function RoomPlatformVideoTile(param) {
         ].filter(Boolean).join(' '),
         "data-kind": kind,
         "data-mirrored": String(isMirrored),
-        "data-state": trackRef ? 'available' : 'empty',
+        "data-state": hasMedia ? 'available' : 'empty',
         "data-testid": "room-platform-video-tile-".concat(kind),
         role: "group",
         children: [
@@ -18650,15 +19221,16 @@ function RoomPlatformCurrentOperationStrip(param) {
 }
 
 function RoomPlatformLocalPreview(param) {
-    var trackRef = param.trackRef, localPreviewTrack = param.localPreviewTrack;
+    var trackRef = param.trackRef, localTrack = param.localTrack;
+    var useCanonicalTrack = localTrack !== undefined;
     return /*#__PURE__*/ jsx(RoomPlatformVideoTile, {
         className: "hidden md:block",
         kind: "preview",
         label: "Camera của bạn",
-        media: localPreviewTrack ? /*#__PURE__*/ jsx(LocalVideoPreview, {
-            track: localPreviewTrack
+        media: localTrack ? /*#__PURE__*/ jsx(LocalVideoPreview, {
+            track: localTrack
         }) : undefined,
-        trackRef: trackRef
+        trackRef: useCanonicalTrack ? undefined : trackRef
     });
 }
 function LocalVideoPreview(param) {
@@ -28261,7 +28833,7 @@ var RoomPlatformWorkspaceContent = function(param) {
     var cameraBackground = param.cameraBackground, completionAction = param.completionAction, extensions = param.extensions, modeConfig = param.modeConfig, onExit = param.onExit, sizing = param.sizing, stageModel = param.stageModel;
     var _resolvedStageModel_cameraOverlay, _ref, _ref1, _ref2, _ref3, _ref4;
     var _resolvedStageModel_primary, _resolvedStageModel_primary1, _extensions_sidebarTabs;
-    var _useRoomPlatform = useRoomPlatform(), access = _useRoomPlatform.access, controlState = _useRoomPlatform.controlState, error = _useRoomPlatform.error, hasCapability = _useRoomPlatform.hasCapability, isActionPending = _useRoomPlatform.isActionPending, localPreviewTrack = _useRoomPlatform.localPreviewTrack, performAction = _useRoomPlatform.performAction, status = _useRoomPlatform.status;
+    var _useRoomPlatform = useRoomPlatform(), access = _useRoomPlatform.access, controlState = _useRoomPlatform.controlState, error = _useRoomPlatform.error, hasCapability = _useRoomPlatform.hasCapability, isActionPending = _useRoomPlatform.isActionPending, localCameraTrack = _useRoomPlatform.localCameraTrack, performAction = _useRoomPlatform.performAction, status = _useRoomPlatform.status;
     var integrations = useRoomPlatformIntegrations().integrations;
     var _useRoomPlatformPrivateRoom = useRoomPlatformPrivateRoom(), cancelPrivateRoom = _useRoomPlatformPrivateRoom.cancelPrivateRoom, currentPrivateRoomOperation = _useRoomPlatformPrivateRoom.currentPrivateRoomOperation;
     var resolvedStageModel = stageModel !== null && stageModel !== void 0 ? stageModel : emptyStageModel;
@@ -28503,7 +29075,7 @@ var RoomPlatformWorkspaceContent = function(param) {
         trackRef: resolvedStageModel.activeSpeaker
     }) : undefined;
     var localMediaSlot = (selectedHostCamera === null || selectedHostCamera === void 0 ? void 0 : selectedHostCamera.participant.isLocal) ? undefined : /*#__PURE__*/ jsx(RoomPlatformLocalPreview, {
-        localPreviewTrack: localPreviewTrack,
+        localTrack: localCameraTrack,
         trackRef: resolvedStageModel.localPreview
     });
     var activeSpeakerMediaSlot = hasActiveSpeaker && !canModerate ? activeSpeakerSlot : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naviedu/room-platform-react",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "type": "module",
   "main": "./index.esm.js",
   "module": "./index.esm.js",