/*
* 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:
*
*/


#include <aknappui.h>
#include <aknkeylock.h>
#include <AknUtils.h>
#include <activitymanager.h>
#include <AknNotifierController.h>
#include <centralrepository.h> 
#include <avkondomainpskeys.h>
#include <e32property.h>
#include <PSVariables.h>
#include <startupdomainpskeys.h>
#include <ctsydomainpskeys.h>
#include <activeidle2domainpskeys.h>
#include <coreapplicationuisdomainpskeys.h>
#include <ScreensaverInternalPSKeys.h>
#include <hwrmdomainpskeys.h>
#include "AutoKeyguardCenRepI.h"
#include "AutoKeyguardObserver.h"
#include "AutolockPrivateCRKeys.h"
#include "AutolockAppUiInterface.h"

const TInt AutoKeyguardOff(60000);
// Screensaver "On" status value
const TInt KSsOn = 1;
// Screensaver started fron idle status value
const TInt KSsStartedFromIdle = 1;
//Flip open
const TInt KFlipOpen = 1;

// ================= MEMBER FUNCTIONS =======================
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::NewL()
// ----------------------------------------------------------
//

CAutoKeyguardObserver* CAutoKeyguardObserver::NewL( MAutolockAppUiInterface* aAppUiI )
	{
	#ifdef RD_AUTO_KEYGUARD
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::NewL() BEGIN"));
    #endif
	CAutoKeyguardObserver* self = new (ELeave) CAutoKeyguardObserver( aAppUiI );
	CleanupStack::PushL(self);
	self->ConstructL(self);
	CleanupStack::Pop(); //self
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::NewL() END"));
    #endif
	return self;
	#else
	return NULL;
	#endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::CAutoKeyguardObserver()
// C++ default constructor
// ----------------------------------------------------------
// 
CAutoKeyguardObserver::CAutoKeyguardObserver( MAutolockAppUiInterface* aAppUiI ):
    iAppUiI( aAppUiI )
	{
	}

//
// ----------------------------------------------------------
// CAutoKeyguardObserver::ConstructL()
// Symbian OS default constructor
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::ConstructL(CAutoKeyguardObserver* aObserver)
	{
	#ifdef RD_AUTO_KEYGUARD
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::ConstructL() BEGIN"));
    #endif	
	//Central Repository handler
    iCenRepI = CAutoKeyguardCenRepI::NewL(aObserver);
	// Activitymanager
	iActivityManager = CUserActivityManager::NewL(CActive::EPriorityStandard);
	StartActivityMonitoringL();
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::ConstructL() END"));
    #endif
    #else // !RD_AUTO_KEYGUARD
    iCenRepI = NULL;
	iActivityManager = NULL;
    #endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::StartActivityMonitoringL()
// Start monitoring user activity
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::StartActivityMonitoringL()
	{
	#ifdef RD_AUTO_KEYGUARD	
	SetActivityManagerL();
	#endif //RD_AUTO_KEYGUARD
	}

//
// ----------------------------------------------------------
// CAutoKeyguardObserver::StopActivityMonitoring()
// Stop monitoring user activity
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::StopActivityMonitoring()
	{
	#ifdef RD_AUTO_KEYGUARD
	CancelActivityManager();
	#endif // RD_AUTO_KEYGUARD
	}

//
// ----------------------------------------------------------
// CAutoKeyguardObserver::SetActivityManagerL()
// Initializes activymanager   
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::SetActivityManagerL()
	{
	#ifdef RD_AUTO_KEYGUARD
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::SetActivityManagerL() BEGIN"));
    #endif
	if (AutoKeyguardTimeout() )
		{
		#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::SetActivityManagerL() ON: Start manager"));
    	#endif
		iActivityManager->Start(AutoKeyguardTimeout(), TCallBack(HandleInactiveEventL,this), 
								TCallBack(HandleActiveEventL,this));
		}
	else
		{
		#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::SetActivityManagerL() OFF: Start manager"));
    	#endif
		iActivityManager->Start(AutoKeyguardOff, TCallBack(HandleInactiveEventL,this), 
								TCallBack(HandleActiveEventL,this));
		}

	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::SetActivityManagerL() END"));
    #endif
    #endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::CancelActivityManager()
// UnInitializes activymanager   
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::CancelActivityManager()
	{
	#ifdef RD_AUTO_KEYGUARD
    if ( iActivityManager )
        {
	    iActivityManager->Cancel();
        }
    #endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::~CAutoKeyguardObserver()
// Destructor   
// ----------------------------------------------------------
//
CAutoKeyguardObserver::~CAutoKeyguardObserver()
	{
	#ifdef RD_AUTO_KEYGUARD
	if(iCenRepI)
    	delete iCenRepI;
	if(iActivityManager)
		{
		StopActivityMonitoring();
		delete iActivityManager;
		iActivityManager = NULL;
		}
	#endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::AutoKeyguardTimeout()
// Returns current AutoKeyguard period
// ----------------------------------------------------------
//
TInt CAutoKeyguardObserver::AutoKeyguardTimeout()
	{
	#ifdef RD_AUTO_KEYGUARD
    return iCenRepI->Timeout();
    #else
    return 0;
    #endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::ResetInactivityTimeoutL()
// Gets AutoKeyguard period and starts monitoring user activity 
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::ResetInactivityTimeout()
	{
	#ifdef RD_AUTO_KEYGUARD	
	if (AutoKeyguardTimeout() )
		{
		#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::ResetInactivityTimeoutL() ON"));
    	#endif
		iActivityManager->SetInactivityTimeout(AutoKeyguardTimeout());
		}
	else
		{
		#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::ResetInactivityTimeoutL() OFF"));
    	#endif
		iActivityManager->SetInactivityTimeout(AutoKeyguardOff);
		}
	#endif //RD_AUTO_KEYGUARD
	}
//
// ----------------------------------------------------------
// CAutoKeyguardObserver::HandleActiveEventL()
// Handles Active event. Called by ActivityManager
// ----------------------------------------------------------
//
TInt CAutoKeyguardObserver::HandleActiveEventL(TAny* /*aPtr*/)
	{
	return KErrNone;
	}

//
// ----------------------------------------------------------
// CAutoKeyguardObserver::HandleInactiveEventL()
// Handles InActive event. Called by ActivityManager
// ----------------------------------------------------------
//
TInt CAutoKeyguardObserver::HandleInactiveEventL(TAny* aPtr)
	{
	#ifdef RD_AUTO_KEYGUARD
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::HandleInactiveEventL() BEGIN"));
    #endif
	if ( STATIC_CAST(CAutoKeyguardObserver*, aPtr)->AutoKeyguardTimeout() )
		{
		#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::HandleInactiveEventL() Lock"));
    	#endif
		STATIC_CAST(CAutoKeyguardObserver*, aPtr)->LockKeysL();
		}
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::HandleInactiveEventL() END"));
    #endif
    #endif //RD_AUTO_KEYGUARD
	return KErrNone;
	}

//
// ----------------------------------------------------------
// CAutoKeyguardObserver::LockKeysL()
// Locks system
// ----------------------------------------------------------
//
void CAutoKeyguardObserver::LockKeysL()
	{
	#ifdef RD_AUTO_KEYGUARD
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() BEGIN"));
    #endif
    CRepository* repository = CRepository::NewL(KCRUidAutolockConf);
    TInt keyguardConf(0);
    //Check local keyguard variation key 
    repository->Get(KAutoKeyLockConf, keyguardConf);
    delete repository;
    if(keyguardConf & KAutoKeylockFeatureIdFlipOpenDisabled)
    {
    	#if defined(_DEBUG)
    	RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Flip variation"));
    	#endif
    	TInt flipState(KFlipOpen);
    	RProperty::Get(KPSUidHWRM, KHWRMFlipStatus, flipState);
	TInt lightStatus=EForcedLightsUninitialized; 
	RProperty::Get(KPSUidCoreApplicationUIs,KLightsVTForcedLightsOn,lightStatus ); 

	//If flip is open and feature flag is on. don't lock
	if(flipState == KFlipOpen || lightStatus == EForcedLightsOn)
    	{
    		#if defined(_DEBUG)
    		RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Flip open"));
    		#endif
    		return;
    	}
    		
    }
    
	{	// REQ 414-5466 Prevention of device lock in context of Hands Free Voice UI
	TInt vuiValue = 0;
	TUid KHFVuiModePSUid = { 0x102818E7 };
	enum THFVuiModePSKeys
	    {
	    EHFVuiPSModeId = 1000
	    };
	TInt tRet = RProperty::Get(KHFVuiModePSUid, EHFVuiPSModeId, vuiValue);	// also 0 if can't get because permissions or because doesn't exists
	#if defined(_DEBUG)
		RDebug::Printf( "%s %s (%u) gatting KHFVuiModePSUid+EHFVuiPSModeId=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, tRet );
		RDebug::Printf( "%s %s (%u) vuiValue=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, vuiValue );
	#endif
	if(vuiValue)
		{
		#if defined(_DEBUG)
		RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Voice functions active. No locking possible."));
		#endif
		return;
		}
	}

	TInt value = 0;
	TBool keylockOn = EFalse;
	TBool autolockOn = EFalse;
	TBool idle = EFalse;
	TInt callState = EPSCTsyCallStateNone;
	TBool okToLock = EFalse;
	TBool screenSaverOn = EFalse;
	TBool screenSaverStertedFromIdle = EFalse;
        TBool startupOver = EFalse;
	TBool codeQueryOpen = EFalse;
    //Get keyguard status
    RProperty::Get(KPSUidAvkonDomain, KAknKeyguardStatus, value);
    keylockOn = (value == EKeyguardLocked);
    //Get call state
    RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);
    
    //See whether we are in idle
 		value = 0;   
    RProperty::Get(KPSUidAiInformation, KActiveIdleState, value);
    idle = (value == EPSAiForeground);
    idle = ETrue; // don't care about idle state. Phone should autolock on any UI, not only HomeSreeen.
    
    value = 0;
    RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, value);
    autolockOn = (value > EAutolockOff);
	
		value = 0;
	  RProperty::Get(KPSUidScreenSaver, KScreenSaverOn, value);
    screenSaverOn = (value == KSsOn);
    
    value = 0;
    RProperty::Get(KPSUidScreenSaver, KScreenSaverActivatedFromIdle, value);
    screenSaverStertedFromIdle = (value == KSsStartedFromIdle);
    
    // See if SIM is accepted
    if(idle)
    	{
	    value = 0;
	    RProperty::Get(KPSUidStartup, KPSSimStatus, value);
	    // automatic lock can't get enabled if SIM-locked.
	    if(value == ESimNotReady)
	    	idle = EFalse;
	    #if defined(_DEBUG)
	    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() KPSSimStatus state: %d"), value);
	    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() ESimUsable: %d"), ESimUsable);
	    #endif
	  	}

    //See if all the startup related queries and graphics has been displayed
    value = 0;
    RProperty::Get(KPSUidStartup, KPSStartupUiPhase, value);
    startupOver = (value == EStartupUiPhaseAllDone);
        
    #if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() startupOver: %d"), startupOver);
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Startup state: %d"), value);
    #endif
	//See if the lock code query is open
    codeQueryOpen = iAppUiI->DeviceLockQueryStatus();
    #if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() codeQueryOpen: %d"), codeQueryOpen);
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() autolockOn: %d"), autolockOn);
    #endif
    if (startupOver)
        {
		// If lock code query is open and device lock is on, cancel the query.
        // AppUi will enable keylock when the query is cancelled
        if (autolockOn && codeQueryOpen)
            {
            #if defined(_DEBUG)
            RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Query open, cancel it"));
            #endif
            iAppUiI->CancelDeviceLockQuery();
            return;
            }
        // If keylock is already ON, there is a ongoing call, 
        // autolock is already ON or phone is not in idle, don't lock.
        if (keylockOn || (callState > EPSCTsyCallStateNone) || autolockOn || !idle)
            {
        	    #if defined(_DEBUG)
    		    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Don't lock"));
    		    RDebug::Print(_L("(AUTOLOCK)keylockstatus: %d"), keylockOn);
    		    RDebug::Print(_L("(AUTOLOCK)callstate: %d"), callState);
    		    RDebug::Print(_L("(AUTOLOCK)autolockstate: %d"), autolockOn);
    		    RDebug::Print(_L("(AUTOLOCK)idlestate: %d"), idle);
    		    RDebug::Print(_L("(AUTOLOCK)screenSaverOn: %d"), screenSaverOn);
    		    RDebug::Print(_L("(AUTOLOCK)screenSaverStertedFromIdle: %d"), screenSaverStertedFromIdle);
    		    #endif
    		    //If screensaver is on, idle does not have foreground. If Screensaver was started from Idle, lock keys.
    		    if(!idle && screenSaverOn && screenSaverStertedFromIdle && (callState <= EPSCTsyCallStateNone))
    			    okToLock = ETrue;
    		    else
    		        okToLock = EFalse;
            }
         else //Otherwise there's no problem...
         		okToLock = ETrue;
        }
    
    
    if (okToLock)
        {
            #if defined(_DEBUG)
            RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Lock"));
            RDebug::Print(_L("(AUTOLOCK)keylockstatus: %d"), keylockOn);
            RDebug::Print(_L("(AUTOLOCK)callstate: %d"), callState);
            RDebug::Print(_L("(AUTOLOCK)autolockstate: %d"), autolockOn);
            RDebug::Print(_L("(AUTOLOCK)idlestate: %d"), idle);
            RDebug::Print(_L("(AUTOLOCK)screenSaverOn: %d"), screenSaverOn);
            RDebug::Print(_L("(AUTOLOCK)screenSaverStertedFromIdle: %d"), screenSaverStertedFromIdle);
            #endif
		//Tell keylock to lock itself.
		RAknKeyLock keylock;
        if ( keylock.Connect() == KErrNone )
          {
          	#if defined(_DEBUG)
    		RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() Connect OK"));
    		#endif
    			 if(AknLayoutUtils::PenEnabled())
    			     keylock.EnableWithoutNote(); //Enable without note
    			 else
    			     keylock.EnableKeyLock();
           keylock.Close();
          }
		}
	#if defined(_DEBUG)
    RDebug::Print(_L("(AUTOLOCK)CAutoKeyguardObserver::LockKeysL() END"));
    #endif
    #endif //RD_AUTO_KEYGUARD
} 
	

// END OF FILE