// 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