/*

* 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 "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 "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");

        {

        }

    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 );

    ret = OfferKeyEventBeforeControlStackL( aKeyEvent, aType );

        {

        keyEvent.iCode = iKeyPressedDown;

        // Start and stop dtmf

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

            {

            // 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 );

        {

            this,

            ECoeStackPriorityEnvironmentFilter,

            ECoeStackFlagRefusesFocus );

        }

    // Create the long press key event timer

    iLongPressKeyEventTimer = CPhoneTimer::NewL();

    // Create qwerty mode handler

    TPhoneCmdParamPointer ptrParam;

    iViewCommandHandle->ExecuteCommand( EPhoneViewGetQwertyModeObserver, &ptrParam );

    CDialer* qwertyObserver = 

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

    iQwertyHandler->AddQwertyModeObserverL( *qwertyObserver );

    }

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

// CPhoneKeyEventForwarder::IsAlphaNumericKey

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

//

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::IsAlphaNumericKey");

    }

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

// CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar

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

//

TBool CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar( TUint& aCode,

        const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar");

    TBool ret( EFalse );

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

          KCRUidAvkon,

          KAknKeyBoardLayout ) );

        {

        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;

    }

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

// 

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

//

    {

    TBool multitap = aKeyEvent.iScanCode == EStdKeyNkpAsterisk && 

            iPreviousScanCode == EStdKeyNkpAsterisk &&

            iKeyPressTime.MicroSecondsFrom( iPreviousKeyPressTime ) < KMultitapDelay;

    if ( multitap )

        {

        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.

        }

    else 

        {

        iMultitapIndex = 0;

        }

    }

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

// 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 );

        {

        // Handle short key press

        iStateMachine->State()->HandleKeyMessageL( 

            MPhoneKeyEvents::EPhoneKeyShortPress, 

            TKeyCode( iKeyPressedDown ) );

        // Reset key code

        iScanCode = EStdKeyNull;

        iKeyPressedDown = EKeyNull;

        }

    return EKeyWasNotConsumed;

    }

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

// CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL

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

//

TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL(

    const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL");

    // Convert key code

    ConvertKeyCode( 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();

        }

    // Re-start the timer

    iLongPressKeyEventTimer->After(

        KPhoneLongPressKeyEventDuration,

        TCallBack( DoHandleLongPressKeyEventCallbackL,

        this ) );

    return ( EKeyWasNotConsumed );

    }

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

// CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL

// Both short key press event (iRepeats == 0) and

// long key press event (iRepeats == 1) are handled here

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

//

TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL(

    const TKeyEvent& aKeyEvent )

    {

    __LOGMETHODSTARTEND( EPhoneControl,

        "CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL");

    TKeyResponse response( EKeyWasNotConsumed );

        {