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

//

#include "ssmstate.h"

#include <e32base.h>

#include "ssmadaptation.h"

#include "ssmdebug.h"

#include "ssmadaptationcmn.h"

#ifndef __SUSSTATEADAPTATION_H__

#define __SUSSTATEADAPTATION_H__

/**

CStateAdaptationRequests

CStateAdaptationObservers

These classes implement the State Adaptation related functionality as part of 

Adaptation server.These classes implement an active object to route the requests

and notifications to Adaptation plugins loaded by CSsmAdaptationServer.

These classes are also responsible for queueing the requests and pooling

the notification requests  when requests are received from multiple clients

Adaptation server handles only one request from each session and uses 

Cancel() methods to cancel any of the session's requests made before.

The queueing mechanism is to handle multiple clients at a time not to handle

multiple requests from one particular clients session.

@internalComponent

*/

class CStateAdaptationRequests : public CActive

{

public:

    static CStateAdaptationRequests* NewL(MStateAdaptation& aAdaptation);

 	~CStateAdaptationRequests();

	void Release();

	void DoRequestCoopSysStateChangeL(const RMessage2& aMessage);

	void DoRequestCoopSysSelfTestL(const RMessage2& aMessage);

	void DoRequestCoopSysPerformRestartActionsL(const RMessage2& aMessage);

	void DoRequestCoopSysPerformShutdownActionsL(const RMessage2& aMessage);

	void DoRequestCoopSysPerformRfsActionsL(const RMessage2& aMessage);

	void DoRequestCancel(const RMessage2& aMessage);

	MStateAdaptation& Adaptation();

protected:

	void RunL();

	TInt RunError( TInt aError );

	void DoCancel();

private:

	CStateAdaptationRequests(MStateAdaptation& aAdaptation);

	void SubmitOrQueueL(const RMessage2 &aMessage);	 	

	void Submit(CAdaptationMessage*& aMessage);

private:

	CAdaptationMessage *iCurrentMessage;

	RSsmAdaptationRequestQueue iPendingRequestsQueue;	

	MStateAdaptation& iStateAdaptation;

};

/**

Internal class for maintaining observers for notifications.Whenever a client 

registers for  StateAdaptation notifications it will be added to the observers

list and it will be notified when CStateAdaptationObservers receives notification

from the State Adaptation plugin loaded by CSsmAdaptationServer.Once client receives 

the notification it has to register again for getting further notification.  

@internalComponent

*/

class RStateAdaptationObserversList

	{

public:

	void AddObserverL(CAdaptationMessage *aNotificationMessage);

	void Close();

	TInt Count();

	void NotifyAndRemoveAll(TSsmCoopSysEventType aEventType,TInt aCompleteCode);

	void RemoveObserver(CAdaptationMessage *);

private:

	RPointerArray<CAdaptationMessage > iObservers;

	};

/**

CStateAdaptationRequests

CStateAdaptationObservers

These classes implement the State Adaptation related functionality as part of 

Adaptation server.These classes implement an active object to route the requests

and notifications to Adaptation plugins loaded by CSsmAdaptationServer.

These classes are also responsible for queueing the requests and pooling

the notification requests  when requests are received from multiple clients

Adaptation server handles only one request from each session and uses 

Cancel() methods to cancel any of the session's requests made before.

The queueing mechanism is to handle multiple clients at a time not to handle

multiple requests from one particular clients session.

@internalComponent

*/

class CStateAdaptationObservers : public CActive

{

public:

    static CStateAdaptationObservers* NewL(MStateAdaptation& aAdaptation);

    //static CStateAdaptationObservers* NewLC();

	~CStateAdaptationObservers();

	//from MStateAdaptation

	void DoGetLastCoopSysEvent(const RMessage2& aMessage);	

	void DoNotifyCoopSysEventL(const RMessage2& aMessage);

	void DoNotifyCoopSysEventCancelL(const RMessage2& aMessage);

protected:

	void RunL();

	TInt RunError( TInt aError );

	void DoCancel();

private:

	CStateAdaptationObservers(MStateAdaptation& aAdaptation);

	void StartNotification();

private:

	MStateAdaptation& iStateAdaptation;

	RStateAdaptationObserversList iObserversList;

	TPckgBuf<TSsmCoopSysEventType> iEventPckg;

};

#endif // __SUSSTATEADAPTATION_H__