Audio Receiver

Use cases

The audio receiver is the right tool whenever the PC must act as the audio endpoint rather than the audio source. Typical scenarios:

• Testing A2DP output of a source device. Verify that a phone, tablet, or another Bluetooth player actually negotiates A2DP and starts streaming — without needing physical Bluetooth speakers on the test bench.
• Capturing phone audio on the PC. The incoming stream is delivered to the PC's audio system, where it can be routed to recording software, transcription tools, or a streaming pipeline. This is handy for podcast production, call recording, and field capture where the phone is the microphone-equipped device.
• Turning a PC into a Bluetooth speaker. A PC with a good sound system can act as a wireless playback target for a phone, tablet, or another PC. The receiver is the software half of that setup — no dedicated Bluetooth speaker required.
• QA and regression testing. Because the receiver is programmable, connection scenarios (initiation from the source, forced initiation from the PC, disconnection, reconnection) can be automated. Useful for driver vendors, headset manufacturers, and anyone validating A2DP behavior across firmware revisions.
• Integrating phone audio into PC workflows. Music, voice memos, or call audio from a phone can be mixed into a conference setup, a streaming session, or a home studio — the PC acts as the bridge between the phone and the rest of the audio chain.
• Demos and presentations. Route audio from a presenter's phone through the PC that drives the room's sound system, without changing the source device or adding a hardware receiver.

Across all of these scenarios, the receiver brings the same set of advantages:

• No extra hardware. The PC itself becomes the Bluetooth audio endpoint.
• Programmatic control. Start, stop, and observe the connection from your own application instead of relying on the Windows UI.
• Event-driven. OnConnected, OnDisconnected, and OnDeviceAdded let the application react to the stream lifecycle instead of polling.
• Cross-language. The same API is available from Delphi, C++ Builder, C#, VB.NET, and C++.
• Cohesive with the rest of the framework. Combine the receiver with the audio switcher and volume control to build a complete audio workflow on the same object model.

How it works

The workflow has five stages:

1. Pair with the source device. The source must be paired with the PC before the receiver can accept its stream. The BluetoothManager sample application shows how to pair with a Bluetooth-enabled device.
2. Install the A2DP service. Once the device is paired, enumerate its services, select the A2DP service, and install it. This is what makes the PC visible to the source as an A2DP sink.
3. Discover sources with the watcher. Start wclBluetoothAudioWatcher to enumerate nearby source devices. The watcher fires OnDeviceAdded for each source it finds; the application stores the selected device ID and passes it to the receiver.
4. Start the receiver. Call Listen with the selected device ID to wait for the source to start the stream, or call Connect to initiate the connection from the PC side. Either way, the receiver registers itself as the A2DP sink for that device.
5. React to events. OnConnected fires when the remote device starts an audio connection; OnDisconnected fires when the remote device terminates it. Both are the natural places to update UI, start monitoring with the volume classes, or log the connection lifecycle.

Limitations

Current limitations of the audio receiver:

• Only the A2DP profile is supported. Voice profiles such as HFP and HSP are out of scope.
• To disconnect a remote device from the PC side, close the receiver and start it again.
• If the remote device terminates the connection from its side, initiating a new connection from the PC side requires restarting the receiver.

Using wclBluetoothAudioReceiver

The example below starts the audio watcher, handles a discovered device, and makes the PC listen for or connect to an A2DP source.

var
  Watcher: TwclBluetoothAudioWatcher;
  Receiver: TwclBluetoothAudioReceiver;
begin
  Watcher := TwclBluetoothAudioWatcher.Create(nil);
  Receiver := TwclBluetoothAudioReceiver.Create(nil);

  Watcher.OnDeviceAdded := WatcherDeviceAdded;
  Watcher.Start;

  // In the DeviceAdded handler, store the device ID.
  // Make the PC discoverable as an A2DP receiver:
  Receiver.Listen(SelectedDeviceId);

  // Or force a connection to a specific paired device:
  Receiver.Connect;

  Receiver.Close;
  Watcher.Stop;
  Receiver.Free;
  Watcher.Free;
end;

TwclBluetoothAudioWatcher* Watcher =
    new TwclBluetoothAudioWatcher(NULL);
TwclBluetoothAudioReceiver* Receiver =
    new TwclBluetoothAudioReceiver(NULL);

Watcher->OnDeviceAdded = WatcherDeviceAdded;
Watcher->Start();

// DeviceAdded event handler:
void __fastcall TForm1::WatcherDeviceAdded(TObject* Sender,
    const String Id, const String Name)
{
    SelectedDeviceId = Id;
}

// Listen for incoming connections:
Receiver->Listen(SelectedDeviceId);

// Or force a connection:
Receiver->Connect();

Receiver->Close();
Watcher->Stop();
delete Receiver;
delete Watcher;

wclBluetoothAudioWatcher Watcher =
    new wclBluetoothAudioWatcher();
wclBluetoothAudioReceiver Receiver =
    new wclBluetoothAudioReceiver();

Watcher.OnDeviceAdded += (sender, args) =>
{
    SelectedDeviceId = args.Id;
};
Watcher.Start();

// Start listening as an A2DP receiver:
Receiver.Listen(SelectedDeviceId);

// Or initiate a connection from the PC side:
Receiver.Connect();

Receiver.Close();
Watcher.Stop();

Dim Watcher As New wclBluetoothAudioWatcher()
Dim Receiver As New wclBluetoothAudioReceiver()

AddHandler Watcher.OnDeviceAdded, Sub(sender, args)
    SelectedDeviceId = args.Id
End Sub

Watcher.Start()

' Start listening:
Receiver.Listen(SelectedDeviceId)

' Or force a connection:
Receiver.Connect()

Receiver.Close()
Watcher.Stop()

CwclBluetoothAudioWatcher Watcher;
CwclBluetoothAudioReceiver Receiver;

Watcher.OnDeviceAdded = [](void* Sender,
    const tstring& Id, const tstring& Name)
{
    SelectedDeviceId = Id;
};

Watcher.Start();

// Listen for incoming A2DP connections:
Receiver.Listen(SelectedDeviceId);

// Or initiate a connection:
Receiver.Connect();

Receiver.Close();
Watcher.Stop();