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