/*

* 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 "alflogger.h"

#include <ecom.h>

#include <alf/AlfTransEffectPlugin.h>

#include <alf/AlfTransEffectPlugin.hrh>

// Implements just Error() to avoid panic

NONSHARABLE_CLASS(CSimpleScheduler) : public CActiveScheduler

    {

    void Error( TInt ) const{} // From CActiveScheduler

    };

// ==================================

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

        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);

    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

    {

    RThread t;    

    aMessage.Client(t);

    CleanupClosePushL(t);

	CSession2* newSession = new(ELeave) CAlfStreamerServerSession(t.Id());

    CleanupStack::PopAndDestroy();

    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 CAlfStreamerServerSession* aClient)

    {

    iSessions--;

    if (WindowMgr())

        {

        WindowMgr()->HandleClientExit(aClient->ThreadId());

        }

    for (TInt i = iSignals.Count()-1; i >= 0 ; i--)

        {

        if (iSignals[i].iSession == aClient)

            {

            // Don't complete because client is already being deleted    

            iSignals.Remove(i);

            }         

        }

    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();

    iAlfTargets.Close();

    iOptionalGRAM.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)

    {

    TInt length = aMessage.GetDesLength(0);

    User::LeaveIfError(length);

    HBufC8* message = HBufC8::NewLC(length+4);

    TPtr8 clientBuf = message->Des();

    aMessage.ReadL(0,clientBuf);

    HandleCompositionRequestL(aSession,aOp, clientBuf);

    if( aOp == KAlfCompOpCreateSource )

        {

        AppendCompositionSessionL(aSession);

        TAlfCompParams* param = (TAlfCompParams*)clientBuf.Ptr();

        for (TInt i = iAlfTargets.Count()-1;i >= 0; i--)

            {

            if (iAlfTargets[i].iWindowHandle == param->iWindowHandle&& 

                iAlfTargets[i].iWindowGroup == param->iWindowGroup)

                {

                aSession->AlfToken() = iAlfTargets[i].iTarget;

                __ALFLOGSTRING("CAlfStreamerServer::HandleCompositionRequestL(): Found ALF token for composition session")

                }     

            }    

        aMessage.Complete(reinterpret_cast<TInt>(aSession));

        }

    else if ( aOp != KAlfCompOpSetZOrder )

        {

        aMessage.Complete(KErrNone);

        }

    CleanupStack::PopAndDestroy(); // unefficient..

    }

void CAlfStreamerServer::HandleCompositionRequestL(CAlfStreamerServerSession* aSession, TInt aOp, TPtr8& aClientBuf)

    {

    CAlfStreamerServerSession* wservsession = WservSession( aSession ? aSession->ScreenNumber() : 0 );

    if (!wservsession)

        {

        __ALFLOGSTRING("CAlfStreamerServer::HandleCompositionRequestL(): Window server not connected yet")

        User::Leave(KErrNotReady);

        }

    if( aSession )

        {

        if(aOp == KAlfCompOpSetExtent ) 

            {

            TInt* ptr = (TInt*)aClientBuf.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 targetId = reinterpret_cast<TInt>(aSession);

        aClientBuf.Insert(0, TPtrC8((TUint8*)&targetId,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, aClientBuf, aOp);

        }

    }

void CAlfStreamerServer::CreatePermissionTokenL(TInt aAlfToken, TInt aWindowHandle, TInt aWindowGroup)

    {

    __ALFLOGSTRING3("CAlfStreamerServer::CreatePermissionTokenL %d, %d, %d >>",aAlfToken,aWindowHandle,aWindowGroup)

    TAlfCompParams param = {aAlfToken, aAlfToken, aWindowHandle, aWindowGroup};

    if (iAlfTargets.Find(param) != KErrNotFound)

        {

        __ALFLOGSTRING("CAlfStreamerServer::CreatePermissionTokenL: Already added")

        return;

        }    

    TPckg<TAlfCompParams> ptr(param);

    HandleCompositionRequestL(0, KAlfCompOpCreateSource, ptr);

    User::LeaveIfError(iAlfTargets.Append(param));

    __ALFLOGSTRING("CAlfStreamerServer::CreatePermissionTokenL <<")

    }

void CAlfStreamerServer::ReleasePermissionTokenL(TInt aAlfToken)

    {

    __ALFLOGSTRING("CAlfStreamerServer::ReleasePermissionTokenL >>")

    RemoveTargetFromInactiveSurfaces(aAlfToken);

    for (TInt i = 0; i < iAlfTargets.Count(); i++)

        {

        if (iAlfTargets[i].iTarget == aAlfToken)

            {

            TPckg<TInt> ptr(aAlfToken);

            HandleCompositionRequestL(0, KAlfCompOpSessionClosed, ptr);        

            iAlfTargets.Remove(i);

            __ALFLOGSTRING("CAlfStreamerServer::ReleasePermissionTokenL: Found <<")

            return;

            }

        }

    __ALFLOGSTRING("CAlfStreamerServer::ReleasePermissionTokenL: Not Found <<")

    }

void CAlfStreamerServer::FormAQueueL(TInt aOp, TInt aSecureId, TInt aWindowGroup)

    {

    __ALFLOGSTRING3("CAlfStreamerServer::FormAQueueL( %d, %d, %d )",aOp, aSecureId, aWindowGroup)

    if (aOp == EAlfVolunteerForGoomTarget)

        {

        TAlfCompParams param = {aSecureId, aSecureId, aWindowGroup, aWindowGroup};

        if (iOptionalGRAM.Find(param) != KErrNotFound)

            {

            __ALFLOGSTRING("CAlfStreamerServer::FormAQueueL: Already added");

            return;

            }    

        User::LeaveIfError(iOptionalGRAM.Append(param));

        }

    else

        {

        for(TInt i = iOptionalGRAM.Count()-1; i >= 0; i-- )

            {

            if ( iOptionalGRAM[i].iWindowGroup == aWindowGroup )

                {

                iOptionalGRAM.Remove(i);

                }       

            }    

        }    

    }

void CAlfStreamerServer::QueueRequestSessionsL(TInt aAlfToken, const TPtrC8& aPtr, TInt aOp)

    {

    __ALFLOGSTRING("CAlfStreamerServer::QueueRequestSessionsL >>")

    for(TInt i = iCompositionSessions.Count()-1; i >= 0; i-- )

        {

        if (iCompositionSessions[i]->AlfToken() == aAlfToken)

            {

            if (iCompositionSessions[i]->IsBgAnimSession() && 

                (aOp == KAlfCompositionTargetHidden || aOp == KAlfCompositionTargetVisible ))

                { // omit

                continue;    

                }        

            __ALFLOGSTRING("CAlfStreamerServer::QueueRequestSessionsL: Session found")

            iCompositionSessions[i]->QueueL(aPtr, aOp);

            }

        }

    __ALFLOGSTRING("CAlfStreamerServer::QueueRequestSessionsL <<")

    }

void CAlfStreamerServer::QueueRequestBGAnimSessionsL(const TPtrC8& aPtr, TInt aOp)

    {

    for(TInt i = iCompositionSessions.Count()-1; i >= 0; i-- )

        {

        if (iCompositionSessions[i]->IsBgAnimSession())

            {

            iCompositionSessions[i]->QueueL(aPtr, aOp);

            }

        }

    }

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( TCompositionToken( newkey, ptr[0] /* customer specified key */,

                                                                ptr[1] /*flags*/, aTarget,

                                                                aSession->ScreenNumber() ) ) );

    if (err)

        {

        newkey = 0;

        }

    __ALFLOGSTRING3("CAlfStreamerServer::CreatePermissionToken - newkey %d target: %d, err: %d", newkey, aTarget, err )

    CleanupStack::PopAndDestroy(message);

    return newkey; 

    }

void CAlfStreamerServer::ValidateToken( CAlfStreamerServerSession* aSession, const RMessage2& aMessage)