--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelpacketdata/dtsy/pckttsy.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,2492 @@
+// 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);
+ case EPacketNotifyMSClassChange:
+ return NotifyMSClassChangeCancel(aTsyReqHandle);
+ case EPacketNotifyDynamicCapsChange:
+ return NotifyDynamicCapsChangeCancel(aTsyReqHandle);
+ case EPacketSetPrefBearer:
+ return SetPreferredBearerCancel(aTsyReqHandle);
+ case EPacketGetPrefBearer:
+ return GetPreferredBearerCancel(aTsyReqHandle);
+ case EPacketSetAttachMode:
+ return SetAttachModeCancel(aTsyReqHandle);
+ case EPacketGetAttachMode:
+ return GetAttachModeCancel(aTsyReqHandle);
+ case EPacketNotifyAttachModeChange:
+ return NotifyAttachModeChangeCancel(aTsyReqHandle);
+ case EPacketSetDefaultContextParams:
+ return SetDefaultContextParamsCancel(aTsyReqHandle);
+ case EPacketGetDefaultContextParams:
+ return GetDefaultContextParamsCancel(aTsyReqHandle);
+ case EPacketGetCurrentReleaseMode:
+ return GetCurrentReleaseModeCancel(aTsyReqHandle);
+ case EPacketNotifyReleaseModeChange:
+ return NotifyReleaseModeChangeCancel(aTsyReqHandle);
+ case EPacketEnumerateNifs:
+ return EnumerateNifsCancel(aTsyReqHandle);
+ case EPacketGetNifInfo:
+ return GetNifInfoCancel(aTsyReqHandle);
+ case EPacketEnumerateContextsInNif:
+ return EnumerateContextsInNifCancel(aTsyReqHandle);
+ case EPacketGetContextNameInNif:
+ return GetContextNameInNifCancel(aTsyReqHandle);
+ case EPacketDeactivateNIF:
+ return DeactivateNIFCancel(aTsyReqHandle);
+ case EPacketNotifyMbmsNetworkServiceStatusChange:
+ return NotifyMbmsNetworkServiceStatusChangeCancel(aTsyReqHandle);
+ case EPacketGetMbmsNetworkServiceStatus:
+ return GetMbmsNetworkServiceStatusCancel(aTsyReqHandle);
+ case EPacketNotifyMbmsServiceAvailabilityChange:
+ return NotifyMbmsServiceAvailabilityChangeCancel(aTsyReqHandle);
+ case EPacketUpdateMbmsMonitorServiceList:
+ return UpdateMbmsMonitorServiceListCancel(aTsyReqHandle);
+ case EPacketGetMbmsMonitoredServicesPhase1:
+ case EPacketGetMbmsMonitoredServicesPhase2:
+ return GetMbmsMonitoredServicesCancel(aTsyReqHandle);
+ case EPacketEnumerateMbmsMonitorServiceList:
+ return EnumerateMbmsMonitorServiceListCancel(aTsyReqHandle);
+ case EPacketEnumerateMbmsActiveServiceList:
+ return EnumerateMbmsActiveServiceListCancel(aTsyReqHandle);
+ default:
+ return KErrGeneral;
+ }
+ }
+
+
+/***********************************************************************************/
+//
+// The following methods are called from ExtFunc and/or CancelService.
+// Each of these will process a TSY request or cancel a TSY request
+// Here, example values are returned or checked within this dummy TSY in order to ensure
+// that the integrity of the data passed to/from client is maintained
+//
+/***********************************************************************************/
+TInt CGprsDGprsTsy::NotifyContextAdded(const TTsyReqHandle aTsyReqHandle, TDes* aContextId)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyContextAdded++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextAdded called"));
+ *aContextId = DPCKTTSY_CONTEXT_ID;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyContextAddedCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextAddedCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::Attach(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::Attach called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iAttach++)
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::AttachCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::AttachCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::Detach(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::Detach called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iDetach++)
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::DetachCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy:: called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aGprsStatus)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::DetachCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ *aGprsStatus = DPCKTTSY_PACKET_STATUS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aGprsStatus)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyStatusChange++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyStatusChange called"));
+ *aGprsStatus = DPCKTTSY_PACKET_STATUS2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyStatusChangeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyContextActivationRequested(const TTsyReqHandle aTsyReqHandle, TPacketDataConfigBase* aConfig)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyContextActivationRequested++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextActivationRequested called"));
+
+ if (aConfig->ExtensionId() == TPacketDataConfigBase::KConfigGPRS)
+ {
+ RPacketContext::TContextConfigGPRS* aGprsConfig = (RPacketContext::TContextConfigGPRS*) aConfig;
+ aGprsConfig->iPdpType = DPCKTTSY_PDP_TYPE1;
+ aGprsConfig->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ aGprsConfig->iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ aGprsConfig->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ aGprsConfig->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ aGprsConfig->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ aGprsConfig->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ aGprsConfig->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else if (aConfig->ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ RPacketContext::TContextConfigR99_R4* aR99Config = (RPacketContext::TContextConfigR99_R4*) aConfig;
+ aR99Config->iPdpType = DPCKTTSY_PDP_TYPE1;
+ aR99Config->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ aR99Config->iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ aR99Config->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ aR99Config->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ aR99Config->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ aR99Config->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ aR99Config->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ aR99Config->iPFI = DPCKTTSY_PFICONTEXT_SIG;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else if (aConfig->ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ RPacketContext::TContextConfig_R5* aR5Config = (RPacketContext::TContextConfig_R5*) aConfig;
+ aR5Config->iPdpType = DPCKTTSY_PDP_TYPE1;
+ aR5Config->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ aR5Config->iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ aR5Config->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ aR5Config->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ aR5Config->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ aR5Config->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ aR5Config->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ aR5Config->iPFI = DPCKTTSY_PFICONTEXT_SIG;
+ aR5Config->iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV42;
+ aR5Config->iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC1144;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyContextActivationRequestedCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextActivationRequestedCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::RejectActivationRequest(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::RejectActivationRequest called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iRejectActivationRequest++)
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::RejectActivationRequestCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::RejectActivationRequestCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateContexts(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateContexts called"));
+ User::After(300000); // wait to have KRequestPending
+ *aCount = DPCKTTSY_NUMBER_OF_CONTEXTS;
+ *aMaxAllowed = DPCKTTSY_MAX_NUMBER_OF_CONTEXTS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetContextInfo(const TTsyReqHandle aTsyReqHandle, TInt* aIndex,RPacketService::TContextInfo* aInfo)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetContextInfo called"));
+
+ User::After(300000); // wait to have KRequestPending
+ switch (*aIndex)
+ {
+ case 0:
+ if(!iGetContextInfo++)
+ {
+ aInfo->iName=DPCKTTSY_CONTEXT_INFO_NAME0;
+ aInfo->iStatus=DPCKTTSY_CONTEXT_INFO_STATUS0;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ break;
+ case 1:
+ aInfo->iName=DPCKTTSY_CONTEXT_INFO_NAME1;
+ aInfo->iStatus=DPCKTTSY_CONTEXT_INFO_STATUS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ default:
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ break;
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetContextInfoCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetContextInfoCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetNtwkRegStatus called"));
+ User::After(300000); // wait to have KRequestPending
+ *aRegistrationStatus = DPCKTTSY_REGISTRATION_STATUS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyChangeOfNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyChangeOfNtwkRegStatus++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyChangeOfNtwkRegStatus called"));
+ *aRegistrationStatus = DPCKTTSY_REGISTRATION_STATUS2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyChangeOfNtwkRegStatusCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyChangeOfNtwkRegStatusCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aCurrentClass, RPacketService::TMSClass* aMaxClass)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy:: GetMSClass called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iGetMSClass++)
+ {
+ *aCurrentClass=DPCKTTSY_CURRENT_MS_CLASS;
+ *aMaxClass=DPCKTTSY_MAX_MS_CLASS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMSClassCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetMSClass called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aClass)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetMSClass called"));
+ User::After(300000); // wait to have KRequestPending
+ if (*aClass!=DPCKTTSY_SET_MS_CLASS)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ {
+ if(!iSetMSClass++)
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetMSClassCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetMSClassCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyMSClassChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aNewClass)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyMSClassChange++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMSClassChange called"));
+ *aNewClass = DPCKTTSY_NEW_MS_CLASS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyMSClassChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMSClassChangeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetStaticCaps(const TTsyReqHandle aTsyReqHandle, TUint* aCaps,RPacketContext::TProtocolType* aPdpType)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetStaticCaps called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if (*aPdpType!=DPCKTTSY_PDP_TYPE1)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ *aCaps = DPCKTTSY_MISC_CAPS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetDynamicCaps(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetDynamicCaps called"));
+ User::After(300000); // wait to have KRequestPending
+ *aCaps = DPCKTTSY_DYNAMIC_CAPS1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyDynamicCapsChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyDynamicCapsChange++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyDynamicCapsChange called"));
+ *aCaps = DPCKTTSY_DYNAMIC_CAPS2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyDynamicCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyDynamicCapsChangeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)
+/**
+ * SetAttachMode method - Sets the Attach mode for the context.
+ * A synchronous and asynchronous variant of this method is now supported - Change
+ * Request: NDOE-58VF4Q. In the test code, the synchronous method is called first.
+ * Note that the synchronous variant is deprecated.
+ * In the switch statement, cases 0 and 1 implement the synchronous call, while cases 2 and
+ * 3 implement the asynchronous call.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetAttachMode called"));
+
+ User::After(300000); // wait to have KRequestPending
+ switch (iSetAttachMode++)
+ {
+ case 0:
+ case 1:
+ if (*aMode!=DPCKTTSY_ATTACH_MODE1)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ case 2:
+ if (*aMode!=DPCKTTSY_ATTACH_MODE2)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ case 3:
+ if (*aMode!=DPCKTTSY_ATTACH_MODE2)
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ default:
+ LOGTEXT(_L8("CGprsDGprsTsy::SetAttachMode - Error in switch statement"));
+ break;
+ } // switch
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetAttachModeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetAttachModeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)
+/**
+ * GetAttachMode method - Gets the Attach mode for the context.
+ * A synchronous and asynchronous variant of this method is now supported - Change
+ * Request: NDOE-58VF4Q. In the test code, the synchronous method is called first.
+ * Note that the synchronous variant is deprecated.
+ * In the switch statement, cases 0 and 1 implement the synchronous call, while cases 2 and
+ * 3 implement the asynchronous call.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetAttachMode called"));
+
+ User::After(300000); // wait to have KRequestPending
+ switch (iGetAttachMode++)
+ {
+ case 0:
+ case 1:
+ *aMode = DPCKTTSY_ATTACH_MODE2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ case 2:
+ *aMode = DPCKTTSY_ATTACH_MODE1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ case 3:
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ default:
+ LOGTEXT(_L8("CGprsDGprsTsy::GetAttachMode - Error in switch statement"));
+ break;
+ } // switch
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetAttachModeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetAttachModeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyAttachModeChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyAttachModeChange++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyAttachModeChange called"));
+ *aMode = DPCKTTSY_ATTACH_MODE2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyAttachModeChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyAttachModeChange called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetDefaultContextParams(const TTsyReqHandle aTsyReqHandle, const TDesC8* aPckg)
+/**
+ * SetDefaultContextParams method - Sets the Default context parameters.
+ * A synchronous and asynchronous variant of this method is now supported - Change
+ * Request: NDOE-58VF4Q. In the test code, the synchronous method is called first.
+ * Note that the synchronous variant is deprecated.
+ * In the switch statement, cases 0 and 1 implement the synchronous call, while cases 2 and
+ * 3 implement the asynchronous call.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetDefaultContextParams called"));
+
+ User::After(300000); // wait to have KRequestPending
+ TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aPckg;
+ TPacketDataConfigBase& configBaseV1 = (*configBase)();
+
+ switch (iSetDefaultContextParams++)
+ {
+ case 0:
+ case 1:
+ if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
+ {
+ TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;
+ RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT1)||
+ (defaultContextV1.iAnonymousAccessReqd != DPCKTTSY_ANONYMOUS_ACCESS1)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS1)||
+ (defaultContextV1.iPdpCompression != DPCKTTSY_COMPRESSION1)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE1) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_REQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aPckg;
+ RPacketContext::TContextConfigR99_R4& defaultContextV1 = (*contextConfigR99Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT1)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS1)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE1) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_REQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SMS))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aPckg;
+ RPacketContext::TContextConfig_R5& defaultContextV1 = (*contextConfigR5Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT1)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS1)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE1) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_REQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SMS) ||
+ (defaultContextV1.iPdpDataCompression != DPCKTTSY_DATACOMPRESSION_EV42) ||
+ (defaultContextV1.iPdpHeaderCompression != DPCKTTSY_HEADERCOMPRESSION_ERFC1144))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ case 2:
+ case 4:
+ if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
+ {
+ TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;
+ RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iAnonymousAccessReqd != DPCKTTSY_ANONYMOUS_ACCESS2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpCompression != DPCKTTSY_COMPRESSION2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME2) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD2) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE2_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aPckg;
+ RPacketContext::TContextConfigR99_R4& defaultContextV1 = (*contextConfigR99Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SIG))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aPckg;
+ RPacketContext::TContextConfig_R5& defaultContextV1 = (*contextConfigR5Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SIG) ||
+ (defaultContextV1.iPdpDataCompression != DPCKTTSY_DATACOMPRESSION_EV44) ||
+ (defaultContextV1.iPdpHeaderCompression != DPCKTTSY_HEADERCOMPRESSION_ERFC2507))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ case 3:
+ if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
+ {
+ TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;
+ RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iAnonymousAccessReqd != DPCKTTSY_ANONYMOUS_ACCESS2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpCompression != DPCKTTSY_COMPRESSION2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME2) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD2) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE2_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aPckg;
+ RPacketContext::TContextConfigR99_R4& defaultContextV1 = (*contextConfigR99Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SIG))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aPckg;
+ RPacketContext::TContextConfig_R5& defaultContextV1 = (*contextConfigR5Pckg)();
+
+ if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT2)||
+ (defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS2)||
+ (defaultContextV1.iPdpType != DPCKTTSY_PDP_TYPE2) ||
+ (defaultContextV1.iUseEdge != DPCKTTSY_EGPRS_NOTREQUIRED) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1) ||
+ (defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0) ||
+ (defaultContextV1.iNWIContext != DPCKTTSY_NWICONTEXT_TRUE) ||
+ (defaultContextV1.iPFI != DPCKTTSY_PFICONTEXT_SIG) ||
+ (defaultContextV1.iPdpDataCompression != DPCKTTSY_DATACOMPRESSION_EV44) ||
+ (defaultContextV1.iPdpHeaderCompression != DPCKTTSY_HEADERCOMPRESSION_ERFC2507))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ }
+ default:
+ LOGTEXT(_L8("CGprsDGprsTsy::SetDefaultContextParams - Error in switch statement"));
+ break;
+ } // switch
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetDefaultContextParamsCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetDefaultContextParamsCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetDefaultContextParams(const TTsyReqHandle aTsyReqHandle, TDes8* aPckg)
+/**
+ * GetDefaultContextParams method - Gets the default context parameters.
+ * A synchronous and asynchronous variant of this method is now supported - Change
+ * Request: NDOE-58VF4Q. In the test code, the synchronous method is called first.
+ * Note that the synchronous variant is deprecated.
+ * In the switch statement, cases 0 and 1 implement the synchronous call, while cases 2 and
+ * 3 implement the asynchronous call.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetDefaultContextParams called"));
+
+ User::After(300000); // wait to have KRequestPending
+ TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aPckg;
+ TPacketDataConfigBase& configBaseV1 = (*configBase)();
+
+ switch (iGetDefaultContextParams++)
+ {
+ case 0:
+ case 1:
+ if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
+ {
+ TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;
+ RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT2;
+ defaultContextV1.iAnonymousAccessReqd = DPCKTTSY_ANONYMOUS_ACCESS2;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;
+ defaultContextV1.iPdpCompression = DPCKTTSY_COMPRESSION2;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE2;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aPckg;
+ RPacketContext::TContextConfigR99_R4& defaultContextV1 = (*contextConfigR99Pckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT2;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE2;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ defaultContextV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ defaultContextV1.iPFI = DPCKTTSY_PFICONTEXT_SMS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aPckg;
+ RPacketContext::TContextConfig_R5& defaultContextV1 = (*contextConfigR5Pckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT2;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE2;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ defaultContextV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ defaultContextV1.iPFI = DPCKTTSY_PFICONTEXT_SMS;
+ defaultContextV1.iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV44;
+ defaultContextV1.iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC2507;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ }
+ case 2:
+ case 4:
+ if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)
+ {
+ TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;
+ RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ defaultContextV1.iAnonymousAccessReqd = DPCKTTSY_ANONYMOUS_ACCESS1;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ defaultContextV1.iPdpCompression = DPCKTTSY_COMPRESSION1;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE1;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ defaultContextV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)
+ {
+ TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aPckg;
+ RPacketContext::TContextConfigR99_R4& defaultContextV1 = (*contextConfigR99Pckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE1;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5)
+ {
+ TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aPckg;
+ RPacketContext::TContextConfig_R5& defaultContextV1 = (*contextConfigR5Pckg)();
+
+ defaultContextV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+ defaultContextV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+ defaultContextV1.iPdpType = DPCKTTSY_PDP_TYPE1;
+ defaultContextV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;
+ defaultContextV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;
+ defaultContextV1.iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV42;
+ defaultContextV1.iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC1144;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ case 3:
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ break;
+ default:
+ LOGTEXT(_L8("CGprsDGprsTsy::GetDefaultContextParams - Error in switch statement"));
+ break;
+ } // switch
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetDefaultContextParamsCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetDefaultContextParamsCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetPreferredBearer(const TTsyReqHandle aTsyReqHandle, RPacketService::TPreferredBearer* aBearer)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetPreferredBearer called"));
+ User::After(300000); // wait to have KRequestPending
+ switch(iGetPrefBearer++)
+ {
+ case 0:
+ *aBearer = RPacketService::EBearerPacketSwitched;
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ break;
+ case 1:
+ *aBearer = RPacketService::EBearerCircuitSwitched;
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ break;
+ default:
+ break;
+ }
+ iTsyAsyncReqHandle=aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetPreferredBearerCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetPreferredBearerCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetPreferredBearer(const TTsyReqHandle aTsyReqHandle, RPacketService::TPreferredBearer* aBearer)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetPreferredBearer called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iSetPrefBearer++)
+ {
+ if (*aBearer == RPacketService::EBearerPacketSwitched)
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ else
+ ReqCompleted(aTsyReqHandle, KErrCorrupt);
+ }
+ iTsyAsyncReqHandle=aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::SetPreferredBearerCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::SetPreferredBearerCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetCurrentReleaseMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TPacketReleaseMode* aMode)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetCurrentReleaseMode called"));
+ User::After(300000); // wait to have KRequestPending
+ if(!iGetCurrentReleaseMode++)
+ {
+ *aMode = DPCKTTSY_NETWORK_MODE1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetCurrentReleaseModeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetCurrentReleaseModeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyReleaseModeChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TPacketReleaseMode* aMode)
+ {
+ User::After(300000); // wait to have KRequestPending
+ if (!iNotifyReleaseModeChange++)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyReleaseModeChange called"));
+ *aMode = DPCKTTSY_NETWORK_MODE2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyReleaseModeChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyReleaseModeChangeCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateNifs(const TTsyReqHandle aTsyReqHandle, TInt* aCount)
+/**
+ * EnumerateNifs method - Set the number of NIFs.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateNifs called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if (!iEnumerateNifs++)
+ {
+ *aCount = DPCKTTSY_NUMBER_OF_NIFS;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateNifsCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * EnumerateNifsCancel - Cancels an asynchronous EnumerateNifs request
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateNifsCancel called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+
+TInt CGprsDGprsTsy::GetNifInfo(const TTsyReqHandle aTsyReqHandle,TInt* aIndex, TDes8* aNifInfoV2)
+/**
+ * GetNifInfo method - sets Nif information depending on the index argument passed in.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetNifInfo called"));
+
+ User::After(300000); // wait to have KRequestPending
+ RPacketService::TNifInfoV2Pckg* nifInfoV2Pckg = (RPacketService::TNifInfoV2Pckg*)aNifInfoV2;
+ RPacketService::TNifInfoV2& nifInfoV2 = (*nifInfoV2Pckg)();
+
+ if(!iGetNifInfo++)
+ {
+ switch (*aIndex)
+ {
+ case 1:
+ nifInfoV2.iContextName=DPCKTTSY_NIF_CONTEXT1;
+ nifInfoV2.iNumberOfContexts=DPCKTTSY_NUMBER_OF_CONTEXTS_IN_NIF1;
+ nifInfoV2.iNifStatus=DPCKTTSY_CONTEXT_INFO_STATUS0;
+ nifInfoV2.iPdpAddress=DPCKTTSY_PDP_ADDRESS1;
+ nifInfoV2.iContextType=DPCKTTSY_INTERNAL_CONTEXT;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ case 2:
+ nifInfoV2.iContextName=DPCKTTSY_NIF_CONTEXT2;
+ nifInfoV2.iNumberOfContexts=DPCKTTSY_NUMBER_OF_CONTEXTS_IN_NIF2;
+ nifInfoV2.iNifStatus=DPCKTTSY_CONTEXT_INFO_STATUS1;
+ nifInfoV2.iPdpAddress=DPCKTTSY_PDP_ADDRESS2;
+ nifInfoV2.iContextType=DPCKTTSY_EXTERNAL_CONTEXT;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ break;
+ default:
+ ReqCompleted(aTsyReqHandle,KErrArgument);
+ break;
+ } // switch
+ } // if
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetNifInfoCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * GetNifInfoCancel - Cancels an asynchronous GetNifInfo request
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetNifInfoCancel called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateContextsInNif(const TTsyReqHandle aTsyReqHandle, const TDesC* aExistingContextName, TInt* aCount)
+/**
+ * EnumerateContextsInNif - sets the number of NIFs in a context.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateContextsInNif called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if (!iEnumerateContextsInNif++)
+ {
+ TInt ret = (*aExistingContextName).Compare(DPCKTTSY_NIF_CONTEXT2);
+ if (ret == KErrNone)
+ {
+ *aCount = DPCKTTSY_NUMBER_OF_CONTEXTS_IN_NIF2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateContextsInNifCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * EnumerateContextsInNifCancel - Cancels an asynchronous EnumerateContextsInNif request.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateContextsInNifCancel called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetContextNameInNif(const TTsyReqHandle aTsyReqHandle, RPacketService::TContextNameInNif* aContextNameInNif, TDes* aContextName)
+/**
+ * GetContextNameInNif - gets a context name within a Nif.
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetContextNameInNif called"));
+
+ User::After(300000); // wait to have KRequestPending
+ if (!iGetContextNameInNif++)
+ {
+ if (!(aContextNameInNif->iExistingContextName).Compare(DPCKTTSY_NIF_CONTEXT1))
+ {
+ switch (aContextNameInNif->iIndex)
+ {
+ case 0:
+ {
+ *aContextName=DPCKTTSY_CONTEXT1_IN_NIF1;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ break;
+ default:
+ ReqCompleted(aTsyReqHandle,KErrArgument);
+ break;
+ } // switch
+ } // if, 'inner block'
+ else if (!(aContextNameInNif->iExistingContextName).Compare(DPCKTTSY_NIF_CONTEXT2))
+ {
+ switch (aContextNameInNif->iIndex)
+ {
+ case 0:
+ {
+ *aContextName=DPCKTTSY_CONTEXT1_IN_NIF2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ break;
+ case 1:
+ {
+ *aContextName=DPCKTTSY_CONTEXT2_IN_NIF2;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ break;
+ default:
+ ReqCompleted(aTsyReqHandle,KErrArgument);
+ break;
+ } // switch
+ } // else if
+ else
+ ReqCompleted(aTsyReqHandle, KErrCorrupt);
+ } // if, 'outer block'
+
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetContextNameInNifCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * GetContextNameInNifCancel - Cancels an asynchronous GetContextNameInNif request
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetContextNameInNifCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::PrepareOpenSecondary(const TTsyReqHandle aTsyReqHandle, const TDesC* /*aOriginalContextName*/)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::PrepareOpenSecondary called"));
+
+ User::After(300000); // wait to have KRequestPending
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::DeactivateNIF(const TTsyReqHandle aTsyReqHandle, const TDesC* dataPtr)
+/**
+ * DeactivateNIF - deactivates a NIF
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::DeactivateNIF called"));
+ User::After(300000); // wait to have KRequestPending
+ if (!iDeactivateNIF++)
+ {
+ if(!dataPtr->Compare(DPCKTTSY_NIF_CONTEXT1))
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ else
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::DeactivateNIFCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * DeactivateNIFCancel - cancels an asynchronous DeactivateNIF request
+ */
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::DeactivateNIFCancel called"));
+ User::After(300000); // wait to have KRequestPending
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ else
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+
+RHandleBase* CGprsDGprsTsy::GlobalKernelObjectHandle()
+/**
+* Implements CSubSessionExtBase virtual method, which provides
+* handle of the mutex object to etel server that passes it up to clients.
+* @return pointer to synchronisation mutex object
+*/
+ {
+ return &iMutex;
+ }
+//
+// Multimedia Broadcast Multicast Service (MBMS)
+//
+TInt CGprsDGprsTsy::NotifyMbmsNetworkServiceStatusChange(const TTsyReqHandle aTsyReqHandle, TMbmsNetworkServiceStatus* aStatus)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMbmsNetworkServiceStatusChange called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ if (!iNotifyMbmsNetworkServiceStatusChange++)
+ {
+ *aStatus = DPCKTTSY_MBMS_NETWORKSERVICE_SUPPORTED;
+ AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyMbmsNetworkServiceStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMbmsNetworkServiceStatusChangeCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMbmsNetworkServiceStatus(const TTsyReqHandle aTsyReqHandle, TBool* aAttemptAttach,TMbmsNetworkServiceStatus* aStatus)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetMbmsNetworkServiceStatus called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ switch(iGetMbmsNetworkServiceStatus)
+ {
+ case 0:
+ if(!(*aAttemptAttach == DPCKTTSY_MBMS_ATTEMPT_GSMATTACH_TRUE))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ *aStatus = DPCKTTSY_MBMS_NETWORKSERVICE_SUPPORTED;
+ AddDelayedReq(aTsyReqHandle, this);
+ }
+ iGetMbmsNetworkServiceStatus++;
+ break;
+ case 1:
+ if(!(*aAttemptAttach == DPCKTTSY_MBMS_ATTEMPT_GSMATTACH_FALSE))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ *aStatus = DPCKTTSY_MBMS_NETWORKSERVICE_UNKNOWN;
+ AddDelayedReq(aTsyReqHandle, this);
+ }
+ iGetMbmsNetworkServiceStatus = 0; //Reset to 0
+ break;
+ default:
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMbmsNetworkServiceStatusCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetMbmsNetworkServiceStatusCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyMbmsServiceAvailabilityChange(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMbmsServiceAvailabilityChange called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ if(!iServiceAvailability++)
+ {
+ AddDelayedReq(aTsyReqHandle,this);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::NotifyMbmsServiceAvailabilityChangeCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::NotifyMbmsServiceAvailabilityChangeCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt) ;
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::UpdateMbmsMonitorServiceListL(const TTsyReqHandle aTsyReqHandle,TMbmsAction* aAction, TDes8* aBuffer)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::UpdateMbmsMonitorServiceListL called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ TInt error = KErrNone;
+ switch(*aAction)
+ {
+ case DPCKTTSY_MBMS_ACTION_ADD:
+ iList->RestoreL(*aBuffer);
+ iServiceCount=iList->Enumerate();
+ if ( iServiceCount != DPCKTTSY_MBMS_SERVICELIST_COUNT_ADD )
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ return KErrNone;
+ }
+ error=AddMbmsServicesToMonitorList(aTsyReqHandle);
+ if(error == KErrNone)
+ {
+ AddDelayedReq(aTsyReqHandle,this);
+ }
+ break;
+ case DPCKTTSY_MBMS_ACTION_REMOVE:
+ //If the client requests to remove invalid service entries, one or more, TSY
+ //shall delete valid entries and if invalid entries are found then the request
+ // shall complete with KErrMbmsImpreciseServiceEntries.
+ iList->RestoreL(*aBuffer);
+ iServiceCount=iList->Enumerate();
+ error=RemoveMbmsServicesFromMonitorList(aTsyReqHandle);
+ if(error == KErrNone)
+ {
+ AddDelayedReq(aTsyReqHandle,this);
+ }
+ break;
+ case DPCKTTSY_MBMS_ACTION_REMOVEALL:
+ //No need to check the list object. TSY should just delete all the objects present
+ // in the monitor list irrespective of the contents present in aBuffer parameter.
+ error = KErrNone;
+ AddDelayedReq(aTsyReqHandle,this);
+ break;
+ default:
+ error = KErrCorrupt;
+ }
+ if(error == KErrCorrupt)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if (error == KErrNotFound)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotFound);
+ }
+ else if (error == KErrMbmsImpreciseServiceEntries)
+ {
+ ReqCompleted(aTsyReqHandle,KErrMbmsImpreciseServiceEntries);
+ }
+ return KErrNone;
+ };
+
+TInt CGprsDGprsTsy::UpdateMbmsMonitorServiceListCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::UpdateMbmsMonitorServiceListCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMbmsMonitoredServicesPhase1(const TTsyReqHandle aTsyReqHandle, TClientId* aClient, TUint* aBufSize)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetMbmsMonitoredServicesPhase1 called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ TInt ret=KErrNone;
+ TInt leaveCode=KErrNone;
+ TRAP(leaveCode, ret=ProcessGetMbmsMonitoredServicesPhase1L(aTsyReqHandle, aClient, aBufSize););
+ if (leaveCode != KErrNone)
+ {
+ ReqCompleted(aTsyReqHandle,leaveCode);
+ }
+ return ret;
+ }
+
+TInt CGprsDGprsTsy::ProcessGetMbmsMonitoredServicesPhase1L(const TTsyReqHandle aTsyReqHandle,
+ TClientId* aClient,
+ TUint* aBufSize)
+ {
+ // retrieve MBMS service list,
+ // store each entry.
+ // stream the list and then return size of this buffer to client
+ CPcktMbmsMonitoredServiceList* list=CPcktMbmsMonitoredServiceList::NewL();
+ CleanupStack::PushL(list);
+ RPacketService::TMbmsServiceAvailabilityV1 entry;
+
+ // fill up an example list
+ for (TInt index=0; index < DPCKTTSY_MBMS_SERVICELIST_COUNT_ADD; index++)
+ {
+ switch (index)
+ {
+ case 0:
+ entry.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_ONE;
+ entry.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_ONE;
+ entry.iMbmsAvailabilityStatus = DPCKTTSY_MBMS_AVAILABILITYSTATUS_ONE;
+ entry.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_ONE);
+ entry.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_ONE);
+ entry.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_ONE);
+ break;
+
+ case 1:
+ entry.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_TWO;
+ entry.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_TWO;
+ entry.iMbmsAvailabilityStatus = DPCKTTSY_MBMS_AVAILABILITYSTATUS_TWO;
+ entry.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_TWO);
+ entry.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_TWO);
+ entry.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_TWO);
+ break;
+
+ case 2:
+ default:
+ entry.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_THREE;
+ entry.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_THREE;
+ entry.iMbmsAvailabilityStatus = DPCKTTSY_MBMS_AVAILABILITYSTATUS_THREE;
+ entry.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_THREE);
+ entry.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_THREE);
+ entry.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_THREE);
+ break;
+ }
+ // Add the entry into the list, at the next empty location
+ list->AddEntryL(entry);
+ }
+ // Store the streamed list and the client ID
+ CListReadAllAttempt* read=CListReadAllAttempt::NewL(aClient,aTsyReqHandle);
+ CleanupStack::PushL(read);
+
+ read->iListBuf = list->StoreLC();
+ CleanupStack::Pop(); // pop the CBufBase allocated by StoreLC
+
+ iGetMbmsMonitoredServices->AppendL(read);
+ CleanupStack::Pop(); // pop the CListReadAllAttempt
+
+ // return the CBufBase’s size to client
+ *aBufSize=(read->iListBuf)->Size();
+ // Complete first phase of list retrieval
+ AddDelayedReq(aTsyReqHandle,this);
+ CleanupStack::PopAndDestroy(); // pop&destroy list
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::GetMbmsMonitoredServicesPhase2(const TTsyReqHandle aTsyReqHandle,TClientId* aClient, TDes8* aBuf)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetMbmsMonitoredServicesPhase2 called"));
+ CListReadAllAttempt* read=NULL;
+ // Find the get Mbms monitored services from this client
+ for (TInt i=0; i<iGetMbmsMonitoredServices->Count(); ++i)
+ {
+ read = iGetMbmsMonitoredServices->At(i);
+ if ((read->iClient.iSessionHandle==aClient->iSessionHandle) &&
+ (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle))
+ {
+ TPtr8 bufPtr((read->iListBuf)->Ptr(0));
+ // Copy the streamed list to the client
+ aBuf->Copy(bufPtr);
+ delete read;
+ iGetMbmsMonitoredServices->Delete(i);
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+ }
+ // Should handle error case of not finding the matching client from read all phase 1
+ return KErrNotFound;
+ }
+
+TInt CGprsDGprsTsy::GetMbmsMonitoredServicesCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::GetPreferredWlanSIDsCancel called"));
+ // Remove the read all attempt from iGetMbmsMonitoredServices
+ RemoveDelayedReq(aTsyReqHandle);
+ CListReadAllAttempt* read=NULL;
+ for (TInt i=0; i<iGetMbmsMonitoredServices->Count(); ++i)
+ {
+ read = iGetMbmsMonitoredServices->At(i);
+ if (read->iReqHandle == aTsyReqHandle)
+ {
+ delete read;
+ iGetMbmsMonitoredServices->Delete(i);
+ break;
+ }
+ }
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::AddMbmsServicesToMonitorList(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::AddMbmsServicesToMonitorList is called"));
+ TInt error = KErrNone;
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ RPacketService::TMbmsServiceAvailabilityV1 entry;
+ for (TInt i=0; i<iServiceCount; ++i)
+ {
+ TRAPD(ret,entry=iList->GetEntryL(i));
+ if (ret != KErrNone)
+ break;
+ switch(i)
+ {
+ case 0:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_ONE ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_ONE ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_ONE ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_ONE ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_ONE)
+ {
+ error = KErrCorrupt;
+ }
+ break;
+ case 1:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_TWO ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_TWO ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_TWO ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_TWO ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_TWO)
+ {
+ error = KErrCorrupt;
+ }
+ break;
+ case 2:
+ default:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_THREE ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_THREE ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_THREE ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_THREE ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_THREE)
+ {
+ error = KErrCorrupt;
+ }
+ break;
+ }//END OF SWITCH
+ }//end of for loop
+ return error;
+ }
+
+TInt CGprsDGprsTsy::RemoveMbmsServicesFromMonitorList(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::RemoveMbmsServicesFromMonitorList is called"));
+ TInt error = KErrNone;
+ RPacketService::TMbmsServiceAvailabilityV1 entry;
+
+ switch(iRemoveMbmsServices)
+ {
+ case 0:
+ for(TInt i=0;i<iServiceCount;i++)
+ {
+ TRAPD(ret,entry=iList->GetEntryL(i));
+ if (ret != KErrNone)
+ break;
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_TWO ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_TWO ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_TWO ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_TWO ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_TWO)
+ {
+ error=KErrCorrupt;
+ }
+ }
+ iRemoveMbmsServices++;
+ break;
+
+ case 1:
+ for(TInt i=0;i<iServiceCount;i++)
+ {
+ TRAPD(ret,entry=iList->GetEntryL(i));
+ if (ret != KErrNone)
+ break;
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_INVALID ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_INVALID ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_INVALID ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_INVALID ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_INVALID)
+ {
+ error=KErrCorrupt;
+ }
+ }
+ if(error != KErrCorrupt)
+ {
+ error=KErrNotFound;
+ }
+ iRemoveMbmsServices++;
+ break;
+
+ case 2:
+ for(TInt i=0;i<iServiceCount;i++)
+ {
+ TRAPD(ret,entry=iList->GetEntryL(i));
+ if (ret != KErrNone)
+ break;
+ switch(i)
+ {
+ case 0:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_ONE ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_ONE ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_ONE ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_ONE ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_ONE )
+ {
+ error=KErrCorrupt;
+ }
+ break;
+
+ case 1:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_INVALID ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_INVALID ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_INVALID ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_INVALID ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_INVALID)
+ {
+ error=KErrCorrupt;
+ }
+ break;
+
+ case 2:
+ default:
+ if(entry.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_THREE ||
+ entry.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_THREE ||
+ entry.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_THREE ||
+ entry.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_THREE ||
+ entry.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_THREE)
+ {
+ error=KErrCorrupt;
+ }
+ break;
+ }
+ }
+ if(error != KErrCorrupt)
+ {
+ error=KErrMbmsImpreciseServiceEntries;
+ }
+ iRemoveMbmsServices=0;
+ break;
+
+ default:
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ break;
+ }
+ return error;
+ }
+
+TInt CGprsDGprsTsy::EnumerateMbmsMonitorServiceList(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateMbmsMonitorServiceList called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ *aCount = DPCKTTSY_MBMS_MONITORSERVICE_NUMBER_OF_CONTEXTS;
+ *aMaxAllowed = DPCKTTSY_MBMS_MONITORSERVICE_MAX_NUMBER_OF_CONTEXTS;
+ AddDelayedReq(aTsyReqHandle,this, DPCKTTSY_MBMS_DELAY);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateMbmsMonitorServiceListCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateMbmsMonitorServiceListCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateMbmsActiveServiceList(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateMbmsActiveServiceList called"));
+ iTsyAsyncReqHandle = aTsyReqHandle;
+ *aCount = DPCKTTSY_MBMS_ACTIVESERVICE_NUMBER_OF_CONTEXTS;
+ *aMaxAllowed = DPCKTTSY_MBMS_ACTIVESERVICE_MAX_NUMBER_OF_CONTEXTS;
+ AddDelayedReq(aTsyReqHandle,this, DPCKTTSY_MBMS_DELAY);
+ return KErrNone;
+ }
+
+TInt CGprsDGprsTsy::EnumerateMbmsActiveServiceListCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ LOGTEXT(_L8("CGprsDGprsTsy::EnumerateMbmsActiveServiceListCancel called"));
+ RemoveDelayedReq(aTsyReqHandle);
+ if(aTsyReqHandle == iTsyAsyncReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+//
+CListReadAllAttempt* CListReadAllAttempt::NewL(TClientId* aId, TTsyReqHandle aReqHandle)
+ {
+ CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);
+ CleanupStack::PushL(read);
+ read->ConstructL();
+ CleanupStack::Pop();
+ return read;
+ }
+
+CListReadAllAttempt::CListReadAllAttempt(TClientId* aId, TTsyReqHandle aReqHandle)
+ :CBase()
+ {
+ iClient.iSessionHandle=aId->iSessionHandle;
+ iClient.iSubSessionHandle=aId->iSubSessionHandle;
+ iReqHandle=aReqHandle;
+ iListBuf = NULL;
+ }
+
+void CListReadAllAttempt::ConstructL()
+ {
+ }
+
+CListReadAllAttempt::~CListReadAllAttempt()
+ {
+ delete iListBuf;
+ }
+
+//
+// methods for CActiveListNode
+//
+
+CGprsDGprsTsy::CActiveListNode::CActiveListNode(CActive *aActive, const TTsyReqHandle aTsyReqHandle) :
+ iActive(aActive), iTsyReqHandle(aTsyReqHandle)
+ {
+ }
+
+CGprsDGprsTsy::CActiveListNode::~CActiveListNode()
+ {
+ delete iActive;
+ }
+
+//
+// methods for the list of aos which corresspond to the outstanding delayed asyncrhonous reqs
+//
+
+TInt CGprsDGprsTsy::FindDelayedReq(const TTsyReqHandle aTsyReqHandle, CActiveListNode *& aNode)
+ {
+ TInt err = KErrNotFound;
+ TSglQueIter<CActiveListNode> iter(iActiveRequestObjects);
+ iter.SetToFirst();
+
+ CActiveListNode *node = aNode = NULL;
+ while ((node = iter++) != NULL)
+ {
+ if (node->iTsyReqHandle == aTsyReqHandle)
+ {
+ break;
+ }
+ }
+ if (node != NULL)
+ {
+ aNode = node;
+ err = KErrNone;
+ }
+ return err;
+ }
+
+TInt CGprsDGprsTsy::RemoveDelayedReq(const TTsyReqHandle aTsyReqHandle)
+ {
+ CActiveListNode *aNode = NULL;
+ TInt err = FindDelayedReq(aTsyReqHandle,aNode);
+ if (err == KErrNone)
+ {
+ iActiveRequestObjects.Remove(*aNode);
+ delete aNode;
+ }
+ return err;
+ }
+
+void CGprsDGprsTsy::RegisterDelayedReqL(const TTsyReqHandle aTsyReqHandle, CTelObject *aTelObject)
+ {
+ CDelayedCompleter *delayed = CDelayedCompleter::NewL(aTsyReqHandle,this,aTelObject);
+ CleanupStack::PushL(delayed);
+ CActiveListNode *newNode = new (ELeave) CActiveListNode(delayed,aTsyReqHandle);
+ iActiveRequestObjects.AddLast(*newNode);
+ delayed->After(DPCKTTSY_STANDARD_DELAY);
+ CleanupStack::Pop(); // delayed
+ }
+
+void CGprsDGprsTsy::RegisterDelayedReqL(const TTsyReqHandle aTsyReqHandle, CTelObject *aTelObject,TInt aPriority)
+ {
+ CDelayedCompleter *delayed = CDelayedCompleter::NewL(aTsyReqHandle,this,aTelObject);
+ CleanupStack::PushL(delayed);
+ CActiveListNode *newNode = new (ELeave) CActiveListNode(delayed,aTsyReqHandle);
+ iActiveRequestObjects.AddLast(*newNode);
+ delayed->After(aPriority);
+ CleanupStack::Pop(); // delayed
+ }
+
+void CGprsDGprsTsy::AddDelayedReq(const TTsyReqHandle aTsyReqHandle, CTelObject *aTelObject)
+ {
+ TRAPD(err, RegisterDelayedReqL(aTsyReqHandle, aTelObject));
+ if (err != KErrNone)
+ {
+ ReqCompleted(aTsyReqHandle, err);
+ }
+ }
+
+void CGprsDGprsTsy::AddDelayedReq(const TTsyReqHandle aTsyReqHandle, CTelObject *aTelObject,TInt aPriority)
+ {
+ TRAPD(err, RegisterDelayedReqL(aTsyReqHandle, aTelObject, aPriority));
+ if (err != KErrNone)
+ {
+ ReqCompleted(aTsyReqHandle, err);
+ }
+ }
+
+//
+//
+// CDelayedCompleter
+//
+//
+
+CDelayedCompleter::CDelayedCompleter(const TTsyReqHandle aTsyReqHandle, CGprsDGprsTsy *aGprsObject,
+ CTelObject *aTelObject) :
+ CTimer(EPriorityStandard),iTsyReqHandle(aTsyReqHandle), iGprsObject(aGprsObject),
+ iTelObject(aTelObject)
+ {
+ }
+
+CDelayedCompleter* CDelayedCompleter::NewL(const TTsyReqHandle aTsyReqHandle, CGprsDGprsTsy *aGprsObject,
+ CTelObject *aTelObject)
+ {
+ CDelayedCompleter* self = new (ELeave) CDelayedCompleter(aTsyReqHandle,aGprsObject,aTelObject);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+void CDelayedCompleter::ConstructL()
+ {
+ CTimer::ConstructL();
+ CActiveScheduler::Add(this);
+ }
+
+void CDelayedCompleter::RunL()
+ {
+ iTelObject->ReqCompleted(iTsyReqHandle,KErrNone);
+ (void) iGprsObject->RemoveDelayedReq(iTsyReqHandle);
+ }