iOS Conflict with Voice Memos/any other app Interrupts and Discards Background Audio Recording

[mishalbutt114]

I'm facing a background recording issue on iOS when another app like Voice Memos is used.

My React Native app records audio in the background (using react-native-audio-recorder-player). However, when the Voice Memos app starts recording, the following occurs:

My app's background recording is interrupted or paused silently.

After Voice Memos is done recording and closed, returning to my app shows that the previously recorded audio has been lost or removed — it doesn’t resume and no audio file is saved.

This seems to be an iOS-level microphone resource conflict. Voice Memos takes over exclusive access to the microphone, and when it finishes, my app doesn’t recover or retain the existing audio session/data.

Expected Behavior:

When another app like Voice Memos interrupts recording, my app should detect this and gracefully pause, preserving the already recorded audio.

After the interruption ends, my app should still have access to the previously recorded audio file, even if recording cannot resume.

Any guidance or help on resolving this would be greatly appreciated.

[nomanakram199]

same issue

[vishalnaikawadi]

I faced this issue with phone calls (whether you're dialing or receiving). I didn't use the default pause/resume functions that come with the library. Instead, I went with a segmentation approach. Basically, on interruption, I stop the recording and create a segment. When the recording resumes, I start a new segment. When the user saves the recording (I have a save button in the UI), I stitch these segments into a single file.

There are two types of interruptions: one is when another app uses the microphone (like phone calls or the Voice Memos app), and the other is when a media app steals audio focus (like Instagram or YouTube).
To handle the first scenario, I added the following code on the iOS native side:

//AudioSessionManager.h

#import <React/RCTEventEmitter.h>
#import <React/RCTBridgeModule.h>

@interface AudioSessionManager : RCTEventEmitter <RCTBridgeModule>
@end

and

//AudioSessionManager.m

#import "AudioSessionManager.h"
#import <AVFoundation/AVFoundation.h>

@implementation AudioSessionManager {
  BOOL hasListeners;
}

RCT_EXPORT_MODULE();

// Start observing
- (NSArray<NSString *> *)supportedEvents {
  return @[@"AudioSessionInterruptionBegan", @"AudioSessionInterruptionEnded"];
}

- (void)startObserving {
  hasListeners = YES;
  [[NSNotificationCenter defaultCenter] addObserver:self
                                           selector:@selector(handleInterruption:)
                                               name:AVAudioSessionInterruptionNotification
                                             object:nil];
}

- (void)stopObserving {
  hasListeners = NO;
  [[NSNotificationCenter defaultCenter] removeObserver:self
                                                  name:AVAudioSessionInterruptionNotification
                                                object:nil];
}

// JS-callable method to manually set session
RCT_EXPORT_METHOD(setCategoryForRecording)
{
  dispatch_async(dispatch_get_main_queue(), ^{
    [self configureAudioSession];
  });
}

// Configures audio session
- (void)configureAudioSession {
  NSError *error = nil;
  AVAudioSession *session = [AVAudioSession sharedInstance];

  BOOL success = [session setCategory:AVAudioSessionCategoryPlayAndRecord
                                 mode:AVAudioSessionModeDefault
                              options:(AVAudioSessionCategoryOptionMixWithOthers |
                                       AVAudioSessionCategoryOptionDefaultToSpeaker |
                                       AVAudioSessionCategoryOptionAllowBluetooth)
                                error:&error];

  if (!success) {
    NSLog(@"❌ Failed to set audio session category: %@", error.localizedDescription);
    return;
  }

  success = [session setActive:YES error:&error];
  if (!success) {
    NSLog(@"❌ Failed to activate audio session: %@", error.localizedDescription);
  } else {
    NSLog(@"✅ Audio session configured successfully.");
  }
}

// Interruption callback
- (void)handleInterruption:(NSNotification *)notification {
  NSDictionary *info = notification.userInfo;
  AVAudioSessionInterruptionType type = [info[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];

  if (type == AVAudioSessionInterruptionTypeBegan) {
    NSLog(@"🔇 Interruption began");
    if (hasListeners) {
      [self sendEventWithName:@"AudioSessionInterruptionBegan" body:@{}];
    }
  } else if (type == AVAudioSessionInterruptionTypeEnded) {
    NSLog(@"🎧 Interruption ended");
    if (hasListeners) {
      [self sendEventWithName:@"AudioSessionInterruptionEnded" body:@{}];
    }
  }
}

@end

Then on the react native side:

    useEffect(() => {
        
        const sub1 = audioEvents.addListener('AudioSessionInterruptionBegan', () => {
            //stop here
        });
        
        const sub2 = audioEvents.addListener('AudioSessionInterruptionEnded', () => {
            //start new recording here
        });
        
    
        return () => {
            sub1.remove();
            sub2.remove();
        };
    }, []);

Note: This is a basic implementation. I found that starting the recording fails in the background, so I used a separate useRef to track the interruption end event. When the app state becomes 'active', I resume the recording by starting a new segment.

I think this should be enough to solve your issue @mishalbutt114

For interruptions from media apps such as Instagram or YouTube, the above approach didn’t work as expected. After struggling for a few hours, I finally decided to fork the repository and comment out the interruption-related code.
You can either fork the repository or patch the changes, but I’d suggest forking—since patching can sometimes get overwritten when running npm install.

In RNAudioRecordingPlayer.swift comment out pauseRecorder and resumeRecorder as below

        switch interruptionType {
        case AVAudioSession.InterruptionType.began.rawValue:
//             pauseRecorder { _ in } rejecter: { _, _, _ in }
            break
        case AVAudioSession.InterruptionType.ended.rawValue:
//             resumeRecorder { _ in } rejecter: { _, _, _ in }
            break
        default:
            break
        }

In my case I also wanted to record the audio coming from the other media apps, so I changed

try audioSession.setCategory(.playAndRecord, mode: avMode, options: [AVAudioSession.CategoryOptions.defaultToSpeaker, AVAudioSession.CategoryOptions.allowBluetooth])

to this:

try audioSession.setCategory(.playAndRecord, mode: avMode, options: [.duckOthers, .mixWithOthers, .defaultToSpeaker, .allowBluetooth])

This is so far working perfectly fine for me. I haven't tested all the cases, if you came across any please let me know.

[collskin]

@vishalnaikawadi what you have done on Android side to prevent recording from failing on phone calls?

[vishalnaikawadi]

@vishalnaikawadi what you have done on Android side to prevent recording from failing on phone calls?

I am not using it on Android, my use case is slightly different. But I believe commenting piece of code in the library itself should solve the problem.

[hyochan]

NitroModule support is available starting in version 4.0.0 via #661. Would anyone be willing to give it a test run?

[hyochan]

Currently solving issue related to nitromodule https://github.com/hyochan/react-native-audio-recorder-player/pull/659#issuecomment-3059855882

[hyochan]

Would you kindly try 5.0.0-rc.1 by installing with npm install react-native-audio-recorder-player@next?

[mysticmew7]

@vishalnaikawadi How did you stitch the segments into a single file?

[ayushhyadav]

I'm encountering the same problem. so i create custom native module and its working no require dependency