/*
* Copyright (c) 2005-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:  Keylock states implementation for Active Idle WS Plug-in
*
*/


#include "keylockstates.h"
#include "keylockcontrol.h"
#include "keypadsettings.h"
#include "panic.h"
#include "activeidle2domainpskeys.h"

#include <e32event.h>
#include <e32property.h>

#include "debug.h"


namespace AiWsPlugin {

const TInt KTenMilliSecondsInu = 10 * 1000;

/**
 * Helper macro for declaring internal state classes for CKeyLockHandler.
 */
#define AI_DECLARE_KEYLOCK_STATE(StateCls) \
    class StateCls { \
    public: \
        static const TKeylockState KState; \
        static const TKeylockState& DefaultNextState(); \
        static void FocusChanged( MKeyLockHandlerControl& aControl, TBool aState ); \
        static TBool OfferRawEvent( MKeyLockHandlerControl& aControl, const TRawEvent& aRawEvent ); \
        static void TimerElapsed( MKeyLockHandlerControl& aControl ); \
        }

/**
 * Inactive state class for CKeyLockHandler.
 */
AI_DECLARE_KEYLOCK_STATE(TKeylockStateInactive);

/**
 * Active state class for CKeyLockHandler.
 */
AI_DECLARE_KEYLOCK_STATE(TKeylockStateWaitForFirstKeyDown);

/**
 * Keylock sequence in progress state class for CKeyLockHandler.
 */
AI_DECLARE_KEYLOCK_STATE(TKeylockStateWaitForSecondKeyDown);

/**
 * Keylock sequence finalizer state class for CKeyLockHandler.
 */
AI_DECLARE_KEYLOCK_STATE(TKeylockStateWaitForSecondKeyUp);

/**
 * Helper macro for defining key lock state function tables.
 */
#define AI_DEFINE_KEYLOCK_STATE_FT(StateCls) \
    const TKeylockState StateCls::KState = {     \
        &StateCls::DefaultNextState,             \
        &StateCls::FocusChanged,                 \
        &StateCls::OfferRawEvent,                \
        &StateCls::TimerElapsed }

/// Defines function table for key lock inactive state
AI_DEFINE_KEYLOCK_STATE_FT(TKeylockStateInactive);

/// Defines function table for key lock active state
AI_DEFINE_KEYLOCK_STATE_FT(TKeylockStateWaitForFirstKeyDown);

/// Defines function table for key lock in progress state
AI_DEFINE_KEYLOCK_STATE_FT(TKeylockStateWaitForSecondKeyDown);

/// Defines function table for key lock finalizing state
AI_DEFINE_KEYLOCK_STATE_FT(TKeylockStateWaitForSecondKeyUp);

// TKeyLockState
const TKeylockState& TKeylockState::StartupState()
    {
    return TKeylockStateInactive::KState;
    }

// TKeylockStateInactive
const TKeylockState& TKeylockStateInactive::DefaultNextState()
    {
    return TKeylockStateWaitForFirstKeyDown::KState;
    }
    
void TKeylockStateInactive::FocusChanged
        ( MKeyLockHandlerControl& aControl, TBool aState )
    {
    __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateInactive::FocusChanged(%d)"), aState );
    if ( aState )
        {
        // Gained focus, switch to active state
        aControl.ActivateNextState();    
        }
    }
    
TBool TKeylockStateInactive::OfferRawEvent
        ( MKeyLockHandlerControl& /*aControl*/, const TRawEvent& /*aRawEvent*/ )
    {
    return EFalse;
    }
    
void TKeylockStateInactive::TimerElapsed
        ( MKeyLockHandlerControl& aControl )
    {
    // Illegal event in this state
    aControl.KeypadLockTimeout();
#ifndef NDEBUG
    //Panic( EPanicInvalidKeylockEvent );
#endif    
    }

// TKeylockStateWaitForFirstLockKeyDown
const TKeylockState& TKeylockStateWaitForFirstKeyDown::DefaultNextState()
    {
    return TKeylockStateWaitForSecondKeyDown::KState;
    }

void TKeylockStateWaitForFirstKeyDown::FocusChanged
        ( MKeyLockHandlerControl& aControl, TBool aState )
    {
    __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForFirstKeyDown::FocusChanged(%d)"), aState );
    if ( !aState )
        {
        if( !aControl.TimeoutTimerActive() )
            {
            // Lost focus, switch to inactive state
            aControl.SetNextState( TKeylockStateInactive::KState );
            aControl.ActivateNextState();
            }
        }
    }
    
TBool TKeylockStateWaitForFirstKeyDown::OfferRawEvent
        ( MKeyLockHandlerControl& aControl, const TRawEvent& aRawEvent )
    {
    switch ( aRawEvent.Type() )
        {
        case TRawEvent::EKeyDown:
            {
            const TInt scanCode = aRawEvent.ScanCode();
            __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForFirstKeyDown::OfferRawEvent(EKeyDown,ScanCode=%d)" ), scanCode );
            if ( aControl.IsFirstLockKey( scanCode ) && aControl.HasFocus() )
                {
                // First lock key was pressed down
                aControl.SetLastLockKeyScanCode( scanCode );
                // (Re)activate the keylock timeout timer
                aControl.StartTimeoutTimer(KTenMilliSecondsInu);
                }
            }
        }

    // Never consume the event to enable its processing if keylock
    // is not activated within the timeout
    return EFalse;
    }
    
void TKeylockStateWaitForFirstKeyDown::TimerElapsed
        ( MKeyLockHandlerControl& aControl )
    {
                TInt value = EPSAiNotDisplayingMenuOrDialog;          
                TInt err = RProperty::Get(
                   KPSUidAiInformation, 
                   KActiveIdlePopupState, 
                   value );
                
                if( value == EPSAiNotDisplayingMenuOrDialog && err == KErrNone )
                    {
                    // (Re)activate the keylock timeout timer
                    aControl.StartTimeoutTimer();
                    // Switch to wait for second lock key down (see constructor of this state)
                    aControl.ActivateNextState();
                    }
                else
                    {
                    if( aControl.HasFocus() )
                        {
                        aControl.StopTimeoutTimer();
                        }
                    else
                        {
                        // Lost focus, switch to inactive state
                        aControl.SetNextState( TKeylockStateInactive::KState );
                        aControl.ActivateNextState();
                        }
                    }
    // Illegal event in this state
#ifndef NDEBUG
    //Panic( EPanicInvalidKeylockEvent );
#endif    
    }

// TKeylockStateWaitForSecondKeyDown
const TKeylockState&  TKeylockStateWaitForSecondKeyDown::DefaultNextState()
    {
    // Assume the keylock sequence is cancelled
    return TKeylockStateWaitForFirstKeyDown::KState;
    }

void TKeylockStateWaitForSecondKeyDown::FocusChanged
        ( MKeyLockHandlerControl& aControl, TBool aState )
    {
    __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForSecondKeyDown::FocusChanged(%d)"), aState );
    if ( aState )
        {
        // Gained focus: return to active state if keylock sequence is cancelled
        aControl.SetNextState( TKeylockStateWaitForFirstKeyDown::KState );
        }
    else
        {
        // Lost focus: return to inactive state if keylock sequence is cancelled
        aControl.SetNextState( TKeylockStateInactive::KState );
        }
    }
    
TBool TKeylockStateWaitForSecondKeyDown::OfferRawEvent
        ( MKeyLockHandlerControl& aControl, const TRawEvent& aRawEvent )
    {
    TBool consumedEvent = EFalse;
    
    switch ( aRawEvent.Type() )
        {
        case TRawEvent::EKeyDown:
            {
            const TInt scanCode = aRawEvent.ScanCode();
            __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForSecondKeyDown::OfferRawEvent(EKeyDown,ScanCode=%d)" ), scanCode );
            if ( aControl.IsSecondLockKey( scanCode ) )
                {
                // Second lock key was pressed down. Cancel keylock timer
                // and switch to wait for key up event.
                aControl.StopTimeoutTimer();
                aControl.SetLastLockKeyScanCode( scanCode );
                aControl.SetNextState( TKeylockStateWaitForSecondKeyUp::KState );
                aControl.ActivateNextState();
                consumedEvent = ETrue;
                }
            else
                {
                // Some other key than second lock key was pressed while
                // keylock timer was running. Cancel the keylock sequence and
                // switch to previous state. (Depending on focus status,
                // see TKeylockStateWaitForFirstKeyDown::FocusChanged.)
                aControl.CancelKeypadLock();
                aControl.ActivateNextState();
                consumedEvent = EFalse;
                }
            break;
            }
        }
        
    return consumedEvent;
    }
    
void TKeylockStateWaitForSecondKeyDown::TimerElapsed
        ( MKeyLockHandlerControl& aControl )
    {
    __PRINTS( "AiWsPlugin: TKeylockStateWaitForSecondKeyDown::TimerElapsed()" ); 
    aControl.KeypadLockTimeout();
    aControl.ActivateNextState();
    }

// TKeylockStateWaitForSecondKeyUp
const TKeylockState& TKeylockStateWaitForSecondKeyUp::DefaultNextState()
    {
    // Idle must currently have focus so return to active state from this state
    return TKeylockStateWaitForFirstKeyDown::KState;
    }

void TKeylockStateWaitForSecondKeyUp::FocusChanged
        ( MKeyLockHandlerControl& aControl, TBool aState )
    {
    __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForSecondKeyUp::FocusChanged(%d)"), aState );
    if ( aState )
        {
        // Gained focus: return to active state if keylock sequence is cancelled
        aControl.SetNextState(
            TKeylockStateWaitForFirstKeyDown::KState );
        }
    else
        {
        // Lost focus: return to inactive state if keylock sequence is cancelled
        aControl.SetNextState( TKeylockStateInactive::KState );
        }
    }
    
TBool TKeylockStateWaitForSecondKeyUp::OfferRawEvent
        ( MKeyLockHandlerControl& aControl, const TRawEvent& aRawEvent )
    {
    TBool consumedEvent = EFalse;
    
    switch ( aRawEvent.Type() )
        {
        case TRawEvent::EKeyUp:
            {
            const TInt scanCode = aRawEvent.ScanCode();
            __PRINT( __DBG_FORMAT("AiWsPlugin: TKeylockStateWaitForSecondKeyUp::OfferRawEvent(EKeyUp,ScanCode=%d)" ), scanCode );
            if ( scanCode == aControl.LastLockKeyScanCode() )
                {
                // Second lock key was released. Activate the keypad lock and
                // switch back to initial state. (Depending on focus status,
                // see TKeylockStateWaitForSecondKeyUp::FocusChanged.)
                aControl.ActivateKeypadLock();
                aControl.ActivateNextState();
                }
            // Consume all key events until the keylock sequence is finalized
            consumedEvent = ETrue;
            break;
            }

        case TRawEvent::EKeyDown:
            {
            // Consume all key events until the keylock sequence is finalized
            consumedEvent = ETrue;
            break;
            }
        }
        
    return consumedEvent;
    }
    
void TKeylockStateWaitForSecondKeyUp::TimerElapsed
        ( MKeyLockHandlerControl& /*aControl*/ )
    {
    // Illegal event in this state
#ifndef NDEBUG
    //Panic( EPanicInvalidKeylockEvent );
#endif    
    }

} // namespace AiWsPlugin