/*

* Copyright (c) 2009 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: Implementation of fotaserver component

* 	This is part of fotaapplication.

*

*/

#include <systemwarninglevels.hrh>

#include <e32property.h>

#include <startupdomainpskeys.h>

#include <hwrmpowerstatesdkpskeys.h>

#include <sysutil.h> 

#include <fotaengine.h>

#include "fotaserverPrivateCRKeys.h"

#include "fmsserver.h"

#include "fmsinterruptaob.h"

#include "fmsclientserver.h"

#include "FotaIPCTypes.h"

#if defined (__WINS__)

#include <cmpluginlanbasedef.h>

#endif

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

// static method StaticCheckNwRequestL() called to check n/w availability

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

static TInt StaticCheckNwRequestL(TAny* aPtr)

	{

	CFMSInterruptAob* ptr = (CFMSInterruptAob*) aPtr;

	FLOG(_L("StaticCheckNwRequestL:-Begin"));	

	TRAPD(err, ptr->NetworkRegistryCheckL() );	

	FLOG(_L("StaticCheckNwRequestL:-end"));

	return err;

	}

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

// CFMSInterruptAob::CFMSInterruptAob()

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

CFMSInterruptAob::CFMSInterruptAob()

:CActive(EPriorityStandard)

	{

	//CActiveScheduler::Add(this);

	iConnStatus = KErrNone;

	iWlanAvailable = EFalse;

	iGPRSAvail = EFalse;

	iWcdma = EFalse;

	iUpdInterruptType = ENoInterrupt;

	iChargeToMonitor = 0;

	}

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

// CFMSInterruptAob::ConstructL()

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

void CFMSInterruptAob::ConstructL()

	{

	CActiveScheduler::Add(this);	

	User::LeaveIfError(iConnMon.ConnectL());

	}

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

// CFMSInterruptAob::Start()

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

void CFMSInterruptAob::StartL(TFmsIpcCommands aType)

	{	

	FLOG(_L("CFMSInterruptAob::Start- begin"));

	iInterruptType = aType;

	if(iInterruptType == EDLUserInterrupt && iServer->ChargerTobeMonitered())

		{

		FLOG(_L("CFMSInterruptAob::Start--EUserInterrupt"));

		if(!IsActive())

			{

			//RProperty pw;

			iProperty.Attach(KPSUidHWRMPowerState,KHWRMChargingStatus);

			iStatus=KRequestPending;

			iProperty.Subscribe(iStatus);	

			SetActive();	

			}

		}

	else if(iInterruptType == EDLNetworkInterrupt && iServer->NetworkTobeMonitered())

		{	  

		FLOG(_L("CFMSInterruptAob::Start--ENetworkInterrupt"));	

		if(!IsActive())

			{		  

			iStatus=KRequestPending;			  

			TBool phonenotoffline = CheckGlobalRFStateL();

			if ( ( iBearer == EBearerIdGPRS || iBearer == EBearerIdWCDMA )

					&& phonenotoffline )

				{

				FLOG(_L("CFMSInterruptAob::Start--ENetworkInterrupt iBearer is %d"),iBearer);	

				NotifyL();

				return;			  

				}

			else if ( iBearer == EBearerIdWLAN )

				{

				//feature supported check

				iWlanAvailable = EFalse;	  

				iConnMon.GetBoolAttribute( EBearerIdWLAN, 

						0, 

						KBearerAvailability, 

						iWlanAvailable, 

						iStatus );

				SetActive();

				}

			else

				{

				FLOG(_L("CFMSInterruptAob::Start--ENetworkInterrupt--other then GPRS/ WLan bearer "));	  

				//Stop the server	  

				//Dont delete the file if interrupt is network + offline( to differentiate from hard reboot

				iServer->DeleteFile(EFalse);

				StopServer();

				}	  

			}

		}

	else if(iInterruptType == EDLMemoryInterrupt && iServer->MemoryTobeMonitered())

		{

		FLOG(_L("CFMSInterruptAob::Start--EMemoryInterrupt on drive %d"),(TInt)iDrive );		  

		if(!IsActive())

			{

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

			TBool critical = EFalse;

			TInt err = KErrNone;

			err=IsPkgSizeMoreThanWL(critical);		  

			if(critical)

				{	 

				FLOG(_L("CFMSInterruptAob::Start--EMemoryInterrupt--critical pkg dont fit on drive %d"),(TInt)iDrive );		  

				iStatus=KRequestPending;					

				iFs.NotifyDiskSpace( iSize, iDrive, iStatus ); 

				FLOG(_L("CFMSInterruptAob::Start--EMemoryInterrupt-setting as active") );		  

				SetActive();	

				}

			else

				{

				if(err == KErrNone)

					{

					FLOG(_L("CFMSInterruptAob::Start--EMemoryInterrupt--critical pkg fits on drive %d"),(TInt)iDrive );

					LaunchFotaEngineL();

					}

				else

					{

					FLOG(_L("CFMSInterruptAob::Start--EMemoryInterrupt--System error %d on memory drive %d"), err,(TInt)iDrive );

					}

				//Stop the server	 

				StopServer();	   

				}

			}

		}  

	else //case where variation fails or by chance if a bad interrupt reason

		{

		StopServer();	  

		}	 

	}

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

// CFMSInterruptAob::RunL()

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

void CFMSInterruptAob::RunL()

	{

	FLOG(_L("CFMSInterruptAob::RunL()- begin"));

	TInt value = 0;

	if( EUpdMonitorPhoneCallEnd == iUpdInterruptType)

      {

      FLOG(_L("RunL EPhoneCallActiveAsync--call status %d"),iCallStatus);

      if(iStatus == KErrNone && RCall::EStatusIdle == iCallStatus )

          {

          //call fota scheduler & Stop the server          

          LaunchFotaUpdate();

          StopServer();

          }

      else //call in progress, subscribe again

          {

          FLOG(_L("call in progress, subscribing again"));

          iLine.NotifyStatusChange(iStatus, iCallStatus);

          SetActive();

          }

      }

	else if( iUpdInterruptType == EUpdMonitorbattery)

	  {

	  	 FLOG(_L("CFMSInterruptAob::RunL()- handling battery monitor"));

	  	 iProperty.Attach(KPSUidHWRMPowerState,KHWRMBatteryLevel);

		   TInt err=iProperty.Get(KPSUidHWRMPowerState,KHWRMBatteryLevel,value);

		   if(err != KErrNone)

		    { 

		    	FLOG(_L("CFMSInterruptAob::RunL()- error  in getiing the battery level")); 

		    	StopServer();

		    }  

		   if(value >= iChargeToMonitor)

	    	{ iProperty.Cancel();

			    iProperty.Close();	

			  TRAPD(err, LaunchFotaScheduleUpdate());

			  if(err)

			  {

			  	FLOG(_L("CFMSInterruptAob::RunL()- error in launch fota schedule"));

			  }

            iUpdInterruptType = ENoInterrupt;

            StopServer();

		    }

	    	else 

		   	{			

		    	FLOG(_L("CFMSInterruptAob::RunL()--status charger not connected"));

			   if(!IsActive())

			  	{

				  iStatus=KRequestPending;	

				  iProperty.Subscribe(iStatus);

				  FLOG(_L("CFMSInterruptAob::RunL()--waiting for charger Connectivity"));

				  SetActive();

				  }	

	       }

	  }     	

  else if( iInterruptType == EDLUserInterrupt)

		{

		TInt value;	

		//RProperty   pw;

		iProperty.Attach(KPSUidHWRMPowerState,KHWRMChargingStatus);

		iProperty.Get(KPSUidHWRMPowerState,KHWRMChargingStatus,value);

		// charger connected or already charging going on

		if( value == EChargingStatusCharging /*|| value == EChargingStatusChargingComplete ||

				value == EChargingStatusAlmostComplete || value == EChargingStatusChargingContinued */)

			{	

			 	FLOG(_L("CFMSInterruptAob::RunL()--status charging"));

			  HandleChargingInterruptL();			

			}

		else 

			{			

			FLOG(_L("CFMSInterruptAob::RunL()--status charger not connected"));

			if(!IsActive())

				{

				iStatus=KRequestPending;	

				iProperty.Subscribe(iStatus);

				FLOG(_L("CFMSInterruptAob::RunL()--waiting for charger Connectivity"));

				SetActive();

				}				

			}

		}

	else if( iInterruptType == EDLNetworkInterrupt )

		{

		FLOG(_L("CFMSInterruptAob::RunL()--ENetworkInterrupt" ));	

		/*if( iBearer == EBearerIdGPRS || iBearer == EBearerIdWCDMA )

			{

			FLOG(_L("CFMSInterruptAob::RunL()--ENetworkInterrupt:GPRS/WCDMA" ));

			}*/

		 if ( iBearer == EBearerIdWLAN )

			{

			TBuf<10> num;

			FLOG(_L("CFMSInterruptAob::RunL()--ENetworkInterrupt due to bearer id WLAN, iStatus %d"),iStatus.Int());	

			/*if(iWlanAvailable)

				FLOG(_L("iWlanAvailable :TRUE"));

			else

				FLOG(_L("iWlanAvailable :FALSE"));	*/				

			if( iWlanAvailable && iStatus == KErrNone )

				{

				FLOG(_L("CFMSInterruptAob::RunL()--status WLAN networks found"));		

				LaunchFotaEngineL();

				StopServer();				

				}

			else if( iStatus == KErrNotSupported )//feture not supported

				{

				FLOG(_L("CFMSInterruptAob::RunL()--status WLAN feature not supported"));

				StopServer();				

				}

			else 

				{

				FLOG(_L("CFMSInterruptAob::RunL()--status WLAN networks not found"));  			  

				if(!IsActive())

					{	

					iWlanAvailable = EFalse;

					iStatus=KRequestPending;	

					iConnMon.GetBoolAttribute( EBearerIdWLAN, 

							0, 

							KBearerAvailability, 

							iWlanAvailable, 

							iStatus );

					FLOG(_L("CFMSInterruptAob::RunL()--search for wlan availability"));

					SetActive();

					}		   

				}	

			}

		}	

	else if( iInterruptType == EDLMemoryInterrupt )

		{

		FLOG(_L("CFMSInterruptAob::RunL()--EMemoryInterrupt,iStatus %d"),iStatus.Int());			

		if( iStatus == KErrNone  || iStatus == KErrCancel )

			{

			TBool critical = EFalse;

			IsPkgSizeMoreThanWL(critical);

			//if download size doesn't lead to memory less than critical level

			if( !critical )	

				{

				FLOG(_L("CFMSInterruptAob::RunL()--Ok download not greater than critical level"));

				//Check network status at this moment

				HandleAboveCriticallevelL();

				}

			else

				{

				FLOG(_L("CFMSInterruptAob::RunL()--Ok download greater than critical level"));

				// space monitor for this		

				if(!IsActive())

					{

					iStatus=KRequestPending;					

					iFs.NotifyDiskSpace( iSize, iDrive, iStatus ); 

					SetActive(); 	

					}			

				}

			}			

		else // for size request more than disk space

			{

			FLOG(_L("CFMSInterruptAob::RunL()--bad request size greater than the disk limit"));		

			StopServer();			

			}		

		}

	else //general

		{

		//Already ahandled in session class

		}

	FLOG(_L("CFMSInterruptAob::RunL()- End"));

	}

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

// CFMSInterruptAob::DoCancel() 

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

void CFMSInterruptAob::DoCancel()

	{

	FLOG(_L("CFMSInterruptAob::::DoCancel()"));

	if( iStatus == KRequestPending )

		{

		FLOG(_L("CFMSInterruptAob::::DoCancel()--request pending"));

		TRequestStatus* status = &iStatus;

		User::RequestComplete( status, KErrCancel );

		}

	}

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

// CFMSInterruptAob::MemoryToMonitorL() 

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

void CFMSInterruptAob::MemoryToMonitorL(TInt aSize, TDriveNumber aDrive)

	{

	FLOG(_L("CFMSInterruptAob::::MemoryToMonitorL()--Begin"));

	if( aSize < 0 || (aDrive < EDriveA && aDrive > EDriveZ) )

		{

		FLOG(_L("CFMSInterruptAob::::MemoryToMonitorL()--Leving with KErrArgumnet"));

		User::Leave(KErrArgument);

		}

	iDrive = aDrive;

	iSize = aSize;

	CheckMemSizeL();				

	}

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

// CFMSInterruptAob::NetworkTypeL() 

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

void CFMSInterruptAob::NetworkTypeL(TInt aBearer)

	{	

	if( aBearer == EBearerIdGPRS || aBearer == EBearerIdWLAN

									|| aBearer == EBearerIdWCDMA 

#if defined (__WINS__)									

									|| aBearer == EBearerIdLAN)

#else

                                                                 )

#endif

		{

		iBearer = aBearer;		

		}

	else

		{

		FLOG(_L("CFMSInterruptAob::::NetworkTypeL()--leaving with KErrArgument"));

		User::Leave(KErrArgument);

		}

	}

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

// CFMSInterruptAob::IsPkgSizeMoreThanWL() 

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

TInt CFMSInterruptAob::IsPkgSizeMoreThanWL(TBool& aCritical)

	{

	FLOG(_L("CFMSInterruptAob::::IsPkgSizeMoreThanWL()--Begin"));

	TInt err = KErrNone;	

	//Already checked the drive is proper or not

	//here the check happened for warning level

	TRAP(err,aCritical = SysUtil::DiskSpaceBelowCriticalLevelL ( &iFs, iSize, iDrive ));

	FLOG(_L("CFMSInterruptAob::::IsPkgSizeMoreThanWL() end %d"),err);

	return err;

	}

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

// CFMSInterruptAob::CheckNetworkL() 

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

TBool CFMSInterruptAob::CheckNetworkL()

	{	

	FLOG(_L("CFMSInterruptAob::CheckNetworkL--begin"));

	TRequestStatus status=KRequestPending;	

	iConnStatus = KErrNone; 	  

	TBool phonenotoffline = CheckGlobalRFStateL();	  

	if ( phonenotoffline && iBearer == EBearerIdGPRS )

		{

		TRequestStatus gsmstatus = KRequestPending;	

		iConnStatus = KErrNotFound;		

		FLOG(_L("CFMSInterruptAob::CheckNetworkL--check GSM registry"));	

		iConnMon.GetIntAttribute( EBearerIdGSM, 0,KNetworkRegistration, iConnStatus, gsmstatus );

		User::WaitForRequest(gsmstatus);

		FLOG(_L("iConnStatus is %d gsmstatus is %d"),iConnStatus,gsmstatus.Int());

		if( iConnStatus == ENetworkRegistrationHomeNetwork || 

				iConnStatus == ENetworkRegistrationRoaming ) 

			{

			FLOG(_L("CFMSInterruptAob::CheckNetworkL--GSM available"));

			FLOG(_L("CFMSInterruptAob::CheckNetworkL--checking GPRS"));

			iConnMon.GetBoolAttribute( EBearerIdGPRS, 0,KPacketDataAvailability,

					iGPRSAvail, status );

			User::WaitForRequest(status);

			if( iGPRSAvail && status.Int()==KErrNone )

				{

				FLOG(_L("CFMSInterruptAob::CheckNetworkL--GPRS available"));

				return ETrue;

				}

			}

		}

	else if ( phonenotoffline && iBearer == EBearerIdWCDMA )

		{

		TRequestStatus gsmstatus = KRequestPending;	

		iConnStatus = KErrNotFound;		

		FLOG(_L("CFMSInterruptAob::CheckNetworkL--check WCDMA sim registry"));	

		iConnMon.GetIntAttribute( EBearerIdWCDMA, 0,KNetworkRegistration, iConnStatus, gsmstatus );

		User::WaitForRequest(gsmstatus);

		FLOG(_L("iConnStatus is %d WCDMA gsmstatus is %d"),iConnStatus,gsmstatus.Int());

		if( iConnStatus == ENetworkRegistrationHomeNetwork || 

				iConnStatus == ENetworkRegistrationRoaming ) 

			{

			FLOG(_L("CFMSInterruptAob::CheckNetworkL--WCDMA GSM available"));

			FLOG(_L("CFMSInterruptAob::CheckNetworkL--checking WCDMA GPRS"));

			iConnMon.GetBoolAttribute( EBearerIdWCDMA, 0,KPacketDataAvailability,

					iGPRSAvail, status );

			User::WaitForRequest(status);

			if( iGPRSAvail && status.Int()==KErrNone )

				{

				FLOG(_L("CFMSInterruptAob::CheckNetworkL--WCDMA GPRS available"));

				return ETrue;

				}

			}

		}

	else if ( iBearer == EBearerIdWLAN )

		{

		FLOG(_L("CFMSInterruptAob::CheckNetworkL--checking WLAN"));	  

		iWlanAvailable = EFalse;	  

		iConnMon.GetBoolAttribute( EBearerIdWLAN, 

				0, 

				KBearerAvailability, 

				iWlanAvailable, 

				status );	

		User::WaitForRequest(status);//Synchronous call

		if( iWlanAvailable && status == KErrNone )

			{

			FLOG(_L("CFMSInterruptAob::CheckNetworkL--wlan available"));

			return ETrue;

			}

		}

	else //phone is offline

		{

		FLOG(_L("CFMSInterruptAob::CheckNetworkL--phone is offline or invalid bearer"));

		}

	FLOG(_L("CFMSInterruptAob::CheckNetworkL--end"));

	return EFalse;

	}

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

// CFMSInterruptAob::CheckGlobalRFStateL() 

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

TBool CFMSInterruptAob::CheckGlobalRFStateL()

	{		

	TInt val = KErrNone;

	TInt err = KErrNone;

	TInt status = EFalse;

	err = RProperty::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;

	}

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

// CFMSInterruptAob::StopServer() 

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

void CFMSInterruptAob::StopServer()

	{

	FLOG(_L("CFMSInterruptAob::StopServer begin"));	

	iServer->iSessionCount = 0;

	CActiveScheduler::Stop();//---for stopping the server

	FLOG(_L("CFMSInterruptAob::StopServer:server stopped"));	

	}

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

// CFMSInterruptAob::LaunchFotaEngineL() 

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

void CFMSInterruptAob::LaunchFotaEngineL()

	{

	FLOG(_L("CFMSInterruptAob::LaunchFotaEngineL call to iFotaEngine.OpenL() "));

	TInt err = KErrNone;

    iServer->DeleteScheduledRemindersL();

	TRAP(err,iFotaEngine.OpenL());

	FLOG(_L("iFotaEngine.OpenL() launched withe error as %d"),err);

	if(err == KErrNone)

		{

        RFotaEngineSession::TState state = iFotaEngine.GetState(-1);

        if (state == RFotaEngineSession::EDownloadProgressing)

            {

            FLOG(_L("Trying resume download..."));