phoneapp/phoneuiutils/src/ctelerecoverysystem.cpp
changeset 0 5f000ab63145
child 24 41a7f70b3818
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneapp/phoneuiutils/src/ctelerecoverysystem.cpp	Mon Jan 18 20:18:27 2010 +0200
@@ -0,0 +1,1063 @@
+/*
+* Copyright (c) 2007 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:  Recovery system class.
+*
+*/
+
+
+// INCLUDE FILES
+#include    "ctelerecoverysystem.h"
+#include    <e32svr.h>
+#include    <startupdomainpskeys.h>
+
+#include    "phonelogger.h"
+#include  	"phoneui.pan"
+#include    "cphonetimer.h"
+#include    "ctelewaitingidle.h"
+
+
+// CONSTANTS
+const TInt KPhoneRecoveryItemsArrayGranularity = 8;
+const TInt KPhoneRecoveryTickInterval = 50000; // 0.05 second
+const TInt KPhoneRecoveryTicksForCritical = 2;
+const TInt KPhoneRecoveryTicksForHigh = 3; 
+const TInt KPhoneRecoveryTicksForStandard = 5;
+const TInt KPhoneRecoveryTicksForLow = 23;
+const TInt KPhoneRecoveryTicksForDontCare = 37;
+const TInt KPhoneRecoveryTicksMaximum = 2048; //maximum about 1.5 minutes
+const TInt KPhoneRecoveryDontStartTimer = 10000;
+const TInt KPhoneRecoveryCounterStart = 0;
+const TInt KPhoneRecoveryCounterPause = -1;
+const TInt KPhoneRecoveryMainTimerPriority = CActive::EPriorityLow;
+const TInt KPhoneRecoveryAllStepsTimerPriority = CActive::EPriorityLow + 1;
+
+// Priority of active object; set it quite high.
+const TInt KTelePubSubPriority = CActive::EPriorityUserInput;
+
+// Flags for all priorities.
+enum 
+    {
+    EPhoneFlagCritical = 1,
+    EPhoneFlagHigh     = 2,
+    EPhoneFlagStandard = 4,
+    EPhoneFlagLow      = 8,
+    EPhoneFlagDontCare = 16
+    };
+    
+// ============================ MEMBER FUNCTIONS ===============================
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::CTeleRecoverySystem
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CTeleRecoverySystem::CTeleRecoverySystem() 
+    : CActive( KTelePubSubPriority )
+    {
+    CActiveScheduler::Add( this );
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::ConstructL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::ConstructL ()" ); 
+    iRequest = EPhoneNone;
+    
+    // Construct Recovery items array.
+    iRecoveryItems = new ( ELeave ) CArrayFixFlat< TRecoveryItem >( 
+        KPhoneRecoveryItemsArrayGranularity );
+
+    // Construct CPhoneTimer.
+    iTimer = CPhoneTimer::NewL( KPhoneRecoveryMainTimerPriority );    
+
+    // Construct timer for recovery all steps.
+    iAllStepsTimer = CPhoneTimer::NewL( KPhoneRecoveryAllStepsTimerPriority );
+    
+    iWaitingIdle = CTeleWaitingIdle::NewL( CActive::EPriorityLow, *this );
+    iWaitingIdle->StartWaitingIdleL();
+    
+    __PHONELOG( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::ConstructL: timers" );
+
+    User::LeaveIfError( 
+        iSimStatusProperty.Attach( 
+            KPSUidStartup, 
+            KPSSimStatus ) );
+
+    __PHONELOG( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::ConstructL: attach2" );
+
+    // Check current SIM status.
+    User::LeaveIfError( CheckSIMAvailable() );
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CTeleRecoverySystem* CTeleRecoverySystem::NewL()
+    {
+    CTeleRecoverySystem* self = new( ELeave ) CTeleRecoverySystem;
+    
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop();
+
+    return self;
+    }
+    
+// Destructor
+CTeleRecoverySystem::~CTeleRecoverySystem()
+    {
+    // Stop listening for SIM changes.
+    Cancel();    
+
+    iSimStatusProperty.Close();
+    iSimPresentProperty.Close();
+
+    if ( iWaitingIdle )
+        {
+        delete iWaitingIdle;
+        iWaitingIdle = NULL;  
+        }
+		
+    delete iRecoveryItems;
+    delete iTimer;
+    delete iAllStepsTimer;
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::AddL
+// -----------------------------------------------------------------------------
+//
+TPhoneRecoveryId CTeleRecoverySystem::AddL( TCallBack aCallBack, 
+    TPhoneRecoveryPriority aPriority, TRecoveryState aState )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::AddL()" ); 
+	__ASSERT_DEBUG( !iIsCallBack, Panic( EPhoneUtilsNoCallBack ) );   
+
+    CheckStateForPrecondition( aState );
+
+    iIdCounter++;
+    TInt count = iRecoveryItems->Count();
+    TInt i = 0;
+    for ( ; i < count; i++ )
+        {
+        if ( iRecoveryItems->At( i ).iPriority <= aPriority )
+            {
+            break;
+            }
+        }
+    TRecoveryItem item;
+    item.iCallBack = aCallBack;
+    item.iId = iIdCounter;
+    item.iPriority = aPriority;
+    item.iState = aState;
+    
+    __PHONELOG1( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::AddL itemIdx= %d:", i );
+
+    iRecoveryItems->InsertL( i, item );
+
+    StartTimerIfRequired( aState );
+    return iIdCounter;
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::Add
+// -----------------------------------------------------------------------------
+//
+TPhoneRecoveryId CTeleRecoverySystem::Add( TCallBack aCallBack, 
+    TPhoneRecoveryPriority aPriority, TRecoveryState aState )
+    {
+	__LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::AddL()" ); 
+    TPhoneRecoveryId id = KNullId;
+    TRAP_IGNORE( id = AddL( aCallBack, aPriority, aState ) );
+    return id;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::Remove
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::Remove( TPhoneRecoveryId aId )
+    {
+	__LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::Remove()" ); 
+	__ASSERT_DEBUG( !iIsCallBack, Panic( EPhoneUtilsNoCallBack ) ); 
+
+    TInt count = iRecoveryItems->Count();
+    
+    __PHONELOG1( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::count = %d:", count );
+        
+    for ( TInt i = 0; i < count; i++ )
+        {
+        if( iRecoveryItems->At( i ).iId == aId )
+            {
+            iRecoveryItems->Delete( i );
+		    __PHONELOG1( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::Delete itemIdx= %d:", i );
+            return;
+            }
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::SetState
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::SetState( 
+    TPhoneRecoveryId aId, TRecoveryState aState )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::SetState()" );
+    CheckStateForPrecondition( aState );
+    
+    TInt count = iRecoveryItems->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( i );
+        if( item.iId == aId )
+            {
+            item.iState = aState;
+            StartTimerIfRequired( aState ); 
+		    __PHONELOG1( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::SetState itemIdx= %d:", item.iId );      
+            return;
+            }
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::ResetPending
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::ResetPending()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::ResetPending()" );
+    TBool startTimer = EFalse;
+    TInt count = iRecoveryItems->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( i );
+        if( item.iState == EPhoneStatePending )
+            {
+            item.iState = EPhoneStateWaiting;
+            startTimer = ETrue;
+            }
+        }
+
+    if ( startTimer )
+        {
+        StartTimer();
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::RecoverNow
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::RecoverNow( TPhoneRecoveryId aId,
+    TPhoneRecoveryPriority aPriority, TBool aAllSteps )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::RecoverNow()" );
+    TInt err = KErrNone;
+    TInt pos = Find( aId );
+
+    if ( pos != KErrNotFound )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( pos );
+        item.iPriority = aPriority;
+        err = DoItemCallBack( item );
+        if ( item.iState == EPhoneStateWaiting )
+            {
+            if ( aAllSteps )
+                {
+                item.iState = EPhoneStateStarting;
+                }
+                
+            StartTimerIfRequired( item.iState );
+            }
+        }
+    __PHONELOG1( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::RecoverNow error = %d:", err );   
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::RecoverAllNow
+//
+// -----------------------------------------------------------------------------
+//   
+void CTeleRecoverySystem::RecoverAllNow()
+	{
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::RecoverAllNow()" );
+    StartTimerIfIdle();
+    StartAllStepsTimer();
+	}
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::EnablePrecondition
+//
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::EnablePrecondition()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::EnablePrecondition()" );
+    // If precondition has already been satisfied, then
+    // there should not be anything left to do.
+    if ( iPrecondOk )
+        {
+        return;
+        }
+
+    // Store flag to indicate that precondition has been
+    // satisfied.
+    iPrecondOk = ETrue;
+
+    // Go through all recovery items and update state so that
+    // there won't be any items in EPhoneStatePrecond after the loop.
+    // Timer must be started.
+    TInt count = iRecoveryItems->Count();
+
+    for ( TInt index = 0; index < count; index++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( index );
+
+        CheckStateForPrecondition( item.iState );
+        }
+
+	if ( IsIdle() )
+	    {
+	    iTimer->Cancel();
+	    StartTimer();		
+	    }
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::Resume
+// 
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::Resume()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::Resume()" );
+    if ( iTickCounter == KPhoneRecoveryCounterPause )
+        {
+        StartTimer();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::RunL
+// 
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::RunL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::RunL()" );
+    if ( iStatus != KErrNone )
+        {
+        // If SIM is already available, just listen for SIM status.
+	    if ( iSimAvailable == ESimUsable )
+	        {            
+	        iRequest = EPhoneSIMStatus;
+	        }
+	    else
+	        {
+	        iRequest = EPhoneSIMPresent;
+	        }
+
+        __PHONELOG1( 
+	        EBasic, 
+	        EPhoneUIUtils, 
+	        "CTeleRecoverySystem::RunL NewRq = %d ", (TInt) iRequest ); 
+
+        IssueRequest();
+        return;
+        }
+        
+    // If SIM present availability is still scrutinized, check status.
+    if ( iRequest == EPhoneSIMPresent )
+        {
+        if ( iSimPresentProperty.Handle() )
+            {            
+            iSimPresentProperty.Get( iSimAvailable );
+            }            
+
+        if ( iSimAvailable == ESimUsable )
+            {
+            iRequest = EPhoneSIMStatus;
+            
+			__PHONELOG1( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::RunL NewRq = %d ", (TInt) iRequest ); 
+            }
+        else
+            {
+            // SIM is not yet available, start listening again.
+            IssueRequest();
+            return;
+            }
+        }
+
+    // If SIM is available and SIM status is ok and precondition has not been
+    // set, set precondition.
+    if ( IsSIMOk() && !iPrecondSimOk )
+        {
+        EnablePrecondSimOk();
+        }
+    
+    // Start listening again.
+    IssueRequest();
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::DoCancel
+// 
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::DoCancel()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::DoCancel()");
+
+    if ( iSimStatusProperty.Handle() )
+        {        
+        iSimStatusProperty.Cancel();
+        }
+
+    if ( iSimPresentProperty.Handle() )
+        {        
+        iSimPresentProperty.Cancel();
+        }                
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::EnablePrecondSimOk
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::EnablePrecondSimOk()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::EnablePreSIM()");
+    
+    if ( iPrecondSimOk )
+        {
+        return;
+        }
+    iPrecondSimOk = ETrue;
+
+    // Go through all recovery items and update state so that
+    // there won't be any items in EPhoneStatePrecondSim after the loop.
+    // Timer must be started.
+    TInt count = iRecoveryItems->Count();
+
+    for ( TInt index = 0; index < count; index++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( index );
+
+        CheckStateForPrecondition( item.iState );
+        }
+
+    iTimer->Cancel();
+    StartTimer();
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::DoItemCallBack
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::DoItemCallBack( TRecoveryItem& aItem )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::DoItemCallBack()");
+    
+#ifdef _DEBUG
+    iIsCallBack = ETrue;
+#endif // _DEBUG
+
+    TInt err = KErrNone;    
+    TRAPD( leaveErr, err = aItem.iCallBack.CallBack() );
+
+	__PHONELOG1( 
+        EBasic, 
+        EPhoneUIUtils, 
+        "CTeleRecoverySystem::DoItemCallBack Err = %d ", leaveErr );
+    
+#ifdef _DEBUG
+    iIsCallBack = EFalse;
+#endif // _DEBUG
+
+    if( leaveErr != KErrNone )
+        {
+        err = leaveErr;
+        }
+
+    if ( err > KErrNone )
+        {
+        aItem.iState = EPhoneStateWaiting;
+        err = KErrNone;
+        }
+    else
+        {
+        switch ( err )
+            {
+            case KErrNone:
+                aItem.iState = EPhoneStateIdle;
+                break;
+            case KErrNoMemory:
+            case KErrInUse:
+            case KErrServerBusy:
+            case KErrNotReady:
+            case KErrLocked:
+            case KErrTimedOut:
+            case KErrDied:
+            case KErrServerTerminated:
+                aItem.iState = EPhoneStateWaiting;
+                break;
+            default:
+                aItem.iState = EPhoneStatePending;
+                break;
+            }
+        }
+
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::HandleTimer
+//
+// Callback function.
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::HandleTimer( TAny* aAny )
+    {
+    return static_cast< CTeleRecoverySystem* >( aAny )->DoHandleTimer();
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::DoHandleTimer
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::DoHandleTimer()
+    {
+    // It will be sum of flags in which there are items in priority.
+    TInt found = 0;
+
+    // It contains flags which will be run at the current time.
+    const TInt run = DetermineRun();
+    
+    // Go through all items and for each item:
+    //  If item is in waiting state,
+    //      update variable found and
+    //      update priority and
+    //      perform action if required.
+
+    const TInt count = iRecoveryItems->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( i );
+        if( item.iState == EPhoneStateWaiting )
+            {
+            TBool doCallBack = EFalse;
+
+            if ( item.iPriority >= EPhonePriorityCritical )
+                {
+                found |= EPhoneFlagCritical;
+                doCallBack = ( run & EPhoneFlagCritical );
+                }
+            else if ( item.iPriority > EPhonePriorityHigh )
+                {
+                // For priority Critical.
+                item.iPriority--;
+                found |= EPhoneFlagHigh;
+                doCallBack = ( run & EPhoneFlagHigh );
+                }
+            else if ( item.iPriority > EPhonePriorityStandard )
+                {
+                // For priority High.
+                item.iPriority--;
+                found |= EPhoneFlagStandard;
+                doCallBack = ( run & EPhoneFlagHigh );
+                }
+            else if ( item.iPriority > EPhonePriorityLow )
+                {
+                // For priority Standard.
+                item.iPriority--;
+                found |= EPhoneFlagLow;
+                doCallBack = ( run & EPhoneFlagStandard );
+                }
+            else if ( item.iPriority > EPhonePriorityDontCare )
+                {
+                // For priority Low.
+                item.iPriority--;
+                found |= EPhoneFlagDontCare;
+                doCallBack = ( run & EPhoneFlagLow );
+                }
+            else 
+                {
+                // For priority DontCare.
+                found |= EPhoneFlagDontCare;
+                doCallBack = ( run & EPhoneFlagDontCare );
+                }
+
+            if ( doCallBack )
+                {
+                DoItemCallBack( item );
+                }
+            }
+        }
+
+    // Start timer for the next time.
+    StartNext( found );       
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::HandleAllStepsTimer
+//
+// Callback function.
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::HandleAllStepsTimer( TAny* aAny )
+    {
+    return 
+        static_cast< CTeleRecoverySystem* >( aAny )->DoHandleAllStepsTimer();
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::DoHandleAllStepsTimer
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::DoHandleAllStepsTimer()
+    {
+    TInt count = iRecoveryItems->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TRecoveryItem& item = iRecoveryItems->At( i );
+        if( item.iState == EPhoneStateStarting )
+            {
+            // Perform recovery step.
+            //
+            TInt err = DoItemCallBack( item );
+
+            if ( item.iState == EPhoneStateWaiting )
+                {
+                // If step went ok, then we can perform next step soon.
+                // If step didn't succeed, then there is no point to 
+                // start again immediately.
+                if ( err == KErrNone )
+                    {
+                    item.iState = EPhoneStateStarting;
+                    }
+                
+                // And start timer.
+                StartTimerIfRequired( item.iState );
+                }
+            }
+        }
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::CheckStateForPrecondition
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::CheckStateForPrecondition( TRecoveryState& aState )
+    {
+    if ( iPrecondOk && aState == EPhoneStatePrecond )
+        {
+        aState = EPhoneStateWaiting;
+        }
+
+    if ( iPrecondSimOk && aState == EPhoneStatePrecondSim )
+        {
+        aState = EPhoneStateWaiting;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::StartTimerIfRequired
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::StartTimerIfRequired( TRecoveryState aNewState )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::StartTimerIfRequired()");
+    
+    if ( IsIdle() )
+    	{
+	    if ( aNewState == EPhoneStateWaiting )
+	        {
+	        StartTimerIfIdle();
+	        }
+	    else if ( aNewState == EPhoneStateStarting )
+	        {
+	        StartAllStepsTimer();
+        	}    	
+  		}
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::IsIdle()
+// -----------------------------------------------------------------------------
+//    
+TBool CTeleRecoverySystem::IsIdle()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::IsIdle()");
+	TBool retVal(EFalse);
+	TInt error(0);
+  	TInt state(0);
+  	
+    error = iIdleActive.Get(
+        KPSUidStartup, 
+        KPSIdlePhase1Ok, 
+        state );
+    
+    if ( ( state == EIdlePhase1Ok ) &&
+        ( error == KErrNone ) )
+        {
+        if ( iWaitingIdle )
+            {
+            delete iWaitingIdle;
+            iWaitingIdle = NULL;  
+            }
+    	retVal = ETrue;
+        }
+
+    return retVal;    	
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::StartTimerIfIdle
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::StartTimerIfIdle()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::StartTimerIfIdle()");
+
+    if ( !iTimer->IsActive() )
+        {
+        iTimer->After( KPhoneRecoveryTickInterval,
+            TCallBack( HandleTimer, this ) );
+        iTickCounter++;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::StartTimer
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::StartTimer()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::StartTimer()");
+   
+    if ( !iTimer->IsActive() )
+        {
+        iTickCounter = KPhoneRecoveryCounterStart;
+        iTimer->After( KPhoneRecoveryTickInterval, 
+            TCallBack( HandleTimer, this ) );
+        }    	
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::StartAllStepsTimer
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::StartAllStepsTimer()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::StartAllStepsTimer()");
+    if ( !iAllStepsTimer->IsActive() )
+    	{
+    	iAllStepsTimer->After( 1, TCallBack( HandleAllStepsTimer, this ) );
+    	}
+  }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::StartNext
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::StartNext( TInt aFound )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::StartNext()");
+    // Calculate time of next attempt.
+    
+    // This is performed as follows:
+    //  For each priority:
+    //      If there was item in waiting state, 
+    //      then calculate next attempt time for that.
+    //  Use the minimum attempt time to determine next attempt.
+    
+    TInt nextTick = KPhoneRecoveryDontStartTimer; 
+    if ( aFound & EPhoneFlagCritical )
+        {
+        nextTick = Min( nextTick, NextTick( KPhoneRecoveryTicksForCritical ) );
+        }
+    if ( aFound & EPhoneFlagHigh )
+        {
+        nextTick = Min( nextTick, NextTick( KPhoneRecoveryTicksForHigh ) );
+        }
+    if ( aFound & EPhoneFlagStandard )
+        {
+        nextTick = Min( nextTick, NextTick( KPhoneRecoveryTicksForStandard ) );
+        }
+    if ( aFound & EPhoneFlagLow )
+        {
+        nextTick = Min( nextTick, NextTick( KPhoneRecoveryTicksForLow ) );
+        }
+    if ( aFound & EPhoneFlagDontCare )
+        {
+        nextTick = Min( nextTick, NextTick( KPhoneRecoveryTicksForDontCare ) );
+        }
+    
+    if( nextTick < KPhoneRecoveryDontStartTimer )
+        {
+        if ( nextTick <= KPhoneRecoveryTicksMaximum )
+            {
+            iTimer->After( KPhoneRecoveryTickInterval*( nextTick-iTickCounter ), 
+                TCallBack( HandleTimer, this ) );
+            iTickCounter = nextTick;
+            }
+        else 
+            {
+            //pause the recover to save memory
+            iTickCounter = KPhoneRecoveryCounterPause;
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::DetermineRun
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::DetermineRun() const
+    {
+    TInt run = 0;
+
+    // Check if critical tasks ought to be run.
+    if ( !( iTickCounter % KPhoneRecoveryTicksForCritical ) )
+        {
+        run |= EPhoneFlagCritical;
+        }
+    
+    // Check if high tasks ought to be run.
+    if ( !( iTickCounter % KPhoneRecoveryTicksForHigh ) )
+        {
+        run |= EPhoneFlagHigh;
+        }
+    
+    // Check if standard tasks ought to be run.
+    if ( !( iTickCounter % KPhoneRecoveryTicksForStandard ) )
+        {
+        run |= EPhoneFlagStandard;
+        }
+    
+    // Check if low tasks ought to be run.
+    if ( !( iTickCounter % KPhoneRecoveryTicksForLow ) )
+        {
+        run |= EPhoneFlagLow;
+        }
+    
+    // Check if 'dont care' tasks ought to be run.
+    if ( !( iTickCounter % KPhoneRecoveryTicksForDontCare ) )
+        {
+        run |= EPhoneFlagDontCare;
+        }
+
+    if ( !run )
+        {
+        run |= EPhoneFlagCritical;
+        }
+
+    return run;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::NextTick
+// -----------------------------------------------------------------------------
+//
+inline TInt CTeleRecoverySystem::NextTick( TInt aTicks ) const
+    {
+    // Find smallest such value k that satisfies the following conditions:
+    //  1. It must be larger than iTickCounter
+    //  2. It must be multiple of aTicks.
+
+    return ( iTickCounter / aTicks + 1 ) * aTicks; 
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::Find
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::Find( TPhoneRecoveryId aId ) const
+    {
+    const TInt count = iRecoveryItems->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        const TRecoveryItem& item = iRecoveryItems->At( i );
+        if ( item.iId == aId )
+            {
+            return i;
+            }
+        }
+
+    return KErrNotFound;
+    }
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::IssueRequest
+// 
+// -----------------------------------------------------------------------------
+//
+void CTeleRecoverySystem::IssueRequest()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::IssueRequest()");
+    if ( !IsActive() )
+        {
+        if ( iRequest == EPhoneSIMPresent )
+            {                        
+            iSimPresentProperty.Subscribe( iStatus );
+
+			__PHONELOG( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::DoItemCallBack IssueReq.2");
+            }
+        else
+            {
+			__PHONELOG( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::DoItemCallBack IssueReq.3");
+		        
+		    __ASSERT_DEBUG( iRequest == EPhoneSIMStatus, Panic( EPhoneUtilsNoCallBack ) );
+
+            iSimStatusProperty.Subscribe( iStatus );
+            }
+
+        SetActive();
+        }
+    }
+    
+    
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::IsSIMOk
+// 
+// -----------------------------------------------------------------------------
+//
+TBool CTeleRecoverySystem::IsSIMOk()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::IsSIMOk()");
+    
+    TInt value = KErrNotFound;
+    TBool simOk = EFalse;
+
+    if ( iSimAvailable != ESimUsable )
+        {
+       	__PHONELOG( 
+		        EBasic, 
+		        EPhoneUIUtils, 
+		        "CTeleRecoverySystem::IsSIMOk Ret 0");
+        // SIM is not yet available.
+        return EFalse;
+        }
+
+    // Get current status.
+    if ( iSimStatusProperty.Handle() )
+        {        
+        iSimStatusProperty.Get( value );
+        }
+        
+    simOk = ( value == ESimUsable ); 
+
+    __PHONELOG1( 
+		    EBasic, 
+		    EPhoneUIUtils, 
+		    "CTeleRecoverySystem::IsSIMOk Ret: %d ",  (TInt) simOk);
+    
+    return simOk;
+    }
+
+// -----------------------------------------------------------------------------
+// CTeleRecoverySystem::CheckSIMAvailable
+// 
+// -----------------------------------------------------------------------------
+//
+TInt CTeleRecoverySystem::CheckSIMAvailable()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIUtils, "CTeleRecoverySystem::CheckSIMAvailable()");
+
+    // Check current SIM present state.
+    if ( iSimStatusProperty.Handle() )
+        {
+        iSimStatusProperty.Get( iSimAvailable );
+
+	    __PHONELOG1( 
+			    EBasic, 
+			    EPhoneUIUtils, 
+			    "CTeleRecoverySystem::CheckSIMAvailable %d ",  iSimAvailable );
+
+        if ( iSimAvailable != ESimUsable )
+
+            {
+            // Since SIM is not yet present, wait for availability.
+            iRequest = EPhoneSIMStatus;
+            }
+        else
+            {
+            // SIM is now available, start listening for SIM status.
+            iRequest = EPhoneSIMStatus;
+
+		    __PHONELOG1( 
+				    EBasic, 
+				    EPhoneUIUtils, 
+				    "CTeleRecoverySystem::CheckSIMAvailable new rq %d ",  (TInt) iRequest );
+
+            
+            if ( iSimStatusProperty.Handle() )
+                {        
+                TInt value = ESimStatusUninitialized;
+                iSimStatusProperty.Get( value );
+                iPrecondSimOk = ( value == ESimUsable );
+                }
+            else
+                {
+                return KErrBadHandle;
+                }            
+            }      
+        IssueRequest();
+        }
+    else
+        {
+        return KErrBadHandle;
+        }    
+    return KErrNone;
+    }
+//  End of File