/*

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

    }

}

void QTmsCsTest::StreamGain()

{

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Gain) {

        guint maxgain(0);

        static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QTest::qWait(1000);

        guint gain(0);

        static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QCOMPARE(gain,maxgain);

    }

}

void QTmsCsTest::CreateGlobalVol()

{

    gint status(QTMS_RESULT_SUCCESS);

    if (m_Factory && !m_GlobalVol) {

        status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),

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

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