diff -r 000000000000 -r 63b37f68c1ce adaptationlayer/tsy/simatktsy_dll/src/sattimer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/adaptationlayer/tsy/simatktsy_dll/src/sattimer.cpp	Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,909 @@
+/*
+* 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
+#include "osttracedefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "sattimertraces.h"
+#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() );
+
+            }
+        else
+            {
+            TFLOGSTRING2("CSatTimer::StoreEnvelope \
+                Storing failed, not an envelope! %x", aEnvelope[KZero] );
+            OstTraceExt1( TRACE_DETAILED, DUP2_CSATTIMER_STOREENVELOPE, "CSatTimer::StoreEnvelope Storing failed, not an envelope! %s", aEnvelope[KZero] );
+            ret = KErrArgument;
+            }
+
+        }
+    else
+        {
+        TFLOGSTRING2(" CSatTimer::StoreEnvelope \
+            Envelope with requested ID %d already exist!", aTId );
+        OstTraceExt1( TRACE_DETAILED, DUP3_CSATTIMER_STOREENVELOPE, "CSatTimer::StoreEnvelope Envelope with requested ID %hhd already exists!", aTId );
+        ret = KErrAlreadyExists;
+        }
+
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::ActivateEnvelopeResend
+// Activates the resending procedure of stored envelope
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatTimer::ActivateEnvelopeResend
+        (
+        const TUint8 aTId,
+        const TUint8 aCause
+        )
+    {
+    OstTrace0( TRACE_DETAILED, CSATTIMER_ACTIVATEENVELOPERESEND, "CSatTimer::ActivateEnvelopeResend" );
+    TFLOGSTRING("TSY: CSatTimer::ActivateEnvelopeResend");
+
+    TInt ret( LocateEnvelope( aTId ) );
+
+    if ( KErrNotFound != ret )
+        {
+        TSatEnvelope& current = ( *iEnvelopeTable )[ret];
+
+        switch ( aCause )
+            {
+            case ESimBusy:
+                {
+                if ( ETimerExpiration == current.iType
+                  && KTimerIdPosition < current.iEnvelope.Length() )
+                    {
+                    // Resending of Timer envelope is different from others,
+                    // because timer value has to be updated within the resent
+                    // envelope. As a result, we can't just resend old message.
+
+                    // Restart timer using ID.
+                    RestartTimer( current.iEnvelope[KTimerIdPosition] );
+
+                    // Old stored envelope has to be removed from envelope,
+                    // but not from timer table in case of timer reactivation.
+                    RemoveEnvelope( aTId, EFalse );
+                    }
+                else
+                    {
+                    // For other envelope, just activate it
+                    current.iActive = ETrue;
+                    }
+
+                ret = KErrNone;
+                break;
+                }
+            case ERefManagement:
+                {
+                // Resending of envelope when SIM return Reference Management
+                // error, and active envelope is Call Control, is based on
+                // error item( No call after autolock). Because need for send 
+                // is unclear (in other Nokia devices does it),
+                // only CC envelope are resent.
+                if ( ECallControl == current.iType )
+                    {
+                    current.iActive = ETrue;
+                    ret = KErrNone;
+                    }
+                else
+                    {
+                    ret = KErrNotSupported;
+                    }
+                break;
+                }
+            default:
+                {
+                // Unexpected cause
+                ret = KErrNotSupported;
+                }
+            }
+
+        if ( KErrNone == ret )
+            {
+            TFLOGSTRING("TSY: CSatTimer::ActivateEnvelopeResend \
+                Resending activated");
+            OstTrace0( TRACE_DETAILED, DUP1_CSATTIMER_ACTIVATEENVELOPERESEND, "CSatTimer::ActivateEnvelopeResend Resending activated" );
+            // (Re)start the timer if needed
+            Start();
+            }
+        else
+            {
+            TFLOGSTRING2("TSY: CSatTimer::ActivateEnvelopeResend \
+                Resending NOT activated. Cause: %x", aCause );
+            OstTraceExt1( TRACE_DETAILED, DUP2_CSATTIMER_ACTIVATEENVELOPERESEND, "CSatTimer::ActivateEnvelopeResend Resending NOT activated. Cause: %hhu", aCause );
+            RemoveEnvelope( aTId );
+            }
+        }
+
+    return ret;
+    }
+
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::RemoveEnvelope
+// Removes the envelope from the table by given id
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatTimer::RemoveEnvelope
+        (
+        const TUint8 aTId,
+        TBool aRemoveTimer
+        )
+    {
+    OstTrace0( TRACE_DETAILED, CSATTIMER_REMOVEENVELOPE, "CSatTimer::RemoveEnvelope" );
+    TFLOGSTRING("TSY: CSatTimer::RemoveEnvelope");
+
+    TInt ret( LocateEnvelope( aTId ) );
+
+    if ( KErrNotFound != ret )
+        {
+        TSatEnvelope& current = (*iEnvelopeTable)[ret];
+
+        // The timer corresponding the envelope must be removed from timer
+        // table if timer expiration envelope was sent successfully.
+        if ( ETimerExpiration == current.iType && aRemoveTimer )
+            {
+            DeleteTimerById( current.iEnvelope[KTimerIdPosition] );
+            }
+
+        iEnvelopeTable->Remove( ret );
+        iEnvelopeTable->Compress();
+
+        // Stop-method halts the timer only if there are no envelopes or
+        // timer expiration left
+        Stop();
+
+        ret = KErrNone;
+        }
+
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::LocateEnvelope
+// Locates the position of envelope in table by given id
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatTimer::LocateEnvelope
+        (
+        const TUint8 aTId
+        )
+    {
+    OstTrace0( TRACE_DETAILED, CSATTIMER_LOCATEENVELOPE, "CSatTimer::LocateEnvelope" );
+    TFLOGSTRING("TSY: CSatTimer::LocateEnvelope");
+
+    TInt ret( KErrNotFound );
+    TInt numEnvelopes( iEnvelopeTable->Count() );
+
+    for ( TInt i = 0 ; i < numEnvelopes && ret == KErrNotFound ; i++ )
+        {
+        if ( ( *iEnvelopeTable )[i].iTId == aTId )
+            {
+            TFLOGSTRING2("TSY: CSatTimer::LocateEnvelope \
+                Requested envelope was found at index %d", i );
+            OstTrace1( TRACE_DETAILED, DUP1_CSATTIMER_LOCATEENVELOPE, "CSatTimer::LocateEnvelope Requested envelope was found at index %d", i );
+            ret = i;
+            }
+        }
+
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::SetProactiveCommandOnGoingStatus
+// Sets status for ProactiveCommandOnGoing flag
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatTimer::SetProactiveCommandOnGoingStatus
+        (
+        TBool aStatus
+        )
+    {
+    OstTrace0( TRACE_DETAILED, CSATTIMER_SETPROACTIVECOMMANDONGOINGSTATUS, "CSatTimer::SetProactiveCommandOnGoingStatus" );
+    iProactiveCommandOnGoing = aStatus;
+
+    TInt tableSize( iTimerTable->Count() );
+
+    if ( !iProactiveCommandOnGoing && tableSize )
+        {
+        // Some of the timers has been deactivated because of ongoing pcmd
+        for ( TInt i( 0 ) ; i < tableSize ; i++ )
+            {
+            // Get reference to a timer in TimerTable
+            TTimer& timer = ( *iTimerTable )[i];
+
+            if ( TTimer::EWaitingForTr == timer.State() )
+                {
+                timer.SetState( TTimer::ETicking );
+                Start(); // Just in case
+                }
+            }
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::ClearTimerTable
+// Clears the timer table
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatTimer::ClearTimerTable()
+    {
+    OstTrace0( TRACE_DETAILED, CSATTIMER_CLEARTIMERTABLE, "CSatTimer::ClearTimerTable" );
+
+    if ( KZero != iTimerTable->Count() )
+        {
+        // Clear the array
+        iTimerTable->Reset();
+        iTimerTable->Compress();
+
+        // Request timer stop till new entry is done
+        Stop();
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::TTimer
+// Non default Constructor, for nested class
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CSatTimer::TTimer::TTimer
+        (
+        TInt aTimerId,       // Timer id
+        TUint32 aStartTime,  // Timer start time
+        TUint32 aTimeStamp   // Time stamp
+        )
+        :
+        iTimerId( aTimerId ),
+        iStartTime( aStartTime ),
+        iTimeStamp( aTimeStamp ),
+        iState( ETicking )
+    {
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::TimeStamp
+// returns iTimeStamp from a TTimer
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint32 CSatTimer::TTimer::TimeStamp()
+    {
+    return iTimeStamp;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::Id
+// returns iTimerId from a TTimer
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatTimer::TTimer::Id()
+    {
+    return iTimerId;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::StartTime
+// returns iStartTime from a TTimer
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint32 CSatTimer::TTimer::StartTime()
+    {
+    return iStartTime;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::SetState
+// Setter for timer's internal state.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatTimer::TTimer::SetState
+        (
+        TState aState
+        )
+    {
+    iState = aState;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::IsActive
+// Getter for timer's internal state.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CSatTimer::TTimer::TState CSatTimer::TTimer::State()
+    {
+    return iState;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::CompareEntries
+// Returns if two entries are equal
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CSatTimer::TTimer::CompareEntries
+        (
+        const CSatTimer::TTimer& arg1, // First entry
+        const CSatTimer::TTimer& arg2  // Second entry
+        )
+    {
+    TBool ret( EFalse );
+
+    // We are interested only in the timer id
+    if ( arg1.iTimerId == arg2.iTimerId )
+        {
+        ret =  ETrue;
+        }
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatTimer::TTimer::OrderEntries
+// Returns order between two entries
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatTimer::TTimer::OrderEntries
+        (
+        const CSatTimer::TTimer& arg1, // First entry
+        const CSatTimer::TTimer& arg2  // Second entry
+        )
+    {
+    TInt ret( KTimersEqual );
+
+    // We are interested only in the timer id
+    if ( arg1.iTimerId < arg2.iTimerId )
+        {
+        ret = KFirstSmaller;
+        }
+    else if( arg1.iTimerId > arg2.iTimerId )
+        {
+        ret = KFirstBigger;
+        }
+    else
+        {
+        // Timer Id's are equal. Return value already properly initialized.
+        }
+    return ret;
+
+  }
+
+// End of file