File: mediatransport.h

package info (click to toggle)
bluez-qt 5.62.0-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 1,708 kB
  • sloc: cpp: 14,071; xml: 424; ansic: 318; sh: 22; makefile: 9
file content (142 lines) | stat: -rw-r--r-- 4,110 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
 * BluezQt - Asynchronous BlueZ wrapper library
 *
 * Copyright (C) 2019 Manuel Weichselbaumer <mincequi@web.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) version 3, or any
 * later version accepted by the membership of KDE e.V. (or its
 * successor approved by the membership of KDE e.V.), which shall
 * act as a proxy defined in Section 6 of version 3 of the license.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <QObject>

#include "bluezqt_export.h"
#include "mediatypes.h"
#include "tpendingcall.h"

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();

    /**
     * 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;

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:
    explicit MediaTransport(const QString &path, const QVariantMap &properties);

    class MediaTransportPrivate *const d;

    friend class MediaTransportPrivate;
    friend class DevicePrivate;
};

} // namespace BluezQt