liangchengyou / wow_english

  import 'dart:io';
  import 'dart:async';
  
  import 'package:audio_session/audio_session.dart';

  import 'package:flutter/cupertino.dart';

  import 'package:flutter_bloc/flutter_bloc.dart';

  import 'package:flutter_sound/flutter_sound.dart';
  import 'package:path_provider/path_provider.dart';
  import 'package:permission_handler/permission_handler.dart';

  import 'package:wow_english/common/request/dao/listen_dao.dart';

  import 'package:wow_english/route/route.dart';
  import '../../../common/dialogs/show_dialog.dart';

  import '../../../common/request/exception.dart';

  import '../../../common/speech/chivox_evaluation_channel.dart';

  import '../../../models/read_content_entity.dart';
  import '../../../utils/loading.dart';
  import '../../../utils/toast_util.dart';
  

  part 'repeat_after_content_event.dart';
  part 'repeat_after_content_state.dart';
  
  enum VoiceRecordState {
    ///未知
    voiceRecordUnkonw,

    ///开始录音
    voiceRecordStat,

    ///正在录音
    voiceRecording,

    ///录音结束
    voiceRecordEnd
  }
  

  ///驰声测评状态

  enum XSVoiceCheckState {

    ///未知
    unKnow,

    ///测评开始
    start,

    ///评测结果
    result,

    ///测评结束
    stop,

  }
  

  class RepeatAfterContentBloc
      extends Bloc<RepeatAfterContentEvent, RepeatAfterContentState> {

    final String courseLessonId;
  

    /// 是否正在播放视频

    bool _videoPlaying = true;

    bool get videoPlaying => _videoPlaying;

    /// 是否正在录音

    bool _isRecord = false;

    bool get isRecord => _isRecord;

  
    /// 驰声评测状态

    XSVoiceCheckState _xSCheckState = XSVoiceCheckState.unKnow;
    XSVoiceCheckState get xSCheckState => _xSCheckState;

    /// 评测结果

    Map? _voiceTestResult;

    Map? get voiceTestResult => _voiceTestResult;

    /// 录音的次数

    int _recordNumber = 0;

    /// 录音文件地址
    String _path = '';
    String get path => _path;

    /// 当前播放的视频位置
    int _currentPlayIndex = 0;
    int get currentPlayIndex => _currentPlayIndex;
  
    /// 录音状态

    VoiceRecordState _voiceRecordState = VoiceRecordState.voiceRecordUnkonw;

    VoiceRecordState get voiceRecordState => _voiceRecordState;
  

    /// 跟读内容数字

    List<ReadContentEntity?>? _entityList;

    List<ReadContentEntity?>? get entityList => _entityList;

    /// 方法

    final ChivoxEvaluationChannel methodChannel = ChivoxEvaluationChannel();

    ///录音
    late FlutterSoundRecorder _soundRecorder;
    late FlutterSoundPlayer _soundPlayer;

    // StreamSubscription? _soundPlayerListen;

    RepeatAfterContentBloc(this.courseLessonId)
        : super(RepeatAfterContentInitial()) {

      on<VoiceRecordStateChangeEvent>(_voiceRecordStateChange);

      on<PostFollowReadContentEvent>(_postFollowReadContent);

      on<ChangeVideoPlayIndexEvent>(_changeVideoPlayIndex);

      on<VideoPlayChangeEvent>(_videoPlayStateChange);
      on<RecordeVoicePlayEvent>(_recordeVoicePlay);

      on<StarRecordVoiceEvent>(_starRecordVoice);
      on<StopRecordVoiceEvent>(_stopRecordVoice);

      on<XSVoiceResultEvent>(_voiceXsResult);

      on<RequestDataEvent>(_requestData);
      on<XSVoiceTestEvent>(_voiceXsTest);
      on<XSVoiceStopEvent>(_voiceXsStop);
      on<VoiceRecordEvent>(_voiceRecord);

      on<InitBlocEvent>(_initBlocData);
    }

    @override

    Future<void> close() async {
      await _releaseFlauto();
      await _voiceXsCancel();
      await methodChannel.dispose();

      return super.close();
    }

    ///初始化功能

    void _initBlocData(
        InitBlocEvent event, Emitter<RepeatAfterContentState> emitter) async {

      methodChannel.setMethodCallHandler((call) async {

        if (call.method == 'voiceResult') {
          //评测结果

          add(XSVoiceResultEvent(call.arguments));
          add(PostFollowReadContentEvent());

          return;
        }
  
        if (call.method == 'voiceEnd') {
          return;

        }

  
        if (call.method == 'voiceFail') {
          _xSCheckState = XSVoiceCheckState.unKnow;
          add(VoiceRecordStateChangeEvent(_voiceRecordState));
          showToast('评测失败');
        }

      });

      //录音
      _soundRecorder = FlutterSoundRecorder();

      //音屏
      _soundPlayer = FlutterSoundPlayer();

      await _init();
      await methodChannel.invokeMethod('initVoiceSdk', {});

    }
  

    Future<void> _init() async {

      await _soundRecorder.openRecorder();

      await _soundRecorder
          .setSubscriptionDuration(const Duration(milliseconds: 10));

      //设置音频
      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,
      ));
      await _soundPlayer.closePlayer();
      await _soundPlayer.openPlayer();

      await _soundPlayer
          .setSubscriptionDuration(const Duration(milliseconds: 10));

    }
  
    ///请求数据

    void _requestData(
        RequestDataEvent event, Emitter<RepeatAfterContentState> emitter) async {

      try {
        await loading(() async {
          _entityList = await ListenDao.readContent(courseLessonId);
          emitter(RequestDataState());
        });
      } catch (e) {
        if (e is ApiException) {

          showToast(e.message ?? '请求失败,请检查网络连接');

        }
      }
    }
  

    ///提交跟读结果

    void _postFollowReadContent(PostFollowReadContentEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      try {

        ReadContentEntity entity = _entityList![_currentPlayIndex]!;

        await ListenDao.followResult(_recordNumber.toString(), entity.id);

      } catch (e) {

        if (e is ApiException) {}

      }
    }
  

    void _videoPlayStateChange(VideoPlayChangeEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      _videoPlaying = !_videoPlaying;
      emitter(VideoPlayChangeState());
    }
  

    void _voiceRecord(
        VoiceRecordEvent event, Emitter<RepeatAfterContentState> emitter) async {

      _isRecord = !_isRecord;
      emitter(VoiceRecordChangeState());
    }
  

    void _voiceRecordStateChange(VoiceRecordStateChangeEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      _voiceRecordState = event.voiceRecordState;
      emitter(VoiceRecordStateChange());
    }
  

    ///驰声测试
    void _voiceXsTest(
        XSVoiceTestEvent event, Emitter<RepeatAfterContentState> emitter) async {

      _recordNumber += 1;
      _xSCheckState = XSVoiceCheckState.start;
      emitter(XSVoiceTestState());

      await methodChannel.invokeMethod('startLocalVoice', {
        'type': event.type,
        'word': event.testWord,
        'voicePath': _path,
        'userId': event.userId.toString()
      });

    }
  
    ///终止评测

    void _voiceXsStop(
        XSVoiceStopEvent event, Emitter<RepeatAfterContentState> emitter) async {
      await methodChannel.invokeMethod('stopVoice');

    }
  

    ///取消评测（用于处理退出页面后录音未停止等异常情况的保护操作）

    Future<void> _voiceXsCancel() async {
      await methodChannel.invokeMethod('cancelVoice');

    }
  

    ///驰声评测结果
    void _voiceXsResult(XSVoiceResultEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      final Map args = event.message as Map;
      final result = args['result'] as Map;

      final overall = result['overall'].toString();

      _voiceTestResult = {'overall': overall};

      _xSCheckState = XSVoiceCheckState.result;

      emitter(XSVoiceTestState());
    }
  
    ///播放声音

    void _recordeVoicePlay(RecordeVoicePlayEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      if (await _fileExists(_path)) {
        if (_soundPlayer.isPlaying) {
          _soundPlayer.stopPlayer();
        }

        await _soundPlayer.startPlayer(

            fromURI: path, codec: Codec.pcm16WAV, whenFinished: () {});

      }
    }

  
    ///更改播放的视频

    void _changeVideoPlayIndex(ChangeVideoPlayIndexEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      if (_entityList == null || _entityList!.isEmpty) {
        return;
      }
      if (event.isNext) {

        if (_currentPlayIndex < _entityList!.length - 1) {

          _currentPlayIndex++;
        }
      } else {

        if (_currentPlayIndex > 0) {

          _currentPlayIndex--;
        }
      }

      emitter(ChangeVideoPlayIndexState(event.isNext));
    }

  
    ///开始录音

    void _starRecordVoice(StarRecordVoiceEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      try {
        await getPermissionStatus().then((value) async {
          if (!value) {
            debugPrint('失败$value');
            return;
          }
          Directory tempDir = await getTemporaryDirectory();
          var time = DateTime.now().millisecondsSinceEpoch;

          String path = '${tempDir.path}/$time${ext[Codec.pcm16WAV.index]}';

  
          _path = path;
          debugPrint('=====> 准备开始录音');
          await _soundRecorder.startRecorder(
            toFile: path,

            codec: Codec.pcm16WAV,

          );
          debugPrint('=====> 开始录音');
          _voiceRecordState = VoiceRecordState.voiceRecording;

          _xSCheckState = XSVoiceCheckState.unKnow;

          emitter(VoiceRecordStateChange());
        });
      } catch (error) {
        await _soundRecorder.stopRecorder();
      }
    }
  
    ///停止录音

    void _stopRecordVoice(StopRecordVoiceEvent event,
        Emitter<RepeatAfterContentState> emitter) async {

      debugPrint('=====> 停止录音');
      await _soundRecorder.stopRecorder();
      _voiceRecordState = VoiceRecordState.voiceRecordEnd;
      emitter(VoiceRecordStateChange());
    }
  
    /// 判断文件是否存在
    Future<bool> _fileExists(String path) async {
      return await File(path).exists();
    }
  
    ///获取权限
    Future<bool> getPermissionStatus() async {
      Permission permission = Permission.microphone;
      PermissionStatus status = await permission.status;
      if (status.isGranted) {
        return true;
      } else if (status.isDenied) {
        requestPermission(permission);
      } else if (status.isPermanentlyDenied) {

        showDialog();

      } else if (status.isRestricted) {
        requestPermission(permission);

      } else {}

      return false;
    }
  
    /// 释放录音
    Future<void> _releaseFlauto() async {
      await _soundRecorder.closeRecorder();
    }
  
    ///申请权限
    void requestPermission(Permission permission) async {
      PermissionStatus status = await permission.request();
      if (status.isPermanentlyDenied) {

        showDialog();

      }
    }

  
    void showDialog() async {

      showTwoActionDialog('提示', '取消', '去设置', '请进入设置页打开麦克风权限', leftTap: () {

        popPage();

      }, rightTap: () {

        popPage();
        openAppSettings();
      });
    }

  }