cli-call-content.h

/*
 * This file contains D-Bus client proxy classes generated by qt-client-gen.py.
 *
 * This file can be distributed under the same terms as the specification from
 * which it was generated.
 */

#ifndef IN_TP_QT_HEADER
#error IN_TP_QT_HEADER
#endif

#include <TelepathyQt/Types>

#include <QtGlobal>

#include <QString>
#include <QObject>
#include <QVariant>

#include <QDBusPendingReply>

#include <TelepathyQt/AbstractInterface>
#include <TelepathyQt/DBusProxy>
#include <TelepathyQt/Global>

namespace Tp
{
class PendingVariant;
class PendingOperation;
}

namespace Tp
{
namespace Client
{

class TP_QT_EXPORT CallContentInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Call1.Content");
    }

    CallContentInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterface(Tp::DBusProxy *proxy);

    inline Tp::PendingVariant *requestPropertyInterfaces() const
    {
        return internalRequestProperty(QLatin1String("Interfaces"));
    }

    inline Tp::PendingVariant *requestPropertyName() const
    {
        return internalRequestProperty(QLatin1String("Name"));
    }

    inline Tp::PendingVariant *requestPropertyType() const
    {
        return internalRequestProperty(QLatin1String("Type"));
    }

    inline Tp::PendingVariant *requestPropertyDisposition() const
    {
        return internalRequestProperty(QLatin1String("Disposition"));
    }

    inline Tp::PendingVariant *requestPropertyStreams() const
    {
        return internalRequestProperty(QLatin1String("Streams"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<> Remove(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("Remove"));
        return this->connection().asyncCall(callMessage, timeout);
    }

Q_SIGNALS:
    void StreamsAdded(const Tp::ObjectPathList& streams);

    void StreamsRemoved(const Tp::ObjectPathList& streams, const Tp::CallStateReason& reason);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT CallContentInterfaceAudioControlInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Call1.Content.Interface.AudioControl");
    }

    CallContentInterfaceAudioControlInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceAudioControlInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceAudioControlInterface(Tp::DBusProxy *proxy);

    explicit CallContentInterfaceAudioControlInterface(const Tp::Client::CallContentInterface& mainInterface);

    CallContentInterfaceAudioControlInterface(const Tp::Client::CallContentInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyRequestedInputVolume() const
    {
        return internalRequestProperty(QLatin1String("RequestedInputVolume"));
    }

    inline Tp::PendingVariant *requestPropertyRequestedOutputVolume() const
    {
        return internalRequestProperty(QLatin1String("RequestedOutputVolume"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<> ReportInputVolume(int volume, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("ReportInputVolume"));
        callMessage << QVariant::fromValue(volume);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<> ReportOutputVolume(int volume, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("ReportOutputVolume"));
        callMessage << QVariant::fromValue(volume);
        return this->connection().asyncCall(callMessage, timeout);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT CallContentInterfaceDTMFInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Call1.Content.Interface.DTMF");
    }

    CallContentInterfaceDTMFInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceDTMFInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceDTMFInterface(Tp::DBusProxy *proxy);

    explicit CallContentInterfaceDTMFInterface(const Tp::Client::CallContentInterface& mainInterface);

    CallContentInterfaceDTMFInterface(const Tp::Client::CallContentInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
    {
        return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
    }

    inline Tp::PendingVariant *requestPropertyDeferredTones() const
    {
        return internalRequestProperty(QLatin1String("DeferredTones"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<> StartTone(uchar event, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("StartTone"));
        callMessage << QVariant::fromValue(event);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<> StopTone(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("StopTone"));
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("MultipleTones"));
        callMessage << QVariant::fromValue(tones);
        return this->connection().asyncCall(callMessage, timeout);
    }

Q_SIGNALS:
    void TonesDeferred(const QString& tones);

    void SendingTones(const QString& tones);

    void StoppedTones(bool cancelled);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT CallContentInterfaceMediaInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Call1.Content.Interface.Media");
    }

    CallContentInterfaceMediaInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceMediaInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceMediaInterface(Tp::DBusProxy *proxy);

    explicit CallContentInterfaceMediaInterface(const Tp::Client::CallContentInterface& mainInterface);

    CallContentInterfaceMediaInterface(const Tp::Client::CallContentInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyRemoteMediaDescriptions() const
    {
        return internalRequestProperty(QLatin1String("RemoteMediaDescriptions"));
    }

    inline Tp::PendingVariant *requestPropertyLocalMediaDescriptions() const
    {
        return internalRequestProperty(QLatin1String("LocalMediaDescriptions"));
    }

    inline Tp::PendingVariant *requestPropertyMediaDescriptionOffer() const
    {
        return internalRequestProperty(QLatin1String("MediaDescriptionOffer"));
    }

    inline Tp::PendingVariant *requestPropertyPacketization() const
    {
        return internalRequestProperty(QLatin1String("Packetization"));
    }

    inline Tp::PendingVariant *requestPropertyCurrentDTMFEvent() const
    {
        return internalRequestProperty(QLatin1String("CurrentDTMFEvent"));
    }

    inline Tp::PendingVariant *requestPropertyCurrentDTMFState() const
    {
        return internalRequestProperty(QLatin1String("CurrentDTMFState"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<> UpdateLocalMediaDescription(const QVariantMap& mediaDescription, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("UpdateLocalMediaDescription"));
        callMessage << QVariant::fromValue(mediaDescription);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<> AcknowledgeDTMFChange(uchar event, uint state, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("AcknowledgeDTMFChange"));
        callMessage << QVariant::fromValue(event) << QVariant::fromValue(state);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<> Fail(const Tp::CallStateReason& reason, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("Fail"));
        callMessage << QVariant::fromValue(reason);
        return this->connection().asyncCall(callMessage, timeout);
    }

Q_SIGNALS:
    void NewMediaDescriptionOffer(const QDBusObjectPath& mediaDescription, const QVariantMap& properties);

    void MediaDescriptionOfferDone();

    void LocalMediaDescriptionChanged(const QVariantMap& updatedMediaDescription);

    void RemoteMediaDescriptionsChanged(const Tp::ContactMediaDescriptionPropertiesMap& updatedMediaDescriptions);

    void MediaDescriptionsRemoved(const Tp::UIntList& removedMediaDescriptions);

    void DTMFChangeRequested(uchar event, uint state);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT CallContentInterfaceVideoControlInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl");
    }

    CallContentInterfaceVideoControlInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceVideoControlInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    CallContentInterfaceVideoControlInterface(Tp::DBusProxy *proxy);

    explicit CallContentInterfaceVideoControlInterface(const Tp::Client::CallContentInterface& mainInterface);

    CallContentInterfaceVideoControlInterface(const Tp::Client::CallContentInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyVideoResolution() const
    {
        return internalRequestProperty(QLatin1String("VideoResolution"));
    }

    inline Tp::PendingVariant *requestPropertyBitrate() const
    {
        return internalRequestProperty(QLatin1String("Bitrate"));
    }

    inline Tp::PendingVariant *requestPropertyFramerate() const
    {
        return internalRequestProperty(QLatin1String("Framerate"));
    }

    inline Tp::PendingVariant *requestPropertyMTU() const
    {
        return internalRequestProperty(QLatin1String("MTU"));
    }

    inline Tp::PendingVariant *requestPropertyManualKeyFrames() const
    {
        return internalRequestProperty(QLatin1String("ManualKeyFrames"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

Q_SIGNALS:
    void KeyFrameRequested();

    void VideoResolutionChanged(const Tp::VideoResolution& newResolution);

    void BitrateChanged(uint newBitrate);

    void FramerateChanged(uint newFramerate);

    void MTUChanged(uint newMTU);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::CallContentInterface*)
Q_DECLARE_METATYPE(Tp::Client::CallContentInterfaceAudioControlInterface*)
Q_DECLARE_METATYPE(Tp::Client::CallContentInterfaceDTMFInterface*)
Q_DECLARE_METATYPE(Tp::Client::CallContentInterfaceMediaInterface*)
Q_DECLARE_METATYPE(Tp::Client::CallContentInterfaceVideoControlInterface*)