/*
* Copyright (c) 2008 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 FILES
#include "cstsapduexchanger.h"
#include "stsapduconstants.h"
#include "cstscmdapdu.h"
#include "cstsrespapdu.h"
#include "cstscardoperationsfacade.h"
#include "mstsresphandler.h"
#include "cstsgetresponse.h"
#include "fs_methodcall.h"
#include "logger.h"

namespace java
{
namespace satsa
{

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

// -----------------------------------------------------------------------------
// CSTSApduExchanger::CSTSApduExchanger
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//

CSTSApduExchanger::CSTSApduExchanger(CSTSCardOperationsFacade* aCOFacade) :
        CActive(EPriorityNormal)
{
    CActiveScheduler::Add(this);
    iCOFacade = aCOFacade;
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::ConstructL()
{
    iWait = new(ELeave) CActiveSchedulerWait();
    iRespBuf = HBufC8::NewL(KSTSResponseApduMaxLength);
    iRespApdu = CSTSRespApdu::NewL(KSTSResponseApduMaxLength);
    iGetResponseApdu = CSTSGetResponse::NewL(0x00, //empty at this point
                       CSTSApdu::ESTSUICC);
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSTSApduExchanger* CSTSApduExchanger::NewL(JNIEnv* aJni, jobject aPeer,
        CSTSCardOperationsFacade* aCOFacade)
{
    CSTSApduExchanger* self = new(ELeave) CSTSApduExchanger(aCOFacade);
    self->mJni = aJni;
    self->mPeer = aPeer;

    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

// Destructor
CSTSApduExchanger::~CSTSApduExchanger()
{
    Cancel();
    delete iRespBuf;
    delete iWait;
    delete iRespApdu;
    delete iGetResponseApdu;
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::DoExchange
// Set channel, apdu and empties response buffer. Exchanges apdu message
// asynchronously
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::DoExchange(CSTSCmdApdu& aCmdApdu)
{
    LOG(ESATSA, EInfo, "+ CSTSApduExchanger::DoExchange");
    aCmdApdu.SetChannel(iChannel);

    iCmdApdu = &aCmdApdu;
    //response buffer is "reusable" so empty length before next use
    iRespBuf->Des().SetLength(0);
    //send apdu to card
    LOG(ESATSA, EInfo, "CSTSApduExchanger::DoExchange: send apdu to card");
    iCOFacade->SendAPDUReq(iStatus, (TUint8) iReader, &aCmdApdu.ApduBytes());
    SetActive();
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::ExchangeApduL
// Exchanges apdu message synchronously
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CSTSApduExchanger::ExchangeApdu(CSTSCmdApdu& aCmdApdu,
                                     CSTSRespApdu& aRespApdu)
{
    DoExchange(aCmdApdu);
    if (!iWait->IsStarted())
    {
        iWait->Start();
    }
    //save response
    aRespApdu.ResponseBytes() = iRespBuf->Des();
    return iStatus.Int();

}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::ExchangeApdu
// Exchanges apdu message asynchronously
// Sets iClientStatus information for RunL purposes.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::ExchangeApduAsync(CSTSCmdApdu& aCmdApdu,
        MSTSRespHandler* aRespHandler)
{
    LOG(ESATSA, EInfo, "+ CSTSApduExchanger::ExchangeApduAsync 1");

    iRespHandler = aRespHandler;
    LOG(ESATSA, EInfo, "Calling DoExchnage()");
    DoExchange(aCmdApdu);
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::ExchangeApdu
// Exchanges apdu message asynchronously
// Response must be get separately after asynchronous call is returned
// When using this method for sending apdu and GetResponseBytes method for
// getting response bytes there is no checked is resend needed or get response
// needed.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::ExchangeApduAsync(TRequestStatus& aStatus,
        CSTSCmdApdu& aCmdApdu)
{
    aCmdApdu.SetChannel(iChannel);
    // send apdu to card
    iCOFacade->SendAPDUReq(aStatus, (TUint8) iReader, &aCmdApdu.ApduBytes());
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::GetResponseBytes

// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::GetResponseBytes(CSTSRespApdu& aRespApdu)
{
    iCOFacade->GetResponseBytes(&aRespApdu.ResponseBytes());
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::SetChannel
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::SetChannel(TInt aChannel)
{
    LOG(ESATSA, EInfo, "+ CSTSApduExchanger::SetChannel");
    iChannel = aChannel;
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::SetReader
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::SetReader(TInt aReader)
{
    iReader = aReader;
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::SetConnectionType
// Sets connection target to response adpu
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::SetConnectionType(TBool aSatConnection)
{
    if (aSatConnection)
    {
        iRespApdu->SetConnectionTarget(CSTSRespApdu::ESTSUSAT);
    }
    else
    {
        iRespApdu->SetConnectionTarget(CSTSRespApdu::ESTSAID);
    }
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::CancelExchange
// Can be used, if J2ME application calls CLOSE method in another thread for
// closing connection and in other thread is pending apdu send at the same time.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::CancelExchange()
{
    Cancel();
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::RunL
// If apdu send was called synchronously, CActiveSchedulerWait is used to continue
// in ExchangeApduL method. If apdu send was called synchronously, we notify
// and deliver response to java side
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::RunL()
{
    LOG(ESATSA, EInfo, "+ CSTSApduExchanger::RunL");
    if (iStatus == KErrNone)
    {
        LOG(ESATSA, EInfo, "CSTSApduExchanger::RunL:Status is KErrNone.");
        iRespApdu->ResponseBytes().SetLength(0);
        iCOFacade->GetResponseBytes(&iRespApdu->ResponseBytes());

        //append new response after old response
        iRespBuf->Des().Append(iRespApdu->ResponseBytes());

        TUint8 newRespLength = 0x00;
        if (iRespApdu->GetResponseNeeded(newRespLength))
        {
            LOG(ESATSA, EInfo, "CSTSApduExchanger::RunL:GetResponseNeeded");
            //remove sw1 and sw2, because more data will be appended
            iRespBuf->Des().SetLength(iRespBuf->Length() - 2);
            //we got new length from earlier called method
            iGetResponseApdu->SetExpectedResponseLength(newRespLength);
            iGetResponseApdu->SetChannel(iChannel);

            //send get response apdu to card
            LOG(ESATSA, EInfo, "send get response apdu to card");
            iCOFacade->SendAPDUReq(iStatus, (TUint8) iReader,
                                   &iGetResponseApdu->ApduBytes());
            SetActive();
        }
        else if (iRespApdu->ResendNeeded(newRespLength))
        {
            LOG(ESATSA, EInfo, "CSTSApduExchanger::RunL: Resend needed ");
            //Resend apdu with correct length
            iCmdApdu->SetLe(newRespLength);
            iRespBuf->Des().SetLength(0); //empty old response

            LOG(ESATSA, EInfo, "send same apdu to card again (resend)");
            //send same apdu to card again (resend)
            iCOFacade->SendAPDUReq(iStatus, (TUint8) iReader,
                                   &iCmdApdu->ApduBytes());
            SetActive();
        }
        else
        {
            //if synchronous ExchangeApdu was called
            if (iWait->IsStarted())
            {
                LOG(ESATSA, EInfo, "Synch Exchng called!");
                iWait->AsyncStop();
            }
            //if asynchronous ExchangeApduAsync was called
            else
            {
                LOG(ESATSA, EInfo, "calling response handler to complete operation");
                iRespHandler->OperationComplete(mJni, mPeer, iRespBuf, KErrNone);
            }
        }
    }
    else //if the iStatus is not KErrNone
    {
        LOG(ESATSA, EInfo, "CSTSApduExchanger::RunL:iStatus is not KErrNone");
        //if synchronous ExchangeApdu was called
        if (iWait->IsStarted())
        {
            iWait->AsyncStop();
        }
        else
        {
            LOG(ESATSA, EInfo, "calling response handler to complete operation");
            iRespHandler->OperationComplete(mJni, mPeer, NULL, KSTSErrIO);
        }
    }
}

// -----------------------------------------------------------------------------
// CSTSApduExchanger::DoCancel
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSTSApduExchanger::DoCancel()
{

    if (iWait->IsStarted())
    {
        //synchronous call can not be cancelled

    }
    else
    {
        iCOFacade->CancelAPDUReq();
        iRespHandler->OperationComplete(mJni, mPeer, NULL, KSTSErrInterruptedIO
                                        + KSTSErrIIConnClosedDuring);
    }
}

} // namespace satsa
} // namespace java
//  End of File