/*

* Copyright (c) 2005 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:   GPRS and Wlan status getter for sending Generic Alerts

*

*/

// INCLUDE FILES

//System Includes

#include <startupdomainpskeys.h>	//GlobalRFsStates

#include <rconnmon.h>	//RConnectionMonitor

#include <featmgr.h>	//Feature Manager

#include <features.hrh>	//Feature Manager

#include <cmconnectionmethoddef.h>

#include <cmmanagerext.h>

#include <cmpluginwlandef.h>

#include <cmpluginpacketdatadef.h>

//User Includes

#include "FotaServer.h"

#include "FotaNetworkRegStatus.h"

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

// CFotaNetworkRegStatus::NewL

// Symbian 2-Phase construction, NewL used for creating object of this class

// This method can leave

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

CFotaNetworkRegStatus* CFotaNetworkRegStatus::NewL(CFotaServer* aObserver)

	{

	CFotaNetworkRegStatus* self = CFotaNetworkRegStatus::NewLC(aObserver);

	CleanupStack::Pop(self);

	return self;	

	}

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

// CFotaNetworkRegStatus::NewLC

// Symbian 2-Phase construction, NewLC used for creating object of this class

// This method can leave

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

CFotaNetworkRegStatus* CFotaNetworkRegStatus::NewLC(CFotaServer* aObserver)

	{

	CFotaNetworkRegStatus* self = new (ELeave) CFotaNetworkRegStatus (aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// CFotaNetworkRegStatus::ConstructL

// Symbian 2-Phase construction, ConstructL used for constructing the members of this class

// This method can leave

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

void CFotaNetworkRegStatus::ConstructL()

	{

	iTimer.CreateLocal();

	iMonitor.ConnectL();

	}

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

// CFotaNetworkRegStatus::CFotaNetworkRegStatus

// C++ Constructor

// This method shouldn't leave

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

CFotaNetworkRegStatus::CFotaNetworkRegStatus(CFotaServer* aObserver) : 

    CActive( CActive::EPriorityStandard ), iObserver(aObserver), iRetriesLeft (KRetries), iGlobalRFState(EFalse)

    {

     CActiveScheduler::Add( this ); // Add AO to current active scheduler

    }

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

// CFotaNetworkRegStatus::~CFotaNetworkRegStatus

// C++ Desctructor

// This method shouldn't leave

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

CFotaNetworkRegStatus::~CFotaNetworkRegStatus()

	{

	Cancel();

	iTimer.Close();

	iMonitor.Close();

	}

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

// CFotaNetworkRegStatus::DoCancel()

// Cancels currently active notifier, if such exists

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

//

void CFotaNetworkRegStatus::DoCancel()

	{

	FLOG(_L("CFotaNetworkRegStatus::DoCancel >>"));

	if(IsActive())

		{

		iTimer.Cancel();

//		Cancel();

		}

	FLOG(_L("CFotaNetworkRegStatus::DoCancel <<"));

	}

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

// CFotaNetworkRegStatus::StartMonitoringL

// Monitors for connection status

// This method don't leave

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

void CFotaNetworkRegStatus::StartMonitoringL()

    {

    FLOG(_L("CFotaNetworkRegStatus::StartMonitoringL >>"));

	//Check offline state

	FLOG(_L("Check GlobalRF state..."));

	if (!iGlobalRFState)

		{

		iGlobalRFState = CheckGlobalRFState();	

		}

	if (iGlobalRFState)

		{

		//Check registration state only if iGlobalRFState is true

		FLOG(_L("Check registration state..."));

		if (CheckNetworkRegStateL())

			{

			//If both are successful report complete

			FLOG(_L("Network Registration is successful, sending Status as success to FotaServer"));

			iObserver->ReportNetworkStatus(ETrue);

			return;

			}

		}

	//If one of them is not successful, start timer and retry KRetries times...

	if (--iRetriesLeft>=0)

		{

		FLOG(_L("Retry count... [%d]"),KRetries-iRetriesLeft);

		iTimer.After(iStatus,KTimeInterval); 

		if (!IsActive())

			SetActive();

		}

	else

		{

		FLOG(_L("Maximum retries (%d) reached, sending Status as failure to FotaServer"), KRetries);

		iObserver->ReportNetworkStatus(IsWlanSupportedL());		

		}

	FLOG(_L("CFotaNetworkRegStatus::StartMonitoringL <<"));

    }

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

// CFotaNetworkRegStatus::RunL()

// Called when event accomplished

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

//

void CFotaNetworkRegStatus::RunL()

    {

    FLOG(_L("CFotaNetworkRegStatus::RunL >>"));

	if (iStatus==KErrNone)

		{

		StartMonitoringL();

		}

	else

		{

		iObserver->ReportNetworkStatus(EFalse);	

		}

	FLOG(_L("CFotaNetworkRegStatus::RunL <<"));

	}

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

// CFotaNetworkRegStatus::RunError

// Called when RunL leaves

// This method can't leave

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

TInt CFotaNetworkRegStatus::RunError(TInt aError)

	{

	FLOG(_L("CFotaNetworkRegStatus::RunL >>"));

	iObserver->ReportNetworkStatus(EFalse);			

	FLOG(_L("CFotaNetworkRegStatus::RunL <<"));

	return KErrNone;

	}

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

// CFotaNetworkRegStatus::CheckGlobalRFState

// Checks for GlobalRFState, set by Starter

// This method can't leave

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

TBool CFotaNetworkRegStatus::CheckGlobalRFState()

{

	FLOG(_L("CFotaNetworkRegStatus::CheckGlobalRFState >>"));

	RProperty prop;

	TInt val = KErrNone;

	TInt err = KErrNone;

	TInt status = EFalse;

	err = prop.Get(KPSUidStartup, KPSGlobalSystemState, val);

	if (err==KErrNone && val==ESwStateNormalRfOn)

		{

		//Phone is not offline. Check for Network Registration status

		FLOG(_L("Phone is online. Check for Network Registration status"));

		status = ETrue;

		}

	else

		{

		//Phone is offline. No Network activities allowed.

		FLOG(_L("Phone is offline. No Network activities allowed."));

		status = EFalse;

		}

	FLOG(_L("CFotaNetworkRegStatus::CheckGlobalRFState, status = %d <<"),status);	

	return status;

}

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

// CFotaNetworkRegStatus::CheckNetworkRegStatusL

// Checks for Network registration status

// This method can leave

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

TBool CFotaNetworkRegStatus::CheckNetworkRegStateL()

	{

	FLOG(_L("CFotaNetworkRegStatus::CheckNetworkRegStateL >>"));

	TBool status = EFalse;

	TInt registrationStatus (KErrNone);

	TRequestStatus status1;

	iMonitor.GetIntAttribute( EBearerIdGSM,  // See bearer ids from TConnMonBearerId

	                         0, 

	                         KNetworkRegistration, 

	                         registrationStatus, 

	                         status1 );

	User::WaitForRequest( status1 );

	if ( status1.Int() == KErrNone )

	    {

	    switch (registrationStatus)

	    	{

	    		case ENetworkRegistrationHomeNetwork:

	    		case ENetworkRegistrationRoaming:

						{

						status = ETrue;

						break;	

						}

				default:

						{

	    				/* Includes - 	ENetworkRegistrationNotAvailable:

	    								ENetworkRegistrationUnknown:

	    								ENetworkRegistrationNoService:

	    								ENetworkRegistrationEmergencyOnly:

	    								ENetworkRegistrationSearching:

	    								ENetworkRegistrationBusy:

	    								ENetworkRegistrationDenied:*/

	    				status = EFalse;

	    				break;

	    				}

	    	}

	    }

	FLOG(_L("CFotaNetworkRegStatus::CheckNetworkRegStateL, status = %d <<"),status);    

	return status;

	}

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

// CFotaNetworkRegStatus::IsWlanSupportedL

// Checks whether Wlan supported on device and active

// This method can leave

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

TBool CFotaNetworkRegStatus::IsWlanSupportedL()

	{

	FLOG(_L("CFotaNetworkRegStatus::IsWlanSupportedL >>"));

	TBool status = EFalse;

	FeatureManager::InitializeLibL();

	if (FeatureManager::FeatureSupported( KFeatureIdProtocolWlan  )) // check for feature enabled

		{

		status = ETrue;

		}

	FeatureManager::UnInitializeLib();

#if defined(__WINS__)

	status = ETrue;

#endif

	FLOG(_L("CFotaNetworkRegStatus::IsWlanSupportedL, status = %d <<"),status);

	return status;

	}

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

// CFotaNetworkRegStatus::IsConnectionPossibleL

// Checks whether the network connection is possible in the given IAP Id

// This method can leave

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

TBool CFotaNetworkRegStatus::IsConnectionPossibleL(TInt aIapid)

	{

	FLOG(_L("CFotaNetworkRegStatus::IsConnectionPossibleL >>"));

	TBool status (EFalse);

	TUint32 bearer = FindBearerL(aIapid);

	if( bearer == KUidPacketDataBearerType )

	{

	FLOG(_L("Bearer is Packet data"));

	if( CheckGlobalRFState() && CheckNetworkRegStateL() )

		{

		FLOG(_L("Network is up and connection is possible "));

		status = ETrue;

		}

	else

		{

		FLOG(_L("Network is not up and connection is not possible "));

		status = EFalse;

		}

	}

	else if( bearer == KUidWlanBearerType )//for wlan or other bearers

		{

		FLOG(_L("Bearer is wlan and proceeding for download "));

		//proceed & this else loop to be removed

		status = ETrue;

		}

	else

		{

		FLOG(_L("Bearer is not packet data or WLAN"));

		}

	FLOG(_L("CFotaNetworkRegStatus::IsConnectionPossibleL, status = %d <<"),status);

	return status;

	}

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

// CFotaDownload::FindBearerId

// Finds the Bearer Id for a given IAP Id

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

TUint32 CFotaNetworkRegStatus::FindBearerL(TInt aIapId)

	{

	FLOG(_L("CFotaNetworkRegStatus::FindBearerL: %d"),aIapId);

	TUint32 bearer = 0;

	TInt err( KErrNone );

	 // Query CM Id

	TInt cmId ( aIapId );			        

	RCmManagerExt  CmManagerExt;

	TRAP( err, CmManagerExt.OpenL() );

	FLOG(_L("CmManagerExt.OpenL() with error as  %d"),err);	

    if( err == KErrNone )

    	{

    	RCmConnectionMethodExt cm;

    	TRAP( err, cm = CmManagerExt.ConnectionMethodL( cmId ) );			        	

    	FLOG(_L("CmManagerExt.ConnectionMethodL with error as  %d"),err);

	    if ( err == KErrNone )

	        {	        

	        CleanupClosePushL( cm );	  

	        FLOG(_L("cm pushed to cleanupstack "));

	        bearer = cm.GetIntAttributeL( CMManager::ECmBearerType );	        			        

	        FLOG(_L("bearer is %d "),bearer);

		    CleanupStack::PopAndDestroy();  // cm	  

	        FLOG(_L("cm poped & destroyed from cleanupstack "));

	        }	  

	    CmManagerExt.Close();

	    FLOG(_L("CmManagerExt closed "));

    	}

    FLOG(_L("CFotaNetworkRegStatus::FindBearerL end with bearer: %d"),bearer);				

    return bearer;

	}

// End of File