// Copyright (c) 2005-2009 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 CSchStartupStateMgr class which connects to

// the Domain manager to keep aware of the current start-up

// state and distributes the state changes to registered observers.

// 

//

/**

 @file

 @internalComponent

*/

#include "SchSSAMan.h"

#include "SchLogger.h"

/**

constructor of CSchStartupStateMgr

@internalComponent

*/

CSchStartupStateMgr::CSchStartupStateMgr(TDmHierarchyId aHierarchyId, TDmDomainId aDomainId) :

	CDmDomain(aHierarchyId,aDomainId),

	iCurrentStartupState(EStartupStateUndefined)

	 {

	 }

/**

destructor of CSchStartupStateMgr

@internalComponent

*/

CSchStartupStateMgr::~CSchStartupStateMgr()

	{

	Cancel();

	iObserverList.Reset();

	}

/**

Getter

@internalComponent

@return the current startup state

*/

TStartupStateIdentifier CSchStartupStateMgr::CurrentStartupState()

	{

	return iCurrentStartupState;

	}

/**

updates the MSchStartupStateObserver objects.

@internalComponent

*/

void CSchStartupStateMgr::UpdateStateAwareObjectsL(TStartupStateIdentifier aKnownState)

	{

	for (TInt i = 0; i < iObserverList.Count(); i++)

		{

		iObserverList[i]->ProcessSSAEventL(aKnownState);

		}

	}

/**

This method takes a a startup state which can be user defined

state and maps it to a known startup state (KSS). KSS are

Symbian defined states: undefined, critical static, critical dynamic,

and non-critical.

User defined states are refered to as USS - unknown startup state.

@internalComponent

*/

TStartupStateIdentifier CSchStartupStateMgr::GetKnownStartupState(TDmDomainState aStartupState)

	{

	TStartupStateIdentifier knownStartupState = iCurrentStartupState;

	if (aStartupState >= EStartupStateNonCritical)

		{

		knownStartupState = EStartupStateNonCritical;

		}

	else if(aStartupState >= EStartupStateCriticalDynamic)

		{

		knownStartupState = EStartupStateCriticalDynamic;

		}

	else if(aStartupState >= EStartupStateCriticalStatic)

		{

		knownStartupState = EStartupStateCriticalStatic;

		}

	else 

		{

		knownStartupState = EStartupStateUndefined;

		}

	return knownStartupState;

	}

/**

Register the MSchStartupStateObserver object with the CServerStartupMgr.

@internalComponent

@param aObs the pointer to the MStartupStateObserver object to be registered with CServerStartupMgr.

*/

void CSchStartupStateMgr::RegisterObserverL(const MSchStartupStateObserver* aObs)

	{

	User::LeaveIfError(iObserverList.Append(aObs));

	}

/**

Handle the error if RunL leaves. Just tell the observers that

we have reached the final state.

@internalComponent

@param aError error code generated by the RunL(), not used here.

@return KErrNone to avoid CActiveScheduler to panic.

*/

TInt CSchStartupStateMgr::RunError(TInt /*aError*/)

	{

	LOGSTRING("CSchStartupStateMgr::RunL() leaves, set SS to final state.");

	TRAP_IGNORE(UpdateStateAwareObjectsL(KSchFinalStartupState));

	return KErrNone;

	}

/**

Finsish constructing the CSchStartupStateMgr and start

interacting with Domain Manager to receive startup state

changes. 

All observers should have been registered before calling this method

@internalComponent

*/

void CSchStartupStateMgr::InitialiseL()

	{

	TRAPD(err, CDmDomain::ConstructL());

	if (err != KErrNone)

		{

		// the ConstructL leaves, go to final state

		LOGSTRING2("CDmDomain::ConstructL leaves with %d. Goto final state", err);

		UpdateStateAwareObjectsL(KSchFinalStartupState);

		iCurrentStartupState = KSchFinalStartupState;

		return;

		}

	// Typical pattern of using P&S is to subscribe first then get

	// current state. Example implementation given

	// in SSA Adaptation How-to also does it this way.

	RequestTransitionNotification();

	// get the start up state from the Domain Manager.

	TDmDomainState rawstate = GetState();

	// rawstate may be user defined. Map to known states.

	TStartupStateIdentifier nextKnownState = GetKnownStartupState(rawstate);

	// NB: nextKnownState can be KStartupStateUndefined for 2 reasons.

	// One is rawstate == 0 which we must check first. Second:

	// rawstate is user defined values lower than critical static. In

	// the second case we must wait for next state change.

	if (rawstate == EStartupStateUndefined || 

		nextKnownState == KSchFinalStartupState)

		{

		// If either something wrong with DM or final state is reached,

		// go to final state

		iCurrentStartupState = KSchFinalStartupState;

		UpdateStateAwareObjectsL(KSchFinalStartupState);

		Cancel();

		return;

		}

	iCurrentStartupState = nextKnownState;

	}

/**

Executed when the startup state change is done, it does the 

same thing as the method InitialiseL() does

@internalComponent

*/

void CSchStartupStateMgr::RunL()

	{

	if(iStatus != KErrNone) // something wrong with the RequestTransitionNotification().

		{

		AcknowledgeLastState(iStatus.Int()); //Acknowledge the domainmanager in case of leaving, this to avoid the acknowledgement in RunError()

		User::LeaveIfError(iStatus.Int()); //RunError will handle this.

		}

	RequestTransitionNotification();

	TDmDomainState rawstate = GetState();

	// Must first check the case rawstate == undefined and deal with it here.

	// GetKnowStartupState maps 1 to 15 to EStartupStateUndefined

	// which means a SS before critical static. It does not mean go

	// to final state.

	//If the rawstate is EStartupStateUndefined there must be sth wrong.

	if(rawstate == EStartupStateUndefined) 

		{

		Cancel();

		AcknowledgeLastState(KErrBadHandle);

		User::Leave(KErrBadHandle); //RunError will handle this.

		}

	// get the known state			

	TStartupStateIdentifier nextKnownState = GetKnownStartupState(rawstate);

	//Tell domain manager that we have processed the last state change before starting any time consuming work.

	AcknowledgeLastState(KErrNone);

	//Sleep 2 tickperiods this allows the acknowledgement reach the domain manager.

	TTimeIntervalMicroSeconds32 tickPeriod;

	UserHal::TickPeriod(tickPeriod);	

	User::After(2*tickPeriod.Int()); 

	// Schsvr only want to know transition to non-critical.

	// Ignore all states below that level.

	if (iCurrentStartupState < KSchFinalStartupState && nextKnownState == KSchFinalStartupState)

		{

		UpdateStateAwareObjectsL(nextKnownState);

		}

	iCurrentStartupState = nextKnownState;	

	//do not request transition notification if we have reached the last state

	if(iCurrentStartupState == KSchFinalStartupState)

		{

		Cancel();

		}

	}