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

// This file contains the implementation of the Similator TSY MBMS Packet Context functionality.  

// 

//

/**

 @file

*/

#include "Simlog.h"

#include "CSimPhone.h"

#include "CSimMbmsPacketContext.h"

#include "CSimPacketQoS.h"

#include "utils.h"

#include <e32math.h>

#include "CSimPacketService.h"

#include "CSimContextHelper.h"

CSimMbmsPacketContext* CSimMbmsPacketContext::NewL(CSimPhone* aPhone, CSimPacketService* aPacketService, const TDesC& aContextName)

/**

* Standard two phase constructor

*

* @param aPacketService Pointer to the Packet Service object (CSimPacketService)

* @param aContextName name  for this packet context

* @return CSimMbmsPacketContext pointer to the packet context object created.

* @leave Leaves if no memory or object is not created for any reason.

*/

	{

	CSimMbmsPacketContext* packetContext = new(ELeave) CSimMbmsPacketContext(aPhone, aPacketService, aContextName);

	CleanupStack::PushL(packetContext);

	packetContext->ConstructL();

	CleanupStack::Pop();

	return packetContext;

	}

CSimMbmsPacketContext::CSimMbmsPacketContext(CSimPhone* aPhone, CSimPacketService* aPacketService, const TName& aContextName)

	:CSimPacketContext(aPhone,aPacketService,aContextName),iContextName(aContextName), iContextType(TPacketDataConfigBase::KConfigMBMS),

	iPhone(aPhone),iPacketService(aPacketService)

/**

* Trivial Constructor.  Initialises all the data members

*

* @param aPacketService Pointer to the Packet Service object (CSimPacketService)

* @param aContextName name  for this packet context

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: Entered constructor");

	iNotifyConfigMBMS.iNotifyPending = EFalse;

	iNotifyStatusChange.iNotifyPending = EFalse;

	}

void CSimMbmsPacketContext::ConstructL()

/**

* Second phase of the 2-phase constructor.

* Constructs all the member data and retrieves all the data from the config file specific to this class.

*

* @leave Leaves no memory or any data member does not construct for any reason.

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: Entered constructL function");

	CSimPacketContext::ConstructL();

	iMbmsSetConfigTimer = CSimTimer::NewL(iPhone);

	iMbmsContextTimer = CSimTimer::NewL(iPhone);

	iMbmsUpdateSessionTimer = CSimTimer::NewL(iPhone);

	iMbmsContextInitTimer = CSimTimer::NewL(iPhone);

	iMbmsGetSessionTimer = CSimTimer::NewL(iPhone);

	iMbmsContextConfigParams = new (ELeave) CArrayFixFlat<TMbmsConfigParams>(KNumberofConfigs);

	iSessionIdList = new (ELeave) CArrayFixFlat<TUint>(1);

	iMbmsSessionList = new CArrayPtrFlat<CPcktListReadAllAttempt>(1);

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

	/* Reading the MBMS Context configuration parameters */

	TUint count=CfgFile()->ItemCount(KMBMSBroadcastMonitorList); //< Retrieves the Count of MBMS related information

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

		{

		item = CfgFile()->Item(KMBMSBroadcastMonitorList,i); //< Retrieves the MBMS related information

		TInt mnc =0; 

		TInt mcc =0;

		TInt serviceId =0;

		TInt accessBearer=0;

		TInt serviceMode =0;

		TInt activateCode =0;

		TInt servicePriority=0;

		if(!item)

			break;

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

		if(ret!=KErrNone)

			{

			break;

			}

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

		if(ret!=KErrNone)

			{

			break;

			}

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

		if(ret!=KErrNone)

			{

			break;

			}

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

		if(ret!=KErrNone)

			{

			break;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,serviceMode);

		if(ret!=KErrNone)

			{

			break;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,activateCode);

		if(ret!=KErrNone)

			{

			break;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,servicePriority);

		if(ret!=KErrNone)

			{

			break;

			}

		TMbmsConfigParams mbmsConfigParams;

		mbmsConfigParams.iMCC = mcc;

		mbmsConfigParams.iMNC = mnc;

		mbmsConfigParams.iServiceId = serviceId;

		mbmsConfigParams.iAccessBearer = reinterpret_cast<TMbmsScope&> (accessBearer);

		mbmsConfigParams.iServiceMode = reinterpret_cast<TMbmsServiceMode&> (serviceMode);

		mbmsConfigParams.iServicePriority = reinterpret_cast<TMbmsServicePriority&> (servicePriority);

		mbmsConfigParams.iActivateCode = activateCode;

		iMbmsContextConfigParams->AppendL(mbmsConfigParams);

		}

	//iSessionIdList->AppendL(iNumOfSessionId);

	iSessionIdList->InsertL(0,iNumOfSessionId);

	/* Reading the list of session ids mentioned in the configuration file*/

	/*item = CfgFile()->Item(KMBMSSessionIdList,0); //< Retrieves the MBMS related information

	if(item != NULL)

		{

		TInt sessionId =0;

		TInt numOfSessions =0;

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

		iSessionIdList->AppendL(numOfSessions);

		for(TInt j=1;j<=numOfSessions;j++)

			{

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,j,sessionId);

			if(ret!=KErrNone)

				{

				break;

				}

			else

				{

				iSessionIdList->AppendL(sessionId);

				}

			}

		}*/

	}

void CSimMbmsPacketContext::Init()

/*

 * Initialisation function; Not used in the CSimMbmsPacketContext class.

 * but should be implemented as it is a pure virtual function of MTelObjectTSY. 

 */

	{}

CSimMbmsPacketContext::~CSimMbmsPacketContext()

/**

* Trivial Destructor

* Closes all CObject type objects and destroys all other objects created in the ConstructL()

*

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: Entered destructor");

	if (iMbmsSetConfigTimer != NULL)

		{

		delete iMbmsSetConfigTimer;

		}

	if(iMbmsContextTimer != NULL)

		{

		delete iMbmsContextTimer;

		}

	if(iMbmsUpdateSessionTimer != NULL)

		{	

		delete iMbmsUpdateSessionTimer;

		}

	if(iMbmsContextInitTimer)

		{

		delete iMbmsContextInitTimer;

		}

	if(iMbmsGetSessionTimer)

		{

		delete iMbmsGetSessionTimer;

		}

	if(iMbmsContextConfigParams !=NULL)

		{

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

		delete iMbmsContextConfigParams;

		}

	if(iSessionIdList != NULL)

		{

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

		delete iSessionIdList;

		}

	if(iMbmsSessionList)

		{

		iMbmsSessionList->ResetAndDestroy();

		}

	delete iMbmsSessionList;

	iPacketService->DecrementMbmsContextCount();

	}

CTelObject* CSimMbmsPacketContext::OpenNewObjectByNameL(const TDesC& /*aName*/)

/**

 * No Qos settings for the MBMS broadcast context 

 * This is not supported and if called, will leave.

 *

 * @param aName name of the QoS object to be opened

 * @leave Leaves with KErrNotSupported if the name is not as expected.

 * @ return NULL.

 */

	{	

	LOGPACKET1("Unexpected call to CSimMbmsPacketContext: OpenNewObjectByName");

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject* CSimMbmsPacketContext::OpenNewObjectL(TDes& /*aNewName*/)

/**

 * No Qos settings for the MBMS broadcast context 

 * This is not supported and if called, will leave.

 *

 * @param aNewName new name of the object created

 * @return NULL

 * @leave Leaves if out of memory.

 */

	{

	LOGPACKET1("Unexpected call to CSimMbmsPacketContext: OpenNewObjectL");

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject::TReqMode CSimMbmsPacketContext::ReqModeL(const TInt aIpc)

/**

* ReqModeL is called from the server's CTelObject::ReqAnalyserL

* in order to check the type of request it has.

* 

* @param aIpc the ipc number that identifies the client request

* @return CTelObject::TReqMode The request mode to be used for this request

* @leave Leaves if not supported by this tsy 

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: ReqModeL");

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

		case EPacketContextGetConfig:

		case EPacketContextSetConfig:

		case EPacketContextActivate:

		case EPacketContextDeactivate:

		case EPacketContextDelete:

		case EPacketContextGetStatus:

		case EPacketContextUpdateMbmsSessionList:

		case EPacketContextInitialiseContext:

		case EPacketGetMbmsSessionListPhase1:

		case EPacketGetMbmsSessionListPhase2:

		case EPacketContextGetLastErrorCause:

			break;

		case EPacketContextNotifyConfigChanged:

		case EPacketContextNotifyStatusChange:

		case EPacketContextNotifyDataTransferred:

			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

			break;

		default:

			LOGPACKET1("CSimMbmsPacketContext: ReqModeL error, unknown IPC");

			LOGPACKET1("CSimMbmsPacketContext: ReqModeL sending the request to CSimPacketContext");

			ret = CSimPacketContext::ReqModeL(aIpc);

			break;

		}

	return ret;

	}

TInt CSimMbmsPacketContext::RegisterNotification(const TInt aIpc)

/**

* RegisterNotification is called when the server recognises that this notification

* is being posted for the first time on this sub-session object.

* 

* It enables the TSY to "turn on" any regular notification messages that it may receive 

* from the phone

*

* @param aIpc the ipc number that identifies the client request

* @return err KErrNone if fine

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: RegisterNotification called");

	switch (aIpc)

		{

		case EPacketContextNotifyConfigChanged:

		case EPacketContextNotifyStatusChange:

		case EPacketContextNotifyDataTransferred:

			LOGPACKET1("CSimMbmsPacketContext: RegisterNotification");

			return KErrNone;

		default:

			// Unknown or invalid IPC

			LOGPACKET1("CSimMbmsPacketContext: Register error, unknown IPC");

			LOGPACKET1("CSimMbmsPacketContext: Register sending the request to CSimPacketContext");

			return CSimPacketContext::RegisterNotification(aIpc);

		}

	}

TInt CSimMbmsPacketContext::DeregisterNotification(const TInt aIpc)

/**

* DeregisterNotification is called when the server recognises that this notification

* will not be posted again because the last client to have a handle on this sub-session

* object has just closed the handle.

*

* It enables the TSY to "turn off" any regular notification messages that it may 

* receive from the phone

*

* @param aIpc the ipc number that identifies the client request

* @return err KErrNone if fine

*/

	{	

	LOGPACKET1("CSimMbmsPacketContext: DeregisterNotification called");

	switch (aIpc)

		{

		case EPacketContextNotifyConfigChanged:

		case EPacketContextNotifyStatusChange:

		case EPacketContextNotifyDataTransferred:

			LOGPACKET1("CSimMbmsPacketContext: DeregisterNotification");

			return KErrNone;

		default:

			// Unknown or invalid IPC

			LOGPACKET1("CSimMbmsPacketContext: Deregister error, unknown IPC");

			LOGPACKET1("CSimMbmsPacketContext: Deregister sending the request to CSimPacketContext");

			return CSimPacketContext::DeregisterNotification(aIpc);

		}

	}

TInt CSimMbmsPacketContext::NumberOfSlotsL(const TInt aIpc)

/**

* NumberOfSlotsL is called by the server when it is registering a new notification

* It enables the TSY to tell the server how many buffer slots to allocate for

* "repost immediately" notifications that may trigger before clients collect them

*

* @param aIpc the ipc number that identifies the client request

* @return err KErrNone if fine

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: NumberOfSlotsL called");

	TInt numberOfSlots=1;

	switch (aIpc)

		{

		case EPacketContextNotifyConfigChanged:

		case EPacketContextNotifyStatusChange:

		case EPacketContextNotifyDataTransferred:

			LOGPACKET1("CSimMbmsPacketContext: Registered with 5 slots");

			numberOfSlots=5;

			break;

		default:

			// Unknown or invalid IPC

			LOGPACKET1("CSimMbmsPacketContext: Number of Slots error, unknown IPC");

			LOGPACKET1("CSimMbmsPacketContext: Number of Slots: sending the request to CSimPacketContext");

			return CSimPacketContext::NumberOfSlotsL(aIpc);

		}  

	return numberOfSlots;

	}

TInt CSimMbmsPacketContext::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

							  const TDataPackage& aPackage)

/**

* ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request

* for the TSY to process.

* A request handle, request type and request data are passed to the TSY

* 

* @param aTsyReqHandle  The request handle for completing the request 

* @param aIpc Ipc representing the request

* @param aPackage any data associated with the request

* @return err KErrNone if request completes ok

*/

	{

	//< if this context has been deleted then the client can not do anything with it

	//< if the client wants to use this class, the client must open a new object by 

	//< name with the name for this context and this will reactivate the context.

	if(iDeleted && (aIpc != EPacketContextGetStatus))  

		{

		ReqCompleted(aTsyReqHandle,KErrNotReady);

		return KErrNone;

		}

	LOGPACKET1("CSimMbmsPacketContext: ExtFunc Called");

	TAny* dataPtr=aPackage.Ptr1();

	TAny* dataPtr2=aPackage.Ptr2();

	switch (aIpc)

		{

		case EPacketContextGetConfig:

			return GetConfig(aTsyReqHandle, aPackage.Des1n());

		case EPacketContextGetConfigCancel:

			return GetConfigCancel(aTsyReqHandle);

		case EPacketContextSetConfig:

			return SetConfig(aTsyReqHandle, aPackage.Des1n());

		case EPacketContextSetConfigCancel:

			return SetConfigCancel(aTsyReqHandle);

		case EPacketContextActivate:

			{	//< Ensures that theres only one context active as only one active context is 

			//<permitted at any one time

			if(iIsActive)

				{

				LOGPACKET1("Trying to activate an already activated context");

				ReqCompleted(aTsyReqHandle,KErrEtelCallAlreadyActive);

				return KErrNone;

				}

			else

				return Activate(aTsyReqHandle);

			}

		case EPacketContextActivateCancel:

			return ActivateCancel(aTsyReqHandle);

		case EPacketContextDeactivate:

			return Deactivate(aTsyReqHandle);

		case EPacketContextDeactivateCancel:

			return DeactivateCancel(aTsyReqHandle);

		case EPacketContextDelete:

			return Delete(aTsyReqHandle);

		case EPacketContextDeleteCancel:

			return DeleteCancel(aTsyReqHandle);

		case EPacketContextGetLastErrorCause:

			return GetLastErrorCause(aTsyReqHandle,

			REINTERPRET_CAST(TInt*, dataPtr));

		case EPacketContextNotifyConfigChanged:

			return NotifyConfigChanged(aTsyReqHandle, aPackage.Des1n());

		case EPacketContextNotifyConfigChangedCancel:

			return NotifyConfigChangedCancel(aTsyReqHandle);

		case EPacketContextNotifyStatusChange:

			return NotifyStatusChange(aTsyReqHandle,

					REINTERPRET_CAST(RPacketContext::TContextStatus*, dataPtr));

		case EPacketContextNotifyStatusChangeCancel:

			return NotifyStatusChangeCancel(aTsyReqHandle);

		case EPacketContextGetStatus:

			return GetStatus(aTsyReqHandle,

					REINTERPRET_CAST(RPacketContext::TContextStatus*, dataPtr));

		case EPacketContextUpdateMbmsSessionList:

					REINTERPRET_CAST(TMbmsAction*, dataPtr),

					REINTERPRET_CAST(TUint*, dataPtr2));	

		case EPacketContextInitialiseContext:

			return InitialiseContext(aTsyReqHandle, aPackage.Des1n());

		case EPacketContextInitialiseContextCancel:

			return InitialiseContextCancel(aTsyReqHandle);

		case EPacketGetMbmsSessionListPhase1:

			return GetMbmsSessionsPhase1(aTsyReqHandle, 

			REINTERPRET_CAST(TClientId*, dataPtr), 

			REINTERPRET_CAST(TInt*, dataPtr2));

		case EPacketGetMbmsSessionListPhase2:

			return GetMbmsSessionsPhase2(aTsyReqHandle, 

			REINTERPRET_CAST(TClientId*, dataPtr), aPackage.Des2n());		

		default:

			LOGPACKET1("CSimMbmsPacketContext: ExtFunc Unknown IPC");

			LOGPACKET1("CSimMbmsPacketContext: sending the request to CSimPacketContext::ExtFunc Unknown IPC");

			return CSimPacketContext::ExtFunc(aTsyReqHandle,aIpc,aPackage);

		}

	}

TInt CSimMbmsPacketContext::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

/**

* CancelService is called by the server when it is "cleaning-up" any still outstanding

* asynchronous requests before closing a client's sub-session.

* This will happen if a client closes its R-class handle without cancelling outstanding asynchronous requests.

* 

* @param aTsyReqHandle  The request handle for completing the request 

* @param aIpc Ipc representing the request

* @return err KErrNone if request completes ok

*/

	{

	LOGPACKET1("CSimMbmsPacketContext: - CancelService called");

	switch (aIpc)

		{

		case EPacketContextSetConfig:

			return SetConfigCancel(aTsyReqHandle);

		case EPacketContextGetConfig:

			return GetConfigCancel(aTsyReqHandle);

		case EPacketContextActivate:

			return ActivateCancel(aTsyReqHandle);

		case EPacketContextDeactivate:

			return DeactivateCancel(aTsyReqHandle);

		case EPacketContextDeleteCancel:

			return DeleteCancel(aTsyReqHandle);

		case EPacketContextNotifyConfigChanged:

			return NotifyConfigChangedCancel(aTsyReqHandle);

		case EPacketContextNotifyStatusChange: