/*

* 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 <uiacceltk/HuiEnv.h>

#include <uiacceltk/HuiRoster.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiEvent.h>

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiUtil.h>

#include "alf/alfappsrvsessionbase.h"

#include "alf/alfappserver.h"

#include "alf/alfappui.h"

#include "alf/alfconstants.h"

#include "alfloggingconfiguration.h"

#include "alflogger.h"

#include "alfsrvdisplaysubsession.h"

#include "alfsrvcontrolgroupsubsession.h"

#include "alfsrvtransformationsubsession.h"

#include "alf/alfextensionfactory.h"

#include "alf/alfversion.h"

#include "alfsrvsettingshandler.h"

#include "alfstreamerconsts.h"

#include "alfdecoderserverclient.h"

const TUint KAlfMaxCpuUsageDuringPointerEvent = 35; // Percentage

struct TAlfHandleAndImplUid

    {

    TAlfHandleAndImplUid(TInt aHandle, TInt aUid):iHandle(aHandle),iUid(aUid){}

    static TBool Compare(const TInt* aKey, const TAlfHandleAndImplUid& aEntry)

        {

        return (*aKey==aEntry.iHandle);

        }

    TInt iHandle;

    TInt iUid;

    };

struct TAlfTouchEventS: public TAlfTouchEvent

    {

    TAlfTouchEventS(const THuiEvent& aEvent) 

        {

        iEvent = aEvent.iPointerEvent;

        Mem::FillZ(iControls, sizeof(iControls));

        Mem::FillZ(iVisuals, sizeof(iVisuals));

        }

    void AppendCtrl(TInt aControlHandle, TInt aVisualHandle)

        {

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

            {

            if (iControls[ii] == 0)

                {

                iControls[ii] = aControlHandle;

                iVisuals[ii] = aVisualHandle;

                break;

                }

            else if ( ii == KAlfTouchEventControlCount-1 )

                {

                __ALFLOGSTRING( "TAlfTouchEventS::AppendCtrl: Overflow" )

                }

            else

                {

                // For PC-lint

                }

            }

        }

    };

NONSHARABLE_CLASS(CAlfAppSrvSessionBase::TPrivateData)

    {

    public:

    enum TAlfPtrEventState 

        {

        ENotInitialized,

        EStartNewEvent,

        EUpdateCtrls,

        ENotFocused

        };

    public:

    TPrivateData():iSharedEnv(0),iContainer(0),iObjectIx(0) {}

    CHuiEnv* iSharedEnv;

    TInt iClientWindowGroupId;

    CObjectCon* iContainer;     // Not own

    CObjectIx* iObjectIx;       // Own

    RArray<TAlfHandleAndImplUid> iHandles;    

    RPointerArray<CAlfClientMessage> iMessages;

    RArray<TAlfTouchEventS>       iHuiEvents; // now only pointer events are supported

    TAlfPtrEventState iPtrEventState;

    RMessagePtr2 iPointerEvent;

    RMessagePtr2 iSystemEvent;

    TInt iParentId;

    TBool iActive;

    TUint iSecureId;

    }; 

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

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

// Cosntructor

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

//

EXPORT_C CAlfAppSrvSessionBase::CAlfAppSrvSessionBase(const CAlfAppServer* aServer)

    :iHost(const_cast<CAlfAppServer*>(aServer))

    {

    }

EXPORT_C CAlfAppSrvSessionBase::CAlfAppSrvSessionBase()

    :iHost(static_cast<CAlfAppServer*>(CEikonEnv::Static()->AppServer()))

    {

    }

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

// Destructor

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

//

EXPORT_C CAlfAppSrvSessionBase::~CAlfAppSrvSessionBase()

    {

    iHost->HandleClientExit(reinterpret_cast<TInt>(this));

    if ( iData )

        {

        if (AlfAppUi()->BridgerClient())

            {

            AlfAppUi()->BridgerClient()->SendBlind(EAlfExcludeFromGoomTargets, TIpcArgs(iData->iSecureId,iData->iClientWindowGroupId));

            }

        iData->iHandles.Close();

        delete iData->iObjectIx;

        // there shouldn't be orphean messages unless client app has been abnormally terminated...

        while( iData->iMessages.Count() )

            {

            iData->iMessages[0]->CompleteMessageD(KErrCancel);

            iData->iMessages.Remove(0);

            }

        iData->iMessages.Close();

        iData->iHuiEvents.Close();

        if (!iData->iPointerEvent.IsNull())

            {

            iData->iPointerEvent.Complete(KErrCancel);

            }

        if (!iData->iSystemEvent.IsNull())

            {

            iData->iSystemEvent.Complete(KErrCancel);

            }

        if ( iData->iContainer )

            {

            iHost->ReleaseContainer( *iData->iContainer );

            }

        delete iData;

        }

    iHost = NULL;

    }

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

// Called when focus gained.

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

//  

EXPORT_C void CAlfAppSrvSessionBase::FocusGainedL( TBool /*aDoTransitionEffect*/ )

    {

    // do some default effect if any

    }

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

// Called when focus lost.

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

//    

EXPORT_C TBool CAlfAppSrvSessionBase::FocusLostL( TBool /*aDoTransitionEffect*/ )

    {

    // do some default effect if any

    return EFalse;

    }

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

// Returns server.

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

//  

EXPORT_C CAlfAppServer* CAlfAppSrvSessionBase::AlfServer()

    {

    return iHost;

    }

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

// Returns AppUi.

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

//  

EXPORT_C CAlfAppUi* CAlfAppSrvSessionBase::AlfAppUi()

    {

    return iHost->AppUi(); // there is always AppUi when it is possible to create clients

    }

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

// From class CAknAppServiceBase.

// Called when client requests a service.

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

//

EXPORT_C void CAlfAppSrvSessionBase::ServiceL(const RMessage2& aMessage)

    {

    iData->iSecureId = aMessage.SecureId(); // one time would be enough    

    if(iHost->MetricsInterface())

        {

        iHost->MetricsInterface()->EnterClientMessageL(reinterpret_cast<TInt>(this), aMessage);

        if (aMessage.IsNull())

            { // metrics interface completed the message, just abort handling of message 

            return;

            }

        }

#ifdef _ALF_LOGGING

    TRAPD( err, 

        {

        if (!DoSubSessionCmdL(aMessage))    

            {

            DoHandleCommandL(aMessage);

            }

        } );

    if ( err != KErrNone )

        {

        __ALFLOGSTRING2( "CAlfAppSrvSessionBase::ServiceL req %d err %d", aMessage.Function(), err )

        User::Leave( err );

        }

#else

    if (!DoSubSessionCmdL(aMessage))    

        {

        DoHandleCommandL(aMessage);

        }

#endif

    if(iHost->MetricsInterface())

        {

        iHost->MetricsInterface()->ExitClientMessage(reinterpret_cast<TInt>(this), aMessage);

        }

    }

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

// 

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

// 

TBool CAlfAppSrvSessionBase::DoSubSessionCmdL(const RMessage2& aMessage)

    {

    TBool handled = ETrue;

    TInt function = aMessage.Function();

     // check if we are creating a subsession

    if ( function == EAlfCreateSubSession )

        {

        // Create subsession.

        CAlfSrvSubSessionBase* subSession = CreateSubSessionLC( aMessage );

        // Add to container (takes ownership)

        iData->iContainer->AddL( subSession );

        CleanupStack::Pop( subSession );

        const TInt handle = iData->iObjectIx->AddL( subSession );

        iData->iHandles.AppendL(TAlfHandleAndImplUid(handle,subSession->iFactoryUid));

        // Inform client of the handle its been allocated

        TPckg<TInt> handlePckg( handle );

        aMessage.Write(3,handlePckg);

        if ( !aMessage.IsNull() )

            {

            // Complete the message

            aMessage.Complete( KErrNone );

            }

        }

    else if ( function == EAlfDoSubSessionCmd ||

        function == EAlfDoAsyncSubSessionCmd ||

        function == EAlfSubSCancelAsynchRequest )

        {

        // Find an appropriate object and pass the message to it

        // for processing...

        //

        // we don't allow subsessions close each other, but session that sent the 

        // original request must be used for cancelling  

        //

        // We could use subsession information from message queue if anyone 

        // needs to be able to cancel commands

        const TInt handle = aMessage.Int3();

        // Fetch the sub-session by its handle

        CObject* object = iData->iObjectIx->At( handle );

        __ASSERT_ALWAYS( object , USER_INVARIANT() );

        CAlfSrvSubSessionBase* subsession = static_cast<CAlfSrvSubSessionBase*>(object);

        if (function != EAlfSubSCancelAsynchRequest)

            {

            subsession->ProcessMessageL( aMessage );

            }

        else

            {

            TInt index = iData->iMessages.Find(aMessage.Int0(), CAlfClientMessage::Compare);

            TInt count = iData->iMessages.Count();

            if  (index != KErrNotFound)   

                {

                TInt2 cancelParams(iData->iMessages[index]->iClientId, iData->iMessages[index]->iDecodedOp);

                TPckgC<TInt2> inbuf(cancelParams);

                TBuf8<1> dum;

                MAlfExtension* cmdHandler =  subsession->AsCommandHandler();

                if (cmdHandler)

                    {

                    cmdHandler->HandleCmdL(EAlfSubSCancelAsynchRequest, inbuf, dum);

                    }

                if (count == iData->iMessages.Count()) // message not successfully removed

                    {

#ifdef _ALF_LOGGING

                    RThread thread; 

                    iData->iMessages[index]->iMessage.ClientL(thread);

                    const TName threadName = thread.Name();

                    __ALFLOGSTRING2( "CAlfAppSrvSessionBase::DoSubSessionCmdL: Asynch message from client: %S, op: %d was not cancelled correctly",

                        &threadName, iData->iMessages[index]->iDecodedOp)

                    thread.Close();

#endif // _ALF_LOGGING       

                    iData->iMessages[index]->CompleteMessageD(KErrCancel);

                    iData->iMessages.Remove(index);

                    }                

                }

            aMessage.Complete(KErrNone);

            }

        }

    else if (function == EAlfCloseSubSession)

        {

        CloseSubSession(aMessage);

        }

     else 

        {

        handled = EFalse;

        }    

    return handled;

    }

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

// Called on contruction.

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

// 

EXPORT_C void CAlfAppSrvSessionBase::BaseConstructL()

    {

    // instrument private data etc..

    __ASSERT_ALWAYS(!iData,USER_INVARIANT());

    iData = new (ELeave) TPrivateData();

    iData->iSharedEnv = &AlfAppUi()->HuiEnv();

    iData->iClientWindowGroupId = KErrNotFound;

    iData->iContainer = iHost->NewContainerL();

    iData->iObjectIx = CObjectIx::NewL();  

    iData->iParentId = KErrNotFound; 

    }

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

// 

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

// 

EXPORT_C void CAlfAppSrvSessionBase::ExtensionInterfaceL(TUid /*aInterfaceId*/, TAny*& /*aImplementaion*/)

    {

    }

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

// 

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

// 

EXPORT_C CHuiEnv* CAlfAppSrvSessionBase::SharedHuiEnv() const

    {

    if (iData)

        {

        return iData->iSharedEnv;

        }

    return 0;

    }

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

// 

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

// 

EXPORT_C void CAlfAppSrvSessionBase::SetClientWindowGroupId(TInt aId)

    {

    __ASSERT_DEBUG(iData, USER_INVARIANT());

    iData->iClientWindowGroupId = aId;

    }

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

// 

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

//     

EXPORT_C TRect CAlfAppSrvSessionBase::ClientDrawingArea() const

    {

    return TRect(0,0,0,0);

    }

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

// 

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

// 

TInt CAlfAppSrvSessionBase::ClientWindowGroup() const

    {

    if (iData)

        {

        return iData->iClientWindowGroupId;

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// 

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

//   

CAlfSrvSubSessionBase* CAlfAppSrvSessionBase::CreateSubSessionLC(const RMessage2& aMessage)

    {

    CAlfSrvSubSessionBase* subSession = NULL;

    TPckgBuf<TAlfImplementationInformation> buf;

    aMessage.ReadL(0,buf);

    if (buf().iImplementationUid == 0) // built in component requested

        {

        switch (buf().iImplementationId)

            {

            case EAlfDisplaySubSessionOpen:

                {

                TRect rect;

                TPckg<TRect> rectPckg(rect); 

                aMessage.Read(1,rectPckg);

                TAlfDisplayCreateParams params;

                TPckg<TAlfDisplayCreateParams> paramPckg(params); 

                aMessage.Read(2,paramPckg);

                const TInt windowGroupId = params.iWindowGroupId;

                const TInt displayType = params.iDisplayType;

                subSession = CAlfSrvDisplaySubSession::NewLC( *this, rect, windowGroupId, displayType, KHuiUidBackBufferScreen0 );

                break;

                }

            case EAlfDisplaySubSessionOpen2:

                {

                TRect rect;

                TPckg<TRect> rectPckg(rect); 

                aMessage.Read(1,rectPckg);

                TAlfDisplayCreateParams2 params;

                TPckg<TAlfDisplayCreateParams2> paramPckg(params); 

                aMessage.Read(2,paramPckg);

                const TInt windowGroupId = params.iWindowGroupId;

                const TInt displayType = params.iDisplayType;

                const TUid bufferUid = params.iBufferUid;

                subSession = CAlfSrvDisplaySubSession::NewLC( *this, rect, windowGroupId, displayType, bufferUid );

                break;

                }

            case EAlfControlGroupSubSessionOpen:

                {

                const TInt id = aMessage.Int1();

                subSession = CAlfSrvControlGroupSubSession::NewLC( *this, id );

                break;

                }

            case EAlfTransformationSubSessionOpen:

                {

                subSession = CAlfSrvTransformationSubSession::NewLC( *this );

                break;

                }

            default:

                subSession = CAlfSrvSubSessionBase::NewLC( aMessage, 

                                                   buf().iImplementationUid,

                                                   buf().iImplementationId, 

                                                   *this );

                break;

            }

        }

    else

        {

        // Check what API has been used when app has been compiled before

        // loading extension. If runtime version is no more binary compatible, leave

        TVersion compiletimeVersion = buf().iVersion;

        TVersion runtimeVersion = TVersion(ALF_VERSION_MAJOR, ALF_VERSION_MINOR, ALF_VERSION_BUILD);

        // Major version (AlfClient.dll) has been already checked in the client side at this time.        

        // Minor version (AlfServercore, coretoolkit) is checked here.

        if (compiletimeVersion.iMinor != runtimeVersion.iMinor)

            {

            User::Leave(KErrNotSupported);    

            }

        // For check also build here

        else if (compiletimeVersion.iBuild > runtimeVersion.iBuild)

            {                

            User::Leave(KErrNotSupported);    

            }    

        else

            {                

            subSession = CAlfSrvSubSessionBase::NewLC( aMessage, 

                                                       buf().iImplementationUid,

                                                       buf().iImplementationId,                                                        *this );

            }

        }