/*

* 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:   State machine interface. Used for the statemachine in the 

*                server drawer to keep track on when a transition should be made

*                and when not.

*

*/

#include "statehandler.h"

#include "states.h"

#include "uidblock.h"

#include "uidexception.h"

#include <alflogger.h>

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

// This LUT defines what fullscreen transitions is of wich type.

// It is needed by the filter, but is part of platform requirements,

// so it feels logical to keep it here.

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

//

#include  <akntranseffect.h> 

const CStateHandler::TFullscreenType FullscreenTypeLUT[] = 

	{

	CStateHandler::ENone,  						//none

	CStateHandler::EActivation, //activation

	CStateHandler::EError,   	//removed action

	CStateHandler::EStart, 		//start

	CStateHandler::EStart, 		//start embedded

	CStateHandler::EExit, 		//exit

	CStateHandler::EStart, 		//start rect

	CStateHandler::EStart, 		//start switch

	CStateHandler::EStart, 		//start switch rect

	CStateHandler::EExit, 		//exit for end key

	CStateHandler::EExit,		//exit embedded

	CStateHandler::EError,      //right?

	CStateHandler::ELayoutSwitch, //ELayoutSwitch

	CStateHandler::ELayoutSwitch, //ELayoutSwitch

	CStateHandler::ELayoutSwitch, //ELayoutSwitch

	};

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

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

//

CStateBase::CStateBase(MAlfDrawerEngine& aEngine, CStateHandler& aHandler) :

	iEngine(aEngine),

	iHandler(aHandler)

	{

	}

CStateBase::~CStateBase()

	{

	}

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

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

//

TBool CStateBase::IsBlocked(const TUid& aFromUid, const TUid& aToUid)

	{

	return iHandler.IsBlocked(aFromUid, aToUid);

	}

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

// StateHandler Implementation:

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

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

//

void CStateHandler::Signal(CStateBase::TSignal aSignal)

	{

	CStateBase* newstate = NULL;

	TRAPD(err, newstate = iState->SignalL(aSignal));

	if((KErrNone == err) && (NULL != newstate))

		{

		delete iState;

		iState = newstate;

		}

	}

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

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

//

TBool CStateHandler::IsBlocked(const TUid& aFromUid, const TUid& aToUid)

	{

	__ALFFXLOGSTRING2("CStateHandler::IsBlocked - aFromUid: 0x%x, aToUid: 0x%x", aFromUid, aToUid );

	TInt flags = iEngine.Flags();

	if(flags & AknTransEffect::TParameter::EActivateExplicitContinue)

		{

//		return EFalse;

		}

    for(TInt i = iExceptionList.Count() - 1; i >= 0; i--) 

    	{

    	if(iExceptionList[i]->IsAllowed(aFromUid,aToUid)) 

    		{

    		__ALFFXLOGSTRING("CStateHandler::IsBlocked - return EFalse <<");

    	    return EFalse;

    		}

    	}

	for(TInt i = iBlockList.Count() - 1; i >= 0; i--) 

		{

		if(iBlockList[i]->IsBlocked(aFromUid,aToUid)) 

			{

			__ALFFXLOGSTRING("CStateHandler::IsBlocked - return ETrue <<");

			return ETrue;

			}

		}

	__ALFFXLOGSTRING("CStateHandler::IsBlocked - return EFalse <<");

	return EFalse;

	}

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

// OOM condition means block will not be added, this is ok.

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

//

void CStateHandler::AddBlockUid(const TUid& aUid)

	{

	CFullUidBlock* uidblock = new CFullUidBlock(aUid);

	if(uidblock)

		{

		if(KErrNone != iBlockList.Append(uidblock)) 

			{

			//Failed to add, forget about it.

			delete uidblock;

			}

		}

	}

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

// OOM condition means block will not be added, this is ok.

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

//

void CStateHandler::AddBlockUidPair(const TUid& aFromUid, const TUid& aToUid)

	{

	CPairedUidBlock* uidblock = new CPairedUidBlock(aFromUid, aToUid);

	if(uidblock)

		{

		if(KErrNone != iBlockList.Append(uidblock))

			{

			//Failed to add, forget about it.

			delete uidblock;

			}

		}

	}

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

// OOM condition means exception will not be added, this is ok.

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

//

void CStateHandler::AddExceptionUid(const TUid& aUid)

	{

	CFullUidException* uidexception = new CFullUidException(aUid);

	if(uidexception)

		{

		if(KErrNone != iExceptionList.Append(uidexception)) 

			{

			//Failed to add, forget about it.

			delete uidexception;

			}

		}

	}	

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

// OOM condition means exception will not be added, this is ok.

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

//	

void CStateHandler::AddExceptionUidPair(const TUid& aFromUid, const TUid& aToUid)

    {

	CPairedUidException* uidexception = new CPairedUidException(aFromUid, aToUid);

	if(uidexception)

		{

		if(KErrNone != iExceptionList.Append(uidexception))

			{

			//Failed to add, forget about it.

			delete uidexception;

			}

		}    

    }

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

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

//

void CStateHandler::RemoveBlockUid(const TUid& aUid)

	{

	for(TInt i = iBlockList.Count() - 1; i >= 0; i--) 

		{

		if(iBlockList[i]->IsBlocked(aUid,aUid)) 

			{

			delete iBlockList[i];

			iBlockList.Remove(i);

			}

		}

	}

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

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

//

CStateHandler::TFullscreenType CStateHandler::GetFullscreenType(TUint aAction)

	{

	TFullscreenType type = EError;

	if(aAction < (sizeof(FullscreenTypeLUT) / sizeof(TInt)))

		{

		type = FullscreenTypeLUT[aAction];

		}

	if(aAction >= AknTransEffect::EAppSpesificEvent)

		type = EAppSpecific;

	return type;

	}

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

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

//

CStateHandler::TFullscreenType CStateHandler::GetCurrentFullscreenType()

	{

	return GetFullscreenType(iState->StateInfo().iAction);

	}

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

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

//

CStateHandler* CStateHandler::NewL(MAlfDrawerEngine* aEngine)

	{

	CStateHandler* self = new (ELeave) CStateHandler(aEngine);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

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

//

CStateBase::TState CStateHandler::GetState()

	{

	return iState->StateInfo().iState;

	}

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

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

//

CStateHandler::CStateHandler(MAlfDrawerEngine* aEngine) :

	iEngine(*aEngine)

	{

	}

void CStateHandler::ConstructL()

	{

	iState = CRestingState::NewL(iEngine,*this);

	}

CStateHandler::~CStateHandler()

	{

	iBlockList.ResetAndDestroy();

	iExceptionList.ResetAndDestroy();

	delete iState;

	}