diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerCore/Src/alfstreamerserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/ServerCore/Src/alfstreamerserver.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,871 @@ +/* +* Copyright (c) 2006 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: Server implementation fo share files in application private gage +* with controlled way +* +*/ + + + +#include +#include +#include +#include "alfstreamerserver.h" +#include "alfstreamerconsts.h" +#include "alfstreamerbridge.h" +#include "alfwindowmanager.h" +#include "alfhierarchymodel.h" +#include +#include +#include + + +// ================================== +// Launcher implementation. +// ================================== + +// --------------------------------------------------------------------------- +// DoAlfStreamerServerThreadStartFunctionL +// Construct the server object +// --------------------------------------------------------------------------- +// +LOCAL_C void DoAlfStreamerServerThreadStartFunctionL(CAlfStreamerBridge* aBridge) + { + CAlfStreamerServer::NewLC(aBridge); + + RThread().Rendezvous(KErrNone); + CActiveScheduler::Start(); + CleanupStack::PopAndDestroy(); // server + } + +// --------------------------------------------------------------------------- +// Entry point into the new thread +// --------------------------------------------------------------------------- +// +GLDEF_C TInt AlfStreamerServerThreadStartFunction(TAny* aBridge) + { + __UHEAP_MARK; + RThread thread; + + TInt err = User::RenameThread(KAlfStreamerServerThreadName); + if (err == KErrNone) + { + thread.SetPriority(EPriorityAbsoluteHigh); + thread.Close(); + + // Set up scheduler and cleanup stack for this thread + CActiveScheduler* scheduler = new CActiveScheduler; + if (!scheduler) + { + return KErrNoMemory; + } + CActiveScheduler::Install(scheduler); + CTrapCleanup* trapCleanup = CTrapCleanup::New(); + if (!trapCleanup) + { + return KErrNoMemory; + } + + // Set initial trap harness, and construct server object + TRAP(err,DoAlfStreamerServerThreadStartFunctionL((CAlfStreamerBridge*)aBridge)); + + delete CActiveScheduler::Current(); + delete trapCleanup; + } + __UHEAP_MARKEND; + return err; + } + +// --------------------------------------------------------------------------- +// LaunchServer +// --------------------------------------------------------------------------- +// +TInt CAlfStreamerServer::LaunchServer(TThreadId& aThreadId, CAlfStreamerBridge* aBridge) + { + // First, check that ther server isn't already running. + TFindServer findServer(ALFSTREAMER_SERVER_NAME); + TFullName name; + if (findServer.Next(name) == KErrNone) + { + return KErrAlreadyExists; + } + RThread serverThread; + + TInt err = serverThread.Create( + KAlfStreamerServerThreadName, + AlfStreamerServerThreadStartFunction, + 16384, // magic + 0, // uses caller thread's heap + (TAny*)aBridge, + EOwnerThread); + + aThreadId = serverThread.Id(); + TRequestStatus status; + serverThread.Rendezvous(status); + serverThread.Resume(); + serverThread.Close(); + User::WaitForRequest(status); + return err; + } + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +void CAlfStreamerServer::NewLC(CAlfStreamerBridge* aBridge) + { + CAlfStreamerServer* pS = new (ELeave) CAlfStreamerServer(aBridge); + CleanupStack::PushL(pS); + pS->ConstructL(); + } + +TInt DoRendezvous(TAny* aCallBack) + { + RThread().Rendezvous(KErrNone); + CAsyncCallBack* cb = (CAsyncCallBack*) aCallBack; + delete cb; + return KErrNone; + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CAlfStreamerServer::ConstructL() + { + StartL(ALFSTREAMER_SERVER_NAME); + + iWindowHierarcy = CAlfHierarchyModel::NewL(*this); + iWindowMgr = CAlfWindowManager::NewL(iWindowHierarcy); + iBridge->SetStreamerServer( *this ); + iThemesListener = CThemeRepositoryListener::NewL(); + iThemesListener->IssueRequest(); + iRendezvous = new (ELeave) CAsyncCallBack(EPriorityHigh*3); + iRendezvous->Set(TCallBack(DoRendezvous, iRendezvous)); + iRendezvous->CallBack(); + } + +// --------------------------------------------------------------------------- +// NewSessionL +// --------------------------------------------------------------------------- +// +CSession2* CAlfStreamerServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const + { + CSession2* newSession = new(ELeave) CAlfStreamerServerSession(); + iSessions++; + + return newSession; + } + +CAlfStreamerServerSession* CAlfStreamerServer::WservSession(TInt aScreenNumber) + { + CAlfStreamerServerSession* windowServerSession = NULL; + for(TInt i = 0; i < iWindowServerSessions.Count(); i++ ) + { + if(aScreenNumber == iWindowServerSessions[i]->ScreenNumber() ) + { + windowServerSession = iWindowServerSessions[i]; + break; + } + } + return windowServerSession; + } + + +// --------------------------------------------------------------------------- +// HandleClientExit +// --------------------------------------------------------------------------- +// +void CAlfStreamerServer::HandleClientExit(const CSession2* /*aClient*/) + { + iSessions--; + if (!iSessions) + { + // CActiveScheduler::Stop(); // TODO: lets not die, if client dies. + } + } + +// --------------------------------------------------------------------------- +// destructor of CAlfStreamerServer +// --------------------------------------------------------------------------- +// +CAlfStreamerServer::~CAlfStreamerServer() + { + delete iThemesListener; + delete iWindowMgr; + delete iWindowHierarcy; + iCompositionSessions.Close(); + iCompositionHostSessions.Close(); + iCompositionTokens.Close(); + iWindowServerSessions.Close(); + } + +void CAlfStreamerServer::AppendCompositionSessionL(CAlfStreamerServerSession* aSession, TBool aHost) + { + if(!aHost) + { + TInt index = iCompositionSessions.Find(aSession); + if (index == KErrNotFound) + { + iCompositionSessions.AppendL(aSession); + } + } + else + { + TInt index = iCompositionHostSessions.Find(aSession); + if (index == KErrNotFound) + { + iCompositionHostSessions.AppendL(aSession); + } + } + } +void CAlfStreamerServer::RemoveCompositionSession(CAlfStreamerServerSession* aSession) + { + TInt index = iCompositionSessions.Find(aSession); + if (index != KErrNotFound) + { + FreeCompositionSessionExtents(aSession); + TPckgC id(reinterpret_cast(aSession)); + for(TInt u = 0; u < iWindowServerSessions.Count(); u++ ) + { + if( aSession->ScreenNumber() == iWindowServerSessions[u]->ScreenNumber()) + { + TRAP_IGNORE(QueueRequestForSessionL(iWindowServerSessions[u], id, KAlfCompOpSessionClosed)); + } + } + + iCompositionSessions.Remove(index); + + } + TInt hostindex = iCompositionHostSessions.Find(aSession); + if (hostindex != KErrNotFound) + { + HBufC8* message = HBufC8::NewLC(8); + TInt session = reinterpret_cast(aSession); + TPtr8 clientBuf = message->Des(); + clientBuf.Insert(0, TPtrC8((TUint8*)&session ,sizeof(TInt))); + TInt newtarget = 0; + clientBuf.Insert(1 * sizeof(TInt), TPtrC8((TUint8*)&newtarget ,sizeof(TInt))); + for(TInt i = 0; i < iWindowServerSessions.Count(); i++ ) + { + if( aSession->ScreenNumber() == iWindowServerSessions[i]->ScreenNumber()) + { + TRAP_IGNORE(QueueRequestForSessionL(iWindowServerSessions[i], *message, KAlfCompOpBindSourceToToken)); // bind to 0 -> remove binding + } + } + CleanupStack::PopAndDestroy(); + iCompositionHostSessions.Remove(hostindex); + } + + // clean possible tokens for this composition source + TInt targetSession = reinterpret_cast(aSession); + for( TInt i = 0; i < iCompositionTokens.Count() ; i++) + { + if ( targetSession == iCompositionTokens[i].iTarget ) + { + iCompositionTokens.Remove(i); + i--; + } + }; + } + +void CAlfStreamerServer::HandleCompositionRequestL(CAlfStreamerServerSession* aSession, TInt aOp, const RMessage2& aMessage) + { + CAlfStreamerServerSession* wservsession = WservSession( aSession->ScreenNumber() ); + + TInt length = aMessage.GetDesLength(0); + User::LeaveIfError(length); + HBufC8* message = HBufC8::NewLC(length+4); + TPtr8 clientBuf = message->Des(); + aMessage.ReadL(0,clientBuf); + + if(aOp == KAlfCompOpSetExtent) + { + TInt* ptr = (TInt*)clientBuf.Ptr(); + TInt screennumber = ptr[4]; + if(screennumber!=aSession->ScreenNumber()) + { + aSession->ExtentSurfaceId().iInternal[0] = ptr[5]; + aSession->ExtentSurfaceId().iInternal[1] = ptr[6]; + aSession->ExtentSurfaceId().iInternal[2] = ptr[7]; + aSession->ExtentSurfaceId().iInternal[3] = ptr[8]; + wservsession = WservSession( screennumber ); + } + } + else if(aOp == KAlfCompOpSessionClosed) + { + FreeCompositionSessionExtents(aSession); + } + + TInt session = reinterpret_cast(aSession); + clientBuf.Insert(0, TPtrC8((TUint8*)&session ,sizeof(TInt))); + + if( wservsession ) // don't send to any wservsession if composition source does not have a window anywhere and this is not SetExtent operation + { + QueueRequestForSessionL(wservsession, clientBuf, aOp); + } + + CleanupStack::PopAndDestroy(); // unefficient.. + + if (!wservsession) + { + aMessage.Complete(KErrNotReady); + return; + } + + if( aOp == KAlfCompOpCreateSource ) + { + AppendCompositionSessionL(aSession); + aMessage.Complete(reinterpret_cast(aSession)); + } + else if ( aOp != KAlfCompOpSetZOrder ) + { + aMessage.Complete(KErrNone); + } + } + +void CAlfStreamerServer::QueueRequestForSessionL(CAlfStreamerServerSession* aSession, const TPtrC8& aPtr, TInt aOp) + { + aSession->QueueL(aPtr, aOp); + } + +void CAlfStreamerServer::QueueRequestAllSessionsL(const TPtrC8& aPtr, TInt aOp, TBool aAlsoWServ) + { + if (aAlsoWServ) + { + for(TInt i = 0; i < iWindowServerSessions.Count(); i++ ) + { + iWindowServerSessions[i]->QueueL(aPtr, aOp); + } + } + + for(TInt i = iCompositionSessions.Count()-1; i >= 0; i-- ) + { + iCompositionSessions[i]->QueueL(aPtr, aOp); + } + } + +TInt CAlfStreamerServer::CreatePermissionToken(const RMessage2& aMessage, TInt aTarget, CAlfStreamerServerSession* aSession) + { + TInt length = aMessage.GetDesLength(0); + User::LeaveIfError(length); + HBufC8* message = HBufC8::NewLC(length); + TPtr8 clientBuf = message->Des(); + aMessage.ReadL(0,clientBuf); + + TInt* ptr = (TInt*) clientBuf.Ptr(); + TInt newkey = Math::Random(); + + TRAPD( err, iCompositionTokens.AppendL( CCompositionToken( newkey, ptr[0] /* customer specified key */, + ptr[1] /*flags*/, aTarget, + aSession->ScreenNumber() ) ) ); + if (err) + { + newkey = 0; + } + RDebug::Print(_L("CAlfStreamerServer::CreatePermissionToken - newkey %d target: %d, err: %d"), newkey, aTarget, err ); + + CleanupStack::PopAndDestroy(message); + return newkey; + } + +void CAlfStreamerServer::ValidateToken( CAlfStreamerServerSession* aSession, const RMessage2& aMessage) + { + TInt length = aMessage.GetDesLength(0); + User::LeaveIfError(length); + HBufC8* message = HBufC8::NewLC(length + 12); + TPtr8 clientBuf = message->Des(); + aMessage.ReadL(0,clientBuf); + + TInt* ptr = (TInt*) clientBuf.Ptr(); + TInt tokenkey = ptr[1]; + TInt secret = ptr[2]; + // only AlfStreamer server knows the tokens. Thus it will pass the existing target and attribs to the client + TInt i = 0; + while( i < iCompositionTokens.Count() ) + { + if ( tokenkey == iCompositionTokens[i].iKey && secret == iCompositionTokens[i].iSecretKey ) + { + break; + } + i++; + }; + + if ( i < iCompositionTokens.Count()) + { + CAlfStreamerServerSession* wservsession = WservSession( iCompositionTokens[i].iScreenNumber ); + if( wservsession ) + { + aSession->SetScreenNumber( wservsession->ScreenNumber() ); +// CCompositionToken token(iCompositionTokens[i].iKey, iCompositionTokens[i].iSecretKey, iCompositionTokens[i].iFlags, iCompositionTokens[i].iTarget, iCompositionTokens[i].iScreenNumber); + TInt session = reinterpret_cast(aSession); + clientBuf.Insert(0, TPtrC8((TUint8*)&session ,sizeof(TInt))); + + if( iCompositionTokens[i].iCombinedTarget ) + { + clientBuf.Insert(1 * sizeof(TInt), TPtrC8((TUint8*)&iCompositionTokens[i].iKey ,sizeof(TInt))); + clientBuf.Insert(2 * sizeof(TInt), TPtrC8((TUint8*)&iCompositionTokens[i].iFlags ,sizeof(TInt))); + } + else + { + clientBuf.Insert(1 * sizeof(TInt), TPtrC8((TUint8*)&iCompositionTokens[i].iTarget ,sizeof(TInt))); + clientBuf.Insert(2 * sizeof(TInt), TPtrC8((TUint8*)&iCompositionTokens[i].iFlags ,sizeof(TInt))); + } + + AppendCompositionSessionL(aSession, ETrue); + // pass the updated buffer to client + QueueRequestForSessionL(wservsession, clientBuf, KAlfCompOpBindSourceToToken); + CleanupStack::PopAndDestroy(); // unefficient.. + aMessage.Complete(KErrNone); + } + else + { + CleanupStack::PopAndDestroy(); // unefficient.. + aMessage.Complete(KErrNotFound); + } + } + else + { + CleanupStack::PopAndDestroy(); // unefficient.. + aMessage.Complete(KErrNotFound); // client will get User::Leave after this. + } + } + +void CAlfStreamerServer::HandleCompositionEventL(CAlfStreamerServerSession* aSession, TInt aOp, const RMessage2& aMessage) + { + if ( aOp == KAlfCompositionWServReady ) + { + TInt index = iWindowServerSessions.Find(aSession); + if (index == KErrNotFound) + { + iWindowServerSessions.AppendL(aSession); + } + aMessage.Complete(KErrNone); + return; + } + + if ( aOp == KAlfCompositionLowOnGraphicsMemory || aOp == KAlfCompositionGoodOnGraphicsMemory + || aOp == KAlfCompositionTargetHidden ||aOp == KAlfCompositionTargetVisible) + { + aMessage.Complete(KErrNone); + QueueRequestAllSessionsL(KNullDesC8(), aOp, ETrue); + return; + } + + TInt length = aMessage.GetDesLength(0); + User::LeaveIfError(length); + HBufC8* message = HBufC8::NewLC(length); + TPtr8 clientBuf = message->Des(); + aMessage.ReadL(0,clientBuf); + + TInt* ptr = (TInt*) clientBuf.Ptr(); + CAlfStreamerServerSession* target = reinterpret_cast(*ptr); + + switch(aOp) + { + case KAlfCompositionFrameReady: + { + QueueRequestAllSessionsL(clientBuf.Right(4), aOp); + break; + } + case KAlfCompositionTargetCreated: + { + if (!target->MessagePtr().IsNull()) + { + // create a combined target token + if(ptr[1] > 0 ) + { + + TRAPD( err, iCompositionTokens.AppendL( + CCompositionToken( + ptr[1], // new token + ptr[2], // secret key + 0, + reinterpret_cast(aSession), + aSession->ScreenNumber(), + ETrue // combined target + ) ) ); + if (err) + { + ptr[1] = 0; + } + + } + + target->MessagePtr().Complete(ptr[1]); + } + break; + } + default: + break; + } + CleanupStack::PopAndDestroy(); + aMessage.Complete(KErrNone); + } + + +void CAlfStreamerServer::FreeCompositionSessionExtents(CAlfStreamerServerSession* aSession) + { + if( !aSession->ExtentSurfaceId().IsNull()) + { + for(TInt i = 0; i < iWindowServerSessions.Count(); i++) + { + if( aSession->ScreenNumber() != iWindowServerSessions[i]->ScreenNumber() ) + { + TInt session = reinterpret_cast(aSession); + TInt array[] = {session, 0,0,0,0, // TRect() + 0, // screennumber does not matter + aSession->ExtentSurfaceId().iInternal[0], + aSession->ExtentSurfaceId().iInternal[1], + aSession->ExtentSurfaceId().iInternal[2], + aSession->ExtentSurfaceId().iInternal[3] }; + TPtrC8 ptr((TUint8*)&array ,sizeof(array)); + QueueRequestForSessionL(iWindowServerSessions[i], ptr, KAlfCompOpSetExtent ); + } + } + aSession->ExtentSurfaceId().CreateNullId(); + } + } + +// --------------------------------------------------------------------------- +// constructor +// --------------------------------------------------------------------------- +// +CAlfStreamerServerSession::CAlfStreamerServerSession() : iScreenNumber(KErrNotFound) + { + } + +// --------------------------------------------------------------------------- +// destructor of CAlfStreamerServerSession +// --------------------------------------------------------------------------- +// +CAlfStreamerServerSession::~CAlfStreamerServerSession() + { + TInt i = 0; + RImplInfoPtrArray pluginArray; + REComSession::ListImplementationsL( KAlfGfxPluginInterfaceUId, pluginArray ); + for ( i = iLoadedPlugins.Count() - 1; i >= 0; i-- ) + { + TInt j = 0; + for ( j= 0; j < pluginArray.Count(); j++ ) + { + TUid loaded = TUid::Uid(iLoadedPlugins[i]); + TUid listed = pluginArray[j]->ImplementationUid(); + TPtrC8 listedopaque = pluginArray[j]->OpaqueData(); + if ( loaded == listed && ( (listedopaque.CompareF( KAlfDoNotUnloadPlugin )) != 0 ) ) + { + ((CAlfStreamerServer*)(Server()))->WindowMgr()->DestroyPlugin(TUid::Uid(iLoadedPlugins[i])); + } + } + } + // Clear the data in plugin array + for (TInt i = pluginArray.Count() - 1; i >= 0; i-- ) + { + // destroy + delete pluginArray[i]; + pluginArray.Remove( i ); + } + pluginArray.Close(); + iLoadedPlugins.Close(); + + CAlfStreamerServer* server = dynamic_cast((CAlfStreamerServer*)Server()); // nice const cast + server->RemoveCompositionSession((CAlfStreamerServerSession*)this); // deja vu + server->HandleClientExit(this); + } + + +// --------------------------------------------------------------------------- +// ServiceL +// --------------------------------------------------------------------------- +// +void CAlfStreamerServerSession::ServiceL(const RMessage2& aMessage) + { +// RDebug::Print(_L("CAlfStreamerServerSession::ServiceL %d"), aMessage.Function()); + CAlfStreamerServer* server = (CAlfStreamerServer*)( Server() ); + + TInt op = aMessage.Function(); + + // handle composition control ops in different function + if (op >= KAlfCompOpCreateSource) + { + HandleCompositionOpL(op, aMessage, server); + return; + } + + switch(op) + { + case EAlfBridgerBlindSend: + case EAlfBridgerSendChunk: + case EAlfBridgerRequestDataBlock: + case EAlfBridgerAsyncronousData: + case EDsNotifyNativeWindowData: + { + server->WindowTree()->HandleMessageL( aMessage ); + return; + } + + case EAlfDecodSLoadPlugin: + { + TInt index = iLoadedPlugins.Find(aMessage.Int0()); + TRAPD( err, server->WindowMgr()->LoadPluginL(TUid::Uid(aMessage.Int0())) ); + // was successfully loaded, add uid to session's array + if ( err == KErrNone || err == KErrAlreadyExists ) + { + if ( index == KErrNotFound ) + { + iLoadedPlugins.AppendL(aMessage.Int0()); + } + } + else + { + User::Leave( err ); + } + break; + } + case EAlfDecodSUnloadPlugin: + { + TInt index = iLoadedPlugins.Find(aMessage.Int0()); + if (index != KErrNotFound ) + { + RImplInfoPtrArray pluginArray; + REComSession::ListImplementationsL( KAlfGfxPluginInterfaceUId, pluginArray ); + TInt i = 0; + for ( i = 0; i < pluginArray.Count(); i++ ) + { + TUid loaded = TUid::Uid(aMessage.Int0()); + TUid listed = pluginArray[i]->ImplementationUid(); + TPtrC8 listedopaque = pluginArray[i]->OpaqueData(); + if ( loaded == listed && (listedopaque.CompareF( KAlfDoNotUnloadPlugin )) != 0 ) + { + iLoadedPlugins.Remove(index); + server->WindowMgr()->DestroyPlugin(TUid::Uid(aMessage.Int0())); + } + } + // Clear the data in plugin array, it is not going to be used any more. + for ( i = pluginArray.Count() - 1; i >= 0; i-- ) + { + // destroy + delete pluginArray[i]; + pluginArray.Remove( i ); + } + pluginArray.Close(); + } + break; + } + + case EAlfDecodSSendSynch: + case EAlfDecodSSendAsynch: + { + server->WindowMgr()->HandlePluginMsgL(aMessage); // will complete synch message immediately + return; // so message won't be completed + } + + case EAlfDecodSCancelAsynch: + { + server->WindowMgr()->CancelPluginMsg(TUid::Uid(aMessage.Int0()), aMessage.Int1()); + break; + } + + case EAlfDecodSPrepareFrame: + { + server->WindowMgr()->PrepareNewFrame(aMessage.Int0()); + break; + } + case EAlfSetScreenRotation: + { + TInt rotation = aMessage.Int0(); + aMessage.Complete(KErrNone); + server->Bridge()->AddData( EAlfBridgeSetScreenRotation,rotation); + break; + } + case EAlfGetNativeWindowHandles: + { + TPckgC data(server->Bridge()->iAlfWindowData); + aMessage.WriteL(0, data); + break; + } + + default: + { + aMessage.Complete(KErrNotSupported); + break; + } + } + if (!aMessage.IsNull()) + { + aMessage.Complete(KErrNone); + } +// RDebug::Print(_L("CAlfStreamerServerSession::ServiceL exit")); + } + +void CAlfStreamerServerSession::HandleCompositionOpL(TInt aOp, const RMessage2& aMessage, CAlfStreamerServer* aServer) + { + switch (aOp) + { + case KAlfCompOpRequestEvent: + { + iIsListeningCompositionEvents = ETrue; + if (!CompletedFromQueue(aMessage)) + { + iMessagePtr = aMessage; + } + break; + } + + case KAlfCompOpCancelEventRequest: + { + if (!iMessagePtr.IsNull()) + { + iMessagePtr.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + + case KAlfCompositionWServReady: + case KAlfCompositionFrameReady: + case KAlfCompositionLowOnGraphicsMemory: + case KAlfCompositionGoodOnGraphicsMemory: + case KAlfCompositionTargetHidden: + case KAlfCompositionTargetVisible: + case KAlfCompositionTargetCreated: + { + aServer->HandleCompositionEventL(this, aOp, aMessage); + break; + } + + // temp, should go to window server to have more precise control on + // operations + case KAlfCompOpCreateToken: + { + TInt token = aServer->CreatePermissionToken( aMessage, reinterpret_cast(this), this ); + aMessage.Complete(token); + break; + } + case KAlfCompOpBindSourceToToken: + { + aServer->ValidateToken(this, aMessage); // called method will complete aMessage + break; + } + case KAlfCompOpSetZOrder: + iMessagePtr = aMessage; + case KAlfCompOpCreateSource: + case KAlfCompOpEnableAlpha: + case KAlfCompOpSetOpacity: + case KAlfCompOpSetRotation: + case KAlfCompOpSetExtent: + case KAlfCompOpEnableKb: + case KAlfComOpSetBackgroundAnim: + case KAlfCompOpSessionClosed: + { + aServer->HandleCompositionRequestL(this, aOp, aMessage); + break; + } + case KAlfCompositionWServScreenNumber: + { + iScreenNumber = aMessage.Int0(); + aMessage.Complete(KErrNone); + break; + } + case KAlfCompositionSourceScreenNumber: + { + TInt length = aMessage.GetDesLength(0); + User::LeaveIfError(length); + HBufC8* message = HBufC8::NewLC(length); + TPtr8 clientBuf = message->Des(); + aMessage.ReadL(0,clientBuf); + + TInt* ptr = (TInt*) clientBuf.Ptr(); + iScreenNumber = ptr[0]; + + CleanupStack::PopAndDestroy(message); + aMessage.Complete(KErrNone); + break; + } + default: + // add debug guards or remove + RDebug::Print(_L("Oops, unknown composition command: %d "), aOp); + User::Invariant(); + } + } + +TBool CAlfStreamerServerSession::CompletedFromQueue(const RMessage2& aMessage) + { + if (iQueue.Count()) + { + TRAPD(err, aMessage.WriteL(0,*iQueue[0]/*->Des()*/)); + TInt cmd = iCmds[0]; + if (!err) + { + delete iQueue[0]; + iQueue.Remove(0); + iCmds.Remove(0); + } + else + { + RDebug::Print(_L("CAlfStreamerServerSession::CompletedFromQueue err: %d"),err); + } + if( !iMessagePtr.IsNull()) + { + iMessagePtr.Complete(err?err:cmd); + } + else + { + aMessage.Complete(err?err:cmd); + } + return ETrue; + } + return EFalse; + } + +void CAlfStreamerServerSession::QueueL(const TPtrC8& aPtr, TInt aCmd) + { + if (!iIsListeningCompositionEvents) + { + return; + } + + if (!iMessagePtr.IsNull()) + { + TRAPD(err, iMessagePtr.WriteL(0,aPtr)); + iMessagePtr.Complete(err?err:aCmd); + } + else + { + HBufC8* ptr = aPtr.AllocLC(); + TInt err = iCmds.Append(aCmd); + if (!err) + { + iQueue.AppendL(ptr); + } + User::LeaveIfError(err); + CleanupStack::Pop(); + } + } + +void CAlfStreamerServerSession::SetScreenNumber(TInt aScreennumber) + { + iScreenNumber = aScreennumber; + } + +TInt CAlfStreamerServerSession::ScreenNumber() const + { + return iScreenNumber; + } + +TSurfaceId& CAlfStreamerServerSession::ExtentSurfaceId() + { + return iExtentSurfaceId; + } +// end of file