/*
* Copyright (c) 2010 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: This file contains Hardcoded module implementation.
*
*/


#include <Stiftestinterface.h>
#include <SettingServerClient.h>
#include <sifui.h>                      // CSifUi
#include "SifUiTest.h"


//
// NOTE: This cpp file contains just generic STIF module code.
// Test case functions are defined in SifUiTestCases.cpp
//


_LIT( KWaitAndSendThread, "WaitAndSendKey" );
const TInt KWaitAndSendThreadStack = 0x1000;

class TDelayAndKeyEvent {
public:
    TTimeIntervalMicroSeconds32 iDelay;
    TKeyEvent iKeyEvent;
};


// ======== LOCAL FUNCTIONS =========

// -----------------------------------------------------------------------------
// DoSendKeyEventL( const TKeyEvent& aKeyEvent )
// -----------------------------------------------------------------------------
//
void DoSendKeyEventL( const TKeyEvent& aKeyEvent )
    {
    RWsSession wsSession;
    User::LeaveIfError( wsSession.Connect() );
    CleanupClosePushL( wsSession );
    TInt focusedGroup = wsSession.GetFocusWindowGroup();

    TWsEvent event;
    TKeyEvent& keyEvent( *event.Key() );
    TInt err;

    /*
    event.SetType( EEventKeyDown );
    event.SetTimeNow();
    keyEvent = aKeyEvent;
    err = wsSession.SendEventToWindowGroup( focusedGroup, event );
    User::LeaveIfError( err );
    */

    event.SetType( EEventKey );
    event.SetTimeNow();
    keyEvent = aKeyEvent;
    err = wsSession.SendEventToWindowGroup( focusedGroup, event );
    User::LeaveIfError( err );

    /*
    event.SetType( EEventKeyUp );
    event.SetTimeNow();
    keyEvent = aKeyEvent;
    err = wsSession.SendEventToWindowGroup( focusedGroup, event );
    User::LeaveIfError( err );
    */

    CleanupStack::PopAndDestroy( &wsSession );
    }

// -----------------------------------------------------------------------------
// WaitAndSendThreadFunc()
// -----------------------------------------------------------------------------
//
TInt WaitAndSendThreadFunc( TAny* aPtr )
    {
    TDelayAndKeyEvent* params = reinterpret_cast<TDelayAndKeyEvent*>( aPtr );
    ASSERT( params );
    TInt retVal = KErrNone;

    CTrapCleanup* cleanup = CTrapCleanup::New();
    if( !cleanup )
        {
        delete params;
        retVal = KErrNoMemory;
        }

    RThread::Rendezvous( retVal );
    if( retVal == KErrNone )
        {
        User::After( params->iDelay );
        TRAP( retVal, DoSendKeyEventL( params->iKeyEvent ) );
        }

    delete cleanup;
    delete params;
    return retVal;
    }


// ======== MEMBER FUNCTIONS ========

// -----------------------------------------------------------------------------
// CSifUiTest::NewL()
// -----------------------------------------------------------------------------
//
CSifUiTest* CSifUiTest::NewL()
    {
    CSifUiTest* self = new (ELeave) CSifUiTest;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CSifUiTest::~CSifUiTest()
// -----------------------------------------------------------------------------
//
CSifUiTest::~CSifUiTest()
    {
    delete iSifUi;
    iLog = NULL;
    delete iStdLog;
    delete iTCLog;
    iFs.Close();

    if( iScheduler )
        {
        CActiveScheduler::Install( NULL );
        delete iScheduler;
        }
    }

// -----------------------------------------------------------------------------
// CSifUiTest::InitL()
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::InitL( TFileName& /*aIniFile*/, TBool /*aFirstTime*/ )
    {
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CSifUiTest::GetTestCasesL()
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::GetTestCasesL( const TFileName& /*aConfig*/,
        RPointerArray<TTestCaseInfo>& aTestCases )
    {
    for( TInt index = 0; Case( index ).iMethod != NULL; ++index )
        {
        TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo();
        CleanupStack::PushL( newCase );
        newCase->iCaseNumber = index;
        newCase->iTitle.Copy( Case(index).iCaseName );
        aTestCases.AppendL( newCase );
        CleanupStack::Pop( newCase );
        }

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CSifUiTest::RunTestCaseL
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::RunTestCaseL( const TInt aCaseNumber,
        const TFileName& /*aConfig*/, TTestResult& aResult )
    {
    if( !iVersionLogged )
        {
        SendTestModuleVersion();
        iVersionLogged = ETrue;
        }

    TInt returnValue = KErrNone;

    TCaseInfo caseInfo = Case ( aCaseNumber );
    if( caseInfo.iMethod != NULL )
        {
        _LIT( KLogStartTC, "Starting testcase [%S]" );
        iLog->Log( KLogStartTC, &caseInfo.iCaseName );

        // Switch to use test case (TC) logger if necessary
        if( iAddTestCaseTitleToLogName )
            {
            if( iTCLog )
                {
                delete iTCLog;
                iTCLog = NULL;
                }

            TName title;
            TestModuleIf().GetTestCaseTitleL( title );
            TFileName logFileName;
            logFileName.Format( KSifUiTestLogFileWithTitle, &title );
            iTCLog = CStifLogger::NewL( KSifUiTestLogPath, logFileName );
            iLog = iTCLog;
            }

        // Run test case
        iMethod = caseInfo.iMethod;
        TRAPD( err, returnValue  = ( this->*iMethod )( aResult ) );

        // Restore standard log and close test case logger
        if( iAddTestCaseTitleToLogName )
            {
            iLog = iStdLog;
            delete iTCLog;
            iTCLog = NULL;
            }

        // Leave if the case execution failed
        User::LeaveIfError( err );
        }
    else
        {
        returnValue = KErrNotFound;
        }

    // Return case execution status (not the result of the case execution)
    return returnValue;
    }

//-----------------------------------------------------------------------------
// CSifUiTest::SendTestModuleVersion
//-----------------------------------------------------------------------------
//
void CSifUiTest::SendTestModuleVersion()
    {
    TVersion moduleVersion;
    moduleVersion.iMajor = TEST_MODULE_VERSION_MAJOR;
    moduleVersion.iMinor = TEST_MODULE_VERSION_MINOR;
    moduleVersion.iBuild = TEST_MODULE_VERSION_BUILD;

    TFileName moduleName;
    moduleName = _L("SifUiTest.dll");

    TBool newVersionOfMethod = ETrue;
    TestModuleIf().SendTestModuleVersion( moduleVersion, moduleName, newVersionOfMethod );
    }

// -----------------------------------------------------------------------------
// CSifUiTest::CSifUiTest()
// -----------------------------------------------------------------------------
//
CSifUiTest::CSifUiTest()
    {
    }

// -----------------------------------------------------------------------------
// CSifUiTest::ConstructL()
// -----------------------------------------------------------------------------
//
void CSifUiTest::ConstructL()
    {
    User::LeaveIfError( iFs.Connect() );

    // Read logger settings
    RSettingServer settingServer;
    TInt ret = settingServer.Connect();
    User::LeaveIfError( ret );
    TLoggerSettings loggerSettings;
    ret = settingServer.GetLoggerSettings( loggerSettings );
    User::LeaveIfError( ret );
    settingServer.Close();

    iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;
    iStdLog = CStifLogger::NewL( KSifUiTestLogPath, KSifUiTestLogFile );
    iLog = iStdLog;

    _LIT( KLogStart, "SifUiTest starts" );
    iLog->Log( KLogStart );

    iVersionLogged = EFalse;

    if( !CActiveScheduler::Current() )
        {
        iScheduler = new( ELeave ) CActiveScheduler;
        CActiveScheduler::Install( iScheduler );
        }
    }

// -----------------------------------------------------------------------------
// CSifUiTest::ErrorCodeString()
// -----------------------------------------------------------------------------
//
TPtrC CSifUiTest::ErrorCodeString( TInt aErrorCode ) const
    {
    switch( aErrorCode )
        {
        case KErrNone:
            return _L("KErrNone");
        case KErrNotFound:
            return _L("KErrNotFound");
        case KErrGeneral:
            return _L("KErrGeneral");
        case KErrCancel:
            return _L("KErrCancel");
        case KErrNoMemory:
            return _L("KErrNoMemory");
        case KErrNotSupported:
            return _L("KErrNotSupported");
        case KErrArgument:
            return _L("KErrArgument");
        case KErrTotalLossOfPrecision:
            return _L("KErrTotalLossOfPrecision");
        case KErrBadHandle:
            return _L("KErrBadHandle");
        case KErrOverflow:
            return _L("KErrOverflow");
        case KErrUnderflow:
            return _L("KErrUnderflow");
        case KErrAlreadyExists:
            return _L("KErrAlreadyExists");
        case KErrPathNotFound:
            return _L("KErrPathNotFound");
        case KErrDied:
            return _L("KErrDied");
        case KErrInUse:
            return _L("KErrInUse");
        case KErrServerTerminated:
            return _L("KErrServerTerminated");
        case KErrServerBusy:
            return _L("KErrServerBusy");
        case KErrCompletion:
            return _L("KErrCompletion");
        case KErrNotReady:
            return _L("KErrNotReady");
        case KErrUnknown:
            return _L("KErrUnknown");
        case KErrCorrupt:
            return _L("KErrCorrupt");
        case KErrAccessDenied:
            return _L("KErrAccessDenied");
        case KErrLocked:
            return _L("KErrLocked");
        case KErrWrite:
            return _L("KErrWrite");
        case KErrDisMounted:
            return _L("KErrDisMounted");
        case KErrEof:
            return _L("KErrEof");
        case KErrDiskFull:
            return _L("KErrDiskFull");
        case KErrBadDriver:
            return _L("KErrBadDriver");
        case KErrBadName:
            return _L("KErrBadName");
        case KErrCommsLineFail:
            return _L("KErrCommsLineFail");
        case KErrCommsFrame:
            return _L("KErrCommsFrame");
        case KErrCommsOverrun:
            return _L("KErrCommsOverrun");
        case KErrCommsParity:
            return _L("KErrCommsParity");
        case KErrTimedOut:
            return _L("KErrTimedOut");
        case KErrCouldNotConnect:
            return _L("KErrCouldNotConnect");
        case KErrCouldNotDisconnect:
            return _L("KErrCouldNotDisconnect");
        case KErrDisconnected:
            return _L("KErrDisconnected");
        case KErrBadLibraryEntryPoint:
            return _L("KErrBadLibraryEntryPoint");
        case KErrBadDescriptor:
            return _L("KErrBadDescriptor");
        case KErrAbort:
            return _L("KErrAbort");
        case KErrTooBig:
            return _L("KErrTooBig");
        case KErrDivideByZero:
            return _L("KErrDivideByZero");
        case KErrBadPower:
            return _L("KErrBadPower");
        case KErrDirFull:
            return _L("KErrDirFull");
        case KErrHardwareNotAvailable:
            return _L("KErrHardwareNotAvailable");
        case KErrSessionClosed:
            return _L("KErrSessionClosed");
        case KErrPermissionDenied:
            return _L("KErrPermissionDenied");
        case KErrExtensionNotSupported:
            return _L("KErrExtensionNotSupported");
        case KErrCommsBreak:
            return _L("KErrCommsBreak");
        case KErrNoSecureTime:
            return _L("KErrNoSecureTime");
        }
    return _L("UNKNOWN ERROR CODE");
    }

// -----------------------------------------------------------------------------
// CSifUiTest::SetResult()
// -----------------------------------------------------------------------------
//
void CSifUiTest::SetResult( TTestResult& aResult, const TInt aReturnCode ) const
    {
    aResult.SetResult( aReturnCode, ErrorCodeString( aReturnCode ) );
    }

// -----------------------------------------------------------------------------
// CSifUiTest::AsyncWaitAndSendKeyEventL()
// -----------------------------------------------------------------------------
//
void CSifUiTest::AsyncWaitAndSendKeyEventL( TTimeIntervalMicroSeconds32 aDelay,
        const TKeyEvent& aKeyEvent ) const
    {
    if( aDelay.Int() )
        {
        TDelayAndKeyEvent* paramPack = new( ELeave ) TDelayAndKeyEvent;
        paramPack->iDelay = aDelay;
        paramPack->iKeyEvent = aKeyEvent;

        RThread waitingAndSendingThread;
        TInt err = waitingAndSendingThread.Create( KWaitAndSendThread, WaitAndSendThreadFunc,
                KWaitAndSendThreadStack, NULL, reinterpret_cast< TAny* >( paramPack ) );
        if( err == KErrNone )
            {
            TRequestStatus status;
            waitingAndSendingThread.Rendezvous( status );
            waitingAndSendingThread.Resume();
            User::WaitForRequest( status );
            waitingAndSendingThread.Close();
            User::LeaveIfError( status.Int() );
            }
        else
            {
            delete paramPack;
            User::Leave( err );
            }
        }
    else
        {
        DoSendKeyEventL( aKeyEvent );
        }
    }


// ==== OTHER EXPORTED FUNCTIONS ====

// -----------------------------------------------------------------------------
// LibEntryL is a polymorphic Dll entry point
// -----------------------------------------------------------------------------
//
EXPORT_C CTestModuleBase* LibEntryL()
    {
    return CSifUiTest::NewL();
    }

// -----------------------------------------------------------------------------
// SetRequirements handles test module parameters
// -----------------------------------------------------------------------------
//
EXPORT_C TInt SetRequirements( CTestModuleParam*& aTestModuleParam,
        TUint32& aParameterValid )
    {
    aParameterValid = KStifTestModuleParameterChanged;

    CTestModuleParamVer01* param = CTestModuleParamVer01::NewL();
    param->iTestThreadStackSize = 16384;    // 16K stack
    param->iTestThreadMinHeap = 4096;       // 4K heap min
    param->iTestThreadMaxHeap = 1048576;    // 1M heap max
    aTestModuleParam = param;

    return KErrNone;
    }