/*

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

*

*/

//  INCLUDE FILES

#include "siprfsmonitorao.h"

#include <sipsystemstatemonitorpskeys.h>

#include <sipsystemstateobserver.h>

_LIT_SECURITY_POLICY_PASS( KSIPRfsAlwaysPass );

static const TInt KMicroSecondsInSecond = 1000000;

static const TInt KGuardTimerSeconds = 20;

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

// CSipRfsMonitorAo::NewL

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

//

CSipRfsMonitorAo* CSipRfsMonitorAo::NewL()

    {

    CSipRfsMonitorAo* self = new( ELeave )CSipRfsMonitorAo();

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSipRfsMonitorAo::ConstructL

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

//

void CSipRfsMonitorAo::ConstructL ()

    {

    iGuardTimer = CPeriodic::NewL( EPriorityNormal );

    TInt err = iProperty.Define( KPSSipRfsUid, KSipRfsState, RProperty::EInt,

				   KSIPRfsAlwaysPass, KSIPRfsAlwaysPass);

    if ( KErrNone != err && KErrAlreadyExists != err && 

            KErrPermissionDenied != err )

        {

        User::Leave( err );

        }

    User::LeaveIfError( iProperty.Attach(KPSSipRfsUid, KSipRfsState));

    iProperty.Subscribe( iStatus );

    SetActive();

    }

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

// CSipRfsMonitorAo::CSipRfsMonitorAo

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

//

CSipRfsMonitorAo::CSipRfsMonitorAo():

    CActive(EPriorityStandard)

    {

    CActiveScheduler::Add( this );

    iCount = 0;

    }

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

// CSipRfsMonitorAo::~CSipRfsMonitorAo

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

//

CSipRfsMonitorAo::~CSipRfsMonitorAo()

    {

	if(iGuardTimer)

		{

    	iGuardTimer->Cancel();

    	delete iGuardTimer;

		iGuardTimer = NULL;

		}

    CActive::Cancel();

    iProperty.Close();

	iProperty.Delete(KPSSipRfsUid,KSipRfsState);

    iObservers.Close();

    }

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

// CSipRfsMonitorAo::AddObserverL

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

//

void CSipRfsMonitorAo::AddObserverL( 

    MSipSystemStateObserver& aObserver )

    {

    iObservers.InsertInAddressOrderL( &aObserver );

    }

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

// CSipRfsMonitorAo::RemoveObserver

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

//    

void CSipRfsMonitorAo::RemoveObserver(

    MSipSystemStateObserver& aObserver )

    {

    TInt index = iObservers.Find( &aObserver );

    if ( index >= 0 )

        {

        iObservers.Remove( index ); 

        }

    }

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

// CSipRfsMonitorAo::NotifyObservers

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

//

void CSipRfsMonitorAo::NotifyObservers()

    {

    for ( TInt i = iObservers.Count()-1; i >= 0; i-- )

        {

        iObservers[i]->SystemVariableUpdated( 

            CSipSystemStateMonitor::ERfsState, 

            0,

            iState);

        }

    if(iObservers.Count() && iState == CSipSystemStateMonitor::ERfsStarted)

        {

        iGuardTimer->Cancel();

        iGuardTimer->Start(

			TTimeIntervalMicroSeconds32( KGuardTimerSeconds * KMicroSecondsInSecond ),

            TTimeIntervalMicroSeconds32( KGuardTimerSeconds * KMicroSecondsInSecond ),

            TCallBack( TimerExpired, this ) );

        }

    }

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

// CSipRfsMonitorAo::State

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

//

CSipSystemStateMonitor::TRfsState CSipRfsMonitorAo::State() const

    {

    return iState;

    }

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

// CSipRfsMonitorAo::EventProcessingCompleted

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

//

void CSipRfsMonitorAo::EventProcessingCompleted(

        MSipSystemStateObserver& /*aObserver*/ )

    {

    }

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

// CSipRfsMonitorAo::EventProcessingCompleted

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

//

void CSipRfsMonitorAo::EventProcessingCompleted()

    {

    iGuardTimer->Cancel();

    iProperty.Set(KPSSipRfsUid, KSipRfsState, ESipRfsEventProcessingCompleted );

    iCount = 0;

    }

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

// CSipRfsMonitorAo::TimerExpired

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

//

TInt CSipRfsMonitorAo::TimerExpired(TAny* aSelf)

    {

    CSipRfsMonitorAo* self = reinterpret_cast<CSipRfsMonitorAo*>(aSelf);

    self->EventProcessingCompleted();

    return ETrue;

    }

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

// CSipRfsMonitorAo::RunL

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

//

void CSipRfsMonitorAo::RunL()

    {

    TInt state ( 0 );  

    if ( KErrNone == iProperty.Get( state ) )

        {

        if (MappedState(state))

            NotifyObservers();

        }

    iProperty.Subscribe( iStatus );

    SetActive();

    }

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

// CSipRfsMonitorAo::RunError

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

//     

TInt CSipRfsMonitorAo::RunError( TInt /*aError*/ )

    {

    return KErrNone; // RunL cannot leave at the moment

    }

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

// CSipRfsMonitorAo::DoCancel

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

//  

void CSipRfsMonitorAo::DoCancel()

    {

    iProperty.Cancel();

    }

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

// CSipRfsMonitorAo::MappedState

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

//

TBool CSipRfsMonitorAo::MappedState(TInt aState)

    {

    TBool ret = ETrue;

    switch(aState)

        {

        case CSipSystemStateMonitor::ERfsStarted:

            iState = CSipSystemStateMonitor::ERfsStarted;

            break;

        case CSipSystemStateMonitor::ERfsFailed:

            iState = CSipSystemStateMonitor::ERfsFailed;

            break;

        case CSipSystemStateMonitor::ERfsCompleted:

            iState = CSipSystemStateMonitor::ERfsCompleted;

            break;

        default:

            ret = EFalse;

        }

    return ret;

    }