trimAudio method

  1. @override
Future<ConversionResult> trimAudio({
  1. required String inputPath,
  2. required String outputPath,
  3. required int startTimeMs,
  4. required int endTimeMs,
  5. required AudioFormat format,
  6. int bitRate = 128,
  7. int sampleRate = 44100,
  8. ProgressCallback? onProgress,
})
override

Trims an audio file to the specified time range

Supports both lossless and lossy trimming modes depending on format compatibility. Lossless trimming preserves original quality when possible.

inputPath - Path to the input audio file outputPath - Path where the trimmed file will be saved startTimeMs - Start time in milliseconds endTimeMs - End time in milliseconds format - Output format (see AudioFormat) bitRate - Target bit rate for lossy trimming (default: 128) sampleRate - Target sample rate for lossy trimming (default: 44100) onProgress - Optional callback for trimming progress (0.0 to 1.0)

Returns ConversionResult with trimmed file information. Throws AudioTrimmingException if trimming fails.

Implementation

@override
Future<ConversionResult> trimAudio({
  required String inputPath,
  required String outputPath,
  required int startTimeMs,
  required int endTimeMs,
  required AudioFormat format,
  int bitRate = 128,
  int sampleRate = 44100,
  ProgressCallback? onProgress,
}) async {
  // Validate arguments
  _validateFilePath(inputPath, 'inputPath');
  _validateFilePath(outputPath, 'outputPath');
  _validateTimeRange(startTimeMs, endTimeMs);
  _validateBitRate(bitRate);
  _validateSampleRate(sampleRate);

  // Set up progress listening
  StreamSubscription<dynamic>? progressSub;
  if (onProgress != null) {
    progressSub = _progressChannel.receiveBroadcastStream().listen((data) {
      if (data is Map && data['operation'] == 'trim') {
        final progress = data['progress'] as double?;
        if (progress != null) {
          onProgress(progress);
        }
      }
    });
  }

  try {
    final Map<String, dynamic> arguments = {
      'inputPath': inputPath,
      'outputPath': outputPath,
      'startTimeMs': startTimeMs,
      'endTimeMs': endTimeMs,
      'format': format.name,
      'bitRate': bitRate,
      'sampleRate': sampleRate,
    };

    final result = await methodChannel
        .invokeMethod('trimAudio', arguments)
        .timeout(const Duration(minutes: 10));

    if (result == null) {
      throw AudioTrimmingException(
        'Trimming failed: No result returned from platform',
        inputPath: inputPath,
        outputPath: outputPath,
        startTimeMs: startTimeMs,
        endTimeMs: endTimeMs,
      );
    }

    // Safely convert the result to Map<String, dynamic>
    final Map<String, dynamic> convertedResult;
    if (result is Map) {
      convertedResult = Map<String, dynamic>.from(result);
    } else {
      throw AudioTrimmingException(
        'Trimming failed: Invalid result type from platform',
        inputPath: inputPath,
        outputPath: outputPath,
        startTimeMs: startTimeMs,
        endTimeMs: endTimeMs,
      );
    }

    return ConversionResult(
      outputPath: convertedResult['outputPath'] as String,
      durationMs: convertedResult['durationMs'] as int,
      bitRate: convertedResult['bitRate'] as int,
      sampleRate: convertedResult['sampleRate'] as int,
    );
  } on PlatformException catch (e) {
    throw _convertPlatformException(e, AudioTrimmingException.new, {
      'inputPath': inputPath,
      'outputPath': outputPath,
      'startTimeMs': startTimeMs,
      'endTimeMs': endTimeMs,
    });
  } catch (e) {
    throw AudioTrimmingException(
      'Trimming failed: $e',
      originalError: e,
      inputPath: inputPath,
      outputPath: outputPath,
      startTimeMs: startTimeMs,
      endTimeMs: endTimeMs,
    );
  } finally {
    await progressSub?.cancel();
  }
}