/*

 * 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(QTMSBuffer& buffer);

    void BufferProcessed(QTMSBuffer* buffer, gint reason);

    //From TMSClientSinkObserver

    void ProcessBuffer(const QTMSBuffer* 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()

{