Skip to content

Audio Recorder#

Allows recording audio in Flet apps.

Platform Support#

Platform Windows macOS Linux iOS Android Web
Supported ✅ ✅ ✅ ✅ ✅ ✅

Usage#

To use AudioRecorder service add flet-audio-recorder package to your project dependencies:

uv add flet-audio-recorder

pip install flet-audio-recorder  # (1)!
  1. After this, you will have to manually add this package to your requirements.txt or pyproject.toml.

Linux

Audio encoding on Linux is provided by fmedia and must be installed separately.

Example#

import logging

import flet_audio_recorder as far

import flet as ft

logging.basicConfig(level=logging.DEBUG)


def main(page: ft.Page):
    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
    page.appbar = ft.AppBar(title=ft.Text("Audio Recorder"), center_title=True)

    path = "test-audio-file.wav"

    def show_snackbar(message):
        page.show_dialog(ft.SnackBar(ft.Text(message)))

    async def handle_recording_start(e: ft.Event[ft.Button]):
        show_snackbar("Starting recording...")
        await recorder.start_recording(output_path=path)

    async def handle_recording_stop(e: ft.Event[ft.Button]):
        output_path = await recorder.stop_recording()
        show_snackbar(f"Stopped recording. Output Path: {output_path}")
        if page.web and output_path is not None:
            await page.launch_url(output_path)

    async def handle_list_devices(e: ft.Event[ft.Button]):
        o = await recorder.get_input_devices()
        show_snackbar(f"Input Devices: {', '.join([f'{d.id}:{d.label}' for d in o])}")

    async def handle_has_permission(e: ft.Event[ft.Button]):
        try:
            status = await recorder.has_permission()
            show_snackbar(f"Audio Recording Permission status: {status}")
        except Exception as e:
            show_snackbar(f"Error checking permission: {e}")

    async def handle_pause(e: ft.Event[ft.Button]):
        print(f"isRecording: {await recorder.is_recording()}")
        if await recorder.is_recording():
            await recorder.pause_recording()

    async def handle_resume(e: ft.Event[ft.Button]):
        print(f"isPaused: {await recorder.is_paused()}")
        if await recorder.is_paused():
            await recorder.resume_recording()

    async def handle_audio_encoder_test(e: ft.Event[ft.Button]):
        print(await recorder.is_supported_encoder(far.AudioEncoder.WAV))

    recorder = far.AudioRecorder(
        configuration=far.AudioRecorderConfiguration(encoder=far.AudioEncoder.WAV),
        on_state_change=lambda e: print(f"State Changed: {e.data}"),
    )

    page.add(
        ft.Button(content="Start Audio Recorder", on_click=handle_recording_start),
        ft.Button(content="Stop Audio Recorder", on_click=handle_recording_stop),
        ft.Button(content="List Devices", on_click=handle_list_devices),
        ft.Button(content="Pause Recording", on_click=handle_pause),
        ft.Button(content="Resume Recording", on_click=handle_resume),
        ft.Button(content="WAV Encoder Support", on_click=handle_audio_encoder_test),
        ft.Button(
            content="Get Audio Recording Permission Status",
            on_click=handle_has_permission,
        ),
    )


ft.run(main)

Description#

Inherits: Service

A control that allows you to record audio from your device.

This control can record audio using different audio encoders and also allows configuration of various audio recording parameters such as noise suppression, echo cancellation, and more.

Properties

Events

Methods

Properties#

configuration #

configuration: AudioRecorderConfiguration = field(
    default_factory=lambda: AudioRecorderConfiguration()
)

The default configuration of the audio recorder.

Events#

on_state_change #

on_state_change: (
    EventHandler[AudioRecorderStateChangeEvent] | None
) = None

Event handler that is called when the state of the audio recorder changes.

Methods#

cancel_recording #

cancel_recording()

Cancels the current audio recording.

get_input_devices #

get_input_devices() -> list[InputDevice]

Retrieves the available input devices for recording.

Returns:

has_permission #

has_permission() -> bool

Checks if the app has permission to record audio.

Returns:

  • bool –

    True if the app has permission, False otherwise.

is_paused #

is_paused() -> bool

Checks whether the audio recorder is currently paused.

Returns:

  • bool –

    True if the recorder is paused, False otherwise.

is_recording #

is_recording() -> bool

Checks whether the audio recorder is currently recording.

Returns:

  • bool –

    True if the recorder is currently recording, False otherwise.

is_supported_encoder #

is_supported_encoder(encoder: AudioEncoder) -> bool

Checks if the given audio encoder is supported by the recorder.

Parameters:

Returns:

  • bool –

    True if the encoder is supported, False otherwise.

pause_recording #

pause_recording()

Pauses the ongoing audio recording.

resume_recording #

resume_recording()

Resumes a paused audio recording.

start_recording #

start_recording(
    output_path: str | None = None,
    configuration: AudioRecorderConfiguration | None = None,
) -> bool

Starts recording audio and saves it to the specified output path.

If not on the web, the output_path parameter must be provided.

Parameters:

  • output_path (str | None, default: None ) –

    The file path where the audio will be saved. It must be specified if not on web.

  • configuration (AudioRecorderConfiguration | None, default: None ) –

    The configuration for the audio recorder. If None, the AudioRecorder.configuration will be used.

Returns:

  • bool –

    True if recording was successfully started, False otherwise.

Raises:

  • ValueError –

    If output_path is not provided on platforms other than web.

stop_recording #

stop_recording() -> str | None

Stops the audio recording and optionally returns the path to the saved file.

Returns:

  • str | None –

    The file path where the audio was saved or None if not applicable.