Inconsistent `AudioInterruptionMode` behavior: Android ignores interruptions, iOS fails to resume

[leonardmatasel-dinova]

Package version
6.1.1

Environment

• OS: Android (android 16) / iOS (26)
• Flutter version: 3.38.6

Describe the bug
I am experiencing inconsistent behavior regarding AudioInterruptionMode on both platforms when a native phone call is received during recording:

1. Android: The recording fails to pause during an incoming call. The session remains active but captures only silence, ignoring both AudioInterruptionMode.pause and AudioInterruptionMode.pauseResume configurations.
2. iOS: The recording correctly pauses when the call starts, but it fails to resume automatically after the call ends, despite using AudioInterruptionMode.pauseResume.

Add your record configuration RecordConfig(...)

const config = RecordConfig(
  encoder: encoder,
  numChannels: 2,
  noiseSuppress: true,
  echoCancel: true,
  autoGain: true,
  audioInterruption: AudioInterruptionMode.pauseResume,
);

To Reproduce
Steps to reproduce the behavior:

1. Initialize the recorder with the configuration above.
2. Start recording on a real device.
3. Receive an incoming phone call.
4. Answer the call.
5. Hang up the call.

Expected behavior
With AudioInterruptionMode.pauseResume, the recorder should:

1. Pause automatically when the phone call is answered.
2. Resume recording automatically when the call is ended.

Additional context

• On Android, I also tested with AudioInterruptionMode.pause, but the recording still ignores the interruption and keeps running during the call.
• On iOS, the interruption start is detected (it pauses), but the end of the interruption does not trigger the resume.

[llfbandit]

Thanks for the report.

[leonardmatasel-dinova]

Hi @llfbandit,

thanks for the recent fixes 🚀

I have tested the latest commits and here are my results:

• Pause: Now works correctly on both Android and iOS.
• Resume: Works perfectly on Android, but fails on iOS. On iOS, the recording pauses correctly when the interruption starts, but it does not automatically resume after the interruption ends (using AudioInterruptionMode.pauseResume).

Could you please clarify if this behavior on iOS is something that can be fixed within the package, or if it is an unavoidable restriction of the operating system?

Best regards,
Leonard

[llfbandit]

Thanks for the feedback.
On iOS, when you say that the recording doesn't resume, does it stop or stay in pause?
Any additional native log could help.

I can't clarify the issue now. This may be on my side but we never know and Apple documentation is... well... That may be on me too 😄

[leonardmatasel-dinova]

Hi @llfbandit 😃,

First of all, please apologize for the delay in my response.

I also wanted to take a moment to say that this plugin is extremely important for our application. You have done an excellent job creating it, and we really appreciate your hard work. Thank you so much! ❤️

I have conducted testing on both Android and iOS, and I hope the following details will help you reproduce the issues.

To give you full context: I have attached the small service we use in our application. We use this to synchronize the recording state between the notification and the application, as we handle recording in the background.

Our code

import 'dart:async';
import 'dart:convert';

import 'package:flutter_foreground_task/flutter_foreground_task.dart';
import 'package:record/record.dart';

@pragma('vm:entry-point')
void startAudioRecorder() {
  FlutterForegroundTask.setTaskHandler(AudioRecorderHandler());
}

class AudioRecorderHandler extends TaskHandler {
  final AudioRecorder _recorder = AudioRecorder();

  // serve per sincronizzarsi con l'arrivo delle etichette per le notifiche
  final Completer<Unit> _recordingLabelsCompleter = Completer();
  late final String _recordingNotificationStartedDescription;
  late final String _recordingNotificationPausedDescription;
  late final String _recordingNotificationStop;
  late final String _recordingNotificationPause;
  late final String _recordingNotificationResume;

  AudioRecorderHandler() {
    _recorder.onStateChanged().listen(_onRecordState);
    _recorder
        .onAmplitudeChanged(const Duration(milliseconds: 100))
        .listen(_onAmplitude);
  }

  @override
  Future<void> onStart(DateTime timestamp, TaskStarter starter) async {
    // non usata
  }

  @override
  void onRepeatEvent(DateTime timestamp) {
    // non usata
  }

  @override
  Future<void> onDestroy(DateTime timestamp, bool isTimeout) async {
    // lo rifacciamo per sicurezza
    await _recorder.stop();
    await _recorder.dispose();
  }

  @override
  Future<void> onReceiveData(Object data) async {
    if (data is String) {
      AudioRecorderAction? action;

      try {
        action = AudioRecorderAction.valueOf(data);
      } on ArgumentError {
        action = null;
      }

      if (action != null) {
        await _requestAction(action);
      } else {
        final confJson = json.decode(data);

        await _start(
          confJson['audioPath'] as String,
          confJson['labels'] as Map<String, dynamic>,
        );
      }
    }
  }

  @override
  Future<void> onNotificationButtonPressed(String id) async {
    // qui ho bisogno proprio del action id
    await _requestAction(AudioRecorderAction.valueById(id));
  }

  Future<void> _onRecordState(RecordState state) async {
    await _recordingLabelsCompleter.future;

    _sendStatus(switch (state) {
      RecordState.pause => AudioRecorderStatus.paused,
      RecordState.record => AudioRecorderStatus.started,
      RecordState.stop => AudioRecorderStatus.stopped,
    });

    final result = switch (state) {
      RecordState.pause => await FlutterForegroundTask.updateService(
        notificationTitle: _recordingNotificationPausedDescription,
        notificationButtons: [
          NotificationButton(
            id: AudioRecorderAction.resume.id,
            text: _recordingNotificationResume,
          ),
          NotificationButton(
            id: AudioRecorderAction.stop.id,
            text: _recordingNotificationStop,
          ),
        ],
      ),
      RecordState.record => await FlutterForegroundTask.updateService(
        notificationTitle: _recordingNotificationStartedDescription,
        notificationButtons: [
          NotificationButton(
            id: AudioRecorderAction.pause.id,
            text: _recordingNotificationPause,
          ),
          NotificationButton(
            id: AudioRecorderAction.stop.id,
            text: _recordingNotificationStop,
          ),
        ],
      ),
      RecordState.stop => await FlutterForegroundTask.stopService(),
    };

    if (result is ServiceRequestFailure) {
      throw result.error;
    }
  }

  void _onAmplitude(Amplitude amplitude) {
    _sendAmplitude(amplitude);
  }

  void _sendStatus(AudioRecorderStatus status) {
    FlutterForegroundTask.sendDataToMain('status:${status.name}');
  }

  void _sendAmplitude(Amplitude amplitude) {
    FlutterForegroundTask.sendDataToMain(
      'amplitude:${amplitude.current}:${amplitude.max}',
    );
  }

  Future<void> _requestAction(AudioRecorderAction action) async {
    switch (action) {
      case AudioRecorderAction.pause:
        await _pause();
      case AudioRecorderAction.resume:
        await _resume();
      case AudioRecorderAction.stop:
        await _stop();
    }
  }

  Future<void> _start(String audioPath, Map<String, dynamic> labels) async {
    const encoder = AudioEncoder.aacLc;
    const config = RecordConfig(
      encoder: encoder,
      numChannels: 2,
      noiseSuppress: true,
      echoCancel: true,
      autoGain: true,
      androidConfig: AndroidRecordConfig(),
      audioInterruption: AudioInterruptionMode.pauseResume,
    );

    // start recorder
    await _recorder.start(config, path: audioPath);

    _recordingNotificationStartedDescription =
        labels['startedDescription'] as String;
    _recordingNotificationPausedDescription =
        labels['pausedDescription'] as String;
    _recordingNotificationStop = labels['stop'] as String;
    _recordingNotificationPause = labels['pause'] as String;
    _recordingNotificationResume = labels['resume'] as String;

    _recordingLabelsCompleter.complete(unit);
  }

  Future<void> _pause() async {
    await _recorder.pause();
  }

  Future<void> _resume() async {
    await _recorder.resume();
  }

  Future<void> _stop() async {
    await _recorder.stop();
  }
}

const unit = Unit._unit;

enum Unit { _unit }

enum AudioRecorderAction {
  stop('audio_recorder.stop'),
  pause('audio_recorder.pause'),
  resume('audio_recorder.resume')
  ;

  final String id;

  const AudioRecorderAction(this.id);

  static AudioRecorderAction valueById(String id) {
    return AudioRecorderAction.values.firstWhere(
      (action) => action.id == id,
      orElse: () =>
          throw UnsupportedError('Audio recorder action $id unsupported'),
    );
  }

  static AudioRecorderAction valueOf(String name) {
    return AudioRecorderAction.values.byName(name);
  }
}

enum AudioRecorderStatus { ready, starting, started, stopping, stopped, paused }

Here are my observations and what I would like to see fixed:

---

Android

Steps to reproduce:

1. Start recording.
2. Receive an incoming call (state: ringing, not answered yet).
3. Observe the incoming samples.
4. Answer the call (recording pauses correctly).
5. Hang up (recording resumes correctly).

The Issue:
During the "ringing" phase (step 2 & 3), the samples I receive are "frozen" (they return identical values repeatedly). However, curiously, if I listen to the final generated audio file, my voice was recorded during the ringing phase even though the live samples were stuck.

Expected Behavior:
When the phone starts ringing, I expect the plugin to either:

1. Pause immediately (so no recording happens during ringing), OR
2. Return correct/live samples of my voice (instead of repeating the same values).

---

iOS

I found two distinct scenarios on iOS.

Scenario 1: Standard Call
Steps to reproduce:

1. Start recording.
2. Receive an incoming call (Result: auto-pauses, no samples returned. This is correct).
3. Answer the call.
4. Switch back to the recording app (while in call).
5. Hang up the call.

The Issue:
After hanging up, I start receiving new audio samples again (which is good), but the flutter_foreground_task plugin does not receive the "resume" event. Essentially, the data stream resumes, but the event listener doesn't trigger the resume state, causing a sync issue.
Note: When I manually stop the audio later, the generated file is correct (it contains all samples), so it is recording, just not notifying the system correctly.

Scenario 2: WhatsApp / VoIP Call
Steps to reproduce:

1. Start recording.
2. Receive an incoming call (Result: auto-pauses).
3. Answer the call.
4. Switch to the WhatsApp application (full screen).
5. Hang up the call using the WhatsApp UI.
6. Return to the recording app.

The Issue:
The recording stops completely. flutter_foreground_task receives a full STOP command instead of remaining in pause or allowing me to resume. I cannot resume the session; it effectively kills the recording.

---

I hope this helps clarify the flow. Let me know if you need any further logs or details regarding the attached service code.

Best regards,

Leonard

[llfbandit]

Thanks for the additional testing.

I'm a bit confused now on Android part. I'm unable to reproduble the issue you describe in the last message. And in the previous one, you confirmed that it was OK...
On my side, when receiving a call, the recording pauses correctly on emulator and real device...
Please confirm that you are with the latest versions of record and record_android packages.
Also, can you try with the example project? (without any disturbing or conflicting additionnal layer).

On iOS, I see the issue, a new release will land soon.