liangchengyou / wow_english

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

  import 'package:flutter/cupertino.dart';
  import 'package:flutter/services.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 '../../../common/request/exception.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 ;
  

    /// 方法

    late MethodChannel methodChannel;
  

    ///录音
    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<XSVoiceInitEvent>(_initVoiceSdk);
      on<RequestDataEvent>(_requestData);
      on<XSVoiceTestEvent>(_voiceXsTest);
      on<XSVoiceStopEvent>(_voiceXsStop);
      on<VoiceRecordEvent>(_voiceRecord);

      on<InitBlocEvent>(_initBlocData);
    }

    @override
    Future<void> close() {
      _releaseFlauto();

      _voiceXsCancel();

      return super.close();
    }

    ///初始化功能

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

      methodChannel = const MethodChannel('wow_english/sing_sound_method_channel');
      methodChannel.setMethodCallHandler((call) async {
        if (call.method == 'voiceResult') {//评测结果
          add(XSVoiceResultEvent(call.arguments));
          add(PostFollowReadContentEvent());

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

        }
      });

      //录音
      _soundRecorder = FlutterSoundRecorder();

      await _soundRecorder.openRecorder();

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

  
      //音屏
      _soundPlayer = FlutterSoundPlayer();
      //设置音频
      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 {
        await loading(() async {
          _entityList = await ListenDao.followResult(_recordNumber.toString(),courseLessonId);

        });
      } 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());
    }
  
  
    _initVoiceSdk(XSVoiceInitEvent event,Emitter<RepeatAfterContentState> emitter) async {
      methodChannel.invokeMethod('initVoiceSdk',event.data);
    }
  
    ///先声测试
    void _voiceXsTest(XSVoiceTestEvent event,Emitter<RepeatAfterContentState> emitter) async {

      await methodChannel.invokeMethod(

          'startLocalVoice',

          {
            'type':event.type,
            'word':event.testWord,
            'voicePath':_path,
            'userId':event.userId.toString()
          }

      );

      _recordNumber++;

      _xSCheckState = XSVoiceCheckState.start;

      emitter(XSVoiceTestState());
    }
  
    ///终止评测
    void _voiceXsStop(XSVoiceStopEvent event,Emitter<RepeatAfterContentState> emitter) async {
      methodChannel.invokeMethod('stopVoice');
    }
  

    ///取消评测（用于处理退出页面后录音未停止等异常情况的保护操作）
    void _voiceXsCancel() {
      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.aacADTS,
          sampleRate: 44000,
          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;
          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) {
        openAppSettings();
      } 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) {
        openAppSettings();
      }
    }

  }