trtc_simple_demo_ios/lib/page/hardware_detection/controller.dart

import 'dart:async';
import 'package:camera/camera.dart';
import 'package:flutter_sound/flutter_sound.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:trtc_demo/page/hardware_detection/state.dart';
import 'package:audio_session/audio_session.dart';
import 'package:flutter/foundation.dart' show kDebugMode, kIsWeb;
import 'package:flutter_sound_platform_interface/flutter_sound_recorder_platform_interface.dart';
import 'package:tencent_trtc_cloud/trtc_cloud.dart';
import 'package:tencent_trtc_cloud/tx_device_manager.dart';

class HardwareDetectionController extends GetxController {
  HardwareDetectionController();

  /// 本地硬件设置持久化缓存服务
  // HardwareSettingService hardwareSettingService =
  //     Get.find<HardwareSettingService>();

  // HardwareSetting hardwareSetting = HardwareSetting.ins;
  final state = HardwareDetectionState();

  /// 相机控制器需要的参数
  late List<CameraDescription> _cameras;

  late CameraController cameraController;

  /// 扬声器控制器需要的参数
  final FlutterSoundPlayer flutterSound = FlutterSoundPlayer();

  /// 麦克风控制器需要的参数
  Codec _codec = Codec.aacMP4;

  final FlutterSoundRecorder flutterRecorder = FlutterSoundRecorder();

  /// dispose 释放内存
  @override
  void dispose() {
    super.dispose();
    cameraController.dispose();
    flutterSound.closePlayer();
    flutterRecorder.closeRecorder();
  }

  /// 在 [onDelete] 方法之前调用。
  @override
  void onClose() {
    super.onClose();
  }

  /// 在 widget 内存中分配后立即调用。
  @override
  void onInit() async {
    // hardwareSettingService.init();
    await _intialize();
    super.onInit();
  }

  /// 在 onInit() 之后调用 1 帧。这是进入的理想场所
  @override
  void onReady() {
    super.onReady();
  }

  // 刷新设备列表
  Future<void> refreshAllDevices() async {
    await refreshCameraList();
    await refreshMicrophoneList();
    await refreshSpeakerList();
  }

  /// 刷新摄像头列表
  Future<void> refreshCameraList() async {
    state.searchingCamera = true;
    if (state.detectingCamera) stopDetectingCamera();
    try {
      _cameras = await availableCameras();
      state.cameraList = [];
      state.cameraAvailable = null;
      await Future.delayed(Duration(milliseconds: 100));
      state.cameraList = await _trtcGetCameras();
      state.searchingCamera = false;
    } on Exception catch (e) {
      state.cameraList = [];
      state.cameraAvailable = null;
      state.searchingCamera = false;
      print('Search camera failed: $e');
    }
    // 如果当前没有选择摄像头，则选择第一个
    if (state.currentCameraId.isEmpty && state.cameraList.isNotEmpty) {
      selectCameraById(state.cameraList.first.id);
    }
  }

  /// 刷新麦克风列表
  Future<void> refreshMicrophoneList() async {
    state.searchingMicrophone = true;
    if (state.detectingMicrophone) stopDetectingMicrophone();
    state.microphoneList = [];
    state.microphoneAvailable = null;
    await Future.delayed(Duration(milliseconds: 100));
    try {
      state.microphoneList = await _trtcGetMicrophones();
      state.searchingMicrophone = false;
    } on Exception catch (e) {
      state.microphoneList = [];
      state.searchingMicrophone = false;
      print('Search microphone failed: $e');
    }
    // 如果当前没有选择麦克风，则选择第一个
    if (state.currentMicrophoneId.isEmpty && state.microphoneList.isNotEmpty) {
      selectMicrophoneById(state.microphoneList.first.id);
    }
  }

  /// 刷新扬声器列表
  Future<void> refreshSpeakerList() async {
    state.searchingSpeaker = true;
    if (state.detectingSpeaker) stopDetectingSpeaker();
    state.speakerList = [];
    state.speakerAvailable = null;
    await Future.delayed(Duration(milliseconds: 100));
    try {
      state.speakerList = await _trtcGetSpeakers();
      state.searchingSpeaker = false;
    } on Exception catch (e) {
      state.speakerList = [];
      state.searchingSpeaker = false;
      print('Search speaker failed: $e');
    }
    // 如果当前没有选择扬声器，则选择第一个
    if (state.currentSpeaker == null && state.speakerList.isNotEmpty) {
      selectSpeakerById(state.speakerList.first.id);
    }
  }

  /// 选择摄像头
  void selectCameraById(String deviceId) {
    if (state.currentCamera != null && deviceId == state.currentCameraId)
      return;

    state.cameraList.forEach((element) {
      if (element.id == deviceId) {
        print('select camera: ${element.name}');
        print('select camera: ${element.id}');
        state.currentCamera = element;
        state.cameraAvailable = null;
        state.currentCameraId = element.id;
        // hardwareSetting.setIdealWebVideoInputDeviceName(element.name);
        // hardwareSettingService.save();
      }
    });
    if (state.currentCamera == null) return;
    if (state.detectingCamera) {
      _stopCamera();
      _openSelectedCamera();
    }
  }

  /// 选择麦克风
  Future<void> selectMicrophoneById(String deviceId) async {
    state.microphoneList.forEach((element) {
      if (element.id == deviceId) {
        state.currentMicrophone = element;
        state.microphoneAvailable = null;
        state.currentMicrophoneId = element.id;
      }
    });
    if (state.currentMicrophone == null) return;
    if (state.detectingMicrophone) {
      await _stopRecordMicrophone();
      _startRecordMicrophone();
    }
  }

  /// 选择扬声器
  void selectSpeakerById(String deviceId) {
    state.speakerList.forEach((element) {
      if (element.id == deviceId) {
        state.currentSpeaker = element;
        state.speakerAvailable = null;
      }
    });
    if (state.currentSpeaker == null) return;
  }

  /// 设置当前选中的摄像头可用性
  void setCameraAvailable(bool available) {
    state.cameraAvailable = available;
    stopDetectingCamera();
  }

  /// 设置当前选中的麦克风可用性
  void setMicrophoneAvailable(bool available) {
    state.microphoneAvailable = available;
    stopDetectingMicrophone();
  }

  /// 设置当前选中的扬声器可用性
  void setSpeakerAvailable(bool available) {
    state.speakerAvailable = available;
    stopDetectingSpeaker();
  }

  /// 开始检测所有设备
  Future<void> startDetectingAll() async {
    await refreshAllDevices();
    if (state.cameraList.isNotEmpty) startDetectingCamera();
    if (state.microphoneList.isNotEmpty) startDetectingMicrophone();
    if (state.speakerList.isNotEmpty) startDetectingSpeaker();
  }

  /// 开始检测摄像头
  void startDetectingCamera() {
    state.cameraAvailable = null;
    state.detectingCamera = true;
    _openSelectedCamera();
  }

  /// 开始检测麦克风
  void startDetectingMicrophone() {
    state.microphoneAvailable = null;
    state.detectingMicrophone = true;
    _startRecordMicrophone();
  }

  /// 开始检测扬声器
  void startDetectingSpeaker() {
    state.speakerAvailable = null;
    state.detectingSpeaker = true;
    _startPlaySound();
  }

  /// 结束检测摄像头
  void stopDetectingCamera() {
    state.detectingCamera = false;
    _stopCamera();
  }

  /// 结束检测麦克风
  void stopDetectingMicrophone() {
    state.detectingMicrophone = false;
    _stopRecordMicrophone();
  }

  /// 结束检测扬声器
  void stopDetectingSpeaker() {
    state.detectingSpeaker = false;
    _stopPlaySound();
  }

  /// 初始化摄像头列表
  Future<void> _initCameras() async {
    state.searchingCamera = true;
    List<HardwareDevice> _cameraList = await _trtcGetCameras();
    try {
      _cameras = await availableCameras();
    } on Exception catch (e) {
      print('Search camera failed: $e');
      _cameras = [];
    }
    for (var i = 0; i < _cameras.length; i++) {
      for (var j = 0; j < _cameraList.length; j++) {
        if (_cameras[i].name == _cameraList[j].name) {
          state.cameraList.add(_cameraList[j]);
          break;
        }
      }
    }
    if (state.cameraList.isNotEmpty) {
      state.currentCamera = state.cameraList[0];
      state.currentCameraId = state.cameraList[0].id;
    }
    // final idealCameraName = hardwareSetting.idealWebVideoInputDeviceName;
    // bool isFind = false;
    // if (idealCameraName != '') {
    //   for (var i = 0; i < state.cameraList.length; i++) {
    //     if (state.cameraList[i].name == idealCameraName) {
    //       state.currentCamera = state.cameraList[i];
    //       isFind = true;
    //       break;
    //     }
    //   }
    // }
    // if (isFind == false && state.cameraList.isNotEmpty) {
    //   hardwareSetting.setIdealWebVideoInputDeviceName(state.cameraList[0].name);
    //   hardwareSettingService.save();
    // }
    state.searchingCamera = false;
  }

  /// 初始化麦克风列表
  Future<void> _initMicrophones() async {
    state.searchingMicrophone = true;
    List<HardwareDevice> _microphoneList = await _trtcGetMicrophones();
    state.microphoneList.addAll(_microphoneList);
    await _initTheRecorder();
    if (state.microphoneList.isNotEmpty) {
      state.currentMicrophone = state.microphoneList[0];
      state.currentMicrophoneId = state.microphoneList[0].id;
    }
    // final idealMicrophoneName = '';
    // bool isFind = false;
    // if (idealMicrophoneName != '') {
    //   for (var i = 0; i < state.microphoneList.length; i++) {
    //     if (state.microphoneList[i].name == idealMicrophoneName) {
    //       state.currentMicrophone = state.microphoneList[i];
    //       // isFind = true;
    //       break;
    //     }
    //   }
    // }
    // if (isFind == false && state.microphoneList.isNotEmpty) {
    //   hardwareSetting
    //       .setIdealWebAudioInputDeviceName(state.microphoneList[0].name);
    //   hardwareSettingService.save();
    // }
    state.searchingMicrophone = false;
  }

  /// 初始化扬声器列表
  Future<void> _initSpeakers() async {
    state.searchingSpeaker = true;
    List<HardwareDevice> _speakerList = await _trtcGetSpeakers();
    state.speakerList.addAll(_speakerList);
    await _initThePlayer();
    if (state.speakerList.isNotEmpty) {
      state.currentSpeaker = state.speakerList[0];
      state.currentSpeakerId = state.speakerList[0].id;
    }
    state.searchingSpeaker = false;
  }

  /// 初始化播放器
  Future<void> _initThePlayer() async {
    await flutterSound.openPlayer();
    await flutterSound
        .setSubscriptionDuration(const Duration(milliseconds: 100));
    state.isDisplaySpeakerWave = true;
  }

  /// 初始化麦克风录音器
  Future<void> _initTheRecorder() async {
    await flutterRecorder.openRecorder();
    if (!await flutterRecorder.isEncoderSupported(_codec) && kIsWeb) {
      _codec = Codec.opusWebM;
      if (!await flutterRecorder.isEncoderSupported(_codec) && kIsWeb) {
        state.isDisplayMicrophoneWave = true;
        return;
      }
    }
    // 设置采样率
    await flutterRecorder
        .setSubscriptionDuration(const Duration(milliseconds: 50));
    final session = await AudioSession.instance;
    await session.configure(AudioSessionConfiguration(
      avAudioSessionCategory: AVAudioSessionCategory.playAndRecord,
      avAudioSessionCategoryOptions:
          AVAudioSessionCategoryOptions.allowBluetooth |
              AVAudioSessionCategoryOptions.defaultToSpeaker,
      avAudioSessionMode: AVAudioSessionMode.spokenAudio,
      avAudioSessionRouteSharingPolicy:
          AVAudioSessionRouteSharingPolicy.defaultPolicy,
      avAudioSessionSetActiveOptions: AVAudioSessionSetActiveOptions.none,
      androidAudioAttributes: const AndroidAudioAttributes(
        contentType: AndroidAudioContentType.speech,
        flags: AndroidAudioFlags.none,
        usage: AndroidAudioUsage.voiceCommunication,
      ),
      androidAudioFocusGainType: AndroidAudioFocusGainType.gain,
      androidWillPauseWhenDucked: true,
    ));
    state.isDisplayMicrophoneWave = true;
  }

  /// 初始化设备列表
  Future<void> _intialize() async {
    await _initCameras();
    await _initMicrophones();
    await _initSpeakers();
  }

  /// 打开当前选中的摄像头
  _openSelectedCamera() {
    bool found = false;
    int cameraIndex = 0;
    for (var i = 0; i < _cameras.length; i++) {
      if (_cameras[i].name == state.currentCamera?.name) {
        cameraIndex = i;
        found = true;
        break;
      }
    }
    if (!found) {
      return;
    }
    cameraController =
        CameraController(_cameras[cameraIndex], ResolutionPreset.max);
    cameraController.initialize().then((_) {
      state.isDisplayCameraWindow = true;
    }).catchError((Object e) {
      if (e is CameraException) {
        switch (e.code) {
          case 'CameraAccessDenied':
            // Handle access errors here.
            break;
          default:
            // Handle other errors here.
            break;
        }
      }
    });
  }

  /// 使用当前的扬声器播放测试音频
  Future<void> _startPlaySound() async {
    await flutterSound.startPlayer(
        fromURI: kDebugMode
            ? "assets/audio/testspeak.mp3"
            : "assets/assets/audio/testspeak.mp3",
        codec: Codec.aacADTS,
        whenFinished: () {});
  }

  // 开始采集麦克风音频
  void _startRecordMicrophone() async {
    /// 获取到当前选中的麦克风的id
    if (state.currentMicrophone == null) {
      return;
    }
    final String fileNameWithMicrophoneId =
        "temp@${state.currentMicrophone!.id}.webm";

    ///  将麦克风的id作为文件名，web端的record会做处理，会将文件名作为选中的麦克风id进行设置
    await flutterRecorder.startRecorder(
        toFile: fileNameWithMicrophoneId,
        codec: _codec,
        audioSource: AudioSource.microphone);
  }

  /// 关闭摄像头并释放
  _stopCamera() {
    state.isDisplayCameraWindow = false;
    if (cameraController.value.isStreamingImages) {
      cameraController.stopImageStream();
    }
    cameraController.dispose();
  }

  /// 停止播放音频
  _stopPlaySound() {
    flutterSound.stopPlayer();
  }

  /// 停止采集麦克风音频
  Future<void> _stopRecordMicrophone() async {
    await flutterRecorder.stopRecorder();
  }

  /// 调用 TRTC 获取摄像头列表以及ids
  Future<List<HardwareDevice>> _trtcGetCameras() async {
    List<HardwareDevice> deviceList = [];
    TRTCCloud trtcCloud = (await TRTCCloud.sharedInstance())!;
    TXDeviceManager deviceManager = trtcCloud.getDeviceManager();
    final List<dynamic>? cameras = await deviceManager.getDevicesList(2);
    if (cameras != null && cameras.isNotEmpty) {
      cameras.forEach((camera) {
        deviceList.add(HardwareDevice(
            id: camera["deviceId"],
            name: camera["label"],
            type: HardwareDeviceType.camera));
      });
    }
    return deviceList;
  }

  /// 调用 TRTC 获取麦克风列表
  Future<List<HardwareDevice>> _trtcGetMicrophones() async {
    List<HardwareDevice> deviceList = [];
    TRTCCloud trtcCloud = (await TRTCCloud.sharedInstance())!;
    TXDeviceManager deviceManager = trtcCloud.getDeviceManager();
    final List<dynamic>? microphones = await deviceManager.getDevicesList(0);
    if (microphones != null && microphones.isNotEmpty) {
      microphones.forEach((microphone) {
        deviceList.add(HardwareDevice(
            id: microphone["deviceId"],
            name: microphone["label"],
            type: HardwareDeviceType.microphone));
      });
    }
    return deviceList;
  }

  /// 调用 TRTC 获取扬声器列表
  Future<List<HardwareDevice>> _trtcGetSpeakers() async {
    List<HardwareDevice> deviceList = [];
    TRTCCloud trtcCloud = (await TRTCCloud.sharedInstance())!;
    TXDeviceManager deviceManager = trtcCloud.getDeviceManager();
    final List<dynamic>? speakers = await deviceManager.getDevicesList(1);
    if (speakers != null && speakers.isNotEmpty) {
      speakers.forEach((speaker) {
        deviceList.add(HardwareDevice(
            id: speaker["deviceId"],
            name: speaker["label"],
            type: HardwareDeviceType.speaker));
      });
    }
    return deviceList;
  }
}