/*
* Copyright (c) 2002-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:   RMmCustomAPI contains multimode API's vendor specific
*                functionality.
*
*/



// INCLUDE FILES
#include <etelext.h>
#include <etelmm.h>
#include <s32file.h>

#define _READ_FROM_FILE_

#include "epos_rsuplmmcustomapi.h"

 const TInt KTimeRequest = 2000000;

 const TInt KTA = 100; // 0 to 255
 const TInt KPrimaryScrambilingCode = 200; // 0 to 511
 const TInt KCarrierRSSI = 100; //0 to 127

 const TInt KMeasuredCID			= 500; 	 // 0 to 268435455

 const TInt KPrimaryCPICH = 125;  //0 to 127
 const TInt KCpichEcN0 = 50;		 // 0 to 63, max=49      
 const TInt KCichRscp = 125; 	 // 0 to 127, max=91      
 const TInt KPathloss = 100; 	 // 6 to 173, max=58
 const TInt KCellParamID = 125;	 // 0 to 127
 const TInt KProposedTGSN = 10;	 // 0 to 14
 const TInt KPrimaryCcpchRscp = 100; // 0 to 127
 const TInt KFddUL = 12000;			// 0 to 16383	
 const TInt KFddDL = 14000;			// 0 to 16383 	
 const TInt KTddDt = 15000;			// 0 to 16383	
 	
_LIT(KMyFile,"c:\\logs\\epos\\input.txt");
 	   		
 RMmCustomAPI::RMmCustomAPI()
    {
    	
    }
    
RMmCustomAPI::TMmCellInfo::TMmCellInfo()
	{
	}

RMmCustomAPI::TMmCellInfo::~TMmCellInfo()
	{
	}

 void RMmCustomAPI::ConstructL()
    {
    	iFileError  = iFs.Connect();
    	iRTimer.CreateLocal();
    	iSUPLNwMode = ESUPLWCDMA;
    	#ifdef _READ_FROM_FILE_
    		iSUPLNwMode = (TSUPLNwMode)GetParameterValue(1);
    	#endif
    	
    	iInitialTNmr = 0;
		iSUPLFrequecyMode = EFDD;
		iSUPLFrequecyMode = ETDD;
		#ifdef _READ_FROM_FILE_
			iSUPLFrequecyMode = (TSUPLFrequecyMode)GetParameterValue(16);
		#endif	
		iNoOfCells = GetParameterValue(2);
    }

 void RMmCustomAPI::Destruct()
    {
    	iRTimer.Close();
    	iFs.Close();
    }

// -----------------------------------------------------------------------------
// RMmCustomAPI::Open
// This method opens a RMmCustomAPI subsession from RMobilePhone.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
 TInt RMmCustomAPI::Open( RMobilePhone& /*aPhone*/ )
    {
    	TInt error = KErrNone;
    	TRAP(error,ConstructL());
    	return error;   
    }

// -----------------------------------------------------------------------------
// RMmCustomAPI::Close
// This method closes a RMmCustomAPI subsession
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
 void RMmCustomAPI::Close()
    {
    	Destruct();
    }

 TInt RMmCustomAPI::GetCellInfo ( TMmCellInfo& aCellInfo ) 
	{
		TInt error = KErrNone;
	
		if( iSUPLNwMode == ESUPLGSM )
			{
				FillGSMCellInfo(aCellInfo);
			}
		else
			{
				FillWCDMACellInfo(aCellInfo); 
			}
			
		return error;
	}


 void RMmCustomAPI::GetCellInfo (TRequestStatus& aStatus, TDes8& aCellInfo ) 
	{
	     TInt error = KErrNone;
		 if(error == KErrNone)
		 	{
		 		 TMmCellInfoPckg& infoPkg = static_cast<TMmCellInfoPckg&>(aCellInfo );
		 		 TMmCellInfo& CellInfo = infoPkg();
		 		 GetCellInfo(CellInfo);
				 TTimeIntervalMicroSeconds32 microsec(KTimeRequest);
				 iStatus = &aStatus; 
				 iRTimer.After(*iStatus, microsec); 		
		 	}
	 	else
	 		{
				TRequestStatus* pStat = &aStatus;
				User::RequestComplete(pStat, error);
	 		}
	}


 void RMmCustomAPI::FillGSMCellInfo ( TMmCellInfo& aCellInfo ) 
	{
		aCellInfo.iGsmCellInfo.iTA = KTA;
		#ifdef _READ_FROM_FILE_ 
			aCellInfo.iGsmCellInfo.iTA = GetParameterValue(9);
		#endif
		iInitialTNmr = 0;
		for(TInt i = 0; i < KMaxNmrAmount; i++)
			{
				aCellInfo.iGsmCellInfo.iNmr[i] = GetTNmr();
			}
			
		aCellInfo.iMode = TMmCellInfo::EGSM;	
	}

 RMmCustomAPI::TMmCellInfo::TNmr RMmCustomAPI::GetTNmr()
 	{
 			RMmCustomAPI::TMmCellInfo::TNmr tNmr;
			tNmr.iARFCN  = iInitialTNmr;
			tNmr.iBSIC   = iInitialTNmr;
			tNmr.RxLEV   = iInitialTNmr;
 			iInitialTNmr++;
		#ifdef _READ_FROM_FILE_	
			tNmr.iARFCN  = GetParameterValue(6,iInitialTNmr);
			tNmr.iBSIC   = GetParameterValue(7,iInitialTNmr);
			tNmr.RxLEV   = GetParameterValue(8,iInitialTNmr);
    	#endif	
			return tNmr;				
 	}

 void RMmCustomAPI::FillWCDMACellInfo ( TMmCellInfo& aCellInfo ) 
	{
		TMmCellInfo::TWCDMACellInfo wcdmaCellInfo;
		TMmCellInfo::TFrequencyInfo frequencyInfo;
		FillMeasureRequestList(wcdmaCellInfo);
		FillFrequencyMode(frequencyInfo,1,0); // 0 means Freq info used for wcdmaCellInfo struct

		aCellInfo.iMode = TMmCellInfo::EWCDMA;	
		wcdmaCellInfo.iPrimaryScrambilingCode = KPrimaryScrambilingCode;
		#ifdef _READ_FROM_FILE_
			wcdmaCellInfo.iPrimaryScrambilingCode = GetParameterValue(15); 
		#endif
		wcdmaCellInfo.iFrequencyInfo = frequencyInfo;
		aCellInfo.iWcdmaCellInfo = wcdmaCellInfo;
	}

 void RMmCustomAPI::FillMeasureRequestList(TMmCellInfo::TWCDMACellInfo& aWcdmaCellInfo) 
	{
//		for(TInt i = 0; i < KMaxFrequency; i++)	

		iTotalCellCount = 1;
		iCellMeasuredResults = GetParameterValue(3);
		iCount = 1;
		
		for(TInt i = 0; i < iNoOfCells; i++)	
			{
				aWcdmaCellInfo.iNwkMeasureReport[i] = GetMeasureRequest((i + 1) * iCount);
				iCount++;
			}
	}

 RMmCustomAPI::TMmCellInfo::TNetworkMeasureReport RMmCustomAPI::GetMeasureRequest(TInt /*i*/) 
	{
			TMmCellInfo::TNetworkMeasureReport measureReport;
			TMmCellInfo::TFrequencyInfo frequencyInfo;

			FillFrequencyMode(frequencyInfo,iCount,1);// 1 means Freq info used for MeasuredResults struct
			measureReport.iCarrierRSSI = KCarrierRSSI;
			measureReport.iCarrierRSSI = -1;
			
			#ifdef _READ_FROM_FILE_
 
				measureReport.iCarrierRSSI = GetParameterValue(20,iCount); 
			#endif
			measureReport.iFrequencyInfo = frequencyInfo;
			FillCellMeasuredResultsList(measureReport);
			return measureReport;
	}

 void RMmCustomAPI::FillCellMeasuredResultsList(TMmCellInfo::TNetworkMeasureReport& aMeasureReport) 
 	{
 		//for(TInt i = 0; i < KMaxCellMeas; i++ )
	 	for(TInt i = 0; i < iCellMeasuredResults; i++ )
	 		{
	 			aMeasureReport.iCellMeasuredResult[i] = GetCellMeasuredResults( iTotalCellCount);
	 			iTotalCellCount++;
	 		}
 	}

RMmCustomAPI::TMmCellInfo::TCellMeasuredResult RMmCustomAPI::GetCellMeasuredResults(TInt aReadIndex) 
	{
		TMmCellInfo::TCellMeasuredResult cellMeasuredResult;
		cellMeasuredResult.iCID = KMeasuredCID;
		
		#ifdef _READ_FROM_FILE_
			cellMeasuredResult.iCID = GetParameterValue(21,aReadIndex); 
		#endif
		
		if( iSUPLFrequecyMode == EFDD)
			{
				FillFDDSpecificFrequencyMode(cellMeasuredResult,0,aReadIndex);
				FillTDDSpecificFrequencyMode(cellMeasuredResult,-1,aReadIndex);
			}
		else
			{
				FillTDDSpecificFrequencyMode(cellMeasuredResult,0,aReadIndex);
				FillFDDSpecificFrequencyMode(cellMeasuredResult,-1,aReadIndex);
			}
			
			return cellMeasuredResult;
	}

void RMmCustomAPI::FillFDDSpecificFrequencyMode(TMmCellInfo::TCellMeasuredResult& aCellMeasuredResult,TInt aOption,TInt aReadIndex) 
	{
		TMmCellInfo::TFddInfo fddInfo;
		if(aOption == 0)
			{
				fddInfo.iPrimaryCPICH = KPrimaryCPICH;
				fddInfo.iCpichEcN0 = KCpichEcN0;
				fddInfo.iCichRscp = KCichRscp;
				fddInfo.iPathloss = KPathloss;
		
#ifdef _READ_FROM_FILE_
		fddInfo.iPrimaryCPICH = GetParameterValue(22,aReadIndex);
		fddInfo.iCpichEcN0 = GetParameterValue(23,aReadIndex);
		fddInfo.iCichRscp = GetParameterValue(24,aReadIndex);
		fddInfo.iPathloss = GetParameterValue(25,aReadIndex);
#endif		
			}
		else
			{
				fddInfo.iPrimaryCPICH = -1;
				fddInfo.iCpichEcN0 = -1;
				fddInfo.iCichRscp = -1;
				fddInfo.iPathloss = -1;
			}	
		
		aCellMeasuredResult.iFddInfo = fddInfo;
	}


void RMmCustomAPI::FillTDDSpecificFrequencyMode(TMmCellInfo::TCellMeasuredResult& aCellMeasuredResult,TInt aOption,TInt aReadIndex) 
	{
		TMmCellInfo::TTddInfo tddInfo;
		
		if(aOption == 0)
			{
		   		tddInfo.iCellParamID = KCellParamID;	
		   		tddInfo.iProposedTGSN= KProposedTGSN;	
		   		tddInfo.iPrimaryCcpchRscp = KPrimaryCcpchRscp;
		   		tddInfo.iPathloss = KPathloss; 		
		   		tddInfo.iProposedTGSN= -1;	
		   		tddInfo.iPrimaryCcpchRscp = -1;
		   		tddInfo.iPathloss = -1; 		

#ifdef _READ_FROM_FILE_
   		tddInfo.iCellParamID = GetParameterValue(26,aReadIndex);	
   		tddInfo.iProposedTGSN= GetParameterValue(27,aReadIndex);	
   		tddInfo.iPrimaryCcpchRscp = GetParameterValue(28,aReadIndex);
   		tddInfo.iPathloss = GetParameterValue(29,aReadIndex); 		
#endif
		   		for(TInt i = 0;i < KMaxTimeSlotIscpAmount; i++ )
		   			{
		   				
		   				#ifdef _READ_FROM_FILE_	
		   					tddInfo.iTimeslotISCP[ i ] = GetParameterValue(30,i+1);
		   				#endif

		   			}
			}
		else
			{
		   		tddInfo.iCellParamID = -1;	
		   		tddInfo.iProposedTGSN= -1;	
		   		tddInfo.iPrimaryCcpchRscp = -1;
		   		tddInfo.iPathloss = -1; 		
		   		for(TInt i = 0;i < KMaxTimeSlotIscpAmount; i++ )
		   			{
		   				tddInfo.iTimeslotISCP[ i ] = -1;
		   			}
			}	
   			
		aCellMeasuredResult.iTddInfo = tddInfo;
		
	}

void RMmCustomAPI::FillFrequencyMode(TMmCellInfo::TFrequencyInfo& aFrequencyInfo,TInt aUsedFor,TInt aInnerOuter) 
	{
		if( iSUPLFrequecyMode == EFDD)
			{
				aFrequencyInfo.iFddUL = KFddUL;		// 0..16383		In case of fdd( iFddUL, iFddDL),
				aFrequencyInfo.iFddUL = -1;
				aFrequencyInfo.iFddDL = KFddDL;		// 0..16383 	iFddUL is optional while iFddDL is mandatory. 
				
#ifdef _READ_FROM_FILE_				
				if(aInnerOuter == 0)
					{
						aFrequencyInfo.iFddUL = GetParameterValue(12,aUsedFor);
						aFrequencyInfo.iFddDL = GetParameterValue(13,aUsedFor);
					}
				else
					{
						aFrequencyInfo.iFddUL = GetParameterValue(17,aUsedFor);
						aFrequencyInfo.iFddDL = GetParameterValue(18,aUsedFor);
					}	
#endif				
			}
		else
			{
				aFrequencyInfo.iTddNt = KTddDt;		// 0..16383		
				aFrequencyInfo.iFddUL = -1;
				aFrequencyInfo.iFddDL = -1;		
				
#ifdef _READ_FROM_FILE_				
				if(aInnerOuter == 0)
					aFrequencyInfo.iTddNt = GetParameterValue(14,aUsedFor);
				else
					aFrequencyInfo.iTddNt = GetParameterValue(19,aUsedFor);			
#endif				
			}	
	}

void RMmCustomAPI::CancelAsyncRequest()
	{
		iRTimer.Cancel();
	}
 
TInt RMmCustomAPI::GetParameterValue(TInt aLineNumber,TInt aIndex ) 
{
		
		if ( KErrNone != iFileError)
		 	return -1;
		
		RFile fread;	
		TInt lError = fread.Open(iFs,KMyFile,EFileRead); 	
		RFileReadStream rfs(fread);
		
		TChar delmeter(10); 
		TInt ret = -9999;
		TInt err;
		if ( KErrNone == lError )
		    {
		    for(TInt i = 0; i < aLineNumber; i++ )
		    	{
					TRAP(err,rfs.ReadL(iLineBuffer,delmeter));
					if(err != KErrNone)
						{
							rfs.Close();	
							fread.Close();	    
							return -1;
						}
					iLineBuffer.Copy(iLineBuffer.Left(iLineBuffer.Length() - 2 ));
		    	}
		    }
		    
	TBuf8<64> restBuffer;  
	TInt pos = KErrNotFound;
	TChar c(44); // 44 means ',' 
	
	if(aIndex != -1 )
		{
			for(TInt i = 0; i < aIndex; i++ )
				{
					pos = iLineBuffer.Locate(c);    
					if(pos == KErrNotFound)
						break;
					restBuffer.Copy(iLineBuffer.Left(pos ));
					iLineBuffer.Copy(iLineBuffer.Mid( pos + 1));
				}
			if(pos != KErrNotFound)	
				iLineBuffer.Copy(restBuffer);
		}
		
	if(ret == -9999)	    
		{
			pos = iLineBuffer.Locate(c);    
			if(pos != KErrNotFound)
				{
					restBuffer.Copy(iLineBuffer.Left(pos ));
					iLineBuffer.Copy(restBuffer);
				}
			TLex8 input(iLineBuffer);		    
			input.Val(ret);
		}
	
	rfs.Close();	
	fread.Close();	    

	return ret;
	
#if 0
		RFs fs;
		RFile fread;
		TInt lError = fs.Connect();
		if ( KErrNone != lError )
		 	return -1;
		 	
		 lError = fread.Open(fs,KMyFile,EFileRead);
		RFileReadStream rfs(fread);
		TBuf8<8> buf;
		TChar delmeter(10); 
		TInt ret = -999;
		TInt err;
		if ( KErrNone == lError )
		    {
		    for(TInt i = 0; i < aIndex; i++ )
		    	{
					TRAP(err,rfs.ReadL(buf,delmeter));
					if(err != KErrNone)
						{
							rfs.Close();	
							fread.Close();	    
							fs.Close();
							return -1;
						}
					buf.Copy(buf.Left(buf.Length() - 2 ));
		    	}
		    }
		    
	if(ret == -999)	    
		{
			TLex8 input(buf);		    
			input.Val(ret);
		}
	
	rfs.Close();	
	fread.Close();	    
	fs.Close();
	return ret;
#endif	

}	

//  End of File