// Copyright (c) 1997-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:

//

#include "pckttsy.h"

#include "testdef.h"

#include "etelpckt.h"

#include <et_clsvr.h>

#include "dpcktlog.h"

#include <pcktcs.h>

#include "coretsy.h"

/**************************************************************************/

//

//	CGprsDGprsTsy

//

/**************************************************************************/

CGprsDGprsTsy* CGprsDGprsTsy::NewL(CPhoneFactoryDummyBase* aFac)

/**

 * NewL method - Standard 2 phase constructor.

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: Entered NewL()"));

	CGprsDGprsTsy* subsession=new(ELeave) CGprsDGprsTsy(aFac);

	CleanupStack::PushL(subsession);

	subsession->ConstructL();

	CleanupStack::Pop();

	return subsession;

	}

void CGprsDGprsTsy::Init()

	{}

CGprsDGprsTsy::CGprsDGprsTsy(CPhoneFactoryDummyBase* aFac)

	:CSubSessionExtDummyBase(aFac),

	iActiveRequestObjects(_FOFF(CGprsDGprsTsy::CActiveListNode,iNext))

	{

	}

void CGprsDGprsTsy::ConstructL()

/**

 * ConstructL method.

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: Entered constructor"));

	iMutex.CreateGlobal(KNullDesC, EOwnerProcess);

	iGetMbmsMonitoredServices = new CArrayPtrFlat<CListReadAllAttempt>(1);

	iList=CPcktMbmsMonitoredServiceList::NewL();

	}

CGprsDGprsTsy::~CGprsDGprsTsy()

/**

 * Destructor.

 */

	{

	if(iGetMbmsMonitoredServices)

		{

		iGetMbmsMonitoredServices->ResetAndDestroy();

		delete iGetMbmsMonitoredServices;

		}

  	if(iList)

  		{

  		delete iList;

  		}

  	iMutex.Close();

	LOGTEXT(_L8("CGprsDGprsTsy: Entered destructor"));

	}

CTelObject* CGprsDGprsTsy::OpenNewObjectByNameL(const TDesC& aName)

/**

 * 	Only gprs context objects can be opened from gprs object(s).

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectByNameL()"));

	if (aName.Compare(_L("GPRS_CONTEXT"))==KErrNone)

		{

		return reinterpret_cast<CTelObject*>(CGprsContextDGprsTsy::NewL(FacPtr()));

		}

	return NULL;

	}

CTelObject* CGprsDGprsTsy::OpenNewObjectL(TDes& aNewName)

/**

 * A new context opened by a client will have its name allocated by the TSY.

 */

	{

	if(aNewName.Compare(KMBMSContextName) == KErrNone)

		{

		LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectL()"));

		aNewName.AppendNum(++iMbmsContextObjectCount);

		return CMbmsContextDMbmsTsy::NewL(this,FacPtr());

		}

	else

		{

		LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectL()"));

		aNewName.Append(_L("PACKET_CONTEXT"));

		aNewName.AppendNum(++iGprsContextObjectCount);

		return CGprsContextDGprsTsy::NewL(FacPtr());

		}

	}

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

/**

 * ReqModeL is called from the server's CTelObject::ReqAnalyserL in order to check the 

 * type of request it has.

 * The following are example request types for this dummy TSY. All TSYs do not need to 

 * have these request types but they have been given "sensible" values in this dummy TSY code.

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: ReqModeL() method"));

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

		case EPacketAttach:

		case EPacketDetach:

		case EPacketRejectActivationRequest:

		case EPacketSetMSClass:

		case EPacketSetAttachMode:

		case EPacketSetDefaultContextParams:

		case EPacketGetStatus:

		case EPacketGetContextInfo:

		case EPacketGetNtwkRegStatus:

		case EPacketGetMSClass:

		case EPacketGetStaticCaps:

		case EPacketGetDynamicCaps:

		case EPacketGetAttachMode:

		case EPacketGetDefaultContextParams:

		case EPacketEnumerateContexts:

		case EPacketSetPrefBearer:

		case EPacketGetPrefBearer:

		case EPacketGetCurrentReleaseMode:

		case EPacketEnumerateNifs:

		case EPacketGetNifInfo:

		case EPacketEnumerateContextsInNif:

		case EPacketGetContextNameInNif:

		case EPacketPrepareOpenSecondary:

		case EPacketDeactivateNIF:

		case EPacketGetMbmsNetworkServiceStatus:

		case EPacketUpdateMbmsMonitorServiceList:

		case EPacketGetMbmsMonitoredServicesPhase1:

		case EPacketGetMbmsMonitoredServicesPhase2:

		case EPacketEnumerateMbmsMonitorServiceList:

		case EPacketEnumerateMbmsActiveServiceList:

			break;

		case EPacketNotifyContextAdded:

		case EPacketNotifyContextAddedCancel:

		case EPacketNotifyStatusChange:

		case EPacketNotifyContextActivationRequested:

		case EPacketNotifyChangeOfNtwkRegStatus:

		case EPacketNotifyMSClassChange:

		case EPacketNotifyDynamicCapsChange:

		case EPacketNotifyReleaseModeChange:

		case EPacketNotifyAttachModeChange:

		case EPacketNotifyMbmsNetworkServiceStatusChange:

		case EPacketNotifyMbmsServiceAvailabilityChange:

			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	return ret;

	}

TInt CGprsDGprsTsy::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.

 */

	{

	switch (aIpc)

		{

		case EPacketNotifyContextAdded:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Context added"));

			return KErrNone;

		case EPacketNotifyStatusChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Gprs status change"));

			return KErrNone;

		case EPacketNotifyContextActivationRequested:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Context activation requested"));

			return KErrNone;

		case EPacketNotifyChangeOfNtwkRegStatus:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network registration status change"));

			return KErrNone;

		case EPacketNotifyMSClassChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - MS class change"));

			return KErrNone;

		case EPacketNotifyDynamicCapsChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Dynamic capabilities change"));

			return KErrNone;

		case EPacketNotifyReleaseModeChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Release mode change"));

			return KErrNone;

		case EPacketNotifyAttachModeChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network attach mode change"));

			return KErrNone;

		case EPacketNotifyMbmsNetworkServiceStatusChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Mbms Service Status change"));

			return KErrNone;

		case EPacketNotifyMbmsServiceAvailabilityChange:

			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Mbms Service change"));

			return KErrNone;

		default:

			// Unknown or invalid IPC

			LOGTEXT(_L8("CGprsDGprsTsy: Register error, unknown IPC"));

			return KErrNotSupported;

		}

	}

TInt CGprsDGprsTsy::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.

 */

	{

	switch (aIpc)

		{

		case EPacketNotifyContextAdded:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Context added"));

			return KErrNone;

		case EPacketNotifyStatusChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Gprs status change"));

			return KErrNone;

		case EPacketNotifyContextActivationRequested:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Context activation requested"));

			return KErrNone;

		case EPacketNotifyChangeOfNtwkRegStatus:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network registration status change"));

			return KErrNone;

		case EPacketNotifyMSClassChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - MS class change"));

			return KErrNone;

		case EPacketNotifyDynamicCapsChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Dynamic capabilities change"));

			return KErrNone;

		case EPacketNotifyReleaseModeChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network release mode change"));

			return KErrNone;

		case EPacketNotifyAttachModeChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network attach mode change"));

			return KErrNone;

		case EPacketNotifyMbmsNetworkServiceStatusChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network Mbms Service Status change"));

			return KErrNone;

		case EPacketNotifyMbmsServiceAvailabilityChange:

			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network Mbms Service change"));

			return KErrNone;

		default:

			// Unknown or invalid IPC

			LOGTEXT(_L8("CGprsDGprsTsy: Deregister error, unknown IPC"));

			return KErrNotSupported;

		}

	}

TInt CGprsDGprsTsy::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.

 */

	{

	TInt numberOfSlots=1;

	switch (aIpc)

		{

		case EPacketNotifyStatusChange:

		case EPacketNotifyDynamicCapsChange:

		case EPacketNotifyMbmsNetworkServiceStatusChange:

			LOGTEXT(_L8("CGprsDGprsTsy: Registered with 10 slots"));

			numberOfSlots=10;

			break;

		case EPacketNotifyContextAdded:

		case EPacketNotifyContextActivationRequested:

		case EPacketNotifyChangeOfNtwkRegStatus:

		case EPacketNotifyMSClassChange:

		case EPacketNotifyReleaseModeChange:

		case EPacketNotifyAttachModeChange:

		case EPacketNotifyMbmsServiceAvailabilityChange:

			LOGTEXT(_L8("CGprsDGprsTsy: Registered with 2 slots"));

			numberOfSlots=2;

			break;

		default:

			// Unknown or invalid IPC

			LOGTEXT(_L8("CGprsDGprsTsy: Number of Slots error, unknown IPC"));

			User::Leave(KErrNotSupported);

			break;

		}  

	return numberOfSlots;

	}

TInt CGprsDGprsTsy::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.

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: ExtFunc() method"));

	TAny* dataPtr=aPackage.Ptr1();

	TAny* dataPtr2=aPackage.Ptr2();

	switch (aIpc)

		{

		case EPacketNotifyContextAdded:

			return NotifyContextAdded(aTsyReqHandle, aPackage.Des1u());

		case EPacketGetStatus:

			return GetStatus(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

		case EPacketNotifyStatusChange:

			return NotifyStatusChange(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

		case EPacketNotifyContextActivationRequested:

			return NotifyContextActivationRequested(aTsyReqHandle,

				REINTERPRET_CAST(TPacketDataConfigBase*, dataPtr));

		case EPacketEnumerateContexts:

			return EnumerateContexts(aTsyReqHandle,

			REINTERPRET_CAST(TInt*, dataPtr),

			REINTERPRET_CAST(TInt*, dataPtr2));

		case EPacketGetContextInfo:

			return GetContextInfo(aTsyReqHandle,

			REINTERPRET_CAST(TInt*, dataPtr),

			REINTERPRET_CAST(RPacketService::TContextInfo*, dataPtr2));

		case EPacketGetNtwkRegStatus:

			return GetNtwkRegStatus(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

		case EPacketNotifyChangeOfNtwkRegStatus:

			return NotifyChangeOfNtwkRegStatus(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

		case EPacketGetMSClass:

			return GetMSClass(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr),

			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr2));

		case EPacketSetMSClass:

			return SetMSClass(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

		case EPacketNotifyMSClassChange:

			return NotifyMSClassChange(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

		case EPacketGetStaticCaps:

			return GetStaticCaps(aTsyReqHandle, 

				REINTERPRET_CAST(TUint*, dataPtr),

				REINTERPRET_CAST(RPacketContext::TProtocolType*, dataPtr2));

		case EPacketGetDynamicCaps:

			return GetDynamicCaps(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

		case EPacketNotifyDynamicCapsChange:

			return NotifyDynamicCapsChange(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

		case EPacketSetAttachMode:

			return SetAttachMode(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

		case EPacketGetAttachMode:

			return GetAttachMode(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

		case EPacketNotifyAttachModeChange:

			return NotifyAttachModeChange(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

		case EPacketNotifyContextAddedCancel:

			return NotifyContextAddedCancel(aTsyReqHandle);

		case EPacketAttach:

			return Attach(aTsyReqHandle);

		case EPacketAttachCancel:

			return AttachCancel(aTsyReqHandle);

		case EPacketDetach:

			return Detach(aTsyReqHandle);

		case EPacketDetachCancel:

			return DetachCancel(aTsyReqHandle);

		case EPacketNotifyStatusChangeCancel:

			return NotifyStatusChangeCancel(aTsyReqHandle);

		case EPacketNotifyContextActivationRequestedCancel:

			return NotifyContextActivationRequestedCancel(aTsyReqHandle);

		case EPacketRejectActivationRequest:

			return RejectActivationRequest(aTsyReqHandle);

		case EPacketRejectActivationRequestCancel:

			return RejectActivationRequestCancel(aTsyReqHandle);

		case EPacketGetContextInfoCancel:

			return GetContextInfoCancel(aTsyReqHandle);

		case EPacketNotifyChangeOfNtwkRegStatusCancel:

			return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle);

		case EPacketGetMSClassCancel:

			return GetMSClassCancel(aTsyReqHandle);

		case EPacketSetMSClassCancel:

			return SetMSClassCancel(aTsyReqHandle);

		case EPacketNotifyMSClassChangeCancel:

			return NotifyMSClassChangeCancel(aTsyReqHandle);

		case EPacketSetPrefBearer:

			return SetPreferredBearer(aTsyReqHandle, 

				REINTERPRET_CAST(RPacketService::TPreferredBearer*, dataPtr));

		case EPacketGetPrefBearer:

			return GetPreferredBearer(aTsyReqHandle,

				REINTERPRET_CAST(RPacketService::TPreferredBearer*, dataPtr));

		case EPacketNotifyDynamicCapsChangeCancel:

			return NotifyDynamicCapsChangeCancel(aTsyReqHandle);

		case EPacketSetDefaultContextParams:

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

		case EPacketGetDefaultContextParams:

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

		case EPacketGetCurrentReleaseMode:

			return GetCurrentReleaseMode(aTsyReqHandle,

				REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr));

		case EPacketNotifyReleaseModeChange:

			return NotifyReleaseModeChange(aTsyReqHandle,

			REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr));

		case EPacketEnumerateNifs:

			return EnumerateNifs(aTsyReqHandle,

				REINTERPRET_CAST(TInt*, dataPtr));

		case EPacketEnumerateNifsCancel:

			return EnumerateNifsCancel(aTsyReqHandle);

		case EPacketGetNifInfo:

			return GetNifInfo(aTsyReqHandle,

				REINTERPRET_CAST(TInt*, dataPtr),

				aPackage.Des2n());

		case EPacketGetNifInfoCancel:

			return GetNifInfoCancel(aTsyReqHandle);	

		case EPacketEnumerateContextsInNif:

			return EnumerateContextsInNif(aTsyReqHandle,

				aPackage.Des2u(),

				REINTERPRET_CAST(TInt*, dataPtr));

		case EPacketEnumerateContextsInNifCancel:

			return EnumerateContextsInNifCancel(aTsyReqHandle);

		case EPacketGetContextNameInNif:

			return GetContextNameInNif(aTsyReqHandle,

				REINTERPRET_CAST(RPacketService::TContextNameInNif*, dataPtr),

				aPackage.Des2u());

		case EPacketGetContextNameInNifCancel:

			return GetContextNameInNifCancel(aTsyReqHandle);

		case EPacketPrepareOpenSecondary:

			return PrepareOpenSecondary(aTsyReqHandle, aPackage.Des1u());

		case EPacketDeactivateNIF:

			return DeactivateNIF(aTsyReqHandle, REINTERPRET_CAST(TDesC*,dataPtr));

		case EPacketNotifyMbmsNetworkServiceStatusChange:

			return NotifyMbmsNetworkServiceStatusChange(aTsyReqHandle,

			reinterpret_cast<TMbmsNetworkServiceStatus*>(dataPtr));

		case EPacketGetMbmsNetworkServiceStatus:

			return GetMbmsNetworkServiceStatus(aTsyReqHandle,

			reinterpret_cast<TBool*>(dataPtr),

			reinterpret_cast<TMbmsNetworkServiceStatus*>(dataPtr2));

		case EPacketNotifyMbmsServiceAvailabilityChange:

			return NotifyMbmsServiceAvailabilityChange(aTsyReqHandle);

		case EPacketUpdateMbmsMonitorServiceList:

			if(dataPtr2)

				{

				return UpdateMbmsMonitorServiceListL(aTsyReqHandle,

				reinterpret_cast<TMbmsAction*>(dataPtr),aPackage.Des2n());	

				}

			else

				{

				return UpdateMbmsMonitorServiceListL(aTsyReqHandle,

				reinterpret_cast<TMbmsAction*>(dataPtr));

				}

		case EPacketGetMbmsMonitoredServicesPhase1:

			return GetMbmsMonitoredServicesPhase1(aTsyReqHandle, 

			reinterpret_cast<TClientId*>(dataPtr), 

			reinterpret_cast<TUint*>(dataPtr2));

		case EPacketGetMbmsMonitoredServicesPhase2:

			return GetMbmsMonitoredServicesPhase2(aTsyReqHandle, 

			reinterpret_cast<TClientId*>(dataPtr),aPackage.Des2n());

		case EPacketEnumerateMbmsMonitorServiceList:

			return EnumerateMbmsMonitorServiceList(aTsyReqHandle, 

			reinterpret_cast<TInt*>(dataPtr),

			reinterpret_cast<TInt*>(dataPtr2));

		case EPacketEnumerateMbmsActiveServiceList:

			return EnumerateMbmsActiveServiceList(aTsyReqHandle, 

			reinterpret_cast<TInt*>(dataPtr),

			reinterpret_cast<TInt*>(dataPtr2));

		default:

			return KErrNotSupported;

		}

	}

TInt CGprsDGprsTsy::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.

 */

	{

	LOGTEXT(_L8("CGprsDGprsTsy: - CancelService called"));

	switch (aIpc)

		{

		case EPacketNotifyContextAdded:

			return NotifyContextAddedCancel(aTsyReqHandle);

		case EPacketAttach:

			return AttachCancel(aTsyReqHandle);

		case EPacketDetach:

			return DetachCancel(aTsyReqHandle);

		case EPacketNotifyStatusChange:

			return NotifyStatusChangeCancel(aTsyReqHandle);

		case EPacketNotifyContextActivationRequested:

			return NotifyContextActivationRequestedCancel(aTsyReqHandle);

		case EPacketRejectActivationRequest:

			return RejectActivationRequestCancel(aTsyReqHandle);

		case EPacketGetContextInfo:

			return GetContextInfoCancel(aTsyReqHandle);

		case EPacketNotifyChangeOfNtwkRegStatus:

			return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle);

		case EPacketGetMSClass:

			return GetMSClassCancel(aTsyReqHandle);

		case EPacketSetMSClass:

			return SetMSClassCancel(aTsyReqHandle);