/*

* Copyright (c) 2005-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: Implementation of CPhoneSecurityModeState class.

*

*/

#include "cphonesecuritymodeobserver.h"

#include "mphonesecuritymodechangeobserver.h"

#include "cphonelogger.h"

#include "cphonepubsubproxy.h"

#include <mpeengineinfo.h>

#include <featmgr.h>

#include <e32cmn.h>

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

// CPhoneSecurityModeObserver::NewL

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

CPhoneSecurityModeObserver* CPhoneSecurityModeObserver::NewL()

	{

	return new( ELeave )CPhoneSecurityModeObserver;

	}

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

// CPhoneSecurityModeObserver::NewLC

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

CPhoneSecurityModeObserver* CPhoneSecurityModeObserver::NewLC()

	{

	CPhoneSecurityModeObserver* self = new( ELeave )CPhoneSecurityModeObserver;

	CleanupStack::PushL( self );

	return self;

	}

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

// CPhoneSecurityModeObserver::~CPhoneSecurityModeObserver

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

CPhoneSecurityModeObserver::~CPhoneSecurityModeObserver()

	{

	iObserverArray.Reset();

	iObserverArray.Close();

	}

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

// CPhoneSecurityModeObserver::SetPhoneEngineInfo

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

void CPhoneSecurityModeObserver::SetPhoneEngineInfo( MPEEngineInfo* aEngineInfo )

	{

	iEngineInfo = aEngineInfo;

	}

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

// CPhoneSecurityModeObserver::RegisterStateObserver

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

void CPhoneSecurityModeObserver::RegisterStateObserver( MPhoneSecurityModeChangeObserver& aObserver )

	{

	iObserverArray.Append( &aObserver );

	if ( iInitialized )

		{

		// Notify observer with registration call, if state instance is initialized.

		aObserver.HandleSecurityModeChanged( iSecurityMode );

		}

	}

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

// CPhoneSecurityModeObserver::RemoveStateObserver

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

void CPhoneSecurityModeObserver::RemoveStateObserver( MPhoneSecurityModeChangeObserver& aObserver )

	{

	TInt index = iObserverArray.Find( &aObserver );

	if ( KErrNotFound != index )

		{

		iObserverArray.Remove( index );

		}

	}

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

// CPhoneSecurityModeObserver::IsAutolockEnabled

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

TBool CPhoneSecurityModeObserver::IsAutolockEnabled()

	{

	// Autolock is enabled in uninitialized state also.

	return ( iDeviceLockState > EAutolockOff

		|| EAutolockStatusUninitialized == iDeviceLockState );

	}

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

// CPhoneSecurityModeObserver::IsSecurityMode

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

TBool CPhoneSecurityModeObserver::IsSecurityMode()

	{

	return iSecurityMode;

	}

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

// CPhoneSecurityModeObserver::HandlePhoneEngineMessageL

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

void CPhoneSecurityModeObserver::HandlePhoneEngineMessageL( const TInt aMessage,

	TInt /*aCallId*/ )

	{

	TBool previousSecurityMode = iSecurityMode;

	switch( aMessage )

		{

		case MEngineMonitor::EPEMessageSIMStateChanged:

			{

			__PHONELOG( EBasic,

				EPhoneControl,

				"CPhoneSecurityModeObserver::HandlePhoneEngineMessageL() " );

			// Register new sim states.

			iEnginePreviousSimState = iEngineCurrentSimState;

			if ( iEngineInfo )

				{

				iEngineCurrentSimState = iEngineInfo->SimState();

				DefineSecurityModeState();

				}

			}

		break;

		}

	// Notify observers for state change.

	if ( previousSecurityMode != iSecurityMode )

		{

		HandleStateChange();

		}

	}

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

// CPhoneSecurityModeObserver::HandlePropertyChangedL

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

void CPhoneSecurityModeObserver::HandlePropertyChangedL(const TUid& aCategory,

	const TUint aKey,

	const TInt aValue )

	{

	__PHONELOG( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::HandlePropertyChangedL() " );

	// Register sim security and autolock value changes.

	TBool previousSecurityMode = iSecurityMode;

	if ( KPSUidStartup == aCategory && KStartupSimSecurityStatus == aKey )

		{

		iSimState = ( TPSSimSecurityStatus )aValue;

		DefineSecurityModeState();

		}

	else if ( KPSUidCoreApplicationUIs == aCategory 

	    && KCoreAppUIsAutolockStatus == aKey )

		{

		iDeviceLockState = ( TPSAutolockStatus )aValue;

		DefineSecurityModeState();

		}

	// Notify observer for state change.

	if ( previousSecurityMode != iSecurityMode )

		{

		HandleStateChange();

		}

	}

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

// CPhoneSecurityModeObserver::Initialize

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

void CPhoneSecurityModeObserver::Initialize()

	{

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::Initialize() %d ", iSecurityMode );

	if ( !iInitialized )

		{

		if ( !iEngineInfo )

			{

			// Do not initialize if engine info data interface hasn't been set.

			return;

			}

		// Get current values for sim states and autolock value.

		iEngineCurrentSimState = iEngineInfo->SimState();

		iSimState = ( TPSSimSecurityStatus )CPhonePubSubProxy::Instance()->Value(

			KPSUidStartup,

			KStartupSimSecurityStatus );

		iDeviceLockState = ( TPSAutolockStatus )CPhonePubSubProxy::Instance()->Value(

			KPSUidCoreApplicationUIs,

			KCoreAppUIsAutolockStatus );

		iInitialized = ETrue;

		DefineSecurityModeState();

		HandleStateChange();

		}

	}

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

// CPhoneSecurityModeObserver::CPhoneSecurityModeObserver

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

CPhoneSecurityModeObserver::CPhoneSecurityModeObserver() :

	iSimState( ESimSecurityStatusUninitialized ),

	iEngineCurrentSimState( EPESimStatusUninitialized ),

	iEnginePreviousSimState(EPESimStatusUninitialized ),

	iDeviceLockState( EAutolockStatusUninitialized ),

    iSecurityMode( ETrue )

	{

	}

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

// CPhoneSecurityModeObserver::DefineSecurityModeState

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

void CPhoneSecurityModeObserver::DefineSecurityModeState()

	{

	// Device lock 

	if ( IsAutolockEnabled() )

		{

		iSecurityMode = ETrue;

		}

	// Sim security status

	else if ( IsSimSecurityStatus() )

		{

		iSecurityMode = ETrue;

		}

	// Phone engine sim state

	else if ( !IsEngineSimStateAccepted() )

		{

		iSecurityMode = ETrue;

		}

	else

		{

		iSecurityMode = EFalse;

		}

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::DefineSecurityModeState(), iEngineCurrentSimState( %d )",

		iEngineCurrentSimState );

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::DefineSecurityModeState(), iEnginePreviousSimState( %d )",

		iEnginePreviousSimState );

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::DefineSecurityModeState(), iSimState( %d )",

		iSimState );

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::DefineSecurityModeState(), iDeviceLockState( %d )",

		iDeviceLockState );

	__PHONELOG1( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::DefineSecurityModeState(), iSecurityMode( %d )",

		iSecurityMode );

	}

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

// CPhoneSecurityModeObserver::HandleStateChange

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

void CPhoneSecurityModeObserver::HandleStateChange()

	{

	__PHONELOG2( EBasic,

		EPhoneControl,

		"CPhoneSecurityModeObserver::HandleStateChange() %d, %d observers ", iSecurityMode, iObserverArray.Count() );

	if ( iInitialized )

		{

		for( TInt i( 0 ); i < iObserverArray.Count(); i++ )

			{

			MPhoneSecurityModeChangeObserver& observer = *( iObserverArray[ i ] );

			observer.HandleSecurityModeChanged( iSecurityMode );

			}

		}

	}

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

// CPhoneSecurityModeObserver::HandleStateChange

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

TBool CPhoneSecurityModeObserver::IsSimSecurityStatus()

	{

	TBool securityStatus( EFalse );

	if ( ESimRejected == iSimState )

		{

		securityStatus = ETrue;

		}

	else if ( ESimUnaccepted == iSimState )

		{

		securityStatus = ETrue;

		}

	else if ( ESimInvalid == iSimState )

		{

		securityStatus = ETrue;

		}

	return securityStatus;

	}

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

// CPhoneSecurityModeObserver::HandleStateChange

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

TBool CPhoneSecurityModeObserver::IsEngineSimStateAccepted()

	{

	TBool accepted( ETrue );

	if ( ( EPESimNotPresent == iEngineCurrentSimState )

		&& ( ( EPESimUsable == iEnginePreviousSimState )

		|| ( EPESimReadable == iEnginePreviousSimState )

		|| ( EPESimNotReady == iEnginePreviousSimState ) ) )

		{

		accepted = EFalse;

		}

	else if ( EPESimNotSupported == iEngineCurrentSimState )

		{

		accepted = EFalse;

		}

	else if ( EPESimNotPresent == iEngineCurrentSimState &&

		!AreSimlessFeaturesSupported() )

		{

		accepted = EFalse;

		}

	return accepted;

	}

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

// CPhoneSecurityModeObserver::HandleStateChange

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

TBool CPhoneSecurityModeObserver::AreSimlessFeaturesSupported()

	{

	return FeatureManager::FeatureSupported( KFeatureIdOfflineMode )

		&&FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport );

	}

// END OF FILE