/*

* Copyright (c) 2006 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 "kefmapimpl.h"

#include <e32std.h>

#include <e32math.h>

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include "kefresource.h"

#include "keflogger.h"

#include "kefprovider.h"

// CONSTANTS

#define STRIP_MODS  &0x0000FFFF

#define GET_MODS    &0xFFFF0000

// Key event map resource file.

_LIT( KKefKeyTableRsc, "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 ===============================

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

// CKefMapImpl::NewL

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

//

CKefMapImpl* CKefMapImpl::NewL()

    {

    CKefMapImpl* self = new (ELeave)CKefMapImpl();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CKefMapImpl::CKefMapImpl

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

//

CKefMapImpl::CKefMapImpl()

    : iDownEvents( KKefMaxComboKeys ), iUpEvents( KKefMaxComboKeys )

    {    

    }

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

// CKefMapImpl::ConstructL

//

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

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

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

//

void CKefMapImpl::ConstructL()

    {

    if ( KKefMaxDeviceMode < 1 || KKefMaxDeviceMode > 15)

        {

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

        User::Leave(KErrGeneral);

        }

    //NEW CODE

    iDelayedCombo = EFalse;

    iIsPartialMatch = EFalse;

    iCompleteDelayedComboMatch = EFalse;

    iPostPendingDownEvents = EFalse;

    //END NEW CODE

    iCurrentDeviceMode = KKefModeDefault;

    iKeyBeacon.iKeyCode = EKeyNull;

    iKeyBeacon.iEventType = 0;

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

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

    iRepeatRate = KKefRepeatRate;

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

    iConsume = EFalse;

    iIsCanceled = EFalse;

    iScanCodeIJustGenerated = -1;

    iPostedDelayedScanCode = -1;

    iIsCombo = EFalse;

    // Initialize keymap.

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

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

        {

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

            {

            iKeyMap[i][j] = nullEvent;

            }

        }

    // Load the default configuration.

    TRAPD( ierr, InitializeKeyTableFromResourceL( KKefKeyTableRsc ) );

    if ( ierr != KErrNone )

        {

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

        }

    if ( !IsKeyEventMapEnabled() )

        {

        return;

        }

    // Define Publish & Subscribe key

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

        RProperty::EInt, KAlwaysPassPolicy, KSysapOnlyPolicy );

    if ( err != KErrNone )

        {

        __KEFLOGSTRING1("CKefMapImpl::ConstrucL() Problem defining The Key %d", err);

        }

    // Subscribe to Publish & Subscribe keys

    err = KErrNone;

    CKefSubscriber *sub = NULL;

    sub = CKefSubscriber::NewL( *this, KUidWinservCategory , KKefPSDeviceMode  );

    if ( sub )

        {        

        err = iKefSubscribers.Append( sub );

        if ( err != KErrNone )

            {

            delete sub;

            __KEFLOGSTRING( "CKefMapImpl::ConstructL ERROR: device mode subscription failed." );

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

            // the device modes.

            }

        }

    }

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

// CKefMapImpl::~CKefMapImpl

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

//

CKefMapImpl::~CKefMapImpl()

    {

    __KEFLOGSTRING("CKefMapImpl::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();

    iRawEventsNotPosted.Close();

    }

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

// CKefMapImpl::SetProvider

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

//    

void CKefMapImpl::SetProvider( MKefProvider& aProvider )

    {

    iProvider = &aProvider;

    }

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

// CKefMapImpl::IsKeyEventMapEnabled

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

//

TBool CKefMapImpl::IsKeyEventMapEnabled() const

    {

    return iKeyEventMapEnabled;

    }

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

// CKefMapImpl::OfferRawEvent

// 

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

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

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

//

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

    {

    __ASSERT_ALWAYS( iProvider, User::Invariant() );

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

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

    //NEW CODE

    iCompleteDelayedComboMatch = EFalse;

    //END NEW CODE

    //

    // Raw events created by this CKefMapImpl 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.

            __KEFLOGSTRING1("CKefMapImpl::OfferRawEvent adding %x to iUpEvents", iScanCodeIJustGenerated);

            TInt err = iUpEvents.Append( iScanCodeIJustGenerated );

            if ( err != KErrNone )  // never happened

                {

                __KEFLOGSTRING("CKefMapImpl::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.

        } 

    //NEW CODE

    if ( ( downEvent || upEvent ) && 

         ( aRawEvent.ScanCode() == iPostedDelayedScanCode ) )

        { 

        iPostedDelayedScanCode = -1;

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

        }

    //END NEW CODE      

    TInt err = KErrNone;

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

    // log arrays

#ifdef _KEF_LOGGING	

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

        {

        __KEFLOGSTRING2("CKefMapImpl::OfferRawEvent iDownEvents[%d] = %x", i, iDownEvents[i] );

        }

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

        {

        __KEFLOGSTRING2("CKefMapImpl::OfferRawEvent iUpEvents[%d] = %x", i, iUpEvents[i] );

        }

#endif // _KEF_LOGGING	

    // Down events

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

        {

        iIsDownEvent = ETrue;

        iCurrentScanCode = aRawEvent.ScanCode(); 

        iPostMeOnUp.iKeyCode = EKeyNull;

        iPostMeOnUp.iEventType = 0;

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

            iCurrentScanCode STRIP_MODS, iCurrentScanCode GET_MODS, iCurrentDeviceMode);

        // Combo support

        if ( iDownEvents.Count() < KKefMaxComboKeys )

            {

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

            if ( err != KErrNone )  // never happened

                {

                __KEFLOGSTRING("CKefMapImpl::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())

        //NEW CODE

        if ( iDownEvents.Count() < 2 && !iDelayedCombo)

        //END NEW CODE        

            {            

            iKeyPressDuration = 0.0;

            iDownTimer->Cancel();

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

            iDownTimer->Start( iKeyPollInterval, iKeyPollInterval, 

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

            }

        if ( iKeyBeacon.iKeyCode > KKefKeyDisabled )

            {

            if ( ( iKeyBeacon.iEventType & KKefIsLongOnly ) )

                {

                // delayed posting of the short event when KKefIsLongOnly

                iPostMeOnUp = iKeyBeacon;  

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

                }//this might be part of special combo key event

            //NEW CODE

            else if(iDelayedCombo && !iCompleteDelayedComboMatch)

                {

                    __KEFLOGSTRING("CKefMapImpl::OfferRawEvent Delayed Combo; downevent pending");

                 //delay posting of down event(s) in case this is part of the combo

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

                }

            //END NEW CODE

            else

                {

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

                    {

                    PostEvent( EKefPostRaw );

                    }

                else 

                    {

                    PostEvent( EKefPostKey );

                    }

                //NEW CODE    

                if(iCompleteDelayedComboMatch)

                    {

                        TInt existsAlready(-1);

                        __KEFLOGSTRING("CKefMapImpl::OfferRawEvent Delayed Combo Complete. Key event posted");

                      //Events for keys part of completed special combo are NOT posted. Ever.

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

                        {   

                            existsAlready = iRawEventsNotPosted.Find( iDownEvents[i] );

                            //However, do NOT add same events more than once.

                            //When user is pressing the second key of a combo multiple times and holding the first down

                            //we'd have the first key of the combo umpty times on the list.

                            if(existsAlready == KErrNotFound)

                                iRawEventsNotPosted.Append( iDownEvents[i] );

                        }

                      iIsPartialMatch = EFalse;

                      iPostPendingDownEvents = EFalse;

                      iCompleteDelayedComboMatch = EFalse;

                    }

                //END NEW CODE  

                }

            }

         //NEW CODE

         if(iPostPendingDownEvents)

                {   //This is not a special combo. Post delayed downevents.

                    __KEFLOGSTRING("CKefMapImpl::OfferRawEvent Delayed Combo ABORT. Post pending events.");

                    iDelayedCombo = EFalse;

                    iIsPartialMatch = EFalse;

                    TInt lastBeforeCurrentEvent = iDownEvents.Count();

                    TInt eventNotPostedIndex(-1);

                    //The current downevent will be posted by the window server (iConsume is EFalse).

                    for(TInt i=0; i<lastBeforeCurrentEvent; i++)

                        {

                            eventNotPostedIndex = KErrNotFound;

                            if(iRawEventsNotPosted.Count())                           

                                eventNotPostedIndex = iRawEventsNotPosted.Find( iDownEvents[i] );

                            if(eventNotPostedIndex == KErrNotFound)

                                {

                                    iPostedDelayedScanCode = iDownEvents[i];

                                    TRawEvent rawEvent;

                                    rawEvent.Set( TRawEvent::EKeyDown, iPostedDelayedScanCode );

                                    __KEFLOGSTRING1("CKefMapImpl::OfferRawEvent Posted pending event scancode=%x",rawEvent.ScanCode());

                                    iProvider->KefPostRawEvent( rawEvent );

                                }

                        }          

                    iPostPendingDownEvents = EFalse;

                }

            //END NEW CODE       

        // Emit a keyclick.

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

            {

            if ( iKeyBeacon.iKeyCode > KKefKeyDisabled )

                {

                if (iDownEvents.Count() > 1)

                	{	//Make sure the key sound is played for the last key of a combo

                		iProvider->KefGenerateKeySound( iCurrentScanCode STRIP_MODS );

                	}

                else

                	{	//Otherwise send the mapped single key

                		iProvider->KefGenerateKeySound( iKeyBeacon.iKeyCode STRIP_MODS );

                	}

                }

            else

                {

                iProvider->KefGenerateKeySound( aRawEvent.ScanCode() STRIP_MODS );

                }

            }

        return iConsume; // this was set by ResolveMapping

        }

    //  Up events    

    if ( upEvent )

        {

        iIsDownEvent = EFalse;               

        iCurrentScanCode = aRawEvent.ScanCode(); 

        __KEFLOGSTRING1("CKefMapImpl::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 );

        __KEFLOGSTRING1("CKefMapImpl::OfferRawEvent finishesKeypress index %d", finishesKeyPress);

        __KEFLOGSTRING1("CKefMapImpl::OfferRawEvent Duration =%f",iKeyPressDuration);

        // We got an UP for a known DOWN

        if ( finishesKeyPress != KErrNotFound) 

            {

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

                {

                iKeyBeacon = iPostMeOnUp;

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

                    {

                    PostEvent( EKefPostRaw );

                    }

                else 

                    {

                    PostEvent( EKefPostKey );

                    }

                iPostMeOnUp.iKeyCode = EKeyNull;

                iPostMeOnUp.iEventType = 0;

                }

            //NEW CODE

            if(iDelayedCombo )

                {

                    TInt lastDownEventIndex = iDownEvents.Count() - 1;

                    TInt eventNotPostedIndex(-1);

                    TInt lastEvent = iDownEvents[lastDownEventIndex]; //DEBUG VARIABLE

                    //Up event for some other key than the last pressed; handling of special event aborted.

                    if(finishesKeyPress != lastDownEventIndex)

                        {

                            __KEFLOGSTRING("CKefMapImpl::OfferRawEvent: Not the last key of DK. ABORT by UP event.");

                            iDelayedCombo = EFalse;

                            iIsPartialMatch = EFalse;

                            iCompleteDelayedComboMatch = EFalse;

                            iPostPendingDownEvents = ETrue;

                            //Check if current UP event is in the "not to be posted" list

                            eventNotPostedIndex = iRawEventsNotPosted.Find( iCurrentScanCode STRIP_MODS );

                            if(eventNotPostedIndex != KErrNotFound)

                              {

                                iDownEvents.Remove( finishesKeyPress ); 

                                iRawEventsNotPosted.Remove(eventNotPostedIndex);

                                iConsume = ETrue; //This UP event is not sent either...

                              }

                            //Post pending down events

                            __KEFLOGSTRING("CKefMapImpl::OfferRawEvent: Post pending events.");

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

                                {

                                    eventNotPostedIndex = iRawEventsNotPosted.Find( iDownEvents[i] STRIP_MODS );

                                    //Event is not in the "not to be posted" list; send it.

                                    if(eventNotPostedIndex == KErrNotFound)

                                        {

                                            iPostedDelayedScanCode = iDownEvents[i];

                                            TRawEvent rawEvent;

                                            rawEvent.Set( TRawEvent::EKeyDown, iPostedDelayedScanCode );

                                            iProvider->KefPostRawEvent( rawEvent );

                                            eventNotPostedIndex = - 1;

                                        }

                                }

                            iPostPendingDownEvents = EFalse;

                        }

                     else //Last key of a special combo or a candidate.Continue processing as special combo.

                        {

                            __KEFLOGSTRING("CKefMapImpl::OfferRawEvent: The last key of DK.");

                            eventNotPostedIndex = iRawEventsNotPosted.Find( iCurrentScanCode STRIP_MODS );

                            //Last key of a partial match 

                            if(eventNotPostedIndex == KErrNotFound)

                                {

                                  __KEFLOGSTRING("CKefMapImpl::OfferRawEvent: Last key not on NO list. Post downevent.");

                                  iPostedDelayedScanCode = iDownEvents[finishesKeyPress];

                                  iDownEvents.Remove( finishesKeyPress ); 

                                  TRawEvent rawEvent;

                                  rawEvent.Set( TRawEvent::EKeyDown, iPostedDelayedScanCode );

                                  //Post DOWN event. UP event will be posted by Window Server since iConsume is False.

                                  iProvider->KefPostRawEvent( rawEvent );

                                }

                            else //Part of a completed special event. Do not post events associated with this key.

                                { 

                                    __KEFLOGSTRING("CKefMapImpl::OfferRawEvent: Last key on NO list. Don't post events.");  

                                  iDownEvents.Remove( finishesKeyPress ); 

                                  iRawEventsNotPosted.Remove(eventNotPostedIndex);

                                  iConsume = ETrue;

                                }  

                        }

                }

            else

                {