### Setup OBEX File Transfer

Source: https://context7.com/kde/bluez-qt/llms.txt

Initializes the OBEX manager, creates an FTP session with a specified device, and demonstrates various file operations including listing, changing directories, downloading, uploading, creating folders, and deleting files. Ensure OBEX initialization is successful before proceeding with session creation.

```cpp
#include <BluezQt/ObexManager>
#include <BluezQt/InitObexManagerJob>
#include <BluezQt/ObexFileTransfer>
#include <BluezQt/ObexFileTransferEntry>
#include <BluezQt/PendingCall>

void setupObexFileTransfer(const QString &deviceAddress) {
    BluezQt::ObexManager *obexManager = new BluezQt::ObexManager(this);
    BluezQt::InitObexManagerJob *initJob = obexManager->init();
    initJob->start();

    connect(initJob, &BluezQt::InitObexManagerJob::result,
            [obexManager, deviceAddress](BluezQt::InitObexManagerJob *job) {
        if (job->error()) {
            qWarning() << "OBEX init failed:" << job->errorText();
            return;
        }

        // Create FTP session to device
        QVariantMap args;
        args["Target"] = "ftp";  // Options: ftp, opp, pbap, map, sync

        BluezQt::PendingCall *sessionCall = obexManager->createSession(deviceAddress, args);
        connect(sessionCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
            if (call->error()) {
                qWarning() << "Session creation failed:" << call->errorText();
                return;
            }

            QDBusObjectPath sessionPath = call->value().value<QDBusObjectPath>();
            qDebug() << "Session created:" << sessionPath.path();

            // Create file transfer object
            BluezQt::ObexFileTransfer *ftp = new BluezQt::ObexFileTransfer(sessionPath);

            // List current directory
            BluezQt::PendingCall *listCall = ftp->listFolder();
            connect(listCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
                if (call->error()) {
                    qWarning() << "List failed:" << call->errorText();
                    return;
                }

                QList<BluezQt::ObexFileTransferEntry> entries =
                    call->value().value<QList<BluezQt::ObexFileTransferEntry>>();
                for (const auto &entry : entries) {
                    qDebug() << entry.name() << entry.size() << entry.type();
                }
            });

            // Change directory
            ftp->changeFolder("Documents");

            // Download a file
            BluezQt::PendingCall *getCall = ftp->getFile("/tmp/downloaded.txt", "remote_file.txt");
            connect(getCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
                if (call->error() == BluezQt::PendingCall::NoError) {
                    qDebug() << "File downloaded successfully";
                }
            });

            // Upload a file
            ftp->putFile("/tmp/local_file.txt", "uploaded.txt");

            // Create folder
            ftp->createFolder("NewFolder");

            // Delete file
            ftp->deleteFile("old_file.txt");
        });
    });
}
```

--------------------------------

### Manage Bluetooth Adapter Properties and Discovery

Source: https://context7.com/kde/bluez-qt/llms.txt

Use this C++ code to get adapter properties, set its name and power state, configure discoverability, set discovery filters for BLE devices, and start device discovery. Connect to signals to receive notifications about found devices.

```cpp
#include <BluezQt/Adapter>
#include <BluezQt/PendingCall>

void manageAdapter(BluezQt::AdapterPtr adapter) {
    // Get adapter properties
    qDebug() << "Adapter UBI:" << adapter->ubi();           // e.g., "/org/bluez/hci0"
    qDebug() << "Address:" << adapter->address();            // e.g., "1C:E5:C3:BC:94:7E"
    qDebug() << "Name:" << adapter->name();
    qDebug() << "Powered:" << adapter->isPowered();
    qDebug() << "Discoverable:" << adapter->isDiscoverable();
    qDebug() << "Pairable:" << adapter->isPairable();
    qDebug() << "Discovering:" << adapter->isDiscovering();

    // Set adapter name
    BluezQt::PendingCall *nameCall = adapter->setName("My Bluetooth");
    connect(nameCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Failed to set name:" << call->errorText();
        }
    });

    // Power on the adapter
    BluezQt::PendingCall *powerCall = adapter->setPowered(true);
    connect(powerCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error() == BluezQt::PendingCall::NoError) {
            qDebug() << "Adapter powered on successfully";
        }
    });

    // Make adapter discoverable for 180 seconds
    adapter->setDiscoverableTimeout(180);
    adapter->setDiscoverable(true);

    // Set discovery filter (for BLE devices only)
    QVariantMap filter;
    filter["Transport"] = "le";
    filter["DuplicateData"] = false;
    adapter->setDiscoveryFilter(filter);

    // Connect to discovery signals
    connect(adapter.data(), &BluezQt::Adapter::deviceAdded, [](BluezQt::DevicePtr device) {
        qDebug() << "Device found:" << device->name() << device->address();
    });

    // Start device discovery
    BluezQt::PendingCall *discoverCall = adapter->startDiscovery();
    connect(discoverCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Discovery failed:" << call->errorText();
        } else {
            qDebug() << "Discovery started";
        }
    });
}

```

--------------------------------

### Implement Custom Bluetooth Profile (RFCOMM/L2CAP)

Source: https://context7.com/kde/bluez-qt/llms.txt

Create a custom Bluetooth profile by inheriting from BluezQt::Profile. This example implements a Serial Port Profile (SPP) using RFCOMM. It handles new connections, data reception, and disconnection requests. Ensure the profile name, channel, and UUID are correctly set.

```cpp
#include <BluezQt/Profile>
#include <BluezQt/Request>
#include <BluezQt/Manager>
#include <QLocalSocket>
#include <QDBusUnixFileDescriptor>

class SerialPortProfile : public BluezQt::Profile
{
    Q_OBJECT
public:
    explicit SerialPortProfile(QObject *parent = nullptr)
        : BluezQt::Profile(parent)
    {
        setName("Serial Port Profile");
        setChannel(1);  // RFCOMM channel (0 = auto)
        setRequireAuthentication(true);
        setRequireAuthorization(false);
        setAutoConnect(true);
    }

    QDBusObjectPath objectPath() const override {
        return QDBusObjectPath("/org/example/serialport");
    }

    QString uuid() const override {
        return BluezQt::Services::SerialPort;  // SPP UUID
    }

    void newConnection(BluezQt::DevicePtr device,
                      const QDBusUnixFileDescriptor &fd,
                      const QVariantMap &properties,
                      const BluezQt::Request<> &request) override {
        qDebug() << "New connection from:" << device->name();

        // Create socket from file descriptor
        QSharedPointer<QLocalSocket> socket = createSocket(fd);
        if (!socket->isValid()) {
            qWarning() << "Invalid socket";
            request.reject();
            return;
        }

        // Handle incoming data
        connect(socket.data(), &QLocalSocket::readyRead, [socket]() {
            QByteArray data = socket->readAll();
            qDebug() << "Received:" << data;

            // Echo back
            socket->write("ACK: " + data);
        });

        connect(socket.data(), &QLocalSocket::disconnected, []() {
            qDebug() << "Connection closed";
        });

        request.accept();
        m_sockets.append(socket);
    }

    void requestDisconnection(BluezQt::DevicePtr device,
                             const BluezQt::Request<> &request) override {
        qDebug() << "Disconnection requested for:" << device->name();
        request.accept();
    }

    void release() override {
        qDebug() << "Profile released";
        m_sockets.clear();
    }

private:
    QList<QSharedPointer<QLocalSocket>> m_sockets;
};

// Register custom profile
void registerProfile(BluezQt::Manager *manager) {
    SerialPortProfile *profile = new SerialPortProfile(manager);

    BluezQt::PendingCall *call = manager->registerProfile(profile);
    connect(call, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Failed to register profile:" << call->errorText();
        } else {
            qDebug() << "Profile registered";
        }
    });
}
```

--------------------------------

### Control Bluetooth Media Player

Source: https://context7.com/kde/bluez-qt/llms.txt

Use the MediaPlayer interface to control playback, get track information, and monitor status changes on connected Bluetooth audio devices. Requires a valid BluezQt::DevicePtr.

```cpp
#include <BluezQt/MediaPlayer>
#include <BluezQt/MediaPlayerTrack>
#include <BluezQt/Device>

void controlMediaPlayer(BluezQt::DevicePtr device) {
    BluezQt::MediaPlayerPtr player = device->mediaPlayer();
    if (!player) {
        qDebug() << "No media player available";
        return;
    }

    // Get player info
    qDebug() << "Player name:" << player->name();
    qDebug() << "Status:" << player->status();
    qDebug() << "Position:" << player->position() << "ms";

    // Get current track info
    BluezQt::MediaPlayerTrack track = player->track();
    qDebug() << "Track:" << track.title();
    qDebug() << "Artist:" << track.artist();
    qDebug() << "Album:" << track.album();
    qDebug() << "Duration:" << track.duration() << "ms";

    // Playback controls
    player->play();
    player->pause();
    player->stop();
    player->next();
    player->previous();
    player->fastForward();
    player->rewind();

    // Set playback modes
    player->setRepeat(BluezQt::MediaPlayer::RepeatAllTracks);
    player->setShuffle(BluezQt::MediaPlayer::ShuffleAllTracks);
    player->setEqualizer(BluezQt::MediaPlayer::EqualizerOn);

    // Monitor playback changes
    connect(player.data(), &BluezQt::MediaPlayer::statusChanged,
            [](BluezQt::MediaPlayer::Status status) {
        switch (status) {
            case BluezQt::MediaPlayer::Playing:
                qDebug() << "Now playing";
                break;
            case BluezQt::MediaPlayer::Paused:
                qDebug() << "Paused";
                break;
            case BluezQt::MediaPlayer::Stopped:
                qDebug() << "Stopped";
                break;
            default:
                break;
        }
    });

    connect(player.data(), &BluezQt::MediaPlayer::trackChanged,
            [](BluezQt::MediaPlayerTrack track) {
        qDebug() << "Now playing:" << track.artist() << "-" << track.title();
    });
}
```

--------------------------------

### Configure BLE Advertising with BluezQt

Source: https://context7.com/kde/bluez-qt/llms.txt

Creates a custom advertisement class and registers it via the LEAdvertisingManager. Ensure the adapter supports LE advertising before registration.

```cpp
#include <BluezQt/LEAdvertisement>
#include <BluezQt/LEAdvertisingManager>
#include <BluezQt/Adapter>

class MyAdvertisement : public BluezQt::LEAdvertisement
{
    Q_OBJECT
public:
    explicit MyAdvertisement(QObject *parent = nullptr)
        : BluezQt::LEAdvertisement(
            {BluezQt::Services::HeartRate},  // Advertised service UUIDs
            parent
        )
    {
        // Set service data
        QHash<QString, QByteArray> serviceData;
        serviceData[BluezQt::Services::HeartRate] = QByteArray::fromHex("0150");
        setServiceData(serviceData);

        // Set manufacturer data (company ID 0x004C = Apple)
        QHash<quint16, QByteArray> mfrData;
        mfrData[0x004C] = QByteArray::fromHex("0215");
        setManufacturerData(mfrData);
    }

    void release() override {
        qDebug() << "Advertisement released";
        deleteLater();
    }
};

void startAdvertising(BluezQt::AdapterPtr adapter) {
    BluezQt::LEAdvertisingManagerPtr advManager = adapter->leAdvertisingManager();
    if (!advManager) {
        qWarning() << "LE Advertising not supported";
        return;
    }

    MyAdvertisement *advertisement = new MyAdvertisement(this);

    BluezQt::PendingCall *call = advManager->registerAdvertisement(advertisement);
    connect(call, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Failed to register advertisement:" << call->errorText();
        } else {
            qDebug() << "Advertising started";
        }
    });
}
```

--------------------------------

### Define Executable and Source Files

Source: https://github.com/kde/bluez-qt/blob/master/tools/bluezapi2qt/CMakeLists.txt

Defines the main executable 'bluezapi2qt' and lists all its source files. Ensure all listed files are present in the build directory.

```cmake
add_executable(bluezapi2qt
    BluezApiParser.cpp
    Comment.cpp
    CppGenerator.cpp
    Interface.cpp
    Method.cpp
    Methods.cpp
    Parameter.cpp
    Properties.cpp
    Property.cpp
    TypeAnnotation.cpp
    XmlGenerator.cpp
    main.cpp
)
```

--------------------------------

### Initialize BluezQt Manager in C++

Source: https://context7.com/kde/bluez-qt/llms.txt

Initializes the BluezQt manager and connects to the result signal to handle initialization success or failure. This must be called before using other manager functions. It retrieves adapter and device counts and finds a usable adapter.

```cpp
#include <BluezQt/Manager>
#include <BluezQt/InitManagerJob>
#include <BluezQt/Adapter>
#include <BluezQt/Device>

// Create and initialize the manager
BluezQt::Manager *manager = new BluezQt::Manager(this);
BluezQt::InitManagerJob *initJob = manager->init();
initJob->start();

connect(initJob, &BluezQt::InitManagerJob::result, this, [manager](BluezQt::InitManagerJob *job) {
    if (job->error()) {
        qWarning() << "Failed to initialize BluezQt manager:" << job->errorText();
        return;
    }

    // Manager is now operational
    qDebug() << "Manager operational:" << manager->isOperational();
    qDebug() << "Bluetooth operational:" << manager->isBluetoothOperational();
    qDebug() << "Adapters count:" << manager->adapters().count();
    qDebug() << "Devices count:" << manager->devices().count();

    // Get usable adapter (any powered adapter)
    BluezQt::AdapterPtr adapter = manager->usableAdapter();
    if (adapter) {
        qDebug() << "Usable adapter:" << adapter->name() << adapter->address();
    }
});
```

--------------------------------

### Implement a GATT Service with BluezQt

Source: https://context7.com/kde/bluez-qt/llms.txt

Defines a custom GATT service class and registers it with the GATT manager. Requires an active BluezQt adapter instance.

```cpp
#include <BluezQt/GattApplication>
#include <BluezQt/GattService>
#include <BluezQt/GattCharacteristic>
#include <BluezQt/GattManager>
#include <BluezQt/Adapter>

class HeartRateService : public QObject
{
    Q_OBJECT
public:
    explicit HeartRateService(BluezQt::GattApplication *app) {
        // Create a primary GATT service with Heart Rate UUID
        m_service = new BluezQt::GattService(
            BluezQt::Services::HeartRate,  // "0000180d-0000-1000-8000-00805f9b34fb"
            true,  // isPrimary
            app
        );

        // Create Heart Rate Measurement characteristic
        QStringList flags = {"read", "notify"};
        m_characteristic = new BluezQt::GattCharacteristic(
            "00002a37-0000-1000-8000-00805f9b34fb",  // Heart Rate Measurement UUID
            flags,
            m_service
        );

        // Set up read callback for pull mode
        m_characteristic->setReadCallback([this]() {
            QByteArray value;
            value.append(static_cast<char>(0x00));  // Flags
            value.append(static_cast<char>(m_heartRate));  // Heart rate value
            return value;
        });

        // Start notifications
        m_characteristic->startNotify();
    }

    void setHeartRate(quint8 rate) {
        m_heartRate = rate;
        QByteArray value;
        value.append(static_cast<char>(0x00));
        value.append(static_cast<char>(rate));
        m_characteristic->writeValue(value);  // Notifies connected clients
    }

private:
    BluezQt::GattService *m_service;
    BluezQt::GattCharacteristic *m_characteristic;
    quint8 m_heartRate = 75;
};

// Register GATT application
void registerGattApplication(BluezQt::AdapterPtr adapter) {
    BluezQt::GattApplication *app = new BluezQt::GattApplication(this);
    HeartRateService *hrService = new HeartRateService(app);

    BluezQt::GattManagerPtr gattManager = adapter->gattManager();
    if (!gattManager) {
        qWarning() << "GATT Manager not available";
        return;
    }

    BluezQt::PendingCall *call = gattManager->registerApplication(app);
    connect(call, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Failed to register GATT app:" << call->errorText();
        } else {
            qDebug() << "GATT application registered";
        }
    });
}
```

--------------------------------

### Configure BluezQt QML Module with CMake

Source: https://github.com/kde/bluez-qt/blob/master/src/imports/CMakeLists.txt

Defines the QML module, lists source files, and links required Qt and KF6 libraries.

```cmake
ecm_add_qml_module(bluezqtextensionplugin URI "org.kde.bluezqt" CLASSNAME BluezQtExtensionPlugin VERSION 1.0 DEPENDENCIES QtCore)

target_sources(bluezqtextensionplugin PRIVATE
    declarativemanager.cpp
    declarativeadapter.cpp
    declarativebattery.cpp
    declarativedevice.cpp
    declarativeinput.cpp
    declarativemediaplayer.cpp
    declarativedevicesmodel.cpp
    bluezqtextensionplugin.cpp
)

ecm_target_qml_sources(bluezqtextensionplugin SOURCES DevicesModel.qml)

target_link_libraries(bluezqtextensionplugin PRIVATE
    Qt6::Core
    Qt6::Qml
    Qt6::DBus
    KF6::BluezQt
)

ecm_finalize_qml_module(bluezqtextensionplugin DESTINATION ${KDE_INSTALL_QMLDIR})
```

--------------------------------

### Implement and Register a Custom Pairing Agent

Source: https://context7.com/kde/bluez-qt/llms.txt

Inherit from BluezQt::Agent to handle pairing callbacks and register the instance via the BluezQt::Manager. Ensure the agent is set as the default agent after successful registration.

```cpp
#include <BluezQt/Agent>
#include <BluezQt/Request>
#include <BluezQt/Manager>

class MyAgent : public BluezQt::Agent
{
    Q_OBJECT
public:
    explicit MyAgent(QObject *parent = nullptr)
        : BluezQt::Agent(parent)
    {}

    QDBusObjectPath objectPath() const override {
        return QDBusObjectPath("/org/example/agent");
    }

    Capability capability() const override {
        return DisplayYesNo;  // Options: DisplayOnly, DisplayYesNo, KeyboardOnly, NoInputNoOutput
    }

    // Called when PIN code is needed (legacy pairing)
    void requestPinCode(BluezQt::DevicePtr device, const BluezQt::Request<QString> &request) override {
        qDebug() << "PIN requested for device:" << device->name();
        // Accept with a PIN code (1-16 alphanumeric characters)
        request.accept("1234");
        // Or reject: request.reject();
    }

    // Called to display PIN code
    void displayPinCode(BluezQt::DevicePtr device, const QString &pinCode) override {
        qDebug() << "Display PIN" << pinCode << "for device:" << device->name();
    }

    // Called when passkey is needed (Secure Simple Pairing)
    void requestPasskey(BluezQt::DevicePtr device, const BluezQt::Request<quint32> &request) override {
        qDebug() << "Passkey requested for device:" << device->name();
        request.accept(123456);  // 0-999999
    }

    // Called to display passkey
    void displayPasskey(BluezQt::DevicePtr device, const QString &passkey, const QString &entered) override {
        qDebug() << "Display passkey" << passkey << "entered:" << entered;
    }

    // Called to confirm passkey matches
    void requestConfirmation(BluezQt::DevicePtr device, const QString &passkey,
                            const BluezQt::Request<> &request) override {
        qDebug() << "Confirm passkey" << passkey << "for" << device->name();
        request.accept();  // User confirms the passkey matches
    }

    // Called to authorize incoming pairing
    void requestAuthorization(BluezQt::DevicePtr device, const BluezQt::Request<> &request) override {
        qDebug() << "Authorization requested for:" << device->name();
        request.accept();
    }

    // Called to authorize service connection
    void authorizeService(BluezQt::DevicePtr device, const QString &uuid,
                         const BluezQt::Request<> &request) override {
        qDebug() << "Authorize service" << uuid << "for" << device->name();
        request.accept();
    }

    void cancel() override {
        qDebug() << "Agent request cancelled";
    }

    void release() override {
        qDebug() << "Agent released";
    }
};

// Register the agent
void registerAgent(BluezQt::Manager *manager) {
    MyAgent *agent = new MyAgent(manager);

    BluezQt::PendingCall *call = manager->registerAgent(agent);
    connect(call, &BluezQt::PendingCall::finished, [manager, agent](BluezQt::PendingCall *call) {
        if (call->error()) {
            qWarning() << "Failed to register agent:" << call->errorText();
            return;
        }
        // Make this the default agent
        manager->requestDefaultAgent(agent);
    });
}
```

--------------------------------

### Manage Bluetooth Device Properties and Actions

Source: https://context7.com/kde/bluez-qt/llms.txt

Use this snippet to retrieve device properties, set trust, connect, pair, and connect to specific profiles. It also demonstrates monitoring connection state changes.

```cpp
#include <BluezQt/Device>
#include <BluezQt/PendingCall>

void manageDevice(BluezQt::DevicePtr device) {
    // Get device properties
    qDebug() << "Device UBI:" << device->ubi();              // e.g., "/org/bluez/hci0/dev_40_79_6A_0C_39_75"
    qDebug() << "Address:" << device->address();              // e.g., "40:79:6A:0C:39:75"
    qDebug() << "Name:" << device->name();
    qDebug() << "Friendly name:" << device->friendlyName();
    qDebug() << "Type:" << BluezQt::Device::typeToString(device->type());
    qDebug() << "Icon:" << device->icon();
    qDebug() << "Paired:" << device->isPaired();
    qDebug() << "Trusted:" << device->isTrusted();
    qDebug() << "Connected:" << device->isConnected();
    qDebug() << "RSSI:" << device->rssi();
    qDebug() << "UUIDs:" << device->uuids();

    // Check device type
    switch (device->type()) {
        case BluezQt::Device::Phone:
            qDebug() << "This is a phone";
            break;
        case BluezQt::Device::Headset:
        case BluezQt::Device::Headphones:
            qDebug() << "This is an audio device";
            break;
        case BluezQt::Device::Keyboard:
        case BluezQt::Device::Mouse:
            qDebug() << "This is an input device";
            break;
        default:
            break;
    }

    // Set device as trusted
    device->setTrusted(true);

    // Connect to device
    BluezQt::PendingCall *connectCall = device->connectToDevice();
    connect(connectCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        switch (call->error()) {
            case BluezQt::PendingCall::NoError:
                qDebug() << "Connected successfully";
                break;
            case BluezQt::PendingCall::AlreadyConnected:
                qDebug() << "Device already connected";
                break;
            case BluezQt::PendingCall::Failed:
                qWarning() << "Connection failed:" << call->errorText();
                break;
            default:
                qWarning() << "Error:" << call->errorText();
        }
    });

    // Pair with device
    BluezQt::PendingCall *pairCall = device->pair();
    connect(pairCall, &BluezQt::PendingCall::finished, [](BluezQt::PendingCall *call) {
        if (call->error() == BluezQt::PendingCall::NoError) {
            qDebug() << "Pairing successful";
        } else if (call->error() == BluezQt::PendingCall::AlreadyExists) {
            qDebug() << "Already paired";
        } else {
            qWarning() << "Pairing failed:" << call->errorText();
        }
    });

    // Connect to specific profile by UUID
    device->connectProfile(BluezQt::Services::AudioSink);

    // Monitor connection state
    connect(device.data(), &BluezQt::Device::connectedChanged, [](bool connected) {
        qDebug() << "Connection state changed:" << connected;
    });
}
```

--------------------------------

### Link Libraries for Executable

Source: https://github.com/kde/bluez-qt/blob/master/tools/bluezapi2qt/CMakeLists.txt

Links the 'bluezapi2qt' executable against the Qt6::Core library. This is necessary for using Qt functionalities within the application.

```cmake
target_link_libraries(bluezapi2qt
    Qt6::Core
)
```

--------------------------------

### Implement DevicesModel for Qt Views

Source: https://context7.com/kde/bluez-qt/llms.txt

Use DevicesModel to populate a QListView with Bluetooth devices. Access device properties via model indices or specific data roles.

```cpp
#include <BluezQt/DevicesModel>
#include <BluezQt/Manager>
#include <QListView>

void setupDevicesList(BluezQt::Manager *manager, QListView *listView) {
    BluezQt::DevicesModel *model = new BluezQt::DevicesModel(manager, listView);
    listView->setModel(model);

    // Access device from model index
    connect(listView, &QListView::clicked, [model](const QModelIndex &index) {
        BluezQt::DevicePtr device = model->device(index);
        if (device) {
            qDebug() << "Selected device:" << device->name();

            // Or access via roles
            QString name = index.data(BluezQt::DevicesModel::NameRole).toString();
            QString address = index.data(BluezQt::DevicesModel::AddressRole).toString();
            bool paired = index.data(BluezQt::DevicesModel::PairedRole).toBool();
            bool connected = index.data(BluezQt::DevicesModel::ConnectedRole).toBool();

            qDebug() << name << address << "paired:" << paired << "connected:" << connected;
        }
    });
}

// Available data roles:
// UbiRole, AddressRole, NameRole, FriendlyNameRole, RemoteNameRole,
// ClassRole, TypeRole, AppearanceRole, IconRole, PairedRole, TrustedRole,
// BlockedRole, LegacyPairingRole, RssiRole, ConnectedRole, UuidsRole,
// ModaliasRole, AdapterNameRole, AdapterAddressRole, AdapterPoweredRole,
// AdapterDiscoverableRole, AdapterPairableRole, AdapterDiscoveringRole, AdapterUuidsRole
```

--------------------------------

### Define BluezQt executable tests with CMake

Source: https://github.com/kde/bluez-qt/blob/master/tests/CMakeLists.txt

Use this macro to register multiple test executables that link against Qt6 and KF6BluezQt libraries.

```cmake
include(ECMMarkAsTest)

macro(bluezqt_executable_tests)
    foreach(_testname ${ARGN})
        add_executable(${_testname} ${_testname}.cpp)
        target_link_libraries(${_testname} Qt6::DBus Qt6::Network Qt6::Test KF6BluezQt)
        ecm_mark_as_test(${_testname})
    endforeach(_testname)
endmacro()

bluezqt_executable_tests(
    adaptersreceiver
    devicereceiver
    chatprofile
    leserver
    mediaendpointconnector
)
```

--------------------------------

### QML Integration with BluezQt Manager

Source: https://context7.com/kde/bluez-qt/llms.txt

Integrates BluezQt manager into a QML Item for use in Qt Quick applications. It exposes properties like device and adapter counts, and Bluetooth operational status. A ListView is used to display devices using the BluezQt.DevicesModel.

```qml
import QtQuick
import org.kde.bluezqt as BluezQt

Item {
    readonly property BluezQt.Manager manager: BluezQt.Manager

    // Properties are automatically updated through bindings
    property int devicesCount: manager.devices.length
    property int adaptersCount: manager.adapters.length
    property bool bluetoothOn: manager.bluetoothOperational

    Component.onCompleted: {
        console.log("Manager operational:", manager.operational)
        console.log("Bluetooth blocked:", manager.bluetoothBlocked)
    }

    // Display devices in a ListView
    ListView {
        model: BluezQt.DevicesModel { }
        delegate: Text {
            text: "%1 (%2)".arg(Name).arg(Address)
        }
    }
}
```

--------------------------------

### Access Predefined Service UUIDs

Source: https://context7.com/kde/bluez-qt/llms.txt

Retrieve standard Bluetooth Classic and BLE service UUID strings using the BluezQt::Services namespace.

```cpp
#include <BluezQt/Services>

// Classic Bluetooth services
QString spp = BluezQt::Services::SerialPort;                    // "00001101-0000-1000-8000-00805F9B34FB"
QString opp = BluezQt::Services::ObexObjectPush;                // "00001105-0000-1000-8000-00805F9B34FB"
QString ftp = BluezQt::Services::ObexFileTransfer;              // "00001106-0000-1000-8000-00805F9B34FB"
QString headset = BluezQt::Services::Headset;                   // "00001108-0000-1000-8000-00805F9B34FB"
QString audioSink = BluezQt::Services::AudioSink;               // "0000110B-0000-1000-8000-00805F9B34FB"
QString a2dp = BluezQt::Services::AdvancedAudioDistribution;    // "0000110D-0000-1000-8000-00805F9B34FB"
QString avrcp = BluezQt::Services::AudioVideoRemoteControl;     // "0000110E-0000-1000-8000-00805F9B34FB"
QString hfp = BluezQt::Services::Handsfree;                     // "0000111E-0000-1000-8000-00805F9B34FB"
QString hid = BluezQt::Services::HumanInterfaceDevice;          // "00001124-0000-1000-8000-00805F9B34FB"
QString pbap = BluezQt::Services::PhonebookAccessServer;        // "0000112F-0000-1000-8000-00805F9B34FB"

// Bluetooth Low Energy services
QString genericAccess = BluezQt::Services::GenericAccess;       // "00001800-0000-1000-8000-00805f9b34fb"
QString genericAttribute = BluezQt::Services::GenericAttribute; // "00001801-0000-1000-8000-00805f9b34fb"
QString immediateAlert = BluezQt::Services::ImmediateAlert;     // "00001802-0000-1000-8000-00805f9b34fb"
QString heartRate = BluezQt::Services::HeartRate;               // "0000180d-0000-1000-8000-00805f9b34fb"
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.