/*

* 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 CS 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>

using namespace QTMS;

_LIT8(KRTBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\

\x05\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B");

_LIT16(KTestFile1,   "c:\\data\\sounds\\digital\\test_8khz.wav");

class QTmsCsTest : public QObject

    {

Q_OBJECT

private slots:

    void initTestCase();

    void CSCallSetup();

    void CreateUplink();

    void CreateDnlink();

    void CreateMicSource();

    void AddMicSourceToStream();

    void CreateModemSink();

    void AddModemSinkToStream();

    void CreateModemSource();

    void AddModemSourceToStream();

    void CreateSpeakerSink();

    void AddSpeakerSinkToStream();

    void CreateStreamVol();

    void CreateStreamGain();

    void InitUplink();

    void InitDnlink();

    void StartUplink();

    void StopUplink();

    void StartDnlink();

    void StreamVol();

    void StreamGain();

   // void StopDnlink();

    void CreateGlobalVol();

    void CreateGlobalGain();

    void CreateRouting_data();

    void CreateRouting();

    void CreateInband_data();

    void CreateInband();

    void CreateDnlinkDtmf();

    void CreateUplinkDtmf();

    void CreateRingTone();    

    void InitRingTonePlayerFromProfiles();

    void PlayRingTone();

    void PauseRingTone();

    void MuteRingTone();

    void StopRingTone();  

    void CloseRingTonePlayer();

    void CloseUplink();

    void CloseDownlink();

    void cleanupTestCase();

public slots:

    //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);

    //From TMSInbandToneObserver

    void InbandToneEvent(const QTMSInbandTone& inbandtone,

            QTMSSignalEvent event);

private:    

    void InitRingToneSequencePlayer();

    void InitRingTonePlayerFromFile();    

    void StopDnlink();

    void GetAvailableOutput();

    void DisplayDevice(QTMSAudioOutput device);

private:    

    QTMSFactory *m_Factory;

    QTMSCall *m_Call;

    QTMSDTMF *m_Dnlnkdtmf;

    QTMSDTMF *m_Uplnkdtmf;

    QTMSStream *m_Dnlink;

    QTMSStream *m_Uplink;

    QTMSSource *m_MicSource;

    QTMSSource *m_ModemSource;

    QTMSSink *m_SpeakerSink;

    QTMSSink *m_ModemSink;

    QTMSEffect *m_Vol;

    QTMSEffect *m_Gain;

    QTMSEffect *m_GlobalVol;

    QTMSEffect *m_GlobalGain;

    QTMSGlobalRouting *m_Routing;

    QTMSInbandTone *m_InbandTonePlayer;

    QTMSRingTone *m_RingTonePlayer;

    GString* m_RTStr;

    GString* m_TTSStr;   

    QSignalSpy *m_UplinkSpy;

    QSignalSpy *m_DnlinkSpy;

    QSignalSpy *m_InbandSpy;

    QSignalSpy *m_RoutingSpy; 

    OutputVector  m_Availableoutputs;

    };

void QTmsCsTest::initTestCase()

    {

    qDebug("Start QTms CS tests");

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

    m_Factory = NULL;

    m_Call = NULL;

    m_Dnlink = NULL;

    m_Uplink = NULL;  

    m_MicSource = NULL;

    m_ModemSource = NULL;

    m_SpeakerSink = NULL;

    m_ModemSink = NULL;

    m_Vol = NULL;

    m_Gain = NULL;

    m_GlobalVol = NULL;

    m_GlobalGain = NULL;

    m_Routing = NULL;  

    m_Dnlnkdtmf = NULL;

    m_Uplnkdtmf = NULL;

    m_InbandTonePlayer = NULL;

    m_RingTonePlayer = NULL;

    m_UplinkSpy = NULL;

    m_DnlinkSpy = NULL;

    QTMSVer *ver(NULL);

    gint status;

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

    QVERIFY(status == QTMS_RESULT_SUCCESS);

    qRegisterMetaType<QTMSSignalEvent>("QTMSSignalEvent");

    qRegisterMetaType<QTMSAudioOutput>("QTMSAudioOutput");

    }

void QTmsCsTest::cleanupTestCase()

    {

    qDebug("End QTms tests");

    StopDnlink();

    m_Factory->DeleteSource(m_MicSource);   

    m_Factory->DeleteSource(m_ModemSource);  

    m_Factory->DeleteSink(m_ModemSink);

    m_Factory->DeleteSink(m_SpeakerSink);

    m_Factory->DeleteDTMF(m_Dnlnkdtmf);

    m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);

    m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);

    m_Factory->DeleteEffect(m_Vol);

    m_Factory->DeleteEffect(m_Gain);

    m_Factory->DeleteEffect(m_GlobalVol);

    m_Factory->DeleteEffect(m_GlobalGain);

    m_Factory->DeleteGlobalRouting(m_Routing);

    m_Call->DeleteStream(m_Uplink);

    m_Call->DeleteStream(m_Dnlink);

    m_Factory->DeleteCall(m_Call);

    delete m_Factory;

    }

void QTmsCsTest::CSCallSetup()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Factory && !m_Call)

        {

        gboolean issupported(FALSE);

        m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);

        QVERIFY(issupported == TRUE);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QTMSCallType calltype = m_Call->GetCallType();

        QVERIFY(calltype == QTMS_CALL_CS);

        }

    QVERIFY(status == QTMS_RESULT_SUCCESS);

    }

void QTmsCsTest::CreateUplink()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Call)

        {

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        m_UplinkSpy = new QSignalSpy(m_Uplink,

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

        QVERIFY( m_UplinkSpy->isValid() );

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

        connect(m_Uplink,

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

                this,

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

        }

    }

 void QTmsCsTest::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 QTmsCsTest::CreateModemSink()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Factory && !m_ModemSink)

         {

         status = m_Factory->CreateSink(QTMS_SINK_MODEM, m_ModemSink);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::CreateModemSource()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Factory && !m_ModemSource)

         {

         status = m_Factory->CreateSource(QTMS_SOURCE_MODEM, m_ModemSource);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::AddModemSinkToStream()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Uplink && m_ModemSink)

         {

         status = m_Uplink->AddSink(m_ModemSink);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::AddModemSourceToStream()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Dnlink && m_ModemSource)

         {

         status = m_Dnlink->AddSource(m_ModemSource);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::CreateMicSource()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Factory && !m_MicSource)

         {

         status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::AddMicSourceToStream()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Uplink && m_MicSource)

         {

         status = m_Uplink->AddSource(m_MicSource);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::CreateSpeakerSink()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Factory && !m_SpeakerSink)

         {

         status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::AddSpeakerSinkToStream()

     {

     gint status(QTMS_RESULT_SUCCESS);

     if (m_Dnlink && m_SpeakerSink)

         {

         status = m_Dnlink->AddSink(m_SpeakerSink);

         qDebug("QTMS speaker sink added to stream");

         }

     QVERIFY(status == QTMS_RESULT_SUCCESS);

     }

 void QTmsCsTest::InitUplink()

     {    

     QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);

     QTest::qWait(1000);  

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

     }

 void QTmsCsTest::InitDnlink()

     {

     QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);

     QTest::qWait(1000);      

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

     }

 void QTmsCsTest::StartUplink()

     {

     QVERIFY(m_Uplink->Start() == QTMS_RESULT_SUCCESS);

     QTest::qWait(1000);  

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

     }

 void QTmsCsTest::StartDnlink()

    {

    QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);

    QTest::qWait(1000);      

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

    }

void QTmsCsTest::StopUplink()

    {

    QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);

    QTest::qWait(1000);

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

    }

void QTmsCsTest::StopDnlink()

    {

    QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);

    QTest::qWait(1000);  

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

    }

void QTmsCsTest::CloseUplink()

    {

    m_Uplink->Deinit();

    QTest::qWait(1000);

    if (m_Uplink)

        {

        if (m_Gain)

            {

            QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);

            }

        if (m_MicSource)

            {

            QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);

            }

        if (m_ModemSink)

            {

            QVERIFY(m_Uplink->RemoveSink(m_ModemSink)== QTMS_RESULT_SUCCESS);

            }

        }

    }

void QTmsCsTest::CloseDownlink()

    {  

    m_Dnlink->Deinit();

    QTest::qWait(1000);

    if (m_Dnlink)

        {

        if (m_Vol)

            {

            QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);

            }

        if (m_ModemSource)

            {

            QVERIFY(m_Dnlink->RemoveSource(m_ModemSource)== QTMS_RESULT_SUCCESS);

            }

        if (m_SpeakerSink)

            {

            QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);

            }

        }

    }

void QTmsCsTest::CreateStreamVol()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Factory && !m_Vol)

        {

        status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(static_cast<QTMSVolumeEffect*> (m_Vol),

                SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

                this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

        if(m_Dnlink)

            {

            status = m_Dnlink->AddEffect(m_Vol);          

            }

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        }

    }

void QTmsCsTest::StreamVol()

    {

    gint status(QTMS_RESULT_SUCCESS);

    guint maxvol(0);

    if (m_Vol)

        {

        status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QTest::qWait(1000);

        guint vol(0);

        status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QCOMPARE(vol,maxvol);

        }

    }

void QTmsCsTest::CreateStreamGain()

    {

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Factory && !m_Gain)

        {

        status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(static_cast<QTMSGainEffect*> (m_Gain),

                SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

                this,

                SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

        if(m_Uplink)

            {

            status = m_Uplink->AddEffect(m_Gain);

            }

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        }