// 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 "CMmWimTsy.h"

#include <ctsy/rmmcustomapi.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

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

CMmWimTsy::CMmWimTsy()

    {

    }

void CMmWimTsy::ConstructL(

    CMmCustomTsy* aMmCustomTsy )

    {

    iMmCustomTsy = aMmCustomTsy;

    // Create req handle store

#ifdef REQHANDLE_TIMER   

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( iMmCustomTsy,

        iMmCustomTsy->iMmPhoneTsy, EWIMRequestTypeMaxNumOfRequests, 

        iWIMReqHandles );

#else // REQHANDLE_TIMER

   iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EWIMRequestTypeMaxNumOfRequests, iWIMReqHandles );

    return;

#endif // REQHANDLE_TIMER

    }

CMmWimTsy* CMmWimTsy::NewL(

    CMmCustomTsy* aMmCustomTsy )

    {

    CMmWimTsy* mmWIM = new ( ELeave ) CMmWimTsy();

    CleanupStack::PushL( mmWIM );

    mmWIM->ConstructL( aMmCustomTsy );

    CleanupStack::Pop( mmWIM );

    return mmWIM;

    }

CMmWimTsy::~CMmWimTsy()

    {

    if ( iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        }

    iMmCustomTsy = NULL;

    iRetApduInfo = NULL;

    iRetApduData = NULL;

    iAnswerToReset = NULL;

    iApduParameters = NULL;

    iSimCardReaderStatus = NULL;

    iNotifiedSimCardStatus = NULL;

    }

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

// CMmWimTsy::Init

// Initialisation method that is called from ETel Server.

// (other items were commented in a header).

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

//

void CMmWimTsy::Init()

    {

    }

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

// CMmWimTsy::RegisterNotification

// Called when the server recognises that this notification is being posted 

// for the first time on this sub-session object. It enables the TSY to "turn 

// on" any regular notification messages that it may receive from DOS.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::RegisterNotification(    

    const TInt aIpc )

    {

    TInt ret ( KErrNotSupported );

    switch ( aIpc )

        {

        case ECustomNotifySimCardStatusIPC:

            ret =  KErrNone;

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmWimTsy::SupportingIPC

// Tells whether the object supports given IPC.

// (other items were commented in a header).

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

//

TBool CMmWimTsy::SupportingIPC(

    const TInt aIpc )

    { 

    TInt ret( EFalse );

    switch ( aIpc )

        {

        case ECustomSimWarmResetIPC:

        case ECustomGetATRIPC:

        case ECustomSendAPDUReqIPC:

        case ECustomGetSimCardReaderStatusIPC:

        case ECustomNotifySimCardStatusIPC:

        case ECustomSendAPDUReqV2IPC:

        case ECustomPowerSimOnIPC:

        case ECustomPowerSimOffIPC:

            ret = ETrue;

            break;

        default:

            ret = EFalse;

            break;

        }

    return ret;

    }

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

// CMmWimTsy::DeregisterNotification

// Called when the server recognises that this notification will not be posted 

// again because the last client to have a handle on this sub-session object 

// has just closed the handle. It enables the TSY to "turn off" any regular 

// notification messages that it may receive from DOS.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::DeregisterNotification(    

    const TInt aIpc )

    {

    TInt ret ( KErrNotSupported );

    switch ( aIpc )

        {

        case ECustomNotifySimCardStatusIPC:

            ret =  KErrNone;

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmWimTsy::DoExtFuncL

// Dispatches extension function requests. At the beginning of this method,

// packaged pointers are unpacked. Then the correct function is selected

// using the IPC number.

// If the IPC is supported, returns the return value of corresponding function

// else returns KErrNotSupported.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNotSupported );

    switch ( aIpc )

        {

        case ECustomSendAPDUReqIPC:

            ret = SendAPDUReqL( aTsyReqHandle, aPackage.Des1n(), 

                aPackage.Des2n() );

            break;                    

        case ECustomGetATRIPC:

            ret = GetATRL( aTsyReqHandle, aPackage.Des1n() );

            break;

        case ECustomSimWarmResetIPC:

            ret = SimWarmResetL( aTsyReqHandle );

            break;

        case ECustomGetSimCardReaderStatusIPC:

            ret =  GetSimCardReaderStatusL( aTsyReqHandle, REINTERPRET_CAST( 

                RMmCustomAPI::TSimCardReaderStatus*, aPackage.Ptr1() ) );

            break;                            

        case ECustomNotifySimCardStatusIPC:

            ret =  NotifySimCardStatus( aTsyReqHandle, REINTERPRET_CAST( 

                RMmCustomAPI::TSIMCardStatus*, aPackage.Ptr1() ) );

            break;                        

        case ECustomSendAPDUReqV2IPC:

            ret = SendAPDUReqV2L( aTsyReqHandle, REINTERPRET_CAST( 

                RMmCustomAPI::TApduParameters*, aPackage.Ptr1() ) );

            break;

        case ECustomPowerSimOnIPC:

            ret = PowerSimOnL( aTsyReqHandle );

            break;

        case ECustomPowerSimOffIPC:

            ret = PowerSimOffL( aTsyReqHandle );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;        

    }

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

// CMmWimTsy::ReqModeL

// Returns request mode for given IPC. Leaves with error code KErrNotSupported

// if the IPC number does not belong to some of the WIM-related API functions. 

// (other items were commented in a header).

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

//

CTelObject::TReqMode CMmWimTsy::ReqModeL(

    const TInt aIpc )

    {

    CTelObject::TReqMode ret=0;

    switch ( aIpc )

        {

        case ECustomSendAPDUReqIPC: 

            // Custom TSY has its own flow control and allows several 

            // simultaneous requests.

            ret = KReqModeMultipleCompletionEnabled;

            break;

        case ECustomNotifySimCardStatusIPC:

            ret = KReqModeRePostImmediately | 

                  KReqModeMultipleCompletionEnabled;

            break;

        default:

            break;    

        }

    return ret;

    }

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

// CMmWimTsy::NumberOfSlotsL

// Returns number of slots to be used for given IPC. Leaves with error code 

// KErrNotSupported if the IPC number does not belong to some of the 

// WIM-related API functions. 

// (other items were commented in a header).

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

//

TInt CMmWimTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    TInt numberOfSlots = KMmCustomDefaultSlots;

    switch ( aIpc )

        {

        case ECustomSendAPDUReqIPC:

            break;    

        case ECustomNotifySimCardStatusIPC:

            break;

        default:

            // Unknown or invalid IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmWimTsy::CancelService

// When the clients close their sub-sessions (eg. by calling RPhone::Close),

// they may not have cancelled all their outstanding asynchronous requests

// before closing. It is up to the ETel server to clean up in this situation,

// so the server will find the list of outstanding requests related to that

// sub-session object and pass these outstanding IPC request numbers, one at

// a time, to the CancelService function in the TSY.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::CancelService(

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle )

    {

    TInt ret( KErrGeneral );

    switch ( aIpc )

        {

        case ECustomSendAPDUReqIPC:

            ret = SendAPDUReqCancel( aTsyReqHandle );

            break;

        case ECustomGetATRIPC:

            ret = GetATRCancel();

            break;

        case ECustomSimWarmResetIPC:

            ret = SimWarmResetCancel();

            break;

        case ECustomGetSimCardReaderStatusIPC:

            ret = GetSimCardReaderStatusCancel();

            break;

        case ECustomNotifySimCardStatusIPC:

            ret = NotifySimCardStatusCancel();

            break;

        case ECustomSendAPDUReqV2IPC:

            ret = SendAPDUReqV2Cancel();

            break;

        case ECustomPowerSimOnIPC:

            ret = PowerSimOnCancel();

            break;

        case ECustomPowerSimOffIPC:

            ret = PowerSimOffCancel();

            break;

        default:

            ret = KErrGeneral;

            break; 

        }

    return ret;

    }

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

// CMmWimTsy::SendAPDUReqL

// Send APDU request to DOS.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::SendAPDUReqL( 

    const TTsyReqHandle aTsyReqHandle,

    TDes8* aInfo, 

    TDes8* aData )

    {

    TInt ret ( KErrNone );

    // This is originally a TApdu in the API

    RMmCustomAPI::TApdu apduReq;

    apduReq.iInfo = aInfo;

    apduReq.iData = aData;

    // call DOS, packed parameter: a RMmCustomAPI::TApdu

    CMmDataPackage dataPackage;

    dataPackage.PackData( &apduReq );

    ret = iMmCustomTsy->Phone()->MessageManager()->HandleRequestL( 

        ECustomSendAPDUReqIPC, &dataPackage );

    if ( KErrNone == ret )

        {

        // save pointer to client for response data

        iRetApduInfo = aInfo;

        iRetApduData = aData;

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( EWIMRequestTypeSendAPDUReq, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle(

            EWIMRequestTypeSendAPDUReq, aTsyReqHandle );

#endif // REQHANDLE_TIMER

        }	

    return ret;

    }

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

// CMmWimTsy::CompleteSendAPDUReq

// Completes a Send APDU request.

// (other items were commented in a header).

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

//

#ifndef USING_CTSY_DISPATCHER

void CMmWimTsy::CompleteSendAPDUReq(

    CMmDataPackage* aDataPackage, 

    TInt aError )

    {

	// Complete request

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

            EWIMRequestTypeSendAPDUReq );

	if( reqHandle )

		{

    if ( KErrNone == aError )

        {

        //unpack the data

        TPtrC8* info = NULL;

        TPtrC8* data = NULL;

        aDataPackage->UnPackData( &info, &data );

    // request was successful, copy data to client side

    if ( iRetApduInfo && info )

        {

        iRetApduInfo->Copy( info->Ptr(), info->Length() );

        }

    if ( iRetApduData && data )

        {

        iRetApduData->Copy( data->Ptr(), data->Length() );

        }

        }

       iMmCustomTsy->ReqCompleted( reqHandle, aError );

       }

    }

#endif //USING_CTSY_DISPATCHER

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

// CMmWimTsy::SendAPDUReqCancel

// Cancel outstanding Send APDU request.

// (other items were commented in a header).

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

//

TInt CMmWimTsy::SendAPDUReqCancel( 

    TTsyReqHandle aTsyReqHandle )

    {

    // reset the reqhandle

    iTsyReqHandleStore->ResetTsyReqHandle(

        EWIMRequestTypeSendAPDUReq );

    // reset return pointers

    iRetApduInfo = NULL;

    iRetApduData = NULL;

    // complete

    iMmCustomTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

#ifdef REQHANDLE_TIMER

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

// CMmWimTsy::SetTypeOfResponse

// Sets the type of response for a given handle. Automatic mode includes an 

// automatic response in case of non response from the DOS in a specified time.

// (other items were commented in a header).

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

//

void CMmWimTsy::SetTypeOfResponse(

    const TInt aReqHandleType, 

    const TTsyReqHandle aTsyReqHandle )

    {

    TInt timeOut( 0 );

    TInt ipc( 0 );

    switch ( aReqHandleType )

        {

        case EWIMRequestTypeSendAPDUReq:

            timeOut = KMmSendAPDUTimeOut;

            ipc = ECustomSendAPDUReqIPC;

            break;

        case EWIMRequestTypeSimWarmReset:

            timeOut = KMmSimWarmResetTimeOut;

            ipc = ECustomSimWarmResetIPC;

            break;

        case EWIMRequestTypeGetATR:

            timeOut = KMmGetATRTimeOut;

            ipc = ECustomGetATRIPC;

            break;

        case EWIMRequestTypeGetSimCardReaderStatus:

            timeOut = KMmGetSimCardReaderStatusTimeOut;

            ipc = ECustomGetSimCardReaderStatusIPC;

            break;

        case EWIMRequestTypeSendAPDUReqV2:

            timeOut = KMmSendAPDUV2TimeOut;            

            ipc = ECustomSendAPDUReqV2IPC;

            break;

        case EWIMRequestTypePowerSimOn:

            timeOut = KMmPowerSimOnTimeOut;

            ipc = ECustomPowerSimOnIPC;

            break;

        case EWIMRequestTypePowerSimOff:  

            timeOut = KMmPowerSimOffTimeOut;

            ipc = ECustomPowerSimOffIPC;

            break;

        default:

            // Does not use timer

            break;

        }

    if ( 0 < timeOut )

        {

        // The timeout parameter is given in seconds.

        iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, aTsyReqHandle,

            timeOut, ipc );

        }

    }

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

// CMmWimTsy::Complete

// Completes the request due the timer expiration.

// (other items were commented in a header).

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

//

void CMmWimTsy::Complete(

    TInt aReqHandleType, 

    TInt aError )

    {

    iMmCustomTsy->ReqCompleted( iTsyReqHandleStore->ResetTsyReqHandle( 

        aReqHandleType ), aError );

    }

#endif // REQHANDLE_TIMER

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

// CMmWimTsy::GetATRL

// Send GetATR request.

// (other items were commented in a header).

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

//  

TInt CMmWimTsy::GetATRL(

    const TTsyReqHandle aTsyReqHandle, 

    TDes8 *aATR )

    {