// Copyright (c) 2002-2010 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\domaincli.cpp

// 

//

#include <e32base.h>

#include <e32base_private.h>

#include <e32property.h>

#include <domainmember.h>

#include <domainmanager.h>

#include "domainmanager_private.h"

#include "domainobserver.h"

#include "domainsrv.h"

#include "domainmember_private.h"

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

#define __DM_ASSERT(aCond) __ASSERT_DEBUG(aCond,User::Panic(_L("domainCli.cpp; assertion failed"), __LINE__))

TInt RDmDomainSession::Connect(TDmHierarchyId aHierarchyId, TDmDomainId aDomainId, TUint* aKey)

	{

	TInt r = RSessionBase::CreateSession(KDmDomainServerNameLit, KDmDomainServerVersion, 1);

	if (r != KErrNone)

		return r;

	TIpcArgs a( (TInt)aHierarchyId, (TInt)aDomainId );

	r = RSessionBase::SendReceive(EDmDomainJoin, a);

	if (r != KErrNone)

		{

		RSessionBase::Close();

		return r;

		}

	*aKey = DmStatePropertyKey(

		aHierarchyId, 

		aDomainId);

	return KErrNone;

	}

TInt RDmDomainSession::Acknowledge(TInt aValue, TInt aError)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	TIpcArgs a(aValue, aError);

	return RSessionBase::SendReceive(EDmStateAcknowledge, a);

	}

void RDmDomainSession::RequestTransitionNotification()

	{

	__DM_ASSERT(Handle() != KNullHandle);

	TInt r = RSessionBase::SendReceive(EDmStateRequestTransitionNotification);

	if (r != KErrNone)

		__DM_PANIC(r);

	}

void RDmDomainSession::CancelTransitionNotification()

	{

	if (Handle() != KNullHandle)

		{

		TInt r = RSessionBase::SendReceive(EDmStateCancelTransitionNotification);

		if (r != KErrNone)

			__DM_PANIC(r);

		}

	}

void RDmDomainSession::DeferAcknowledgement(TRequestStatus& aStatus)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	RSessionBase::SendReceive(EDmStateDeferAcknowledgement, aStatus);

	}

void RDmDomainSession::CancelDeferral()

	{

	if (Handle() != KNullHandle)

		{

		TInt r = RSessionBase::SendReceive(EDmStateCancelDeferral);

		if (r != KErrNone)

			__DM_PANIC(r);

		}

	}

/**

Connects to the domain identified by the specified domain Id.

To connect to the root domain, which has the Id KDmIdRoot,

the capability WriteDeviceData is required.

Once connected, an  application can use this RDmDomain object to read

the domain's power state and to request notification

when the power state changes.

@param aDomainId The identifier of the domain to be connected to.

@return KErrNone, if successful; otherwise one of the other system-wide

        or Domain Manager specific error codes.

@capability WriteDeviceData If aDomainId==KDmIdRoot

*/

EXPORT_C TInt RDmDomain::Connect(TDmDomainId aDomainId)

	{

	TUint key;

	TInt r = iSession.Connect(KDmHierarchyIdPower, aDomainId, &key);

	if (r != KErrNone)

		return r;

	r = iStateProperty.Attach(KUidDmPropertyCategory, key);

	if (r != KErrNone)

		{

		iSession.Close();

		return r;

		}

	return KErrNone;

	}

/**

Connects to the domain identified by the specified domain Id.

To connect to the root domain, which has the Id KDmIdRoot,

the capability WriteDeviceData is required.

Once connected, an  application can use this RDmDomain object to read

the domain's state and to request notification

when the state changes.

@param aHierarchyId	The Id of the domain hierarchy to connect to.

@param aDomainId    The identifier of the domain to be connected to.

@return KErrNone, if successful; otherwise one of the other system-wide

        or Domain Manager specific error codes.

@capability WriteDeviceData If aDomainId==KDmIdRoot

*/

EXPORT_C TInt RDmDomain::Connect(TDmHierarchyId aHierarchyId, TDmDomainId aDomainId)

	{

	TUint key;

	TInt r = iSession.Connect(aHierarchyId, aDomainId, &key);

	if (r != KErrNone)

		return r;

	r = iStateProperty.Attach(KUidDmPropertyCategory, key);

	if (r != KErrNone)

		{

		iSession.Close();

		return r;

		}

	return KErrNone;

	}

/**

Disconnects from the associated domain.

If this object is not connected to any domain, then it returns silently.

*/

EXPORT_C void RDmDomain::Close()

	{

	iSession.Close();

	iStateProperty.Close();

	}

/**

Requests notification when the domain's state changes.

This is an asynchronous request that completes when

the domain's state changes.

@param aStatus The request status object for this asynchronous request.

@see RDmDomain::CancelTransitionNotification()

*/

EXPORT_C void RDmDomain::RequestTransitionNotification(TRequestStatus& aStatus)

	{

	iStateProperty.Subscribe(aStatus);

	iSession.RequestTransitionNotification();

	}

/**

Cancels an outstanding notification request.

Any outstanding notification request completes with KErrCancel.

*/

EXPORT_C void RDmDomain::CancelTransitionNotification()

	{

	iSession.CancelTransitionNotification();

	iStateProperty.Cancel();

	}

/**

Gets the domain's power state.

An application normally calls this function after a notification request

has completed. It then performs any application-dependent action demanded by

the power state, and then acknowledges the state transition.

Note that the Domain Manager requires any domain power state change to be

acknowledged by all applications connected to the domain.

@return The connected domain's power state.

@see RDmDomain::AcknowledgeLastState()

*/

EXPORT_C TPowerState RDmDomain::GetPowerState()

	{

	TInt value;

	TInt r = iStateProperty.Get(value);

	if (r != KErrNone)

		__DM_PANIC(r);

	iLastStatePropertyValue = value;

	return (TPowerState) DmStateFromPropertyValue(value);

	}

/**

Acknowledges the state change.

An application must acknowledge that it has performed all actions required

by the last known state of the domain.

*/

EXPORT_C void RDmDomain::AcknowledgeLastState()

	{

	TInt r = iSession.Acknowledge(iLastStatePropertyValue, KErrNone);

	if (r != KErrNone && r != KErrNotFound)

		__DM_PANIC(r);

	}

/**

Acknowledges the state change with the specified error

An application must acknowledge that it has performed all actions required

by the last known state of the domain.

@param aError KDmErrNotJoin if domain is not part of the hierarchy or a

	system wide error value associated with the state change.

*/

EXPORT_C void RDmDomain::AcknowledgeLastState(TInt aError)

	{

	TInt r = iSession.Acknowledge(iLastStatePropertyValue, aError);

	if (r != KErrNone && r != KErrNotFound)

		__DM_PANIC(r);

	}

/**

Acknowledges the state change with the specified error

@param aError KDmErrNotJoin if domain is not part of the hierarchy or a

	system wide error value associated with the state change.

@return KErrNone If the acknowledgment was valid, KErrNotFound if it was spurious

*/

TInt RDmDomain::AcknowledgeLastStatePriv(TInt aError)

	{

	return iSession.Acknowledge(iLastStatePropertyValue, aError);

	}

/**

Having received a state transition notification, instead of acknowledging,

request more time. To be sure of deferring in time a client should call this immediately

after receiving notification. This asynchronous call will complete once the original deadline

is reached (ie. one period earlier than the final deadline), at which point the member must either

defer again or acknowledge the transition. In the meantime, the member should perform

its transition actions, whilst remaining responsive to new completion events.

For example, if after receiving a transition notification, the client calls DeferAcknowledgement

once, but fails to acknowledge or renew its deferral, it would be timed out after two time periods.

Once the member has completed all necessary actions it should call AcknowledgeLastState

to indicate a successful transition (it need not wait for the completion of DeferAcknowledgement).

@note Deferrals are not always possible,

whether the member will actually be given more time depends on if

   - The current transition allows deferrals at all.

   - The member still has deferrals left - there may be a maximum number

     allowed.

   - The deferral request was received in time.

@param aStatus Status of request

   - KErrNone Request has completed i.e. The member must either defer again or acknowledge.

   - KErrCompletion The deferral was obsoleted by a subsequent call to AcknowledgeLastState.

   - KErrNotSupported The current transition may not be deferred, or maximum deferral count reached.

   - KErrCancel The deferral was cancelled.

   - KErrNotReady Deferral attempted before a transition notification was received

     or after the deadline for the previous one.

   - KErrPermissionDenied The member lacked the necessary capabilities.

   - KErrServerBusy A deferral was already outstanding.

This function is provided for members to inform the Domain Manager that they

are still active and are responding to a transition notification.

For example, a server may have to persist data using

the file server before shut down. Since this task should be allowed to complete

before shutdown continues, the member should defer the transition, and then persist

the data, using asynchronous calls.

At least one of the below capabilities is required in order to defer a

domain transition. Without them, the client will get KErrPermissionDenied.

@capability WriteDeviceData

@capability ProtServ

@pre The member has been notified of a transition which it has not yet acknowledged

*/

EXPORT_C void RDmDomain::DeferAcknowledgement(TRequestStatus& aStatus)

	{

	iSession.DeferAcknowledgement(aStatus);

	}

/**

Will cancel a call of DeferAcknowledgement(), if one was pending.

If none was pending, it does nothing.

*/

EXPORT_C void RDmDomain::CancelDeferral()

	{

	iSession.CancelDeferral();

	}

/**

Gets the domain's state.

An application normally calls this function after a notification request

has completed. It then performs any application-dependent action demanded by

the state, and then acknowledges the state transition.

Note, that the Domain Manager requires any domain state change to be

acknowledged by all applications connected to the domain.

@return The connected domain's state.

*/

EXPORT_C TDmDomainState RDmDomain::GetState()

	{

	TInt value;

	TInt r = iStateProperty.Get(value);

	if (r != KErrNone)

		__DM_PANIC(r);

	iLastStatePropertyValue = value;

	return DmStateFromPropertyValue(value);

	}

TInt RDmManagerSession::Connect()

	{

	__DM_ASSERT(Handle() == KNullHandle);

	return RSessionBase::CreateSession(

				KDmManagerServerNameLit, 

				KDmManagerServerVersion, 

				2);

	}

TInt RDmManagerSession::ConnectObserver(TDmHierarchyId aHierarchyId)

	{

	TInt r = Connect();

	if (r != KErrNone)

		return r;

	TIpcArgs a( (TInt)aHierarchyId);

	r = RSessionBase::SendReceive(EDmObserverJoin, a);

	if (r != KErrNone)

		{

		RSessionBase::Close();

		return r;

		}

	return KErrNone;

	}

TInt RDmManagerSession::Connect(TDmHierarchyId aHierarchyId)

	{

	TInt r = Connect();

	if (r != KErrNone)

		return r;

	TIpcArgs a( (TInt)aHierarchyId);

	r = RSessionBase::SendReceive(EDmHierarchyJoin, a);

	if (r != KErrNone)

		{

		RSessionBase::Close();

		return r;

		}

	return KErrNone;

	}

void RDmManagerSession::RequestDomainTransition(

	TDmDomainId aDomainId, 

	TDmDomainState aState,

	TDmTraverseDirection aDirection,

	TRequestStatus& aStatus)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	if(aDirection < 0 || aDirection > ETraverseMax)

		__DM_PANIC(KErrArgument);

	TIpcArgs a(aDomainId, aState, aDirection);

	RSessionBase::SendReceive(EDmRequestDomainTransition, a, aStatus);

	}

void RDmManagerSession::CancelTransition()

	{

	if (Handle() != KNullHandle)

		{

		TInt r = RSessionBase::SendReceive(EDmCancelTransition);

		if (r != KErrNone)

			__DM_PANIC(r);

		}

	}

void RDmManagerSession::CancelObserver()

	{

	if (Handle() != KNullHandle)

		{

		TInt r = RSessionBase::SendReceive(EDmObserverCancel);

		if (r != KErrNone)

			__DM_PANIC(r);

		}

	}

void RDmManagerSession::RequestSystemTransition(

	TDmDomainState aState,

	TDmTraverseDirection aDirection,

	TRequestStatus& aStatus)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	TIpcArgs a(aState, aDirection);

	RSessionBase::SendReceive(EDmRequestSystemTransition, a, aStatus);

	}

TInt RDmManagerSession::AddDomainHierarchy(TDmHierarchyId aHierarchyId)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	TIpcArgs a( (TInt)aHierarchyId);

	TInt r = RSessionBase::SendReceive(EDmHierarchyAdd, a);

	return r;

	}

TInt RDmManagerSession::GetTransitionFailureCount()

	{

	__DM_ASSERT(Handle() != KNullHandle);

	return RSessionBase::SendReceive(EDmGetTransitionFailureCount);

	}

TInt RDmManagerSession::GetTransitionFailures(RArray<const TTransitionFailure>& aTransitionFailures)

	{

	__DM_ASSERT(Handle() != KNullHandle);

	aTransitionFailures.Reset();

	TInt err = KErrNone;

	TInt failureCount = GetTransitionFailureCount();

	if (failureCount <= 0)

		return failureCount;

	// Pre-allocate array with a known size which for this case is the value in failureCount 

	// in order to guarantee that future append operations to the array aTransitionFailures would

	// not fail. This is assuming that the pre-allocated size is not exceeded.

	err=aTransitionFailures.Reserve(failureCount); 

	if (err != KErrNone)

		return err;

	TTransitionFailure* failures = new TTransitionFailure[failureCount];

	if(failures == NULL)

		{		

		aTransitionFailures.Reset();

		return(KErrNoMemory);

		}

	TPtr8 dataPtr(reinterpret_cast<TUint8*>(failures), failureCount * sizeof(TTransitionFailure));

	TIpcArgs a(&dataPtr);

	err = RSessionBase::SendReceive(EDmGetTransitionFailures, a);

	if (err == KErrNone)

		{

		for (TInt i=0; i<failureCount; i++)	

			{

			err = aTransitionFailures.Append(failures[i]);		

			//The pre-allocation made above for the array aTransitionFailures should guarantee

			//that append operations complete succesfully.			

			__DM_ASSERT(err == KErrNone);	

			}

		}