/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: QTMS Voip test

*

*/

#include <QObject>

#include <QtTest/QtTest>

#include "qtestmains60.h"

#include <qtms.h>

#include <qtmsfactory.h>

#include <qtmscall.h>

#include <qtmsstream.h>

#include <tmsstreamobsrvr.h>

#include <qtmsformat.h>

#include <qtmspcmformat.h>

#include <qtmsamrformat.h>

#include <qtmsilbcformat.h>

#include <qtmsg711format.h>

#include <qtmsg729format.h>

#include <qtmsclientsink.h>

#include <qtmsclientsource.h>

#include <qtmsvolumeeffect.h>

#include <qtmsgaineffect.h>

#include <qtmsglobalvoleffect.h>

#include <qtmsglobalgaineffect.h>

#include <qtmsglobalrouting.h>

#include <qtmsbuffer.h>

#include <qtmsdtmf.h>

#include <qtmsringtone.h>

#include <qtmsinbandtone.h>

#include <tmsbuffer.h>

// CONSTANTS

#define __TEST_CODE_COVERAGE__

using namespace QTMS;

class QTmsVoipTest : public QObject

    {

Q_OBJECT

private slots:

    void initTestCase();

    void init();

    void cleanup();

    void SupportedFormats();

    void CreateRouting_data();

    void CreateRouting();

    void CreateGlobalVol();

    void CreateGlobalGain();

    void CreateFormat_data();

    void CreateFormat();

    void CreateStreamVol();

    void CreateStreamGain();

    void CreateDnlinkDtmf();

    void CreateBuffer();

    void cleanupTestCase();

public slots:

    //From TMSClientSourceObserver

    void FillBuffer(TMS::TMSBuffer& buffer);

    void BufferProcessed(TMS::TMSBuffer* buffer, gint reason);

    //From TMSClientSinkObserver

    void ProcessBuffer(const TMS::TMSBuffer* buffer);

    //From TMSStreamObserver

    void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);

    //From TMSClientSinkObserver

    void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);

    //From TMSGlobalRoutingObserver

    void GlobalRoutingEvent(const QTMSGlobalRouting& routing,

            QTMSSignalEvent event, QTMSAudioOutput output);

    //From TMSRingToneObserver

    void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);

    //From TMSDTMFObserver

    void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);

private:

    void VoipCallSetup();

    void SupportedUplinkFormats();

    void SupportedDnlinkFormats();

    void CreateUplink();

    void CreateDnlink();

    void CreateMicSource();

    void AddMicSourceToStream();

    void CreateClientSink();

    void AddClientSinkToStream();

    void CreateClientSource();

    void AddClientSourceToStream();

    void CreateSpeakerSink();

    void AddSpeakerSinkToStream();

    void InitUplink();

    void InitDnlink();

    void DeinitUplink();

    void DeinitDnlink();

    void StartUplink();

    void StopUplink();

    void StartDnlink();

    void ResetUplnkFormat();

    void ResetDnlnkFormat();

    void StreamVol();

    void StreamGain();

    void CloseUplink();

    void CloseDownlink();

    void DisplayFormat(QTMSFormatType format);

    void StopDnlink();

    void CreateRingTone();

    void ToggleVad();

    void GetVad();

    void ToggleCng();

    void GetCng();

    void TogglePlc();

    void GetPlc();

    void SelectMinBitrate();

    void SelectMaxBitrate();

    void SetBitrate(guint bitrate);

    void GetSupportedBitrates();

    gint GetSupportedBitrates(BitRateVector& aBrArr);

    void GetBitrate();

    void SetDnLinkG711ALAW();

    void SetDnLinkG711uLAW();

    void SetDnLinkILBC20MS();

    void SetDnLinkILBC30MS();

    void SetUpLinkG711ALAW();

    void SetUpLinkG711uLAW();

    void SetUpLinkILBC20MS();

    void SetUpLinkILBC30MS();

    void GetDnLinkG711Mode();

    void GetDnLinkILBCMode();

    void GetUpLinkG711Mode();

    void GetUpLinkILBCMode();

    void DisplayDevice(QTMSAudioOutput device);

private:

    QTMSFactory *m_Factory;

    QTMSCall *m_Call;

    QTMSDTMF *m_Dnlnkdtmf;

    QTMSStream *m_Dnlink;

    QTMSStream *m_Uplink;

    QTMSSource *m_MicSource;

    QTMSSource *m_ClientSource;

    QTMSSink *m_ClientSink;

    QTMSSink *m_SpeakerSink;

    QTMSFormat *m_G711EncFormatIntfc;

    QTMSFormat *m_G711DecFormatIntfc;

    QTMSFormat *m_G729EncFormatIntfc;

    QTMSFormat *m_G729DecFormatIntfc;

    QTMSFormat *m_ILBCEncFormatIntfc;

    QTMSFormat *m_ILBCDecFormatIntfc;

    QTMSFormat *m_AMRNBEncFormatIntfc;

    QTMSFormat *m_AMRNBDecFormatIntfc;

    QTMSFormat *m_PCM16EncFormatIntfc;

    QTMSFormat *m_PCM16DecFormatIntfc;

    QTMS::FormatVector m_UplCodecs;

    QTMS::FormatVector m_DnlCodecs;

    BitRateVector m_BitratesVector;

    guint iBitrate;

    QTMSEffect *m_Vol;

    QTMSEffect *m_Gain;

    QTMSEffect *m_GlobalVol;

    QTMSEffect *m_GlobalGain;

    QTMSGlobalRouting *m_Routing;

    QTMSFormatType m_DnLinkCodec;

    QTMSFormatType m_UpLinkCodec;

    QSignalSpy *m_UplinkSpy;

    QSignalSpy *m_DnlinkSpy;

    QSignalSpy *m_RoutingSpy;

    gboolean m_Vad;

    gboolean m_Cng;

    gboolean m_Plc;

    };

void QTmsVoipTest::initTestCase()

    {

    qDebug("Start QTms Voip tests");

    g_setenv("G_SLICE", "always-malloc", 1);

    qRegisterMetaType<QTMSSignalEvent>("QTMSSignalEvent");

    qRegisterMetaType<QTMSAudioOutput>("QTMSAudioOutput");

    }

void QTmsVoipTest::cleanupTestCase()

    {

    qDebug("End QTms tests");

    }

void QTmsVoipTest::init()

    {

    qDebug("****NEW TEST****");

    m_Factory = NULL;

    m_Call = NULL;

    m_Dnlink = NULL;

    m_Uplink = NULL;  

    m_MicSource = NULL;

    m_ClientSource = NULL;

    m_SpeakerSink = NULL;

    m_ClientSink = NULL;

    m_Vol = NULL;

    m_Gain = NULL;

    m_GlobalVol = NULL;

    m_GlobalGain = NULL;

    m_Routing = NULL;  

    m_Dnlnkdtmf = NULL;

    m_G711EncFormatIntfc = NULL;

    m_G711DecFormatIntfc = NULL;

    m_G729EncFormatIntfc = NULL;

    m_G729DecFormatIntfc = NULL;

    m_ILBCEncFormatIntfc = NULL;

    m_ILBCDecFormatIntfc = NULL;

    m_AMRNBEncFormatIntfc = NULL;

    m_AMRNBDecFormatIntfc = NULL;

    m_PCM16EncFormatIntfc = NULL;

    m_PCM16DecFormatIntfc = NULL;

    m_UplinkSpy = NULL;

    m_DnlinkSpy = NULL;

    QTMSVer *ver(NULL);

    gint status;

    status = QTMSFactory::CreateFactory(m_Factory, *ver);

    QVERIFY(status == QTMS_RESULT_SUCCESS);

    VoipCallSetup();

    CreateUplink();

    CreateDnlink();

    CreateMicSource();

    AddMicSourceToStream();

    CreateClientSink();

    AddClientSinkToStream();

    CreateClientSource();

    AddClientSourceToStream();

    CreateSpeakerSink();

    AddSpeakerSinkToStream();

    }

void QTmsVoipTest::cleanup()

    {

    qDebug("****END TEST******");

    ResetUplnkFormat();

    ResetDnlnkFormat();

    CloseUplink();

    CloseDownlink();

    if (m_MicSource)

        m_Factory->DeleteSource(m_MicSource);

    if (m_ClientSource)

        m_Factory->DeleteSource(m_ClientSource);

    if (m_ClientSink)

        m_Factory->DeleteSink(m_ClientSink);

    if (m_SpeakerSink)

        m_Factory->DeleteSink(m_SpeakerSink);

    if (m_Dnlnkdtmf)

        m_Factory->DeleteDTMF(m_Dnlnkdtmf);

    if (m_Vol)

        m_Factory->DeleteEffect(m_Vol);

    if (m_Gain)

        m_Factory->DeleteEffect(m_Gain);

    if (m_GlobalVol)

        m_Factory->DeleteEffect(m_GlobalVol);

    if (m_GlobalGain)

        m_Factory->DeleteEffect(m_GlobalGain);

    if (m_Routing)

        m_Factory->DeleteGlobalRouting(m_Routing);

    if (m_PCM16EncFormatIntfc)

        m_Factory->DeleteFormat(m_PCM16EncFormatIntfc);

    if (m_ILBCEncFormatIntfc)

        m_Factory->DeleteFormat(m_ILBCEncFormatIntfc);

    if (m_AMRNBEncFormatIntfc)

        m_Factory->DeleteFormat(m_AMRNBEncFormatIntfc);

    if (m_G711EncFormatIntfc)

        m_Factory->DeleteFormat(m_G711EncFormatIntfc);

    if (m_G729EncFormatIntfc)

        m_Factory->DeleteFormat(m_G729EncFormatIntfc);

    if (m_PCM16DecFormatIntfc)

        m_Factory->DeleteFormat(m_PCM16DecFormatIntfc);

    if (m_ILBCDecFormatIntfc)

        m_Factory->DeleteFormat(m_ILBCDecFormatIntfc);

    if (m_AMRNBDecFormatIntfc)

        m_Factory->DeleteFormat(m_AMRNBDecFormatIntfc);

    if (m_G711DecFormatIntfc)

        m_Factory->DeleteFormat(m_G711DecFormatIntfc);

    if (m_G729DecFormatIntfc)

        m_Factory->DeleteFormat(m_G729DecFormatIntfc);

    if (m_Uplink)

        m_Call->DeleteStream(m_Uplink);

    if (m_Dnlink)

        m_Call->DeleteStream(m_Dnlink);

    if (m_Call)

        m_Factory->DeleteCall(m_Call);

    if (m_Factory)

        delete m_Factory;

    }

void QTmsVoipTest::VoipCallSetup()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Factory && !m_Call)

        {

        gboolean issupported(FALSE);

        m_Factory->IsCallTypeSupported(QTMS_CALL_IP,issupported);

        QVERIFY(issupported == TRUE);

        status = m_Factory->CreateCall(QTMS_CALL_IP, m_Call, 0);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        guint ctxid;

        m_Call->GetCallContextId(ctxid);

        }

    }

void QTmsVoipTest::SupportedFormats()

    {

    SupportedUplinkFormats();

    SupportedDnlinkFormats();

    }

void QTmsVoipTest::SupportedUplinkFormats()

    {

    gint status(QTMS_RESULT_SUCCESS);

    status = m_Factory->GetSupportedFormats(QTMS_STREAM_UPLINK,m_UplCodecs);

    QVERIFY(status == QTMS_RESULT_SUCCESS);  

    qDebug("Supported UPL codecs");

    std::vector<QTMSFormat*>::iterator codecs = m_UplCodecs.begin();

    QTMSFormatType fmttype;

    for (; codecs < m_UplCodecs.end(); codecs++)

        {

        (*codecs)->GetType(fmttype);

        DisplayFormat(fmttype);

        }

    gint size = m_UplCodecs.size();

    for (gint i = 0; i < size; i++)

        {

        codecs = m_UplCodecs.begin();

        m_Factory->DeleteFormat(*codecs);

        m_UplCodecs.erase(codecs);

        }

    }

void QTmsVoipTest::SupportedDnlinkFormats()

    {

    gint status(QTMS_RESULT_SUCCESS);

    status = m_Factory->GetSupportedFormats(QTMS_STREAM_DOWNLINK,m_DnlCodecs);

    QVERIFY(status == QTMS_RESULT_SUCCESS);  

    qDebug("Supported DNL codecs");

    std::vector<QTMSFormat*>::iterator codecs = m_DnlCodecs.begin();

    QTMSFormatType fmttype;

    for (; codecs < m_DnlCodecs.end(); codecs++)

        {

        (*codecs)->GetType(fmttype);

        DisplayFormat(fmttype);

        }

    gint size = m_DnlCodecs.size();

    for (gint i = 0; i < size; i++)

        {

        codecs = m_DnlCodecs.begin();

        m_Factory->DeleteFormat(*codecs);

        m_DnlCodecs.erase(codecs);

        }

    }

void QTmsVoipTest::DisplayFormat(QTMSFormatType format)

    {

    switch (format)

        {

        case QTMS_FORMAT_AMR:

            qDebug("AMR-NB");

            break;

        case QTMS_FORMAT_G711:

            qDebug("G.711");

            break;

        case QTMS_FORMAT_G729:

            qDebug("G.729");

            break;

        case QTMS_FORMAT_ILBC:

            qDebug("iLBC");

            break;

        case QTMS_FORMAT_PCM:

            qDebug("PCM-16");

            break;

        default:

            break;

        }

    }

void QTmsVoipTest::CreateUplink()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Call)

        {

        status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);

        m_UplinkSpy = new QSignalSpy(m_Uplink,

                SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));

        QVERIFY( m_UplinkSpy->isValid() );

       // QCOMPARE(m_UplinkSpy->count(), 0 );

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(m_Uplink,

                SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),

                this,

                SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));  

        }

    }

 void QTmsVoipTest::CreateDnlink()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Call)

        {

        status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        m_DnlinkSpy = new QSignalSpy(m_Dnlink,

                SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));

        QVERIFY( m_DnlinkSpy->isValid() );

       // QCOMPARE(m_DnlinkSpy->count(), 0 );

        connect(m_Dnlink,

                SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),

                this,

                SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));             

        }

    }

void QTmsVoipTest::CreateClientSource()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Factory && !m_ClientSource)

         {

         status = m_Factory->CreateSource(QTMS_SOURCE_CLIENT, m_ClientSource);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

void QTmsVoipTest::AddClientSourceToStream()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Dnlink && m_ClientSource)

        {

        connect(static_cast<QTMSClientSource*> (m_ClientSource),

                SIGNAL(FillBuffer(TMS::TMSBuffer&)), this,

                SLOT(FillBuffer(TMS::TMSBuffer&)));

        status = m_Dnlink->AddSource(m_ClientSource);

#ifdef __TEST_CODE_COVERAGE__

        QTMSSourceType st;

        static_cast<QTMSClientSource*>(m_ClientSource)->GetType(st);

        gboolean enqueue(FALSE);

        static_cast<QTMSClientSource*>(m_ClientSource)->GetEnqueueMode(enqueue);

        static_cast<QTMSClientSource*>(m_ClientSource)->SetEnqueueMode(FALSE);

        static_cast<QTMSClientSource*>(m_ClientSource)->Flush();

#endif //__TEST_CODE_COVERAGE__

        }

    QVERIFY(status == QTMS_RESULT_SUCCESS);

    }