/*

* Copyright (c) 2002 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 <activitymanager.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <AknNotifierController.h>

#include <featmgr.h>

#include    <e32property.h>

#include	<PSVariables.h>

#include    <startupdomainpskeys.h>

#include    <coreapplicationuisdomainpskeys.h>

#include <ctsydomainpskeys.h>

#include <SCPClient.h>

#include    "AutoLockModelPS.h"  

#include	"AutolockAppUiPS.h"

#include    "AutoLockLockObserverPS.h"

#include "AutoLockCenRepI.h"

const TInt AutoLockOff(60000);

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

//

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

// CAutoLockModel::NewL()

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

//

CAutoLockModel* CAutoLockModel::NewL(CAutolockAppUi* aAppUi, TBool aLocked)

	{

	CAutoLockModel* self = new (ELeave) CAutoLockModel(aAppUi);

	CleanupStack::PushL(self);

	self->ConstructL( aLocked );

	CleanupStack::Pop(); //self

	return self;

	}

//

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

// CAutoLockModel::CAutoLockModel()

// C++ default constructor

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

// 

CAutoLockModel::CAutoLockModel(CAutolockAppUi* aAppUi) : 

 iAppUi( aAppUi ), iMonitoring(EFalse)	

	{

	}

//

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

// CAutoLockModel::ConstructL()

// Symbian OS default constructor

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

//

void CAutoLockModel::ConstructL( TBool aLocked )

	{

		FeatureManager::InitializeLibL();

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() BEGIN"));

  #endif	

    iCenRepI = CAutolockCenRepI::NewL(iAppUi);

	// lock status observer

	iLockObserver = CLockObserver::NewL(iAppUi);

	// Activitymanager

	iActivityManager = CUserActivityManager::NewL(CActive::EPriorityStandard);

	StartActivityMonitoringL();

    // In GSM the device is always unlocked.

    // In CDMA, SecClientUi will lock the device on boot-up if needed.

 	if ( aLocked == EAutolockStatusUninitialized )

	{

			RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,	EAutolockStatusUninitialized);

	}

	else

	{

	    RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,	EAutolockOff);

  }

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() END"));

    #endif

	}

	//

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

// CAutoLockModel::StartActivityMonitoringL()

// Start monitoring user activity

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

//

void CAutoLockModel::StartActivityMonitoringL()

	{	

	SetActivityManagerL();

	}

//

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

// CAutoLockModel::StopActivityMonitoring()

// Stop monitoring user activity

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

//

void CAutoLockModel::StopActivityMonitoring()

	{

	CancelActivityManager();

	}

//

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

// CAutoLockModel::SetActivityManagerL()

// Initializes activymanager   

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

//

void CAutoLockModel::SetActivityManagerL()

	{

	if (AutoLockTimeout() )

		{

		iActivityManager->Start(AutoLockTimeout(), TCallBack(HandleInactiveEventL,this), 

								TCallBack(HandleActiveEventL,this));

		}

	else

		{

		iActivityManager->Start(AutoLockOff, TCallBack(HandleInactiveEventL,this), 

								TCallBack(HandleActiveEventL,this));

		}

	}

//

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

// CAutoLockModel::CancelActivityManager()

// UnInitializes activymanager   

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

//

void CAutoLockModel::CancelActivityManager()

	{

    if ( iActivityManager )

        {

	    iActivityManager->Cancel();

        }

	delete iActivityManager;

	iActivityManager = NULL;

	}

//

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

// CAutoLockModel::~CAutoLockModel()

// Destructor   

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

//

CAutoLockModel::~CAutoLockModel()

	{

    delete iCenRepI;

	delete iLockObserver;

	StopActivityMonitoring();

	FeatureManager::UnInitializeLib();

    // close custom phone

	}

//

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

// CAutoLockModel::AutoLockTimeout()

// Returns current autolock period

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

//

TInt CAutoLockModel::AutoLockTimeout()

	{

    return iCenRepI->Timeout();

	}

//

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

// CAutoLockModel::ResetInactivityTimeoutL()

// Gets autolock period and starts monitoring user activity 

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

//

void CAutoLockModel::ResetInactivityTimeout()

	{	

	if (AutoLockTimeout() )

		{

		iActivityManager->SetInactivityTimeout(AutoLockTimeout());

		}

	else

		{

		iActivityManager->SetInactivityTimeout(AutoLockOff);

		}

	}

//

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

// CAutoLockModel::HandleActiveEventL()

// Handles Active event. Called by ActivityManager

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

//

TInt CAutoLockModel::HandleActiveEventL(TAny* /*aPtr*/)

	{

	return KErrNone;

	}

//

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

// CAutoLockModel::HandleInactiveEventL()

// Handles InActive event. Called by ActivityManager

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

//

TInt CAutoLockModel::HandleInactiveEventL(TAny* aPtr)

	{

	if ( STATIC_CAST(CAutoLockModel*, aPtr)->AutoLockTimeout() )

		{

			TInt value(EStartupUiPhaseUninitialized);

			RProperty::Get(KPSUidStartup, KPSStartupUiPhase, value);

			//Don't lock unless boot is over.

	    if(value == EStartupUiPhaseAllDone)

		    {

		    #if defined(_DEBUG)

    		RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::HandleInactiveEventL() Boot over"));

    		#endif

				#ifdef RD_REMOTELOCK

				STATIC_CAST(CAutoLockModel*, aPtr)->LockSystemL(ETimerLocked);

				#else

				STATIC_CAST(CAutoLockModel*, aPtr)->LockSystemL(EAutolockOn);

				#endif //RD_REMOTELOCK

			  }

			else

			{

				#if defined(_DEBUG)

    		RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::HandleInactiveEventL() In boot; don't lock"));

    		#endif

			}

		}

	return KErrNone;

	}

//

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

// CAutoLockModel::LockSystemL()

// Locks system

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

//

void CAutoLockModel::LockSystemL(TInt aAutolockState)

	{

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() BEGIN"));

    #endif

    // If already locked, do nothing. Otherwise we'll end up

    // on top of Screensaver

    // Check if iSideKey2 is zero or not (locked if nonzero)

    // Also, phone should not be locked if PUK1 code query is up.

#ifdef FF_STARTUP_OMA_DM_SUPPORT	// New booting order	Start	ID:	 MVKS-7PZDZ5

		TInt autolock_value	=	0;

		RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,	autolock_value);	

		if (autolock_value ==	EAutolockStatusUninitialized)

		{

				return;					

		}		

#endif	//End	ID:	 MVKS-7PZDZ5

    if (iAppUi->Locked() || iAppUi->IsPinBlocked())

        {

        return;

        }

	TInt lightStatus=EForcedLightsUninitialized; 

	RProperty::Get(KPSUidCoreApplicationUIs,KLightsVTForcedLightsOn,lightStatus ); 

	//If display is forced on. don't lock 

	if(lightStatus == EForcedLightsOn ) 

		{

		#if defined(_DEBUG) 

		RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() Display is forced on. Device not locked")); 

		#endif 

		return;

		}

    //Check which state we are in to see if it's OK to lock the phone

    //In CDMA when there is no SIM (RUIM) support we should be able to lock

    //the phone after reboot. In this case ESWStateNormal is too late to lock the phone

    //and other states below are needed.

    TBool okToLock = EFalse;

    TInt sysState = 0;

    iProperty.Get(KPSUidStartup, KPSGlobalSystemState, sysState);    

    //If NOT in CDMA the Autolock should come up only after the phone has booted up.

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) || iAppUi->HiddenReset())

        {

        if( (sysState == ESwStateNormalRfOn       ||

            sysState == ESwStateNormalRfOff       ||

             sysState == ESwStateCriticalPhaseOK) &&

            (aAutolockState > EAutolockOff) )	// EMKK-7N3G7R

            {

            #if defined(_DEBUG)

            RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCKED AFTER HIDDEN RESET"));

            #endif

            okToLock = ETrue;

            }

        }

    else //Feature Manager

        {

        if( (sysState == ESwStateNormalRfOn       ||

             sysState == ESwStateNormalRfOff)      &&

            (aAutolockState > EAutolockOff) ) // EMKK-7N3G7R

            {

            okToLock = ETrue;

            }

        }

   TInt tarmFlag;

if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))    

{

    // Get the TARM admin flag value

	TInt tRet = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );

    if ( tRet != KErrNone )

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL():\

            Warning: failed to get TARM Admin Flag state"));

        #endif

        }

    else

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL(): TARM flag: %d"),

            tarmFlag );

        #endif

        }

}

    TInt callState;

    iProperty.Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);

TBool isConditionSatisfied = EFalse;

if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))

{        

    if ( ( callState != EPSCTsyCallStateNone ) && (!( tarmFlag & KSCPFlagAdminLock )) )    

    			isConditionSatisfied = ETrue;

}

else

{

    if ( callState != EPSCTsyCallStateNone )

    		isConditionSatisfied = ETrue;

}

		if (isConditionSatisfied)

        {

        TBool remoteLocked(EFalse);

        #ifdef RD_REMOTELOCK

        remoteLocked = (aAutolockState == ERemoteLocked);

        #endif //RD_REMOTELOCK

         if(remoteLocked) 

         {

            #if defined(_DEBUG)

            RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() REMOTE LOCKED"));

            #endif

            okToLock = ETrue;

         }

         else

            okToLock = EFalse;        

        }

    if (!iAppUi->IsForeground() && okToLock)

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCK PHONE"));

        #endif   

		// close fast-swap window

		CEikonEnv::Static()->DismissTaskList();

		// inform Avokon & Other app that system is locked

		// unless the value has already been set in secuisystemlock

		#ifdef RD_REMOTELOCK

		if(aAutolockState != EManualLocked)

    		{

    		    #if defined(_DEBUG)

                RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() Timer/Remote locked: %d"), aAutolockState);

                #endif

    		    SetLockedL(aAutolockState);		    

    		}

		else if((aAutolockState == EManualLocked)  && !iAppUi->Locked() && iAppUi->HiddenReset())

		     {   //set the PubSub key if we are to be locked after a hidden reset has occurred.

		         #if defined(_DEBUG)

                 RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() HIDDEN RESET LOCK"));

                 #endif

		         SetLockedL(aAutolockState);	   

		     }

		else

		    {   //Normal manual lock from power key. Just set the CenRep key.

		        iCenRepI->SetLockedL(okToLock);

		    }

		#else //! RD_REMOTELOCK

		SetLockedL(aAutolockState);

		#endif//RD_REMOTELOCK

		// lock keys

		iAppUi->LockKeysL();

		// app to foreground

		iAppUi->BringAppToForegroundL();

         // Reset inactivity time so that Screensaver gets to

        // run again after its timeout. We'll ignore the new

        // inactivity timeout, if already locked

        User::ResetInactivityTime();

		}

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() END"));

    #endif

} 

//

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

// CAutoLockModel::SetLocked

// Sets lockvalue in Publish & Subscribe and Central Repository

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

//

void CAutoLockModel::SetLockedL(TInt aAutolockState)

	{

	#if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() begin"));

    #endif

	TBool locked = (aAutolockState > EAutolockOff);

	if (locked)

		{

        iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, aAutolockState);

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() LOCK"));

        #endif

		}		

  else

		{				

        iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() UNLOCK"));         

        #endif

    }

    iCenRepI->SetLockedL(locked);

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() end"));

    #endif

	}

// END OF FILE