/*

* Copyright (c) 2005 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:  An implementation of a configurable key translation map.

*

*/

// INCLUDES

#include "AknKeyEventMap.h"

#include <e32std.h>

#include <e32math.h>

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include "AknKeyResource.h"

#include <aknkeyeventmap.rsg>

#include "AknAnimLogger.h"

#include "aknanimdllstd.h"

// CONSTANTS

#define STRIP_MODS  &0x0000FFFF

#define GET_MODS    &0xFFFF0000

// Key event map resource file.

_LIT( KAknKeyTableRsc, "z:\\resource\\AknKeyEventMap.rsc" );

// Publish & Subscribe device mode category.

const TInt32 KUidWinservCategoryValue = 0x10003B20;

// Publish & Subscribe device mode category as TUid.

const TUid KUidWinservCategory = { KUidWinservCategoryValue };

// Always pass policy.

_LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy);

// Only system application can access.

_LIT_SECURITY_POLICY_S0(KSysapOnlyPolicy, 0x100058F3);

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

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

// CAknKeyEventMap::CAknKeyEventMap

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

//

CAknKeyEventMap::CAknKeyEventMap(CAknAsynchTonePlayer& aSoundSession)

    : iDownEvents( KAknMaxComboKeys ), iUpEvents( KAknMaxComboKeys ), iSoundSession(aSoundSession)

    {    

    }

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

// CAknKeyEventMap::ConstructL

//

// Initializes member variables, reads the default keytables from a resource 

// file, instantiates P&S subscriber and opens the door for raw events.

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

//

void CAknKeyEventMap::ConstructL( MAnimGeneralFunctions* aFunctions )

    {

    iFunctions = aFunctions;

    if ( KAknMaxDeviceMode < 1 || KAknMaxDeviceMode > 15)

        {

        __AKNANIMLOGSTRING("CAknKeyEventMap::ConstructL ERROR: must have at least 1 and at most 15 device modes");

        User::Leave(KErrGeneral);

        }

    iCurrentDeviceMode = KAknModeDefault;

    iKeyBeacon.iKeyCode = EKeyNull;

    iKeyBeacon.iEventType = 0;

    iDownTimer = CPeriodic::New( CActive::EPriorityLow );

    iCombos = new (ELeave) RArray<RArray<TUint32>*>( KAknMaxComboKeys );

    iRepeatRate = KAknRepeatRate;

    iKeyPollInterval = static_cast<TTimeIntervalMicroSeconds32>(1000000./iRepeatRate);

    iConsume = EFalse;

    iIsCanceled = EFalse;

    iScanCodeIJustGenerated = -1;

    // Initialize keymap.

    const TAknKeyEvent nullEvent = { EKeyNull, EKeyNull, 0 };

    for ( TUint j = 0; j < KAknKeyMapRows; j++ )

        {

        for ( TUint i = 0; i < KAknKeyMapColumns; i++ )

            {

            iKeyMap[i][j] = nullEvent;

            }

        }

    // Load the default configuration.

    TRAPD( ierr, InitializeKeyTableFromResourceL( KAknKeyTableRsc ) );

    if ( ierr != KErrNone )

        {

        __AKNANIMLOGSTRING1( "Error initializing the key tables, %d", ierr );

        }

    if ( !IsKeyEventMapEnabled() )

        {

        return;

        }

    // Define Publish & Subscribe key

    TInt err = RProperty::Define( KUidWinservCategory, KAknPSDeviceMode, 

        RProperty::EInt, KAlwaysPassPolicy, KSysapOnlyPolicy );

    if ( err != KErrNone )

        {

        __AKNANIMLOGSTRING1("CAknKeyEventMap::ConstrucL() Problem defining The Key %d", err);

        }

    // Subscribe to Publish & Subscribe keys

    err = KErrNone;

    CAknKefSubscriber *sub = NULL;

    sub = CAknKefSubscriber::NewL( *this, KUidWinservCategory , KAknPSDeviceMode  );

    if ( sub )

        {        

        err = iKefSubscribers.Append( sub );

        if ( err != KErrNone )

            {

            delete sub;

            __AKNANIMLOGSTRING( "CAknKeyEventMap::ConstructL ERROR: device mode subscription failed." );

            // We could stop the boot here, but we can also continue, just without 

            // the device modes.

            }

        }

    }

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

// CAknKeyEventMap::~CAknKeyEventMap

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

//

CAknKeyEventMap::~CAknKeyEventMap()

    {

    __AKNANIMLOGSTRING("CAknKeyEventMap::Destructor entered.");

    if ( iCombos )

        {

        const TInt count = iCombos->Count();

        for ( TInt i = count - 1; i >= 0; i-- ) 

            {

            (*iCombos)[i]->Close();

            delete (*iCombos)[i];

            iCombos->Remove(i);

            }

        iCombos->Close();

        delete iCombos;

        }

    delete iDownTimer;

    iUpEvents.Close();   

    iDownEvents.Close();

    iRepeatRates.Close();

    iKefSubscribers.ResetAndDestroy();

    iKefSubscribers.Close();

    }

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

// CAknKeyEventMap::IsKeyEventMapEnabled

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

//

TBool CAknKeyEventMap::IsKeyEventMapEnabled() const

    {

    return iKeyEventMapEnabled;

    }

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

// CAknKeyEventMap::OfferRawEvent

// 

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

//

TBool CAknKeyEventMap::OfferRawEvent( const TRawEvent& aRawEvent )

    {

    return OfferRawEvent(aRawEvent, EFalse);

    }    

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

// CAknKeyEventMap::OfferRawEvent

// 

// This is where the raw events end up in, and

// where we have to decide what to do with them.

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

//

TBool CAknKeyEventMap::OfferRawEvent( const TRawEvent& aRawEvent, TBool aSilentEvent )    

    {

    const TBool downEvent = ( aRawEvent.Type() == TRawEvent::EKeyDown );

    const TBool upEvent = ( aRawEvent.Type() == TRawEvent::EKeyUp );

    //

    // Raw events created by this CAknKeyEventMap itself: pass them on.

    //

    if ( ( downEvent || upEvent ) && 

         ( aRawEvent.ScanCode() == iScanCodeIJustGenerated ) )

        {

        if ( downEvent )

            {

            // Add this scan code to iUpEvents so we can generate

            // the appropriate raw UPs when the key press is finished.

            __AKNANIMLOGSTRING1("CAknKeyEventMap::OfferRawEvent adding %x to iUpEvents", iScanCodeIJustGenerated);

            TInt err = iUpEvents.Append( iScanCodeIJustGenerated );

            if ( err != KErrNone )  // never happened

                {

                __AKNANIMLOGSTRING("CAknKeyEventMap::OfferRawEvent ERROR appending up event!");

                }        

            }

        if ( upEvent )

            {

            // would be nice to .Remove() elements from iUpEvents here,

            // but that'd require another call to ResolveMapping(),

            //  -- .Remove() in CancelProcessingKeyPress() instead.

            }

        iScanCodeIJustGenerated = -1;

        return EFalse;  // not further processing for scan codes iJustGenerated.

        }       

    TInt err = KErrNone;

    iConsume = EFalse;  // very important to set this here.

    // log arrays

    for ( TInt i = 0 ; i < iDownEvents.Count() ; i++ )

        {

        __AKNANIMLOGSTRING2("CAknKeyEventMap::OfferRawEvent iDownEvents[%d] = %x", i, iDownEvents[i] );

        }

    for ( TInt i = 0 ; i < iUpEvents.Count() ; i++ )

        {

        __AKNANIMLOGSTRING2("CAknKeyEventMap::OfferRawEvent iUpEvents[%d] = %x", i, iUpEvents[i] );

        }

    // Down events

    if ( downEvent && aRawEvent.ScanCode() >= 0 )

        {

        iCurrentScanCode = aRawEvent.ScanCode(); 

        iPostMeOnUp.iKeyCode = EKeyNull;

        iPostMeOnUp.iEventType = 0;

        __AKNANIMLOGSTRING3( "CAknKeyEventMap::OfferRawEvent KeyDown scancode=%x mods=%x, we're in devicemode=%d", 

            iCurrentScanCode STRIP_MODS, iCurrentScanCode GET_MODS, iCurrentDeviceMode);

        // Combo support

        if ( iDownEvents.Count() < KAknMaxComboKeys )

            {

            err = iDownEvents.Append( aRawEvent.ScanCode() STRIP_MODS );

            if ( err != KErrNone )  // never happened

                {

                __AKNANIMLOGSTRING("CAknKeyEventMap::OfferRawEvent ERROR appending down event!");

                }                

            }

        else 

            {

            // User is trying to press more simultaneous keys than supported.

            // We have no problem with that, just ignore it.

            }

        // Resolve mapping for this event and set is as the beacon.

        iKeyBeacon = ResolveMapping();

        // Launch a CPeriodic so the duration of the keypress can be known.  

        // There's only one timer; for combos, it measures the time starting

        // from the first DOWN event of the combo.  If usability troubles appear,

        // try re-starting the timer for each participating key in a combo

        // (by removing the test against iDownEvents.Count())

        if ( iDownEvents.Count() < 2 )

            {            

            iKeyPressDuration = 0.0;

            iDownTimer->Cancel();

            iIsCanceled = EFalse; // set this before Start()

            iDownTimer->Start( iKeyPollInterval, iKeyPollInterval, 

                TCallBack( &KeyPressDuration, (TAny*) this ) );

            }

        if ( iKeyBeacon.iKeyCode > KAknKeyDisabled )

            {

            if ( ( iKeyBeacon.iEventType & KAknIsLongOnly ) )

                {

                // delayed posting of the short event when KAknIsLongOnly

                iPostMeOnUp = iKeyBeacon;  

                return iConsume;      // notice!  we're finished with this event.

                }

            else

                {

                if ( ( iKeyBeacon.iEventType & KAknIsShortKey ) == EFalse )

                    {

                    PostEvent( EAknPostRaw );

                    }

                else 

                    {

                    PostEvent( EAknPostKey );

                    }

                }

            }       

        // Emit a keyclick.

        if ( !aSilentEvent && iKeyBeacon.iKeyCode != KAknKeyDisabled )

            {

            if ( iKeyBeacon.iKeyCode > KAknKeyDisabled )

                {

                iSoundSession.KeyPressed( iKeyBeacon.iKeyCode STRIP_MODS );

                }

            else

                {

                iSoundSession.KeyPressed( aRawEvent.ScanCode() STRIP_MODS );

                }

            }

        return iConsume; // this was set by ResolveMapping

        }

    //  Up events    

    if ( upEvent )

        {

        iCurrentScanCode = aRawEvent.ScanCode(); 

        __AKNANIMLOGSTRING1("CAknKeyEventMap::OfferRawEvent KeyUp scancode=%x",aRawEvent.ScanCode());

        // Check whether this up event finishes a keypress we've been handling.

        TInt finishesKeyPress = 

            iDownEvents.Find( aRawEvent.ScanCode() STRIP_MODS );

        __AKNANIMLOGSTRING1("CAknKeyEventMap::OfferRawEvent finishesKeypress index %d", finishesKeyPress);

        __AKNANIMLOGSTRING1("CAknKeyEventMap::OfferRawEvent Duration =%f",iKeyPressDuration);

        // We got an UP for a known DOWN

        if ( finishesKeyPress != KErrNotFound ) 

            {

            if ( iPostMeOnUp.iKeyCode > KAknKeyDisabled && !iIsLongKeyPress  )

                {

                iKeyBeacon = iPostMeOnUp;

                if ( ( iKeyBeacon.iEventType & KAknIsShortKey ) == EFalse )

                    {

                    PostEvent( EAknPostRaw );

                    }

                else 

                    {

                    PostEvent( EAknPostKey );

                    }

                iPostMeOnUp.iKeyCode = EKeyNull;

                iPostMeOnUp.iEventType = 0;

                }

            iKeyBeacon = ResolveMapping();

            // Remove key from the down array

            iDownEvents.Remove( finishesKeyPress );

            // if it is mapped on the up array -> generate the up event

            TInt upKeyPressIndex = KErrNotFound;

            for ( TInt i = 0 ; i < iUpEvents.Count() ; i++ )

                {

                if ( (iUpEvents[i] STRIP_MODS) == ( iKeyBeacon.iKeyCode STRIP_MODS ) )

                    {

                    upKeyPressIndex = i;

                    break;

                    }

                }

            if ( upKeyPressIndex != KErrNotFound )

                {

                iScanCodeIJustGenerated = iUpEvents[upKeyPressIndex];

                TRawEvent rawEvent;

                rawEvent.Set( TRawEvent::EKeyUp, iScanCodeIJustGenerated );

                __AKNANIMLOGSTRING1("CAknKeyEventMap::OfferRawEvent POST RAW UP-EVENT for %x",iScanCodeIJustGenerated);

                iFunctions->PostRawEvent( rawEvent ) ;

                iUpEvents.Remove(upKeyPressIndex);

                iConsume = ETrue;

                }

            if ( !iDownEvents.Count() )

                {

                CancelProcessingKeyPress();

                }

            }

         else // finishesKeyPress == KErrNotFound

            {

            // probably a hardware/driver bug, in any case we're

            // confused now.

            __AKNANIMLOGSTRING("CAknKeyEventMap::OfferRawEvent INPUT IS CONFUSED: cancel key processing");            

            CancelProcessingKeyPress();

            }

        }

    return iConsume;

    }

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

// CAknKeyEventMap::CancelProcessingKeyPress

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

void CAknKeyEventMap::CancelProcessingKeyPress()

    {

    iDownTimer->Cancel();

    iIsCanceled = ETrue;

    iDownEvents.Reset();

    // be sure to send out all raw upevents or CKeyTranslator

    // will think the key is still being pressed.

    TRawEvent rawEvent;    

    while ( iUpEvents.Count() > 0 )

        {

        iScanCodeIJustGenerated = iUpEvents[0];

        rawEvent.Set( TRawEvent::EKeyUp, iScanCodeIJustGenerated );

        __AKNANIMLOGSTRING1("CAknKeyEventMap::CancelProcessingKeyPress POST RAW UP-EVENT for %x",iScanCodeIJustGenerated);

        iFunctions->PostRawEvent( rawEvent ) ;

        iUpEvents.Remove(0);

        }

    iUpEvents.Reset();

    iRepeats = 0;

    iKeyPressDuration = 0.0;

    iIsLongKeyPress = EFalse;                

    __AKNANIMLOGSTRING1("CAknKeyEventMap::CancelProcessingKeyPress Last beacon sent: %x", iKeyBeacon.iKeyCode);

    iKeyBeacon.iKeyCode = EKeyNull;

    iKeyBeacon.iEventType = 0;

    }

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

// CAknKeyEventMap::HandlePropertyChangedL

//

// Callback for Publish & Subscribe key events, it tracks

// the device mode changes for internal use.

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

//

void CAknKeyEventMap::HandlePropertyChangedL( 

        const TUid& aCategory, 

        const TUint aKey )

    {

    TInt keyValue( 0 );

    TInt err = KErrNone;

    err = RProperty::Get( aCategory, aKey, keyValue );

    if ( err == KErrNone )

        {

        switch( aKey )

            {

            case KAknPSDeviceMode:

                {

                __AKNANIMLOGSTRING1("CAknKeyEventMap::HandlePropertyChanged VALUE: %d",aKey);

                iCurrentDeviceMode = keyValue;

                const TInt count = iRepeatRates.Count();

                TUint16 currentMode = iCurrentDeviceMode; 

                for ( TInt ii = 0; ii < count; ii++ )

                    {

                    const TAknKeyRepeatRate& repeatRate = iRepeatRates[ ii ];

                    if ( ( currentMode & repeatRate.iModeMask ) == 

                         repeatRate.iMode )

                        {

                        SetRepeatRate( repeatRate.iRate );

                        ii = count; // exit the loop.

                        }

                    }

                }

                break;

            default:

                {

                __AKNANIMLOGSTRING1("CAknKeyEventMap::HandlePropertyChanged GOT A P&S VALUE: %d",aKey);

                }

                break;

            }

        }

    }

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

// CAknKeyEventMap::InitializeKeyTableFromResourceL

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

//

void CAknKeyEventMap::InitializeKeyTableFromResourceL(

        const TDesC& aConfigFile ) 

    {

    // Get a handle for the resource file.

    RFs fsSession;

    CleanupClosePushL( fsSession );

    TInt err = fsSession.Connect();

    if ( err != KErrNone )

        {

        User::Leave( err );

        }

    RResourceFile resourceFile;

    CleanupClosePushL( resourceFile );

    // Make sure we have the resource file.

    if ( BaflUtils::FileExists( fsSession, aConfigFile ) )

        {

        resourceFile.OpenL( fsSession, aConfigFile );

        }

    else

        {

        __AKNANIMLOGSTRING( "CAknKeyEventMap::InitializeKeyTableFromResourceL: no configuration file!");

        CleanupStack::PopAndDestroy(); // CleanupClosePushL.

        CleanupStack::PopAndDestroy(); // CleanupClosePushL.

        return;

        }

    // Confirm signature of the resource file.

    resourceFile.ConfirmSignatureL( 0 );

    // Now just get the resource chunk into a heap buffer and give it to a 

    // TResourceReader.

    HBufC8* res;

    res = resourceFile.AllocReadLC( R_AVKON_KEY_EVENT_MAP );

    TResourceReader theReader;

    theReader.SetBuffer( res );

    // Check version field.

    const TUint16 version = theReader.ReadUint16();

    if ( version != KAknKeyEventVersion1 )

        {

        __AKNANIMLOGSTRING( "CAknKeyEventMap::InitializeKeyTableFromResourceL: key event map disabled!");

        CleanupStack::PopAndDestroy( res );

        CleanupStack::PopAndDestroy(); // CleanupClosePushL.

        CleanupStack::PopAndDestroy(); // CleanupClosePushL.

        return;