/*

* Copyright (c) 2007 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:  Controls lock states (unlocked, keylock, devicelock)

 *

*/

#include "lockappstatecontrol.h"

// child controls

#include "lockappidlecontrol.h"

#include "lockappkeyguardcontrol.h"

#include "lockappdevicelockcontrol.h"

#include "lockapppubsubobserver.h"

#include "lockappcenrepobserver.h"

#include "lockappkeycapturecontroller.h"

#include "lockappstatepublisher.h"

#include "lockappecsdetector.h"

#include "lockapputils.h"

#include <featmgr.h>

#include <settingsinternalcrkeys.h>

// #include <ScreensaverInternalPSKeys.h>

#include <ctsydomainpskeys.h>

// #include <activeidle2domainpskeys.h>

#include "GlobalWindowPriorities.h"

#include <avkon.rsg> // general avkon resources

#include <aknnotpi.rsg> // keyguard spesific resources

#include <aknsoundsystem.h>

#include <AknIncallBubbleNotify.h> // incall bubble

#include <bautils.h> // BaflUtils

#include <apgwgnam.h>

#include <keylockpolicyapi.h>

#include <hwrmdomainpskeys.h>

    TUid KUidFpsCategory = {0x1020507E};

const		TInt KFpsAuthenticationKey = 1;

// used avkon dialog resources

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

// Visibility gate WG priority's relative offset from ECoeWinPriorityAlwaysAtFront

// Now equals -1000 to be an absolute 0.

const TInt KGlobalWindowPriority_LockVisibilityGate = -1000;

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

// Standard Symbian OS construction sequence

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

CLockAppStateControl* CLockAppStateControl::NewL( )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destruction releases key captures.

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

CLockAppStateControl::~CLockAppStateControl( )

    {

    // localized resources are freed

    if ( iResourceFileOffset )

        {

        // We implicitely trust that eikon env exists (though in practice it does not make the

        // difference as this destructor is really never called...)

        iEikonEnv->DeleteResourceFile(iResourceFileOffset);

        }

    // PuSub observers

    if ( iPSScreenSaverObserver )

        {

        delete iPSScreenSaverObserver;

        iPSScreenSaverObserver = NULL;

        }

    if ( iPSTelephonyObserver )

        {

        delete iPSTelephonyObserver;

        iPSTelephonyObserver = NULL;

        }

    if ( iPSGripObserver )

        {

        delete iPSGripObserver;

        iPSGripObserver = NULL;

        }

    if ( iPSFPSObserver )

        {

        delete iPSFPSObserver;

        iPSFPSObserver = NULL;

        }

    CLockAppKeyCaptureController::Destroy( );

    if ( iIncallBubble )

        {

        delete iIncallBubble;

        iIncallBubble = NULL;

        }

    if ( iSoundsMuted )

        {

        MuteSounds( EFalse );

        }

    }

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

// The uninitialized status is ELockNoteActive.

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

CLockAppStateControl::CLockAppStateControl( ) :

    iLockStatus( ELockNotActive),

    iWGEventGate( iEikonEnv->RootWin()),

    iEnvState( 0 )

    {

    // no implementation required

    }

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

// All lock state observers are created here.

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

void CLockAppStateControl::ConstructL( )

    {

    INFO( "CLockAppStateControl::ConstructL started" );

    // creates observer list

    BaseConstructL( );

    // localized resources are loaded

    TFileName resourceFile;

    resourceFile.Append( KRESOURCEFILE );

    BaflUtils::NearestLanguageFile( iEikonEnv->FsSession(), resourceFile );

    iResourceFileOffset = iEikonEnv->AddResourceFileL(resourceFile);

    // fetch power key configuration from feature manager

    FeatureManager::InitializeLibL( );

    iFeatureNoPowerkey = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );

    FeatureManager::UnInitializeLib( );

    // allow autoforwarding for the application (stacked bringforwards)

    iEikonEnv->SetAutoForwarding( ETrue );

    CLockAppKeyCaptureController::InitL( iEikonEnv->RootWin() );

    // Create second windowgroup for visibility gate

    CreateVisibilityGateWgL( );

    INFO_1( "CLockAppStateControl - EventGate WgID = %d", iWGEventGate.WindowGroupId() );

    INFO_1( "CLockAppStateControl - VisibilityGate WgID = %d", iWGVisibilityGate.WindowGroupId() );

    //

    // Construct Controls

    //

    iIdle = CLockAppIdleControl::NewL( *this );

    AddObserverL( iIdle ); // ownership is transfered

    iCurrentControl = iIdle;

    iCurrentControl->HandleActivateEventL( iEnvState );

    iKeyguard = CLockAppKeyguardControl::NewL( *this );

    AddObserverL( iKeyguard ); // ownership is transfered

    RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );

    iDevicelock = CLockAppDevicelockControl::NewL( *this, iWGVisibilityGate ); 

    RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );

    iDevicelock->ConnectToPhoneL( iWGVisibilityGate );

    RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );

    AddObserverL( iDevicelock ); // ownership is transfered

    // Emergency support

    iLockEcsDetector = CLockAppEcsDetector::NewL( );

    AddObserverL( iLockEcsDetector ); // ownership is transfered

    // Lock state publisher

    CLockAppStatePublisher* lockPublisher = CLockAppStatePublisher::NewL( );

    AddObserverL( lockPublisher ); // ownership is transfered

    // PubSub observers

		/* This is not used any more because screensavers are removed now

    iPSScreenSaverObserver = CLockAppPubSubObserver::NewL( this, KPSUidScreenSaver, KScreenSaverOn );

    */

    iPSTelephonyObserver = CLockAppPubSubObserver::NewL( this, KPSUidCtsyCallInformation, KCTsyCallState );

    iPSGripObserver = CLockAppPubSubObserver::NewL( this, KPSUidHWRM, KHWRMGripStatus );

    iPSFPSObserver = CLockAppPubSubObserver::NewL( this, KUidFpsCategory, KFpsAuthenticationKey );

    // Call bubble

    iIncallBubble = CAknIncallBubble::NewL( );

    ActivateL( );

    INFO( "CLockAppStateControl::ConstructL completed" );

    }

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

// Create visibility gate window group

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

void CLockAppStateControl::CreateVisibilityGateWgL( )

    {

    INFO( "CLockAppStateControl - CreateVisibilityGateL" );

    iWGVisibilityGate = RWindowGroup( iCoeEnv->WsSession( ) );

    User::LeaveIfError( iWGVisibilityGate.Construct( (TUint32) &iWGVisibilityGate ) );

    /* hide this window group from the app switcher */

    iWGVisibilityGate.SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );

    iWGVisibilityGate.EnableReceiptOfFocus( EFalse );

    /*CApaWindowGroupName* wn = CApaWindowGroupName::NewLC( ws );

    wn->SetHidden( ETrue );

    wn->SetWindowGroupName( iWGVisibilityGate );

    CleanupStack::PopAndDestroy( wn );*/

    }

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

// This method should be called to enable keyguard.

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

TInt CLockAppStateControl::EnableKeyguardL( TBool aWithNote )

    {

    INFO_1( "CLockAppStateControl::EnableKeyguardL aWithNote= %d", aWithNote );

    TInt err = CheckIfLegal( ELockAppEnableKeyguard );

    if ( err == KErrNone && !iKeyguard->ActivationAllowedL( ) )

        {

        err = KErrPermissionDenied;

        }

    if ( err == KErrNone )

        {

        PostStatusChangeL( EKeyguardActive );

        __ASSERT_DEBUG( iLockStatus == EKeyguardActive, DoPanic(ELockIllegalState));

        INFO( "CLockAppStateControl - Keyguard Enabled" );

        if ( aWithNote )

            {

            iKeyguard->DisplayKeysLockedNote( );

            }

        }

    return err;

    }

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

// This method should be called to disable keyguard.

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

TInt CLockAppStateControl::DisableKeyguardL( TBool aWithNote )

    {

    INFO_1( "CLockAppStateControl::DisableKeyguardL aWithNote= %d", aWithNote );

    TInt err = CheckIfLegal( ELockAppDisableKeyguard );

    if ( err == KErrNone && !iKeyguard->DeActivationAllowedL( ) )

        {

        err = KErrPermissionDenied;

        }

    if ( err == KErrNone )

        {

        PostStatusChangeL( ELockNotActive );

        __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));

        INFO( "CLockAppStateControl - Keyguard Disabled" );

        if ( aWithNote )

            {

            iKeyguard->DisplayKeysActiveNote( );

            }

        }

    return err;

    }

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

// This method should be called to enable device lock.

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

TInt CLockAppStateControl::EnableDevicelockL( TDevicelockReason aReason )

    {

    INFO_1( "CLockAppStateControl::EnableDevicelockL aReason= %d", aReason );

    RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );

    TInt err = CheckIfLegal( ELockAppEnableDevicelock );

    if ( err == KErrNone && !iDevicelock->ActivationAllowedL( aReason ) )

        {

        err = KErrPermissionDenied;

        }

    if ( err == KErrNone )

        {

        PostStatusChangeL( EDevicelockActive );

        __ASSERT_DEBUG( iLockStatus == EDevicelockActive, DoPanic(ELockIllegalState));

        iDevicelock->SetLockingReason( aReason );

        INFO( "CLockAppStateControl - Devicelock Enabled" );

        }

    return err;

    }

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

// This method should be called to disable device lock.

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

TInt CLockAppStateControl::DisableDevicelockL( )

    {

    INFO_1( "CLockAppStateControl::DisableDevicelockL 1= %d", 1 );

    TInt err = CheckIfLegal( ELockAppDisableDevicelock );

    if ( err == KErrNone && !iDevicelock->DeActivationAllowedL( ) )

        {

        err = KErrPermissionDenied;

        }

    if ( err == KErrNone )

        {

        PostStatusChangeL( ELockNotActive );

        __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));

        INFO( "CLockAppStateControl - Devicelock Disabled" );

        }

    return err;

    }

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

// Checks if offer keyguard is allowed and if it is, offers to lock keyguard.

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

TInt CLockAppStateControl::OfferKeyguard( )

    {

    INFO_1( "CLockAppStateControl::OfferKeyguard 1= %d", 1 );

    TInt err = CheckIfLegal( ELockAppOfferKeyguard );

    if ( err == KErrNone )

        {

        __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));

        INFO( "CLockAppStateControl - OfferKeyguard" );

        iIdle->OfferKeyLock( );

        }

    return err;

    }

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

// Shows keys locked note if keyguard is enabled.

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

TInt CLockAppStateControl::ShowKeysLockedNote( )

    {

    INFO_1( "CLockAppStateControl::ShowKeysLockedNote 1= %d", 1 );

    TInt err = CheckIfLegal( ELockAppShowKeysLockedNote );

    if ( err == KErrNone )

        {

        __ASSERT_DEBUG( iLockStatus == EKeyguardActive, DoPanic(ELockIllegalState));

        INFO( "CLockAppStateControl - ShowKeysLockedNote" );

        iKeyguard->DisplayLockedNote( );

        }

    return err;

    }

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

// A method for returning the lock status.

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

TLockStatus CLockAppStateControl::LockStatus( ) const

    {

    INFO_1( "CLockAppStateControl::LockStatus iLockStatus= %d", iLockStatus );

    return iLockStatus;

    }

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

// A method for returning the environment status bitmask.

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

TUint CLockAppStateControl::EnvironmentStatus( ) const

    {

    return iEnvState;

    }

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

// A method for executing different internal tests.

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

TInt CLockAppStateControl::ExecuteInternalTest( )

    {

#ifdef _DEBUG

    return iLockEcsDetector->TestEcsNote( );

#else

    return KErrNone;

#endif

    }

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

// Number of owned UI controls (idle, keyguard, devicelock)

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

TInt CLockAppStateControl::CountComponentControls( ) const

    {

    return 3;

    }

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

// Owned UI controls (idle, keyguard, devicelock)

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

CCoeControl* CLockAppStateControl::ComponentControl( TInt aIndex ) const

    {

    RDebug::Printf( "%s %s (%u) aIndex=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aIndex );

    switch ( aIndex )

        {

        case 0:

            return iIdle;

        case 1:

            return iKeyguard;

        case 2:

     		    RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );

            return iDevicelock;

        default:

            return NULL;

        }

    }

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

// Handle window-server events

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

void CLockAppStateControl::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* /*aDestination*/)

    {

    TInt type = aEvent.Type( );

    	RDebug::Printf( "%s %s (%u) type=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, type );

    switch ( type )

        {

        case KAknFullOrPartialForegroundLost: // partial or full fg lost

        case KAknFullOrPartialForegroundGained: // partial or full fg gained

            {

    				RDebug::Printf( "%s %s (%u) type=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, type );

            RWsSession& ws = iCoeEnv->WsSession( );

            TFileName windowName;

            TInt fwgid = ws.GetFocusWindowGroup( );

            ws.GetWindowGroupNameFromIdentifier( fwgid, windowName );

            INFO_3( "CLockAppStateControl::HandleWsEventL type: %d - FocusWg: %d %S", type, fwgid, &windowName);

            }

            break;

        case EEventKeyUp:

        case EEventKey:

        case EEventKeyDown:

        		{

        		RDebug::Printf( "%s %s (%u) EEventKey*=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, EEventKeyDown );

        		TKeyEvent* aKeyEvent = aEvent.Key();

        		TKeyResponse response = OfferKeyEventL( *aKeyEvent, (TEventCode)type );

        		}

            break;

        default:

            break;

        }

    }

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

// From @c CAknAppUiBase. Overriden the parent method, because otherwise

// the main lock state control would not receive the call, because is is not

// window-owning control (=without window->not visible). The call is needed

// because the main state control owns window-owning child controls.

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

void CLockAppStateControl::HandleResourceChange( TInt aType )

    {

    // these would not normally get handleresource call since they do not own window

		RDebug::Printf( "%s %s (%u) aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aType );

	if(iIdle)

		iIdle->HandleResourceChange( aType );

	if(iKeyguard)

		iKeyguard->HandleResourceChange( aType );

	if(iDevicelock)

		iDevicelock->HandleResourceChange( aType );

    // call parent

    CCoeControl::HandleResourceChange( aType );

    }

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

// Update the environment state variable with the event.

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

TBool CLockAppStateControl::HandleEnvironmentChange( TUint aEventMask, TBool aEnable )

    {

    // check if there will be a change

    if ( IsBitFieldSet( iEnvState, aEventMask ) != aEnable )

        {

        // set the bit-field

        SetBitField( iEnvState, aEventMask, aEnable );

        // notify current control

        __ASSERT_DEBUG( iCurrentControl, DoPanic(ELockIllegalState));

        iCurrentControl->HandleEnvironmentChange( iEnvState, aEventMask );

        // return true because the environment changed

        return ETrue;

        }

    return EFalse;

    }

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

// Handle all Central Repository observer callbacks.

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

void CLockAppStateControl::HandleCenRepNotify(TUid aCenRepUid, TUint32 aKeyId, TInt aValue )

    {

    	RDebug::Printf( "%s %s (%u) ???? Nothing done for aKeyId=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyId );

    INFO_3( "CLockAppStateControl::HandleCenRepNotify %d %d = %d", aCenRepUid.iUid, aKeyId, aValue );

    }

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

// Handle all Publish & Subscribe observer callbacks.

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

void CLockAppStateControl::HandlePubSubNotify(TUid aPubSubUid, TUint aKeyId, TInt aValue )

    {

    INFO_3( "CLockAppStateControl::HandlePubSubNotify %x %x = %d", aPubSubUid.iUid, aKeyId, aValue );

		/* This is not used any more because screensavers are removed now

    INFO_3( "CLockAppStateControl::HandlePubSubNotify KPSUidScreenSaver=%x KPSUidCtsyCallInformation=%x KPSUidAiInformation=%x", KPSUidScreenSaver, KPSUidCtsyCallInformation, KPSUidAiInformation );

    INFO_3( "CLockAppStateControl::HandlePubSubNotify KPSUidHWRM=%x KHWRMGripStatus=%x KPSUidAiInformation=%x", KPSUidHWRM, KHWRMGripStatus, KPSUidAiInformation );

    if ( aPubSubUid == KPSUidScreenSaver )

        {

        switch ( aKeyId )

            {

            case KScreenSaverOn:

                {

                INFO_1("CLockAppStateControl::ScreenSaver - %d", (aValue > 0));

                HandleEnvironmentChange( KLockAppEnvScreenSaverOn, (aValue > 0) );

                }

                break;

            default:

                break;

            }

        }

    else if ( aPubSubUid == KPSUidCtsyCallInformation )

        {

        switch ( aKeyId )

            {

            case KCTsyCallState:

                {

                PrintCallState( aValue );

                HandleEnvironmentChange( KLockAppEnvPhonecallOngoing, (aValue > EPSCTsyCallStateNone) );

                }