/*

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

*

*/

#include <flogger.h>

#include "alfappsrvsession.h"

#include "alf/alfappserver.h"

#include "alf/alfappui.h"

#include "alf/alfconstants.h"

#include "alf/alfclientwindow.h"

#include "alfsrvdisplaysubsession.h"

#include "alfsrvcontrolgroupsubsession.h"

#include "alfsrvsettingshandler.h"

#include "alfsrvtranseffect.h"

#include "alf/alfsrveffectenv.h"

#include "alf/alfserverutils.h"

#include "alflogger.h"

#include "alfclientserver.h"

#include "alfsrvtexturemanager.h"

#include "alfsrvscreenbuffermanager.h"

#include <coemain.h>

#include <alf/alfroster.h>

#include <alf/alftexture.h>

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiDisplayCoeControl.h>

#include <uiacceltk/HuiEnv.h>

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiImageVisual.h>

#include <uiacceltk/HuiGridLayout.h>

#include <uiacceltk/HuiTextureProcessor.h>

#include <uiacceltk/HuiSegmentedTexture.h>

#include <uiacceltk/huitextstylemanager.h>

#include <uiacceltk/huitextstyle.h>

#include <uiacceltk/HuiFont.h>

#include <uiacceltk/HuiTexture.h>

#include <uiacceltk/HuiUtil.h>

_LIT( KAlfFPSLogDir, "alf"); // remember to create the c:\logs\alf in order to enable logging

_LIT( KAlfFPSLogFile, "alffpslog.txt");

const TReal32 KAlfUseDefaultFrameRate = 0.f;

TBool RealCompare( 

    TReal32 aCompare1, 

    TReal32 aCompare2, 

    TReal32 aEpsilon = 0.001f  )

    {

    if ( Abs(aCompare1 - aCompare2) < aEpsilon )

        {

        return ETrue;

        }

    return EFalse;

    }

/**

 * Size of command batch buffer allocated from stack.

 * (This is used if all else fails)

 */

const TInt KAlfStackBatchBufferSize = 128;

// bitmap provider

NONSHARABLE_CLASS(CSharedBitmapProvider) : public CBase, public MHuiBitmapProvider

	{

public:

	CSharedBitmapProvider();

	CSharedBitmapProvider(TInt aBitmapHandle, TInt aMaskHandle);

	~CSharedBitmapProvider();

	// from MHuiBitmapProvider	

	void ProvideBitmapL(TInt aId, CFbsBitmap*& aBitmap, CFbsBitmap*& aMaskBitmap);				

private:

	TInt iBitmapHandle;

	TInt iMaskHandle;

	};

CSharedBitmapProvider::CSharedBitmapProvider()

	{

	}

CSharedBitmapProvider::CSharedBitmapProvider(TInt aBitmapHandle, TInt aMaskHandle)

	{

	iBitmapHandle = aBitmapHandle;

	iMaskHandle = aMaskHandle;	

	}

CSharedBitmapProvider::~CSharedBitmapProvider()

	{

	}

void CSharedBitmapProvider::ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask)

	{

	CFbsBitmap* bitmap(0);

	CFbsBitmap* mask(0);

	if (iBitmapHandle) // mandatory

	    {

	    bitmap = new (ELeave) CFbsBitmap;

	    CleanupStack::PushL(bitmap);

	    bitmap->Reset();

	    User::LeaveIfError(bitmap->Duplicate(iBitmapHandle));

	    }

	else

	    {

	    User::Leave(KErrArgument);

	    }

	if ( iMaskHandle ) // optional

	    {

     	mask = new (ELeave) CFbsBitmap;

	    CleanupStack::PushL(mask);

	    mask->Reset();

	    User::LeaveIfError(mask->Duplicate(iMaskHandle));

	    CleanupStack::Pop(); // mask

	    }

    CleanupStack::Pop(); // bitmap

    aBitmapMask = mask; 	

    aBitmap = bitmap; 	

    }

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

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

// Constructor

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

//

CAlfAppSrvSession::CAlfAppSrvSession(const CAlfAppServer* aServer)

    : CAlfAppSrvSessionBase(aServer),

      iExecutionFlags( 

        EAlfExecuteUsingDynamicBuffer + EAlfExecuteUsingCommonBuffer )

    {

    }

CAlfAppSrvSession* CAlfAppSrvSession::NewL(const CAlfAppServer* aServer)

    {

    CAlfAppSrvSession* me = new (ELeave) CAlfAppSrvSession(aServer);

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop();

    return me;

    }

void CAlfAppSrvSession::ConstructL()

    {

    BaseConstructL();

    AlfServer()->SetWindowChangeObserverL(this, TInt(this)); 

    iRefreshMode = EHuiRefreshModeAutomatic;

    iMaxFrameRate = KAlfUseDefaultFrameRate;

    iIdleThreshold = 10 * 1000; // 10 from HuiEnv as seconds

    iEffectEnv = CAlfSrvEffectEnv::NewL(*this);

    }

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

// Destructor

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

//

CAlfAppSrvSession::~CAlfAppSrvSession()

    {

    iOwnershipItems.ResetAndDestroy();    

    if ( iTextureOwnedIdSet )

        {

        CAlfSrvTextureManager& manager = AlfTextureManager();

        TProcessId ownerId = TextureOwnerId();

        manager.DestroyDeletedTextureIds( ownerId );

        manager.RemoveClient( *this );

        }

    iTextures.ResetAndDestroy();        

    iAnimatedTextures.ResetAndDestroy();

    delete iEffectEnv;

    iEffectEnv = NULL;

    iTextureInfo.Close();

    iControlGroupOrder.Close();

    }

TRect CAlfAppSrvSession::ClientDrawingArea() const

    {

    return iClientDisplayRect;

    }

void CAlfAppSrvSession::SetClientDrawingArea( const TRect& aRect )

    {

    TRAP_IGNORE(SetClientDrawingAreaL(aRect))

    }

void CAlfAppSrvSession::SetClientDrawingAreaL( const TRect& aRect )

    {

    iClientDisplayRect = aRect;

    // Update all the control groups

    RPointerArray<CAlfSrvSubSessionBase> groups;

    CleanupClosePushL( groups );

    GetSubsessionsByTypeL( groups, EHuiObjectTypeControlGroup );

    for ( TInt g = 0 ; g < groups.Count() ; g++ )

        {

        CHuiControlGroup* group = groups[g]->AsHuiControlCroup();

        ASSERT( group ); 

        CHuiLayout* hostContainer = group->Control(0).ContainerLayout( NULL );

        hostContainer->SetSize( iClientDisplayRect.Size() );

        hostContainer->SetPos( iClientDisplayRect.iTl );

        }

    CleanupStack::PopAndDestroy( &groups ); // groups.Close()

    }

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

// From class CAlfAppSrvSessionBase.

// Called when client receives focus.

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

//   

void CAlfAppSrvSession::FocusGainedL( TBool aDoTransitionEffect )

    {

    iFocused = ETrue;

    DeliverTextureInfo();

    // update frame rate

    if ( RealCompare( iMaxFrameRate, KAlfUseDefaultFrameRate ) )

        {

        SharedHuiEnv()->SetMaxFrameRate( 

            TReal32(AlfAppUi()->SettingsHandler().DefaultFramerate()) );

        }

    else

        {

        SharedHuiEnv()->SetMaxFrameRate( iMaxFrameRate );

        }

    // update refresh mode

    if ( SharedHuiEnv()->RefreshMode() != iRefreshMode )

        {

        SharedHuiEnv()->SetRefreshMode( iRefreshMode );

        }

    // update idle threshold

    SharedHuiEnv()->SetIdleThreshold( iIdleThreshold );

    // update display attributes for each display

    CHuiDisplay* display = NULL;

    RPointerArray<CAlfSrvSubSessionBase> displays;

    CleanupClosePushL( displays );

    GetSubsessionsByTypeL( displays, EHuiObjectTypeDisplay );

    for ( TInt d = 0 ; d < displays.Count() ; d++ )

        {

        CAlfSrvDisplaySubSession* displaySubSession = 

                static_cast<CAlfSrvDisplaySubSession*>( displays[d] );     

        displaySubSession->SetSessionFocused();

        if ( !display && !displaySubSession->IsTvOut())

            {

            display = &displaySubSession->Display();

            }

        }     

    CleanupStack::PopAndDestroy( &displays ); // displays.Close()

    if ( !display )

        {

        return;

        }

    // Enable animated textures for the session

    for (TInt index = 0; index < iAnimatedTextures.Count(); index++)

        {

       	iAnimatedTextures.operator[](index)->EnableAnimation(ETrue);     

        }

    if ( aDoTransitionEffect && AlfServer()->TransitionEffects()->IsEnabled() &&

         (display->DisplayType() != CHuiDisplay::EDisplayOffScreenBuffer))        

        {

       	ASSERT(AlfServer()->TransitionEffects() != NULL);

       	AlfServer()->TransitionEffects()->StartPhase( MAlfTransEffectPlugin::EFirstPhase, 

       	    aDoTransitionEffect, *iEffectEnv );            

       	iControlGroupOrder.Reset();

        }

    else

        {

//        ShowControlGroupsInOrderL(*display);

        }    

	// This is needed for Huitk BitBlit() to succeed 

#ifdef SYMBIAN_BUILD_GCE

    SharedHuiEnv()->ContinueRefresh();

#else

    AlfAppUi()->Container()->DrawNow();

#endif

    }

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

// From class CAlfAppSrvSessionBase.

// Called when client loses focus.

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

//

TBool CAlfAppSrvSession::FocusLostL( TBool aDoTransitionEffect )

    {

    iFocused = EFalse;

    TBool didTransition = EFalse;

    if ( !SharedHuiEnv()->DisplayCount() )

        {

        return EFalse;

        }

    // Notify displays about losing focus so that tv out can be released

    CHuiDisplay* display = NULL;

    RPointerArray<CAlfSrvSubSessionBase> displays;

    CleanupClosePushL( displays );

    GetSubsessionsByTypeL( displays, EHuiObjectTypeDisplay );

    for ( TInt d = 0 ; d < displays.Count() ; d++ )

        {

        CAlfSrvDisplaySubSession* displaySubSession = 

                static_cast<CAlfSrvDisplaySubSession*>( displays[d] );     

        displaySubSession->SetSessionFocused(EFalse);

        if ( !display && !displaySubSession->IsTvOut())

            {

            display = &displaySubSession->Display();

            }

        }     

    CleanupStack::PopAndDestroy( &displays ); // displays.Close()

    if ( !display )

        {

        return didTransition;

        }

/*        

#ifdef HUI_FX

*/

    if (display->DisplayType() != CHuiDisplay::EDisplayOffScreenBuffer) 

    	{

    	// Disable all animated textures for the session

    	for (TInt index = 0; index < iAnimatedTextures.Count(); index++)

        	{

      		iAnimatedTextures.operator[](index)->EnableAnimation(EFalse); 

        	}

#ifndef SYMBIAN_BUILD_GCE       	

      	StoreControlGroupOrderL(*display, EFalse ); // do not hide  

#endif

      	// background must be drawn as long as the effect is displayed 

       	// as the background will be visible if the effect does not cover full screen

       	// or is partially transparent.

    	}

/*    	

#else

    // Do not hide or set transparency if this is off-screen buffer         

    if (display->DisplayType() != CHuiDisplay::EDisplayOffScreenBuffer) 

    	{

    	// Disable all animated textures for the session

    	for (TInt index = 0; index < iAnimatedTextures.Count(); index++)

        	{

      		iAnimatedTextures.operator[](index)->EnableAnimation(EFalse); 

        	}

     	if ( aDoTransitionEffect && AlfServer()->TransitionEffects()->IsEnabled() )

        	{

        	StoreControlGroupOrderL(*display, EFalse ); // do not hide  

        	ASSERT(AlfServer()->TransitionEffects() != NULL);

        	AlfServer()->TransitionEffects()->StartPhase( MAlfTransEffectPlugin::EFirstPhase, 

            	aDoTransitionEffect, *iEffectEnv );            

        	didTransition = ETrue;

        	}

    	// Hide control groups 

    	else 

        	{

        	StoreControlGroupOrderL(*display, ETrue ); // hide as well     

    		}

#ifdef SYMBIAN_BUILD_GCE

        // When alf application is not focused we dont draw background because it is

        // not visible as the alf application is not visible either (its controlgroups

        // were just hidden in the code above).

   	    display->SetClearBackgroundL(CHuiDisplay::EClearNone);

#endif

    	}

#endif    		

*/

    return didTransition;

    }

void CAlfAppSrvSession::StoreControlGroupOrderL(CHuiDisplay& aDisplay, TBool aAlsoHide )

    {

    for ( TInt g = 0 ; g < aDisplay.Roster().Count() ; g++ )

        {

        // first append the bottom one

        CHuiControlGroup& group = aDisplay.Roster().ControlGroup( g );

        // make sure we only store control groups for this session

        if ( GetHandleFromInterface(EHuiObjectTypeControlGroup, &group) != KErrNotFound )

            {

            iControlGroupOrder.AppendL( &group );

            }

        }

    // at the end the lowest index the bottom most and the biggest index the top most.

    // hide at the end so it does not affect the order of the group in the roster

    if ( aAlsoHide )

        {

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

            {

            CHuiLayout* hostContainer = iControlGroupOrder[i]->Control(0).ContainerLayout( NULL );

            aDisplay.Roster().Hide( *iControlGroupOrder[i] );

            }

        }

    }

void CAlfAppSrvSession::ShowControlGroupsInOrderL(CHuiDisplay& /*aDisplay*/)

    {

/*#ifdef SYMBIAN_BUILD_GCE

    iControlGroupOrder.Reset();

    // gather all the control groups that belong to this session

    for ( TInt g = 0 ; g < aDisplay.Roster().Count() ; g++ )

        {

        // first append the bottom one

        CHuiControlGroup& group = aDisplay.Roster().ControlGroup( g );

        // make sure we only store control groups for this session

        if ( GetHandleFromInterface(EHuiObjectTypeControlGroup, &group) != KErrNotFound )

            {

            iControlGroupOrder.AppendL( &group );

            }

        }

#endif

    // put this session's controlgroups on top

    while ( iControlGroupOrder.Count() )

        {

        CHuiControlGroup& group = *iControlGroupOrder[iControlGroupOrder.Count()-1];

        // make sure that the group still exists.

        if ( GetHandleFromInterface(EHuiObjectTypeControlGroup, &group) != KErrNotFound )

            {

            CHuiLayout* hostContainer = group.Control(0).ContainerLayout( NULL );

#ifdef SYMBIAN_BUILD_GCE

            AlfAppUi()->ShowControlGroupL(aDisplay.Roster(), group, KHuiRosterShowAtTop, 0); 

#else    

            aDisplay.Roster().ShowL( group, KAlfRosterShowAtBottom );

#endif

            iControlGroupOrder.Remove(iControlGroupOrder.Count()-1);

            }

        }

    iControlGroupOrder.Reset();*/

    }

void CAlfAppSrvSession::ReOrderControlGroupSessionsL( RPointerArray<CAlfSrvSubSessionBase>& aGroupSessions )

    {

    if ( iControlGroupOrder.Count() && aGroupSessions.Count() > 1 )

        {

        // go through the items from bottom to top

        for ( TInt g = iControlGroupOrder.Count() -1 ; g >= 0 ; g-- ) 

            {

            CHuiControlGroup* nextGroupFromBottom = iControlGroupOrder[g];

            // Find the session and move it into first position

            for ( TInt s = 0 ; s < aGroupSessions.Count() ; s++ )

                {

                CAlfSrvControlGroupSubSession* controlGroupSubSession = static_cast<CAlfSrvControlGroupSubSession*>( aGroupSessions[s] );   

                if ( &controlGroupSubSession->ControlGroup() == nextGroupFromBottom )

                    {

                    // move into g:th position

                    aGroupSessions.Remove( s );

                    User::LeaveIfError( aGroupSessions.Insert( controlGroupSubSession, 0 ) );

                    }

                }

            }

        }

    }

void CAlfAppSrvSession::SetBackgroundMaxFps( TBool aBackground )

    {

    TReal32 newMaxFrameRate = 0;

    // update frame rate

    if ( RealCompare( iMaxFrameRate, KAlfUseDefaultFrameRate ) )

        {

        newMaxFrameRate = TReal32( AlfAppUi()->SettingsHandler().DefaultFramerate() );

        SharedHuiEnv()->SetMaxFrameRate( 

            TReal32(AlfAppUi()->SettingsHandler().DefaultFramerate()) );

        }

    else

        {

        newMaxFrameRate = iMaxFrameRate;

        }