--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/appfw/viewserver/server/VWSSESSN.CPP Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,682 @@
+// 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:
+//
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include "vwsinternal.h"
+#include "vwsdefpartner.h"
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+
+#include "VWSSESSN.H"
+#include "VWSERVER.H"
+#include "VWSQUEUE.H"
+#include "VWSSEVNT.H"
+#include "VWSPRIV.H"
+#include "VWSDEBUG.H"
+
+
+
+//
+// TVwsViewSwitchNotification
+//
+
+TVwsViewSwitchNotification::TVwsViewSwitchNotification()
+ : iViewId(KNullViewId), iIsOutstanding(EFalse)
+ {}
+
+void TVwsViewSwitchNotification::SetRequest(const TVwsViewId& aViewId)
+ {
+ iViewId=aViewId;
+ iIsOutstanding=ETrue;
+ }
+
+void TVwsViewSwitchNotification::ClearRequest()
+ {
+ iViewId=KNullViewId;
+ iIsOutstanding=EFalse;
+ }
+
+TBool TVwsViewSwitchNotification::IsViewToNotify(const TVwsViewId& aViewId) const
+ {
+ return (iIsOutstanding && (aViewId==iViewId || iViewId==KNullViewId));
+ }
+
+
+//
+// CVwsSession.
+//
+
+const TInt KVwsViewArrayGranularity=4;
+
+
+CVwsSession::~CVwsSession()
+ {
+ iIsExiting=ETrue;
+ iServer.HandleSessionRemoval(iClientThreadId);
+ delete iEventQueue;
+ delete iClientMessage;
+ }
+
+CVwsSession* CVwsSession::NewL(const TThreadId& aThreadId,CVwsServer& aServer)
+ {
+ CVwsSession* self=new(ELeave) CVwsSession(aThreadId,aServer);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+CVwsSession::CVwsSession(const TThreadId& aThreadId,CVwsServer& aServer)
+ :iServer(aServer),
+ iViewIdArray(KVwsViewArrayGranularity),
+ iActiveViewIndex(-1),
+ iLastActiveViewIndex(-1),
+ iClientThreadId(aThreadId),
+ iIsExiting(EFalse)
+ {
+ }
+
+void CVwsSession::ConstructL()
+ {
+#ifdef __DO_LOGGING__
+ iEventQueue=new(ELeave) CVwsEventQueue(_L("Session Queue (client unknown)"));
+#else
+ iEventQueue=new(ELeave) CVwsEventQueue;
+#endif
+ }
+
+void CVwsSession::ServiceL(const RMessage2& aMessage)
+ {
+ TBool completeMessage=ETrue;
+ switch (aMessage.Function())
+ {
+ case EVwsAsynchronousMessageForServerToPanicClientWith:
+ iPanicMessage=aMessage;
+ completeMessage=EFalse;
+ break;
+ case EVwsClose:
+ CActiveScheduler::Stop();
+ break;
+ case EVwsAddView:
+ AddViewL(aMessage);
+ break;
+ case EVwsSetSystemDefaultView:
+ SetSystemDefaultViewL(aMessage);
+ break;
+ case EVwsGetSystemDefaultView:
+ GetSystemDefaultViewL(aMessage);
+ break;
+ case EVwsRemoveView:
+ RemoveViewL(aMessage);
+ break;
+ case EVwsRequestViewEvent:
+ RequestViewEventL(aMessage);
+ completeMessage=EFalse;
+ break;
+ case EVwsRequestViewEventCancel:
+ CancelRequestViewEvent();
+ break;
+ case EVwsActivateView:
+ ActivateViewL(aMessage,ECompleteRequest);
+ completeMessage=EFalse;
+ break;
+ case EVwsCreateActivateViewEvent:
+ ActivateViewL(aMessage,EDoNotCompleteRequest);
+ break;
+ case EVwsRequestCustomMessage:
+ RequestCustomMessageL(aMessage);
+ break;
+ case EVwsStartApp:
+ StartAppL(aMessage);
+ completeMessage=EFalse;
+ break;
+ case EVwsDeactivateActiveView:
+ DeactivateActiveViewL(aMessage,ECompleteRequest);
+ completeMessage=EFalse;
+ break;
+ case EVwsDeactivateActiveViewIfOwnerMatch:
+ DeactivateActiveViewIfOwnerMatchL(aMessage,ECompleteRequest);
+ completeMessage=EFalse;
+ break;
+ case EVwsCreateDeactivateViewEvent:
+ DeactivateActiveViewL(aMessage,EDoNotCompleteRequest);
+ break;
+ case EVwsNotifyNextDeactivation:
+ NotifyNextDeactivationL(aMessage);
+ break;
+ case EVwsNotifyNextActivation:
+ NotifyNextActivationL(aMessage);
+ break;
+ case EVwsSetClientRequestTimeOut:
+ SetClientRequestTimeOut(aMessage);
+ break;
+ case EVwsSetServerEventTimeOut:
+ SetServerEventTimeOut(aMessage);
+ break;
+ case EVwsEnableServerEventTimeOut:
+ EnableServerEventTimeOut(aMessage);
+ break;
+ case EVwsCheckSourceOfViewSwitch:
+ CheckSourceOfViewSwitchL(aMessage);
+ break;
+ case EVwsPriority:
+ GetPriorityForActiveObjectL(aMessage);
+ break;
+ case EVwsEnableServerBlankScreen:
+ EnableServerBlankScreen(aMessage);
+ break;
+ case EVwsSetProtected:
+ SetProtectedL(aMessage);
+ break;
+ case EVwsSetCrossCheckUid:
+ iServer.SetCrossCheckUid(aMessage);
+ break;
+ case EVwsSetWindowBackgroundColor:
+ iServer.SetWindowBackgroundColor(aMessage);
+ break;
+ case EVwsCurrentActiveViewId:
+ GetCurrentActiveViewIdL(aMessage);
+ break;
+ default:
+ PanicClient(aMessage,EVwsBadRequest);
+ }
+ if (completeMessage && !aMessage.IsNull())
+ {
+ LOG3(CVwsLog::ENormal,_L("Auto completing with %d"),KErrNone);
+ aMessage.Complete(KErrNone);
+ }
+ }
+
+void CVwsSession::ServiceError(const RMessage2& aMessage,TInt aError)
+ {
+ LOG3(CVwsLog::ENormal,_L("Auto completing with %d"),aError);
+ CSession2::ServiceError(aMessage,aError);
+ }
+
+
+void CVwsSession::PanicClient(const RMessage2& aMessage,TInt aPanic)
+ {
+ if (!aMessage.IsNull())
+ {
+ aMessage.Panic(_L("ViewSrv"),aPanic);
+ }
+ }
+
+void CVwsSession::PanicClient(TInt aPanic)
+ {
+ __ASSERT_DEBUG(aPanic!=0,User::Invariant());
+ PanicClient(iPanicMessage,aPanic);
+ }
+
+
+TUid CVwsSession::AppUid() const
+ {
+ return iAppUid;
+ }
+
+CVwsSession::TState CVwsSession::State() const
+ {
+ return iState;
+ }
+
+void CVwsSession::RequestClientActivationL(MVwsSessionObserver& aObserver,const TVwsViewId& aViewId,
+ const TVwsViewId& aPreviousViewId,CVwsClientMessage* aClientMessage,RThread aThreadOfClientInitiatingViewSwitch)
+ {
+ User::LeaveIfError(aThreadOfClientInitiatingViewSwitch.Duplicate(RThread()));
+ CleanupClosePushL(aThreadOfClientInitiatingViewSwitch);
+ CVwsSessionEvent* activationEvent=new(ELeave) CVwsSessionEvent_Activation(*this,*iEventQueue,aObserver,aViewId,aPreviousViewId,aClientMessage,aThreadOfClientInitiatingViewSwitch);
+ aObserver.NowObserving(activationEvent);
+ CleanupStack::Pop(&aThreadOfClientInitiatingViewSwitch);
+ TRAPD(err, iEventQueue->ProcessEventL(activationEvent))
+ if(err!=KErrNone)
+ {
+ iLeaveAfterOwnershipTaken=ETrue;
+ User::Leave(err);
+ };
+ }
+
+void CVwsSession::RequestClientDeactivationL(MVwsSessionObserver& aObserver,const TVwsViewId& aViewId,const TVwsViewId& aActiveViewId, TBool aDifferentInstanceOfSameApp)
+ {
+ CVwsSessionEvent* deactivationEvent=new(ELeave) CVwsSessionEvent_Deactivation(*this,*iEventQueue,aObserver,aViewId,aActiveViewId, aDifferentInstanceOfSameApp);
+ aObserver.NowObserving(deactivationEvent);
+ iEventQueue->ProcessEventL(deactivationEvent);
+ }
+
+void CVwsSession::RequestScreenDeviceChangeNotificationL(MVwsSessionObserver& aObserver,const TVwsViewId& aViewId)
+ {
+ CVwsSessionEvent* screenDeviceChangeEvent=new(ELeave) CVwsSessionEvent_ScreenDeviceChangeNotification(*this,*iEventQueue,aObserver,aViewId);
+ aObserver.NowObserving(screenDeviceChangeEvent);
+ iEventQueue->ProcessEventL(screenDeviceChangeEvent);
+ }
+
+void CVwsSession::SetMessageHandler(MVwsMessageHandler& aMessageHandler)
+ {
+ ASSERT(iMessageHandler==NULL);
+ iMessageHandler=&aMessageHandler;
+ }
+
+void CVwsSession::ClearMessageHandler()
+ {
+ ASSERT(iMessageHandler);
+ iMessageHandler=NULL;
+ }
+
+void CVwsSession::AddViewL(const RMessage2& aMessage)
+ {
+ TVwsViewId viewId(ViewIdFromMessageL(aMessage));
+
+ if (iAppUid.iUid==0)
+ {
+ iAppUid.iUid=viewId.iAppUid.iUid;
+#ifdef __DO_LOGGING__
+ TBuf<64> queueName;
+ queueName.Format(_L("Session Queue for \"%x\""),iAppUid.iUid);
+ iEventQueue->SetName(queueName);
+#endif
+ }
+ else if (iAppUid!=viewId.iAppUid)
+ {
+ // All views added by the same client should have the same app uid.
+ PanicClient(aMessage,EVwsInvalidViewUid);
+ }
+
+ LOG4(CVwsLog::ENormal,_L("Adding view \"%x,%x\""),viewId.iAppUid.iUid,viewId.iViewUid.iUid);
+ AddViewL(viewId);
+ }
+
+void CVwsSession::RemoveViewL(const RMessage2& aMessage)
+ {
+ TVwsViewId viewId(ViewIdFromMessageL(aMessage));
+ LOG4(CVwsLog::ENormal,_L("Removing view \"%x,%x\""),viewId.iAppUid.iUid,viewId.iViewUid.iUid);
+ if (RemoveView(aMessage,viewId)==KErrNotFound)
+ {
+ PanicClient(aMessage,EVwsViewNotFound);
+ }
+ }
+
+void CVwsSession::SetSystemDefaultViewL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TVwsViewId> viewId;
+ aMessage.ReadL(0,viewId);
+ iServer.SetSystemDefaultViewL(aMessage.Int1(),viewId());
+ }
+
+void CVwsSession::GetSystemDefaultViewL(const RMessage2& aMessage)
+ {
+ TVwsViewId viewId;
+ iServer.GetSystemDefaultView(viewId);
+ TRAP_IGNORE(aMessage.WriteL(0,TPckgC<TVwsViewId>(viewId)));
+ }
+
+void CVwsSession::RequestViewEventL(const RMessage2& aMessage)
+ {
+ iViewEventMessage=aMessage;
+ const TInt error=aMessage.Int1();
+ switch (iState)
+ {
+ case EWaitingForClientRequest:
+ {
+ LOG4(CVwsLog::ENormal,_L("Client \"%x\" requested view event [session state: EWaitingClientRequest, last error: %d]"),iAppUid.iUid,error);
+ iState=EClientRequestPending;
+ CVwsEvent* headEvent=iEventQueue->Head();
+ if (headEvent)
+ {
+ STATIC_CAST(CVwsSessionEvent*,headEvent)->HandleViewEventRequestL(error,iViewEventMessage);
+ }
+ }
+ break;
+ case EClientRequestPending:
+ LOG3(CVwsLog::ENormal,_L("PANIC Client \"%x\" for requesting view event when one is already pending"),iAppUid.iUid);
+ PanicClient(aMessage,EVwsViewEventRequestAlreadyPending);
+ break;
+ default:
+ ASSERT(EFalse);
+ }
+ }
+
+void CVwsSession::CancelRequestViewEvent()
+ {
+ LOG3(CVwsLog::ENormal,_L("Client \"%x\" requested cancelation of view event request"),iAppUid.iUid);
+ if (iState==EClientRequestPending)
+ {
+ CompleteViewEvent(KErrCancel);
+ }
+ }
+
+void CVwsSession::CompleteViewEvent(TInt aNotification)
+ {
+ ASSERT(iState==EClientRequestPending);
+
+ if (iState==EClientRequestPending)
+ {
+ LOG4(CVwsLog::ENormal,_L("Completing view event in client \"%x\" with \"%d\""),iAppUid.iUid,aNotification);
+ iViewEventMessage.Complete(aNotification);
+ iState=EWaitingForClientRequest;
+ }
+ else
+ {
+ LOG3(CVwsLog::ELoud,_L("Completing view event in client \"%x\" - ERROR: No pending client request!"),iAppUid.iUid);
+ }
+ }
+
+void CVwsSession::CompleteViewEventL(TInt aNotification,const TVwsViewEvent& aEvent)
+ {
+ ASSERT(iState==EClientRequestPending);
+
+ if (aNotification==KErrNone && iState==EClientRequestPending)
+ {
+ LOG3(CVwsLog::ENormal,_L("Writing view event buffer to client \"%x\""),iAppUid.iUid);
+ iViewEventMessage.WriteL(0,TPckgC<TVwsViewEvent>(aEvent));
+ }
+ CompleteViewEvent(aNotification);
+ }
+
+void CVwsSession::ActivateViewL(const RMessage2& aMessage,TVwsCompleteRequest aCompleteRequest)
+ {
+ TPckgBuf<TVwsViewId> viewId;
+ aMessage.ReadL(0,viewId);
+ LOG5(CVwsLog::ENormal,_L("Client \"%x\" requested activation of \"%x,%x\""),iAppUid.iUid,viewId().iAppUid.iUid,viewId().iViewUid.iUid);
+ CVwsClientMessage* clientMessage=CVwsClientMessage::NewL(TUid::Uid(aMessage.Int1()),User::LeaveIfError(aMessage.GetDesLength(2)),aMessage,2);
+ LOG2(CVwsLog::ENormal,_L("Allocated custom message"));
+ iServer.ActivateViewL(viewId(),clientMessage,aMessage,*this,aCompleteRequest);
+ }
+
+void CVwsSession::RequestCustomMessageL(const RMessage2& aMessage)
+ {
+ if (iMessageHandler==NULL)
+ {
+ User::Leave(KErrUnknown);
+ }
+ iMessageHandler->WriteClientMessageL(aMessage);
+ }
+
+TVwsViewId CVwsSession::ViewIdFromMessageL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TVwsViewId> viewIdBuf;
+ aMessage.ReadL(0,viewIdBuf);
+ return viewIdBuf();
+ }
+
+void CVwsSession::StartAppL(const RMessage2& aMessage)
+ {
+ TUid appToStart={aMessage.Int0()};
+ iServer.RequestAppStartL(aMessage,appToStart);
+ }
+
+void CVwsSession::DeactivateActiveViewL(const RMessage2& aMessage,TVwsCompleteRequest aCompleteRequest)
+ {
+ iServer.RequestDeactivateActiveViewL(aMessage,*this,aCompleteRequest);
+ }
+void CVwsSession::DeactivateActiveViewIfOwnerMatchL(const RMessage2& aMessage,TVwsCompleteRequest aCompleteRequest)
+ {
+ if(iServer.ActiveViewSession() == this)
+ {
+ return DeactivateActiveViewL(aMessage, aCompleteRequest);
+ }
+ else if(aCompleteRequest==ECompleteRequest)
+ {
+ aMessage.Complete(KErrNone);
+ }
+ }
+
+void CVwsSession::NotifyNextDeactivationL(const RMessage2& aMessage)
+ {
+ iDeactivationNotification.SetRequest(ViewIdFromMessageL(aMessage));
+ }
+
+void CVwsSession::HandleDeactivationL(const TVwsViewId& aDeactivatedViewId, const TVwsViewId& aActivatedViewId)
+ {
+ if (iDeactivationNotification.IsViewToNotify(aDeactivatedViewId))
+ {
+ LOG3(CVwsLog::ENormal,_L("Requesting deactivation notification in \"%x\""),iAppUid);
+ iDeactivationNotification.ClearRequest();
+ CVwsSessionEvent* deactivationNotificationEvent=new(ELeave) CVwsSessionEvent_DeactivationNotification(*this,*iEventQueue,aDeactivatedViewId,aActivatedViewId);
+ iEventQueue->ProcessEventL(deactivationNotificationEvent);
+ }
+ }
+
+void CVwsSession::NotifyNextActivationL(const RMessage2& aMessage)
+ {
+ iActivationNotification.SetRequest(ViewIdFromMessageL(aMessage));
+ }
+
+void CVwsSession::HandleActivationL(const TVwsViewId& aActivatedViewId, const TVwsViewId& aViewToBeDeactivatedId)
+ {
+ if (iActivationNotification.IsViewToNotify(aActivatedViewId))
+ {
+ LOG3(CVwsLog::ENormal,_L("Requesting activation notification in \"%x\""),iAppUid);
+ iActivationNotification.ClearRequest();
+ CVwsSessionEvent* activationNotificationEvent=new(ELeave) CVwsSessionEvent_ActivationNotification(*this,*iEventQueue,aActivatedViewId,aViewToBeDeactivatedId);
+ iEventQueue->ProcessEventL(activationNotificationEvent);
+ }
+ }
+
+void CVwsSession::SetClientRequestTimeOut(const RMessage2& aMessage)
+ {
+ iServer.SetClientRequestTimeOut(TTimeIntervalMicroSeconds32(REINTERPRET_CAST(TInt32,aMessage.Ptr0())));
+ }
+
+void CVwsSession::SetServerEventTimeOut(const RMessage2& aMessage)
+ {
+ iServer.SetServerEventTimeOut(TTimeIntervalMicroSeconds32(REINTERPRET_CAST(TInt32,aMessage.Ptr0())));
+ }
+
+void CVwsSession::EnableServerEventTimeOut(const RMessage2& aMessage)
+ {
+ iServer.EnableServerEventTimeOut(TBool(REINTERPRET_CAST(TInt32,aMessage.Ptr0())));
+ }
+
+void CVwsSession::EnableServerBlankScreen(const RMessage2& aMessage)
+ {
+ iServer.EnableServerBlankScreen(aMessage.Int0());
+ }
+
+void CVwsSession::CheckSourceOfViewSwitchL(const RMessage2& aMessage)
+ {
+ if (iMessageHandler==NULL)
+ {
+ User::Leave(KErrUnknown);
+ }
+ iMessageHandler->CheckSourceOfViewSwitchL(aMessage);
+ }
+
+void CVwsSession::SetProtectedL(const RMessage2& aMessage)
+ {
+ iProtected = (aMessage.Int0() != 0);
+ }
+
+
+TInt CVwsSession::IndexById(const TVwsViewId& aViewId) const
+ {
+ const TInt numViews=iViewIdArray.Count();
+ for (TInt ii=0;ii<numViews;ii++)
+ {
+ if (iViewIdArray[ii] == aViewId)
+ {
+ return ii;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+TInt CVwsSession::GetTopView(TVwsViewId& aViewId)
+ {
+ TInt ret=KErrNone;
+ const TInt numViews=iViewIdArray.Count();
+ if (numViews && iLastActiveViewIndex!=-1 && iLastActiveViewIndex<numViews)
+ {
+ aViewId=iViewIdArray[(iLastActiveViewIndex) ? iLastActiveViewIndex : 0];
+ }
+ else
+ {
+ ret=KErrNotFound;
+ }
+ return ret;
+ }
+
+void CVwsSession::AddViewL(const TVwsViewId& aViewId)
+ {
+ iViewIdArray.AppendL(aViewId);
+ iServer.HandleSessionViewAddition(aViewId, iClientThreadId);
+ }
+
+TInt CVwsSession::RemoveView(const RMessage2& /*aMessage*/,const TVwsViewId& aViewId)
+ {
+ TBool systemView=iServer.IsSystemDefaultView(aViewId);
+ TInt index=IndexById(aViewId);
+ if (index==iActiveViewIndex && !systemView)
+ {
+ LOG4(CVwsLog::ENormal,_L("Not removing the currently active view [\"%x,%x\"]"),aViewId.iAppUid.iUid,aViewId.iViewUid.iUid);
+ return KErrInUse;
+ }
+ else if (index>=0)
+ {
+ iViewIdArray.Delete(index);
+ if (iActiveViewIndex>index)
+ {
+ iActiveViewIndex--;
+ iLastActiveViewIndex--;
+ }
+#ifdef _DEBUG
+ if (systemView)
+ {
+ LOG4(CVwsLog::ENormal,_L("Removed system default view [\"%x,%x\"]"),aViewId.iAppUid.iUid,aViewId.iViewUid.iUid);
+ }
+#endif
+ return KErrNone;
+ }
+
+ return KErrNotFound;
+ }
+
+void CVwsSession::SetActiveView(const TVwsViewId& aViewId)
+ {
+ iActiveViewIndex=IndexById(aViewId);
+ iLastActiveViewIndex=iActiveViewIndex;
+ }
+
+TVwsViewId CVwsSession::ActiveView() const
+ {
+ if (iViewIdArray.Count()>0 && iActiveViewIndex>=0)
+ {
+ return iViewIdArray[iActiveViewIndex];
+ }
+
+ return KNullViewId;
+ }
+
+void CVwsSession::ClearActiveView()
+ {
+ iActiveViewIndex=-1;
+ }
+
+TBool CVwsSession::HasActiveView() const
+ {
+ return (iActiveViewIndex==-1) ? EFalse : ETrue;
+ }
+
+TInt CVwsSession::CheckViewExists(const TVwsViewId& aViewId) const
+ {
+ return IndexById(aViewId);
+ }
+
+TBool CVwsSession::IsViewActive(const TVwsViewId& aViewId) const
+ {
+ if (iViewIdArray.Count()>0 && iActiveViewIndex>=0)
+ {
+ if (iViewIdArray[iActiveViewIndex]==aViewId)
+ {
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+ }
+
+TBool CVwsSession::Protected() const
+ {
+ return iProtected;
+ }
+
+
+//
+// CVwsClientMessage.
+//
+
+CVwsClientMessage* CVwsClientMessage::New()
+ {
+ CVwsClientMessage* self=new CVwsClientMessage();
+ return self;
+ }
+
+CVwsClientMessage* CVwsClientMessage::NewL()
+ {
+ CVwsClientMessage* self=new(ELeave) CVwsClientMessage();
+ return self;
+ }
+
+CVwsClientMessage* CVwsClientMessage::NewL(const TUid& aMessageId)
+ {
+ CVwsClientMessage* self=new(ELeave) CVwsClientMessage(aMessageId);
+ return self;
+ }
+
+CVwsClientMessage* CVwsClientMessage::NewL(const TUid& aMessageId,TInt aMessageLength,const RMessage2& aMessage,TInt aParameter)
+ {
+ CVwsClientMessage* self=new(ELeave) CVwsClientMessage(aMessageId);
+ CleanupStack::PushL(self);
+ self->ConstructL(aMessageLength,aMessage,aParameter);
+ CleanupStack::Pop();
+ return self;
+ }
+
+
+CVwsClientMessage::~CVwsClientMessage()
+ {
+ delete iMessage;
+ }
+
+CVwsClientMessage::CVwsClientMessage()
+ {
+ }
+
+CVwsClientMessage::CVwsClientMessage(const TUid& aMessageId)
+ : iMessageId(aMessageId)
+ {
+ }
+
+void CVwsClientMessage::ConstructL(TInt aMessageLength,const RMessage2& aMessage,TInt aParameter)
+ {
+ if (aMessageLength)
+ {
+ iMessage=HBufC8::NewL(aMessageLength);
+ TPtr8 ptr(iMessage->Des());
+ aMessage.ReadL(aParameter,ptr);
+ }
+ }
+
+void CVwsSession::GetPriorityForActiveObjectL(const RMessage2& aMessage)
+ {
+ TInt priority;
+ iServer.GetPriorityForActiveObjectL(priority);
+ aMessage.WriteL(0,TPckgBuf<TInt>(priority));
+ }
+
+void CVwsSession::GetCurrentActiveViewIdL(const RMessage2& aMessage)
+ {
+ TVwsViewId activeViewId;
+ iServer.GetCurrentActiveViewId(activeViewId);
+ aMessage.WriteL(0,TPckgBuf<TVwsViewId>(activeViewId));
+ }