/*
* Copyright (c) 2006-2007 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:  Emulate key and pointer event.
*
*/


#include <eikon.hrh>

#include "AutotestCommands.h" // test commands are defined in here
#include "bctestkeyfeeder.h"
#include "bctestlogger.h"
#include "bctestsuite.h"

const TInt KInitDelay = 1000000; // 1 second
const TInt KInterval = 100000; // 1/10 second
const TInt KTickCount = 10; // default one second between key feeds
const TText KKey1 = '1';
const TText KKey2 = '2';
const TText KKey3 = '3';
const TText KKey4 = '4';
const TText KKey5 = '5';
const TText KKey6 = '6';
const TText KKey7 = '7';
const TText KKey8 = '8';
const TText KKey9 = '9';
const TText KKey0 = '0';
const TText KKeyAsterisk = '*';
const TText KKeyHash = '#';

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

// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBCTestKeyFeeder::CBCTestKeyFeeder()
    {
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBCTestKeyFeeder::~CBCTestKeyFeeder()
    {
    if ( iPeriodic )
        {
        iPeriodic->Cancel();
        delete iPeriodic;
        }
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::StartAutoTestL
// Initialize member variables and start timer.
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::StartAutoTestL( SAutoTest* aAutoTest )
    {    
    if ( aAutoTest )
        {
        iAutoTest = aAutoTest;        
        iScriptCommands = iAutoTest->scripts[0];        
        }    
    if ( !iAutoTest || !iScriptCommands )
        {
        return;
        }   
    
    iSuite->HandleTestEventL( ETestCaseStart, iScriptIndex );
    
    if ( iPeriodic )
        {
        iPeriodic->Cancel();
        delete iPeriodic;
        iPeriodic = NULL;
        }
    iPeriodic=CPeriodic::NewL( CActive::EPriorityHigh );
    // Start periodic function after 1 seconds and after that call
    // it every 1/10th of second    
    iPeriodic->Start( KInitDelay, KInterval, TCallBack( 
        PeriodicKeyFeederL, this ) );

    // member variables don't need to be cleared before use,
    // but do it anyway - just in case
    iIndex = 0;
    iScriptIndex = 0;
    iCommand = 0;
    iRepeatCommand = 0;
    iRepeat = 0;
    iWaitCount = 0;
    
    iTickCount = KTickCount;
    iTickCounter = iTickCount;

    iKeyUp = EFalse;
    iKeyDown = EFalse;
    
    // ensure sane values for conditional stuff
    iIfCount = 0;    
    
    if ( !iEikEnv )
        {
        iEikEnv = CEikonEnv::Static();
        }    
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::PeriodicKeyFeeder
// This method is called every 0.1 seconds, calls HandleAutoCommand
// ---------------------------------------------------------------------------
//
TInt CBCTestKeyFeeder::PeriodicKeyFeederL( TAny* aThis )
    {
    CBCTestKeyFeeder* feeder = 
        static_cast<CBCTestKeyFeeder*>( aThis );

    feeder->HandleAutoCommandL();
    return 0;
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::HandleAutoCommand
// Does the actual key feeding
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::HandleAutoCommandL()
    {    
    if ( iTimerPaused ) // timer paused, do nothing
        {
        return;
        }
    if ( iTickCounter > 0 )
        {
        iTickCounter--;
        return; // tick count not yet full, do nothing
        }
    iTickCounter=iTickCount; // reset tick counter and continue

    //commands in one script done
    if ( iIndex >= iAutoTest->countArray[iScriptIndex] )
        {
        iSuite->HandleTestEventL( ETestCaseEnd, iScriptIndex );
        iScriptIndex++;      
        TBool continueRun = ETrue;        
        if ( iScriptIndex >= iAutoTest->scriptCount ) // all scripts done
            {
            continueRun = EFalse;            
            }
        else
            {            
            iScriptCommands = iAutoTest->scripts[iScriptIndex];            
            iIndex = 0; 
            if ( !iScriptCommands )
                {                
                iSuite->HandleTestEventL( ETestCaseNoScript, iScriptIndex );
                iIndex = iAutoTest->countArray[iScriptIndex];              
                }
            else
                {
                iSuite->HandleTestEventL( ETestCaseStart, iScriptIndex );
                }
            }        
        
        if ( iIfCount != 0 )
            {
            iSuite->HandleTestEventL( 
                ETestCaseUnbalancedIf, iScriptIndex - 1 );            
            iIfCount = 0;
            }
        
        if ( !continueRun )
            {
            iPeriodic->Cancel(); // stop periodic timer
            }
                
        return;
        }

    if ( iWaitCount > 0 ) // still waiting (WAIT command)
        {
        iWaitCount--;
        return;    // waiting - do nothing
        }

    if ( iRepeat == 0 ) // not repeating, parse next command
        {
        iCommand = iScriptCommands[iIndex];
        iIndex++;
        }
    else // still doing REPEAT
        {
        iCommand = iRepeatCommand; // command being repeated
        iRepeat--;
        }
    
    switch ( iCommand )
        {
        case LeftCBA:
            KeyPress( EKeyDevice0, EStdKeyDevice0 );
            break;
        case RightCBA:
            KeyPress( EKeyDevice1, EStdKeyDevice1 );
            break;
        case KeyOK:
            KeyPress( EKeyDevice3, EStdKeyDevice3 );
            break;
        case Up:
            KeyPress( EKeyUpArrow, EStdKeyUpArrow );
            break;
        case Down:
            KeyPress( EKeyDownArrow, EStdKeyDownArrow );
            break;
        case Left:
            KeyPress( EKeyLeftArrow, EStdKeyLeftArrow );
            break;
        case Right:
            KeyPress( EKeyRightArrow, EStdKeyRightArrow );
            break;
        case Key1:
            KeyPress( KKey1, KKey1 );
            break;
        case Key2:
            KeyPress( KKey2, KKey2 );
            break;
        case Key3:
            KeyPress( KKey3, KKey3 );
            break;
        case Key4:
            KeyPress( KKey4, KKey4 );
            break;
        case Key5:
            KeyPress( KKey5, KKey5 );
            break;
        case Key6:
            KeyPress( KKey6, KKey6 );
            break;
        case Key7:
            KeyPress( KKey7, KKey7 );
            break;
        case Key8:
            KeyPress( KKey8, KKey8 );
            break;
        case Key9:
            KeyPress( KKey9, KKey9 );
            break;
        case Key0:
            KeyPress( KKey0, KKey0 );
            break;
        case KeyAsterisk:
            KeyPress( KKeyAsterisk, EStdKeyNkpAsterisk );
            break;
        case KeyHash:
            KeyPress( KKeyHash, EStdKeyHash );
            break;
        case KeyApplication:
            KeyPress( EKeyApplication, EStdKeyApplication0 );
            break;
        case KeyPhoneSend:
            KeyPress( EKeyPhoneSend, EStdKeyYes );
            break;
        case KeyPhoneEnd:
            KeyPress( EKeyPhoneEnd, EStdKeyNo );
            break;
        case KeyPower:
            KeyPress( EKeyPowerOff, EStdKeyDevice2 );
            break;
        case KeyVoice:
            KeyPress( EKeySide, EStdKeyDevice6 );
            break;
        case KeyBackspace:
            KeyPress( EKeyBackspace, EStdKeyBackspace );
            break;
        case KeyABC:  // may not work as ABC key, should work as shift, tough
            KeyPress( EStdKeyRightShift, EStdKeyRightShift );
            break;
        case GripOpen:
            KeyPress( EKeyGripOpen, EStdKeyDevice4 );
            break;
        case GripClose:
            KeyPress( EKeyGripClose, EStdKeyDevice5 );
            break;
        case REPEAT: // one round missed because no commands executed
            iRepeatCommand = iScriptCommands[iIndex++];
            iRepeat = iScriptCommands[iIndex++];
            break;
        case WAITCOMMAND:
            iWaitCount = iScriptCommands[iIndex++];
            break;        
        case SETTICKCOUNT:
            iTickCount = iScriptCommands[iIndex++];
            iTickCounter = iTickCount;
            break;
        case JUSTKEYDOWN:
            iKeyDown = ETrue;
            break;
        case JUSTKEYUP:
            iKeyUp = ETrue;            
            break;        
        case PointerDown:
        	{
        	TInt pointerX = iScriptCommands[iIndex++];
        	TInt pointerY = iScriptCommands[iIndex++];
        	TRawEvent event;
        	event.Set( TRawEvent::EButton1Down, pointerX, pointerY );
        	PointerEvent( event );
        	}
        	break;
        case PointerUp:    
        	{
        	TInt pointerX = iScriptCommands[iIndex++];
        	TInt pointerY = iScriptCommands[iIndex++];
        	TRawEvent event;
        	event.Set( TRawEvent::EButton1Up, pointerX, pointerY );
        	PointerEvent( event );
        	}
            break;
        case PointerMove:
	    	{
        	TInt pointerX = iScriptCommands[iIndex++];
        	TInt pointerY = iScriptCommands[iIndex++];
        	TRawEvent event;
        	event.Set( TRawEvent::EPointerMove, pointerX, pointerY );
        	PointerEvent( event );
	    	break;	
	    	}        
        default:
            break;
        }
    }

/******************* autotest key feeder implementations ********************/

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::KeyDown
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::KeyDown( TInt aScanCode )
    {
    if ( aScanCode == EStdKeyRightShift )
        {
        iOldModifiers = iEikEnv->WsSession().GetModifierState();
        iModifiers = EModifierShift | iOldModifiers;
        }
    
    TRawEvent event;
    event.Set( TRawEvent::EKeyDown, aScanCode );
    iEikEnv->WsSession().SimulateRawEvent( event );
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::KeyUp
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::KeyUp( TInt aScanCode )
    {
    if ( aScanCode == EStdKeyRightShift )
        {
        iModifiers = iOldModifiers;
        }

    TRawEvent event;
    event.Set( TRawEvent::EKeyUp, aScanCode );
    iEikEnv->WsSession().SimulateRawEvent( event );
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::KeyPress
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::KeyPress( TInt aCode, TInt aScanCode )
    {
    User::ResetInactivityTime();// Reset user inactivity timers

    if ( iKeyDown ) // Long key press -> do just key down
        {
        KeyDown( aScanCode );
        iKeyDown = EFalse;
        return; // ends key press
        }

    if ( iKeyUp ) // Ends long key press -> do just key up
        {
        KeyUp( aScanCode );
        iKeyUp = EFalse;
        return; // ends key press
        }

    // there seems to be no keycode for abc-key, simulate by pressing
    // key down and up
    if ( aCode == EStdKeyRightShift )
        {
        KeyDown( aCode );
        KeyUp( aCode );
        return; 
        }

    // Do normal key press
    TKeyEvent event = { aCode, aScanCode, iModifiers, 0 };
    iEikEnv->WsSession().SimulateKeyEvent( event );
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::PauseTimer
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::PauseTimer()
    {
    iTimerPaused = ETrue;
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::ResumeTimer
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::ResumeTimer()
    {
    iTimerPaused = EFalse;
    }

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::PointerEvent
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::PointerEvent( TRawEvent& aEvent )
	{	
    iEikEnv->WsSession().SimulateRawEvent( aEvent );
	}

// ---------------------------------------------------------------------------
// CBCTestKeyFeeder::SetSuite
// ---------------------------------------------------------------------------
//
void CBCTestKeyFeeder::SetSuite( CBCTestSuite* aSuite )
    {
    iSuite = aSuite;
    }