/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 "sattimer.h"           // sat timer class

#include "satmessaging.h"       // sat messaging class

#include "satmesshandler.h"     // sat message handler class

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

// CONSTANTS

const TInt KTimersEqual                 = 0;

const TInt KFirstBigger                 = 1;

const TInt KFirstSmaller                = -1;

const TInt KTick                        = 500000; // 500 milliseconds

const TInt KMaxNumberOfStoredEnvelopes  = 10;

const TInt KHiByteMask                  = 0xF0;

const TInt KTimerIdPosition             = 8;

const TInt KDefaultDelay                = 1; // Envelope resending delay

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

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

// CSatTimer::CSatTimer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSatTimer::CSatTimer

        (

        CSatMessHandler* aSatMessHandler,

        CTsySatMessaging* aSatMessaging

        )

        :

        iSatMessHandler( aSatMessHandler ),

        iSatMessaging( aSatMessaging ),

        iSecondsPassed( 0 ),

        iHalfSecondTick( EFalse ),

        iProactiveCommandOnGoing( EFalse ),

        iTimer( NULL ),

        iTimerTable( NULL ),

        iEnvelopeTable( NULL )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_CSATTIMER, "CSatTimer::CSatTimer" );

    }

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

// CSatTimer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSatTimer::ConstructL()

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_CONSTRUCTL, "CSatTimer::ConstructL" );

    TFLOGSTRING("TSY: CSatTimer::ConstructL");

    iTimerTable = new ( ELeave ) RArray<TTimer>( 8 );

    iEnvelopeTable = new ( ELeave ) RArray<TSatEnvelope>( 1 );

     // Neutral priority, 0

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    }

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

// CSatTimer::NewL

// Two-phased constructor.

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

//

CSatTimer* CSatTimer::NewL

        (

        CSatMessHandler*    aSatMessHandler,

        CTsySatMessaging*   aSatMessaging

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_NEWL, "CSatTimer::NewL" );

    TFLOGSTRING("TSY: CSatTimer::NewL");

    CSatTimer* self = new( ELeave ) CSatTimer( aSatMessHandler, aSatMessaging );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSatTimer::~CSatTimer

// Destructor

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

//

CSatTimer::~CSatTimer()

    {

    OstTrace0( TRACE_DETAILED, DUP1_CSATTIMER_CSATTIMER, "CSatTimer::~CSatTimer" );

    TFLOGSTRING("TSY: CSatTimer::~CSatTimer");

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    if ( iTimerTable )

        {

        iTimerTable->Close();

        delete iTimerTable;

        }

    if ( iEnvelopeTable )

        {

        iEnvelopeTable->Close();

        delete iEnvelopeTable;

        }

    }

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

// CSatTimer::StartTimer

// Starts a timer

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

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

//

void CSatTimer::Start()

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_START, "CSatTimer::Start" );

    //Check if timer is active just in case

    if ( !iTimer->IsActive() )

        {

        TFLOGSTRING("TSY: CSatTimer::Start: Timer started");

        OstTrace0( TRACE_DETAILED, DUP1_CSATTIMER_START, "CSatTimer::Start: Timer started" );

        //Timer will tick every half second

        TCallBack callback( Tick, this );

        iTimer->Start( KTick, KTick, callback );

        }

    }

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

// CSatTimer::StartTimer

// Starts a timer with specified id

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

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

//

TInt CSatTimer::StartTimer

        (

        TInt aTimerId,

        TUint32 aTimerValue

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_STARTTIMER, "CSatTimer::StartTimer" );

    TFLOGSTRING("TSY: CSatTimer::StartTimer");

    TInt ret( KErrNone );

    // Check if the entry is already in the table and delete if found.

    if ( CheckTimerTable( aTimerId ) )

        {

        DeleteTimerById( aTimerId );

        }

    // Calculate the trigger time (actual beat amount + timeout)

    TUint32 timeStamp = iSecondsPassed + aTimerValue;

    // Create timer

    TTimer timer( aTimerId, iSecondsPassed, timeStamp );

    // Insert the entry in the table and start timer

    ret = iTimerTable->InsertInOrder( timer, TTimer::OrderEntries );

    // Start timer

    if ( KErrNone == ret )

        {

        Start();

        }

    return ret;

    }

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

// CSatTimer::RestartTimer

// Restarts the inactive timer with specified id

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

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

//

TInt CSatTimer::RestartTimer

        (

        TInt aTimerId

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_RESTARTTIMER, "CSatTimer::RestartTimer" );

    TFLOGSTRING("TSY: CSatTimer::RestartTimer");

    TInt ret( KErrNone );

    // Find timer from TimerTable

    TTimer helper( aTimerId, 0, 0 );

    TInt index = iTimerTable->Find( helper, TTimer::CompareEntries );

    if ( KErrNotFound != index )

        {

        // Reactivate timer if proactive command is not ongoing, otherwise

        // set state to witing for terminal response

        if ( iProactiveCommandOnGoing )

            {

            ( *iTimerTable )[index].SetState( TTimer::EWaitingForTr );

            }

        else

            {

            ( *iTimerTable )[index].SetState( TTimer::ETicking );

            }

        // Start clock

        Start();

         }

    else

        {

        TFLOGSTRING2("TSY: CSatTimer::ReStart - Requested ID (%d) not found!",

            aTimerId);

        OstTrace1( TRACE_DETAILED, DUP1_CSATTIMER_RESTARTTIMER, "CSatTimer::RestartTimer - Requested ID (%d) not found!", aTimerId );

        ret = KErrNotFound;

        }

    return ret;

    }

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

// CSatTimer::Stop

// Stops the timer counting

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

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

//

void CSatTimer::Stop()

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_STOP, "CSatTimer::Stop" );

    // If both timer and envelope arrays are empty, stop the timer.

    // Also if timer table is empty, clear the second counter.

    if ( iTimer->IsActive () )

        {

        if ( !iEnvelopeTable->Count()

          && !iTimerTable->Count() )

            {

            TFLOGSTRING("TSY: CSatTimer::Stop: Timer stopped");

            OstTrace0( TRACE_DETAILED, DUP1_CSATTIMER_STOP, "CSatTimer::Stop: Timer stopped" );

            iTimer->Cancel();

            }

        if ( !iTimerTable->Count() )

            {

            TFLOGSTRING("TSY: CSatTimer::Stop: Second counters cleared");

            OstTrace0( TRACE_DETAILED, DUP2_CSATTIMER_STOP, "CSatTimer::Stop: Second counters cleared" );

            iSecondsPassed = 0;

            iHalfSecondTick = EFalse;

            }

        }

    }

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

// CSatTimer::Tick

// Static callback method for CPeriodic timer.

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

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

//

TInt CSatTimer::Tick

        (

        TAny* aSatTimer

        )

    {

    // Logging omitted to avoid excessive log output

    // This is a static method, we need a pointer to parent class in

    // order to utilize it's method and members

    CSatTimer* satTimer = static_cast<CSatTimer*>( aSatTimer );

    // Invert boolean value of half second boolean

    satTimer->iHalfSecondTick = !satTimer->iHalfSecondTick;

    // Update second counter and check timers only when there are active

    // timers and whole second has passed since last update.

    TInt tableSize( satTimer->iTimerTable->Count() );

    if ( KZero != tableSize && !satTimer->iHalfSecondTick )

        {

        satTimer->iSecondsPassed++;

        TFLOGSTRING2("TSY: CSatTimer::Tick, seconds %d",

            satTimer->iSecondsPassed );

        OstTrace1( TRACE_DETAILED, CSATTIMER_TICK, "CSatTimer::Tick, seconds %u", satTimer->iSecondsPassed );

        for( TInt i = tableSize - 1; KZero <= i; i-- )

            {

            // Get reference to a timer in TimerTable

            TTimer& timer = ( *satTimer->iTimerTable )[i];

            // Send timer expiration envelope if:

            // 1) Enough time has passed

            // 2) Timer is active

            // 3) Proactive command is not ongoing

            if ( timer.TimeStamp() <= satTimer->iSecondsPassed

                 && TTimer::ETicking == timer.State() )

                {

                // Deactive timer to avoid multiple envelopes

                timer.SetState( TTimer::EBeingSent);

                // Elapsed time

                TInt time( satTimer->iSecondsPassed - timer.StartTime() );

                satTimer->iSatMessaging->TimerExpiration( timer.Id(), time );

                }

            }

        }

    // Handle the stored envelopes. Look for envelopes activated for resending.

    // Resend the oldest envelope if delay criteria has been met.

    tableSize = satTimer->iEnvelopeTable->Count();

    TBool done( EFalse );

    if ( KZero != tableSize )

        {

        for ( TInt i = 0 ; i < tableSize && done == EFalse ; i++ )

            {

            TSatEnvelope& current = ( *satTimer->iEnvelopeTable )[i];

            if ( current.iActive )

                {

                // Active envelope found. Decrease delay and send envelope

                // if zero.

                current.iDelay--;

                if ( KZero >= current.iDelay )

                    {

                    TFLOGSTRING2("TSY: CSatTimer::Tick: \

                        Resending type %x envelope", current.iType );

                    OstTraceExt1( TRACE_DETAILED, DUP1_CSATTIMER_TICK, "CSatTimer::Tick Resending type %hhu envelope", current.iType );

                    // Deactivate envelope just in case. Get new transaction

                    // if for envelope and resend it. Finally remove the

                    // envelope from table.

                    current.iActive = EFalse;

                    satTimer->iSatMessHandler->UiccCatReqEnvelope(

                        current.iTId, current.iEnvelope, EFalse );

                    satTimer->RemoveEnvelope( current.iTId );

                    tableSize = satTimer->iEnvelopeTable->Count();

                    // Exit resending loop, only one resent envelope per tick

                    done = ETrue;

                    }

                } // If active

            } // For-loop

        } // Table size not zero

    return KErrNone;

    }

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

// CSatTimer::CheckTimerTable

// Returns true if the timer exists in the timer table.

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

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

//

TBool CSatTimer::CheckTimerTable

        (

        TInt aTimerId

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_CHECKTIMERTABLE, "CSatTimer::CheckTimerTable" );

    TFLOGSTRING("TSY: CSatTimer::CheckTimerTable");

    TBool ret( EFalse );

    // Create the helper entry with meaningful values only

    TTimer timer( aTimerId, 0, 0 );

    // Find the entry for this Handle in the list

    TInt position = iTimerTable->Find( timer, TTimer::CompareEntries );

    if ( KErrNotFound != position )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CSatTimer::DeleteTimerById

// Deletes timer from the table

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

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

//

TInt CSatTimer::DeleteTimerById

        (

        TInt aTimerId // Timer identifier

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_DELETETIMERBYID, "CSatTimer::DeleteTimerById" );

    TFLOGSTRING("TSY: CSatTimer::DeleteTimerById");

    TInt ret( KErrNotFound );

    // Create the entry with meaningful values only

    TTimer timer( aTimerId, 0, 0 );

    // Find the entry for this Handle in the list

    TInt position = iTimerTable->Find (timer, TTimer::CompareEntries );

    // Check if element is found

    if ( KErrNotFound != position )

        {

        iTimerTable->Remove( position );

        iTimerTable->Compress();

        // Check if empty

        if ( KZero == iTimerTable->Count())

            {

            // Request stopping of timer

            Stop();

            }

        ret = KErrNone;

        }

    return ret;

    }

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

// CSatTimer::GetCurrentValueOfTimerById

// Gets current value of timer by timer id

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

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

//

TUint32 CSatTimer::GetCurrentValueOfTimerById

        (

        TInt aTimerId // Timer identifier

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_GETCURRENTVALUEOFTIMERBYID, "CSatTimer::GetCurrentValueOfTimerById" );

    TFLOGSTRING("TSY: CSatTimer::GetCurrentValueOfTimerById");

    TInt ret( KErrNotFound );

    // Create the entry with meaningful values only

    TTimer timer( aTimerId, 0, 0 );

    // Find the entry for this Handle in the list

    TInt position = iTimerTable->Find( timer, TTimer::CompareEntries );

    // Check if element is found

    if ( KErrNotFound != position )

        {

        // Get the reference to the a timer in timer table

        TTimer& timer = ( *iTimerTable )[ position ];

        // Get timeStamp

        TUint32 timeStamp = timer.TimeStamp();

        // Current timer value = timer timeout value - current time

        ret = timeStamp - iSecondsPassed;

        // If current timer value is smaller than zero set value to 0

        // this can happen if there is some kind of delay before

        // timer is expired and iSecondsPassed is still counting...

        if( KZero > ret )

            {

            ret = 0;

            }

        }

    return ret;

    }

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

// CSatTimer::StoreEnvelope

// Stores envelope for possible resending

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

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

//

TInt CSatTimer::StoreEnvelope

        (

        const TUint8 aTId,

        const TDesC8& aEnvelope

        )

    {

    OstTrace0( TRACE_DETAILED, CSATTIMER_STOREENVELOPE, "CSatTimer::StoreEnvelope" );

    TFLOGSTRING("TSY: CSatTimer::StoreEnvelope");

    TInt ret( KErrNone );

    // Add envelope to array only if it is not already there,

    // envelope has proper length a envelope data begins with

    // envelope tag (D1..D8)

    if ( KErrNotFound == LocateEnvelope( aTId )

      && KZero < aEnvelope.Length() )

        {

        if ( ( aEnvelope[KZero] & KHiByteMask ) == ETypeUnknown )

            {

            // Backup system. Oldest envelope is deleted if too

            // many envelopes exist in the queue

            if ( KMaxNumberOfStoredEnvelopes < iEnvelopeTable->Count() )

                {

                iEnvelopeTable->Remove( 0 );

                iEnvelopeTable->Compress();

                }

            TSatEnvelope envelope;

            envelope.iTId = aTId;

            envelope.iDelay = KDefaultDelay;

            envelope.iType = aEnvelope[KZero]; // Type is at index 0

            envelope.iActive = EFalse;

            envelope.iEnvelope.Copy( aEnvelope );

            iEnvelopeTable->Append( envelope );

            TFLOGSTRING2("CSatTimer::StoreEnvelope \

                Stored envelopes: % d", iEnvelopeTable->Count() );

            OstTrace1( TRACE_DETAILED, DUP1_CSATTIMER_STOREENVELOPE, "CSatTimer::StoreEnvelope Stored envelopes: %d", iEnvelopeTable->Count() );