/*

* 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:  Avkon KeyLock Notifier

*

*/

#include "AknKeyLockNotifier.h"

#include <aknnotpi.rsg>

#include <eikenv.h>

#include <eikappui.h>

#include <apgwgnam.h>

#include <aknsoundsystem.h>

#include <avkon.rsg>

#include <eikkeysound.h>

#include <bautils.h>

#include <featmgr.h>

#include <AknTasHook.h>

#include <AknUtils.h>

#include <eikcba.h>

#include <aknnotecontrol.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <avkondomainpskeys.h> // KPSUidAvkonDomain, KAknKeyguardStatus, TAknKeyguardStatus

#include <startupdomainpskeys.h> // KStartupSecurityCodeQueryStatus

#include <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus

#include <AknNotifySignature.h>

#include "AknCapServerEntry.h"

#include <aknglobalpopupprioritycontroller.h>

#include "GlobalWindowPriorities.h"

#include <keylockpolicyapi.h>

#include <ScreensaverInternalPSKeys.h>

#include <PSVariables.h>   // Property values

#include <coreapplicationuisdomainpskeys.h>

#include <startupdomainpskeys.h>

#include <ctsydomainpskeys.h>

#include <bafindf.h>

#include "AknNotifyPlugin.hrh"

#ifdef _DEBUG

    #define TRACES(x)   x

#else

    #define TRACES(x)

#endif

/** Autolock application UID. */

const TUid KAutolockUid = { 0x100059B5 };

/** SysAp application UID. */

const TUid KSysApUid    = { 0x100058F3 };

const TInt KAknObserverListGranularity = 4;

/** Timeout for the "offer keylock" note. */

const TInt KAknOfferKeyLockTimeout = 6000000; // 6sec

/** Command ID for note focus lost. */

const TInt KNoteCmdFocusLost = 3100;

// Asterisk key code for the keylock.

const TUint KAknAsterisk = '*';

const TUint KAknChineseAsterisk = 0xFF0A;

// Timeout defined in Keylock UI spesification.

// Custom value since Avkon note TTimeout values

// don't support 1 second timeout

const TInt KKeyLockCustomShortTimeout = 1000000;

// Timeout for display locked note

const TInt KKeyLockDisplayLockedTimeout = 3000000;

_LIT( KRESOURCEFILE, "\\resource\\aknnotpi.rsc" );

_LIT_SECURITY_POLICY_C1( KWritePolicy, ECapabilityWriteDeviceData );

/**

 *  CAknKeylockScreenSaverObserver captures primary keys

 *  from screensaver when screen saver is active.

 *

 *  @lib   aknoldstylenotif.lib

 *  @since 3.2

 */

NONSHARABLE_CLASS( CAknKeylockScreenSaverObserver ): public CActive

    {

public:

    /**

    * Creates instance of the CAknKeylockScreenSaverObserver class.

    *

    * @param aWindowGroup application window group used to capture primary keys

    * @return Returns the instance just created.

    */

    static CAknKeylockScreenSaverObserver* NewL( RWindowGroup& aWindowGroup );

    /**

    * Destructor.

    */

    ~CAknKeylockScreenSaverObserver();

public:

    /**

    * Starts asynchronic listening KUidCurrentCall event

    *

    * @return KErrNone: if no errors

    * @return KErrInUse: if already listening

    */

    TInt Start();

    /**

    * Stops asynchronic listening KUidAutolockStatus event

    */

    void Stop();

public:

    /**

     *  Method handles the lock state changes.

     *

     * @param aStatus The new lock state

     */

    void SetLockStatus( TBool aKeylockEnabled, TBool aAutolockEnabled );

private: // constructors

    /**

    * C++ default constructor.

    *

    * @param aAppUi (pointer to autolock appui)

    */

    CAknKeylockScreenSaverObserver( RWindowGroup& aWindowGroup );

    /**

    * Symbian OS constructor.

    */

    void ConstructL();

private: // from CActive

    /** @see CActive::RunL() */

    void RunL();

    /** @see CActive::DoCancel() */

    void DoCancel();

private:

    /**

    * Used to capture primary keys defined in keylocking policies

    */

    void CapturePrimaryKeys( TBool aCapture );

private: // data

    // screen saver on property

    RProperty  iScreenSaverActiveProperty;

    // if screensaver is active or not

    TBool iScreenSaverActive;

    // if primary keys have been captured

    TBool iCaptured;

    // locking states

    TBool iKeylockEnabled;

    TBool iAutolockEnabled;

    // left softkey capture

    TInt iLeftSoftKey;

    // a reference to application window group

    RWindowGroup& iWindowGroup;

    // keylockpolicy support (not owned)

    CKeyLockPolicyApi* iUnlockPolicyApi;

    // keylockpolicy support (not owned)

    CKeyLockPolicyApi* iDevicelockPolicyApi;

    // primary key captures

    RArray<TUint> iPrimaryKeyCaptures;

    };

// ===========================================================================

// class CAknKeylockScreenSaverObserver

// ===========================================================================

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

// Constructs a new entry with given values.

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

//

CAknKeylockScreenSaverObserver* CAknKeylockScreenSaverObserver::NewL(

    RWindowGroup& aWindowGroup )

    {

    CAknKeylockScreenSaverObserver* self =

        new (ELeave) CAknKeylockScreenSaverObserver( aWindowGroup );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknKeylockScreenSaverObserver::~CAknKeylockScreenSaverObserver()

    {

    Cancel();

    // Close the property handle.

    iScreenSaverActiveProperty.Close();

    // Release key captures.

    CapturePrimaryKeys( EFalse );

    // Delete policies.

    delete iUnlockPolicyApi;

    delete iDevicelockPolicyApi;

    }

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

// Starts listening to the KScreenSaverOn event.

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

//

TInt CAknKeylockScreenSaverObserver::Start()

    {

    if ( IsActive() )

        {

        return KErrInUse;

        }

    iStatus = KRequestPending;

    iScreenSaverActiveProperty.Subscribe( iStatus );

    SetActive();

    return KErrNone;

    }

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

// Stops listening to the KScreenSaverOn event.

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

//

void CAknKeylockScreenSaverObserver::Stop()

    {

    if ( !IsActive() )

        {

        return;

        }

    Cancel();

    iScreenSaverActiveProperty.Cancel();

    }

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

// C++ constructor

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

//

CAknKeylockScreenSaverObserver::CAknKeylockScreenSaverObserver(

    RWindowGroup& aWindowGroup )

    : CActive( 0 ),

      iScreenSaverActive( EFalse ),

      iCaptured( EFalse ),

      iKeylockEnabled( EFalse ),

      iAutolockEnabled( EFalse ),

      iLeftSoftKey( NULL ),

      iWindowGroup( aWindowGroup )

    {

    }

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

// Second phase constructor.

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

//

void CAknKeylockScreenSaverObserver::ConstructL()

    {

    // Add this active object to the scheduler.

    CActiveScheduler::Add( this );

    User::LeaveIfError( iScreenSaverActiveProperty.Attach( KPSUidScreenSaver,

                                                           KScreenSaverOn ) );

    // We need policies to poll primary keys.

    iUnlockPolicyApi = CKeyLockPolicyApi::NewL( EPolicyDeactivateKeyguard );

    if ( !iUnlockPolicyApi->HasConfiguration() )

        {

        delete iUnlockPolicyApi;

        iUnlockPolicyApi = NULL;

        }

    // we need policies to poll primary keys

    iDevicelockPolicyApi = CKeyLockPolicyApi::NewL( EPolicyDevicelockQuery );

    if ( !iDevicelockPolicyApi->HasConfiguration() )

        {

        delete iDevicelockPolicyApi;

        iDevicelockPolicyApi = NULL;

        }

    }

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

// From base class CActive.

// Handles change in the screen saver state.

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

//

void CAknKeylockScreenSaverObserver::RunL()

    {

    if ( iKeylockEnabled || iAutolockEnabled )

        {

        // Resubscribe before processing new value to prevent missing updates.

        Start();

        }

    TInt screenSaverState;

    iScreenSaverActiveProperty.Get( screenSaverState );

    // Primary keys are captured from screensaver when screensaver

    // is the top most application.

    if ( screenSaverState > NULL )

        {

         __ASSERT_DEBUG( !iCaptured,

                         Panic( EAknPanicKeyLockObserverAlreadyExists ) );

        iScreenSaverActive = ETrue;

        CapturePrimaryKeys( ETrue );

        }

    else

        {

        // If screensaver is disabled, stop capturing primary key events.

        if ( iScreenSaverActive )

            {

            CapturePrimaryKeys( EFalse );

            }

        iScreenSaverActive = EFalse;

        }

    }

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

// Set the lock status.

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

//

void CAknKeylockScreenSaverObserver::SetLockStatus( TBool aKeylockEnabled,

                                                    TBool aAutolockEnabled )

    {

    iKeylockEnabled  = aKeylockEnabled;

    iAutolockEnabled = aAutolockEnabled;

    if ( iKeylockEnabled || iAutolockEnabled )

        {

        // Start observing screensaver activation.

        Start();

        }

    else

        {

        if ( iScreenSaverActive )

            {

            CapturePrimaryKeys( EFalse );

            }

        // Screensaver is only observed when keylock is enabled.

        Stop();

        }

    }

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

// Capture or uncapture primary keys.

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

//

void CAknKeylockScreenSaverObserver::CapturePrimaryKeys( TBool aCapture )

    {

    if ( aCapture )

        {

        if ( iScreenSaverActive && !iCaptured )

            {

            if ( iKeylockEnabled && !iAutolockEnabled )

                {

                iCaptured = ETrue;

                // If no unlocking policy has been defined,

                // the default primary key is the left soft key.

                if ( !iUnlockPolicyApi )

                    {

                    // Capture LSK (starts unlock prosess, capturing

                    // bypasses screensaver)

                    iLeftSoftKey = iWindowGroup.CaptureKey( EKeyDevice0, 0, 0 );

                    }

                else

                    {

                    iPrimaryKeyCaptures.Reset();

                    TUint32 index( 0 );

                    TUint32 primaryKey( 0 );

                    TUint32 secondaryKey( 0 );

                    while ( iUnlockPolicyApi->GetKeyCombination( index,

                                                                 primaryKey,

                                                                 secondaryKey ) == KErrNone )

                        {

                        iPrimaryKeyCaptures.Append(

                            iWindowGroup.CaptureKeyUpAndDowns( primaryKey, 0, 0 ) );

                        index++;

                        }

                    }

                }

            else

                {

                if ( iKeylockEnabled && iAutolockEnabled )

                    {

                    iCaptured = ETrue;

                    // If no devicelock query policy has been defined,

                    // the default primary key is the left soft key.

                    if ( !iDevicelockPolicyApi )

                        {

                        // Capture LSK (starts unlock prosess,

                        // capturing bypasses screensaver).

                        iLeftSoftKey = iWindowGroup.CaptureKey( EKeyDevice0, 0, 0 );

                        }

                    else

                        {

                        iPrimaryKeyCaptures.Reset();

                        TUint32 index( 0 );

                        TUint32 primaryKey( 0 );

                        TUint32 secondaryKey( 0 );

                        while ( iDevicelockPolicyApi->GetKeyCombination( index, primaryKey, secondaryKey ) == KErrNone )

                            {

                            iPrimaryKeyCaptures.Append(

                                iWindowGroup.CaptureKeyUpAndDowns( primaryKey, 0, 0 ) );

                            index++;

                            }

                        }

                    }

                }

            }

        }

    else

        {

        if (iCaptured)

            {

            if (iLeftSoftKey > 0)

                {

                iWindowGroup.CancelCaptureKey(iLeftSoftKey); 

                }

            iLeftSoftKey = 0;

            if (iPrimaryKeyCaptures.Count() > 0)

                {

                for (TInt x = 0; x < iPrimaryKeyCaptures.Count(); x++)

                    {

                    iWindowGroup.CancelCaptureKeyUpAndDowns(iPrimaryKeyCaptures[x]);

                    }

                iPrimaryKeyCaptures.Reset();

                }

            iCaptured = EFalse;

            }

        }

    }

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

// From base class CActive.

// Cancels event listening.

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

//

void CAknKeylockScreenSaverObserver::DoCancel()

    {

    iScreenSaverActiveProperty.Cancel();

    }

// ===========================================================================

// class CAknLockedNote.

// ===========================================================================

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

// C++ constructor.

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

//

CAknLockedNote::CAknLockedNote( TInt& aLocked,

                                MEikCommandObserver* aCommandObserver )

    : CAknSleepingNote( aCommandObserver ),

      iLocked( aLocked )

    {

    AKNTASHOOK_ADD( this, "CAknLockedNote" );

    }

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

// From base class CAknSleepingNote.

// Handles a dialog button press for the button with ID aCommand.

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

//

TBool CAknLockedNote::OkToExitL( TInt aCommand )

    {

    iLocked = EFalse;

    if ( iCommandObserver )

        {

        iCommandObserver->ProcessCommandL( aCommand );

        }

    return ETrue;

    }

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

// Destructor

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

//

CAknLockedNote::~CAknLockedNote()

    {

    AKNTASHOOK_REMOVE();

    iLocked = EFalse;

    }