// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// domain\src\domainsrv.cpp

// 

//

#include <e32debug.h>

#include <e32base.h>

#include <e32base_private.h>

#include <e32property.h>

#include <f32file.h>

#include <domainpolicy.h>

#include "domainsrv.h"

#define __DS_PANIC(aError) User::Panic(_L("domainSrv.cpp"), (-(aError)) | (__LINE__ << 16))

#define __DS_ASSERT(aCond) ((aCond) || (User::Panic(_L("domainSrv.cpp; assertion failed"), __LINE__), 1))

//#define __DS_DEBUG

#ifdef __DS_DEBUG

#define __DS_TRACE(s) RDebug::Print s

#else

#define __DS_TRACE(s)

#endif

static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

static _LIT_SECURITY_POLICY_C1(KPowerMgmtPolicy,ECapabilityPowerMgmt);

// forward refs

class CSvrDomain;

class CDmHierarchy;

class CPowerUpHandler;

class CDmHierarchyPower;

class CDmSvrManager;

class CDmDomainServer;

class CDmDomainSession;

class CDmManagerServer;

class CDmManagerSession;

// CSvrDomain

class CSvrDomain : public CTimer

	{

public: 

	static CSvrDomain* New(CDmHierarchy& aHierarchy, const TDmDomainSpec&);

	// from CTimer

	void RunL();

	void Attach(CDmDomainSession*);

	void Detach(CDmDomainSession*);

	void AddChild(CSvrDomain*);

	CSvrDomain* Lookup(TDmDomainId);

	TBool CheckPropValue(TInt aPropValue);

	void RequestDomainTransition();

	void CompleteMemberTransition(TInt aError);

	void CancelTransition();

	void SetObserver(TBool aSet);

	TDmDomainState State();

private:

	CSvrDomain(CDmHierarchy& aHierarchy, const TDmDomainSpec*);

	void Construct(const TDmDomainSpec* spec);

	void RequestMembersTransition();

	void RequestChildrenTransition();

	void MembersTransitionDone();

	void ChildrenTransitionDone();

	void CompleteDomainTransition();

private:

	CDmHierarchy&		iHierarchy;

	CSvrDomain*			iParent;

	CSvrDomain*			iPeer;

	CSvrDomain*			iChild;

	RProperty			iProperty;

	CDmDomainSession*	iSessions;

	TUint16				iChildrenCount;

	TUint16				iTransCount;

	TTimeIntervalMicroSeconds32	iTransTimeBudget;

public:

	const TSecurityPolicy	iJoinPolicy;

	TBool iIsObserved;

	TDmDomainId			iId;

	};

// CDmHierarchy

class CDmHierarchy : public CBase

	{

public:

	static CDmHierarchy* New(TDmHierarchyId aHierarchyId, TDmHierarchyPolicy& aPolicy);

	CSvrDomain* LookupDomain(TDmDomainId aDomainId);

	TInt RequestDomainTransition(TDmDomainId, TDmDomainState aTargetState, TDmTraverseDirection aTraverseDirection, const RMessage2* aMessage);

	void RequestTransition(const RMessage2* aMessage);

	TInt StartObserver( TDmDomainId aDomainId,TDmNotifyType aNotifyType);

	void SetNotifyMessage(const RMessage2* aMessage);

	void CompleteNotification(TInt aError);

	TBool OutstandingNotification();

	void StopObserver();

	virtual TInt RequestSystemTransition(TDmDomainState aTargetState, TDmTraverseDirection aTraverseDirection, const RMessage2* aMessage);

	virtual void CompleteTransition(TInt aError);

	virtual void NotifyCompletion(TInt aReason);

protected:

	CDmHierarchy(TDmHierarchyId aHierarchyId, TDmHierarchyPolicy& aPolicy);

	void SetState(TDmDomainState aTargetState, TDmTraverseDirection aTraverseDirection = ETraverseDefault);

private:

	RMessagePtr2	iTransMessagePtr;

	RMessagePtr2	iObsvrMessagePtr;

	CSvrDomain*		iObservedDomain;

	TBool			iOutstandingNotification;

public:

	TDmHierarchyId	iHierarchyId;

	CSvrDomain*		iRootDomain;

	CSvrDomain*		iTransDomain;

	TInt			iTransPropValue;

	TDmDomainState	iTransState;

	TDmTraverseDirection	iTraverseDirection;

	TUint8			iTransId;

	CDmManagerSession* iControllerSession;	// only one controller per hierarchy

	TDmHierarchyPolicy iPolicy;

	RArray<TTransitionFailure> iTransitionFailures;

	// observer stuff

	TBool			iObserverStarted;

	TDmNotifyType	iNotifyType;

	RArray<TTransInfo>	iTransitions;

	CDmManagerSession* iObserverSession;	// only one observer per hierarchy

	TInt			iObservedChildren;

	};

// CPowerUpHandler

// Active object used to receive power-up notifications 

// from the Kernel-level power manager

class CPowerUpHandler : public CActive

	{

public: 

	static CPowerUpHandler* New(CDmHierarchyPower& aHierarchyPower);

	// from CActive

	void RunL();

	void DoCancel();

	void RequestWakeupEventNotification();

	void Cancel();

private:

	CPowerUpHandler(CDmHierarchyPower& aHierarchyPower);

	void Construct();

private:

	CDmHierarchyPower& iHierarchyPower;

	};

// CDmHierarchyPower

// CDmHierarchy-derived class 

// Interfaces to the Kernel-level power manager

class CDmHierarchyPower : public CDmHierarchy

	{

public:

	static CDmHierarchyPower* New(TDmHierarchyId aHierarchyId, TDmHierarchyPolicy& aPolicy);

	// from CDmHierarchy

	virtual TInt RequestSystemTransition(TDmDomainState, TDmTraverseDirection aTraverseDirection, const RMessage2* aMessage);

	virtual void CompleteTransition(TInt aError);

	virtual void NotifyCompletion(TInt aReason);

	void PowerUp();	// called from CPowerUpHandler

private:

	CDmHierarchyPower(TDmHierarchyId aHierarchyId, TDmHierarchyPolicy& aPolicy);

	void Construct();

private:

	enum 

		{

		EPoweringDown	= 0x01,

		};

	TUint8			iTransStatus;

	CPowerUpHandler* iPowerUpHandler;

	};

// CDmSvrManager

class CDmSvrManager : public CBase

	{

public:

	static CDmSvrManager* New();

	TInt BuildDomainTree(TDmHierarchyId aHierarchyId, CDmHierarchy*& aHierarchy);

	CDmHierarchy* LookupHierarchy(TDmHierarchyId aHierarchyId);

	TInt LookupDomain(TDmHierarchyId aHierarchyId, TDmDomainId aDomainId, CSvrDomain*& aDomain);

private:

	CDmSvrManager();

	void Construct();

private:

	RPointerArray<CDmHierarchy> iDomainHierarchies;

	};

// CDmDomainServer

class CDmDomainServer : public CServer2

	{

public: 

	// from CServer2

	CSession2* NewSessionL(const TVersion& aVer) const;

	CSession2* NewSessionL(const TVersion& aVer, const RMessage2& aMessage) const;

	CDmDomainServer(CDmSvrManager* aManager) : CServer2(CActive::EPriorityStandard), iManager(aManager)

		{}

public:

	CDmSvrManager*	iManager;

	};

// CDmDomainSession

class CDmDomainSession : public CSession2

	{

public: 

	// from CBase

	~CDmDomainSession();

	// from CSession2

	void ServiceL(const RMessage2& aMessage);

private:

	CSvrDomain*			iDomain;

public:

	CDmDomainSession*	iNext;

	TUint8				iPending;

	TBool				iNotificationEnabled;

	};

class CDmManagerServer : public CServer2

	{

public: 

	// from CServer2

	CSession2* NewSessionL(const TVersion& aVer) const;

	CSession2* NewSessionL(const TVersion& aVer, const RMessage2&) const;

	CDmManagerServer(CDmSvrManager* aManager) : CServer2(CActive::EPriorityStandard), iManager(aManager)

		{}

	CDmSvrManager*	iManager;

	};

class CDmManagerSession : public CSession2

	{

public: 

	// from CBase

	~CDmManagerSession();

	// from CSession2

	void ServiceL(const RMessage2& aMessage);

	CDmManagerSession();

private:

	CDmHierarchy* iHierarchy;	// not owned

	};

//*********************************************************

// TTransitionFailure

//*********************************************************

/**

@internalTechnology

Constructor for transition failure info.

@param aDomainID	Id of the domain of interest

@param aError		error code of transition	 

*/

TTransitionFailure::TTransitionFailure(TDmDomainId aDomainId, TInt aError) :

	iDomainId(aDomainId), iError(aError)

	{

	}

//*********************************************************

// TTransInfo

//*********************************************************

/**

@internalTechnology

Constructor for transition failure info.

@param aDomainID	Id of the domain of interest

@param aState		State of the domain after transition

@param aError		error code of transition	 

*/

TTransInfo::TTransInfo(TDmDomainId aDomainId, TDmDomainState aState, TInt aError) :

	iDomainId(aDomainId), iState(aState), iError(aError)

	{

	}

//*********************************************************

// CSvrDomain

//*********************************************************

CSvrDomain::CSvrDomain(CDmHierarchy& aHierarchy, const TDmDomainSpec* spec)

	:	CTimer(CActive::EPriorityStandard), 

		iHierarchy(aHierarchy),

		iTransTimeBudget(spec->iTimeBudgetUs),

		iJoinPolicy(spec->iJoinPolicy),

		iId(spec->iId)

	{}

CSvrDomain* CSvrDomain::New(CDmHierarchy& aHierarchy, const TDmDomainSpec& aSpec)

	{

	CSvrDomain* self = new CSvrDomain(aHierarchy, &aSpec);

	if (!self)

		__DS_PANIC(KErrNoMemory);

	self->Construct(&aSpec);

	return self;

	}

void CSvrDomain::Construct(const TDmDomainSpec* spec)

	{

	TInt r = iProperty.Define(

		KUidDmPropertyCategory, 

		DmStatePropertyKey(iHierarchy.iHierarchyId, iId), 

		RProperty::EInt,

		KAllowAllPolicy,KPowerMgmtPolicy);

	if (r != KErrNone)

		__DS_PANIC(r);

	r = iProperty.Attach(KUidDmPropertyCategory, DmStatePropertyKey(

		iHierarchy.iHierarchyId, 

		iId));

	if (r != KErrNone)

		__DS_PANIC(r);

	r = iProperty.Set(DmStatePropertyValue(0, spec->iInitState));

	if (r != KErrNone)

		__DS_PANIC(r);

	TRAP(r, CTimer::ConstructL());

	if (r != KErrNone)

		__DS_PANIC(r);

	CActiveScheduler::Add(this);

	}

void CSvrDomain::Attach(CDmDomainSession* aSession)

	{

	aSession->iNext = iSessions;

	iSessions = aSession;

	}

void CSvrDomain::Detach(CDmDomainSession* aSession)

	{

	CDmDomainSession** prevp = &iSessions;

	while (*prevp != aSession)

		{

		prevp = &((*prevp)->iNext);

		__DS_ASSERT(*prevp);

		}

	*(prevp) = aSession->iNext;

	}

void CSvrDomain::AddChild(CSvrDomain* aChild)

	{

	++iChildrenCount;

	aChild->iParent = this;

	if(iIsObserved)

		aChild->iIsObserved=ETrue;

	// Insert the child in the list of its peers

	aChild->iPeer = iChild;

	iChild = aChild;

	}

CSvrDomain* CSvrDomain::Lookup(TDmDomainId aDomainId)

	{

	if (iId == aDomainId)

		return this;

	CSvrDomain* child = iChild;

	while (child)

		{

		CSvrDomain* domain = child->Lookup(aDomainId);

		if (domain)

			return domain;

		child = child->iPeer;

		}

	return NULL;

	}

TBool CSvrDomain::CheckPropValue(TInt aPropValue)

	{ return iHierarchy.iTransPropValue == aPropValue; }

void CSvrDomain::RequestMembersTransition()

	{

	__DS_TRACE((_L("CSvrDomain::RequestMembersTransition() hierarchy=%d, domain=0x%x"), iHierarchy.iHierarchyId, iId));

	__DS_ASSERT(iTransCount == 0);

	for(CDmDomainSession* s = iSessions; s; s = s->iNext)

		if (s->iNotificationEnabled)

			{

			++iTransCount;

			s->iPending = ETrue;

			// notifications will be disabled until the client makes another 

			// call to RDmDomain::RequestTransitionNotification()

			s->iNotificationEnabled = EFalse;

			}

	if(iIsObserved)

		{

		if((iHierarchy.iNotifyType&EDmNotifyTransRequest)==EDmNotifyTransRequest)

			{

			TTransInfo transInfo(iId,State(),KDmErrOutstanding);

			iHierarchy.iTransitions.Append(transInfo);

			if(iHierarchy.OutstandingNotification())

					iHierarchy.CompleteNotification(KErrNone);	

			}

		}

	if (iTransCount > 0)

		CTimer::After(iTransTimeBudget);

	iProperty.Set(iHierarchy.iTransPropValue);

	if (iTransCount == 0)

		MembersTransitionDone();

	}

void CSvrDomain::RequestChildrenTransition()

	{

	__DS_TRACE((_L("CSvrDomain::RequestChildrenTransition() hierarchy=%d, domain=0x%x"), iHierarchy.iHierarchyId, iId));

	__DS_ASSERT(iTransCount == 0);

	iTransCount = iChildrenCount;

	if (iTransCount)

		{

		CSvrDomain* child = iChild;

		__DS_ASSERT(child);

		do	{

			child->RequestDomainTransition();

			child = child->iPeer;

			}

		while(child);

		}

	else

		ChildrenTransitionDone();

	}

void CSvrDomain::RequestDomainTransition()

	{

	__DS_TRACE((_L("CSvrDomain::RequestDomainTransition() hierarchy=%d, domain=0x%x state=0x%x prop=0x%x"), 

						iHierarchy.iHierarchyId, iId, iHierarchy.iTransState, iHierarchy.iTransPropValue));

	__DS_ASSERT(iTransCount == 0);

	if (iHierarchy.iTraverseDirection == ETraverseChildrenFirst)

		RequestChildrenTransition();

	else

		RequestMembersTransition();

	}

void CSvrDomain::MembersTransitionDone()

	{

	__DS_TRACE((_L("CSvrDomain::MembersTransitionDone() hierarchy=%d, domain=0x%x"), iHierarchy.iHierarchyId, iId));

	__DS_ASSERT(iTransCount == 0);

	if (iHierarchy.iTraverseDirection == ETraverseChildrenFirst)

		CompleteDomainTransition();

	else

		RequestChildrenTransition();

	}

void CSvrDomain::ChildrenTransitionDone()

	{

	__DS_TRACE((_L("CSvrDomain::ChildrenTransitionDone() hierarchy=%d, domain=0x%x"), iHierarchy.iHierarchyId, iId));

	__DS_ASSERT(iTransCount == 0);

	if (iHierarchy.iTraverseDirection == ETraverseChildrenFirst)

		RequestMembersTransition();

	else

		CompleteDomainTransition();

	}

void CSvrDomain::CompleteMemberTransition(TInt aError)

	{

	__DS_TRACE((_L("CSvrDomain::CompleteMemberTransition() hierarchy=%d, domain=0x%x, aError = %d"), iHierarchy.iHierarchyId, iId, aError));

	__DS_ASSERT(iTransCount);

	if (aError)

		{

		// Add a transition failure to the array

		TTransitionFailure failure(iId, aError);

		iHierarchy.iTransitionFailures.Append(failure);

		if(iIsObserved)

			{

				if((iHierarchy.iNotifyType&EDmNotifyFail)==EDmNotifyFail)

				{

				TTransInfo transInfo(iId,State(),aError);

				iHierarchy.iTransitions.Append(transInfo);

				if(iHierarchy.OutstandingNotification())

					iHierarchy.CompleteNotification(KErrNone);

				}

			}

		// examine the failure policy to work out what to do

		if (iHierarchy.iPolicy.iFailurePolicy == ETransitionFailureStop)

			{

			iHierarchy.CompleteTransition(aError);

			return;

			}

		}

	else if(iIsObserved)