mediatransport.h

/*
 * BluezQt - Asynchronous BlueZ wrapper library
 *
 * SPDX-FileCopyrightText: 2019 Manuel Weichselbaumer <mincequi@web.de>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
#ifndef BLUEZQT_MEDIATRANSPORT_H
#define BLUEZQT_MEDIATRANSPORT_H
 
#include <QObject>
 
#include "bluezqt_export.h"
#include "mediatypes.h"
#include "tpendingcall.h"
 
#include <memory>
 
namespace BluezQt
{
class PendingCall;
 
/**
 * @class BluezQt::MediaTransport mediatransport.h <BluezQt/MediaTransport>
 *
 * Media transport.
 *
 * This class represents a media transport interface.
 */
class BLUEZQT_EXPORT MediaTransport : public QObject
{
    Q_OBJECT
    Q_PROPERTY(State state READ state NOTIFY stateChanged)
    Q_PROPERTY(quint16 volume READ volume NOTIFY volumeChanged)
 
public:
    /** Indicates the state of the transport. */
    enum class State {
        Idle,
        Pending,
        Active,
    };
    Q_ENUM(State)
 
    /**
     * Destroys a MediaTransport object.
     */
    ~MediaTransport() override;
 
    /**
     * Returns the (audio) configuration of the transport.
     *
     * @return configuration of transport
     */
    AudioConfiguration audioConfiguration() const;
 
    /**
     * Returns the state of the transport.
     *
     * @return state of transport
     */
    State state() const;
 
    /**
     * Returns the volume of the transport.
     *
     * The volume is a percentage of the maximum. The value 0x00 corresponds to 0%.
     * The value 0x7F corresponds to 100%. Scaling should be applied to achieve
     * values between these two. The existence of this scale does not impose any
     * restriction on the granularity of the volume control scale on the target.
     * As this command specifies a percentage rather than an absolute dB level
     * the controller should exercise caution when sending this command.
     *
     * @return volume of transport
     */
    quint16 volume() const;
 
    /**
     * Sets the volume of the transport.
     *
     * Only works when the transport was acquired by the sender.
     *
     * @param quint16 volume of the transport in the range [0x00..0x7F] (0-127)
     *
     * @return void pending call
     * @since 6.6
     */
    PendingCall *setVolume(quint16 volume);
 
public Q_SLOTS:
    /**
     * Acquire transport file descriptor and the MTU for read
     * and write respectively.
     *
     * Possible errors: PendingCall::NotAuthorized, PendingCall::Failed
     *
     * @return <fd, uint16, uint16> pending call
     */
    TPendingCall<QDBusUnixFileDescriptor, uint16_t, uint16_t> *acquire();
 
    /**
     * Acquire transport file descriptor only if the transport
     * is in "pending" state at the time the message is
     * received by BlueZ. Otherwise no request will be sent
     * to the remote device and the function will just fail
     * with org.bluez.Error.NotAvailable.
     *
     * Possible errors: PendingCall::NotAuthorized, PendingCall::Failed, PendingCall::NotAvailable
     *
     * @return <fd, uint16, uint16> pending call
     */
    TPendingCall<QDBusUnixFileDescriptor, uint16_t, uint16_t> *tryAcquire();
 
    /**
     * Releases file descriptor.
     *
     * @return void pending call
     */
    TPendingCall<void> *release();
 
Q_SIGNALS:
    /**
     * Indicates that transport's state have changed.
     */
    void stateChanged(State state);
 
    /**
     * Indicates that transport's volume have changed.
     */
    void volumeChanged(quint16 volume);
 
private:
    BLUEZQT_NO_EXPORT explicit MediaTransport(const QString &path, const QVariantMap &properties);
 
    std::unique_ptr<class MediaTransportPrivate> const d;
 
    friend class MediaTransportPrivate;
    friend class DevicePrivate;
};
 
} // namespace BluezQt
 
#endif