--- /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 <e32std.h>
+#include <f32file.h>
+#include <e32math.h>
+#include "alfstreamerserver.h"
+#include "alfstreamerconsts.h"
+#include "alfstreamerbridge.h"
+#include "alfwindowmanager.h"
+#include "alfhierarchymodel.h"
+#include <ecom.h>
+#include <alf/AlfTransEffectPlugin.h>
+#include <alf/AlfTransEffectPlugin.hrh>
+
+
+// ==================================
+// 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<TInt> id(reinterpret_cast<TInt>(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<TInt>(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<TInt>(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<TInt>(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<TInt>(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<TInt>(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<CAlfStreamerServerSession*>(*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<TInt>(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<TInt>(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*>((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<TAlfNativeWindowData> 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<TInt>(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