Microphone Permission: Essence, Access Types and Working Principle

What is Microphone Permission

Microphone Permission is a privacy protection mechanism that prevents unauthorized audio recording from the device microphone. Mobile platforms consider the microphone one of the most sensitive resources because audio recording can capture personal conversations, surrounding environment, and confidential information.

Android classifies RECORD_AUDIO as a dangerous permission, and iOS requires the mandatory addition of the NSMicrophoneUsageDescription key in Info.plist. On both platforms, the request is performed at runtime, and the user can revoke the permission at any time through system settings. The system recording indicator (orange dot on iOS, green indicator on Android 12+) signals to the user that the application is currently using the microphone.

According to a study by Pew Research Center (2024), 54% of mobile device users have refused microphone access to an application at least once. The main reason is not understanding why the app needs audio recording. Therefore, the developer must explain the purpose of microphone usage as transparently as possible.

Microphone Permission on Android

Microphone Permission on Android is requested by declaring RECORD_AUDIO in the manifest and performing a runtime request in the application code. Starting from Android 10, microphone access is additionally regulated by restrictions for background applications.

Declaration in AndroidManifest.xml

The first step is to declare the RECORD_AUDIO permission in the manifest file. Without this declaration, the runtime request will have no effect, and the application will not be able to access the microphone.

<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.CAPTURE_AUDIO_OUTPUT" />

CAPTURE_AUDIO_OUTPUT is a system permission not available to third-party applications. It is only used by system applications to capture audio output. Regular applications only need RECORD_AUDIO for microphone recording.

Runtime Request in Kotlin

After declaring in the manifest, you need to perform a runtime request. Consider an example using AudioRecord for recording audio from the microphone.

private val recordAudioPermission =
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
    if (granted) {
        startRecording()
    } else {
        showMicrophoneExplanation()
    }
}

fun startRecording() {
    val sampleRate = 44100
    val bufferSize = AudioRecord.getMinBufferSize(sampleRate,
        AudioFormat.CHANNEL_IN_MONO,
        AudioFormat.ENCODING_PCM_16BIT)
    val recorder = AudioRecord(MediaRecorder.AudioSource.MIC,
        sampleRate, AudioFormat.CHANNEL_IN_MONO,
        AudioFormat.ENCODING_PCM_16BIT, bufferSize)
    recorder.startRecording()
    // Recording audio data to buffer
}

Handling Recording State

It is important to properly handle the audio recording lifecycle. When the application moves to the background on Android 9 and above, microphone recording may be paused by the system. Starting from Android 10, background microphone access is additionally restricted: an app in the background cannot start recording, and active recording is paused. Background recording requires MediaProjection or a Service with a notification.

Microphone Permission on iOS

Microphone Permission on iOS is configured through the NSMicrophoneUsageDescription key in Info.plist and calling the AVAudioSession.requestRecordPermission method. Apple requires a mandatory explanation of the microphone usage reason in the request dialog.

Configuring Info.plist

The NSMicrophoneUsageDescription key is mandatory for any application that requests microphone access. Without it, the application will crash when attempting to record audio.

<key>NSMicrophoneUsageDescription</key>
<string>The app needs microphone access to record voice notes and send audio messages.</string>

Request in Swift

Requesting microphone access on iOS is performed through AVAudioSession. After receiving the response, the application configures the audio session and starts recording.

import AVFAudio

func requestMicrophoneAccess() {
    AVAudioSession.sharedInstance().requestRecordPermission { granted in
        DispatchQueue.main.async {
            if granted {
                self.configureAudioSession()
                self.startAudioRecording()
            } else {
                self.redirectToSettings()
            }
        }
    }
}

private func configureAudioSession() {
    let session = AVAudioSession.sharedInstance()
    do {
        try session.setCategory(.playAndRecord, mode: .default)
        try session.setActive(true)
    } catch {
        print("Audio session error: \(error)")
    }
}

Recording Indicator

On iOS 14 and above, an application using the microphone displays an orange indicator in the status bar. The user can see which application is currently recording audio. If the application uses the microphone in the background without a valid reason, Apple may reject the update. AVAudioSession allows you to configure the category and mode of the audio session, determining the application's behavior when transitioning to the background.

Audio Capture Scenarios

Microphone usage scenarios in mobile applications are diverse: from simple voice recording to complex real-time audio stream processing.

Voice Messages and Notes

Messengers and note-taking apps use the microphone for recording voice messages. In this case, Microphone Permission is requested when the record button is pressed. After recording is complete, it is important to stop the audio session so that other applications can use the microphone. AVAudioSession on iOS and AudioManager on Android manage audio focus.

Speech Recognition

Applications with voice input (search, dictation, voice assistants) use the microphone in conjunction with speech recognition APIs. On Android, this is SpeechRecognizer from android.speech, on iOS — SFSpeechRecognizer from the Speech framework. Speech recognition may require an additional permission for recognition services (SPEECH on Android, SFSpeechRecognizer.requestAuthorization on iOS).

Video Calls and Streaming

Video calling applications (WebRTC, Zoom, Telegram) request Microphone Permission simultaneously with Camera Permission. In this context, it is important to request both permissions sequentially rather than simultaneously, so the user is not overwhelmed with dialogs. WebRTC uses getUserMedia for audio and video capture, but on mobile platforms, system permissions are required first.

Audio Session Configuration Settings

For high-quality recording, you need to properly configure audio session parameters. On iOS, the .playAndRecord category allows simultaneous playback and recording of sound. On Android, choosing AudioSource.MIC provides capture from the main microphone, while AudioSource.VOICE_COMMUNICATION optimizes recording for voice communication. Additionally, you can set a sampling rate of 44100 Hz and PCM 16-bit format for standard CD quality.

Handling Recording Interruptions

During audio recording, system interruptions may occur: incoming call, alarm trigger, notification from another application. On iOS, AVAudioSessionDelegate handles beginInterruption and endInterruption. On Android, AudioManager.OnAudioFocusChangeListener notifies the application about the loss or return of audio focus. Proper interruption handling allows you to save the recording during unexpected events and avoid data loss. It is recommended to pause recording when focus is lost and resume after its return with a user notification.

Audio Capture Optimization

Audio capture optimization includes configuring the sampling rate, buffer size, and encoding format. For voice messages, a frequency of 44100 Hz and mono channel are sufficient. For speech recognition, a frequency of 16000 Hz may be required.

On iOS, use AVAudioSession.setPreferredIOBufferDuration to configure recording latency. A smaller buffer reduces latency but increases CPU load. On Android, AudioRecord.getMinBufferSize returns the minimum buffer size for the given parameters. It is recommended to use a buffer no smaller than this minimum to prevent data loss when recording under high system load.

Best Practices for Working with the Microphone

Best practices for Microphone Permission are aimed at increasing user trust and meeting platform requirements.

Explain the Purpose Before Recording

Before requesting Microphone Permission, show a screen explaining why the app needs the microphone and how the recording will be used. Indicate whether the audio is transmitted to the server or processed locally. Users are significantly more likely to grant access if they understand that the recording does not leave the device. Local processing (on-device ASR) is a strong argument for trust.

Stop Recording in the Background

If the application does not require background audio recording, be sure to stop the microphone when transitioning to the background. This not only saves battery but also prevents negative user reaction upon seeing the recording indicator. On iOS, use UIApplicationDelegate methods applicationDidEnterBackground to pause recording. On Android, handle onPause and onStop in Activity or Service.

Use Recording Indicators

Show your own recording indicator (animated microphone icon or waveform) during audio capture. This informs the user that the microphone is active and reduces the risk of a negative reaction. Apple and Google recommend duplicating the system indicator with your own UI element for maximum transparency.