/*

* 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:  Class Implementation, aware of Device System State Changes and perform

*                processing related to profile registration/deregistration

*

*/

#include "sipdevicestateaware.h"

#include <sipsystemstateobserver.h>

#include <ssm/ssmdomaindefs.h>

#include <ssm/ssmstate.h>

#include <ssm/ssmsubstates.hrh>

#include <e32std.h> 

static const TInt KMicroSecondsInSecond = 1000000;

static const TInt KGuardTimerSeconds = 5;

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

// CSipDeviceStateAware::NewL

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

//

CSipDeviceStateAware* CSipDeviceStateAware::NewL ()

    {

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

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop(self);

    return self;

    }

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

// CSipDeviceStateAware::ConstructL

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

//

void CSipDeviceStateAware::ConstructL()

	{

	iGuardTimer = CPeriodic::NewL( EPriorityNormal );

    //SIP System connects to Domain Id GenMiddlewareDomain3    

    User::LeaveIfError(iStateAwareSession.Connect(KSM2GenMiddlewareDomain3));

    TSsmState currentState = iStateAwareSession.State();

    if(ESsmNormal == currentState.MainState())

        {

        iState = CSipSystemStateMonitor::ESystemReady;

        }

    iStateAwareSession.RequestStateNotification(iStatus);        

    SetActive();

    }

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

// CSipDeviceStateAware::CSipDeviceStateAware

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

//

CSipDeviceStateAware::CSipDeviceStateAware():CActive(EPriorityStandard)

    {    

    CActiveScheduler::Add(this);

	iState = CSipSystemStateMonitor::ESystemNotReady;

    iCount = 0;

    }

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

// CSipDeviceStateAware::~CSipDeviceStateAware

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

//

CSipDeviceStateAware::~CSipDeviceStateAware ()

    {

     iGuardTimer->Cancel();

     delete iGuardTimer;

     CActive::Cancel();     

     iObservers.Close();

    }

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

// CSipDeviceStateAware::RunL

// Currently this object only monitor for basically three events, Offline, online

// and shutdown. 

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

//

void CSipDeviceStateAware::RunL()

    {

	TBool ackAndRequest = ETrue;

    TInt status = iStatus.Int();

    if(KErrNone == status)

        {

            TSsmState currentState = iStateAwareSession.State();

            if(ESsmNormal == currentState.MainState() )

                {                

                switch (currentState.SubState())

                    {

                    // Device is entering into Offline Mode. Hence as part

                    // of staged offline, SIP tries to deregister all profiles.

                    case ESsmNormalRfOffSubState:

                        {

						if(iState == CSipSystemStateMonitor::ESystemOnline)

							{

                       		iState = CSipSystemStateMonitor::ESystemOffline;

                       		NotifyObservers(CSipSystemStateMonitor::ESystemOffline);

							iGuardTimer->Cancel();

							TTimeIntervalMicroSeconds32 time( KGuardTimerSeconds * KMicroSecondsInSecond );

							iGuardTimer->Start( time, time, TCallBack( TimerExpired, this) );                                        

							ackAndRequest = EFalse;

							}

                        break;

                        }

                    //Device entering into online mode, SIP tries to register all

                    //profiles with registration mode 'always on'

                    case ESsmNormalRfOnSubState:

                        {

						if(iState == CSipSystemStateMonitor::ESystemOffline)

							{

                       		NotifyObservers(CSipSystemStateMonitor::ESystemOnline);

							}

                       	iState = CSipSystemStateMonitor::ESystemOnline;

                        break;

                        }

                    default:

                        {                        

                        break;

                        }

                    }//end switch                

                } //end if

			}//end outer if

	if(ackAndRequest)

    	iStateAwareSession.AcknowledgeAndRequestStateNotification(KErrNone, iStatus);

	else

		iStateAwareSession.RequestStateNotification(iStatus);

    SetActive();

    }

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

// CSipDeviceStateAware::RunError

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

//     

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

    {

    return KErrNone; // RunL cannot leave at the moment

    }

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

// CSipDeviceStateAware::DoCancel

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

//

void CSipDeviceStateAware::DoCancel()

    {

    iStateAwareSession.Close();

    }

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

// CSipDeviceStateAware::AddObserverL

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

//

void CSipDeviceStateAware::AddObserverL(MSipSystemStateObserver& aObserver)

    {

    iObservers.InsertInAddressOrderL( &aObserver );

    }

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

// CSipDeviceStateAware::RemoveObserver

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

//

void CSipDeviceStateAware::RemoveObserver(MSipSystemStateObserver& aObserver)

    {

    TInt index = iObservers.Find( &aObserver );

    if ( index >= 0 )

        {

        iObservers.Remove( index ); 

        } 

    }

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

// CSipDeviceStateAware::NotifyObservers

// This function will notify all the observers when the state of the phone changes

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

//

void CSipDeviceStateAware::NotifyObservers(

				CSipSystemStateMonitor::TSystemState aState) const

    {

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

            {

            iObservers[i]->SystemVariableUpdated( 

                    CSipSystemStateMonitor::ESystemState, 

                    0,

                    aState );

            }

    }

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

// CSipDeviceStateAware::TimerExpired

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

//

TInt CSipDeviceStateAware::TimerExpired(TAny* aSelf)

    {

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

    self->EventProcessingCompleted();

    return ETrue;

    }

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

// CSipDeviceStateAware::EventProcessingCompleted

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

//

void CSipDeviceStateAware::EventProcessingCompleted(

        MSipSystemStateObserver& aObserver )

    {

    TInt index = iObservers.Find( &aObserver );

    if ( index >= 0 )

        iCount++;

    if( iObservers.Count() == iCount)

        {

        iGuardTimer->Cancel();

        }	

    }

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

// CSipDeviceStateAware::EventProcessingCompleted

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

//

void CSipDeviceStateAware::EventProcessingCompleted()

    {

    iGuardTimer->Cancel();

    }