/*

* Copyright (c) 2006-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:  ?Description

*

*/

#include "irdebug.h"

#include "irnwinfoobserver.h"

#include "irui.h"

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

// Function : CIRNwInfoObserver

// Function is the default constructor, sets the CActive priority

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

//

CIRNwInfoObserver::CIRNwInfoObserver():CActive (EPriorityLow),

				iCurrentNetworkInfoV1Pckg(iCurrentNetworkInfo),

      			iHomeOperatorInfoPckg(iHomeOperatorInfo)   

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::CIRNwInfoObserver" );

	//no implementation

	}

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

// Function : ConstructL

// Function does all the initializations

// Two phase constructor

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

//

void CIRNwInfoObserver::ConstructL(CIRUi* aUi)

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::ConstructL - Entering" );

	iUi = aUi;

	iNwInfoObserver = CTelephony::NewL();

	CActiveScheduler::Add(this);

	iCurrentNetwork = ETrue;

    iHomeNetworkType = EFalse;

	iFirstTime = ETrue;

	IRLOG_DEBUG( "CIRNwInfoObserver::ConstructL - Exiting." );

    }

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

// Function : NewL

// Function returns an instance of CIRNwInfoObserver

// Two phase constructor

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

//

CIRNwInfoObserver* CIRNwInfoObserver::NewL(CIRUi* aUi)

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::NewL - Entering" );

	CIRNwInfoObserver* self = CIRNwInfoObserver::NewLC(aUi);

	CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRNwInfoObserver::NewL - Exiting." );

	return self;

	}

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

// Function : NewLC

// Function returns an instance of CIRNwInfoObserver

// Two phase constructor

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

//

CIRNwInfoObserver* CIRNwInfoObserver::NewLC(CIRUi* aUi)

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::NewLC - Entering" );

	CIRNwInfoObserver* self = new (ELeave) CIRNwInfoObserver;

	CleanupStack::PushL(self);

	self->ConstructL(aUi);

	IRLOG_DEBUG( "CIRNwInfoObserver::NewLC - Exiting." );

	return self;

	}

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

// Function : ~CIRNwInfoObserver

// Default destructor calls Cancel function which cancel the active request 

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

//

CIRNwInfoObserver::~CIRNwInfoObserver()

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::~CIRNwInfoObserver - Entering" );

	Cancel();

	delete iNwInfoObserver;

	IRLOG_DEBUG( "CIRNwInfoObserver::~CIRNwInfoObserver - Exiting" );

	}

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

// Function : IRStartNwMonitor

// Function to start network monitoring

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

//

void CIRNwInfoObserver::IRStartNwMonitor()

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::IRStartNwMonitor - Entering" );

	if( !IsActive() )

		{

		//get the network status for the first time

		iNwInfoObserver->GetCurrentNetworkInfo(iStatus,

			iCurrentNetworkInfoV1Pckg);			

		SetActive(); 

		}		 

	IRLOG_DEBUG( "CIRNwInfoObserver::IRStartNwMonitor - Exiting." );

	}

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

// Function : IssueRequest

// Issue request

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

//

void CIRNwInfoObserver::IssueRequest()

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::IssueRequest - Entering" );

	if( iCurrentNetwork )

		{

		if( !IsActive() )

			{

			//notify if current operator changes

			iNwInfoObserver->NotifyChange(iStatus,

				CTelephony::ECurrentNetworkInfoChange,

								iCurrentNetworkInfoV1Pckg);

			SetActive();

			}			

		}	

	 if( iHomeNetworkType )

		{

		if( !IsActive() )

			{

			//notify if home operator changes

			iNwInfoObserver->NotifyChange(iStatus,

				CTelephony::ENetworkRegistrationStatusChange,

									iHomeOperatorInfoPckg);

			SetActive();

			}	

		}

	IRLOG_DEBUG( "CIRNwInfoObserver::IssueRequest - Exiting." );

	}

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

// Function : DoCancel

// Function stops getting the battery info if it is active

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

//

void CIRNwInfoObserver::DoCancel()

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::DoCancel - Entering" );

	if( IsActive() )

		{

		//cancel the out standing requests if any

		iNwInfoObserver->CancelAsync(CTelephony::ECurrentNetworkInfoChangeCancel);

		iNwInfoObserver->CancelAsync(CTelephony::ENetworkRegistrationStatusChangeCancel);	

		iNwInfoObserver->CancelAsync(CTelephony::EGetCurrentNetworkInfoCancel);

		iNwInfoObserver->CancelAsync(CTelephony::EGetNetworkRegistrationStatusCancel);

		}	

	IRLOG_DEBUG( "CIRNwInfoObserver::DoCancel - Exiting" );

	}

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

// Function : RunL

// RunL of the nwinfoobserver

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

//

void CIRNwInfoObserver::RunL()

	{	

	IRLOG_DEBUG( "CIRNwInfoObserver::RunL - Entering" );

	if(KErrNone == iStatus.Int())

		{		

		if( iCurrentNetwork )

			{

			//if the request was to find the current network

			//(changes) then the value is updated

			#ifdef _WINS_

				iCurrentNetworkMCC.Zero();

				iCurrentNetworkMNC.Zero();

				iUi->UpdateCurrentNetwork

					(iCurrentNetworkMCC,iCurrentNetworkMNC);		

			#else

				iCurrentNetworkMCC = iCurrentNetworkInfo.iCountryCode;

				iCurrentNetworkMNC = iCurrentNetworkInfo.iNetworkId;

				//updating mcc+mnc value

				iUi->UpdateCurrentNetwork

					(iCurrentNetworkMCC,iCurrentNetworkMNC);

			#endif

			iHomeNetworkType = ETrue;

			iCurrentNetwork = EFalse;

			if( iFirstTime )

				{

				//if first time we have check the 

				//current operator is home operator

				iNwInfoObserver->GetNetworkRegistrationStatus

					(iStatus,iHomeOperatorInfoPckg);			

				SetActive();

				iFirstTime = EFalse;	

				}

			else

				{

				//else issue request is called for notifying

				//home operator change

				IssueRequest();	

				}			

			}

		else if( iHomeNetworkType )

			{

			//home operator (or the change in home operator is 

			//notified. 

			#ifdef _WINS_

				iHomeNetworkMCC.Zero();

				iHomeNetworkMNC.Zero();

				iUi->UpdateHomeNetwork(iHomeNetworkMCC,iHomeNetworkMNC);

			#else

				//if operator is not same as home operator it is not updated

				if (CTelephony::ERegisteredOnHomeNetwork 

					== iHomeOperatorInfo.iRegStatus)

					{

					//if registration status shows that user is registered in 

					//home network and not in roaming status, the current operator

					//is updated

					iHomeNetworkMCC = iCurrentNetworkMCC;

					iHomeNetworkMNC = iCurrentNetworkMNC;

					iUi->UpdateHomeNetwork(iHomeNetworkMCC,iHomeNetworkMNC);

					}

			#endif

			//issue request to find the current network change

			iHomeNetworkType = EFalse;

			iCurrentNetwork = ETrue;

			IssueRequest();

			}		

		else

			{

			return;	

			}		

		}

	else

		{

		//if any error network is updated to zero

		iCurrentNetworkMCC.Zero();

		iCurrentNetworkMNC.Zero();

		iUi->UpdateCurrentNetwork(iCurrentNetworkMCC,iCurrentNetworkMNC);

		iHomeNetworkMCC.Zero();

		iHomeNetworkMNC.Zero();

		iUi->UpdateHomeNetwork(iHomeNetworkMCC,iHomeNetworkMNC);

		}

	IRLOG_DEBUG( "CIRNwInfoObserver::RunL - Exiting." );

	return;

	}

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

// Function : RunError

// Function which handles RunL error

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

//

TInt CIRNwInfoObserver::RunError(TInt aError)

	{

	IRLOG_DEBUG( "CIRNwInfoObserver::RunError" );

	return aError;		

	}