/*

* Copyright (c) 2005-2008 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:  Translates key events for different UI related situations.

*

*/

// INCLUDE FILES

#include <barsread.h>

#include <apgwgnam.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>    // KUikLayoutState, KUikFlipStatus

#include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

#include <eikpriv.rsg>

#include <AknDef.h>

#include <AknSgcc.h>

#include <aknenv.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <AknSettingCache.h>

#include <AknLayoutConfig.h>

#include "AknKeyFilter.h"

#include <AknTaskList.h>

#include <aknconsts.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include "akntranseffect.h" // for Transition effect enumerations

#include <hwrmdomainpskeys.h>

#include "AknCapServerEntry.h"

/** Phone application's AppUID. */

const TUid KPhoneAppUid  = { 0x100058B3 };

/** Phone application's view UID. */

const TUid KPhoneViewUid = { 0x10282D81 };

/** Video call application's AppUID */

const TUid KVideoCallAppUid     = { 0x101F8681 }; 

/**

* Command used in activating the phone view.

* Null command allows the the phone app to decide whether

* to open dialer or call handling.

*/

const TUid KPhoneVievCommand = { 0x0 };

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <PtiDefs.h>

#include <AknFepInternalCRKeys.h>

#endif

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

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

// CAknServKeyFilter::CAknServKeyFilter

// Default constructor.

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

//

CAknServKeyFilter::CAknServKeyFilter()

    : iHardwareStateKeyCaptures( 2 )

    {

    }

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

// CAknServKeyFilter::~CAknServKeyFilter

// Destructor.

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

//

CAknServKeyFilter::~CAknServKeyFilter()

    {

    FreeHardwareStateKeys();

    RWindowGroup& groupWin = iCoeEnv->RootWin();

    groupWin.CancelCaptureKeyUpAndDowns( iHomeKeyHandle );

    groupWin.CancelCaptureKeyUpAndDowns( iQwertyOnKeyHandle );

    groupWin.CancelCaptureKeyUpAndDowns( iQwertyOffKeyHandle );

    groupWin.CancelCaptureKey( iFlipOpenKeyHandle );

    groupWin.CancelCaptureKey( iFlipCloseKeyHandle );

#ifdef RD_INTELLIGENT_TEXT_INPUT

    delete iAvkonRepository;

#endif

    delete iHomeTimer;

    }

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

// CAknServKeyFilter::ConstructL

// Second-phase constructor.

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

//

void CAknServKeyFilter::ConstructL( CAknCapAppServerAppUi& aAppUi )

    {

    RWindowGroup& groupWin = iCoeEnv->RootWin();

    iHomeKeyHandle      = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication0, 0, 0);

    iQwertyOnKeyHandle  = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication7, 0, 0); // EKeyQwertyOn

    iQwertyOffKeyHandle = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication8, 0, 0); // EKeyQwertyOff

    iFlipOpenKeyHandle  = groupWin.CaptureKey(EKeyDeviceA, 0, 0); // EKeyFlipOpen

    iFlipCloseKeyHandle = groupWin.CaptureKey(EKeyDeviceB, 0, 0); // EKeyFlipClose

    // Get the default view id

    TResourceReader reader;

    // AppUi loads this resource

    iEikonEnv->CreateResourceReaderLC( reader, R_EIK_SYSTEM_DEFAULT_VIEW_ID );

    iHomeViewId.iAppUid.iUid  = reader.ReadInt32();

    iHomeViewId.iViewUid.iUid = reader.ReadInt32();

    CleanupStack::PopAndDestroy(); // reader

    aAppUi.AddToStackL(

        this,

        ECoeStackPriorityEnvironmentFilter,

        ECoeStackFlagRefusesFocus|ECoeStackFlagOwnershipTransfered|ECoeStackFlagSharable);

    iAppUi = &aAppUi;

    CaptureHardwareStateKeysL();

    InitHardwareStateL();

    RProperty::Define( KPSUidUikon, KUikFlipStatus, RProperty::EInt );

    // Set default value for the KUikFlipStatus Pub&Sub key.

    RProperty::Set( KPSUidUikon, KUikFlipStatus, 0 );

    RProperty::Define( KCRUidAvkon, KAknQwertyInputModeActive, RProperty::EInt );

    // Set default value for the KAknQwertyInputModeActive Pub&Sub key.

    RProperty::Set(KCRUidAvkon, KAknQwertyInputModeActive, 0);

    iAppUi->iQwertyStatus = EFalse;

#ifdef RD_INTELLIGENT_TEXT_INPUT        

#if defined(__WINS__)    

    TInt layoutState = 0;

    TInt hwKeyCode = 0;

    RProperty::Get(KPSUidUikon, KUikLayoutState, layoutState);

    CAknLayoutConfig::THardwareStateArray hwStates = CAknSgcClient::LayoutConfig().HardwareStates();

    TInt count = hwStates.Count();

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

        {

        const CAknLayoutConfig::THardwareState& hwState = hwStates.At(ii);

        if (hwState.StateNumber() == layoutState)

            {

            hwKeyCode = hwState.KeyCode();

            break;

            }

        }

    RProperty::Define( KCRUidAvkon, KAknKeyBoardLayout, RProperty::EInt );

    iAvkonRepository = CRepository::NewL(KCRUidAvkon);

    TInt keyboardLayout = HwKeyToKeyBoardType(hwKeyCode);

    // Set default value for the KAknKeyBoardLayout Pub&Sub key.

    RProperty::Set(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

#else

    RProperty::Define( KCRUidAvkon, KAknKeyBoardLayout, RProperty::EInt );

    iAvkonRepository = CRepository::NewL(KCRUidAvkon);

    TInt keyboardLayout = EPtiKeyboard12Key;

    iAvkonRepository->Get(KAknKeyBoardLayout, keyboardLayout); 

    RProperty::Set(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

#endif // !__WINS__   

    TBool isQwertyOn = EFalse;

    switch(keyboardLayout)

        {

        case EPtiKeyboardQwerty4x12:

        case EPtiKeyboardQwerty4x10:

        case EPtiKeyboardQwerty3x11:

        case EPtiKeyboardHalfQwerty:

        case EPtiKeyboardCustomQwerty:

            {

            isQwertyOn = ETrue;

            break;

            }

        default:

            break;

        }

    if(isQwertyOn)

        {

        RProperty::Set(KCRUidAvkon, KAknQwertyInputModeActive, 1);

        iAppUi->iQwertyStatus = ETrue;

        }

    else

        {

        RProperty::Set(KCRUidAvkon, KAknQwertyInputModeActive, 0);

        iAppUi->iQwertyStatus = EFalse;

        }

#endif // RD_INTELLIGENT_TEXT_INPUT

    }

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

// CAknServKeyFilter::ToggleShellL

// This method handles the short press of the applications key.

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

//

void CAknServKeyFilter::ToggleShellL()

    {

    RWsSession& ws = iCoeEnv->WsSession();

    TInt fgWgId    = ws.GetFocusWindowGroup();

    // Foreground application might be embedded into another application,

    // find root.

    CAknTaskList* taskList = CAknTaskList::NewL( ws );

    const RArray<RWsSession::TWindowGroupChainInfo>& chain = taskList->WgArray();

    const TInt chainCount = chain.Count();

    TBool found = ETrue;

    TInt wgId = fgWgId;

    while ( found )

        {

        found = EFalse;

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

            {

            const RWsSession::TWindowGroupChainInfo& info = chain[ ii ];

            if ( info.iId == wgId && info.iParentId > 0 )

                {

                wgId = info.iParentId;

                found = ETrue;

                ii = chainCount; // break from for loop.

                }

            }

        }

    delete taskList;

    // Get application UID of root window group.

    CApaWindowGroupName* wgName = CApaWindowGroupName::NewL( ws, wgId );

    CleanupStack::PushL( wgName );

    TUid appUid = wgName->AppUid();

    CleanupStack::PopAndDestroy( wgName );

    TVwsViewId idleView = TVwsViewId();

    TInt err = AknDef::GetPhoneIdleViewId( idleView );

    if ( err )

        {

        return;

        }

    if ( appUid == iHomeViewId.iAppUid )

        {

        // We are in AppShell, so try to activate the idle app

        // or phone app if there's a call ongoing.

        TInt value = 0;

        err = RProperty::Get( KPSUidUikon, KUikVideoCallTopApp, value );

      	if ( value == KPhoneAppUid.iUid )

      	    {

            ActivateViewL( TVwsViewId( TUid::Uid( value ), KPhoneViewUid ), KPhoneVievCommand );

            }

      	else if ( value == KVideoCallAppUid.iUid )

            {

            ActivateViewL( TVwsViewId( TUid::Uid( value ), KVideoCallAppUid ), TUid::Null() );

      	    }

        else

            {

            ActivateViewL( idleView, TUid::Uid( 1 ) );

            }

          }

    else if ( appUid == idleView.iAppUid || iAppUi->IsIdelActive( ))

        {

        ActivateViewL( iHomeViewId, TUid::Uid(1) );

        }

    else

        {

        GfxTransEffect::AbortFullScreen();

        ActivateViewL( idleView, TUid::Uid(1) );

        }

    }

void CAknServKeyFilter::ActivateViewL( const TVwsViewId& aViewId, TUid aCustomMessageId )

    {

    RWsSession& ws = iCoeEnv->WsSession();

    TApaTaskList appList( ws );

    TApaTask task = appList.FindApp( aViewId.iAppUid );

    if ( task.Exists() )

        {

        // If the task already exists, bring it to foreground.

        if ( aViewId.iAppUid == iHomeViewId.iAppUid )

            {

            // special process for appshell

            RThread menuThread;

            TInt error = menuThread.Open(task.ThreadId());

            if ( error == KErrNone )

               {

               menuThread.SetProcessPriority(EPriorityForeground);  

               }

            // matrix menu will bring itself foreground when getting the message below

            task.SendMessage( KUidApaMessageSwitchOpenFile , KNullDesC8 );

            }

        else

            {

            CAknSgcClient::MoveApp(task.WgId(), ESgcMoveAppToForeground);

            }

        }

    else

        {

        // Shell app wants reactivation, so send a non-zero message ID.

        // Note that in high CPU load situations this might

        // cause the view server to panic an application,

        // that's why we try to bring an existing task

        // to foreground first.

        iAppUi->CreateActivateViewEventL( aViewId, aCustomMessageId, KNullDesC8() );

        }

    }

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

// CAknServKeyFilter::OfferKeyEventL

// Handles key events.

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

//

TKeyResponse CAknServKeyFilter::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                TEventCode aType )

    {

    // Forward up event to app ui because of soft notification

    // key forwaring to phone app.

    if ( aType == EEventKeyUp &&

         iAppUi->iScanCodeCaptureHandle &&

         iAppUi->iPhoneKey.iScanCode == aKeyEvent.iScanCode )

        {

        iAppUi->PhoneKeyUpReceived();

        return EKeyWasConsumed;

        }

    if ( aKeyEvent.iScanCode == EStdKeyApplication0 )

        {

        return HandleHomeKeyEventL( aType );

        }

    else if ( aKeyEvent.iScanCode == EStdKeyApplication7 || // EKeyQwertyOn

              aKeyEvent.iScanCode == EStdKeyApplication8 )  // EKeyQwertyOff

        {

        return HandleQwertyKeyEvent( aKeyEvent, aType );

        }

    else if ( aType==EEventKey && HandleHardwareStateKeyL( aKeyEvent.iCode ) )

        {

        return EKeyWasConsumed;

        }

    return EKeyWasNotConsumed;

    }

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

// CAknServKeyFilter::HandleHomeKeyEventL

// Handles the pressing of applications key.

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

//

TKeyResponse CAknServKeyFilter::HandleHomeKeyEventL( TEventCode aType )

    {

    if ( iAppUi->IsAppsKeySuppressed() )

        {

        return EKeyWasNotConsumed;

        }

    if ( aType == EEventKeyDown )

        {

        delete iHomeTimer;

        iHomeTimer = NULL;

        iHomeTimer = CPeriodic::NewL( CActive::EPriorityHigh );

        iHomeTimer->Start( KHomeHoldDelay, 1, TCallBack( HomeTickL, this ) );

        return EKeyWasConsumed;

        }

    else if ( aType == EEventKeyUp )

        {

        if ( iHomeTimer && iHomeTimer->IsActive() )

            {

            iHomeTimer->Cancel();

            delete iHomeTimer;

            iHomeTimer = NULL;

            if ( !iAppUi->HandleShortAppsKeyPressL() )

                {

                RWsSession& ws = iEikonEnv->WsSession();

                TApaTaskList apList( ws );

                TApaTask task = apList.FindApp( iHomeViewId.iAppUid );

                if( task.Exists() && task.WgId() == ws.GetFocusWindowGroup() )

                    {

                    GfxTransEffect::BeginFullScreen(

                        AknTransEffect::EApplicationExit,

                        TRect(),

                        AknTransEffect::EParameterType,

                        AknTransEffect::GfxTransParam( iHomeViewId.iAppUid ) );

                    }

                ToggleShellL();

                }

            return EKeyWasConsumed;

            }

        }

    return EKeyWasNotConsumed;

    }

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

// CAknServKeyFilter::HandleQwertyKeyEvent

// Handles the pressing of QWERTY key.

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

//

TKeyResponse CAknServKeyFilter::HandleQwertyKeyEvent( const TKeyEvent& /*aKeyEvent*/,

                                                      TEventCode aType )

    {

    if ( aType == EEventKeyDown )

        {

        TInt qwertyOn = 0;

#ifdef RD_INTELLIGENT_TEXT_INPUT                

        TInt keyboardLayout = EPtiKeyboard12Key;

        iAvkonRepository->Get(KAknKeyBoardLayout, keyboardLayout);            

        switch(keyboardLayout)

            {

            case EPtiKeyboardQwerty4x12:

            case EPtiKeyboardQwerty4x10:

            case EPtiKeyboardQwerty3x11:

            case EPtiKeyboardHalfQwerty:

            case EPtiKeyboardCustomQwerty:

                {

                qwertyOn = 1;

                break;

                }

            default:

                break;

            }

#endif            

        TInt err = RProperty::Set( KCRUidAvkon,

                                   KAknQwertyInputModeActive,

                                   qwertyOn );

        iAppUi->iQwertyStatus = qwertyOn;

#ifdef _DEBUG

        _LIT( KDMsg, "xxxx KAknQwertyInputModeActive err=%d" );

        RDebug::Print( KDMsg, err );

#endif

#ifdef RD_INTELLIGENT_TEXT_INPUT                

        err = RProperty::Set(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

#endif

        }

    return EKeyWasConsumed;

    }

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

// CAknServKeyFilter::HandleFlipKeyEvent

// Handles the flip events.

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

//

void CAknServKeyFilter::HandleFlipKeyEvent( TInt aCode )

    {

    if ( aCode == EKeyFlipOpen )

        {

        RProperty::Set( KPSUidUikon, KUikFlipStatus, 1 ); // flip opened

        // hack solution for mcl only, need refactory after summer vacation by SysAp

        //RProperty::Set( KPSUidHWRM, KHWRMFlipStatus, EPSHWRMFlipOpen ); // valid API

        }

    else

        {

        RProperty::Set( KPSUidUikon, KUikFlipStatus, 0 ); // flip closed

        // hack solution for mcl only, need refactory after summer vacation by SysAp

        //RProperty::Set( KPSUidHWRM, KHWRMFlipStatus, EPSHWRMFlipClosed ); // valid API

        }

    }

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

// CAknServKeyFilter::HomeTickL

// Static callback method of the long keypress detector of applications key.

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

//

TInt CAknServKeyFilter::HomeTickL( TAny* aThis )

    {

    static_cast<CAknServKeyFilter*>( aThis )->DoHomeTickL();

    return 0;   // do not continue

    }

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

// CAknServKeyFilter::HomeTickL

// Callback method of the long keypress detector of applications key.

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

//

void CAknServKeyFilter::DoHomeTickL()

    {

    iHomeTimer->Cancel();

    delete iHomeTimer;

    iHomeTimer = NULL;

    // method return value ignored (not needed)

    // leave should not happen in this level

    TRAP_IGNORE( iAppUi->HandleLongAppsKeyPressL() );

    }

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

// CAknServKeyFilter::CaptureHardwareStateKeysL

// Reads the hardware state keys of supported layouts and appends them

// to the captured keys.

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

//

void CAknServKeyFilter::CaptureHardwareStateKeysL()

    {

    RWindowGroup& groupWin = iCoeEnv->RootWin();

    CAknLayoutConfig::THardwareStateArray hwStates =

        CAknSgcClient::LayoutConfig().HardwareStates();

    TInt count = hwStates.Count();

    iHardwareStateKeyCaptures.ReserveL( count );