liangchengyou / wow_english

  import 'dart:async';
  import 'dart:convert';
  import 'dart:io';
  import 'dart:typed_data';
  
  import 'package:audio_session/audio_session.dart';
  import 'package:chivox_aiengine/chivox_aiengine.dart';
  import 'package:flutter/services.dart';
  import 'package:path_provider/path_provider.dart';
  
  import '../core/app_consts.dart';
  
  /// 将驰声 Flutter SDK 适配为原评测桥接的事件协议，业务页面无需感知 SDK 差异。
  class ChivoxEvaluationChannel {
    ChivoxAiengine? _engine;
    Future<void>? _initializing;
    Future<dynamic> Function(MethodCall)? _methodCallHandler;
    int _sessionId = 0;
    bool _active = false;
    bool _stopping = false;
    bool _stopNotified = false;
    String? _recordFilePath;
  
    void setMethodCallHandler(
        Future<dynamic> Function(MethodCall)? methodCallHandler) {
      _methodCallHandler = methodCallHandler;
    }
  
    Future<T?> invokeMethod<T>(String method, [dynamic arguments]) async {
      final params = _asStringMap(arguments);
      switch (method) {
        case 'initVoiceSdk':
          await _initialize();
          break;
        case 'startVoice':
          await _startInnerRecorder(params);
          break;
        case 'startLocalVoice':
          await _evaluateWaveFile(params);
          break;
        case 'stopVoice':
          await _stop();
          break;
        case 'cancelVoice':
          await _cancel(notify: true);
          break;
        default:
          throw MissingPluginException('Unsupported evaluation method: $method');
      }
      return null;
    }
  
    Future<void> dispose() async {
      _sessionId++;
      await _cancel(notify: false);
      final engine = _engine;
      _engine = null;
      _initializing = null;
      await engine?.destroy();
      _methodCallHandler = null;
    }
  
    Future<void> _initialize() {
      if (_engine != null) return Future.value();
      return _initializing ??= _createEngine().catchError((Object error) {
        _initializing = null;
        throw error;
      });
    }
  
    Future<void> _createEngine() async {
      final supportDirectory = await getApplicationSupportDirectory();
      final resourceDirectory = Directory('${supportDirectory.path}/chivox');
      if (!await resourceDirectory.exists()) {
        await resourceDirectory.create(recursive: true);
      }
      final provisionPath = await _copyAssetIfNeeded(
        'assets/chivox/aiengine.provision',
        '${resourceDirectory.path}/aiengine.provision',
      );
      final vadPath = await _copyAssetIfNeeded(
        'assets/chivox/vad.0.13.bin',
        '${resourceDirectory.path}/vad.0.13.bin',
      );
  
      final config = jsonEncode({
        'appKey': AppConsts.chivoxAppKey,
        'secretKey': AppConsts.chivoxSecretKey,
        'provision': provisionPath,
        'vad': {
          'enable': 1,
          'res': vadPath,
          'speechLowSeek': 125,
          'sampleRate': 16000,
          'strip': 0,
        },
        'cloud': {'enable': 1},
      });
      _engine = await ChivoxAiengine.create(config);
    }
  
    Future<void> _startInnerRecorder(Map<String, String> params) async {
      await _prepareAudioSession();
      await _startEvaluation(
        params,
        audioSourceBuilder: (recordFilePath) => {
          'srcType': 'innerRecorder',
          'innerRecorderParam': {
            'channel': 1,
            'sampleBytes': 2,
            'sampleRate': 16000,
            'saveFile': recordFilePath,
          },
        },
      );
    }
  
    Future<void> _evaluateWaveFile(Map<String, String> params) async {
      final wavePath = params['voicePath'] ?? '';
      if (wavePath.isEmpty || !await File(wavePath).exists()) {
        await _emit('voiceFail', {
          'code': -1,
          'message': '录音文件不存在',
        });
        return;
      }
  
      await _startEvaluation(
        params,
        fallbackRecordPath: wavePath,
        audioSourceBuilder: (_) => {'srcType': 'outerFeed'},
        afterStarted: (sessionId) async {
          final pcmBytes = await _readWavePcm(File(wavePath));
          const chunkSize = 8192;
          for (var offset = 0;
              offset < pcmBytes.length && _isActiveSession(sessionId);
              offset += chunkSize) {
            final end = (offset + chunkSize).clamp(0, pcmBytes.length);
            final chunk = Uint8List.sublistView(pcmBytes, offset, end);
            await _engine?.feed(chunk, chunk.length);
          }
          if (_isActiveSession(sessionId)) await _stop();
        },
      );
    }
  
    Future<void> _startEvaluation(
      Map<String, String> params, {
      required Map<String, dynamic> Function(String recordFilePath)
          audioSourceBuilder,
      String? fallbackRecordPath,
      Future<void> Function(int sessionId)? afterStarted,
    }) async {
      try {
        await _initialize();
        if (_active) await _cancel(notify: false);
  
        final text = _normalizeReferenceText(params['word'] ?? '');
        if (text.isEmpty) {
          throw const FormatException('评测文本不能为空');
        }
        final sessionId = ++_sessionId;
        _active = true;
        _stopping = false;
        _stopNotified = false;
        _recordFilePath = fallbackRecordPath ?? await _newRecordFilePath();
  
        final request = jsonEncode({
          'coreProvideType': 'cloud',
          'vad': {
            'vadEnable': fallbackRecordPath == null ? 1 : 0,
            'refDuration': 3,
            'speechLowSeek': 125,
          },
          'app': {'userId': params['userId'] ?? 'guest'},
          'audio': {
            'audioType': 'wav',
            'channel': 1,
            'sampleBytes': 2,
            'sampleRate': 16000,
            'compress': 'speex',
          },
          'request': {
            'coreType': 'en.sent.score',
            'refText': text,
            'rank': 100,
            'attachAudioUrl': 0,
            'result': {
              'details': {'gop_adjust': 0}
            },
          },
        });
  
        final listener = ChivoxAiengineResultListener(
          onEvalResult: (result) => _handleResult(sessionId, text, result),
          onError: (result) => unawaited(_handleError(sessionId, result)),
          onVad: (result) => _handleVad(sessionId, result),
        );
        await _engine!.start(
          audioSourceBuilder(_recordFilePath!),
          request,
          listener,
        );
        if (!_isActiveSession(sessionId)) return;
        await _emit('voiceStart', null);
        await afterStarted?.call(sessionId);
      } catch (error) {
        _active = false;
        _stopping = false;
        try {
          await _engine?.cancel();
        } catch (_) {}
        await _emit('voiceFail', {
          'code': error is PlatformException ? error.code : -1,
          'message': error.toString(),
        });
      }
    }
  
    void _handleResult(
        int sessionId, String referenceText, ChivoxAiengineResult result) {
      if (!_isActiveSession(sessionId)) return;
      try {
        final raw = jsonDecode(result.text ?? '{}') as Map<String, dynamic>;
        final resultJson = raw['result'] as Map<String, dynamic>? ?? const {};
        final detailsJson = resultJson['details'] as List<dynamic>? ?? const [];
        final details = detailsJson
            .whereType<Map>()
            .map((detail) {
              return {
                'char': detail['char']?.toString() ?? '',
                'score': _asScore(detail['score']),
              };
            })
            .where((detail) => (detail['char'] as String).isNotEmpty)
            .toList();
  
        _active = false;
        _stopping = false;
        unawaited(_emit('voiceResult', {
          'result': {
            'overall': _asScore(resultJson['overall']),
            'details': details,
            'refText': referenceText,
          },
          'audioUrl': result.recFilePath ?? _recordFilePath ?? '',
        }));
      } catch (error) {
        unawaited(_handleError(sessionId, null, error: error));
      }
    }
  
    Future<void> _handleError(
      int sessionId,
      ChivoxAiengineResult? result, {
      Object? error,
    }) async {
      if (!_isActiveSession(sessionId)) return;
      _active = false;
      _stopping = false;
      try {
        await _engine?.cancel();
      } catch (_) {}
      var code = -1;
      var message = error?.toString() ?? result?.text ?? '评测失败';
      try {
        final errorJson = jsonDecode(result?.text ?? '') as Map<String, dynamic>;
        code = _asScore(errorJson['errId']);
        message = errorJson['error']?.toString() ?? message;
      } catch (_) {}
      await _emit('voiceFail', {'code': code, 'message': message});
    }
  
    void _handleVad(int sessionId, ChivoxAiengineResult result) {
      if (!_isActiveSession(sessionId) || _stopping) return;
      try {
        final vad = jsonDecode(result.text ?? '{}') as Map<String, dynamic>;
        if (_asScore(vad['vad_status']) == 2) unawaited(_stop());
      } catch (_) {}
    }
  
    Future<void> _stop() async {
      if (!_active || _stopping) return;
      _stopping = true;
      try {
        await _engine?.stop();
        if (!_stopNotified) {
          _stopNotified = true;
          await _emit('voiceEnd', null);
        }
      } catch (error) {
        _active = false;
        _stopping = false;
        _sessionId++;
        try {
          await _engine?.cancel();
        } catch (_) {}
        await _emit('voiceFail', {
          'code': error is PlatformException ? error.code : -1,
          'message': error.toString(),
        });
      }
    }
  
    Future<void> _cancel({required bool notify}) async {
      final wasActive = _active;
      _active = false;
      _stopping = false;
      _sessionId++;
      try {
        await _engine?.cancel();
      } catch (_) {}
      if (notify && wasActive) await _emit('voiceCancel', null);
    }
  
    bool _isActiveSession(int sessionId) => _active && sessionId == _sessionId;
  
    Future<void> _prepareAudioSession() async {
      final session = await AudioSession.instance;
      await session.configure(AudioSessionConfiguration(
        avAudioSessionCategory: AVAudioSessionCategory.playAndRecord,
        avAudioSessionCategoryOptions:
            AVAudioSessionCategoryOptions.defaultToSpeaker |
                AVAudioSessionCategoryOptions.allowBluetooth,
        avAudioSessionMode: AVAudioSessionMode.spokenAudio,
        androidAudioAttributes: const AndroidAudioAttributes(
          contentType: AndroidAudioContentType.speech,
          usage: AndroidAudioUsage.voiceCommunication,
        ),
        androidAudioFocusGainType: AndroidAudioFocusGainType.gain,
        androidWillPauseWhenDucked: true,
      ));
      await session.setActive(true);
    }
  
    Future<String> _newRecordFilePath() async {
      final tempDirectory = await getTemporaryDirectory();
      final directory = Directory('${tempDirectory.path}/chivox_records');
      if (!await directory.exists()) await directory.create(recursive: true);
      return '${directory.path}/${DateTime.now().millisecondsSinceEpoch}.wav';
    }
  
    Future<String> _copyAssetIfNeeded(String assetPath, String targetPath) async {
      final data = await rootBundle.load(assetPath);
      final file = File(targetPath);
      if (!await file.exists() || await file.length() != data.lengthInBytes) {
        await file.writeAsBytes(data.buffer.asUint8List(), flush: true);
      }
      return file.path;
    }
  
    Future<Uint8List> _readWavePcm(File file) async {
      final bytes = await file.readAsBytes();
      if (bytes.length < 12 || ascii.decode(bytes.sublist(0, 4)) != 'RIFF') {
        return bytes;
      }
      var offset = 12;
      final byteData = ByteData.sublistView(bytes);
      while (offset + 8 <= bytes.length) {
        final chunkName =
            ascii.decode(bytes.sublist(offset, offset + 4), allowInvalid: true);
        final chunkLength = byteData.getUint32(offset + 4, Endian.little);
        final dataStart = offset + 8;
        final dataEnd = (dataStart + chunkLength).clamp(0, bytes.length);
        if (chunkName == 'data') {
          return Uint8List.sublistView(bytes, dataStart, dataEnd);
        }
        offset = dataEnd + (chunkLength.isOdd ? 1 : 0);
      }
      throw const FormatException('无效的 WAV 文件');
    }
  
    Future<void> _emit(String method, dynamic arguments) async {
      await _methodCallHandler?.call(MethodCall(method, arguments));
    }
  
    Map<String, String> _asStringMap(dynamic arguments) {
      if (arguments is! Map) return const {};
      return arguments
          .map((key, value) => MapEntry(key.toString(), value?.toString() ?? ''));
    }
  
    int _asScore(dynamic value) {
      if (value is num) return value.round();
      return double.tryParse(value?.toString() ?? '')?.round() ?? 0;
    }
  
    String _normalizeReferenceText(String text) => text
        .trim()
        .replaceAll('’', "'")
        .replaceAll('‘', "'")
        .replaceAll('“', '"')
        .replaceAll('”', '"')
        .replaceAll('，', ',')
        .replaceAll('。', '.')
        .replaceAll('？', '?')
        .replaceAll('！', '!');
  }