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

//

#ifndef __VWSEVENT_H__

#define __VWSEVENT_H__

#include <e32std.h>

#include "VWSQUEUE.H"

#include "VWSERVER.H"

#include "VWSSESSN.H"

#include "VWSADDOB.H"

#include "VWSSEVNT.H"

/**

 * The CVwsThreadWatcher class actively watches an application thread and makes a call back on thread death.

 */

class CVwsThreadWatcher : public CActive

	{

public:

	~CVwsThreadWatcher();

	CVwsThreadWatcher();

	TInt StartWatching(const TThreadId& aThreadId, const TCallBack& aCallBack);

protected:

	void RunL();

	void DoCancel();

protected:

	RThread iThread;

	TCallBack iCallBack;

	};

class MVwsEventTimerObserver;

/**

 * The CVwsEventTimer class times the processing of an event and notifies an observer if the processing time

 * exceeds server limits.

 */

class CVwsEventTimer : public CBase

	{

public:

	enum TTimeOut

		{

		EUndefined,

		EClientRequestTimeOut,

		EServerEventTimeOut,

		EIntermediateEventTimeOut

		};

public:

	~CVwsEventTimer();

	static CVwsEventTimer* NewLC(const TTimeIntervalMicroSeconds32& aClientRequestTimeOut, const TTimeIntervalMicroSeconds32& aServerEventTimeOut);

	void Start(MVwsEventTimerObserver* aObserver,const TBool& aScreenDeviceChangeEvent);

public:

	static TInt TimerCallBack(TAny* aSelf);

	void DoTimerCallBack();

private:

	CVwsEventTimer(const TTimeIntervalMicroSeconds32& aClientRequestTimeOut, const TTimeIntervalMicroSeconds32& aServerEventTimeOut);

	void ConstructL();

private:

	CPeriodic* iPeriodic;

	MVwsEventTimerObserver* iObserver;

	TTimeIntervalMicroSeconds32 iClientRequestTimeOut;

	TTimeIntervalMicroSeconds32 iServerEventTimeOut;

	TTimeOut iTimeOutState;

	TBool iScreenDeviceChangeEvent;

	};

/**

 * The MVwsEventTimerObserver class provides an interface to handle time out call-backs from the CVwsEventTimer

 *

 */

class MVwsEventTimerObserver

	{

public:

	virtual void HandleTimeOut(CVwsEventTimer::TTimeOut aTimeOut)=0;

	};

/**

 * The CVwsServerEvent class is the base class for server events generated on receipt of requests to the view server.

 */ 

class CVwsServerEvent : public CVwsEvent

	{

public:

	CVwsServerEvent(CVwsServer& aServer,TType aType,CVwsEventQueue& aQueue);

	~CVwsServerEvent();

private:

	virtual void HandleLastOnQueue();

protected:

	CVwsServer& iServer;

	CVwsSessionEvent* iObserved;

	};

/**

 * The CVwsServerEvent_Activate class represents a view activation request in the server. It owns the message contents buffer

 * associated with a view activation request.

 */ 

class CVwsServerEvent_Activate : public CVwsServerEvent, public MVwsSessionObserver, public MVwsViewAdditionObserver, public MVwsEventTimerObserver

	{

public:

	CVwsServerEvent_Activate(CVwsServer& aServer,TType aType,CVwsEventQueue& aQueue,const TVwsViewId& aViewIdToActivate,CVwsClientMessage* aClientMessage,const RMessage2& aMessage,const TThreadId& aClientThreadId,TVwsCompleteRequest aCompleteRequest,CVwsThreadWatcher* aThreadWatcher, CVwsEventTimer* aEventTimer,const RThread& aThreadOfClientInitiatingViewSwitch);

	~CVwsServerEvent_Activate();

	static TInt AppThreadWatcherCallBack(TAny* aPtr);

private: // From CVwsServerEvent.

	virtual void ProcessEventL();

protected:

	virtual void HandleSessionRemoval(const TThreadId& aClientThreadId);

protected: // From MVwsSessionObserver.

	virtual void RequestCompleted(TRequestType aType,TInt aError,const RMessage2& aMessage);

	virtual void NowObserving(CVwsSessionEvent* aObserved);

	virtual void NullifyObserved();

private: // From MVwsViewAdditionObserver.

	virtual void HandleViewAdded(const TVwsViewId& aViewId, const TThreadId& aNewViewClientThreadId);

public: // from MVwsEventTimerObserver

	virtual void HandleTimeOut(CVwsEventTimer::TTimeOut aTimeOut);

protected:

	void RequestActivateNewView();

	void RequestActivateSystemDefaultView();

	void DoRequestActivateNewView(CVwsSession& aSessionWithNewView);

	void RequestDeactivateOldView();

	void RequestAppStart();

	void Complete(TInt aError);

	void StartAppStartProfile();

	void StopAppStartProfile();

	void StartActivationProfile();

	void StopActivationProfile();

private:

	enum TState

		{

		EPending,

		EAppStartRequested,

		EActivationRequested,

		ESystemDefaultActivationRequested,

		EDeactivationRequested

		};

	enum TWhichProfile

		{

		ENone,

		EAppStart,

		EActivation

		};

private:

	TInt RequestClientActivation(CVwsSession& aSession,CVwsClientMessage* aClientMessage,TState aNewState);

	void CustomCrossCheck(CVwsSession& aSessionWithNewView);

protected:

	TVwsViewId iViewIdToActivate;

	CVwsClientMessage* iClientMessage;

	TThreadId iNewViewClientThreadId;

private:

	TState iState;

	TWhichProfile iWhichProfile;

	TVwsCompleteRequest iCompleteRequest;

	CVwsSession* iSessionWithNewView;

	TThreadId iClientThreadId;

	const RMessage2 iMessage;

	CVwsThreadWatcher* iThreadWatcher;

	CVwsEventTimer* iEventTimer;

	RThread iThreadOfClientInitiatingViewSwitch;

	};

/**

 * The CVwsServerEvent_ScreenDeviceChanged class represents a screen device change request in the server.

 */ 

class CVwsServerEvent_ScreenDeviceChanged : public CVwsServerEvent_Activate

	{

public:

	CVwsServerEvent_ScreenDeviceChanged(CVwsServer& aServer,CVwsEventQueue& aQueue,CVwsThreadWatcher* aThreadWatcher, CVwsEventTimer* aEventTimer);

	~CVwsServerEvent_ScreenDeviceChanged();

	static TInt AppThreadWatcherCallBack(TAny* aPtr);

private: // From CVwsServerEvent.

	virtual void ProcessEventL();

	virtual void HandleAddedToQueue();

	virtual void HandleSessionRemoval(const TThreadId& aClientThreadId);

private: // From MVwsSessionObserver.

	virtual void RequestCompleted(TRequestType aType,TInt aError,const RMessage2& aMessage);

	virtual void NowObserving(CVwsSessionEvent* aObserved);

	virtual void NullifyObserved();

private:

	virtual void HandleTimeOut(CVwsEventTimer::TTimeOut aTimeOut);

private:

	void RequestChangeNotification();

	void RequestActivationAsRequiredL(const RMessage2& aMessage);

	void Complete(TInt aError);

private:

	enum TScreenDeviceNotificationState

		{

		EPending,

		EScreenDeviceChangeNotificationRequested,

		EViewActivationRequested,

		EDefaultSystemViewActivationRequested

		};

private:

	TScreenDeviceNotificationState iScreenDeviceNotificationState;

	CVwsThreadWatcher* iThreadWatcher;

	CVwsEventTimer* iEventTimer;

	};

/**

 * The CVwsServerEvent_DeactivateActiveView class represents a deactivation request in the server. A client view activation is

 * implemented as an activation followed by a deactivation event in the server.

 */

class CVwsServerEvent_DeactivateActiveView : public CVwsServerEvent, public MVwsSessionObserver, public MVwsEventTimerObserver

	{

public:

	CVwsServerEvent_DeactivateActiveView(CVwsServer& aServer,CVwsEventQueue& aQueue,const RMessage2& aMessage,const TThreadId& aClientThreadId,TVwsCompleteRequest aCompleteRequest,CVwsEventTimer* aEventTimer);

	~CVwsServerEvent_DeactivateActiveView();

private: // From CVwsServerEvent.

	virtual void ProcessEventL();

	virtual void HandleSessionRemoval(const TThreadId& aClientThreadId);

private: // From MVwsSessionObserver.

	virtual void RequestCompleted(TRequestType aType,TInt aError,const RMessage2& aMessage);

	virtual void NowObserving(CVwsSessionEvent* aObserved);

	virtual void NullifyObserved();

private: // from MVwsEventTimerObserver

	virtual void HandleTimeOut(CVwsEventTimer::TTimeOut aTimeOut);

private:

	void RequestDeactivationL();

	void Complete(TInt aError);

private:

	enum TState

		{

		EPending,

		EDeactivationRequested

		};

private:

	TState iState;

	TVwsViewId iActiveView;

	const RMessage2 iMessage;

	TThreadId iClientThreadId;

	TVwsCompleteRequest iCompleteRequest;

	CVwsEventTimer* iEventTimer;

	};

/**

 * The CVwsServerEvent_AppStart class represents a direct server-side app start request.

 */

class CVwsServerEvent_AppStart : public CVwsServerEvent, public MVwsViewAdditionObserver

	{

public:

	CVwsServerEvent_AppStart(CVwsServer& aServer,CVwsEventQueue& aQueue,const RMessage2& aMessage,const TUid& aAppToStart,CVwsThreadWatcher* aThreadWatcher);

	~CVwsServerEvent_AppStart();

	static TInt AppThreadWatcherCallBack(TAny* aPtr);

private: // From CVwsServerEvent.

	virtual void ProcessEventL();

private: // From MVwsViewAdditionObserver.

	virtual void HandleViewAdded(const TVwsViewId& aViewId, const TThreadId& aNewViewClientThreadId);

private:

	void RequestAppStart();

	void Complete(TInt aError);

private:

	enum TState

		{

		EPending,

		EAppStartRequested

		};

private:

	TState iState;

	TUid iAppToStart;

	const RMessage2 iMessage;

	CVwsSession* iSessionWithNewApp;

	CVwsThreadWatcher* iThreadWatcher;

	};

#endif