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

// Implements the functionality required to provide clients with

// callforwarding status and registration information.

// 

//

/**

 @file

*/

#include <testconfigfileparser.h>

#include "CSimCallForwarding.h"

#include "CSimPhone.h"

const TInt KSettingListGranularity=5;	// < The granularity used for parameter list arrays.

const TInt KInvalidTimeout = -1;        // Value used when timeout period does not matter

const TInt KMobServiceIndxStart = 1;

const TInt KMobServiceIndxEnd   = 6;

CSimCallForwarding* CSimCallForwarding::NewL(CSimPhone* aPhone)

/**

 * Standard two-phase constructor.

 * @param aPhone				The parent phone object.

 * @return CSimNetworkStatus	The new network status class.

 */

	{

	CSimCallForwarding* self=new(ELeave) CSimCallForwarding(aPhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CSimCallForwarding::CSimCallForwarding(CSimPhone* aPhone)

		: iPhone(aPhone)

/**

 * Trivial first phase construction.

 * @param aPhone				The parent phone object.

 */

	{

	}

void CSimCallForwarding::ConstructL()

	/** 

	Second phase of 2-Phase Constructor

 	Retrieves all the Call forwarding and Identity services tags from the config file

	*/

	{

	iIdentityServiceStatus=new(ELeave) CArrayFixFlat<TIdentityServiceStatus>(KSettingListGranularity);

	iGetCFStatus = new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(1);

	FindAndCreateCFListL();

	// Read in the Identity services information

	TInt count=CfgFile()->ItemCount(KIdentityServiceStatus);

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

	for(TInt i=0;i<count;i++)

		{

		item=CfgFile()->Item(KIdentityServiceStatus,i);

		if(!item)

			break;

		TInt status, service;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,service);

		if(ret!=KErrNone)

			{

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,status);

		if(ret!=KErrNone)

			{

			continue;

			}

		TIdentityServiceStatus identityServiceStatus;

		identityServiceStatus.iService = static_cast<RMobilePhone::TMobilePhoneIdService>(service);

		identityServiceStatus.iStatus = static_cast<RMobilePhone::TMobilePhoneIdServiceStatus>(status);

		iIdentityServiceStatus->AppendL(identityServiceStatus);

		}

	}

CSimCallForwarding::~CSimCallForwarding()

	/** 

	Destroy all the objects constructed.

	*/

	{

	if (iIdentityServiceStatus != NULL)

		{

		iIdentityServiceStatus->Delete(0,iIdentityServiceStatus->Count());

		delete iIdentityServiceStatus;

		}

	delete iCFList;

	if (iGetCFStatus)

		iGetCFStatus->ResetAndDestroy();

	delete iGetCFStatus;

	}

TInt CSimCallForwarding::ExtFunc(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg)

	{

	/**

	Handles all the Call forwarding APIs

	@param aReqHandle to the request

	@param Ipc unique identifier of the method to call

	@param aPckg contains arguments of the method to call

	*/

	TAny* dataPtr = aPckg.Ptr1();

	TAny* dataPtr2 = aPckg.Ptr2();

	// The following requests can be completed even if the completion of another request is pending.

	switch(aIpc)

		{

	case EMobilePhoneSetCallForwardingStatus:

		return SetCallForwardingStatus(aReqHandle,

			reinterpret_cast<RMobilePhone::TMobilePhoneCFCondition*>(dataPtr),

			reinterpret_cast<RMobilePhone::TMobilePhoneCFChangeV1*>(dataPtr2));

	case EMobilePhoneNotifyCallForwardingStatusChange:

		return NotifyCallForwardingStatusChange(aReqHandle, reinterpret_cast<RMobilePhone::TMobilePhoneCFCondition*>(dataPtr));

	case EMobilePhoneGetIdentityServiceStatus:

		return GetIdentityServiceStatus(aReqHandle, 

			reinterpret_cast<RMobilePhone::TMobilePhoneIdService*>(dataPtr),

			reinterpret_cast<RMobilePhone::TMobilePhoneIdServiceStatus*>(dataPtr2));

	case EMobilePhoneGetCallForwardingStatusPhase1:

		return GetCallForwardingStatusPhase1(aReqHandle, 

			REINTERPRET_CAST(CRetrieveMobilePhoneCFList::TGetCallForwardingRequest*, dataPtr), 

			REINTERPRET_CAST(TInt*, dataPtr2));

	case EMobilePhoneGetCallForwardingStatusPhase2:

		return GetCallForwardingStatusPhase2(aReqHandle, 

			REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr), aPckg.Des2n());			

	default:

		break;

		}

	return KErrNotSupported;

	}

TInt CSimCallForwarding::CancelService(const TInt aIpc, const TTsyReqHandle aReqHandle)

	/**

	Cancels Call forwarding requests

	@param ipc request to cancel

	@param aReqHandle Handle to the request

	*/

	{

	switch(aIpc)

		{

	case EMobilePhoneSetCallForwardingStatus:

		return SetCallForwardingStatusCancel(aReqHandle);

	case EMobilePhoneNotifyCallForwardingStatusChange:

		return NotifyCallForwardingStatusChangeCancel(aReqHandle);

	case EMobilePhoneGetIdentityServiceStatus:

		return GetIdentityServiceStatusCancel(aReqHandle);

	default:

		break;

		}

	return KErrNone;

	}

void CSimCallForwarding::FindAndCreateCFListL()

	{

	/**

	Creates the Call forwarding list from the config file

	*/

	RMobilePhone::TMobilePhoneCFInfoEntryV1 entry;

	if(iCFList)

		delete iCFList;

	iCFList=NULL;

	iCFList = CMobilePhoneCFList::NewL();

	TInt count=CfgFile()->ItemCount(KCFList);

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

	TInt i;

	for(i=0;i<count;i++)

		{

		item=CfgFile()->Item(KCFList,i);

		if(!item)

			break;

		TPtrC8 number;

		TInt condition, serviceGroup, status, timeout; // valid for CFRNy only

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,condition);

		if(ret!=KErrNone)

			{

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,serviceGroup);

		if(ret!=KErrNone)

			{

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,status);

		if(ret!=KErrNone)

			{

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,timeout);

		if(ret!=KErrNone)

			{

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,number);

		if(ret!=KErrNone)

			{

			continue;

			}

		entry.iServiceGroup=(RMobilePhone::TMobileService)serviceGroup;

		entry.iNumber.iTelNumber.Copy(number);

		entry.iTimeout=timeout;

		entry.iCondition=(RMobilePhone::TMobilePhoneCFCondition)condition;

		entry.iStatus=(RMobilePhone::TMobilePhoneCFStatus)status;

		iCFList->AddEntryL(entry);

		}//end for

	//CFlist must define entries for each condition even if unknown

	//fill up table if it misses conditions:

	RArray<TBool> serviceArray;

	//voice, auxVoice, data, packet, fax, sms, all;

	CleanupClosePushL(serviceArray);

	RMobilePhone::TMobilePhoneCFInfoEntryV1 extraEntry;

	for (TInt j=1;j<5;j++)//loop conditions

		{

		TInt serviceFound=EFalse;

		TInt index;

		extraEntry.iCondition=static_cast<RMobilePhone::TMobilePhoneCFCondition>(j);

		serviceArray.Reset();

		for(TInt h=0;h<8;h++)

			{

			serviceArray.Append(EFalse);

			}

		for (TInt k=0;k<count;k++)//loop entries

			{

			entry=iCFList->GetEntryL(k);

			if(entry.iCondition==static_cast<RMobilePhone::TMobilePhoneCFCondition>(j))

				{

				index = (TInt)entry.iServiceGroup;

				serviceArray[index]=ETrue;

				}

			}

		if (!serviceArray[7])//(all services)

			{

			for (TInt l=1;l<7;l++)

				{

				if (serviceArray[l])

					serviceFound=ETrue;										

				}

			//no service defined for this condition

			if(!serviceFound)

				{

				extraEntry.iServiceGroup=RMobilePhone::EAllServices;

				extraEntry.iStatus=RMobilePhone::ECallForwardingStatusNotRegistered;

				iCFList->AddEntryL(extraEntry);

				}

			//some services defined in table

			else

				{

				for (TInt m=1;m<7;m++)

					{

					if (!serviceArray[m])

						{

						extraEntry.iServiceGroup=static_cast<RMobilePhone::TMobileService>(m);

						extraEntry.iStatus=RMobilePhone::ECallForwardingStatusNotRegistered;

						iCFList->AddEntryL(extraEntry);

						}

					}//end for

				}//end else

			}//end if

		}//end for

	CleanupStack::PopAndDestroy(&serviceArray);	//Destroying serviceArray to free the memory

	}

TInt CSimCallForwarding::GetIdentityServiceStatus(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneIdService* aService, RMobilePhone::TMobilePhoneIdServiceStatus* aStatus)

	/**

	Gets the status of the identity services

	@param aReqHandle handle to the request

	@param aService service that the client is interested in

	@param aStatus of the identity service

	*/

	{

	RMobilePhone::TMobilePhoneIdServiceStatus status;

	status = RMobilePhone::EIdServiceUnknown;

	TInt count = iIdentityServiceStatus->Count();

	for(TInt i=0; i<count; i++)

		{

		if(iIdentityServiceStatus->At(i).iService == *aService)

			{

			status = iIdentityServiceStatus->At(i).iStatus;

			break;

			}

		}

	*aStatus = status;

	iPhone->ReqCompleted(aReqHandle, KErrNone);

	return KErrNone;

	}

TInt CSimCallForwarding::GetIdentityServiceStatusCancel(const TTsyReqHandle aReqHandle)

	/**

	Cancels the request to get the status of the identity services

	@param aReqHandle hadle to the request

	*/

	{

	iPhone->ReqCompleted(aReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSimCallForwarding::NotifyCallForwardingStatusChange(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneCFCondition* aCF)

	/**

	Requests to be notified of call forwarding status change

	@param aReqHandle handle to the request

	@param aCF condition for which the client wants to be notified

	 */

	{

	__ASSERT_ALWAYS(!iCFNotification.iCFChangeInfoNotificationPending,SimPanic(ENotificationReqAlreadyOutstanding));

	iCFNotification.iCFChangeInfoNotificationPending=ETrue;

	iCFNotification.iCFChangeInfoReqHandle=aReqHandle;

	iCFNotification.iCurrentCFCondition=aCF;

	return KErrNone;

	}

TInt CSimCallForwarding::NotifyCallForwardingStatusChangeCancel(const TTsyReqHandle aReqHandle)

	/**

	Cancels the request to be notified of call forwarding status change

	@param aReqHandle handle to the request

	*/

	{

	if(iCFNotification.iCFChangeInfoNotificationPending)

		{

		iCFNotification.iCFChangeInfoNotificationPending=EFalse;

		iPhone->ReqCompleted(aReqHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCallForwarding::SetCallForwardingStatus(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneCFCondition* aCF,  RMobilePhone::TMobilePhoneCFChangeV1* aInfo)

	/**

	Sets the status of call forwarding

	@param aReqHandle handle to the request

	@param aCF condition for which the client wants to set the status

	@param aInfo value of Call forwarding to set

	*/

	{

	TRAPD(err, UpdateCFListL(aCF,aInfo));

	if ( err != KErrNone )

		{ 

		iPhone->ReqCompleted(aReqHandle,err);

		return KErrNone;

		}

	if(iCFNotification.iCFChangeInfoNotificationPending)

		{

		*(iCFNotification.iCurrentCFCondition)=*aCF;

		iCFNotification.iCFChangeInfoNotificationPending=EFalse;

		iPhone->ReqCompleted(iCFNotification.iCFChangeInfoReqHandle,KErrNone);

		}

	iPhone->ReqCompleted(aReqHandle,err);

	return KErrNone;

	}

TInt CSimCallForwarding::SetCallForwardingStatusCancel(const TTsyReqHandle aReqHandle)

	/**

	Cancels the request to set the status of call forwarding

	@param aReqHandle handle to the request

	*/

	{

	iPhone->ReqCompleted(aReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSimCallForwarding::GetCallForwardingStatusPhase1(const TTsyReqHandle aTsyReqHandle, 

												 CRetrieveMobilePhoneCFList::TGetCallForwardingRequest* aReqData, 

												 TInt* aBufSize)

	{

	/**

	1st phase retrieval of the status of call forwarding

	@param aTsyReqHandle handle to the request

	@param aReqData contains details of the request

	@param aBufSize size of the buffer the client needs to allocate for phase 2

	*/

	TInt ret=KErrNone;

    // for forwarding we cannot querry for all conditions;

    // conditions - specific

    // services  - individual and all

	if ((aReqData->iCondition==RMobilePhone::ECallForwardingUnspecified)

	   || (aReqData->iCondition==RMobilePhone::ECallForwardingAllCases)

	   || (aReqData->iCondition==RMobilePhone::ECallForwardingAllConditionalCases))

	   {

			iPhone->ReqCompleted(aTsyReqHandle,KErrArgument);

		}

	else

		{

		TInt leaveCode=KErrNone;

		TRAP(leaveCode, ret=ProcessGetCallForwardingStatusPhase1L(aTsyReqHandle, aReqData, aBufSize););

		if (leaveCode != KErrNone)

			iPhone->ReqCompleted(aTsyReqHandle,leaveCode);

		}

	return ret;

	}

TInt CSimCallForwarding::ProcessGetCallForwardingStatusPhase1L(const TTsyReqHandle aTsyReqHandle, 

														 CRetrieveMobilePhoneCFList::TGetCallForwardingRequest* aReqData, 

														 TInt* aBufSize)

	{

	/** Retrieve call forwarding status of each line from phone, 

	store each CF status response as a list entry,

	stream the list and then return size of this buffer to client

	@param aReqHandle Handle to the request

	@param aReqData information about the request

	@param aBufSize Size of the buffer the client has to allocate for the 2nd pahase

	*/

	CMobilePhoneCFList* list=CMobilePhoneCFList::NewL();

	CleanupStack::PushL(list);

	TInt cnt=0;//Only interested by entries with a particular condition

	TInt maxNum=iCFList->Enumerate();

	TBool isAllGroups = (aReqData->iServiceGroup == RMobilePhone::EAllServices);

	for(TInt i=0;i<maxNum;i++)

		{

		RMobilePhone::TMobilePhoneCFInfoEntryV1 entry = iCFList->GetEntryL(i);

		// Check that the data structure is supported by the simulated TSY version

		TInt err = iPhone->CheckSimTsyVersion(entry);

		if(err != KErrNone)

			{

			iPhone->ReqCompleted(aTsyReqHandle, err);

			return KErrNone;

			}

		if((entry.iCondition == aReqData->iCondition) 

		   &&(entry.iStatus != RMobilePhone::ECallForwardingStatusNotRegistered))

			{

			if ( !isAllGroups && (entry.iServiceGroup != aReqData->iServiceGroup))

				{

				continue;

				}

			list->AddEntryL(entry);

			cnt++;

			}	

		}

	// Store the streamed list and the client ID

	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aReqData->iClient,aTsyReqHandle);

	CleanupStack::PushL(read);

	read->iListBuf = list->StoreLC();

	CleanupStack::Pop(); // pop the CBufBase allocated by StoreLC

	iGetCFStatus->AppendL(read);

	CleanupStack::Pop(read); // pop the CListReadAllAttempt

	// return the CBufBase’s size to client

	*aBufSize=(read->iListBuf)->Size();

	CleanupStack::PopAndDestroy(list); // pop&destroy list

	// Complete first phase of list retrieval

	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;	

	}

TInt CSimCallForwarding::GetCallForwardingStatusPhase2(const TTsyReqHandle aTsyReqHandle, 

												 RMobilePhone::TClientId* aClient, TDes8* aBuf)

	/**

	2nd phase retrieval of the status of call forwarding

	@param aTsyRqHandle handle to the request

	@param aClient pointer to the client

	@param aBuf buffer that contains the call forwarding list

	*/

	{

	CListReadAllAttempt* read=NULL;

	// Find the get detected network attempt from this client

	for (TInt i=0; i<iGetCFStatus->Count(); ++i)

		{

		read = iGetCFStatus->At(i);