/*

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

*

*/

#include <coemain.h>

#include <AknsConstants.h>

#include <AknTaskList.h>

#include <alf/ftokenclient.h>

#include <aknappui.h>

#include "alf/alfenv.h"

#include "alfclient.h"

#include "alf/alfdisplay.h"

#include "alf/alfroster.h"

#include "alf/alfcontrolgroup.h"

#include "alf/alfevent.h"

#include "alf/alftexturemanager.h"

#include "alf/alftextstylemanager.h"

#include "alfcommandscheduler.h"

#include "alf/alfstatic.h"

#include "alf/alflayoutmetrics.h"

#include "alf/alfconstants.h"

#include "alf/alfevent.h"

#include "alf/alfcontrol.h"

#include "alf/alfbatchbuffer.h"

#include "alf/alfenvobject.h"

#include "alfuids.h"

#include "alfpanic.h"

#include "uiacceltk/HuiUtil.h"

#include "alflogger.h"

// Literals and constants

// This string is used with multiple ALF clients -panic. The panic conserns 

// only ALF clients, NOT the server!

_LIT( KUIAcceltkClientPanic, "UIAcceltkClient" );

struct TSharedTextureManagerEntry 

    {

    public:

    	~TSharedTextureManagerEntry()

        {

        }

    	TSharedTextureManagerEntry()                      

                      : iRefCount(0), iTextureManager(NULL)

        {                            

        }

    	TSharedTextureManagerEntry(CAlfTextureManager* aTextureManager)                      

                      : iRefCount(1), iTextureManager(aTextureManager)

        {

        }

    /** The texturemanager reference count */

    TInt iRefCount;

    /** The shared texture manager entry. */

    CAlfTextureManager* iTextureManager;

    };

// Used flags.

enum TAlfEnvFlags

    {

    EOwnClient =            0x01,

    ETokenClientConnected = 0x02 

    // ...add other flags...

    };

// Deault max framerate

const TInt KAlfDefaultMaxFrameRate = 33;

// Default flags

const TUint KAlfEnvDefaultFlags = 0x00;

// Size of buffer towards client side.

const TInt KAlfTextureInfoMonitorBufferSize = 128;

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

// Returns connected control with ID 

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

//

CAlfControl* FindConnectedControl(CAlfControl& aControl, TInt aId, TBool aUserId)

    {

    CAlfControl* result = NULL;

    for ( TInt connectionIndex = 0 ; connectionIndex < aControl.ConnectionCount() && !result ; connectionIndex++ )

        {

        CAlfControl& connection = aControl.Connection( connectionIndex );

        if( (aUserId?

            connection.Id():

            connection.Identifier()) 

                == aId)

            {

            result = &connection;

            }

        else

            {

            result = FindConnectedControl( connection, aId, aUserId );

            }

        }

    return result;

    }

/**

 * Gets the pointer evetns from the server

 */

NONSHARABLE_CLASS(CAlfPtrEventFetcher):public CActive

    {

    public:

    CAlfPtrEventFetcher(RAlfClient& aClient, CAlfEnv& aEnv)

        :CActive(CActive::EPriorityHigh),iClient(aClient),iEventAsDescriptor(iEvent),iEnv(aEnv)

        {

        CActiveScheduler::Add(this);

        }

    ~CAlfPtrEventFetcher()

        {

        Cancel();

        }

    void Start()

        {

        ASSERT(!IsActive());

        SetActive();

        iClient.RequestPointerEvents(iEventAsDescriptor, iStatus);

        }

    private:

    void DeliverPointerEventL();

    void RunL()

        {

        if(iStatus.Int() == KErrNone)    

        	{

        	DeliverPointerEventL();		

        	Start();

        	}

        else

        	{

        	__ALFLOGSTRING1( "~CAlfPtrEventFetcher::RunL error %d", iStatus.Int() )	

        	}

        }

    void DoCancel()

        {

        iClient.CancelPointerEvents();

        }

    TInt RunError(TInt /*aError*/)

        {

        //Nothing to worry, just restart

        Start();

        return KErrNone;

        }

    RAlfClient& iClient;

    TAlfTouchEvent iEvent;

    TPckg<TAlfTouchEvent> iEventAsDescriptor;

    CAlfEnv& iEnv;

    friend class CAlfEnv; // allow env to acces our event data

    };

void CAlfPtrEventFetcher::DeliverPointerEventL()

    {

    TBool eventSent(EFalse);

    // search clients based on handles from server

    CAlfControl* ctrl = iEnv.FindControl(iEvent.iControls[0], EFalse);

    TInt visualIdentifier = iEvent.iVisuals[0];

    for(TInt ii = 1; ctrl ; ii++)

        {

        // Find the visual index

        CAlfVisual* visual = NULL;

        for ( TInt i = ctrl->VisualCount() - 1 ; i >= 0 && visualIdentifier ; i-- )

            {

            if ( ctrl->Visual( i ).Identifier() == visualIdentifier )

                {

                visual = &ctrl->Visual( i );

                break;

                }

            }

        // Todo: Do we allow ctrl to leave and still pass the event to other cntrls ??

        TBool consumed = EFalse;

        TAlfEvent event(*ctrl->Display(), iEvent.iEvent); 

        event.SetVisual( visual );

        eventSent = ETrue;

        /*TRAP_IGNORE(*/consumed = ctrl->OfferEventL(event)/*)*/;

        if (consumed)

            {

            break;

            }

        ctrl = iEnv.FindControl(iEvent.iControls[ii], EFalse);

        visualIdentifier = iEvent.iVisuals[ii];

        }

    if (!eventSent)

        {

        // ptr event hit visual having groupless control as an owner

        // we can't resolve destination in toolkit side, just post infromation about the event data to 

        // action observers and let the app implementation decide whether event is used or nor.

        iEnv.ReportAction(TAlfActionCommand(KAlfOrpheanPtrEventReceived));

        }

    }

NONSHARABLE_CLASS(CAlfSystemEventFetcher):public CActive

    {

    public:

    CAlfSystemEventFetcher(RAlfClient& aClient, CAlfEnv& aEnv)

        :CActive(CActive::EPriorityHigh),iClient(aClient),iEventAsDescriptor(iEvent),iEnv(aEnv)

        {

        CActiveScheduler::Add(this);

        }

    ~CAlfSystemEventFetcher()

        {

        Cancel();

        }

    void Start()

        {

        ASSERT(!IsActive());

        SetActive();

        iClient.RequestSystemEvents(iEventAsDescriptor, iStatus);

        }

    private:

    void DeliverSystemEventL();

    void RunL()

        {

        if(iStatus.Int() != KErrNone)

            { // for now..

            USER_INVARIANT();

            }

        DeliverSystemEventL();

        Start();

        }

    void DoCancel()

        {

        iClient.CancelSystemEvents();

        }

    TInt RunError(TInt /*aError*/)

        {

        //Nothing to worry, just restart

        Start();

        return KErrNone;

        }

    RAlfClient& iClient;

    TInt iEvent;

    TPckg<TInt> iEventAsDescriptor;

    CAlfEnv& iEnv;

    };

void CAlfSystemEventFetcher::DeliverSystemEventL()

    {

    if (iEvent == KAknsMessageSkinChange)

        {

        iEnv.SetSkinChangePending(ETrue);

        iEnv.ReportWsEventAsActionCommand(KAlfActionIdSkinChanged); 

        // Some action observer may have already called by themselves

        // NotifySkinChangedL, so check before we do it.

        if (iEnv.SkinChangePending())

            {

            iEnv.NotifySkinChangedL();            

            }        

        }

    }

/**

 * Texture information monitor.

 */

NONSHARABLE_CLASS( CAlfTextureInfoMonitor ) : public CActive

    {

public:

    /**

     * Two-phased constructor.

     * @param aClient reference to client.

     */

    static CAlfTextureInfoMonitor* NewL( CAlfEnv& aEnv );

    /**

     * Destructor.

     */

    ~CAlfTextureInfoMonitor();

private:

    /**

     * Constructor.

     * @param aClient reference to client.

     */

    CAlfTextureInfoMonitor( CAlfEnv& aEnv );

    /**

     * Symbian OS constructor.

     */

    void ConstructL();

    /**

     * Issues a request.

     */

    void IssueRequest();

    /**

     * Called by active object framework when request is completed.

     */

    virtual void RunL();

    /**

     * Cancels pending request.

     */

    virtual void DoCancel();

private:

    /**

     * Reference to environment.

     */

    CAlfEnv& iEnv;    

    /**

     * Buffer containing texture info events.

     */

    TBuf8< KAlfTextureInfoMonitorBufferSize > iTextureEventBuffer;

    };

CAlfTextureInfoMonitor* CAlfTextureInfoMonitor::NewL( CAlfEnv& aEnv )

    {

    CAlfTextureInfoMonitor* self = 

        new (ELeave) CAlfTextureInfoMonitor( aEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

CAlfTextureInfoMonitor::~CAlfTextureInfoMonitor()

    {

    Cancel();

    }

CAlfTextureInfoMonitor::CAlfTextureInfoMonitor( CAlfEnv& aEnv )

    : CActive( CActive::EPriorityStandard ),

      iEnv( aEnv )

    {

    CActiveScheduler::Add( this );

    }

void CAlfTextureInfoMonitor::ConstructL()

    {

    IssueRequest();

    }

void CAlfTextureInfoMonitor::IssueRequest()

    {

    iEnv.Client().TextureNotifyInfo( iStatus, iTextureEventBuffer );

    SetActive();

    }

void CAlfTextureInfoMonitor::RunL()

    {

    if ( iStatus.Int() == KErrNone )

        {

        iEnv.HandleTextureInfo( iTextureEventBuffer );

        IssueRequest();

        }

    }

void CAlfTextureInfoMonitor::DoCancel()

    {

    iEnv.Client().TextureCancelNotifyInfo();

    }

// Private data

struct CAlfEnv::TPrivateData

    {

    // Structure used to hold owned objects in the extension array

    struct TObjectHolder

        {

        TInt iUid;

        MAlfEnvObject* iObject;

        };

    TPrivateData():iFlags(0),iClient(0),iSharedRoster(0),

                   iTextureManager(0),iTextStyleManager(0),iScheduler(0),

                   iMaxFrameRate(0),iRefreshMode(EAlfRefreshModeAutomatic),

                   iStatic(0),iLayoutMetricsUtility(0),iPointerEventAo(0),

                   iBatchBufferHandler(0){}

    TUint iFlags;                                   // Owned.

    RAlfClient* iClient;                            // Owned/not owned - see EOwnClient

    CAlfRoster* iSharedRoster;                      // Owned.

    RPointerArray<CAlfDisplay> iDisplays;           // Owned.

    RPointerArray<CAlfControlGroup> iLoadedGroups;  // Owned.

    CAlfTextureManager* iTextureManager;            // Owned.

    CAlfTextStyleManager* iTextStyleManager;        // Owned.

    RPointerArray<MAlfActionObserver> iActionObservers;   // Owned.

    RArray<TSharedTextureManagerEntry> iSharedTextureManagers; // Owned.

    CAlfCommandScheduler* iScheduler;               // Owned.

    TInt iMaxFrameRate;

    TAlfRefreshMode iRefreshMode;

    RFTokenClient   iTokenClient;                    // lazy bound, connected once first real request occurs

    CAlfStatic* iStatic;                              // Owned.

    CAlfLayoutMetricsUtility* iLayoutMetricsUtility;  // Owned.

    CAlfPtrEventFetcher* iPointerEventAo;             // Owned.

    CAlfSystemEventFetcher* iSystemEventAo;             // Owned.

    TVersion iApiVersion;

    CAlfBatchBuffer* iBatchBufferHandler;

    // Flags to avoid unnecessary skin & layout notify calls

    TBool iNotifySkinChangePending;  

    TBool iNotifyLayoutChangePending;  

    CAlfTextureInfoMonitor* iTextureInfoMonitor; // Owned.

    RArray<CAlfEnv::TPrivateData::TObjectHolder> iExtensionArray;

    };

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

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

// Constructor

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

//

CAlfEnv::CAlfEnv()

    {

    }

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

// ConstructL

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

//

void CAlfEnv::ConstructL(TVersion aVersion)

    {

    /*  

    // AknEventMonitor can be used if we want to know the target control also

    // Otherwise CoeMonitor should be used for better compatibility between 

    // releases 

    CAknAppUi* appUi = iAvkonAppUi; // actually macro using coe static...

    if (appUi && appUi->EventMonitor())

        {

        appUi->EventMonitor()->AddObserverL(this);

        appUi->EventMonitor()->Enable();

        }

*/

    // Enforces single CAlfEnv policy. Panics ONLY the client, NOT the server!!

    __ASSERT_ALWAYS( !CAlfEnv::Static(), User::Panic( KUIAcceltkClientPanic, EAlfEnvPanicMultipleAlfEnvironments ) );

    CCoeEnv* coeStatic = CCoeEnv::Static();

    if ( coeStatic )

        {

        coeStatic->AddMessageMonitorObserverL(*this);

        }

    // Create private data

    iData = new (ELeave) TPrivateData;

    iData->iApiVersion = aVersion;

    // NULL member data before anything else may leave.

    iData->iClient = NULL;

    iData->iSharedRoster = NULL;

    iData->iTextureManager = NULL;

    iData->iTextStyleManager = NULL;

    iData->iScheduler = NULL;

    iData->iStatic = NULL;

    iData->iLayoutMetricsUtility = NULL;

    iData->iPointerEventAo = NULL;

    iData->iSystemEventAo = NULL;

    iData->iBatchBufferHandler = NULL;

    iData->iTextureInfoMonitor = NULL;

    // Set flags

    iData->iFlags = KAlfEnvDefaultFlags;

    // Set client ( pekjokel: client can be passed from outside as well? )

    iData->iClient = new (ELeave) RAlfClient;

    iData->iFlags |= EOwnClient;

    iData->iClient->OpenL();

    if (coeStatic)

        {

        CAknTaskList* taskList = CAknTaskList::NewLC(coeStatic->WsSession());

        const RArray<RWsSession::TWindowGroupChainInfo>& chain = taskList->WgArray();

        const TInt chainCount = chain.Count();

        TInt parentId = 0;

        TInt wgId = coeStatic->RootWin().Identifier();

        for ( TInt ii = 0; ii < chainCount; ii++ )

            {

            const RWsSession::TWindowGroupChainInfo& info = chain[ ii ];

            if ( info.iId == wgId )

                {

                parentId = info.iParentId;

                break;

                }

            }

        if (parentId > 0)

            {