1 /*

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

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

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

     6  * which accompanies this distribution, and is available

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

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: QTMS CS test

    15  *

    16  */

    17 #include <QObject>

    18 #include <QtTest/QtTest>

    19 #include "qtestmains60.h"

    20 

    21 #include <qtms.h>

    22 #include <qtmsfactory.h>

    23 #include <qtmscall.h>

    24 #include <qtmsstream.h>

    25 #include <tmsstreamobsrvr.h>

    26 #include <qtmsformat.h>

    27 

    28 #include <qtmspcmformat.h>

    29 #include <qtmsamrformat.h>

    30 #include <qtmsilbcformat.h>

    31 #include <qtmsg711format.h>

    32 #include <qtmsg729format.h>

    33 

    34 #include <qtmsclientsink.h>

    35 #include <qtmsclientsource.h>

    36 #include <qtmsvolumeeffect.h>

    37 #include <qtmsgaineffect.h>

    38 #include <qtmsglobalvoleffect.h>

    39 #include <qtmsglobalgaineffect.h>

    40 #include <qtmsglobalrouting.h>

    41 

    42 #include <qtmsbuffer.h>

    43 #include <qtmsdtmf.h>

    44 #include <qtmsringtone.h>

    45 #include <qtmsinbandtone.h>

    46 #include <tmsbuffer.h>

    47 

    48 using namespace QTMS;

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

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

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

    52 

    53 class QTmsCsTest: public QObject

    54 {

    55 Q_OBJECT

    56 private slots:

    57     void initTestCase();

    58     void CSCallSetup();

    59 

    60     void CreateUplink();

    61     void CreateDnlink();

    62     void CreateMicSource();

    63     void AddMicSourceToStream();

    64     void CreateModemSink();

    65     void AddModemSinkToStream();

    66     void CreateModemSource();

    67     void AddModemSourceToStream();

    68     void CreateSpeakerSink();

    69     void AddSpeakerSinkToStream();

    70 

    71     void CreateStreamVol();

    72     void CreateStreamGain();

    73 

    74     void InitUplink();

    75     void InitDnlink();

    76 

    77     void StartUplink();

    78     void StopUplink();

    79     void StartDnlink();

    80 

    81     void StreamVol();

    82     void StreamGain();

    83     // void StopDnlink();

    84 

    85     void CreateGlobalVol();

    86     void CreateGlobalGain();

    87     void CreateRouting_data();

    88     void CreateRouting();

    89 

    90     void CreateInband_data();

    91     void CreateInband();

    92     void CreateDnlinkDtmf();

    93     void CreateUplinkDtmf();

    94 

    95     void CreateRingTone();

    96 

    97     void InitRingTonePlayerFromProfiles();

    98     void PlayRingTone();

    99     void PauseRingTone();

   100     void MuteRingTone();

   101     void StopRingTone();

   102     void CloseRingTonePlayer();

   103 

   104     void CloseUplink();

   105     void CloseDownlink();

   106     void cleanupTestCase();

   107 public slots:

   108     //From TMSStreamObserver

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

   110     //From TMSClientSinkObserver

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

   112     //From TMSGlobalRoutingObserver

   113     void GlobalRoutingEvent(const QTMSGlobalRouting& routing, QTMSSignalEvent event,

   114         QTMSAudioOutput output);

   115     //From TMSRingToneObserver

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

   117     //From TMSDTMFObserver

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

   119     //From TMSInbandToneObserver

   120     void InbandToneEvent(const QTMSInbandTone& inbandtone, QTMSSignalEvent event);

   121 

   122 private:

   123     void InitRingToneSequencePlayer();

   124     void InitRingTonePlayerFromFile();

   125     void StopDnlink();

   126     void GetAvailableOutput();

   127     void DisplayDevice(QTMSAudioOutput device);

   128 

   129 private:

   130     QTMSFactory *m_Factory;

   131     QTMSCall *m_Call;

   132     QTMSDTMF *m_Dnlnkdtmf;

   133     QTMSDTMF *m_Uplnkdtmf;

   134     QTMSStream *m_Dnlink;

   135     QTMSStream *m_Uplink;

   136     QTMSSource *m_MicSource;

   137     QTMSSource *m_ModemSource;

   138     QTMSSink *m_SpeakerSink;

   139     QTMSSink *m_ModemSink;

   140     QTMSEffect *m_Vol;

   141     QTMSEffect *m_Gain;

   142     QTMSEffect *m_GlobalVol;

   143     QTMSEffect *m_GlobalGain;

   144     QTMSGlobalRouting *m_Routing;

   145     QTMSInbandTone *m_InbandTonePlayer;

   146     QTMSRingTone *m_RingTonePlayer;

   147     GString* m_RTStr;

   148     GString* m_TTSStr;

   149     QSignalSpy *m_UplinkSpy;

   150     QSignalSpy *m_DnlinkSpy;

   151     QSignalSpy *m_InbandSpy;

   152     QSignalSpy *m_RoutingSpy;

   153     OutputVector m_Availableoutputs;

   154 

   155 };

   156 

   157 void QTmsCsTest::initTestCase()

   158 {

   159     qDebug("Start QTms CS tests");

   160 

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

   162     m_Factory = NULL;

   163     m_Call = NULL;

   164     m_Dnlink = NULL;

   165     m_Uplink = NULL;

   166     m_MicSource = NULL;

   167     m_ModemSource = NULL;

   168     m_SpeakerSink = NULL;

   169     m_ModemSink = NULL;

   170     m_Vol = NULL;

   171     m_Gain = NULL;

   172     m_GlobalVol = NULL;

   173     m_GlobalGain = NULL;

   174     m_Routing = NULL;

   175     m_Dnlnkdtmf = NULL;

   176     m_Uplnkdtmf = NULL;

   177     m_InbandTonePlayer = NULL;

   178     m_RingTonePlayer = NULL;

   179     m_UplinkSpy = NULL;

   180     m_DnlinkSpy = NULL;

   181 

   182     QTMSVer *ver(NULL);

   183     gint status;

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

   185 

   186     QVERIFY(status == QTMS_RESULT_SUCCESS);

   187 

   188     qRegisterMetaType<QTMSSignalEvent> ("QTMSSignalEvent");

   189     qRegisterMetaType<QTMSAudioOutput> ("QTMSAudioOutput");

   190 

   191 }

   192 

   193 void QTmsCsTest::cleanupTestCase()

   194 {

   195     qDebug("End QTms tests");

   196 

   197     StopDnlink();

   198 

   199     m_Factory->DeleteSource(m_MicSource);

   200     m_Factory->DeleteSource(m_ModemSource);

   201     m_Factory->DeleteSink(m_ModemSink);

   202     m_Factory->DeleteSink(m_SpeakerSink);

   203 

   204     m_Factory->DeleteDTMF(m_Dnlnkdtmf);

   205     m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);

   206     m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);

   207 

   208     m_Factory->DeleteEffect(m_Vol);

   209     m_Factory->DeleteEffect(m_Gain);

   210     m_Factory->DeleteEffect(m_GlobalVol);

   211     m_Factory->DeleteEffect(m_GlobalGain);

   212 

   213     m_Factory->DeleteGlobalRouting(m_Routing);

   214 

   215     m_Call->DeleteStream(m_Uplink);

   216     m_Call->DeleteStream(m_Dnlink);

   217 

   218     m_Factory->DeleteCall(m_Call);

   219 

   220     delete m_Factory;

   221 

   222 }

   223 

   224 void QTmsCsTest::CSCallSetup()

   225 {

   226     gint status(QTMS_RESULT_SUCCESS);

   227     if (m_Factory && !m_Call) {

   228         gboolean issupported(FALSE);

   229         m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);

   230         QVERIFY(issupported == TRUE);

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

   232         QVERIFY(status == QTMS_RESULT_SUCCESS);

   233         QTMSCallType calltype = m_Call->GetCallType();

   234         QVERIFY(calltype == QTMS_CALL_CS);

   235     }

   236     QVERIFY(status == QTMS_RESULT_SUCCESS);

   237 }

   238 

   239 void QTmsCsTest::CreateUplink()

   240 {

   241     gint status(QTMS_RESULT_SUCCESS);

   242 

   243     if (m_Call) {

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

   245 

   246         QVERIFY(status == QTMS_RESULT_SUCCESS);

   247 

   248         m_UplinkSpy = new QSignalSpy(m_Uplink,

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

   250 

   251         QVERIFY( m_UplinkSpy->isValid() );

   252 

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

   254 

   255 

   256         connect(m_Uplink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,

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

   258 

   259     }

   260 }

   261 

   262 void QTmsCsTest::CreateDnlink()

   263 {

   264     gint status(QTMS_RESULT_SUCCESS);

   265 

   266     if (m_Call) {

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

   268 

   269         QVERIFY(status == QTMS_RESULT_SUCCESS);

   270 

   271         m_DnlinkSpy = new QSignalSpy(m_Dnlink,

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

   273 

   274         QVERIFY( m_DnlinkSpy->isValid() );

   275 

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

   277 

   278         connect(m_Dnlink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,

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

   280     }

   281 }

   282 

   283 void QTmsCsTest::CreateModemSink()

   284 {

   285     gint status(QTMS_RESULT_SUCCESS);

   286 

   287     if (m_Factory && !m_ModemSink) {

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

   289     }

   290     QVERIFY(status == QTMS_RESULT_SUCCESS);

   291 }

   292 

   293 void QTmsCsTest::CreateModemSource()

   294 {

   295     gint status(QTMS_RESULT_SUCCESS);

   296 

   297     if (m_Factory && !m_ModemSource) {

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

   299     }

   300     QVERIFY(status == QTMS_RESULT_SUCCESS);

   301 }

   302 

   303 void QTmsCsTest::AddModemSinkToStream()

   304 {

   305     gint status(QTMS_RESULT_SUCCESS);

   306     if (m_Uplink && m_ModemSink) {

   307         status = m_Uplink->AddSink(m_ModemSink);

   308     }

   309     QVERIFY(status == QTMS_RESULT_SUCCESS);

   310 }

   311 

   312 void QTmsCsTest::AddModemSourceToStream()

   313 {

   314     gint status(QTMS_RESULT_SUCCESS);

   315     if (m_Dnlink && m_ModemSource) {

   316         status = m_Dnlink->AddSource(m_ModemSource);

   317     }

   318     QVERIFY(status == QTMS_RESULT_SUCCESS);

   319 }

   320 

   321 void QTmsCsTest::CreateMicSource()

   322 {

   323     gint status(QTMS_RESULT_SUCCESS);

   324 

   325     if (m_Factory && !m_MicSource) {

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

   327     }

   328     QVERIFY(status == QTMS_RESULT_SUCCESS);

   329 }

   330 

   331 void QTmsCsTest::AddMicSourceToStream()

   332 {

   333     gint status(QTMS_RESULT_SUCCESS);

   334     if (m_Uplink && m_MicSource) {

   335         status = m_Uplink->AddSource(m_MicSource);

   336     }

   337     QVERIFY(status == QTMS_RESULT_SUCCESS);

   338 }

   339 

   340 void QTmsCsTest::CreateSpeakerSink()

   341 {

   342     gint status(QTMS_RESULT_SUCCESS);

   343 

   344     if (m_Factory && !m_SpeakerSink) {

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

   346     }

   347     QVERIFY(status == QTMS_RESULT_SUCCESS);

   348 }

   349 

   350 void QTmsCsTest::AddSpeakerSinkToStream()

   351 {

   352     gint status(QTMS_RESULT_SUCCESS);

   353     if (m_Dnlink && m_SpeakerSink) {

   354         status = m_Dnlink->AddSink(m_SpeakerSink);

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

   356     }

   357     QVERIFY(status == QTMS_RESULT_SUCCESS);

   358 }

   359 

   360 void QTmsCsTest::InitUplink()

   361 {

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

   363     QTest::qWait(1000);

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

   365 }

   366 

   367 void QTmsCsTest::InitDnlink()

   368 {

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

   370     QTest::qWait(1000);

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

   372 }

   373 

   374 void QTmsCsTest::StartUplink()

   375 {

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

   377     QTest::qWait(1000);

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

   379 }

   380 

   381 void QTmsCsTest::StartDnlink()

   382 {

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

   384     QTest::qWait(1000);

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

   386 }

   387 void QTmsCsTest::StopUplink()

   388 {

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

   390     QTest::qWait(1000);

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

   392 }

   393 

   394 void QTmsCsTest::StopDnlink()

   395 {

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

   397     QTest::qWait(1000);

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

   399 }

   400 

   401 void QTmsCsTest::CloseUplink()

   402 {

   403     m_Uplink->Deinit();

   404     QTest::qWait(1000);

   405     if (m_Uplink) {

   406         if (m_Gain) {

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

   408         }

   409         if (m_MicSource) {

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

   411         }

   412         if (m_ModemSink) {

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

   414         }

   415     }

   416 }

   417 

   418 void QTmsCsTest::CloseDownlink()

   419 {

   420     m_Dnlink->Deinit();

   421     QTest::qWait(1000);

   422     if (m_Dnlink) {

   423         if (m_Vol) {

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

   425         }

   426         if (m_ModemSource) {

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

   428         }

   429         if (m_SpeakerSink) {

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

   431         }

   432     }

   433 

   434 }

   435 

   436 void QTmsCsTest::CreateStreamVol()

   437 {

   438     gint status(QTMS_RESULT_SUCCESS);

   439 

   440     if (m_Factory && !m_Vol) {

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

   442 

   443         QVERIFY(status == QTMS_RESULT_SUCCESS);

   444 

   445         connect(static_cast<QTMSVolumeEffect*> (m_Vol),

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

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

   448 

   449         if (m_Dnlink) {

   450             status = m_Dnlink->AddEffect(m_Vol);

   451         }

   452         QVERIFY(status == QTMS_RESULT_SUCCESS);

   453 

   454     }

   455 }

   456 

   457 void QTmsCsTest::StreamVol()

   458 {

   459     gint status(QTMS_RESULT_SUCCESS);

   460     guint maxvol(0);

   461     if (m_Vol) {

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

   463         QVERIFY(status == QTMS_RESULT_SUCCESS);

   464 

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

   466         QVERIFY(status == QTMS_RESULT_SUCCESS);

   467         QTest::qWait(1000);

   468 

   469         guint vol(0);

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

   471         QVERIFY(status == QTMS_RESULT_SUCCESS);

   472 

   473         QCOMPARE(vol,maxvol);

   474     }

   475 }

   476 

   477 void QTmsCsTest::CreateStreamGain()

   478 {

   479     gint status(QTMS_RESULT_SUCCESS);

   480 

   481     if (m_Factory && !m_Gain) {

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

   483 

   484         QVERIFY(status == QTMS_RESULT_SUCCESS);

   485 

   486         connect(static_cast<QTMSGainEffect*> (m_Gain),

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

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

   489 

   490         if (m_Uplink) {

   491             status = m_Uplink->AddEffect(m_Gain);

   492         }

   493         QVERIFY(status == QTMS_RESULT_SUCCESS);

   494     }

   495 }

   496 

   497 void QTmsCsTest::StreamGain()

   498 {

   499     gint status(QTMS_RESULT_SUCCESS);

   500     if (m_Gain) {

   501         guint maxgain(0);

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

   503         QVERIFY(status == QTMS_RESULT_SUCCESS);

   504 

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

   506         QVERIFY(status == QTMS_RESULT_SUCCESS);

   507         QTest::qWait(1000);

   508 

   509         guint gain(0);

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

   511         QVERIFY(status == QTMS_RESULT_SUCCESS);

   512 

   513         QCOMPARE(gain,maxgain);

   514     }

   515 

   516 }

   517 

   518 void QTmsCsTest::CreateGlobalVol()

   519 {

   520     gint status(QTMS_RESULT_SUCCESS);

   521 

   522     if (m_Factory && !m_GlobalVol) {

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

   524 

   525         QVERIFY(status == QTMS_RESULT_SUCCESS);

   526 

   527         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),

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

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

   530 

   531         guint maxvol(0);

   532         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetMaxLevel(maxvol);

   533         QVERIFY(status == QTMS_RESULT_SUCCESS);

   534 

   535         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->SetLevel(maxvol);

   536         QVERIFY(status == QTMS_RESULT_SUCCESS);

   537         QTest::qWait(1000);

   538 

   539         guint vol(0);

   540         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);

   541         QVERIFY(status == QTMS_RESULT_SUCCESS);

   542 

   543         QCOMPARE(vol,maxvol);

   544 

   545     }

   546 }

   547 

   548 void QTmsCsTest::CreateGlobalGain()

   549 {

   550     gint status(QTMS_RESULT_SUCCESS);

   551 

   552     if (m_Factory && !m_GlobalGain) {

   553         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);

   554 

   555         QVERIFY(status == QTMS_RESULT_SUCCESS);

   556 

   557         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),

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

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

   560 

   561         guint maxgain(0);

   562         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetMaxLevel(maxgain);

   563         QVERIFY(status == QTMS_RESULT_SUCCESS);

   564 

   565         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->SetLevel(maxgain);

   566         QVERIFY(status == QTMS_RESULT_SUCCESS);

   567         QTest::qWait(1000);

   568 

   569         guint gain(0);

   570         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetLevel(gain);

   571         QVERIFY(status == QTMS_RESULT_SUCCESS);

   572 

   573         QCOMPARE(gain,maxgain);

   574 

   575     }

   576 }

   577 

   578 void QTmsCsTest::CreateRouting_data()

   579 {

   580     gint status;

   581     if (m_Factory && !m_Routing) {

   582         status = m_Factory->CreateGlobalRouting(m_Routing);

   583         QVERIFY(status == QTMS_RESULT_SUCCESS);

   584 

   585         m_RoutingSpy = new QSignalSpy(m_Routing,

   586             SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,

   587                     QTMSSignalEvent,

   588                     QTMSAudioOutput)));

   589 

   590         QVERIFY( m_RoutingSpy->isValid() );

   591 

   592         // QCOMPARE(m_RoutingSpy->count(), 0 );

   593         connect(m_Routing, SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,

   594                 QTMSSignalEvent,QTMSAudioOutput)), this,

   595             SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,

   596                     QTMSSignalEvent,QTMSAudioOutput)));

   597     }

   598 

   599     //Populate data and test based on available output

   600     GetAvailableOutput();

   601 }

   602 

   603 void QTmsCsTest::CreateRouting()

   604 {

   605     gint status(QTMS_RESULT_SUCCESS);

   606     QFETCH(QTMSAudioOutput, routing);

   607 

   608     if (m_Routing) {

   609         status = m_Routing->SetOutput(routing);

   610         QVERIFY(status == QTMS_RESULT_SUCCESS);

   611 #ifndef __WINSCW__

   612         QTest::qWait(1000);

   613         //  QCOMPARE(m_RoutingSpy->count(), 1 );

   614 #endif

   615         QTMSAudioOutput current;

   616         status = m_Routing->GetOutput(current);

   617 

   618         QVERIFY(status == QTMS_RESULT_SUCCESS);

   619         QCOMPARE(routing,current);

   620 

   621         QTMSAudioOutput previous;

   622         status = m_Routing->GetPreviousOutput(previous);

   623         QVERIFY(status == QTMS_RESULT_SUCCESS);

   624         qDebug("Previous routing:");

   625         DisplayDevice(previous);

   626     }

   627 }

   628 

   629 void QTmsCsTest::GetAvailableOutput()

   630 {

   631     gint status(QTMS_RESULT_SUCCESS);

   632 

   633     if (m_Routing) {

   634         status = m_Routing->GetAvailableOutputs(m_Availableoutputs);

   635 

   636         QVERIFY(status == QTMS_RESULT_SUCCESS);

   637 

   638         qDebug("Available outputs: %d", m_Availableoutputs.size());

   639         std::vector<guint>::iterator iteroutputs = m_Availableoutputs.begin();

   640         for (; iteroutputs < m_Availableoutputs.end(); iteroutputs++) {

   641             DisplayDevice(*iteroutputs);

   642         }

   643     }

   644 }

   645 

   646 void QTmsCsTest::DisplayDevice(QTMSAudioOutput device)

   647 {

   648     QTest::addColumn<QTMSAudioOutput>("routing");

   649 

   650     switch (device) {

   651     case QTMS_AUDIO_OUTPUT_NONE:

   652     {

   653         qDebug("none");

   654         QTest::newRow("None") << QTMS_AUDIO_OUTPUT_NONE;

   655     }

   656         break;

   657     case QTMS_AUDIO_OUTPUT_PUBLIC:

   658     {

   659         qDebug("Public");

   660         QTest::newRow("Public") << QTMS_AUDIO_OUTPUT_PUBLIC;

   661     }

   662         break;

   663     case QTMS_AUDIO_OUTPUT_PRIVATE:

   664     {

   665         qDebug("Private");

   666         QTest::newRow("Private") << QTMS_AUDIO_OUTPUT_PRIVATE;

   667     }

   668         break;

   669     case QTMS_AUDIO_OUTPUT_HANDSET:

   670     {

   671         qDebug("Handset");

   672         QTest::newRow("Handset") << QTMS_AUDIO_OUTPUT_HANDSET;

   673     }

   674         break;

   675     case QTMS_AUDIO_OUTPUT_LOUDSPEAKER:

   676     {

   677         qDebug("Loudspeaker");

   678         QTest::newRow("Loud speaker") << QTMS_AUDIO_OUTPUT_LOUDSPEAKER;

   679     }

   680         break;

   681     case QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY:

   682     {

   683         qDebug("Wired accessory");

   684         QTest::newRow("Wired accessory") << QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY;

   685     }

   686         break;

   687     case QTMS_AUDIO_OUTPUT_ACCESSORY:

   688     {

   689         qDebug("Accessory");

   690         QTest::newRow("Accessory") << QTMS_AUDIO_OUTPUT_ACCESSORY;

   691     }

   692         break;

   693     case QTMS_AUDIO_OUTPUT_ETTY:

   694     {

   695         qDebug("TTY");

   696         QTest::newRow("ETTY") << QTMS_AUDIO_OUTPUT_ETTY;

   697     }

   698         break;

   699     default:

   700         break;

   701     }

   702 }

   703 

   704 void QTmsCsTest::CreateDnlinkDtmf()

   705 {

   706     gint status(QTMS_RESULT_SUCCESS);

   707     GString* dtmfstring(NULL);

   708 

   709     status = m_Factory->CreateDTMF(QTMS_STREAM_DOWNLINK, m_Dnlnkdtmf);

   710 

   711     QVERIFY(status == QTMS_RESULT_SUCCESS);

   712     if (m_Dnlnkdtmf) {

   713         QSignalSpy dtmfspy(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));

   714 

   715         QVERIFY( dtmfspy.isValid() );

   716 

   717         //QCOMPARE(dtmfspy.count(), 0 );

   718 

   719         connect(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,

   720             SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));

   721 

   722         dtmfstring = g_string_new("4723");

   723         status = m_Dnlnkdtmf->SetTone(dtmfstring);

   724 

   725         m_Dnlnkdtmf->Start();

   726         QTest::qWait(1000);

   727         g_string_free(dtmfstring, TRUE);

   728         //QCOMPARE(dtmfspy.count(), 1 );

   729 

   730         status = m_Dnlnkdtmf->Stop();

   731         QVERIFY(status == QTMS_RESULT_SUCCESS);

   732         QTest::qWait(1000);

   733         //QCOMPARE(dtmfspy.count(), 2 );

   734 

   735     }

   736 }

   737 

   738 void QTmsCsTest::CreateUplinkDtmf()

   739 {

   740     gint status(QTMS_RESULT_SUCCESS);

   741     GString* dtmfstring(NULL);

   742 

   743     status = m_Factory->CreateDTMF(QTMS_STREAM_UPLINK, m_Uplnkdtmf);

   744 

   745     QVERIFY(status == QTMS_RESULT_SUCCESS);

   746     if (m_Uplnkdtmf) {

   747         QSignalSpy uplinkdtmfspy(m_Uplnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));

   748 

   749         QVERIFY( uplinkdtmfspy.isValid() );

   750 

   751         //QCOMPARE(dtmfspy.count(), 0 );

   752 

   753         connect(m_Uplnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,

   754             SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));

   755 

   756         dtmfstring = g_string_new("4723");

   757         status = m_Uplnkdtmf->SetTone(dtmfstring);

   758 

   759         m_Uplnkdtmf->Start();

   760         QTest::qWait(1000);

   761         g_string_free(dtmfstring, TRUE);

   762         //QCOMPARE(dtmfspy.count(), 1 );

   763 

   764         m_Uplnkdtmf->ContinueDTMFStringSending(FALSE);

   765 

   766         status = m_Uplnkdtmf->Stop();

   767         QVERIFY(status == QTMS_RESULT_SUCCESS);

   768         QTest::qWait(1000);

   769         //QCOMPARE(dtmfspy.count(), 2 );

   770 

   771     }

   772 }

   773 

   774 void QTmsCsTest::CreateInband_data()

   775 {

   776 

   777     gint status(QTMS_RESULT_SUCCESS);

   778     if (m_Factory && !m_InbandTonePlayer) {

   779         status = m_Factory->CreateInbandTonePlayer(m_InbandTonePlayer);

   780 

   781         QVERIFY(status == QTMS_RESULT_SUCCESS);

   782         m_InbandSpy = new QSignalSpy(m_InbandTonePlayer,

   783             SIGNAL(InbandToneEvent(const QTMSInbandTone&,QTMSSignalEvent)));

   784 

   785         QVERIFY( m_InbandSpy->isValid() );

   786 

   787         //QCOMPARE(m_InbandSpy->count(), 0 );

   788         connect(m_InbandTonePlayer,

   789             SIGNAL(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)), this,

   790             SLOT(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)));

   791     }

   792 

   793     QTest::addColumn<QTMSInbandToneType>("inbandTone");

   794 

   795     QTest::newRow("Busy") << QTMS_INBAND_USER_BUSY;

   796     QTest::newRow("Path not avail") << QTMS_INBAND_RADIO_PATH_NOT_AVAIL;

   797     QTest::newRow("Congestion") << QTMS_INBAND_CONGESTION;

   798     QTest::newRow("Special info") << QTMS_INBAND_SPECIAL_INFO;

   799     QTest::newRow("Reorder") << QTMS_INBAND_REORDER;

   800     QTest::newRow("Remote alerting") << QTMS_INBAND_REMOTE_ALEARTING;

   801     QTest::newRow("call waiting") << QTMS_INBAND_CALL_WAITING;

   802     QTest::newRow("data call") << QTMS_INBAND_DATA_CALL;

   803     QTest::newRow("no sequence") << QTMS_INBAND_NO_SEQUENCE;

   804     QTest::newRow("beep sequence") << QTMS_INBAND_BEEP_SEQUENCE;

   805 

   806 }

   807 

   808 void QTmsCsTest::CreateInband()

   809 {

   810     gint status(QTMS_RESULT_SUCCESS);

   811     QFETCH(QTMSInbandToneType, inbandTone);

   812 

   813     if (m_InbandTonePlayer) {

   814         status = m_InbandTonePlayer->Start(inbandTone);

   815         QVERIFY(status == QTMS_RESULT_SUCCESS);

   816         QTest::qWait(1000);

   817         // QCOMPARE(m_InbandSpy->count(), 1 );

   818 

   819         status = m_InbandTonePlayer->Stop();

   820         QVERIFY(status == QTMS_RESULT_SUCCESS);

   821         QTest::qWait(1000);

   822         // QCOMPARE(m_InbandSpy->count(), 2 );

   823     }

   824 }

   825 

   826 void QTmsCsTest::CreateRingTone()

   827 {

   828     gint status(QTMS_RESULT_SUCCESS);

   829 

   830     if (m_Factory) {

   831         status = m_Factory->CreateRingTonePlayer(m_RingTonePlayer);

   832         QVERIFY(status == QTMS_RESULT_SUCCESS);

   833 

   834         connect(m_RingTonePlayer, SIGNAL(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)), this,

   835             SLOT(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)));

   836     }

   837 

   838 }

   839 

   840 void QTmsCsTest::InitRingTonePlayerFromProfiles()

   841 {

   842     if (m_RingTonePlayer) {

   843         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_DEFAULT);

   844         QVERIFY(status == QTMS_RESULT_SUCCESS);

   845         QTest::qWait(1000);

   846     }

   847 

   848 }

   849 

   850 void QTmsCsTest::InitRingTonePlayerFromFile()

   851 {

   852     if (m_RingTonePlayer) {

   853         TBuf<sizeof(KTestFile1)> buf(KTestFile1);

   854         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2);

   855         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_FILE, m_RTStr);

   856         QVERIFY(status == QTMS_RESULT_SUCCESS);

   857         QTest::qWait(1000);

   858         g_string_free(m_RTStr, TRUE);

   859         m_RTStr = NULL;

   860     }

   861 

   862 }

   863 

   864 void QTmsCsTest::InitRingToneSequencePlayer()

   865 {

   866     if (m_RingTonePlayer) {

   867         TBuf8<sizeof(KRTBeepSequence)> buf(KRTBeepSequence);

   868         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length());

   869         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_SEQUENCE, m_RTStr);

   870         QVERIFY(status == QTMS_RESULT_SUCCESS);

   871         QTest::qWait(1000);

   872         g_string_free(m_RTStr, TRUE);

   873     }

   874 }

   875 

   876 void QTmsCsTest::PlayRingTone()

   877 {

   878     if (m_RingTonePlayer) {

   879         gint status = m_RingTonePlayer->Play();

   880         QVERIFY(status == QTMS_RESULT_SUCCESS);

   881         QTest::qWait(1000);

   882     }

   883 }

   884 

   885 void QTmsCsTest::PauseRingTone()

   886 {

   887     if (m_RingTonePlayer) {

   888         gint status = m_RingTonePlayer->Pause(); //pause audio for video RT only

   889         QVERIFY(status == QTMS_RESULT_SUCCESS);

   890         QTest::qWait(1000);

   891     }

   892 }

   893 

   894 void QTmsCsTest::StopRingTone()

   895 {

   896     if (m_RingTonePlayer) {

   897         gint status = m_RingTonePlayer->Stop();

   898         QVERIFY(status == QTMS_RESULT_SUCCESS);

   899         QTest::qWait(1000);

   900     }

   901 }

   902 

   903 void QTmsCsTest::MuteRingTone()

   904 {

   905     if (m_RingTonePlayer) {

   906         m_RingTonePlayer->Mute();

   907     }

   908 }

   909 

   910 void QTmsCsTest::CloseRingTonePlayer()

   911 {

   912     if (m_Factory && m_RingTonePlayer) {

   913         m_RingTonePlayer->Deinit();

   914         m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);

   915     }

   916 }

   917 

   918 void QTmsCsTest::EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event)

   919 {

   920     QTMSEffectType effecttype;

   921     const_cast<QTMSEffect&> (tmseffect).GetType(effecttype);

   922 

   923     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

   924 

   925     switch (effecttype) {

   926     case TMS_EFFECT_GLOBAL_VOL:

   927     {

   928         switch (event.type) {

   929         case TMS_EVENT_EFFECT_VOL_CHANGED:

   930             qDebug("Global vol effect change");

   931             break;

   932         default:

   933             break;

   934         }

   935     }

   936         break;

   937     case TMS_EFFECT_GLOBAL_GAIN:

   938     {

   939         switch (event.type) {

   940         case TMS_EVENT_EFFECT_GAIN_CHANGED:

   941             qDebug("Global gain effect change");

   942             break;

   943         default:

   944             break;

   945         }

   946     }

   947         break;

   948     case TMS_EFFECT_VOLUME:

   949         qDebug("Stream vol effect change");

   950         break;

   951     case TMS_EFFECT_GAIN:

   952         qDebug("Stream gain effect change");

   953         break;

   954     default:

   955         break;

   956     }

   957 }

   958 

   959 void QTmsCsTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/, QTMSSignalEvent event,

   960     QTMSAudioOutput /*output*/)

   961 {

   962     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

   963     switch (event.type) {

   964     case TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:

   965         qDebug("Available outputs changed");

   966         break;

   967     case TMS_EVENT_ROUTING_OUTPUT_CHANGED:

   968         qDebug("output changed");

   969         break;

   970     case TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:

   971         qDebug("set output complete");

   972         break;

   973     default:

   974         break;

   975     }

   976 

   977 }

   978 

   979 void QTmsCsTest::TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event)

   980 {

   981 

   982     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

   983 

   984     gint streamId;

   985     streamId = const_cast<QTMSStream&> (stream).GetStreamId();

   986     qDebug("StreamID %d", streamId);

   987     gint state;

   988     state = const_cast<QTMSStream&> (stream).GetState();

   989     QVERIFY(state == event.curr_state);

   990 

   991     switch (const_cast<QTMSStream&> (stream).GetStreamType()) {

   992     case QTMS_STREAM_UPLINK:

   993     {

   994         switch (event.type) {

   995         case QTMS_EVENT_STREAM_STATE_CHANGED:

   996         {

   997             switch (event.curr_state) {

   998             case QTMS_STREAM_INITIALIZED:

   999             {

  1000                 qDebug("Uplink initialized ");

  1001                 break;

  1002             }

  1003             case QTMS_STREAM_UNINITIALIZED:

  1004                 qDebug("Uplink uninitialized ");

  1005                 break;

  1006             case QTMS_STREAM_PAUSED:

  1007                 qDebug("Uplink paused ");

  1008                 break;

  1009             case QTMS_STREAM_STARTED:

  1010                 qDebug("Uplink started ");

  1011                 break;

  1012             default:

  1013                 break;

  1014             }

  1015             break;

  1016         }

  1017         default:

  1018             break;

  1019         }

  1020         break;

  1021     }

  1022     case QTMS_STREAM_DOWNLINK:

  1023     {

  1024         switch (event.type) {

  1025         case QTMS_EVENT_STREAM_STATE_CHANGED:

  1026         {

  1027             switch (event.curr_state) {

  1028             case QTMS_STREAM_INITIALIZED:

  1029             {

  1030                 qDebug("Downlink initialized ");

  1031                 break;

  1032             }

  1033             case QTMS_STREAM_UNINITIALIZED:

  1034                 qDebug("Downlink uninitialized ");

  1035                 break;

  1036             case QTMS_STREAM_PAUSED:

  1037                 qDebug("Downlink paused ");

  1038                 break;

  1039             case QTMS_STREAM_STARTED:

  1040                 qDebug("Downlink started ");

  1041                 break;

  1042             default:

  1043                 break;

  1044             }

  1045             break;

  1046         }

  1047         default:

  1048             break;

  1049         }

  1050         break;

  1051     }

  1052     default:

  1053         break;

  1054     }

  1055 }

  1056 

  1057 void QTmsCsTest::RingtoneEvent(const QTMSRingTone& /*rt*/, QTMSSignalEvent event)

  1058 {

  1059     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

  1060     switch (event.type) {

  1061     case TMS_EVENT_RINGTONE_OPEN_COMPLETE:

  1062         qDebug("RT Open Complete");

  1063         break;

  1064     case TMS_EVENT_RINGTONE_PLAY_COMPLETE:

  1065         qDebug("RT Play Complete");

  1066         break;

  1067     default:

  1068         break;

  1069     }

  1070 }

  1071 

  1072 void QTmsCsTest::DTMFEvent(const QTMSDTMF& /*dtmf*/, QTMSSignalEvent event)

  1073 {

  1074     if (event.reason != QTMS_RESULT_SUCCESS) {

  1075         QEXPECT_FAIL("","Need to be in call, expect uplink dtmf to fail", Continue);

  1076     }

  1077     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

  1078 

  1079     switch (event.type) {

  1080     case QTMS_EVENT_DTMF_TONE_STARTED:

  1081         qDebug("DTMF Started");

  1082         break;

  1083     case QTMS_EVENT_DTMF_TONE_STOPPED:

  1084         qDebug("DTMF Stopped");

  1085         break;

  1086     default:

  1087         break;

  1088     }

  1089 }

  1090 

  1091 void QTmsCsTest::InbandToneEvent(const QTMSInbandTone& /*inbandtone*/, QTMSSignalEvent event)

  1092 {

  1093     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

  1094     switch (event.type) {

  1095     case QTMS_EVENT_INBAND_TONE_STARTED:

  1096         qDebug("Inband Tone Started");

  1097         break;

  1098     case QTMS_EVENT_INBAND_TONE_STOPPED:

  1099         qDebug("Inband Tone Stopped");

  1100         break;

  1101     default:

  1102         break;

  1103     }

  1104 }

  1105 

  1106 QTEST_MAIN_S60(QTmsCsTest)

  1107 

  1108 #include "qtmscstest.moc"

  1109