设备及网络（Web）

import { useEffect } from 'react';
import { useDeviceState } from 'tuikit-atomicx-react/room';

function MicrophoneCheck() {
  const {
    microphoneList,
    currentMicrophone,
    testingMicVolume,
    getMicrophoneList,
    setCurrentMicrophone,
    startMicrophoneTest,
    stopMicrophoneTest,
  } = useDeviceState();

  useEffect(() => {
    const init = async () => {
      await getMicrophoneList();
      await startMicrophoneTest({ interval: 200 });
    };
    init();
    return () => {
      stopMicrophoneTest();
    };
  }, []);

  async function switchMicrophone(deviceId: string) {
    await setCurrentMicrophone({ deviceId });
  }
}

import { useEffect } from 'react';
import { useDeviceState } from 'tuikit-atomicx-react/room';

function CameraCheck() {
  const {
    cameraList,
    currentCamera,
    getCameraList,
    setCurrentCamera,
    startCameraTest,
    stopCameraTest,
  } = useDeviceState();

  useEffect(() => {
    const init = async () => {
      await getCameraList();
      await startCameraTest({ view: 'camera-preview' });
    };
    init();
    return () => {
      stopCameraTest();
    };
  }, []);

  async function switchCamera(deviceId: string) {
    await setCurrentCamera({ deviceId });
  }

  return <div id="camera-preview" className="camera-preview"></div>;
}

import { useEffect } from 'react';
import { useDeviceState } from 'tuikit-atomicx-react/room';

function SpeakerCheck() {
  const {
    speakerList,
    currentSpeaker,
    getSpeakerList,
    setCurrentSpeaker,
    startSpeakerTest,
    stopSpeakerTest,
  } = useDeviceState();

  useEffect(() => {
    getSpeakerList();
    return () => {
      stopSpeakerTest();
    };
  }, []);

  async function switchSpeaker(deviceId: string) {
    await setCurrentSpeaker({ deviceId });
  }

  async function testSpeaker() {
    await startSpeakerTest({ filePath: '/audio/test.mp3' });
  }
}

import { DeviceError, DeviceStatus, useDeviceState, useRoomState } from 'tuikit-atomicx-react/room';

function CameraControl() {
  const { currentRoom } = useRoomState();
  const {
    cameraStatus,
    cameraLastError,
    openLocalCamera,
    closeLocalCamera,
  } = useDeviceState();

  async function toggleCamera() {
    try {
      if (cameraStatus === DeviceStatus.On) {
        await closeLocalCamera();
      } else {
        await openLocalCamera();
      }
    } catch (error) {
      console.error('摄像头操作失败:', error);
      handleCameraError(cameraLastError);
    }
  }

  function handleCameraError(error: DeviceError) {
    switch (error) {
      case DeviceError.NoSystemPermission:
        console.error('摄像头权限被拒绝，请在浏览器或系统设置中开启摄像头权限');
        break;
      case DeviceError.NoDeviceDetected:
        console.error('未检测到摄像头设备');
        break;
      case DeviceError.OccupiedError:
        console.error('摄像头被其他应用占用');
        break;
      case DeviceError.NotSupportCapture:
        console.error('当前浏览器不支持摄像头采集');
        break;
      default:
        console.error('摄像头操作失败，请检查设备状态');
        break;
    }
  }
}

import { useState } from 'react';
import {
  DeviceError,
  useDeviceState,
  useRoomParticipantState,
  useRoomState,
} from 'tuikit-atomicx-react/room';

function MicrophoneControl() {
  const { currentRoom } = useRoomState();
  const {
    currentMicVolume,
    microphoneLastError,
    openLocalMicrophone,
  } = useDeviceState();
  const { muteMicrophone, unmuteMicrophone } = useRoomParticipantState();

  const [isMicrophoneMuted, setIsMicrophoneMuted] = useState(true);

  async function prepareMicrophoneAfterJoinRoom() {
    try {
      await muteMicrophone();
      await openLocalMicrophone();
      setIsMicrophoneMuted(true);
    } catch (error) {
      console.error('麦克风预采集失败:', error);
      handleMicrophoneError(microphoneLastError);
    }
  }

  async function openMicrophoneForSpeaking() {
    await unmuteMicrophone();
    setIsMicrophoneMuted(false);
  }

  async function closeMicrophoneForSpeaking() {
    await muteMicrophone();
    setIsMicrophoneMuted(true);
  }

  function checkSpeakingWhileMuted() {
    if (isMicrophoneMuted && currentMicVolume > 30) {
      console.warn('检测到您正在说话，是否打开麦克风？');
    }
  }

  function handleMicrophoneError(error: DeviceError) {
    switch (error) {
      case DeviceError.NoSystemPermission:
        console.error('麦克风权限被拒绝，请在浏览器或系统设置中开启麦克风权限');
        break;
      case DeviceError.NoDeviceDetected:
        console.error('未检测到麦克风设备');
        break;
      case DeviceError.OccupiedError:
        console.error('麦克风被其他应用占用');
        break;
      case DeviceError.NotSupportCapture:
        console.error('当前浏览器不支持麦克风采集');
        break;
      default:
        console.error('麦克风操作失败，请检查设备状态');
        break;
    }
  }
}