/*

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

*

*/

#include "alf/alfgencomponent.h"

#include "alf/alfconstants.h"

#include "alf/alfenv.h"

#include "alfclient.h"

#include "alflogger.h"

#include <uiacceltk/HuiUtil.h>

class CAlfMessageObserver;

NONSHARABLE_CLASS(RAlfSubsessionSimple): public RSubSessionBase

    {

public:

    TInt Open(CAlfEnv& aEnv, TInt aImplementationId, TInt aImplementationUid, const TDesC8& aConstuctionParams);

    TInt SendSynch(TUint aOp, const TDesC8& aInputBuf, TDes8& aOutBuf);

    TInt SendNoReply(TUint aOp, const TDesC8& aInputBuf);

    void SendAsync(const TDesC8& aInputBuf, TDes8& aOutBuf, CAlfMessageObserver* aObserver); 

    void Cancel(TInt aCmdId);

    void Close();

    TInt Identifier()

        {

        return SubSessionHandle();

        }

private:

    RAlfClient* iClient;

    };

NONSHARABLE_CLASS(CAlfMessageObserver):public CActive

    {

    public:

    static CAlfMessageObserver* NewRequestLC(RAlfSubsessionSimple& aClient, MAlfAsyncOpObserver* aObserver, TInt aCmdId, CAlfGenComponent& aComms)

        {

        CAlfMessageObserver* me = new (ELeave) CAlfMessageObserver(aClient, aObserver, aCmdId, aComms);

        me->SetActive();

        CleanupStack::PushL(me);

        return me;

        }

    TRequestStatus& Status() 

        {

        return iStatus;

        }

    ~CAlfMessageObserver()

        {

        Cancel();

        if (iObserver)

            {

            iObserver->AlfAsyncOpCompleted(TInt(this), KErrCancel);

            }

        }

    const TDesC8& Des() const

        {

        return iAsDescriptor;

        }

    private:

    CAlfMessageObserver(RAlfSubsessionSimple& aClient, MAlfAsyncOpObserver* aObserver, TInt aCmdId, CAlfGenComponent& aComms)

        :CActive(CActive::EPriorityHigh),iClient(aClient), iObserver(aObserver), iComms( aComms ),

        iParametersAsInts(0,0),

        iAsDescriptor( iParametersAsInts )

        {

        ASSERT(aClient.Identifier());

        CActiveScheduler::Add(this);

        iParametersAsInts.iInt1 = aCmdId;

        iParametersAsInts.iInt2 = reinterpret_cast<TInt>(this);

        }

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

    // from CActive, called when asych request completed by server

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

    //    

    void RunL()

        {

        iObserver->AlfAsyncOpCompleted(TInt(this), iStatus.Int());

        iObserver = 0;

        iComms.CommandCompleted( this ); // function call deletes 'this'

        }

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

    // from CActive, called if Cancel called while active

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

    //

    void DoCancel()

        {

        iClient.Cancel(TInt(this));        

        }

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

    // from CActive, will be called if RunL leaves (in this case note allowed )

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

    //

    TInt RunError(TInt /*aError*/)

        {

        // client leaved in AlfAsyncOpCompleted, just panic it

        USER_INVARIANT();

        return KErrNone;

        }

    RAlfSubsessionSimple& iClient;

    MAlfAsyncOpObserver* iObserver;

    CAlfGenComponent& iComms;

    TInt2 iParametersAsInts;

    TPckgC<TInt2> iAsDescriptor;

    };

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

// creates new subsession

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

//

TInt RAlfSubsessionSimple::Open(CAlfEnv& aEnv, TInt aImplementationId, TInt aImplementationUid, const TDesC8& aConstuctionParams)

    {

    iClient = &aEnv.Client();

    (void)iClient->FlushBatchBuffer();

    TAlfImplementationInformation info(aImplementationId,aImplementationUid, aEnv.ApiVersion());

    TPckgC<TAlfImplementationInformation> infoBuf(info);

    return CreateSubSession(*iClient, EAlfCreateSubSession, TIpcArgs(&infoBuf, &aConstuctionParams));

    }

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

// Synchronous server request

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

//

TInt RAlfSubsessionSimple::SendSynch(TUint aOp, const TDesC8& aInputBuf, TDes8& aOutBuf)

    {

    (void)iClient->FlushBatchBuffer();

    return SendReceive(EAlfDoSubSessionCmd, TIpcArgs(aOp,&aInputBuf,&aOutBuf));

    }

TInt RAlfSubsessionSimple::SendNoReply(TUint aOp, const TDesC8& aInputBuf )

    {

	return(iClient->SendNoReply(aOp, aInputBuf, SubSessionHandle()));

    }

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

// Sets asynchronous request

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

//

void RAlfSubsessionSimple::SendAsync(const TDesC8& aInputBuf, TDes8& aOutBuf, CAlfMessageObserver* aObserver)

    {

    (void)iClient->FlushBatchBuffer();

    SendReceive(EAlfDoAsyncSubSessionCmd, TIpcArgs(&aObserver->Des(),&aInputBuf,&aOutBuf), aObserver->Status());

    }

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

// cancels asynch operation if active

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

//

void RAlfSubsessionSimple::Cancel(TInt aCmdId)

    {

    if (SubSessionHandle())

        {

        SendReceive(EAlfSubSCancelAsynchRequest, TIpcArgs(aCmdId));

        }

    }

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

// terminates server side resources

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

//

void RAlfSubsessionSimple::Close()

    {

    if ( SubSessionHandle() )

        {

        (void)iClient->FlushBatchBuffer();

        }

    CloseSubSession(EAlfCloseSubSession);    

    }

// private data

NONSHARABLE_CLASS(CAlfGenComponent::TPrivateData)

    {

    public:

    RAlfSubsessionSimple iClient;

    RPointerArray<CAlfMessageObserver> iObservers;

    };

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

// Public constructor

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

//

EXPORT_C CAlfGenComponent* CAlfGenComponent::NewL(

            CAlfEnv& aEnv,

            TInt aImplementationId, 

            TInt aImplementationUid, 

            const TDesC8& aConstructionParams)

    {

    CAlfGenComponent* me = new (ELeave) CAlfGenComponent(aEnv);

    CleanupStack::PushL(me);

    me->ConstructL( aImplementationId, aImplementationUid,aConstructionParams);

    CleanupStack::Pop(me);

    return me;

    }

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

// Destructor

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

//    

EXPORT_C CAlfGenComponent::~CAlfGenComponent()

    {

    if (iData)

        {

        iData->iObservers.ResetAndDestroy(); // will cancel outstanding requests 

        iData->iObservers.Close();

        iData->iClient.Close();

        }

    delete iData;

    }

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

// performs synchronous request

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

//

EXPORT_C TInt CAlfGenComponent::DoSynchronousCmd( TUint aOp, 

                               const TDesC8& aInputBuf, TDes8& aOutBuf)

    {

    ASSERT(iData);

    return iData->iClient.SendSynch(aOp, aInputBuf, aOutBuf);

    }

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

// performs synchronous request without waiting the reply from the server

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

//    

EXPORT_C  TInt CAlfGenComponent::DoCmdNoReply( TUint aOp, const TDesC8& aInputBuf )

    {

    ASSERT(iData);

    TInt err = iData->iClient.SendNoReply(aOp, aInputBuf);

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "CAlfGenComponent::DoCmdNoReply buffer error %d - using DoSynchronousCmd", err )

        TBuf8<1> dum;

        err = DoSynchronousCmd( aOp, aInputBuf, dum );

        }

    return err;

    }

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

// Raises async request to server

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

//

EXPORT_C TInt CAlfGenComponent::DoAsynchronousCmdL(TUint aOp, const TDesC8& aInputBuf, 

                               TDes8& aOutBuf, MAlfAsyncOpObserver* aObserver)

    {

    ASSERT(iData);

    // ASSERT(aObserver); // todo: does client need to provide observer if it is not interested about response

    CAlfMessageObserver* obsEntry = CAlfMessageObserver::NewRequestLC(iData->iClient, aObserver, aOp, *this);

    iData->iObservers.AppendL(obsEntry);

    CleanupStack::Pop();

    iData->iClient.SendAsync(aInputBuf, aOutBuf, obsEntry);

    return TInt(obsEntry);

    }

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

// Request to cancel possible async request

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

//

EXPORT_C void CAlfGenComponent::CancelAsynchCmd(TInt aCmdId)

    {

    if (iData)

        {

        const TInt index = iData->iObservers.Find(reinterpret_cast<CAlfMessageObserver*>(aCmdId));

        if (index != KErrNotFound)

            {

            CAlfMessageObserver* item = iData->iObservers[index];

            iData->iObservers.Remove(index);

            delete item;

            }

        }

    }

EXPORT_C TInt CAlfGenComponent::Identifier()

    {

    if (iData)

        return iData->iClient.Identifier();

    return 0;

    }

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

// Default construtor, private

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

//

CAlfGenComponent::CAlfGenComponent(CAlfEnv& aEnv)

    :iEnv(aEnv)

    {

    __ASSERT_ALWAYS(aEnv.Client().Handle(), USER_INVARIANT());

    }

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

// 2nd phase ctr, opens subsession to envs client

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

//    

void CAlfGenComponent::ConstructL(

            TInt aImplementationId, 

            TInt aImplementationUid, 

            const TDesC8& aConstructionParams)

    {

    iData = new (ELeave) TPrivateData();

    User::LeaveIfError(iData->iClient.Open(iEnv, aImplementationId,aImplementationUid,aConstructionParams));

    iData->iObservers.Reset();

    }

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

// Called when message completes

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

//        

void CAlfGenComponent::CommandCompleted( CAlfMessageObserver* aMessageObserver )

    {

    ASSERT(iData);

    const TInt index = iData->iObservers.Find(aMessageObserver);

    ASSERT(index != KErrNotFound);

    delete iData->iObservers[index];

    iData->iObservers.Remove(index);

    }

// end of file