/*

* Copyright (c) 2003 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:  Observer of System Agent events

*

*/

// INCLUDE FILES

#include <es_sock.h>

#include <PSVariables.h>  // Publish & Subscribe

// User Includes

#include "mconnectioncallback.h"

// #include <flogger.h>

//_LIT(KDir, "connFilter");

//_LIT(KFile, "filtererr.txt");

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMaxOutOfCoverageTime   = 60*1000000;  //60 sec - Updated to 60 secs as part of error fix JSIN-7JSE6H

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CHttpFilterConnHandlerObserver::CHttpFilterConnHandlerObserver

// C++ default constructor can NOT contain any code, that

// might leave.

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

CHttpFilterConnHandlerObserver::CHttpFilterConnHandlerObserver(MConnectionCallback* aConnCallback):

        CActive(CActive::EPriorityHigh),iConnCallback(aConnCallback)

{

    iObserverState = EIdle;

    // hardcode iUidValue = KPSUidGprsStatusValue for GPRS

    // The iUidValue and iBearerType will be defined after connection is done

    iUidValue = 0;  // no default value, as it will be set on Network mode check

	iPrevUidValue = 0; // no default value, as it will be set on Network mode check

	iBearerType = EApBearerTypeGPRS; // it is hardcoded in Connection manager, and it does not depend on GPRS nor 3G/WCDMA

}

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

// CHttpFilterConnHandlerObserver::ConstructL

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

void CHttpFilterConnHandlerObserver::ConstructL()

{

    // Note: the CHttpFilterConnHandlerObserver object s.b. created after connection is set for particular bearer

    User::LeaveIfError(iGPRSStateProperty.Attach(KUidSystemCategory, KPSUidGprsStatusValue));

    User::LeaveIfError(iWCDMAStateProperty.Attach(KUidSystemCategory, KPSUidWcdmaStatusValue)); 

    CActiveScheduler::Add(this);

    iSuspendTimer = CPeriodic::NewL(CActive::EPriorityLow );

    if( !iTelServer.Handle() )	

        {

        // this initialization needed for identifying 3G networks

        //

        User::LeaveIfError( iTelServer.Connect() );

        User::LeaveIfError( iTelServer.LoadPhoneModule( KMmTsyModuleName ) );

        TInt numPhones;

        User::LeaveIfError( iTelServer.EnumeratePhones( numPhones ) );

        if( numPhones <= 0 )

            {

            // Huh???

            User::Leave( KErrCorrupt );

            }

        RTelServer::TPhoneInfo phoneInfo;

        User::LeaveIfError( iTelServer.GetPhoneInfo( 0, phoneInfo ) );

        User::LeaveIfError( iMobilePhone.Open( iTelServer, phoneInfo.iName ) );

        User::LeaveIfError( iMobilePhone.Initialise() );

		RMobilePhone::TMobilePhoneNetworkMode networkMode;

		User::LeaveIfError( iMobilePhone.GetCurrentMode( networkMode ) );

		if( networkMode == RMobilePhone::ENetworkModeWcdma ||

			networkMode == RMobilePhone::ENetworkModeTdcdma )

			{ // 3G/WCDMA mode

			iUidValue = KPSUidWcdmaStatusValue;

			}

		else if ( networkMode == RMobilePhone::ENetworkModeGsm ||

				  networkMode == RMobilePhone::ENetworkModeUnknown ||	

				  networkMode == RMobilePhone::ENetworkModeUnregistered )

			{

			iUidValue = KPSUidGprsStatusValue;

			}

		}

    // initial subscription and process current property value

    RunL();

}

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

// CHttpFilterConnHandlerObserver::NewL

//

// Creats an instance of the CHttpFilterConnHandlerObserver

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

CHttpFilterConnHandlerObserver* CHttpFilterConnHandlerObserver::NewL(MConnectionCallback* aConnCallback)

{

    CHttpFilterConnHandlerObserver* self = new( ELeave ) CHttpFilterConnHandlerObserver(aConnCallback);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CHttpFilterConnHandlerObserver::~CHttpFilterConnHandlerObserver

//

// Destructor

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

CHttpFilterConnHandlerObserver::~CHttpFilterConnHandlerObserver()

{

    Cancel();

    iGPRSStateProperty.Close();

    iWCDMAStateProperty.Close();

    iMobilePhone.Close();

    iTelServer.Close();

    if ( iSuspendTimer )

        iSuspendTimer->Cancel();

    delete iSuspendTimer;

}

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

// CHttpFilterConnHandlerObserver::DoCancel

//

// Cancellation of notify.

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

void CHttpFilterConnHandlerObserver::DoCancel()

{

	if (iPrevUidValue == KPSUidGprsStatusValue)

		iGPRSStateProperty.Cancel();

	else if (iPrevUidValue == KPSUidWcdmaStatusValue)

		iWCDMAStateProperty.Cancel();

}

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

// CHttpFilterConnHandlerObserver::RunL

//

// This method will be called when the iGPRSStateProperty or iWCDMAStateProperty is updated

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

void CHttpFilterConnHandlerObserver::RunL()

{

    TInt state;

	TInt err = KErrNone;

    // resubscribe before processing new value

	RMobilePhone::TMobilePhoneNetworkMode networkMode;

	User::LeaveIfError( iMobilePhone.GetCurrentMode( networkMode ) );

	if( networkMode == RMobilePhone::ENetworkModeWcdma ||

		networkMode == RMobilePhone::ENetworkModeTdcdma )

		{ 

		iUidValue = KPSUidWcdmaStatusValue;

		// Subscribing to 3G/WCDMA status events

		iWCDMAStateProperty.Subscribe(iStatus);

		SetActive();

		if (iPrevUidValue == KPSUidGprsStatusValue)

			{

			err = iGPRSStateProperty.Get(state);

			}

		else

			{

			err = iWCDMAStateProperty.Get(state);

			}

		iPrevUidValue = KPSUidWcdmaStatusValue;

		}

	else if ( networkMode == RMobilePhone::ENetworkModeGsm ||

			  networkMode == RMobilePhone::ENetworkModeUnknown ||	

			  networkMode == RMobilePhone::ENetworkModeUnregistered )

		{

		iUidValue = KPSUidGprsStatusValue;

		// Subscribing to 2G/GPRS status events

		iGPRSStateProperty.Subscribe(iStatus);

		SetActive();

		if (iPrevUidValue == KPSUidWcdmaStatusValue)

			{

			err = iWCDMAStateProperty.Get(state);

			}

		else

			{

			err = iGPRSStateProperty.Get(state);

			}

		iPrevUidValue = KPSUidGprsStatusValue;

		}

    if(err == KErrNone)

    {

      HandleStatePropertyL(state);      

    }

}

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

// CHttpFilterConnHandlerObserver::GetStateL

//

// Get state property

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

void CHttpFilterConnHandlerObserver::GetStateL(TInt iUidValue, TInt& aState)

{

    TInt ret = KErrNone;

    switch( iUidValue )

        {

        case KPSUidGprsStatusValue:

            {                

            ret = iGPRSStateProperty.Get(KUidSystemCategory, iUidValue, aState);

            }         

            break;

        case KPSUidWcdmaStatusValue:

            {                

            ret = iWCDMAStateProperty.Get(KUidSystemCategory, iUidValue, aState);

            }    

            break;

        default:

	        break;

        }

    if ( ret != KErrNotFound && ret != KErrNone )

        {

        User::Leave( ret );

        }

}

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

// CHttpFilterConnHandlerObserver::SetObserverState

//

// Set iObserverState data member (observer state)

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

void CHttpFilterConnHandlerObserver::SetObserverState(TInt aState)

{

    iObserverState = aState;

}

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

// CHttpFilterConnHandlerObserver::SetBearerTypeAndUid

//

// Set iBearerType

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

void CHttpFilterConnHandlerObserver::SetBearerTypeAndUid(TApBearerType aBearerType)

{

	TInt state;

    iBearerType = aBearerType;

    // set uid according to iBearerType

    switch( iBearerType )

    {

      case EApBearerTypeGPRS:

        {

		RMobilePhone::TMobilePhoneNetworkMode networkMode;

		User::LeaveIfError( iMobilePhone.GetCurrentMode( networkMode ) );

		if( networkMode == RMobilePhone::ENetworkModeWcdma ||

			networkMode == RMobilePhone::ENetworkModeTdcdma )

			{

			User::LeaveIfError(iWCDMAStateProperty.Get(KUidSystemCategory, KPSUidWcdmaStatusValue, state));

			iUidValue = KPSUidWcdmaStatusValue;

			}

		else if ( networkMode == RMobilePhone::ENetworkModeGsm ||

				  networkMode == RMobilePhone::ENetworkModeUnknown ||	

				  networkMode == RMobilePhone::ENetworkModeUnregistered )

			{

			User::LeaveIfError(iGPRSStateProperty.Get(KUidSystemCategory, KPSUidGprsStatusValue, state));

			iUidValue = KPSUidGprsStatusValue;

			}

        }         

        break;

      case EApBearerTypeCDMA:

        {                

           iUidValue = KPSUidWcdmaStatusValue;

        }    

        break;

	default:

		break;

    }

}

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

// CHttpFilterConnHandlerObserver::GetObserverState

//

// Set iRequested data member

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

void CHttpFilterConnHandlerObserver::GetObserverState(TInt& aState)

{

    aState = iObserverState;

}

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

// CHttpFilterConnHandlerObserver::HandleStatePropertyL

//

// This method will be called when the StateProperty will be updated

// In case of GPRS:

//	EPSGprsUnattached,

//	EPSGprsAttach,

//	EPSGprsContextActive,

//	EPSGprsSuspend,

//	EPSGprsContextActivating,

//	EPSGprsMultibleContextActive

// Handle changed stateProperty

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

void CHttpFilterConnHandlerObserver::HandleStatePropertyL(TInt aState )

{

//    RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("GPRS %d"), aState);

//    RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("Obs state %d"), iObserverState);

    // handle GPRS bearer type

     if (iUidValue == KPSUidGprsStatusValue || iUidValue == KPSUidWcdmaStatusValue)

     {

       switch (aState)

        {

        case EPSGprsSuspend: // including case EPSWcdmaSuspend: 

            if (iObserverState == EActiveReady)

            {

                // start the timer. If the ESAGprsContextActive event will not occure

                // before the timer expired the

                // current transaction will be canceled and the user will be notified.

                iSuspendTimer->Cancel();

                iSuspendTimer->Start(

                    KMaxOutOfCoverageTime,

                    0,  // No interval

                    TCallBack( TimerSuspendCallback, this ) );

                iObserverState = ESuspended;

            }

            break;

        case EPSGprsUnattached: // including case EPSWcdmaUnattached:

            if (iObserverState == ESuspended)

            {

                iSuspendTimer->Cancel();

                iConnCallback->CoverageEvent(EErrWaitTimeout);

                iObserverState = EIdle;

            }

            break;

        case EPSGprsContextActive: // case EPSWcdmaContextActive:

        case EPSGprsMultibleContextActive: // case EPSWcdmaMultipleContextActive:

            if (iObserverState == ESuspended)

            {

                // Signal came back, so just stop a timer

                iSuspendTimer->Cancel();

                iObserverState = EActiveReady;

            }

            break;

        default:

            break;

        } //switch

	 }

}

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

// CHttpFilterConnHandlerObserver::DoTimerSuspend

// callback function for the TimerSuspended

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

//

void CHttpFilterConnHandlerObserver::DoTimerSuspend()

{

    iSuspendTimer->Cancel();

    TInt gprsState = EPSGprsSuspend;

    TInt wcdmaState = EPSWcdmaSuspend;

    iGPRSStateProperty.Get(KUidSystemCategory, KPSUidGprsStatusValue, gprsState);

    iWCDMAStateProperty.Get(KUidSystemCategory, KPSUidWcdmaStatusValue, wcdmaState);

    if (gprsState == EPSGprsSuspend && wcdmaState == EPSWcdmaSuspend)

       {

       // Note that this will be run also if there was an error when getting Gprs/Wcdma status

       // because they were initialized to 'suspend'

		if (iObserverState == ESuspended)

			{

			iObserverState = EIdle;

			iConnCallback->CoverageEvent(EErrWaitTimeout);

	//        RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("CTimer:Event"));

			}

		}

	else

       {

       iObserverState = EActiveReady;         

       }

}

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

// CHttpFilterConnHandlerObserver::TimerSuspendCallback

// callback function for the TimerSuspended

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

//

TInt CHttpFilterConnHandlerObserver::TimerSuspendCallback(TAny* aAny )

{

    ((CHttpFilterConnHandlerObserver*)aAny)->DoTimerSuspend();

    return KErrNone;

}

//  End of File