/*
* 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 <f32file.h>
#include <cmconnectionmethoddef.h>
#include <cmmanagerext.h>
#include <cmpluginwlandef.h>
#include <cmpluginpacketdatadef.h>
#include <etel.h> //for telephone mode
#include <etelmm.h> //for telephone mode
#include <fotaConst.h> 
#include "fmsserversession.h"
#include "fmsclientserver.h"

// ----------------------------------------------------------------------------------------
// CFMSSession::CFMSSession
// ----------------------------------------------------------------------------------------
CFMSSession::CFMSSession()
	{	
	iStopServer  =  EFalse;
	iWlanbearer  =  EFalse;
	iWcdmaBearer =  EFalse;
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::~CFMSSession
// ----------------------------------------------------------------------------------------
CFMSSession::~CFMSSession()
	{	
	FLOG(_L("CFMSSession::~CFMSSession-- begin"));
	if( iStopServer )
		{
		FLOG(_L("Stop fmserver CFMSSession::~CFMSSession"));	
		Server().DropSession();
		}
	FLOG(_L("CFMSSession::~CFMSSession-- end"));
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::Server
// ----------------------------------------------------------------------------------------
CFMSServer& CFMSSession::Server()
	{
	return *static_cast<CFMSServer*>(const_cast<CServer2*>(CSession2::Server()));
	}


// ----------------------------------------------------------------------------------------
// CFMSSession::CheckClientSecureIdL
// ----------------------------------------------------------------------------------------
TBool CFMSSession::CheckClientSecureIdL (
		const RMessage2& aMessage)
	{
	TUid    fota            = TUid::Uid( KFotaServerUid );
	TUid    starter         = TUid::Uid( KStarterUid );

	// Fotaserver
	if ( aMessage.SecureId() == fota.iUid ) 
		{
		FLOG(_L("[CFMSSession] CheckClientSecureIdL client is \
		fotaserver!"));
		return ETrue;
		}

	// Starter
	if ( aMessage.SecureId() == starter.iUid )
		{
		return ETrue;
		}

	// test app
	if ( aMessage.SecureId() == 0x01D278B9 )
		{
		return ETrue;
		}

	FLOG(_L("[CFMSSession] CheckClientSecureIdL client 0x%X is unknown \
	(msg %d), bailing out"),aMessage.SecureId().iId, aMessage.Function());
	iStopServer = ETrue;
	User::Leave( KErrAccessDenied );    
	return EFalse; // compiler warning otherwise
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::ServiceL
// ----------------------------------------------------------------------------------------
void CFMSSession::ServiceL(const RMessage2& aMessage)
	{	
	RThread clt; aMessage.ClientL(clt); TFullName cltnm = clt.FullName();
	FLOG(_L( "CFMSSession::ServiceL      %d   serving for %S?" )
			,aMessage.Function(), &cltnm );
	if( CheckClientSecureIdL( aMessage ) )
		{
		//already one request pending
		if( Server().RequestPending() && 
				aMessage.Function() !=  ECancelOutstandingRequest )
			{
			aMessage.Complete(KErrCancel);
			}
		else //For no pending request case
			{
			TRAPD(err,DispatchMessageL(aMessage));
			if(err != KErrNone ) 
				{
				iStopServer = ETrue;
				}
			aMessage.Complete(err);
			}
		}
	else
		{
		aMessage.Complete(KErrAccessDenied);
		}
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::ServiceError
// ----------------------------------------------------------------------------------------
void CFMSSession::ServiceError(const RMessage2& aMessage,TInt aError)
	{		
	CSession2::ServiceError(aMessage,aError);
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::DispatchMessageL
// ----------------------------------------------------------------------------------------
void CFMSSession::DispatchMessageL(const RMessage2& aMessage)
	{	
	FLOG(_L("CFMSSession::DispatchMessageL-begin"));

	if( aMessage.Function() != EFotaStartUpPlugin && 
			aMessage.Function() != ECancelOutstandingRequest && 
			aMessage.Function() != EMonitorbattery &&
			aMessage.Function() != EPhoneCallActive &&
	        aMessage.Function() != EMonitorPhoneCallEnd )
		{
		 
		 HandleBasedOnBearertypeL(aMessage);
		
			
						
		}
	switch(aMessage.Function())
	{
	case EUserInterrupt:
		{
		if(Server().ChargerTobeMonitered())
			{	
			FLOG(_L("FMSSErver::EUserInterrupt"));			
			Server().WriteToFile(EUserInterrupt,aMessage.Int0(),
					(TDriveNumber)aMessage.Int1(),aMessage.Int2(),iWcdmaBearer);
			Server().StartMonitoringL(EUserInterrupt);					    
			}
		else
			{
			WriteDummyFile();
			iStopServer = ETrue;
			}
		}
		break;
	case ENetworkInterrupt:
		{
		if(Server().NetworkTobeMonitered())
			{
			FLOG(_L("FMSSErver::ENetworkInterrupt"));						
			//If wlan = on & network interrupt, then stop the server and dont monitor
			//mean other wlan n/w's present but this wlan gone off
			if(iWlanbearer && Server().CheckWlanL())
				{
				WriteDummyFile();
				Server().DeleteFile(EFalse);
				iStopServer = ETrue;
				break;
				}			
			Server().WriteToFile(ENetworkInterrupt,aMessage.Int0(),
					(TDriveNumber)aMessage.Int1(),aMessage.Int2(),iWcdmaBearer);			
			Server().AsyncSessionRequestL();
			}
		else
			{
			WriteDummyFile();
			iStopServer = ETrue;
			}
		}
		break;
	case EMemoryInterrupt:
		{			
		if(Server().MemoryTobeMonitered())
			{
			FLOG(_L("FMSSErver::EMemoryInterrupt"));				
			Server().MemoryToMonitorL(aMessage.Int2(),(TDriveNumber)aMessage.Int1()); 		
			Server().WriteToFile(EMemoryInterrupt,aMessage.Int0(),
					(TDriveNumber)aMessage.Int1(),aMessage.Int2(),iWcdmaBearer);
			Server().StartMonitoringL(EMemoryInterrupt);		
			}
		else
			{
			WriteDummyFile();
			iStopServer = ETrue;
			}
		}
		break;
	case EGeneralInterrupt:
		{
		if(Server().ChargerTobeMonitered())
			{
			FLOG(_L("FMSSErver::GeneralInterrupt"));	
			Server().WriteToFile(EUserInterrupt,aMessage.Int0(),
					(TDriveNumber)aMessage.Int1(),aMessage.Int2(),iWcdmaBearer);
			Server().StartMonitoringL(EUserInterrupt);
			}
		else
			{
			WriteDummyFile();
			iStopServer = ETrue;
			}
		}
		break;
	case EFotaStartUpPlugin:
		{	
		if(Server().MoniterAfterPhoneRestart())				
			{
			FLOG(_L("CFMSSession::EFotaStartUpPlugin"));	
			TInt intrreason(-1),bearer(-1),size(0);
			TInt drive(-1), wcdmabearer(-1);
			//if loop for Hard reboot--no file or size is empty
			if(Server().ReadFromFile(intrreason,bearer,drive,size,wcdmabearer) == EFalse )
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin no file or size is empty"));
				if(!Server().RequestPending())
					{	
					FLOG(_L("CFMSSession::EFotaStartUpPlugin-no request pending"));						  					  	
					TRAPD(err,PhoneModeL());
					if(err); // remove compiler warning
					FLOG(_L("PhoneModeL() fotastartup returns err as %d"),err);
					if(iWcdmaBearer)						 
						Server().NetworkTypeL( (TInt)EBearerIdWCDMA );

					else
						Server().NetworkTypeL( (TInt)EBearerIdGPRS );	  					  					  
					Server().LockSession();
					Server().TriggerFotaL(); //checks n/w & trigger FOTA DL						
					}
				break;
				}												
			TUint32 BearerId = FindBearerIdL(bearer);
			FLOG(_L("CFMSSession::EFotaStartUpPlugin wcdma bearer is %d"),wcdmabearer);
			if( BearerId == KUidWlanBearerType )
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin-wlan bearer"));	
				Server().NetworkTypeL(EBearerIdWLAN);
				if(intrreason == ENetworkInterrupt)
					{
					//stop the server , but dont delete file to support in second reboot
					FLOG(_L("wlan bearer & n/w interrupt--stopping the server"));
					Server().DeleteFile(EFalse);
					iStopServer = ETrue;
					break;
					}
				}
			else if( BearerId == KUidPacketDataBearerType )
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin-bearer is packet data"));	
				if( wcdmabearer == 1 )
					{
					Server().NetworkTypeL(EBearerIdWCDMA);	
					FLOG(_L("CFMSSession::EFotaStartUpPlugin-packet data and 3G"));
					}
				else
					{
					Server().NetworkTypeL(EBearerIdGPRS);
					FLOG(_L("CFMSSession::EFotaStartUpPlugin-packet data and 2G"));
					}
				}
			else
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin-unknown bearer"));
				Server().DeleteFile(EFalse);
				iStopServer = ETrue;
				break;
				}
			//when there is dummy file in the store
			if( intrreason < EUserInterrupt || intrreason > EGeneralInterrupt )
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin-Interrupt unknown"));	
				Server().DeleteFile(EFalse); //used when variation support & reboot again
				iStopServer = ETrue;
				break;
				}
			if( intrreason == EUserInterrupt || intrreason == EGeneralInterrupt )
				{
				FLOG(_L("CFMSSession::EFotaStartUpPlugin-Check n/w & trigger fotaengine"));	
				Server().CheckNetworkL(bearer,drive,size,wcdmabearer);//3 params used in monitoring if no n/w
				break;
				} 				
			//for other interrupts it will monitor
			Server().StartMonitoringL((TOmaDLInterruptReason)intrreason);
			}
		else
			{
			iStopServer = ETrue;
			}
		}
		break;
	case ECancelOutstandingRequest:
		{					
		FLOG(_L("CFMSSession::DispatchMessageL ECancelOutstandingRequest case:"));
		iStopServer = ETrue; 
		}
		break;	

	case EMonitorbattery:
	   {
	    FLOG(_L("CFMSSession::DispatchMessageL EMonitorbattery case:"));
	 	Server().StartBatteryMonitoringL(EMonitorbattery, aMessage.Int0());
	   }
	 	break;
	   
	case EPhoneCallActive:
	    {
	    FLOG(_L("CFMSSession::DispatchMessageL EPhoneCallActiveSync case:"));
	    Server().LockSession();
	    TInt reason =EFalse;
	    Server().CheckPhoneCallActiveL(reason);
	    TPckgBuf<TInt> callactive(reason);
	    aMessage.WriteL(0,callactive);
	    Server().iSessionCount = 0;
	    FLOG(_L("CFMSSession::DispatchMessageL EPhoneCallActiveSync case:%d"),reason);
	    iStopServer = ETrue;
	    }
	    break;
	    
	case EMonitorPhoneCallEnd:
	    {
	    FLOG(_L("CFMSSession::DispatchMessageL EPhoneCallActiveAsync case:%d,%d"),aMessage.Int0(),aMessage.Int1());
	    Server().LockSession();
	    if(Server().MonitorPhoneCallEndL(aMessage.Int0(),aMessage.Int1()))
	        {
	        iStopServer = ETrue;
	        Server().iSessionCount = 0;
	        }
	    else //let server monitor for active call end
	        {
	        iStopServer = EFalse;
	        }
	   }
	 	break;
	default:
		{
		FLOG(_L("CFMSSession::DispatchMessageL default case:and a leave happened"));
		iStopServer = ETrue;
		User::Leave(KErrArgument);			
		}			
	}
	FLOG(_L("CFMSSession::DispatchMessageL:end"));
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::FindBearerId
// ----------------------------------------------------------------------------------------
TUint32 CFMSSession::FindBearerIdL(TInt aIapId)
	{
	FLOG(_L("CFMSSession::FindBearerId: % d"),aIapId);
	TUint32 bearer = 0;
	TInt err( KErrNone );
	// Query CM Id
	TInt cmId ( aIapId );			        
	RCmManagerExt  CmManagerExt;
	TRAP( err, CmManagerExt.OpenL() );
	if( err == KErrNone )
		{
		RCmConnectionMethodExt cm;
		TRAP( err, cm = CmManagerExt.ConnectionMethodL( cmId ) );			        	
		if ( err == KErrNone )
			{	        
			CleanupClosePushL( cm );	  
			bearer = cm.GetIntAttributeL( CMManager::ECmBearerType );	        			        
			CleanupStack::PopAndDestroy();  // cm	        
			}	    	        
		CmManagerExt.Close();
		}
	return bearer;
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::WriteDummyFile
// This method used when the variation wouldn't support and startup called
// and also differentiates hard reeboot(with empty or no file)
// ----------------------------------------------------------------------------------------
void CFMSSession::WriteDummyFile()
	{
	FLOG(_L("CFMSSession::WriteDummyFile--begin"));
	Server().WriteToFile(KErrNotFound,KErrNotFound,
			(TDriveNumber)KErrNotFound,KErrNotFound,EFalse);
	Server().DeleteFile(EFalse);
	FLOG(_L("CFMSSession::WriteDummyFile--End"));
	}

// ----------------------------------------------------------------------------------------
// CFMSSession::PhoneMode
// This method used to know the current phone mode
// If the phone is in dual mode it will check GPRS bearer only
// ----------------------------------------------------------------------------------------
void CFMSSession::PhoneModeL()
	{
	FLOG(_L("CFMSSession::PhoneModeL--begin"));	
	// find out if we are in 2G or in 3G - it is needed for calculating bearer availability
	__UHEAP_MARK; 
	RTelServer telServer;
	User::LeaveIfError( telServer.Connect());
	FLOG(_L("CFMSSession::PhoneModeL--telServer Connected"));
	RTelServer::TPhoneInfo teleinfo;
	User::LeaveIfError( telServer.GetPhoneInfo( 0, teleinfo ) );
	FLOG(_L("CFMSSession::PhoneModeL--telServer getting tel info"));
	RMobilePhone phone;
	User::LeaveIfError( phone.Open( telServer, teleinfo.iName ) );
	FLOG(_L("CFMSSession::PhoneModeL--RMobilePhone opened"));
	User::LeaveIfError(phone.Initialise());	
	FLOG(_L("CFMSSession::PhoneModeL--phone.Initialise() success"));
	RMobilePhone::TMobilePhoneNetworkMode mode;        	        	
	TInt err = phone.GetCurrentMode( mode );
	phone.Close();
	telServer.Close();
	__UHEAP_MARKEND;

	if( KErrNone == err )
		{
		switch(mode)
		{
		case RMobilePhone::ENetworkModeGsm:
		//case RMobilePhone::ENetworkModeUnknown:  // emulator default
			{
			FLOG(_L("CFMSSession::PhoneModeL-begin-GSM Mode"));	                		
			iWcdmaBearer = EFalse;
			Server().NetworkTypeL(EBearerIdGPRS);
			break;		
			}
		case RMobilePhone::ENetworkModeWcdma:
			{                		     		
			FLOG(_L("CFMSSession::PhoneModeL-begin-3G Mode"));	
			iWcdmaBearer = ETrue;
			Server().SetWcdma();
			Server().NetworkTypeL(EBearerIdWCDMA);
			break;	
			}	
		default:        	
		FLOG(_L("unknown"));
		}        				
		}
	FLOG(_L("CFMSSession::PhoneModeL--end"));
	}
	
//----------------------------------------------------------------------------------------
// CFMSSession::HandleBasedOnBearertypeL
// Handles based on bearer type
//----------------------------------------------------------------------------------------	

void  CFMSSession::HandleBasedOnBearertypeL(const RMessage2& aMessage)
{
    TUint32 bearer = FindBearerIdL(aMessage.Int0());
		if( bearer == KUidPacketDataBearerType )
			{
			FLOG(_L("CFMSSession::DispatchMessageL bearer is packet data"));
			TRAPD(err,PhoneModeL());
			if(err); // remove compiler warning
			FLOG(_L("PhoneModeL() returns err as %d"),err);
			}
		else if	(	bearer == KUidWlanBearerType )
			{
			FLOG(_L("CFMSSession::DispatchMessageL bearer is WLAN"));
			iWlanbearer = ETrue;
			Server().NetworkTypeL(EBearerIdWLAN);
			}
		else	
			{
			FLOG(_L("CFMSSession::DispatchMessageL bearer is not known and a leave happened "));
			iStopServer = ETrue;
			User::Leave(KErrArgument);
			}
}				
//End of file