/*

* Copyright (c) 2002-2010 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:  App UI

*

*/

#include <eikbtgpc.h>

#include "aknappui.h"

#include <avkon.rsg>

#include <avkon.hrh>

#include <eikenv.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <AknDef.h>

#include "aknconsts.h"

#include <aknsoundsystem.h>

#include <AknSgcc.h>

#include <AknSettingCache.h>

#include <AknWsEventObserver.h>

#include <apgwgnam.h>

#include <babitflags.h>

#include <hlplch.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>   // KAknQwertyInputModeActive (and others)

#include <AknFepInternalCRKeys.h>  // KAknFepHashKeySelection

#include <settingsinternalcrkeys.h> // KSettingsAutolockStatus

#include <cenrepnotifyhandler.h>

#include <e32property.h>

#include <ctsydomainpskeys.h>

#include <eikmenub.h>

#include <eikcolib.h>

#include <eikapp.h>

#include <eikon.hrh>

#include <AknsUtils.h>

#include <AknsConstants.h>

#include "aknshut.h"

#include "aknenv.h"

#include <aknsoundsystem.h>

#include "aknanimdllstd.h"

#include <textresolver.h>

#include <AknGlobalNote.h>

#include <apgcli.h>

#include <AknUtils.h>

#include <AknBidiTextUtils.h>

#include <aknconsts.h>

#include <AknCapServerClient.h>

#include "AknDebug.h"

#include <AknPanic.h>

#include <akntranseffect.h> // for Transition effect enumerations

#include <aknlayoutscalable_avkon.cdl.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include <aknSDData.h>

#include <secondarydisplay/AknSecondaryDisplayDefs.h>

#include <startupdomainpskeys.h>

#include "transitionmanager.h"

#include <PtiEngine.h>   

#include <PtiKeyMappings.h> 

#include <akntoolbar.h>

#include <eikdialg.h>

#ifdef RD_SCALABLE_UI_V2

#include <AknPriv.hrh>

#include <akntouchpane.h>

#endif

#include <touchfeedbackadaptation.h>

#include <touchfeedback.h>

#include <aknpointereventmodifier.h>

#include <aknitemactionmenuregister.h>

// UIDS for dialler view

const TUid KPhoneAppUid = { 0x100058B3 };

const TUid KAknDiallerViewUid = {0x10282D81};

const TUid KDiallerVievCommand = {0x1};

const TUid KVoiceUiUID = { 0x101F8543 };

_LIT( KVoiceDialApplication, "z:\\sys\\bin\\vuivoicerecognition.exe" ); //SIVC

#include "akncompaif.h" // touch compatibility mode

const TUid KActiveIdle2Uid = {0x102750F0};

const TUid KActiveIdleView = {0x1};

#ifndef APPLICATIONORIENTATION_H

const TUid KCRUidDefaultAppOrientation = {0x200159ED};

#endif

//const TInt KAknAppUiViewsGranularity = 1;

NONSHARABLE_CLASS(CAknAppUiExtension)

  : public CBase, 

    public MCenRepNotifyHandlerCallback,

    public MCoeViewActivationObserver

    {

public:

    static CAknAppUiExtension* NewL();

    ~CAknAppUiExtension();

    // From MCenRepNotifyHandlerCallback

    void HandleNotifyInt(TUint32 aId, TInt aNewValue); 

    // from MCoeViewActivationObserver

    void HandleViewActivation(const TVwsViewId& aNewlyActivatedViewId,const TVwsViewId& aViewIdToBeDeactivated);

private: 

    CAknAppUiExtension();

    void ConstructL();  

public:    

    MAknAliasKeyCodeResolver* iAknAliasKeyCodeResolver;

    // Handle to Central Repository.

    CRepository* iCenRep;    

    // For CenRep value change notifications. 

    CCenRepNotifyHandler* iCenRepNotifyHandler;        

    // PubSub property for qwerty mode status.

    RProperty iQwertyModeStatusProperty;

    // more app UI flags    

    enum TAknExtFlags

        {

        EHashKeyDown,       // Indicates whether hash key is down.    

        EHashKeyMarking,    // Caches the value of CenRep key KAknFepHashKeySelection.

        ESimulatingEvent,

        EAppIsHiddenInBackground,

        EFocusLost

        };

    TBitFlags iFlags;

    TInt iDisabledScanCode;

    TUid iLastActivatedViewId;

    };

CAknAppUiExtension* CAknAppUiExtension::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }    

CAknAppUiExtension::CAknAppUiExtension():

    iDisabledScanCode( -1 )

    {

    }

void CAknAppUiExtension::ConstructL()

    {

    // Start listening a CenRep key indicating whether hash key selection is active.

    TRAPD(err, iCenRep = CRepository::NewL(KCRUidAknFep));

    if (err == KErrNone)

        {

        iCenRepNotifyHandler = CCenRepNotifyHandler::NewL(*this,

            *iCenRep,

            CCenRepNotifyHandler::EIntKey,

            KAknFepHashKeySelection);

        iCenRepNotifyHandler->StartListeningL();

        TBool hashKeyMarking;

        if (iCenRep->Get(KAknFepHashKeySelection, hashKeyMarking) == KErrNone)

            iFlags.Assign(EHashKeyMarking, hashKeyMarking);

        } 

    // Attach to qwerty mode status property. Hash key marking is disabled when qwerty 

    // mode is active. Attach success also even if the value doesn't exist.

    User::LeaveIfError(iQwertyModeStatusProperty.Attach(KCRUidAvkon, KAknQwertyInputModeActive));

    }     

CAknAppUiExtension::~CAknAppUiExtension()

    {

    // Stop listening CenRep.

    if (iCenRepNotifyHandler)

        {

        iCenRepNotifyHandler->StopListening();

        }

    delete iCenRepNotifyHandler;

    delete iCenRep; 

    // Close PubSub handle.

    iQwertyModeStatusProperty.Close();

    }

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

// CAknAppUiExtension::HandleNotifyInt

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

//

void CAknAppUiExtension::HandleNotifyInt(TUint32 aId, TInt aNewValue)

    {

    if (aId == KAknFepHashKeySelection)

        {

        iFlags.Assign(EHashKeyMarking, aNewValue);

        }

    }

void CAknAppUiExtension::HandleViewActivation(const TVwsViewId& aNewlyActivatedViewId,const TVwsViewId& aViewIdToBeDeactivated)

    {

    CEikonEnv& eikEnv = *CEikonEnv::Static();

    TUid thisAppUid = eikEnv.EikAppUi()->Application()->AppDllUid();

    // if changing from another app to a new view in this app, clear the redraw stores

    if (aViewIdToBeDeactivated.iAppUid != thisAppUid &&

         ( (iLastActivatedViewId != TUid::Null() && 

         aNewlyActivatedViewId.iViewUid != iLastActivatedViewId) ||

         eikEnv.ScreenDevice()->CurrentScreenMode() != CAknSgcClient::ScreenMode().ModeNumber()))

        eikEnv.WsSession().ClearAllRedrawStores();

    if (aNewlyActivatedViewId.iAppUid == thisAppUid)

        iLastActivatedViewId = aNewlyActivatedViewId.iViewUid;

    }

enum TAknAppUiBaseFlags

    {

    EEmbedded,

    EFaded,

    EContainerWasForeground,

    EContainerWasPartialForeground,

    EFullScreen,

    EPartialForeground,

    ELayoutAwareApp, // Deprecated

    EOrientationSpecified,

    EOrientationLandscape,

    EOrientationAutomatic,

    EMSKEnabled,

    EForegroundOrPartialForeground,

    EAppClosing,

    ETouchCompatible,

    ESingleClickCompatible

    };

// CLASS DECLARATION

/** 

 * A class to launch the dialler or SIVC from non used send key press

 */ 

NONSHARABLE_CLASS ( CAknDiallerLauncher ) : public CCoeControl

    {

public:

    static CAknDiallerLauncher* NewL(CAknCompaIf*& aCompaIf);

    ~CAknDiallerLauncher();

    void SetFlags( const TInt aFlags );

private: // From CCoeControl

    TKeyResponse OfferKeyEventL(const TKeyEvent &aKeyEvent, TEventCode aType);

private:

    CAknDiallerLauncher(CAknCompaIf*& aCompaIf);

    void ConstructL();

    void StartKeyTimerL();

    void StopKeyTimer();

    void LaunchDiallerL();

    void LaunchVoiceCommandL();

    static TInt ReportLongPressL( TAny* aThis );

private:

    CPeriodic* iKeyTimer;

    CAknCompaIf*& iCompaIf; // touch compatibility mode

    TInt iKeyFlags;

    };

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

// CAknDiallerLauncher::NewL

// Two-phased constructor.

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

//

CAknDiallerLauncher* CAknDiallerLauncher::NewL(CAknCompaIf*& aCompaIf)

    {

    CAknDiallerLauncher* self = new ( ELeave ) CAknDiallerLauncher(aCompaIf);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknDiallerLauncher::CAknDiallerLauncher

// C++ default constructor.

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

//

CAknDiallerLauncher::CAknDiallerLauncher(CAknCompaIf*& aCompaIf):

    iCompaIf(aCompaIf)

    {

    }

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

// CAknDiallerLauncher::ConstructL

// Symbian 2nd phase constructor.

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

//

void CAknDiallerLauncher::ConstructL()

    {

    iKeyFlags = 0;

    }

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

// Destructor

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

//

CAknDiallerLauncher::~CAknDiallerLauncher()

    {

    delete iKeyTimer;

    }

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

// CAknDiallerLauncher::SetFlags

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

//

void CAknDiallerLauncher::SetFlags( const TInt aFlags )

    {

    iKeyFlags = aFlags;

    }

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

// CAknDiallerLauncher::OfferKeyEventL

// Returns always EKeyWasNotConsumed

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

//

TKeyResponse CAknDiallerLauncher::OfferKeyEventL( 

    const TKeyEvent &aKeyEvent, TEventCode aType )

    {    

    if ( aKeyEvent.iScanCode != EStdKeyYes ) 

        { 

        return EKeyWasNotConsumed;

        }

    if ( iKeyFlags & CAknAppUiBase::EDisableSendKeyLong && 

         iKeyFlags & CAknAppUiBase::EDisableSendKeyShort )

        {

        return EKeyWasNotConsumed;

        }

    // Check if autolock is on (if there is a an active call ongoing

    // and sendkey is pressed, keyevent ends up here and must be dismissed

    // to avoid opening dialler)

    CRepository* repository = CRepository::NewL(KCRUidSecuritySettings); 

    TInt lockStatus(0);

    TInt lockStatusErr = repository->Get(KSettingsAutolockStatus, lockStatus);

    delete repository;

    repository = NULL;

    // If lock is on, nothing should be done so we can just return.

    // Also return if status could't be fetched (just in case).

    if ( lockStatus == 1 || lockStatusErr != KErrNone )

        {

        return EKeyWasNotConsumed;

        }

    TInt curVal( 0 );

    TInt err = RProperty::Get( KPSUidStartup, KPSStartupUiPhase, curVal );

    if ( curVal != EStartupUiPhaseAllDone )

        {

        return EKeyWasNotConsumed;

        }

    // if it's alerting & Ringing status, ignore the send key event

    TInt callVal( 0 );

    TInt errCall = RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callVal );

    if ( err == KErrNone  && ( callVal == EPSCTsyCallStateDialling || EPSCTsyCallStateRinging == callVal ) )

        {

        return EKeyWasNotConsumed;

        }

    // if it's emerency calls status, ignore the send key event

    TInt emergVal( 0 );

    TInt errEmerg = RProperty::Get( KPSUidCtsyEmergencyCallInfo, KCTSYEmergencyCallInfo, emergVal );

    if ( errEmerg == KErrNone  && emergVal == 1 )

        {

        return EKeyWasNotConsumed;

        }

    if ( aType == EEventKeyDown )

        {

        StartKeyTimerL();                

        }

    if ( aType == EEventKeyUp && 

         iKeyTimer && iKeyTimer->IsActive() )

        {

        StopKeyTimer();

        if ( iKeyFlags & CAknAppUiBase::EDisableSendKeyShort )

            {

            return EKeyWasNotConsumed;

            }

        TBool launch = AknLayoutUtils::PenEnabled();

        // In touch compatibility mode current layout (QVGA) doesn't have

        // pen enabled. But dialler can be launched as it executes in

        // "native" layout where pen is enabled.

        launch = launch || ( iCompaIf && iCompaIf->IsForeground() );

        if ( launch )

            {

            LaunchDiallerL();

            }

        }

    return EKeyWasNotConsumed;

    }    

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

// CAknDiallerLauncher::StartKeyTimerL

// Starts the timer for the long press. Timer is constructed when used for the

// first time

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

//

void CAknDiallerLauncher::StartKeyTimerL()

    {

    if ( !iKeyTimer )

        {

        iKeyTimer = CPeriodic::NewL( CActive::EPriorityStandard );

        }

    else if ( iKeyTimer->IsActive() )

        {

        iKeyTimer->Cancel();

        }

    iKeyTimer->Start( KAknKeyboardRepeatInitialDelay,

                      KAknKeyboardRepeatInitialDelay, 

                      TCallBack ( ReportLongPressL, this ) );

    }

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

// CAknDiallerLauncher::StopKeyTimer

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

//

void CAknDiallerLauncher::StopKeyTimer()

    {

    if ( iKeyTimer && iKeyTimer->IsActive() )

        {

        iKeyTimer->Cancel();

        }

    }

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

// CAknDiallerLauncher::ReportLongPressL

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

//

TInt CAknDiallerLauncher::ReportLongPressL( TAny* aThis )

    {

    CAknDiallerLauncher* self = 

        reinterpret_cast <CAknDiallerLauncher* > ( aThis );

    self->StopKeyTimer();

    if ( iAvkonAppUi->IsForeground() )

        {

        self->LaunchVoiceCommandL();

        }

    return 1; // CPeriodic ignores return value

    }

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

// CAknDiallerLauncher::LaunchDiallerL

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

//

void CAknDiallerLauncher::LaunchDiallerL()

    {

    TVwsViewId diallerView( KPhoneAppUid, KAknDiallerViewUid );

    iAvkonAppUi->CreateActivateViewEventL( diallerView,

                KDiallerVievCommand, KNullDesC8() );

    }

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

// CAknDiallerLauncher::LaunchVoiceCommandL

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

//    

void CAknDiallerLauncher::LaunchVoiceCommandL()

    {

    if ( iKeyFlags & CAknAppUiBase::EDisableSendKeyLong )

        {

        return;

        }

    // Touch compatibility mode

    if (iCompaIf)

        {

        // Voice command launches itself in QHD layout on top of compa-mode

        // application. The screen gets messed up. Compa-mode application is

        // using wserv offset support to switch screen right (center the QVGA

        // application window). When it shows behind another non-offsetting

        // application, the shith is lost and screen is messed up.

        // A workaroundfor for this is to switch idle screen to foreground

        // before voice commander is launched.

        TVwsViewId idleView(KActiveIdle2Uid, KActiveIdleView);

        if (iCompaIf->IsForeground())

            {

            iAvkonAppUi->CreateActivateViewEventL(idleView, KNullUid,

                KNullDesC8());

            }

        }

    TApaTaskList apaTaskList( iCoeEnv->WsSession() );

    TApaTask apaTask = apaTaskList.FindApp( KVoiceUiUID );

    if ( apaTask.Exists() )

        {

        apaTask.BringToForeground();

        }

    else

        {

    RApaLsSession apa;

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

    CleanupClosePushL( apa );