RFCOMM Server on Raspberry Pi 5 Fails to Accept Connection from Android App

[Hariprabhu13]

Platform:

Server: Raspberry Pi 5 (Debian Bookworm 64-bit)
Client: Android (Serial Bluetooth Controller App)

Problem Summary: I am using the RFCOMM server example from bluer and modified it to:

Set the adapter to pairable and discoverable
Set a custom alias ("AU79_BT")
Bind and listen on channel 3

I am also trying to support auto-pairing using bluetoothctl with the agent mode set to NoInputNoOutput.
However, I’m facing two main issues:

1. Auto-pairing does not work as expected — the Android app doesn't pair unless manually accepted or previously paired.
2. Even when the Android app reports a successful Bluetooth connection, the RFCOMM server remains stuck on listener.accept().await and never detects the connected device or reads data from the socket.

Expected Behavior:

• The server should detect the incoming connection.
• After successful RFCOMM connection, it should print the connected device name and start reading data from the socket.

Actual Behavior:

• The program is stuck at:

 Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.06s
     Running `target/debug/bt_classic`
     Adapter name: AU79_BT
     Listening on 2C:CF:67:8C:73:9A channel 3
     Waiting for Device...

• No device name is printed, and no data is received or sent.
• It never prints the connected device info or receives any data.
• From the Android app’s perspective, it shows as connected via Bluetooth, but the RFCOMM channel doesn't seem to complete the handshake or allow data transmission.

Code: I have attached my modified version of the RFCOMM server in main.rs [see full code snippet below].

Modified main.rs:

use bluer::rfcomm::{Listener, SocketAddr};
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};

mod config;
use config::save_wifi_config;

const CHANNEL: u8 = 3;

#[tokio::main]
async fn main() -> bluer::Result<()> {
    env_logger::init();

    let session = bluer::Session::new().await?;
    let adapter = session.default_adapter().await?;
    adapter.set_powered(true).await?;
    adapter.set_discoverable(true).await?;
    adapter.set_pairable(true).await?;
    adapter.set_alias("AU79_BT".to_string()).await?;

    let adapter_addr = adapter.address().await?;
    let local_sa = SocketAddr::new(adapter_addr, CHANNEL);
    let listener = Listener::bind(local_sa).await?;

    println!("\nAdapter name: {}", adapter.alias().await?);

    println!("\nListening on {} channel {}", adapter_addr, CHANNEL);

    loop {
        println!("\nWaiting for Device...");

        let (stream, addr) = match listener.accept().await {
            Ok(conn) => conn,
            Err(err) => {
                println!("\nFailed to accept connection: {}", err);
                continue;
            }
        };

        let device = adapter.device(addr.addr)?;
        let device_name = match device.name().await {
                Ok(Some(name)) => name,
                _ => "<unknown>".to_string(),
        };

        println!("\nClient connected: {} ({})", device_name, addr.addr);

        let mut reader = BufReader::new(stream);
        let mut ssid = String::new();
        let mut password = String::new();

        loop {
            let mut line = String::new();
            match reader.read_line(&mut line).await {
                Ok(0) => {
                    println!("\nClient disconnected.");
                    break;
                }
                Ok(_) => {
                    let trimmed = line.trim();
                    if trimmed.starts_with("ssid=") {
                        ssid = trimmed["ssid=".len()..].to_string();
                        println!("\nReceived SSID: {}", ssid);
                    } else if trimmed.starts_with("password=") {
                        password = trimmed["password=".len()..].to_string();
                        println!("\nReceived password.");
                    }

                    if !ssid.is_empty() && !password.is_empty() {
                        println!("\nSaving Wi-Fi credentials...");
                        if let Err(err) = save_wifi_config(&ssid, &password).await {
                            println!("\nFailed to save config: {}", err);
                        } else {
                            println!("\nWi-Fi credentials saved.");
                        }
                    }
                }
                Err(err) => {
                    println!("\nError reading from client: {}", err);
                    break;
                }
            }
        }
    }
}

Questions:

• How can I ensure auto-pairing works correctly using NoInputNoOutput for Android clients?
• Why is the RFCOMM listener.accept() call never completing even when the Android device is connected?
• What steps or changes are recommended to implement a reliable Classic Bluetooth RFCOMM read/write setup with Android clients?

Additional Notes:

• The pairing attempt seems successful at the system level, but the server is not reacting.
• I’ve verified the Android app works with other Bluetooth devices.

@surban, @dati91 I’ve been struggling with this setup for a while and would really appreciate your guidance or pointers.

[surban]

Could you first check whether this works between two Linux machines?