liangchengyou / wow_english

  import 'dart:async';
  

  import 'package:audioplayers/audioplayers.dart';

  import 'package:flutter/cupertino.dart';

  import 'package:flutter/foundation.dart';

  import 'package:flutter_bloc/flutter_bloc.dart';

  import 'package:flutter_easyloading/flutter_easyloading.dart';

  import 'package:permission_handler/permission_handler.dart';

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

  import 'package:wow_english/common/speech/chivox_evaluation_channel.dart';

  import 'package:wow_english/models/course_process_entity.dart';

  import 'package:wow_english/pages/section/subsection/base_section/bloc.dart';
  import 'package:wow_english/pages/section/subsection/base_section/event.dart';
  import 'package:wow_english/pages/section/subsection/base_section/state.dart';

  import 'package:wow_english/utils/audio_player_util.dart';

  import 'package:wow_english/utils/toast_util.dart';

  import '../../../common/permission/permissionRequester.dart';

  import '../../../common/utils/show_star_reward_dialog.dart';

  import '../../../models/voice_result_type.dart';

  import '../../../route/route.dart';

  import '../../../utils/log_util.dart';

  part 'topic_picture_event.dart';

  part 'topic_picture_state.dart';

  class TopicPictureBloc

      extends BaseSectionBloc<TopicPictureEvent, TopicPictureState>
      with WidgetsBindingObserver {

    final PageController pageController;
  

    final String courseLessonId;

  
    int _currentPage = 0;
  

    int _optionSelectItem = -1;

  
    CourseProcessEntity? _entity;
  

    CourseProcessEntity? get entity => _entity;
  

    ///正在评测

    bool _isRecording = false;

    int get currentPage => _currentPage + 1;
  

    /// 选择题选中项
    int get optionSelectItem => _optionSelectItem;

    bool get isRecording => _isRecording;

    final ChivoxEvaluationChannel methodChannel = ChivoxEvaluationChannel();

    late AudioPlayer audioPlayer;

    final BuildContext context;
  

    final Color? moduleColor;
  

    final String TAG = 'TopicPictureBloc';
  

    TopicPictureBloc(
        this.context, this.pageController, this.courseLessonId, this.moduleColor)

        : super(TopicPictureInitial()) {

      on<CurrentPageIndexChangeEvent>(_pageControllerChange);

      on<VoicePlayStateChangeEvent>(_voicePlayStateChange);
      on<XSVoiceResultEvent>(_voiceXsResult);

      on<SelectItemEvent>(_selectItemLoad);

      on<SelectItemResetEvent>(_selectItemReset);

      on<RequestDataEvent>(_requestData);

      on<XSVoiceStartEvent>(_voiceXsStart);

      on<XSVoiceStopEvent>(_voiceXsStop);

      on<VoicePlayEvent>(_questionVoicePlay);

      on<OnXSVoiceStateChangeEvent>(_onVoiceXsStateChange);

      on<InitBlocEvent>((event, emit) async {

        //音频播放器
        audioPlayer = AudioPlayer();

        audioPlayer.onPlayerStateChanged.listen((event) async {

          Log.d('$TAG onPlayerStateChanged event=$event');

          if (isClosed) {
            return;
          }
          add(VoicePlayStateChangeEvent());

        });
  

        methodChannel.setMethodCallHandler((call) async {

          if (call.method == 'voiceResult') {
            //评测结果
            await audioPlayer.setAudioContext(AudioContext());
            await audioPlayer.setBalance(0.0);

            add(XSVoiceResultEvent(call.arguments));

            return;
          }
  

          if (call.method == 'voiceStart') {
            //评测开始

            if (kDebugMode) {
              print('评测开始');
            }

            _isRecording = true;
            add(OnXSVoiceStateChangeEvent());

            return;
          }
  

          if (call.method == 'voiceEnd' || call.method == 'voiceCancel') {

            await audioPlayer.setAudioContext(AudioContext());
            await audioPlayer.setBalance(0.0);
            //评测结束

            if (kDebugMode) {

              print(call.method == 'voiceEnd' ? '评测结束' : '评测取消');

            }

            _isRecording = false;
            add(OnXSVoiceStateChangeEvent());

            return;
          }
  

          if (call.method == 'voiceFail') {
            //评测失败
            await audioPlayer.setAudioContext(AudioContext());
            await audioPlayer.setBalance(0.0);
  

            _isRecording = false;
            add(OnXSVoiceStateChangeEvent());

            EasyLoading.showToast('评测失败');
            return;

          }
        });

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

        WidgetsBinding.instance.addObserver(this);

      });

    }
  

    void _onVoiceXsStateChange(OnXSVoiceStateChangeEvent event,
        Emitter<TopicPictureState> emitter) async {
      emitter(XSVoiceTestState());
    }
  

    @override

    Future<void> didChangeAppLifecycleState(AppLifecycleState state) async {
      super.didChangeAppLifecycleState(state);

      Log.d('$TAG didChangeAppLifecycleState state=$state');

      if (state == AppLifecycleState.paused) {
        ///切到后台暂停音频播放、录音等
        if (audioPlayer.state == PlayerState.playing) {
          await audioPlayer.pause();
        }
        _voiceXsCancel();
      }
    }
  
    @override

    Future<void> close() async {

      pageController.dispose();

      await audioPlayer.release();
      await audioPlayer.dispose();
      await _voiceXsCancel(force: true);
      await methodChannel.dispose();

      WidgetsBinding.instance.removeObserver(this);

      return super.close();
    }
  

    ///请求数据

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

      try {

        _entity = await ListenDao.process(courseLessonId);
        emitter(RequestDataState());

      } catch (e) {
        if (e is ApiException) {

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

        }
      }
    }
  

    ///页面切换

    void _pageControllerChange(CurrentPageIndexChangeEvent event,
        Emitter<TopicPictureState> emitter) async {

      await pageResetIfNeed();

      Log.d('$TAG _pageControllerChange $_currentPage->${event.pageIndex}');

      if (_currentPage == _entity?.topics?.length) {
        return;

      }

      _currentPage = event.pageIndex;

      final topics = _entity?.topics?[_currentPage];

      if (topics?.type != 3 && topics?.type != 4) {

        if (topics?.audioUrl != null) {

          final urlStr = topics?.audioUrl ?? '';

          if (urlStr.isNotEmpty) {

            debugPrint(urlStr);
            await audioPlayer.play(UrlSource(urlStr));

          }
        }

      }

      emitter(CurrentPageIndexState());
    }
  

    ///选择

    void _selectItemLoad(
        SelectItemEvent event, Emitter<TopicPictureState> emitter) async {

      _optionSelectItem = event.selectIndex;
      emitter(SelectItemChangeState());
      if (checkAnswerRight(_optionSelectItem) == true) {
        /// 如果选择题答（选）对后题目没播完，则暂停播放题目。答错的话继续播放体验也不错
        await closePlayerResource();

  
        /// right音频长度比动效短，所以等动效完了再翻页
        AudioPlayerUtil.getInstance().playAudio(AudioPlayerUtilType.right);
        await showStarRewardDialog(context, onDismiss: () {

          _resetSelectItem();

          autoFlipPage();
        });

      } else {

        await AudioPlayerUtil.getInstance().playAudio(AudioPlayerUtilType.wrong);

        _resetSelectItem();

      }

    }

    ///重置选择
    void _selectItemReset(
        SelectItemResetEvent event, Emitter<TopicPictureState> emitter) async {
      ///用于一次完整的选择后重置视图
      emitter(SelectItemResetState());
    }
  

    ///为空则数据异常，用于是否晃动时需要
    bool? checkAnswerRight(int selectIndex) {
      CourseProcessTopics? topics = _entity?.topics?[_currentPage];

      if (topics == null ||
          topics.topicAnswerList == null ||
          selectIndex < 0 ||
          selectIndex >= topics.topicAnswerList!.length) {

        return null;
      }
      CourseProcessTopicsTopicAnswerList? answerList =
          topics.topicAnswerList?[selectIndex];
      return answerList?.correct != 0;
    }
  

    ///驰声测试

    void _voiceXsStart(
        XSVoiceStartEvent event, Emitter<TopicPictureState> emitter) async {

      await audioPlayer.stop();

      // 调用封装好的权限检查和请求方法

      bool result = await requestPermission(
          context, Permission.microphone, "录音", "用于开启录音，识别您的开口作答并给出反馈");

      if (result) {

        await methodChannel.invokeMethod('startVoice', {

          'word': event.testWord,
          'type': event.type,
          'userId': event.userId.toString()
        });

      }

    }
  

    ///终止评测

    Future<void> _voiceXsStop(

        XSVoiceStopEvent event, Emitter<TopicPictureState> emitter) async {

      await methodChannel.invokeMethod('stopVoice');

    }
  

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

    Future<void> _voiceXsCancel({bool force = false}) async {
      if (_isRecording || force) {

        await methodChannel.invokeMethod('cancelVoice');

      }

    }
  

    ///驰声评测结果

    void _voiceXsResult(
        XSVoiceResultEvent event, Emitter<TopicPictureState> emitter) async {

      _isRecording = false;
      emitter(XSVoiceTestState());

      final Map args = event.message as Map;

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

      int score = int.parse(overall);

      final voiceResult = VoiceResultType.fromScore(score);
      if (voiceResult.lottieFilePath != null) {

        AudioPlayerUtil.getInstance().playAudio(voiceResult.audioType);

        await showCheerRewardDialog(context,
            lottieFile: voiceResult.lottieFilePath!, onDismiss: () {

          autoFlipPageByVoice(score);

        });
      } else {
        await AudioPlayerUtil.getInstance().playAudio(voiceResult.audioType);

        autoFlipPageByVoice(score);

      }

    }
  

    // 暂时没用上

    void _voicePlayStateChange(VoicePlayStateChangeEvent event,
        Emitter<TopicPictureState> emitter) async {

      emitter(VoicePlayStateChange());
    }
  

    bool isAudioPlaying() {
      return audioPlayer.state == PlayerState.playing;
    }
  

    // 题目音频播放

    void _questionVoicePlay(
        VoicePlayEvent event, Emitter<TopicPictureState> emitter) async {

      await pageResetIfNeed();

      final topics = _entity?.topics?[_currentPage];

      final urlStr = topics?.audioUrl ?? '';
      await audioPlayer.play(UrlSource(urlStr),
          balance: 0.0, ctx: AudioContext());

    }

    /// 重置状态，音频播放、录音以及一些变量等。用于翻页，打断等场景
    Future<void> pageResetIfNeed() async {
      _optionSelectItem = -1;
      _isRecording = false;

  
      await closePlayerResource();
      await _voiceXsCancel();
    }
  

    void _resetSelectItem() {
      _optionSelectItem = -1;
      add(SelectItemResetEvent());
    }
  

    Future<void> closePlayerResource() async {

      if (isAudioPlaying()) {

        await audioPlayer.stop();
      }

    }
  

    ///是否是最后一页
    bool isLastPage() {
      return currentPage == _entity?.topics?.length;
    }
  

    ///自动翻页
    void autoFlipPage() {
      if (isLastPage()) {
        showStepPage();
      } else {
        // 答对后且播放完自动翻页
        pageController.nextPage(
          duration: const Duration(milliseconds: 250),
          curve: Curves.ease,
        );
      }
    }
  

    ///语音题自动翻页
    ///90分以上自动翻页
    void autoFlipPageByVoice(int score) {
      if (score >= 90) {
        autoFlipPage();
      } else {
        if (isLastPage()) {
          showStepPage();
        }
      }
    }
  

    ///展示过渡页
    void showStepPage() {
      ///如果最后一页是语音问答题，评测完后自动翻页
      sectionComplete(() {

        popPage(data: {
          'currentStep': currentPage,
          'courseLessonId': courseLessonId,
          'isCompleted': true,
          'nextSection': true
        });

      }, againSectionTap: () {

        pageController.jumpToPage(0);
      });
    }

  }