// 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();
		}
	}