/*

* Copyright (c) 2007 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 client for alfredserver.exe

*

*/

#include "alfclient.h"

#include "alf/alfconstants.h"

#include "alfuids.h"

#include "alflogger.h"

#include "alfclientserver.h"

#include "alf/alftexture.h"

#include "alf/alfcontrol.h"

#include <e32math.h>

#include "uiacceltk/HuiUtil.h"

const TInt KAlfClientDefaultBatchBufferSize = 

    KAlfClientServerDefaultCommandBatchBufferSize;

// ======== HELPER CLASSES ========

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

// CBatchBufferAutoFlusher

//

// This class is responsible of flushing the client side command buffer

// when it gets time - hopefully as fast as possible after synchronous 

// commands.

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

//

NONSHARABLE_CLASS( RAlfClient::CBatchBufferAutoFlusher ) : public CActive

    {

public:

    CBatchBufferAutoFlusher( RAlfClient& aClient );

    ~CBatchBufferAutoFlusher();

    void StartAutoFlush();

protected:

    void RunL();

    void DoCancel();

private:

    RAlfClient& iClient;

    };

RAlfClient::CBatchBufferAutoFlusher::CBatchBufferAutoFlusher( RAlfClient& aClient )

 : CActive( EPriorityHigh+5), // Priority must be bigger than any received events from the server

    iClient( aClient ) 

    {

    CActiveScheduler::Add( this );

    }

RAlfClient::CBatchBufferAutoFlusher::~CBatchBufferAutoFlusher()

    {

    Cancel();

    }

void RAlfClient::CBatchBufferAutoFlusher::StartAutoFlush()

    {

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    }

void RAlfClient::CBatchBufferAutoFlusher::RunL()

    {

    iClient.FlushBatchBuffer();

    }

void RAlfClient::CBatchBufferAutoFlusher::DoCancel()

    {

    }

// ======== MEMBER FUNCTIONS ========

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

// Constructor

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

//

RAlfClient::RAlfClient()

    : RAlfClientBase(KAlfServiceUid.iUid), 

        iDefaultBatchBuffer(0), 

        iExtendedBatchBuffer(0),

        iUsedBatchBuffer(0),

        iAutoFlusher(0),

        iAutoFlushMode( EAlfAutoFlushDeferred ),

        iUsedMaxBufferSize( KAlfBatchBufferSizeNoLimit )

    {

    }

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

// "destructor"

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

//    

void RAlfClient::Disconnect()

    {

    if ( Handle() )

        {

        FlushBatchBuffer();

        }

    delete iExtendedBatchBuffer;

    iExtendedBatchBuffer = NULL;   

    delete iDefaultBatchBuffer;

    iDefaultBatchBuffer = NULL;

    iUsedBatchBuffer = NULL;

    delete iAutoFlusher;

    iAutoFlusher = NULL;

    Close();

    }

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

// Sets refresh mode

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

//   

void RAlfClient::EnvSetRefreshMode( TAlfRefreshMode aMode )

    {

    Send(EAlfEnvSetRefreshMode, TIpcArgs(aMode) );

    }

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

// Sets frame rate

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

//

void RAlfClient::EnvSetMaxFrameRate( TReal32 aFrameRate )

    {

    TPckg<TReal32> frameRatePckg( aFrameRate );

    SendReceive(EAlfEnvSetMaxFrameRate, TIpcArgs(&frameRatePckg) );

    }

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

// Shows control group in roster.

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

// 

TInt RAlfClient::RosterShow( 

    TInt aCntrlGroupHandle, 

    TInt aWhere, 

    TInt aDisplayHandle )

    {

    // Need to flush.

    FlushBatchBuffer();

    TInt err = SendReceive(

        EAlfRosterShow, 

        TIpcArgs(aCntrlGroupHandle, aWhere, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterShow return error %d", err )

        }

    return err;

    }

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

// Hides the control group from the roster.

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

//   

TInt RAlfClient::RosterHide( TInt aCntrlGroupHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterHide, 

        TIpcArgs(aCntrlGroupHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterHide return error %d", err )

        }

    return err;

    }

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

// 

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

//  

TInt RAlfClient::RosterShowVisual( TInt aVisualHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterShowVisual, 

        TIpcArgs(aVisualHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterShowVisual return error %d", err )

        }

    return err;

    }

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

// 

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

//  

TInt RAlfClient::RosterHideVisual( TInt aVisualHandle,  TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterHideVisual, 

        TIpcArgs(aVisualHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterHideVisual return error %d", err )

        }

    return err;

    }

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

// 

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

//  

TInt RAlfClient::RosterSetPointerEventObservers( 

    TInt aFlags, TInt aCntrlHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterSetPointerEventFlags, 

        TIpcArgs(aFlags, aCntrlHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterSetPointerEventObservers return error %d", err )

        }

    return err;

    }

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

// 

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

//    

TInt RAlfClient::RosterAddPointerEventObserver( 

    TAlfPointerEventFlags aObserver, TInt aCntrlHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterAddPointerEventObserver, 

        TIpcArgs(aObserver, aCntrlHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterAddPointerEventObserver return error %d", err )

        }

    return err;

    }

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

// 

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

//

TInt RAlfClient::RosterRemovePointerEventObserver( 

    TAlfPointerEventFlags aObserver, TInt aCntrlHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterRemovePointerEventObserver, 

        TIpcArgs(aObserver, aCntrlHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterRemovePointerEventObserver return error %d", err )

        }

    return err;

    }

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

// 

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

//  

TInt RAlfClient::RosterMoveVisualToFront( TInt aVisualHandle, TInt aDisplayHandle )

    {

    TInt err = SendReceive(

        EAlfRosterMoveVisualToFront, 

        TIpcArgs(aVisualHandle, aDisplayHandle) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::RosterMoveVisualToFront return error %d", err )

        }

    return err;

    }

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

// Asks server to update owner id.

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

//   

TInt RAlfClient::TextureUpdateOwnerId()

    {

    return SendReceive( EAlfTextureUpdateOwnerId, TIpcArgs() );

    }

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

// 

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

//   

TInt RAlfClient::TextureCreateAnimatedL(TInt aId, TAlfTextureFlags aFlags, TInt aManagerId, const TDesC& aFilename)

    {

    TInt flags = aFlags;

    flags &= ~EAlfTextureFlagSkinContent; // Skin content is handled in the client side    

    TInt handle = 0;

    TPckg<TInt> handlePckg(handle);

    TAlfCreateTextureAnimatedParams params;

    params.iId = aId; 

    params.iBitmapHandle = 0;

    params.iMaskBitmapHandle = 0;

    params.iFlags = flags;

    params.iManagerId = aManagerId;

    params.iFilename = aFilename;

    TPckg<TAlfCreateTextureAnimatedParams> paramsPckg(params);

    TInt err = SendReceive(EAlfTextureCreateAnimated, TIpcArgs(&handlePckg, &paramsPckg) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureCreateAnimatedL leave error %d", err )

        }

    User::LeaveIfError( err );

    return handle;		

    }

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

// 

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

// 

TInt RAlfClient::TextureStartAnimation( TInt aId )

    {

    TPckg<TInt> idPckg(aId);

    return SendReceive(EAlfTextureStartAnimation, TIpcArgs(aId) );

    }

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

// 

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

//      

TInt RAlfClient::TextureStopAnimation( TInt aId )

    {

    TPckg<TInt> idPckg(aId);

    return SendReceive(EAlfTextureStopAnimation, TIpcArgs(aId) );

    }

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

// Creates a texture.

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

// 

TInt RAlfClient::TextureCreateL(TInt aId, 

    TInt aBitmapHandle, 

    TInt aMaskBitmapHandle, 

    TAlfTextureFlags aFlags,

    TInt aManagerId )

	{

    TInt flags = aFlags;

    flags &= ~EAlfTextureFlagSkinContent; // Skin content is handled in the client side    

    TInt handle = 0;

    TPckg<TInt> handlePckg(handle);

    TAlfCreateTextureParams params;

    params.iId = aId; 

    params.iBitmapHandle = aBitmapHandle;

    params.iMaskBitmapHandle = aMaskBitmapHandle;

    params.iFlags = flags;

    params.iManagerId = aManagerId;

    TPckg<TAlfCreateTextureParams> paramsPckg(params);

    TInt err = SendReceive(EAlfTextureCreate, TIpcArgs(&handlePckg, &paramsPckg) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureCreateL leave error %d", err )

        }

    User::LeaveIfError( err );

    return handle;		

	}

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

// Loads a texture.

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

// 

TInt RAlfClient::TextureLoadL(TInt aId, 

    TInt aBitmapHandle, 

    TInt aMaskBitmapHandle, 

    TAlfTextureFlags aFlags,

    TInt aManagerId )

	{

    TInt flags = aFlags;

    flags &= ~EAlfTextureFlagSkinContent; // Skin content is handled in the client side    

    TInt handle = 0;

    TPckg<TInt> handlePckg(handle);

    TAlfLoadTextureParams params;

    params.iId = aId; 

    params.iBitmapHandle = aBitmapHandle;

    params.iMaskBitmapHandle = aMaskBitmapHandle;

    params.iFlags = flags;

    params.iManagerId = aManagerId;

    TPckg<TAlfLoadTextureParams> paramsPckg(params);

    TInt err = SendReceive(EAlfTextureLoad, TIpcArgs(&handlePckg, &paramsPckg) );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureLoadL leave error %d", err )

        }

    User::LeaveIfError( err );

    return handle;		

	}

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

// Unloads a texture.

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

// 

TInt RAlfClient::TextureUnload( TInt aId, TInt aManagerId )

    {

    TInt err =  SendReceive(EAlfTextureUnload, TIpcArgs(aId, aManagerId));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureUnload return error %d", err )

        }

    return err;

    }	

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

// Delete a texture.

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

// 

TInt RAlfClient::TextureDelete( TInt aId, TInt aManagerId )

    {

    TInt err = SendReceive(EAlfTextureDelete, TIpcArgs(aId, aManagerId));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureDelete return error %d", err )

        }	

    return err;	                    

    }	

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

// Release a texture.

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

// 

TInt RAlfClient::TextureRelease( TInt aId, TInt aManagerId )

    {

    TInt err = SendReceive(EAlfTextureRelease, TIpcArgs(aId, aManagerId));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureRelease return error %d", err )

        }	

    return err;	                    

    }	

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

// Restore a texture.

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

// 

TInt RAlfClient::TextureRestore( TInt aId, TInt aManagerId )

    {

    TInt err = SendReceive(EAlfTextureRestore, TIpcArgs(aId, aManagerId));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureRestore return error %d", err )

        }	

    return err;	                    

    }	

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

// Notifies a skin change for a texture.

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

// 

TInt RAlfClient::TextureNotifySkinChanged( TInt aId, TInt aManagerId )

    {

    TInt err = SendReceive(EAlfTextureNotifySkinChanged, TIpcArgs(aId, aManagerId));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureNotifySkinChanged return error %d", err )

        }	

    return err;	                    

    }	

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

// Blurs a texture.

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

// 

TInt RAlfClient::TextureProcessorBlurL( const TInt aServerSideSrcHandle, 

	    TInt aServerSideDstHandle, 

	    TInt aManagerId, 

	    const TSize& aPreferredSize, 

	    TInt aFilterSize, 

	    TInt aFlag )

    {

    TAlfBlurTextureParams params;

    params.iServerSideSrcHandle = aServerSideSrcHandle;

    params.iServerSideDstHandle = aServerSideDstHandle;

    params.iManagerId = aManagerId;

    params.iPreferredSize = aPreferredSize;     

    params.iFilterSize = aFilterSize;

    params.iFlag = aFlag;

    TPckg<TAlfBlurTextureParams> paramsPckg(params);

    TInt err = SendReceive(EAlfTextureBlur, TIpcArgs(&paramsPckg) );   

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "RAlfClient::TextureProcessorBlurL return error %d", err )

        }	

    return err;