QXmppCallManager.h

/*
 * Copyright (C) 2008-2010 The QXmpp developers
 *
 * Author:
 *  Jeremy Lainé
 *
 * Source:
 *  http://code.google.com/p/qxmpp
 *
 * This file is a part of QXmpp library.
 *
 * 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) any later version.
 *
 * 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.
 *
 */

#ifndef QXMPPCALLMANAGER_H
#define QXMPPCALLMANAGER_H

#include <QObject>
#include <QIODevice>

#include "QXmppJingleIq.h"
#include "QXmppLogger.h"

class QXmppCodec;
class QXmppJingleCandidate;
class QXmppJingleIq;
class QXmppJinglePayloadType;
class QXmppStream;
class QXmppStunSocket;


class QXmppCall : public QIODevice
{
    Q_OBJECT

public:
    enum Direction
    {
        IncomingDirection, 
        OutgoingDirection, 
    };

    enum State
    {
        OfferState = 0,         
        ConnectingState = 1,    
        ActiveState = 2,        
        DisconnectingState = 3, 
        FinishedState = 4,      
    };

    QXmppCall::Direction direction() const;
    QString jid() const;
    QString sid() const;
    QXmppCall::State state() const;

    QXmppJinglePayloadType payloadType() const;

    qint64 bytesAvailable() const;
    bool isSequential() const;

signals:
    void connected();

    void finished();

    void ringing();

    void logMessage(QXmppLogger::MessageType type, const QString &msg);

    void stateChanged(QXmppCall::State state);

public slots:
    void accept();
    void hangup();

private slots:
    void datagramReceived(const QByteArray &datagram);
    void emitSignals();
    void updateOpenMode();
    void terminate();
    void terminated();

protected:
    qint64 readData(char * data, qint64 maxSize);
    qint64 writeData(const char * data, qint64 maxSize);

private:
    QXmppCall(const QString &jid, QXmppCall::Direction direction, QObject *parent);
    void connectToHost();
    QList<QXmppJingleCandidate> localCandidates() const;
    void setPayloadType(const QXmppJinglePayloadType &type);
    void addRemoteCandidates(const QList<QXmppJingleCandidate> &candidates);
    void setRemoteUser(const QString &user);
    void setRemotePassword(const QString &password);
    void setState(QXmppCall::State state);

    Direction m_direction;
    QString m_jid;
    QString m_sid;
    State m_state;
    QString m_contentName;
    QXmppJinglePayloadType m_payloadType;

    QList<QXmppJingleIq> m_requests;
    QList<QXmppJinglePayloadType> m_commonPayloadTypes;

    // ICE-UDP
    QXmppStunSocket *m_socket;
    QXmppStunSocket *m_rtcpSocket;

    // signals
    bool m_signalsEmitted;
    qint64 m_writtenSinceLastEmit;

    // RTP
    QXmppCodec *m_codec;

    QByteArray m_incomingBuffer;
    bool m_incomingBuffering;
    int m_incomingMinimum;
    quint16 m_incomingSequence;
    quint32 m_incomingStamp;

    quint16 m_outgoingChunk;
    QByteArray m_outgoingBuffer;
    bool m_outgoingMarker;
    quint16 m_outgoingSequence;
    quint32 m_outgoingStamp;

    friend class QXmppCallManager;
};


class QXmppCallManager : public QObject
{
    Q_OBJECT

public:
    QXmppCallManager(QXmppStream *stream, QObject *parent = 0);
    QXmppCall *call(const QString &jid);

signals:
    void callReceived(QXmppCall *call);

    void logMessage(QXmppLogger::MessageType type, const QString &msg);

private slots:
    void callDestroyed(QObject *object);
    void callStateChanged(QXmppCall::State state);
    void iqReceived(const QXmppIq &iq);
    void jingleIqReceived(const QXmppJingleIq &iq);

private:
    bool checkPayloadTypes(QXmppCall *call, const QList<QXmppJinglePayloadType> &remotePayloadTypes);
    QXmppCall *findCall(const QString &sid) const;
    QXmppCall *findCall(const QString &sid, QXmppCall::Direction direction) const;
    QList<QXmppJinglePayloadType> localPayloadTypes() const;
    bool sendAck(const QXmppJingleIq &iq);
    bool sendRequest(QXmppCall *call, const QXmppJingleIq &iq);

    QList<QXmppCall*> m_calls;

    // reference to xmpp stream (no ownership)
    QXmppStream* m_stream;
};

#endif

---