/*

* 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;

        }