/*

* Copyright (c) 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:  Key event forwarder.

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <eikappui.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <PtiDefs.h>

#include <AknUtils.h>

#include "mphonestatemachine.h"

#include "mphonekeyeventhandler.h"

#include "cphonekeys.h"

#include "cphonekeyeventforwarder.h"

#include "cphonepubsubproxy.h"

#include "cphonetimer.h"

#include "phonelogger.h"

#include "phoneui.pan"

#include "mphoneviewcommandhandle.h"

#include "cphoneqwertyhandler.h"

#include "tphonecmdparampointer.h"

#include "tphonecmdparamboolean.h"

#include "mphoneqwertymodeobserver.h"

#include "cdialer.h"

// CONSTANTS

//Avkon P&S keys

const TUid KCRUidAvkon = { 0x101F876E };

const TUint32 KAknKeyBoardLayout = 0x0000000B;

// Characters resulting from multitapping *-key.

_LIT( KAsteriskMultitapCharacters, "*+pw" );

// Multitap delay parameter in micro seconds.

const TInt KMultitapDelay = 1000000;

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

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

// CPhoneKeyEventForwarder::NewL

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

//

CPhoneKeyEventForwarder* CPhoneKeyEventForwarder::NewL(

        const TRect& aRect,

        MPhoneStateMachine* aStateMachine,

        MPhoneViewCommandHandle* aViewCommandHandle )

    {

    CPhoneKeyEventForwarder* self =

        new (ELeave) CPhoneKeyEventForwarder( aStateMachine, aViewCommandHandle );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneKeyEventForwarder::~CPhoneKeyEventForwarder

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

//

CPhoneKeyEventForwarder::~CPhoneKeyEventForwarder()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneKeyEventForwarder::~CPhoneKeyEventForwarder");

    if ( AknLayoutUtils::PenEnabled() ) 

        {

        iPeninputServer.RemovePenUiActivationHandler( this );

        }

    iPeninputServer.Close();

    if ( iEikonEnv )

        {

        iEikonEnv->EikAppUi()->RemoveFromStack( this );

        }

    delete iLongPressKeyEventTimer;

    delete iQwertyHandler;

    }

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

// CPhoneKeyEventForwarder::CountComponentControls

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

//

TInt CPhoneKeyEventForwarder::CountComponentControls() const

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneKeyEventForwarder::CountComponentControls");

    return 0;

    }

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

// CPhoneKeyEventForwarder::ComponentControl

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

//

CCoeControl* CPhoneKeyEventForwarder::ComponentControl(

        TInt /*aIndex*/ ) const

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneKeyEventForwarder::ComponentControl");

    return NULL;

    }

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

// CPhoneKeyEventForwarder::SizeChanged

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

//

void CPhoneKeyEventForwarder::SizeChanged()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneKeyEventForwarder::SizeChanged");

    }

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

// CPhoneKeyEventForwarder::Draw

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

//

void CPhoneKeyEventForwarder::Draw(

        const TRect& /*aRect*/ ) const

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneKeyEventForwarder::Draw");

    }

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

// CPhoneKeyEventForwarder::OfferKeyEventL

// Checks is hte keyevent such that the number entry can be opened

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

//

TKeyResponse CPhoneKeyEventForwarder::OfferKeyEventL(

        const TKeyEvent& aKeyEvent,

        TEventCode aType )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::OfferKeyEventL");

    TKeyResponse ret( EKeyWasNotConsumed );

    // After event key, expect to have key up event.

    iExpectKeyUpEvent = ( aType == EEventKey );

    ret = OfferKeyEventBeforeControlStackL( aKeyEvent, aType );

    if ( !aKeyEvent.iRepeats && aKeyEvent.iCode != EKeyEscape )

        {

        // Convert event. Use already converted iKeyPressedDown.

        TKeyEvent keyEvent = aKeyEvent;

        if ( keyEvent.iScanCode == EStdKeyApplication0 )

            {

            keyEvent.iCode = EKeyApplication0;

            }

        else

            {

            keyEvent.iCode = iKeyPressedDown;

            }

        // Do not handle dtmf tone if the type is EEventKey but we are not

        // expecting key up event. This happens if the key up event has been

        // handled by some CActiveSchedulerWait object somewhere in the execution 

        // of function OfferKeyEventBeforeControlStackL.

        if ( iExpectKeyUpEvent || aType != EEventKey )

            {

            // Start and stop dtmf

            iStateMachine->State()->HandleDtmfKeyToneL( keyEvent, aType );

            }

        // Open number entry view if any allowed character key

        // is pressed on homescreen or in-call ui

        if ( aType != EEventKeyUp && IsKeyAllowedL( keyEvent ) )

            {

            // Do not open number entry with up key

            iStateMachine->State()->HandleCreateNumberEntryL( keyEvent, aType );

            }

        }

    return ret;

    }

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

// CPhoneKeyEventForwarder::CPhoneKeyEventForwarder

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

//

CPhoneKeyEventForwarder::CPhoneKeyEventForwarder(

    MPhoneStateMachine* aStateMachine,

    MPhoneViewCommandHandle* aViewCommandHandle  )

    : iStateMachine( aStateMachine ),

    iViewCommandHandle( aViewCommandHandle )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::CPhoneKeyEventForwarder");

    }

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

// CPhoneKeyEventForwarder::ConstructL

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

//

void CPhoneKeyEventForwarder::ConstructL( const TRect& aRect )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::ConstructL");

    if ( FeatureManager::FeatureSupported( KFeatureIdKeypadNoSlider ) )

        {

        RWindowGroup& groupWin = iCoeEnv->RootWin();

        }

    // Create invisible control.

    CreateWindowL();

    MakeVisible( EFalse );

    SetRect( aRect );

    if ( iEikonEnv )

        {

        iEikonEnv->EikAppUi()->AddToStackL(

            this,

            ECoeStackPriorityEnvironmentFilter,

            ECoeStackFlagRefusesFocus );

        }

    // Create the long press key event timer

    iLongPressKeyEventTimer = CPhoneTimer::NewL();

    // Create qwerty mode handler

    iQwertyHandler = CPhoneQwertyHandler::NewL();

    TPhoneCmdParamPointer ptrParam;

    iViewCommandHandle->ExecuteCommand( EPhoneViewGetQwertyModeObserver, &ptrParam );

    CDialer* qwertyObserver = 

            static_cast<CDialer*>( ptrParam.Pointer() );

    iQwertyHandler->AddQwertyModeObserverL( *qwertyObserver );

    if ( AknLayoutUtils::PenEnabled() )

        {

        User::LeaveIfError( iPeninputServer.Connect() );

        iPeninputServer.AddPenUiActivationHandler( this, EPluginInputModeAll );

        iVirtualKeyBoardOpen = iPeninputServer.IsVisible();

        }

    CEikonEnv* env = static_cast<CEikonEnv*>( ControlEnv() );

    if ( env )

        {

        iMenu = env->AppUiFactory()->MenuBar();

        }

    }

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

// CPhoneKeyEventForwarder::IsKeyAllowedL

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

//

TBool CPhoneKeyEventForwarder::IsKeyAllowedL( const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::IsKeyAllowedL");

    TKeyEvent keyEvent( aKeyEvent );

    // Check keyboard mode

    TBool isModeNumeric = iViewCommandHandle->HandleCommandL(

          EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess;

    // Check if key is a numeric key

    TBool isNumeric = CPhoneKeys::IsNumericKey( keyEvent, EEventKey );

    // Check if key is alpha numeric key and alphabet input is allowed

    TBool isAllowedAlphaNumeric =

       iStateMachine->State()->IsAlphanumericSupportedAndCharInput( keyEvent );

    return ( ( isModeNumeric && isNumeric ) || 

             ( !isModeNumeric && isAllowedAlphaNumeric ) );

    }

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

// CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar

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

//

TBool CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar( TUint& aCode,

        const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar");

    TBool ret( EFalse );

    TInt keyboard( CPhonePubSubProxy::Instance()->Value(

          KCRUidAvkon,

          KAknKeyBoardLayout ) );

    if ( keyboard == EPtiKeyboardHalfQwerty )

        {

        switch ( aKeyEvent.iScanCode )

           {

           case EStdKeyLeftShift:

               ret = ETrue;

               aCode = KPhoneDtmfHashCharacter;

               break;

           case EStdKeyLeftFunc:

               ret = ETrue;

               aCode = KPhoneDtmfStarCharacter;

               break;

           case EStdKeySpace:

               ret = ETrue;

               aCode = KPhoneDtmf0Character;

               break;

           default:

               break;

           }

        }

    __PHONELOG1( EBasic, EPhoneControl,

        "CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar =%d ",

        ret );

    return ret;

    }

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

// CPhoneKeyEventForwarder::IsKeySimulatedByTouchDialer

// 

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

//

TBool CPhoneKeyEventForwarder::IsKeySimulatedByTouchDialer( 

        const TKeyEvent& aKeyEvent ) const

    {

    return ( ( aKeyEvent.iModifiers & EModifierNumLock ) &&

             ( aKeyEvent.iModifiers & EModifierKeypad ) );

    }

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

// CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL

// Handle EEventKey type of event from touch dialer

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

//

void CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL( const TKeyEvent& aKeyEvent )

    {

    TBool multitap = aKeyEvent.iScanCode == EStdKeyNkpAsterisk && 

            iPreviousScanCode == EStdKeyNkpAsterisk &&

            iKeyPressTime.MicroSecondsFrom( iPreviousKeyPressTime ) < KMultitapDelay;

    if ( multitap )

        {

        // Update multitap index

        iMultitapIndex = ( iMultitapIndex + 1 ) % KAsteriskMultitapCharacters().Length();

        // Delete the previously entered character by simulating a backspace character.

        TKeyEvent backSpaceEvent;

        backSpaceEvent.iModifiers = 0;

        backSpaceEvent.iRepeats = 0;

        backSpaceEvent.iCode = EKeyBackspace;

        backSpaceEvent.iScanCode = EStdKeyBackspace;

        iStateMachine->State()->HandleKeyEventL( backSpaceEvent, EEventKey );

        TKeyEvent keyEvent( aKeyEvent );

        // Modify the key event to contain the next character on multitap list.

        keyEvent.iCode = ( TInt ) KAsteriskMultitapCharacters()[ iMultitapIndex ];

        // Send character to number entry.

        iStateMachine->State()->HandleKeyEventL( keyEvent, EEventKey );

        }

    else 

        {

        iMultitapIndex = 0;

        iStateMachine->State()->HandleKeyEventL( aKeyEvent, EEventKey );

        }

    }

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

// CPhoneKeyEventForwarder::OfferKeyEventBeforeControlStackL

// Let phone handle before other components in control stack

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

//

TKeyResponse CPhoneKeyEventForwarder::OfferKeyEventBeforeControlStackL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::OfferKeyEventBeforeControlStackL");

    TKeyResponse response( EKeyWasNotConsumed );

    // Handle key events before FEP

    // This is must becouse FEP consumes * key and when

    // editor is in alphanumeric mode FEP consumes all alphanumeric

    // keys

    switch( aType )

        {

         // EEventKeyDown

        case EEventKeyDown:

            response = HandleEventKeyDownBeforeControlStackL( aKeyEvent );

            break;

        // EEventKey

        case EEventKey:

            response = HandleEventKeyBeforeControlStackL( aKeyEvent );

            break;

        // EEventKeyUp

        case EEventKeyUp:

            response = HandleEventKeyUpBeforeControlStackL( aKeyEvent );

            break;

        default:

            break;

        }

    return response;

    }

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

// CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL

// Let phone handle keys if no one has done it already

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

//

TKeyResponse CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL");

    // Send key to editor

    iStateMachine->State()->HandleKeyEventL( aKeyEvent, aType );

    if ( EEventKeyUp == aType && EKeyNull != iKeyPressedDown )

        {

		// EKeyEnter is always offered to Telephony so don´t offer it 

		// to state if there is menu or a dialog open.

        if ( !( EKeyEnter == iKeyPressedDown 

                && iDisplayingMenuOrDialogOnEventKeyDown ) )

            {

            // Handle short key press

            iStateMachine->State()->HandleKeyMessageL( 

                    MPhoneKeyEvents::EPhoneKeyShortPress, 

                    TKeyCode( iKeyPressedDown ) );

            }

        // Reset key code

        iScanCode = EStdKeyNull;

        iKeyPressedDown = EKeyNull;

        iDisplayingMenuOrDialogOnEventKeyDown = EFalse;

        }

    return EKeyWasNotConsumed;

    }

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

// CPhoneKeyEventForwarder::OnPeninputUiDeactivated

//

// Gets called when the virtual keyboard editor is closed.

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

//

void CPhoneKeyEventForwarder::OnPeninputUiDeactivated()

    {

    __LOGMETHODSTARTEND( EPhoneControl,

            "CPhoneKeyEventForwarder::OnPeninputUiDeactivated");

    iVirtualKeyBoardOpen = EFalse;

    }

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

// CPhoneKeyEventForwarder::OnPeninputUiActivated

//

// Gets called when the virtual keyboard editor is opened.

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

//

void CPhoneKeyEventForwarder::OnPeninputUiActivated()

    {

    __LOGMETHODSTARTEND( EPhoneControl,

            "CPhoneKeyEventForwarder::OnPeninputUiActivated");

    iVirtualKeyBoardOpen = ETrue;

    }

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

// CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL

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

//

TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL(

    const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL");

    // Convert key code

    ConvertKeyCodeL( iKeyPressedDown, aKeyEvent );

    // Save key scan code

    iScanCode = aKeyEvent.iScanCode;

    // Store the previous keypress time.

    iPreviousKeyPressTime = iKeyPressTime;

    // Start the key press timer

    iKeyPressTime.UniversalTime();

    // Cancel the long press key event timer, if it is active

    if ( iLongPressKeyEventTimer->IsActive() )

        {

        iLongPressKeyEventTimer->CancelTimer();

        }

    // Don't initiate long tap timer if all these are true 

    // a) key event is not from virtual dialer

    // b) device is in qwerty mode

    // c) phone number editor is alpha mode, i.e. not in numeric mode

    // This is to prevent phone app's long tap functionality with qwerty 

    // long presses, and to have the normal editor long press behaviour 

    // instead.

    TBool preventLongTap = 

            !IsKeySimulatedByTouchDialer( aKeyEvent ) && 

            iQwertyHandler->IsQwertyInput() &&

            iViewCommandHandle->HandleCommandL( EPhoneViewIsNumberEntryNumericMode ) != EPhoneViewResponseSuccess;

    // Prevent long tap functionality for key events coming from virtual touch keyboard.

    // Virtual touch keyboard has own editing functionality for long presses, and telephony

    // should not add conflicting behaviour on top of that.

    preventLongTap = preventLongTap || iVirtualKeyBoardOpen;

    if ( !preventLongTap ) 

        {