/*
* Copyright (c) 2003 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:  Handles messaging with stack
*
*/



// INCLUDE FILES
#include    "ScardBase.h"
#include    "ScardMessageStack.h"
#include    "ScardConnector.h"
#include    "WimTrace.h"

#ifdef _DEBUG // for logging
#include    "ScardLogs.h"
#include    <flogger.h> 
#endif


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

// -----------------------------------------------------------------------------
// CScardMessageStack::CScardMessageStack
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CScardMessageStack::CScardMessageStack()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::CScardMessageStack|Begin"));
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CScardMessageStack::ConstructL()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::ConstructL|Begin"));
    iMessages = new( ELeave ) CArrayFixFlat<TMessageHandle>( 3 );
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CScardMessageStack* CScardMessageStack::NewL()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::NewL|Begin"));
    CScardMessageStack* self = new( ELeave ) CScardMessageStack();
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

    
// Destructor
CScardMessageStack::~CScardMessageStack()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::~CScardMessageStack|Begin"));
    CancelAll( KScErrCancelled );
    delete iMessages;
    }


// -----------------------------------------------------------------------------
// CScardMessageStack::CancelAll
// Cancel all operations for this session ID.
// -----------------------------------------------------------------------------
//
void CScardMessageStack::CancelAll(
    const TInt aSessionID, 
    const TInt aReason )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::CancelAll|Begin"));
    if ( iMessages->Count() )
        {
        //  First check if the message currently serviced is one of 
        //  the cancelled ones (it requires special treatment)
        if ( (*iMessages)[0].iSessionID == aSessionID ) 
            {
            CancelOne( 0, aReason );
            }
        //  Then pop out all the others
        for ( TInt i( 1 ); i < iMessages->Count(); i++ ) 
            {
            if ( (*iMessages)[i].iSessionID == aSessionID )
                {
                CancelOne( i, aReason );
                iMessages->Delete( i );
                i--;
                } // if
            } // for
        } // if
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::CancelAll
// Cancel all messages waiting for service. Delete all others except the 
// first one
// -----------------------------------------------------------------------------
//
void CScardMessageStack::CancelAll( const TInt aReason )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::CancelAll|Begin"));
    if ( iMessages->Count() )
        {
        //  Just cancel the first
        CancelOne( 0, aReason );
    
        //  Then pop out all the others
        for ( TInt i( 1 ); i < iMessages->Count(); i++ )
            {
            CancelOne( i, aReason );
            iMessages->Delete( i );
            i--;
            }
        }
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::CancelCardOperations
// Effectively the same as the above, except that does not cancel 
// OpenReader commands...
// -----------------------------------------------------------------------------
//
void CScardMessageStack::CancelCardOperations()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::CancelCardOperations|Begin"));
    if ( iMessages->Count() )
        {
        //  Just cancel the first
        if ( iMessages->At( 0 ).iAdditionalParameter != KOpenReader )
            {
            CancelOne( 0, KScReaderErrNoCard );
            }
    
        //  Then pop out all the others
        for ( TInt i( 1 ); i < iMessages->Count(); i++ )
            {
            if ( iMessages->At( i ).iAdditionalParameter != KOpenReader )
                {
                CancelOne( i, KScReaderErrNoCard );
                iMessages->Delete( i );
                i--;
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::CancelByTimeOut
// Cancel message by timeout
// -----------------------------------------------------------------------------
//
void CScardMessageStack::CancelByTimeOut( const CScardCommandTimer* aTimer )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::CancelByTimeOut|Begin"));
#ifdef _DEBUG
    RFileLogger::WriteFormat( KScardLogDir, KScardLogFileName, 
        EFileLoggingModeAppend, _L( "CScardMessageStack::CancelByTimeOut\n" ) );
#endif

    if ( iMessages->Count() )
        {
        //  First check if the message currently serviced is the cancelled one
        //  (it requires special treatment)
        if ( (*iMessages)[0].iTimer == aTimer )
            {
            CancelOne( 0, KScErrTimeOut, EFalse );
            return;
            }

        //  Then check out all the others
        for ( TInt i( 1 ); i < iMessages->Count(); i++ )
            {
            if ( (*iMessages)[i].iTimer == aTimer )
                {
                CancelOne( i, KScErrTimeOut, EFalse );
                iMessages->Delete( i );
                return;
                } // if
            } // for
        } // if
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::PushToTop
// Push message to top
// -----------------------------------------------------------------------------
//
TInt CScardMessageStack::PushToTop( const TMessageHandle& aMessage )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::PushToTop|Begin"));
    TRAPD( err, iMessages->InsertL( 0, aMessage ) );
    _WIMTRACE2(_L("WIM|Scard|CScardMessageStack::PushToTop|End|err=%d"), err);
    return err;
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::FromTop
// Message from top
// -----------------------------------------------------------------------------
//
const TMessageHandle CScardMessageStack::FromTop()
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::FromTop|Begin"));
    if ( !iMessages->Count() )
        {
        //  returns the default, which is interpreted as an error
        TMessageHandle a;
        return a;
        }
    TMessageHandle tmp = (*iMessages)[0];
    iMessages->Delete( 0 );
    return tmp;
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::PushToBottom
// Push message to bottom
// -----------------------------------------------------------------------------
//
TInt CScardMessageStack::PushToBottom( const TMessageHandle& aMessage )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::PushToBottom|Begin"));
    TRAPD( err, iMessages->AppendL( aMessage ) );
    return err;
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::NextReservation
// This function is called when a channel is freed. It gives priority
// for applications who are waiting to reserve either this channel or
// any channel
// -----------------------------------------------------------------------------
//
const TMessageHandle CScardMessageStack::NextReservation( const TInt8 aChannel )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::NextReservation|Begin"));
    TMessageHandle tmp;
    for ( TInt i( 0 ); i < iMessages->Count(); i++ )
        {
        tmp = (*iMessages)[i];
        if ( ( tmp.iAdditionalParameter & KReservation ) && 
           ( tmp.iChannel == aChannel || tmp.iChannel == KAllChannels ) )
            {
            iMessages->Delete( i );
            return tmp;
            }
        }
    tmp.iSessionID = ENoSession;
    return tmp;
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::FromPositionL
// Get message from given position
// -----------------------------------------------------------------------------
//
const TMessageHandle CScardMessageStack::FromPositionL( const TInt aPosition )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::FromPositionL|Begin"));
    __ASSERT_ALWAYS( aPosition >= 0 && aPosition < iMessages->Count(), 
        User::Leave( KScErrBadArgument ) );
    TMessageHandle r = iMessages->At( aPosition );
    iMessages->Delete( aPosition );
    return r;
    }

// -----------------------------------------------------------------------------
// CScardMessageStack::PushToPositionL
// Push message to given position
// -----------------------------------------------------------------------------
//
void CScardMessageStack::PushToPositionL(
    const TInt aPosition, 
    TMessageHandle& aHandle )
    {
    _WIMTRACE(_L("WIM|Scard|CScardMessageStack::PushToPositionL|Begin"));
    __ASSERT_ALWAYS( aPosition >= 0 && aPosition <= iMessages->Count(), 
        User::Leave( KScErrBadArgument ) );
    iMessages->InsertL( aPosition, aHandle );
    }

//  End of File