/*

 * 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: Telephony Multimedia Service - STIF TEST

 *

 */

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "TmsAudioServicesTestClass.h"

#include "debug.h"

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

// -----------------------------------------------------------------------------

//

void CTmsAudioServicesTestClass::Delete()

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::Delete")));

    if (iFactory && iTmsBuffer)

        {

        iFactory->DeleteBuffer(iTmsBuffer);

        }

    if (iFactory && iTmsClientSource)

        {

        iFactory->DeleteSource(iTmsClientSource);

        }

    if (iFactory && iTmsModemSource)

        {

        iFactory->DeleteSource(iTmsModemSource);

        }

    if (iFactory && iTmsMicSource)

        {

        iFactory->DeleteSource(iTmsMicSource);

        }

    if (iFactory && iTmsClientSink)

        {

        iFactory->DeleteSink(iTmsClientSink);

        }

    if (iFactory && iTmsModemSink)

        {

        iFactory->DeleteSink(iTmsModemSink);

        }

    if (iFactory && iTmsSpkrSink)

        {

        iFactory->DeleteSink(iTmsSpkrSink);

        }

    if (iFactory && iTmsFormat)

        {

        iFactory->DeleteFormat(iTmsFormat);

        }

    if (iFactory && iTmsFormatUp)

        {

        iFactory->DeleteFormat(iTmsFormatUp);

        }

    if (iFactory && iTmsFormatDn)

        {

        iFactory->DeleteFormat(iTmsFormatDn);

        }

    if (iFactory && iTmsEffect)

        {

        iFactory->DeleteEffect(iTmsEffect);

        }

    if (iTmsUplink && iTmsCall)

        {

        iTmsCall->DeleteStream(iTmsUplink);

        }

    if (iTmsDnlink && iTmsCall)

        {

        iTmsCall->DeleteStream(iTmsDnlink);

        }

    if (iFactory && iTmsCall)

        {

        iFactory->DeleteCall(iTmsCall);

        }

    if (iFactory && iTmsDnlinkEffect)

        {

        iFactory->DeleteEffect(iTmsDnlinkEffect);

        }

    if (iFactory && iTmsUplinkEffect)

        {

        iFactory->DeleteEffect(iTmsUplinkEffect);

        }

    if (iFactory && iGlobalVol)

        {

        iFactory->DeleteEffect(iGlobalVol);

        }

    if (iFactory && iGlobalGain)

        {

        iFactory->DeleteEffect(iGlobalGain);

        }

    if (iFactory && iTmsGlobalRouting)

        {

        iFactory->DeleteGlobalRouting(iTmsGlobalRouting);

        }

    iExpectedEvents.Close();

    iOcurredEvents.Close();

    iLog->Log(_L("Deleting test class..."));

    iLog->Log(_L(""));

    iLog->Log(_L(""));

    // delete iPlayBuf;

    if (iTmsDnlink)

        {

        if (iDnLinkStatus != UNINITIALIZED)

            {

            iTmsDnlink->Deinit();

            }

        delete iTmsDnlink;

        iTmsDnlink = NULL;

        }

    if (iTmsUplink)

        {

        if (iUpLinkStatus != UNINITIALIZED)

            {

            iTmsUplink->Deinit();

            }

        delete iTmsUplink;

        iTmsUplink = NULL;

        }

    delete iFactory;

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CTmsAudioServicesTestClass::RunMethodL(CStifItemParser& aItem)

    {

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "SetTimeout", CTmsAudioServicesTestClass::SetTimeout ),

        ENTRY( "CreateFactory", CTmsAudioServicesTestClass::CreateTmsFactory ),

        ENTRY( "CreateCall", CTmsAudioServicesTestClass::CreateCall ),

        ENTRY( "CreateFormat", CTmsAudioServicesTestClass::CreateFormat ),

        ENTRY( "CreateBuffer", CTmsAudioServicesTestClass::CreateBuffer ),

        ENTRY( "CreateEffect", CTmsAudioServicesTestClass::CreateEffect ),

        ENTRY( "CreateGlobalRouting", CTmsAudioServicesTestClass::CreateGlobalRouting ),

        ENTRY( "CreateSource", CTmsAudioServicesTestClass::CreateSource ),

        ENTRY( "DeleteSource", CTmsAudioServicesTestClass::DeleteSource ),

        ENTRY( "CreateSink", CTmsAudioServicesTestClass::CreateSink ),

        ENTRY( "DeleteSink", CTmsAudioServicesTestClass::DeleteSink ),

        ENTRY( "GetSourceType", CTmsAudioServicesTestClass::GetSourceType ),

        ENTRY( "GetSinkType", CTmsAudioServicesTestClass::GetSinkType ),

        ENTRY( "GetEffectType", CTmsAudioServicesTestClass::GetEffectType ),

        ENTRY( "CreateDownlinkStream", CTmsAudioServicesTestClass::CreateDownlinkStream ),

        ENTRY( "CreateUplinkStream", CTmsAudioServicesTestClass::CreateUplinkStream ),

        ENTRY( "GetSupportedFormats", CTmsAudioServicesTestClass::GetSupportedFormats ),

        ENTRY( "IsCallTypeSupported", CTmsAudioServicesTestClass::IsCallTypeSupported ),

        ENTRY( "SetDownlinkFormat", CTmsAudioServicesTestClass::SetDownlinkFormat ),

        ENTRY( "SetUplinkFormat", CTmsAudioServicesTestClass::SetUplinkFormat ),

        ENTRY( "ReSetDownlinkFormat", CTmsAudioServicesTestClass::ReSetDownlinkFormat ),

        ENTRY( "ReSetUplinkFormat", CTmsAudioServicesTestClass::ReSetUplinkFormat ),

        ENTRY( "OpenDownlink", CTmsAudioServicesTestClass::OpenDownlink ),

        ENTRY( "OpenUplink", CTmsAudioServicesTestClass::OpenUplink ),

        ENTRY( "Gain", CTmsAudioServicesTestClass::Gain ),

        ENTRY( "Volume", CTmsAudioServicesTestClass::Volume ),

        ENTRY( "Close", CTmsAudioServicesTestClass::Close ),

        ENTRY( "Start", CTmsAudioServicesTestClass::Start ),

        ENTRY( "Pause", CTmsAudioServicesTestClass::Pause ),

        ENTRY( "Stop", CTmsAudioServicesTestClass::Stop ),

        ENTRY( "GetBitRateList", CTmsAudioServicesTestClass::GetBitRateList ),

        ENTRY( "SetBitrates", CTmsAudioServicesTestClass::SetBitrates ),

        ENTRY( "GetBitrates", CTmsAudioServicesTestClass::GetBitrates ),

        ENTRY( "GetDownlinkVersion", CTmsAudioServicesTestClass::GetDownlinkVersion ),

        ENTRY( "GetUplinkVersion", CTmsAudioServicesTestClass::GetUplinkVersion ),

        ENTRY( "GetType", CTmsAudioServicesTestClass::GetType ),

        ENTRY( "GetVAD", CTmsAudioServicesTestClass::GetVAD ),

        ENTRY( "ToggleVAD", CTmsAudioServicesTestClass::ToggleVAD ),

        ENTRY( "GetMode", CTmsAudioServicesTestClass::GetMode ),

        ENTRY( "SetMode", CTmsAudioServicesTestClass::SetMode ),

        ENTRY( "GetCNG", CTmsAudioServicesTestClass::GetCNG ),

        ENTRY( "ToggleCNG", CTmsAudioServicesTestClass::ToggleCNG ),

        ENTRY( "GetPLC", CTmsAudioServicesTestClass::GetPLC ),

        ENTRY( "TogglePLC", CTmsAudioServicesTestClass::TogglePLC ),

        ENTRY( "GetBufferType", CTmsAudioServicesTestClass::GetBufferType ),

        ENTRY( "AddClientSrcToDnlStream", CTmsAudioServicesTestClass::AddClientSrcToDnlStream ),

        ENTRY( "AddMicSrcToUplStream", CTmsAudioServicesTestClass::AddMicSrcToUplStream ),

        ENTRY( "AddModemSrcToDnlStream", CTmsAudioServicesTestClass::AddModemSrcToDnlStream ),

        ENTRY( "RemoveClientSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveClientSrcFromDnlStream ),

        ENTRY( "RemoveMicSrcFromUplStream", CTmsAudioServicesTestClass::RemoveMicSrcFromUplStream ),

        ENTRY( "RemoveModemSrcFromDnlStream", CTmsAudioServicesTestClass::RemoveModemSrcFromDnlStream ),

        ENTRY( "AddSourceObserver", CTmsAudioServicesTestClass::AddSourceObserver ),

        ENTRY( "RemoveSourceObserver", CTmsAudioServicesTestClass::RemoveSourceObserver ),

        ENTRY( "AddClientSinkToUplStream", CTmsAudioServicesTestClass::AddClientSinkToUplStream ),

        ENTRY( "AddModemSinkToUplStream", CTmsAudioServicesTestClass::AddModemSinkToUplStream ),

        ENTRY( "AddSpkrSinkToDnlStream", CTmsAudioServicesTestClass::AddSpkrSinkToDnlStream ),

        ENTRY( "RemoveClientSinkFromUplStream", CTmsAudioServicesTestClass::RemoveClientSinkFromUplStream ),

        ENTRY( "RemoveModemSinkFromUplStream", CTmsAudioServicesTestClass::RemoveModemSinkFromUplStream ),

        ENTRY( "RemoveSpkrSinkFromDnlStream", CTmsAudioServicesTestClass::RemoveSpkrSinkFromDnlStream ),

        ENTRY( "AddSinkObserver", CTmsAudioServicesTestClass::AddSinkObserver ),

        ENTRY( "RemoveSinkObserver", CTmsAudioServicesTestClass::RemoveSinkObserver ),

        ENTRY( "GetStreamType", CTmsAudioServicesTestClass::GetStreamType ),

        ENTRY( "GetStreamState", CTmsAudioServicesTestClass::GetStreamState ),

        ENTRY( "SetOutput", CTmsAudioServicesTestClass::SetOutput ),

        ENTRY( "GetOutput", CTmsAudioServicesTestClass::GetOutput ),

        ENTRY( "GetPreviousOutput", CTmsAudioServicesTestClass::GetPreviousOutput ),

        ENTRY( "GetAvailableOutputs", CTmsAudioServicesTestClass::GetAvailableOutputs ),

        ENTRY( "AddGlobalRoutingObserver", CTmsAudioServicesTestClass::AddGlobalRoutingObserver ),

        ENTRY( "DeleteGlobalRoutingObserver", CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver ),

        ENTRY( "Example", CTmsAudioServicesTestClass::ExampleL )

        };

    const TInt count = sizeof(KFunctions) / sizeof(TStifFunctionInfo);

    return RunInternalL(KFunctions, count, aItem);

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::EventName

// Return descriptor with the notification description

// -----------------------------------------------------------------------------

TPtrC CTmsAudioServicesTestClass::EventName(TInt aKey)

    {

    static TText* const badKeyword = (TText*) L"BadKeyword";

    static TText* const keywords[] =

        {

        (TText*)L"EOpenDownlinkComplete",

        (TText*)L"EOpenUplinkComplete",

        (TText*)L"EDownlinkClosed",

        (TText*)L"EUplinkClosed",

        (TText*)L"EOpenCompleteDNL",

        (TText*)L"EOpenCompleteUPL",

        (TText*)L"EStreamPaused",

        (TText*)L"EStreamStarted",

        (TText*)L"EOpenComplete",

        (TText*)L"EPlaybackComplete",

        (TText*)L"EEmptyBuffer",

        (TText*)L"EFillBuffer",

        (TText*)L"EOutputChanged",

        (TText*)L"ESetOutputComplete",

        };

    if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) )

        {

        iLog->Log(_L("Keyword out of bounds"));

        TPtrC keyword( badKeyword );

        return keyword;

        }

    else

        {

        TPtrC keyword( keywords[aKey] );

        return keyword;

        }

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::AddExpectedEvent

// Add an event to the expected events' list

// -----------------------------------------------------------------------------

void CTmsAudioServicesTestClass::AddExpectedEvent(TTmsExpectedEvent event,

        TInt ms)

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::AddExpectedEvent")));

    iExpectedEvents.Append(event);

    TPtrC eventName = EventName(event);

    iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event,

            &eventName, iExpectedEvents.Count());

    if (iTimeoutController && !iTimeoutController->IsActive())

        {

        if (ms > 0)

            {

            iTimeoutController->Start(TTimeIntervalMicroSeconds(ms * 1000));

            }

        else

            {

            iLog->Log(_L("Timeout with default value (1s)"));

            iTimeoutController->Start(TTimeIntervalMicroSeconds(1000000));

            }

        }

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::RemoveExpectedEvent

// Remove the indicated event from the expected events' list

// -----------------------------------------------------------------------------

TBool CTmsAudioServicesTestClass::RemoveExpectedEvent(TTmsExpectedEvent aEvent)

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::RemoveExpectedEvent")));

    iLog->Log(_L("CTmsAudioServicesTestClass::RemoveExpectedEvent"));

    TBool match = EFalse;

    for (TUint i = 0; i < iExpectedEvents.Count(); i++)

        {

        if (iExpectedEvents[i] == aEvent)

            {

            iLog->Log(_L("Expeted events: %d"), iExpectedEvents.Count());

            iExpectedEvents.Remove(i);

            match = ETrue;

            break;

            }

        }

    return match;

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::RemoveAllExpectedEvents

// Remove the indicated event from the expected events' list

// -----------------------------------------------------------------------------

void CTmsAudioServicesTestClass::RemoveAllExpectedEvents()

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::RemoveAllExpectedEvents")));

    iLog->Log(_L("Removing all expected events"));

    iExpectedEvents.Reset();

    iOcurredEvents.Reset();

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::ProcessEvent

// -----------------------------------------------------------------------------

void CTmsAudioServicesTestClass::ProcessEvent(TTmsExpectedEvent aEvent,

        TInt aError)

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::ProcessExpectedEvent")));

    iLog->Log(_L("CTmsAudioServicesTestClass:: ProcessExpectedEvent"));

    TPtrC nameEvent = EventName(aEvent);

    if (aError == KErrNone)

        {

        if (RemoveExpectedEvent(aEvent))

            {

            iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"),

                    aEvent, &nameEvent, iExpectedEvents.Count());

            }

        else

            {

            iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent);

            return;

            }

        if (iExpectedEvents.Count() == 0)

            {

            Signal();

            iTimeoutController->Cancel();

            }

        }

    else

        {

        iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"),

                aEvent, &nameEvent, aError);

        if (iExpectedEvents.Count() != 0)

            {

            RemoveExpectedEvent(aEvent);

            }

        iTimeoutController->Cancel();

        Signal(KErrCallbackErrorCode);

        }

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::HandleTimeout

// Review if all the expected events have ocurred once the time is over

// -----------------------------------------------------------------------------

void CTmsAudioServicesTestClass::HandleTimeout(TInt aError)

    {

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::HandleTimeout")));

    if (aError != KErrNone)

        {

        if (iExpectedEvents.Count() == 0)

            {

            iLog->Log(_L("Timing out but events have ocurred"));

            Signal();

            }

        else

            {

            RemoveAllExpectedEvents();

            iLog->Log(_L("Timing out and events still pending"));

            Signal(KErrEventPending);

            }

        }

    else

        {

        iLog->Log(_L("Timing out return a error %d"), aError);

        Signal(aError);

        }

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::SetTimeout

// Create a timer and set a timeout

// When the timeout is reached the test case is marked as failed

// It's used rather than the "timeout" keyword in the configuration file

// because in this way the log continues

// -----------------------------------------------------------------------------

TInt CTmsAudioServicesTestClass::SetTimeout(CStifItemParser& aItem)

    {

    FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetTimeout")));

    TInt timeout = 0;

    TInt error = aItem.GetNextInt(timeout);

    if (iTimeoutController)

        {

        if (timeout > 0)

            {

            iTimeoutController->Start(TTimeIntervalMicroSeconds(timeout

                    * 1000));

            }

        else

            {

            iTimeoutController->Start(TTimeIntervalMicroSeconds(1000000));

            }

        }

    else

        {

        iLog->Log(_L("Timeout Controller doesn't exist"));

        error = KErrTimeoutController;

        }

    return error;

    }

// -----------------------------------------------------------------------------

// Uses the TestModuleBase API to allow a panic as exit reason for a test case

// -----------------------------------------------------------------------------

TInt CTmsAudioServicesTestClass::SetAllowedPanic(CStifItemParser& aItem)

    {

    FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetAllowedPanic")));

    TInt error = KErrNone;

    TInt panicCode;

    TPtrC panicType;

    if ((KErrNone == aItem.GetNextString(panicType)) &&

            (KErrNone == aItem.GetNextInt(panicCode)))

        {

        iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode);

        //     iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode );

        iNormalExitReason = EFalse;

        }

    else

        {

        iLog->Log(KMsgBadTestParameters);

        error = KErrBadTestParameter;

        }

    return error;

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::SetExpectedEvents()

// -----------------------------------------------------------------------------

TInt CTmsAudioServicesTestClass::SetExpectedEvents(CStifItemParser& aItem)

    {

    FTRACE (FPrint(_L("CTmsAudioServicesTestClass::SetExpectedEvents")));

    TInt error = KErrNone;

    TInt event = 0;

    while (KErrNone == aItem.GetNextInt(event))

        {

        AddExpectedEvent(static_cast<TTmsExpectedEvent> (event), 0); // Default timeout value

        }

    return error;

    }

// -----------------------------------------------------------------------------

// CTmsAudioServicesTestClass::ExampleL

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CTmsAudioServicesTestClass::ExampleL(CStifItemParser& aItem)

    {

    // Print to UI

    _LIT( KTmsAudioServicesTestClass, "TmsAudioServicesTestClass" );

    _LIT( KExample, "In Example" );

    TestModuleIf().Printf(0, KTmsAudioServicesTestClass, KExample);

    // Print to log file

    iLog->Log(KExample);

    TInt i = 0;

    TPtrC string;

    _LIT( KParam, "Param[%i]: %S" );

    while (aItem.GetNextString(string) == KErrNone)

        {

        TestModuleIf().Printf(i, KTmsAudioServicesTestClass, KParam, i,

                &string);

        i++;

        }

    return KErrNone;

    }

TInt CTmsAudioServicesTestClass::CreateTmsFactory(CStifItemParser& /*aItem */)

    {

    RDebug::Printf("CTmsAudioServicesTestClass::CreateTmsFactory >> ENTER");

    FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateFactory")));

    iLog->Log(_L("CTmsAudioServicesTestClass::CreateFactory"));

    TInt error = KErrNone;

    TMSVer* v = NULL;//not defined yet

    error = TMSFactory::CreateFactory(iFactory, *v);

    RDebug::Printf("[TMS STIF] TMSFactory::CreateFactory Return [%d]", error);

    RDebug::Printf("CTmsAudioServicesTestClass::CreateTmsFactory << EXIT");

    return error;

    }

TInt CTmsAudioServicesTestClass::CreateCall(CStifItemParser& aItem)

    {

    iLog->Log(_L("CTmsAudioServicesTestClass::CreateCall"));

    TInt error = KErrNone;

    TInt calltype;