/*

* 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:   

*

*/

#include <alfdecoderserverclient.h>

#include <alfstreamerconsts.h>

#include <uiacceltk/HuiUtil.h>

#include <coemain.h>

#include <alf/alfcompositionclient.h>

#include "graphics/surfacemanager.h"

#include "graphics/surface.h"

#include "graphics/surfaceupdateclient.h"

#include "graphics/suerror.h" // KAllScreens

#include "graphics/surfaceconfiguration.h" // TSurfaceConfiguration

#include "alflogger.h"

// ---------------------------------------------------------------------------

// CAlfCompositionClientBaseData::NewL

// ---------------------------------------------------------------------------

//

CAlfCompositionClientBase::CAlfCompositionClientBaseData* 

    CAlfCompositionClientBase::CAlfCompositionClientBaseData::NewL(

            TInt aBufferSize, 

            RAlfBridgerClient* aClient)

    {

    CAlfCompositionClientBaseData* me = new (ELeave) CAlfCompositionClientBaseData();

    CleanupStack::PushL(me);

    me->ConstructL(aBufferSize, aClient);

    CleanupStack::Pop();

    return me;

    }

// ---------------------------------------------------------------------------

// CAlfCompositionClientBaseData::ConstructL

// ---------------------------------------------------------------------------

//

void CAlfCompositionClientBase::CAlfCompositionClientBaseData::ConstructL(TInt /*aBufferSize*/, RAlfBridgerClient* aClient)

    {

    if (!aClient)

        {

        iClient = new (ELeave) RAlfBridgerClient();     

        iOwnsClient = ETrue; 

        User::LeaveIfError(iClient->Connect());

        }

    else

        {

        iClient = aClient;

        }

    }

// ---------------------------------------------------------------------------

// ~CAlfCompositionClientBaseData

// ---------------------------------------------------------------------------

//

CAlfCompositionClientBase::CAlfCompositionClientBaseData::~CAlfCompositionClientBaseData()

    {

    if (iOwnsClient && iClient)

        {

        iClient->Close();

        delete iClient;    

        }

    if (iDeleted)

        {

        *iDeleted = ETrue;

        }    

    }    

// ---------------------------------------------------------------------------

// RequestEventL

// ---------------------------------------------------------------------------

//

EXPORT_C void CAlfCompositionClientBase::RequestEventL(TInt aBufferSize, RAlfBridgerClient* aClient)

    {

    if (!IsActive())

        {    

        if (!iData)

            {    

            iData = CAlfCompositionClientBaseData::NewL(aBufferSize, aClient);

            }

        SetActive();

        iData->iClient->SendAsynchronous(KAlfCompOpRequestEvent,TIpcArgs(&iData->iBuffer), iStatus);

        }    

    }            

// ---------------------------------------------------------------------------

// SendEvent

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CAlfCompositionClientBase::SendEvent(TInt aOp, const TAny* aEventData, TInt aEventSize)

    {

    // Todo, should support batching / asynch    

    if (!iData)

        {    

        TRAPD(err, iData = CAlfCompositionClientBaseData::NewL(aEventSize, 0)) // basically zero buffer would do 

        if (err)

            {

            return err;

            }    

        }

    TPtrC8 ptr(reinterpret_cast<const TUint8*>(aEventData), aEventSize);

    return iData->iClient->SendSynch(aOp, ptr); 

    }            

// ---------------------------------------------------------------------------

// HandleEventL

// ---------------------------------------------------------------------------

//

EXPORT_C void CAlfCompositionClientBase::HandleEventL(TInt /*aEventType*/, TAny* /*aEventData*/)

    {

    }

// ---------------------------------------------------------------------------

// NullBoolPtr

// ---------------------------------------------------------------------------

//

void NullBoolPtr(TAny* ptr)

    {

    TBool** boolptr = static_cast<TBool**>(ptr);

    *boolptr = 0;    

    }

// ---------------------------------------------------------------------------

// RunL

// ---------------------------------------------------------------------------

//

void CAlfCompositionClientBase::RunL()

    {

    TInt status = iStatus.Int();

    User::LeaveIfError(status);

    TBool deleted = EFalse;

    iData->iDeleted = &deleted; 

    CleanupStack::PushL(TCleanupItem(NullBoolPtr, &iData->iDeleted));

    HandleEventL(status, (void*)iData->iBuffer.Ptr());

    CleanupStack::PopAndDestroy();

    if (!deleted) // just small precaution if client deletes itself on callback

        {

        RequestEventL(sizeof(TInt));

        }

    } 

// ---------------------------------------------------------------------------

// DoCancel

// ---------------------------------------------------------------------------

//    

void CAlfCompositionClientBase::DoCancel()

    {

    if (iData)

        {

        iData->iClient->SendSynch(KAlfCompOpCancelEventRequest, TIpcArgs(Handle()) );

        }

    }    

// ---------------------------------------------------------------------------

// RunError

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CAlfCompositionClientBase::RunError(TInt aError)

    {

    RDebug::Print(_L("CAlfCompositionClientBase::RunError( %d )"),aError);

    if ( aError == KErrServerTerminated )

        {

        RDebug::Print(_L("CAlfCompositionClientBase::RunError - ALF server has died. Everything is lost. Halting."));

        USER_INVARIANT();

        }

    return KErrNone;

    }    

// ---------------------------------------------------------------------------

// ~CAlfCompositionClientBase

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfCompositionClientBase::~CAlfCompositionClientBase()

    {

    Cancel();

    delete iData;

    iData = NULL;

    }

// ---------------------------------------------------------------------------

// SetHandleL

// ---------------------------------------------------------------------------

//

EXPORT_C void CAlfCompositionClientBase::SetHandleL(TInt aHandle)

    {

    User::LeaveIfError(aHandle);

    if (!iData)

        {    

        iData = CAlfCompositionClientBaseData::NewL(sizeof(TInt),0);// basically zero buffer would do 

        }

    iData->iHandle = aHandle;

    }

// ---------------------------------------------------------------------------

// Handle

// ---------------------------------------------------------------------------

//

TInt CAlfCompositionClientBase::Handle() const

    {

    return iData?iData->iHandle:0;

    }

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfCompositionCntrlClient* CAlfCompositionCntrlClient::NewL(RAlfBridgerClient* aClient, MAlfCompositionController* aController)

    {

    CAlfCompositionCntrlClient* me = new (ELeave) CAlfCompositionCntrlClient(aController);    

    me->RequestEventL(60, aClient); // magic, extent with options

    me->SendEvent(KAlfCompositionWServReady,0,0);

    return me;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfCompositionCntrlClient::~CAlfCompositionCntrlClient()

    {

    iHostBindingsHash.Close();

    iHostPermittedOpsHash.Close();

    }

// ---------------------------------------------------------------------------

// HandleEventL

// ---------------------------------------------------------------------------

//

void CAlfCompositionCntrlClient::HandleEventL(TInt aEventType, TAny* aEventData)

    {

    __ASSERT_DEBUG(iController, USER_INVARIANT());

    if (aEventType == KAlfCompositionLowOnGraphicsMemory && iController)

        {

        iController->LowOnGraphicsMemory();    

        return;

        }

    if (aEventType == KAlfCompositionGoodOnGraphicsMemory && iController)

        {

        iController->GraphicsMemoryGood();

        return;

        }    

    if (aEventType == KAlfCompositionLayoutSwitchComplete && iController)

        {

        iController->AlfBridgeCallback(KAlfCompositionLayoutSwitchComplete, NULL);

        }

    TInt* ptr = static_cast<TInt*>(aEventData);

    TInt target;

    // find out if target is a host (is binded to some other target)

    TInt bindedTarget = 0;

    TInt* tempbind = iHostBindingsHash.Find(*ptr);

    if(tempbind)

        bindedTarget = *tempbind;

    TInt32 permittedOps = 0;

    if(bindedTarget)

        {

        target = bindedTarget;

        TInt32* tempOps = iHostPermittedOpsHash.Find(*ptr);

        if(tempOps)

            permittedOps = *tempOps; 

        }

    else

        {

        target = *ptr;

        }

    // SetTargetL is always sent before the actual command.

    iController->SetTargetL(target); // When this is composition

    switch (aEventType)

        {

        case KAlfCompOpCreateToken:

            {

            break;

            }

        case KAlfCompOpBindSourceToToken:

            {

            RDebug::Print(_L("ptr0: %d, Target %d, Flags %d, combinedtarget"), ptr[0], ptr[1], ptr[2]);

            if( ptr[1] != 0) // add binding information for new host to given target with permitted operations

                {

                iHostBindingsHash.Insert(*ptr, ptr[1]);

                iHostPermittedOpsHash.Insert(*ptr, ptr[2]);

                }

            else // remove old host bindings when the host is being deleted.

                {

                iHostBindingsHash.Remove(*ptr);

                iHostPermittedOpsHash.Remove(*ptr);

                }

            break;

            }

        case KAlfCompOpCreateSource:    

            {

            iController->CreateTargetL(target, ptr[2], ptr[3]); 

            break;

            }    

        case KAlfCompOpEnableAlpha:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeAlpha)

                {

                iController->EnableAlpha(ptr[1]);

                }

            break;

            }    

        case KAlfCompOpSetOpacity:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeOpacity)

                {

                TReal32* opacity = /*static_cast<*/(TReal32*)(++ptr);

                iController->SetOpacity(*opacity);

                }

            break;

            }    

        case KAlfCompOpSetRotation:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeRotation)

                {      

                iController->SetRotation(ptr[1]);

                }

            break;

            }     

        case KAlfCompOpSetZOrder:

            {

            TInt newToken = 0;

            if( ptr[3] != KErrNotFound)

                {

                newToken = iController->SetOrder(target,ptr[1],ptr[2],ETrue); //  top, below, combineTargets             

                }

            else

                {

                newToken = iController->SetOrder(target,ptr[1],ptr[2],EFalse); //  top, below, combineTargets             

                }

            TInt array[] = {ptr[0], newToken, ptr[3]}; // caller session, newToken, secretKey

            SendEvent(KAlfCompositionTargetCreated, array, sizeof(array));

            break;

            }    

        case KAlfCompOpSetExtent:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeExtent)

                {

                TRect rect(ptr[1],ptr[2],ptr[3],ptr[4]);

                TSurfaceId surfaceId;

                surfaceId.iInternal[0] = ptr[6];

                surfaceId.iInternal[1] = ptr[7];

                surfaceId.iInternal[2] = ptr[8];

                surfaceId.iInternal[3] = ptr[9];

                iController->SetExtentSurfaceId(surfaceId);

                iController->SetExtent(rect, ptr[5]); // rect, screen

                }

            break;

            }

        case KAlfCompOpSetSRect:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeExtent)

                {

                TRect rect(ptr[1],ptr[2],ptr[3],ptr[4]);

                iController->SetSourceRect(rect);

                }

            break;

            }

        case KAlfComOpSetBackgroundAnim:

            {

            if ( !bindedTarget || permittedOps & CAlfCompositionHost::EAlfAllowChangeBackgroundAnim)

                {

                iController->SetIsBackgroundAnim(ptr[1]);

                }

            break;

            }

        case KAlfCompOpSessionClosed:

            {

            iController->DeleteTarget(target);

            break;

            }

        case KAlfCompositionTargetVisible:

            {

            iController->HideTarget(target, EFalse);

            break;

            }    

        case KAlfCompositionTargetHidden:

            {

            iController->HideTarget(target, ETrue);

            break;

            }    

        default:

            break;

        }

    }    

// ---------------------------------------------------------------------------

// RunError

// ---------------------------------------------------------------------------

//

TInt CAlfCompositionCntrlClient::RunError(TInt aError)

    {

    CAlfCompositionClientBase::RunError(aError);

    // reactivate

    TRAPD(err, RequestEventL(60)); // magic, extent with options

    return err;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

NONSHARABLE_CLASS(CAlfCompositionSource::CAlfCompositionSourceData):public CBase

    {

    public:

    static CAlfCompositionSourceData* NewL()

        {

        CAlfCompositionSourceData* me = new (ELeave) CAlfCompositionSourceData();

        CleanupStack::PushL(me);

        // jada

        CleanupStack::Pop();

        return me;

        }

    ~CAlfCompositionSourceData()

        {

        if (iDeleted)

            {

            *iDeleted = ETrue;

            }    

        iObservers.Reset();

        }    

    TBool* iDeleted;

    TSurfaceId iSurfaceId;

    RPointerArray<MAlfCompositionObserver> iObservers;

    };

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfCompositionSource* CAlfCompositionSource::NewL(RWindow& aClientWindow)

    {

    CAlfCompositionSource* me = new (ELeave) CAlfCompositionSource();

    CleanupStack::PushL(me);

    me->ConstructL(aClientWindow);

    CleanupStack::Pop(me);

    return me;

    }

// ---------------------------------------------------------------------------

// ~CAlfCompositionSource

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfCompositionSource::~CAlfCompositionSource()

    {

    delete iData;

    iData = NULL;

    }

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

//

void CAlfCompositionSource::ConstructL(TInt aWsHandle, TInt aGroupHandle, TInt aScreenNumber)

    {

    iData = CAlfCompositionSourceData::NewL();

    RDebug::Print(_L("CAlfCompositionClientBase::ConstructL - %d"), iData );

    User::LeaveIfError( SendEvent(KAlfCompositionSourceScreenNumber, &aScreenNumber, sizeof(TInt)));

    TInt array[] = { 0, aWsHandle, aGroupHandle}; 

    TInt handle = SendEvent(KAlfCompOpCreateSource, array, sizeof(array));   

    SetHandleL(handle);

    }

void CAlfCompositionSource::ConstructL(RWindow& aClientWindow)

    {

    ConstructL(aClientWindow.ClientHandle(), aClientWindow.WindowGroupId(), aClientWindow.ScreenNumber());

    TSurfaceConfiguration surfaceConfigs;

    User::LeaveIfError(aClientWindow.GetBackgroundSurface(surfaceConfigs));

    surfaceConfigs.GetSurfaceId(iData->iSurfaceId);

    if(iData->iSurfaceId.IsNull())

        {

        __ALFLOGSTRING( "CAlfCompositionSource::NewL - Window does not have background surface set - Leaving");

        User::Leave(KErrNotFound);

        }   

    }

// ---------------------------------------------------------------------------

// CreatePermissionToken

// ---------------------------------------------------------------------------

//  

EXPORT_C TInt CAlfCompositionSource::CreatePermissionToken(TInt aKey, TInt aPermissionFlags)

    {

    TInt array[] = {aKey, aPermissionFlags};    

    return SendEvent(KAlfCompOpCreateToken, array, sizeof(array));

    }    

// ---------------------------------------------------------------------------

// EnableAlpha

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CAlfCompositionSource::EnableAlpha(TBool aEnable)

    {

    return SendEvent(KAlfCompOpEnableAlpha, &aEnable, sizeof(TInt));

    }

// ---------------------------------------------------------------------------

// SetOpacity

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CAlfCompositionSource::SetOpacity(TReal32 aOpacity) __SOFTFP