voicecallengine.h

Go to the documentation of this file.

/*     -*-C++-*- -*-coding: utf-8-unix;-*-
  Classified Ads is Copyright (c) Antti Järvinen 2015.

  This file is part of Classified Ads.

  Classified Ads 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.

  Classified Ads 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 Classified Ads; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef VOICECALL_ENG_H
#define VOICECALL_ENG_H
#include <QString>
#include <QList>
#include <QAbstractTableModel>
#include <QPair>
#include "../datamodel/model.h"
#include "../datamodel/voicecall.h"
#include "../call/audiodecoder.h"
#include "../call/audioencoder.h"
#include "mvoicecallengine.h"

class AudioMixer ;
class AudioEncoder ;
class AudioSource ;
class AudioPlayer ;

class VoiceCallEngine : public QAbstractTableModel,
    public MVoiceCallEngine  {
    Q_OBJECT
public:

    VoiceCallEngine(MController& aController,
                    Model& aModel ) ;
    ~VoiceCallEngine() ;

    virtual void installObserver(MCallStatusObserver* aObserver) ;

    virtual void removeObserver(MCallStatusObserver* aObserver) ;

    virtual void insertCallData(quint32 aCallId,
                                quint32 aSeqNo,
                                PayloadType aPayloadType,
                                const QByteArray& aPayload,
                                Hash& aSendingNode) ;

    virtual void insertCallStatusData(const VoiceCall& aCallStatus,
                                      const Hash& aSendingNode) ;
    virtual QList<quint32> onGoingCalls() const ;
    virtual CallState callStatus(quint32 aCallId) const ;
    virtual void closeCall(quint32 aCallId) ;
    virtual void acceptCall(quint32 aCallId) ;
    QString excuseForCallCreation(const Hash& aOperator,
                                  const Hash& aNode = KNullHash ) const ;
    virtual int rowCount(const QModelIndex & parent = QModelIndex())  const  ;
    virtual int columnCount(const QModelIndex & parent = QModelIndex())  const  ;
    virtual QVariant data(const QModelIndex & index,
                          int role = Qt::DisplayRole) const ;
    virtual QVariant headerData ( int section,
                                  Qt::Orientation orientation,
                                  int role = Qt::DisplayRole ) const ;

public slots:
    void nodeConnectionAttemptStatus(Connection::ConnectionState aStatus,
                                     const Hash aHashOfAttemptedNode );

    void audioFrameEncoded ( quint32 aCallId,
                             quint32 aSeqNo,
                             const QByteArray& aEncodedVoice,
                             Hash aForNode ) ;

    void frameReady ( quint32 aCallId,
                      quint32 aSeqNo,
                      const QByteArray& aRawAudio,
                      Hash aForNode ) ;

    void processCallData() ;
    void setInputLevel(float aInputLevel) ;
    void setOutputLevel(float aOutputLevel) ;
signals:
    void error(QTcpSocket::SocketError socketError);
    void callStateChanged(quint32 aCallId,
                          VoiceCallEngine::CallState aState);
    void startProcessCallData() ;
    void inputLevel(float aInputLevel) ;
    void outputLevel(float aOutputLevel) ;
private:
    class VoiceCallExtension ;
    // methods
    bool setupNewOutgoingCall(VoiceCallExtension& aCall) ;
    bool setupNewIncomingCall(VoiceCallExtension& aCall) ;
    void sendCallStatusUpdates(quint32 aCallId,
                               CallState aState ) ;
    Hash callPeerFingerPrint(const VoiceCall& aCall) const ;
    void removeCallFromArray(VoiceCallExtension& aCall) ;
    void addCallToArray(VoiceCallExtension& aCall) ;
    void sendCallStatusUpdateToRemote(const VoiceCall& aCall,bool aDoSign=true) ;
    QString callStatusString(const VoiceCallExtension& aCall) const ;
    bool checkForNodeValidity(const VoiceCall& aCallStatus,
                              const Hash& aSendingNode) const ;
    bool setupLocalAudioCapture(VoiceCallExtension& aCall) ;
    bool setupAudioOutput(VoiceCallExtension& aCall) ;
    bool addCallToMixer(const VoiceCallExtension& aCall) ;
    bool removeCallFromMixer(const VoiceCallExtension& aCall) ;
private: // data
    class VoiceCallExtension: public VoiceCall {
    public:
        VoiceCallExtension(const VoiceCall& aInitialData) :
            iDecoder(NULL),
            iEncoder(NULL) {
            fromJSon(aInitialData.asJSon()) ;
        }
        ~VoiceCallExtension() {
            if ( iDecoder ) {
                iDecoder->deleteLater() ;
                iDecoder = NULL ;
            }
            if ( iEncoder ) {
                iEncoder->deleteLater() ;
                iEncoder = NULL ;
            }
        }
        CallState iOnGoingCallState ;
        QString iPeerOperatorHash ;
        QString iPeerNodeAddress ;
        AudioDecoder* iDecoder;
        AudioEncoder* iEncoder;
    } ;
    MController& iController ; 
    Model &iModel ; 
    QList<MCallStatusObserver*> iCallObservers ;
    QList<VoiceCallExtension> iOnGoingCalls ; 
    AudioMixer* iMixer ;
    AudioSource* iAudioSource;
    AudioPlayer* iAudioPlayer;
    QList<QPair<VoiceCall, Hash> > iCallDataPendingProcessing ;
} ;
#endif