/*

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

*

*/

#include <coemain.h>

#include <coedef.h>

#include <apgwgnam.h>

#include <eiksvdef.h>

#include <ecom.h>

#include <uiacceltk/HuiUtil.h>

#include <f32file.h>

#include <TfxSrvEcomIds.h>

#include <mtransitionserver.h>

#include "alf/alfappserver.h"

#include "alf/alfappui.h"

#include "alf/alfconstants.h"

#include "alfappsrvsession.h"

#include "alflogger.h"

#include "alfsrvsubsessionbase.h"

#include "alf/alfextensionfactory.h"

#include "alfstaticfactory.h"

#include "alfsrvtranseffect.h"

#include "alf/AlfTransEffectPlugin.h"

#include <uiacceltk/HuiDisplay.h> //@todo::

#include "alfclientserver.h"

#include "alfsrvtexturemanager.h"

#include "alfsrvscreenbuffermanager.h"

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

/**

 * Common command batch buffer size. This must always be larger than command 

 * header size. In practice, this should be always larger than 128.

 */

const TInt KAlfCommonCommandBatchBufferSize = 

    KAlfClientServerDefaultCommandBatchBufferSize;

// a kind of cleanup item for ecom info array

NONSHARABLE_CLASS(CCleanupEcomArray):public CBase

    {

    public:

    ~CCleanupEcomArray()

        {

        iArray.ResetAndDestroy();

        iArray.Close();

        }

    RImplInfoPtrArray iArray;

    };

// ECom notify helper.

NONSHARABLE_CLASS(CAlfEcomUtil): public CActive

    {

    public:    

    CAlfEcomUtil(CAlfAppServer& aServer)

    :CActive(EActivePriorityDefault), iOwner(aServer)

	    {

	    CActiveScheduler::Add(this);

	    }

    void ConstructL()

	    {

	    iEComSession = &REComSession::OpenL();

    	}

    ~CAlfEcomUtil()

	    {

	    Cancel();

	    if (iEComSession)

	        {

	        iEComSession->Close();

	        }

	    iEComSession = NULL;

	    }

    static CAlfEcomUtil* NewL(CAlfAppServer& aServer)

	    {

	    CAlfEcomUtil* self = new (ELeave) CAlfEcomUtil(aServer);

	    CleanupStack::PushL(self);

	    self->ConstructL();

	    CleanupStack::Pop(self);

	    return self;

	    }

    void Start()

	    {

	    if (!IsActive())

	        {

    	    iEComSession->NotifyOnChange(iStatus);

	        SetActive();

	        }

	    }

    void RunL()

	    {

	    // if there was an error, just breathe a moment, i.e. don't activate new request immediately

        if (iStatus.Int() == KErrNone )

            {

    	    //Check wether plugin was installed or removed

     	    TRAP_IGNORE(iOwner.CheckForEcomPluginInstallUninstallL())

    	    Start();

            }

        __ALFLOGSTRING1( "CAlfEcomUtil::RunL: status %d", iStatus.Int() )

	    }

    void DoCancel()

	    {

	    iEComSession->CancelNotifyOnChange(iStatus);

	    }

	private:    

        CAlfAppServer& iOwner;

        REComSession* iEComSession;

    };

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

EXPORT_C CAlfAppServer* CAlfAppServer::NewAppServerL()

    {

    return new (ELeave) CAlfAppServer();

    }

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

// Constructor

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

//

CAlfAppServer::CAlfAppServer():

      iLastActiveClientWg(KErrNotFound)

    {

    CCoeEnv* coe = CCoeEnv::Static();

    if (coe)

        {

        iWs = &coe->WsSession();

        }

    }

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

// Second phase constructor

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

//

void CAlfAppServer::ConstructL( const TDesC& aFixedServerName )

    {

    CAknAppServer::ConstructL( aFixedServerName );

    iCommonCommandBatchBuffer = HBufC8::NewL( KAlfCommonCommandBatchBufferSize );

    iTextureManager = CAlfSrvTextureManager::NewL();

    iScreenBufferManager = CAlfSrvScreenBufferManager::NewL(*this);

    }

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

// Destructor

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

//

CAlfAppServer::~CAlfAppServer()

    {

	#ifdef TFXSERVER_API_V2

    if (iTfxServer)

    	{

        iTfxServer->Disconnect();

    	delete iTfxServer;

    	iTfxServer = NULL;

    	REComSession::DestroyedImplementation( iTfxServerEComDestructorUID );

    	iTfxServerEComDestructorUID.iUid = 0;	

    	}

	#endif

    delete iBackgroundTimer;

    delete iTransitionEffects;

    delete iEcomWatcher;

    iWindowChangeObservers.Close();

    if (iAsynchOneShot)

        {

        iAsynchOneShot->Cancel();

        }

    delete iAsynchOneShot;

    iRemovedArray.Close();

    delete iObjectConIx;

    for (TInt ii = iCustomSessions.Count()-1; ii >= 0; ii--)

        {

        delete iCustomSessions[ii].iImpl;

        REComSession::DestroyedImplementation(

                iCustomSessions[ii].iDestructorUid);

        }

    iCustomSessions.Close();

    // Todo: check remaining implementations

    for (TInt ii = iFactories.Count()-1; ii >= 0; ii--)

        {

        iFactories[ii].iImpl->Release();

        if (iFactories[ii].iDestructorUid.iUid)

            {

            REComSession::DestroyedImplementation(

                iFactories[ii].iDestructorUid);

            }

        }

    iFactories.Close();

    iMetricsInterface = NULL;

    iAppUi= NULL;

    delete iCommonCommandBatchBuffer;

	delete iScreenBufferManager;

    delete iTextureManager;

    }

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

// Called when client application exist.

// All allocated resources for that application should be freed.

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

//

EXPORT_C void CAlfAppServer::HandleClientExit(TInt aClientId)

    {

	if (MetricsInterface())

	    {

		MetricsInterface()->SessionTerminated(aClientId);

		}

    SyncEcomImplementations(aClientId);  

    CAlfAppSrvSessionBase* session = reinterpret_cast<CAlfAppSrvSessionBase*>(aClientId);

    ScreenBufferManager().RemoveScreenBufferObservers(session);

    if (session == iOldSession)

        {

        iOldSession = 0;

        }

    if (iAppUi)

        {

        iAppUi->FreeResourcesForClient(aClientId);

        }

    else 

        {

        return;

        }

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

        {

        if (iWindowChangeObservers[i].iId == aClientId)

            {

            iWindowChangeObservers.Remove(i);

            }

        }

    // todo, is it true that we have no other way to check the count than using iterator?

    TInt count = 0;

    iSessionIter.SetToFirst();

    for(;iSessionIter;iSessionIter++)

        {

        count++;

        }

    // if this was the last client, it is ok to bail out here    

    if (count == 1)

        {

        AppUi()->UpdateActiveSession( 0 );

        AdjustWindowGroupPositionL(*CHuiStatic::RootWin(0),0,EAbsoluteBackground);

        return;

        }

    // Set wg position based in the topmost client app

    TInt parentWg = KErrNotFound;    

    CAlfAppSrvSessionBase* dying = reinterpret_cast<CAlfAppSrvSessionBase*>(aClientId);

    if ( dying->ClientWindowGroup() == KErrNotFound )

        {

        // debugging trash

        // just bail out w/o changing the order of window groups

        return;       

        }

    TBool lastActiveDying = EFalse;

    if ( dying->ClientWindowGroup() == iLastActiveClientWg )

        {

        lastActiveDying = ETrue;

        iLastActiveClientWg = KErrNotFound;

        parentWg = dying->ParentWindowGroupId();

        }

    CAlfAppSrvSessionBase* newFocusSession = 0;

    // if parent of embedded app found, check if it ALF app and set it to focus

    if (parentWg != KErrNotFound)

        {

        iSessionIter.SetToFirst();

        while (iSessionIter)

            {

            CAlfAppSrvSessionBase* session = reinterpret_cast<CAlfAppSrvSessionBase*>(iSessionIter++);

            if ( session && session->ClientWindowGroup() == parentWg)

                {

                newFocusSession = session;

                break;

                }

            }

        }

    if (CCoeEnv::Static() && !newFocusSession) // else find topmost app and move us behind that

        {

        parentWg = KErrNotFound; // just in case app had parent but that was not ALF app

        CArrayFixFlat<TInt>* wgs = new CArrayFixFlat<TInt>(4);

        if ( wgs )

            {

            iWs->WindowGroupList(wgs);

            for ( TInt ordinal = 0 ; ordinal < wgs->Count(); ordinal++ )

                {

                iSessionIter.SetToFirst();

                if( newFocusSession ) // session found from previous ordinal position.

                    {

                    break;

                    }

                while (iSessionIter)

                    {

                    CAlfAppSrvSessionBase* session = reinterpret_cast<CAlfAppSrvSessionBase*>(iSessionIter++);

                    if ( session && 

                         session->ClientWindowGroup() == wgs->At( ordinal ) &&

                         (TInt)session != aClientId )

                        {

                        newFocusSession = session;

                        break;

                        }

                    }

                }

            }

        delete wgs;

        }

    if( lastActiveDying || newFocusSession )

        {

        TRAP_IGNORE(FocusedWindowGroupChangedL(newFocusSession, parentWg));

        }

    }

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

// Static utility used in callback

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

// 

TInt SynchEcomImplementations(TAny* aThis)

    {

    ((CAlfAppServer*)aThis)->DoSynchEcomImplementations();

    return KErrNone;

    }

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

// Check if the exiting client is using ecom based session

// if so, set asynchronous callback for notifying Ecom FW about the change

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

// 

void CAlfAppServer::SyncEcomImplementations(TInt aClientId)  

    {

    TBool isEcom(EFalse);

    for(TInt ii = iCustomSessions.Count()-1; ii >= 0 ; ii--)

        {

        if (iCustomSessions[ii] == aClientId)

            {

            isEcom = ETrue;

            iCustomSessions[ii].iImpl = 0; // session is about to terminate, null the pointer

            break;

            }

        }

    if (isEcom)

        {

        iRemovedArray.Append(aClientId);

        if (iAsynchOneShot && !iAsynchOneShot->IsActive())

            {

            iAsynchOneShot->CallBack();

            }

        }

    }

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

// Check and notify Ecom FW about removed implementations caused by client exit

// Called asynchronously after a client usin ecom based session has exited.

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

// 

void CAlfAppServer::DoSynchEcomImplementations()

    {

    // check if the session was ECOM based and notify FW if so

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

        {

        for(TInt ii = iCustomSessions.Count()-1; ii >= 0 ; ii--)

            {

            if (iCustomSessions[ii] == iRemovedArray[i])

                {

                REComSession::DestroyedImplementation(

                    iCustomSessions[ii].iDestructorUid);            

                iCustomSessions.Remove(ii);

                }

            }

        }

    iRemovedArray.Reset();

    User::Heap().Compress();

    }

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

// From class CAknAppServer.

// Called when all clients have existed.

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

// 

void CAlfAppServer::HandleAllClientsClosed()

    {

    if (iAppUi)

        iAppUi->AllClientsClosed();

    }

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

// From class CAknAppServer.

// Allocates the session instance

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

//

CApaAppServiceBase* CAlfAppServer::CreateServiceL( TUid aServiceType ) const

    {

    CApaAppServiceBase* session = 0;

    if (aServiceType == KAlfServiceUid)   

		{

		session = CAlfAppSrvSession::NewL(this);

		}

    else

	    { // nasty const cast

    	session = ((CAlfAppServer*)this)->LoadServiceExtensionL(aServiceType);		    

	    }

	if(session)	

	    {

		if (MetricsInterface())

		    {

		    const_cast<MAlfMetricsInterface*>(MetricsInterface())->SessionCreated(reinterpret_cast<TInt>(session));

		    }

	    return session;

	    }

	else

		{

		return CAknAppServer::CreateServiceL(aServiceType);	

		}

    }

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

// Adjusts server's wg according to client's wg.

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

// 

EXPORT_C void CAlfAppServer::AdjustWindowGroupPositionL(

    RWindowGroup& aWindowGroup, 

    TInt aParentIdentifier, 

    TAlfWGPostion aPosition)

    {

    if (!iAppUi )

        {

        return;  

        }

    // Update the member variable based on the WG the server follows.

    if (aPosition != EAbsoluteBackground)

        {

        iLastActiveClientWg = aParentIdentifier;

        }

    if (!CCoeEnv::Static())

        {

        iAppUi->AdjustWindowGroupPositionL(

                    aParentIdentifier, 

                    aPosition);

        return;

        }

#ifdef _ALF_LOGGING

    LogWindowGroupsL();

    switch( aPosition )

        {

        case EBehindOfParent:

            __ALFLOGSTRING1( "CAlfAppServer::AdjWinGrpPosL EBehindOfParent parent id %d", aParentIdentifier )

            break;

        case EOnTopOfParent:

            __ALFLOGSTRING1( "CAlfAppServer::AdjWinGrpPosL EOnTopOfParent parent id %d", aParentIdentifier )

            break;

        case EAbsoluteBackground:

            __ALFLOGSTRING1( "CAlfAppServer::AdjWinGrpPosL EAbsoluteBackground parent id %d", aParentIdentifier )

            break;

        default:

            __ALFLOGSTRING2( "CAlfAppServer::AdjWinGrpPosL UNKNOWN parent id %d pos %d", aParentIdentifier, aPosition )

            break;

        }

#endif

    if (aPosition == EAbsoluteBackground) // just for convenience

        {

        aWindowGroup.SetOrdinalPosition(0,ECoeWinPriorityNeverAtFront);

        LogWindowGroupsL();

        return;

        }

    TInt parentPriority = iWs->GetWindowGroupOrdinalPriority(aParentIdentifier);

    // perhaps we should maintain wg-list elsewhere

    CArrayFixFlat<TInt>* wgs = new (ELeave) CArrayFixFlat<TInt>(1); 

    CleanupStack::PushL(wgs);

    iWs->WindowGroupList(parentPriority,wgs);