/*
* 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:   Implementation of DTClient
*
*/



#include "DTClient.h"
#include "DevTokenUtils.h"
#include "DevTokenClientSession.h"


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

// -----------------------------------------------------------------------------
// CDTClient::CDTClient()
// -----------------------------------------------------------------------------
//
CDTClient::CDTClient(TInt aUID,
           MCTToken& aToken, 
           RDevTokenClientSession& aClient)
  : CActive(EPriorityNormal),
    iToken(aToken),   
    iInterfaceUID(aUID),  
    iClientSession(aClient),
    iRequestPtr(NULL, 0, 0)
    {
    } 


// -----------------------------------------------------------------------------
// CDTClient::~CDTClient()
// -----------------------------------------------------------------------------
//
CDTClient::~CDTClient()
    {
    Cancel();     
    delete iRequestDataBuf;
    }


// -----------------------------------------------------------------------------
// CDTClient::TAsyncRequest::~TAsyncRequest()
// -----------------------------------------------------------------------------
//
CDTClient::TAsyncRequest::~TAsyncRequest()
    {
    __ASSERT_DEBUG(EIdle==iRequest, DevTokenPanic(ERequestOutstanding));
    }


// -----------------------------------------------------------------------------
// CDTClient::TAsyncRequest::operator()
// -----------------------------------------------------------------------------
//
void CDTClient::TAsyncRequest::operator()(TDevTokenMessages aRequest, 
                                          TRequestStatus* aStatus)
    {
    __ASSERT_DEBUG(EIdle==iRequest, DevTokenPanic(ERequestOutstanding));
    iRequest = aRequest; 
    iClientStatus = aStatus;
    *aStatus = KRequestPending;
    }


// -----------------------------------------------------------------------------
// CDTClient::TAsyncRequest::Complete()
// -----------------------------------------------------------------------------
//
void CDTClient::TAsyncRequest::Complete(TInt aCompletionResult)
    {
    __ASSERT_DEBUG(EIdle!=iRequest, DevTokenPanic(ENoRequestOutstanding));
    User::RequestComplete(iClientStatus, aCompletionResult);
    iRequest = EIdle;
    }


// -----------------------------------------------------------------------------
// CDTClient::TAsyncRequest::Cancel()
// -----------------------------------------------------------------------------
//
void CDTClient::TAsyncRequest::Cancel()
    {
    User::RequestComplete(iClientStatus, KErrCancel);
    iRequest = EIdle;
    }


// -----------------------------------------------------------------------------
// CDTClient::TAsyncRequest::FreeRequestBuffer()
// -----------------------------------------------------------------------------
//
void CDTClient::FreeRequestBuffer() const
    {
    delete iRequestDataBuf; 
    iRequestDataBuf = NULL;
    iRequestPtr.Set(NULL, 0, 0);
    }


// -----------------------------------------------------------------------------
// CDTClient::AllocRequestBuffer(TInt aReqdSize) const
// -----------------------------------------------------------------------------
//
TInt CDTClient::AllocRequestBuffer(TInt aReqdSize) const
    {
    ASSERT(aReqdSize > 0);
    TInt result = KErrNoMemory;

    FreeRequestBuffer();
    iRequestDataBuf = HBufC8::NewMax(aReqdSize);
    if ( iRequestDataBuf )
        {
        iRequestPtr.Set(iRequestDataBuf->Des());
        iRequestPtr.FillZ();
        result = KErrNone;
        }
    return result;
    }


// -----------------------------------------------------------------------------
// CDTClient::SendSyncRequestAndHandleOverflowL()
// Execute a synchronous request that returns a buffer of indetermintate length.
// If the initial buffer is too short, the server leaves with KErrOverflow and
// passes us the required length - the reuest is then re-sent.
// -----------------------------------------------------------------------------
// 
void CDTClient::SendSyncRequestAndHandleOverflowL(TDevTokenMessages aMessage,
                          TInt aInitialBufSize,
                          const TIpcArgs& aArgs) const
    {
    User::LeaveIfError(AllocRequestBuffer(aInitialBufSize));

    TInt err = iClientSession.SendRequest(aMessage, aArgs);
    if ( err == KErrOverflow )
        {
        TInt sizeReqd = 0;
        TPckg<TInt> theSize(sizeReqd);
        theSize.Copy(iRequestPtr);
        User::LeaveIfError(AllocRequestBuffer(sizeReqd));     
        err = iClientSession.SendRequest(aMessage, aArgs);
        }
    User::LeaveIfError(err);
    }


// -----------------------------------------------------------------------------
// CDTClient::DoCancel()
// -----------------------------------------------------------------------------
// 
void CDTClient::DoCancel()
    {
    iCurrentRequest.Cancel();
    }


// -----------------------------------------------------------------------------
// CDTClient::RunError()
// -----------------------------------------------------------------------------
// 
TInt CDTClient::RunError(TInt aError)
    {
    iCurrentRequest.Complete(aError);
    return KErrNone; // Handled
    }

//EOF