// Copyright (c) 2007-2010 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:

//

#ifndef __SSMSTATEAWARESESSION_H__

#define __SSMSTATEAWARESESSION_H__

#include <e32base.h>

#include <domaindefs.h>

#include <domainmember.h>

#include <ssm/ssmstate.h>

class CSsmStateMonitor;

class CSsmDeferralMonitor;

/**

Read-only client interface to receive notifications when the

System State changes.

CSsmStateAwareSession wraps this class in an active object.

@see CSsmStateAwareSession 

@publishedPartner

@released

*/

NONSHARABLE_CLASS(RSsmStateAwareSession)

	{

public:

	IMPORT_C RSsmStateAwareSession();

	IMPORT_C TInt Connect(TDmDomainId aId);

	IMPORT_C void Close();

	IMPORT_C TSsmState State() const;

	IMPORT_C void RequestStateNotification(TRequestStatus& aStatus);

	IMPORT_C void RequestStateNotificationCancel();

	IMPORT_C void AcknowledgeStateNotification(TInt aError);

	IMPORT_C void AcknowledgeAndRequestStateNotification(TInt aError, TRequestStatus& aStatus);

	IMPORT_C void DeferAcknowledgement(TRequestStatus& aStatus);

	IMPORT_C void CancelDeferral();

private:

	RSsmStateAwareSession(const RSsmStateAwareSession& aState);

private:

	//The main reason for this class is to hide implementation details that might change

	class RPrivateImpl;

	RPrivateImpl* iPimpl;

	};

/**

Interface to implement for clients that want to use the @c CSsmStateAwareSession 

utility class.

@publishedPartner

@released

*/

class MStateChangeNotificationSubscriber

    {

public:

	/** 

	@c StateChanged is called when the System State have changed

	@param aSsmState contains the new System State

	@see TSsmMainSystemStates

	*/

	virtual void StateChanged(TSsmState aSsmState) = 0;

	};	

/**

Utility class for monitoring the System State. Maintains a list of 

subscribers that share a single active object. When the System State

changes the subscribers will be notified in the order

they were added to the list of subscribers.

@see TSsmMainSystemStates

@see RSsmStateAwareSession

@publishedPartner

@released

*/

NONSHARABLE_CLASS(CSsmStateAwareSession) : public CBase

	{

public:

	IMPORT_C static CSsmStateAwareSession* NewL(TDmDomainId aId);

	IMPORT_C static CSsmStateAwareSession* NewLC(TDmDomainId aId);

	IMPORT_C ~CSsmStateAwareSession();

	IMPORT_C TSsmState State() const;

	IMPORT_C void AddSubscriberL(MStateChangeNotificationSubscriber& aSubscriber);	

	IMPORT_C void RemoveSubscriber(const MStateChangeNotificationSubscriber& aSubscriber);

	// for CSsmStateMonitor

	void NotifySubscribers(TSsmState aNewState);

private:

	CSsmStateAwareSession();

	void ConstructL(TDmDomainId aId);

private:

	RPointerArray<MStateChangeNotificationSubscriber> iSubscribers; // Elements of the array are not owned.

	CSsmStateMonitor* iMonitor;

	TInt iSpare[4];

	};

/**

Interface to implement for clients that want to use the @c CExtendedSsmStateAwareSession 

utility class.

@publishedPartner

@released

*/

class MStateChangeNotificationSubscriber2

    {

public:

    /*HandleTransition() will be called when the transition notification

    comes in. Thereafter, the active object will contineouslly defer the transition.

    The implementation of this function should be used first to call

    RequestTransitionNotification() again if required, and then to initiate the

    response to the transition. It should be kept as quick as possible.

    Once the Domain Member's transition operations are complete, it should call

    AcknowledgeLastState() on this active object, to indicate it is ready to be

    transitioned*/

    virtual void HandleTransition(TInt aError) = 0;

    virtual TInt HandleDeferralError(TInt aError) = 0;

    };

/**

This class automatically deferrs transitions as long as possible after the original notification

is received.

To make use of this class, one has to implement the implement the HandleTransition()

in MStateChangeNotificationSubscriber2. HandleTransition() will be called when the transition notification

comes in. Thereafter, the active object will continually defer the transition.

This object is intended to simplify the handling of notifications and

deferrals. The member must ensure that other active objects do not block or

have long-running RunL()s; this is to ensure that the Active Scheduler will

remain responsive to the completion of deadline deferrals.

The capabilities needed are the same as those needed for RDmDomain::DeferAcknowledgement()

@capability WriteDeviceData

@capability ProtServ

@see 

*/

NONSHARABLE_CLASS(CSsmStateAwareSession2):public CActive 

	{

public:	

	IMPORT_C static CSsmStateAwareSession2* NewL(TDmDomainId aDomainId, MStateChangeNotificationSubscriber2& aSubscriber );

	IMPORT_C ~CSsmStateAwareSession2();

	IMPORT_C void RequestStateNotification();

    IMPORT_C void RequestStateNotificationCancel();

    IMPORT_C void AcknowledgeStateNotification(TInt aError);

    IMPORT_C void AcknowledgeAndRequestStateNotification(TInt aError);	  

	IMPORT_C TSsmState GetState();    

	TInt HandleDeferralError(TInt aError);

private:

	CSsmStateAwareSession2(MStateChangeNotificationSubscriber2& aSubscriber);

    void RunL();

    void DoCancel();

	void ConstructL(TDmDomainId aDomainId);  

private:

	RSsmStateAwareSession iSsmStateAwareSession;

	//For deferring the notification.

	CSsmDeferralMonitor* iDeferNotification;	

	MStateChangeNotificationSubscriber2* iSubscriber;

	};

#endif