diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/commontsy/src/mmpacket/cmmmbmscontexttsy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/commontsy/src/mmpacket/cmmmbmscontexttsy.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1643 @@ +// Copyright (c) 2006-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 FILES +#include "cmmmbmscontexttsy.h" +#include "cmmmbmscontextlist.h" +#include "CMmPacketTsy.h" +#include +#include "mbmstypes.h" +#include "MmTsy_timeoutdefs.h" +#include "MmTsy_numberOfSlots.h" + +// ============================ MEMBER FUNCTIONS =============================== + +CMmMBMSContextTsy::CMmMBMSContextTsy() + { + } + +CMmMBMSContextTsy* CMmMBMSContextTsy::NewL( + CMmPacketServiceTsy* aMmPacketService, + const TDes& aName, + const TUint8 aProxyId ) + { +TFLOGSTRING( "TSY: CMmMBMSContextTsy::NewL" ); + + CMmMBMSContextTsy* packetContext = new ( ELeave ) CMmMBMSContextTsy(); + CleanupClosePushL( *packetContext ); + packetContext->ConstructL( aMmPacketService, aName, aProxyId ); + CleanupStack::Pop(); + + return packetContext; + } + +void CMmMBMSContextTsy::ConstructL(CMmPacketServiceTsy* const aMmPacketService, + const TDes& aName, + TUint8 aProxyId) + { + iMmPacketService = aMmPacketService; + iContextName = aName; + iObjectId = aProxyId; + + iConfig = new ( ELeave ) RPacketMbmsContext::TContextConfigMbmsV1(); + +#ifdef REQHANDLE_TIMER + // Create req handle store + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, + iMmPacketService->PhoneTsy(), EMaxNumOfMBMSContextRequests, + iPacketContextReqHandles ); + +#else + // Create req handle store + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( + EMaxNumOfMBMSContextRequests, iPacketContextReqHandles ); + +#endif // REQHANDLE_TIMER + iIsInitialiseAllowed = ETrue; + iServicesArray = RPacketMbmsContext::CMbmsSession::NewL(); + iContextStatus = RPacketContext::EStatusUnknown; + } + +CMmMBMSContextTsy::~CMmMBMSContextTsy() + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::~CMmMBMSContextTsy Context name: %S", &iContextName ); + + if( iMmPacketService ) + { + iMmPacketService->MBMSContextList()->RemoveObject( this ); + + // Set Dynamic Caps + iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag( + RPacketService::KCapsActivate, EFalse ); + } + + delete iServicesArray; + iServicesArray = NULL; + + delete iTsyReqHandleStore; + iTsyReqHandleStore = NULL; + + delete iConfig; + iConfig = NULL; + + delete iTempConfig; + iTempConfig = NULL; + + } + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ExtFunc +// TRAP's all CMmMBMSContextTsy related MM Packet API requests in case that +// they fail. This method functions only as a centralized TRAP for the +// DoExtFuncL method that does the actual mapping of IPC number to TSY method +// call. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// + +TInt CMmMBMSContextTsy::ExtFunc( + TTsyReqHandle aTsyReqHandle, + TInt aIpc, + const TDataPackage& aPackage ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::ExtFunc. IPC: %d Context name:%S", aIpc, &iContextName ); + + TInt ret( KErrNone ); + TInt trapError( KErrNone ); + + // Reset last tsy request type + iReqHandleType = EMultimodePacketMbmsReqHandleUnknown; + + // Set tsy request handle + iTsyReqHandle = aTsyReqHandle; + + // Trap the call of DoExtFuncL + TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ) ); + + if ( KErrNone != trapError ) + { + ReqCompleted( aTsyReqHandle, trapError ); + } + + else if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + + if ( EMultimodePacketMbmsReqHandleUnknown != iReqHandleType ) + { +#ifdef REQHANDLE_TIMER + SetTypeOfResponse( iReqHandleType, aTsyReqHandle ); +#else + iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle ); +#endif // REQHANDLE_TIMER + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::DoExtFuncL +// Packet Data specific functionality of CMmMBMSContextTsy::ExtFunc +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::DoExtFuncL( + TTsyReqHandle aTsyReqHandle, + TInt aIpc, + const TDataPackage& aPackage ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::DoExtFuncL. IPC: %d Handle:%d", + aIpc, aTsyReqHandle ); + + TInt ret( KErrNotSupported ); + + TAny* dataPtr = aPackage.Ptr1(); + TAny* dataPtr2 = aPackage.Ptr2(); + + switch ( aIpc ) + { + case EPacketContextNotifyStatusChange: + ret = NotifyStatusChange( + reinterpret_cast< RPacketContext::TContextStatus*>( dataPtr ) ); + break; + case EPacketContextNotifyConfigChanged: + ret = NotifyConfigChanged( + reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) ); + break; + case EPacketContextInitialiseContext: + ret = InitialiseContextL( reinterpret_cast< RPacketContext::TDataChannelV2*>( dataPtr )); + break; + case EPacketContextSetConfig: + ret = SetConfigL( + reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) ); + break; + case EPacketContextActivate: + ret = ActivateL(); + break; + case EPacketContextDeactivate: + ret = DeactivateL(); + break; + case EPacketContextDelete: + ret = DeleteL(); + break; + case EPacketContextGetStatus: + ret = GetStatus( aTsyReqHandle, + reinterpret_cast< RPacketContext::TContextStatus*>( dataPtr ) ); + break; + case EPacketContextGetConfig: + ret = GetConfig( aTsyReqHandle, + reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) ); + break; + case EPacketContextGetLastErrorCause: + ret = GetLastErrorCause( aTsyReqHandle, + reinterpret_cast< TInt*>( dataPtr ) ); + break; + case EPacketContextUpdateMbmsSessionList: + ret = UpdateMbmsSessionList( + reinterpret_cast< TMbmsAction*>( dataPtr ), + reinterpret_cast< TMbmsSessionId*>( dataPtr2 ) ); + break; + case EPacketGetMbmsSessionListPhase1: + ret = GetMbmsActiveServicesPhase1L( aTsyReqHandle, + reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ), + reinterpret_cast< TInt*>( dataPtr2 ) ); + break; + + case EPacketGetMbmsSessionListPhase2: + ret = GetMbmsActiveServicesPhase2L( aTsyReqHandle, + reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ), + aPackage.Des2n() ); + break; + // These requests currently not supported + case EPacketContextLoanCommPort: + case EPacketContextRecoverCommPort: + case EPacketContextNotifyDataTransferred: + case EPacketContextGetProfileName: + case EPacketContextGetConnectionSpeed: + case EPacketContextGetDataVolumeTransferred: + case EPacketContextEnumeratePacketFilters: + case EPacketContextGetPacketFilterInfo: + case EPacketContextAddPacketFilter: + case EPacketContextRemovePacketFilter: + case EPacketContextModifyActiveContext: + case EPacketContextGetDNSInfo: + case EPacketAddMediaAuthorization: + case EPacketRemoveMediaAuthorization: + default: + break; + } + + return ret; + } + + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ReqModeL +// Returns request mode for given IPC. +// --------------------------------------------------------------------------- +// +CTelObject::TReqMode CMmMBMSContextTsy::ReqModeL( + TInt aIpc ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::ReqModeL. IPC: %d", aIpc ); + + CTelObject::TReqMode reqMode( 0 ); + TBool doLeave( EFalse ); + + switch ( aIpc ) + { + // All disabled + // TSYs wishing to implement their own buffering algorithm will place + // all requests in this category. + + // Get methods that do not use DOS and return immediately. + // Flow control not required. + case EPacketContextGetLastErrorCause: + + // Other methods that do not use DOS and return immediately. + // Flow control not required. + + // Methods that can propably take a long time and cannot therefore be + // flow controlled. Solution: All these methods must check req handle + // table before handling the request. In case that the request table + // indicates that same method has been called and has not been + // completed, the method should return KErrServerBusy. + + case EPacketContextGetStatus: + case EPacketContextGetConfig: + break; + + // KReqModeFlowControlObeyed + // Commands that change the state of the phone, e.g. clearing the AoC + // counter, are commands that the TSY should only deal with one at + // a time. + case EPacketContextUpdateMbmsSessionList: + case EPacketContextInitialiseContext: + case EPacketContextActivate: + case EPacketContextDelete: + case EPacketContextSetConfig: + case EPacketContextAddPacketFilter: + case EPacketContextRemovePacketFilter: + + case EPacketContextDeactivate: + { + reqMode = KReqModeFlowControlObeyed; + break; + } + + // KReqModeMultipleCompletionEnabled | ReqModePostImmediately + // Requests that notify a client about a change of state. + // Since these requests do not require the issuing of any modem + // commands, they do not have to obey flow control. + // The TSY never gets more than one of these outstanding. + case EPacketContextNotifyConfigChanged: + + case EPacketContextNotifyStatusChange: + reqMode = KReqModeMultipleCompletionEnabled | + KReqModeRePostImmediately; + break; + + case EPacketGetMbmsSessionListPhase1: + case EPacketGetMbmsSessionListPhase2: + reqMode = 0; + break; + // Cancel Requests + // It's not necessary to include the Cancel methods in ReqModeL at all. + // The ETel server never calls ReqModeL with a Cancel IPC. + + // Other variations of return values are unusable. + // Following requests are not supported + //case EPacketContextNotifyDataTransferred: + //case EPacketContextLoanCommPort: + //case EPacketContextRecoverCommPort: + //case EPacketContextModifyActiveContext: + // Default + default: + doLeave = ETrue; + break; + } + + if ( doLeave ) + { + User::Leave( KErrNotSupported ); + } + + return reqMode; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::NumberOfSlotsL +// Returns number of slots to be used for given IPC. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::NumberOfSlotsL( + TInt aIpc ) + { + TInt numberOfSlots( 0 ); + + switch ( aIpc ) + { + case EPacketContextNotifyStatusChange: + numberOfSlots = KMmPacketContextNotifyStatusChangeSlots; + break; + case EPacketContextNotifyConfigChanged: + numberOfSlots = KMmPacketContextNotifyConfigChangedSlots; + break; + + default: + // Unknown or invalid IPC + User::Leave( KErrNotSupported ); + break; + + } +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::NumberOfSlotsL. IPC: %d Number of slots: %d", aIpc, numberOfSlots ); + + return numberOfSlots; + + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CancelService +// Cancel the outstanding request.ETel Server when it is "cleaning-up" any +// 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. Only Packet API requests are handled +// here. Client can also cancel a request by calling CancelAsyncRequest +// (defined in etel.h). The ETel server passes this kind of cancel requests +// to CancelService. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::CancelService( + TInt aIpc, + TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::CancelService. IPC: %d Handle:%d", aIpc, aTsyReqHandle ); + + TInt ret( KErrNone ); + //TTsyReqHandle reqHandle( NULL ); + // Reset last tsy request type + iReqHandleType = EMultimodePacketMbmsReqHandleUnknown; + + switch ( aIpc ) + { + // TSY has started a request and it is not possible to then cancel + // this request. The best thing for the TSY to do in this case is to + // proceed as though the Cancel never happened. The server's call to + // the TSY cancel function will return synchronously. The TSY then + // continues to wait for the original acknowledgement and when it + // receives it, the TSY will complete the original request. + case EPacketContextUpdateMbmsSessionList: + case EPacketContextInitialiseContext: + case EPacketContextActivate: + case EPacketContextDeactivate: + case EPacketContextDelete: + case EPacketContextSetConfig: + case EPacketContextGetConfig: + break; + case EPacketGetMbmsSessionListPhase1: + ret = CancelGetMbmsActiveServicesPhase1(); + break; + // Notification Cancels, no special requirements. + case EPacketContextNotifyStatusChange: + iRetNotifyStatus = NULL; + iReqHandleType = EMultimodeMbmsContextNotifyStatusChange; + break; + case EPacketContextNotifyConfigChanged: + iRetNotifyConfig = NULL; + iReqHandleType = EMultimodeMbmsContextNotifyConfigChanged; + break; + + // IPCs that are not supported + //case EPacketContextLoanCommPort: + //case EPacketContextRecoverCommPort: + //case EPacketContextNotifyDataTransferred: + //case EPacketContextModifyActiveContext: + // Default + default: + ret = KErrNotSupported; + break; + } + + if ( EMultimodePacketMbmsReqHandleUnknown != iReqHandleType ) + { + // Reset tsy request handle + iTsyReqHandleStore->ResetTsyReqHandle( iReqHandleType ); + + // Complete request + CMmMBMSContextTsy::ReqCompleted( aTsyReqHandle, KErrCancel ); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::RegisterNotification +// Register notification. RegisterNotification is called when the ETel Server +// recognises that this notification is being posted for the first time on +// this subsession object.It enables the TSY to "turn on" any regular +// notification messages that it may receive from DOS. If this object is +// Dial-Up context only supported notification is +// EPacketContextNotifyStatusChange. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::RegisterNotification( + TInt aIpc ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::RegisterNotification. IPC: %d", aIpc ); + + TInt ret( KErrNone ); + + switch ( aIpc ) + { + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + break; + //case EPacketContextNotifyDataTransferred: + default: + // Not supported + ret = KErrNotSupported; + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::DeregisterNotification +// Deregister notification. DeregisterNotification is called when the ETel +// 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 DOS. If this object is Dial-Up context +// only supported notification is EPacketContextNotifyStatusChange. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::DeregisterNotification( + TInt aIpc ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::DeregisterNotification. IPC: %d", aIpc ); + + TInt ret( KErrNone ); + + switch ( aIpc ) + { + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + break; + //case EPacketContextNotifyDataTransferred: + default: + // Not supported + ret = KErrNotSupported; + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::InitialiseContextL +// This function initialises the context created previously. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::InitialiseContextL( RPacketContext::TDataChannelV2* aDataChannel ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::InitialiseContextL. %S", &iContextName ); + + TInt ret( KErrArgument ); + + if ( iIsInitialiseAllowed ) + { + CMmDataPackage dataPackage; + dataPackage.PackData( &iContextName); + iDataChannelV2 = aDataChannel; + + ret = iMmPacketService->MessageManager()->HandleRequestL( + ECtsyPacketMbmsInitialiseContextReq, &dataPackage ); + + if( KErrNone == ret ) + { + iIsInitialiseAllowed = EFalse; + } + } + + if ( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = EMultimodePacketMbmsInitialiseContext; + } + + + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteInitialiseContext +// Complete the asynchronous InitialiseContext request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// + +void CMmMBMSContextTsy::CompleteInitialiseContext(TInt aResult, RPacketContext::TDataChannelV2* aDataChannel ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteInitialiseContext. Error: %d", aResult ); + + iIsActivateAllowed = ETrue; + if (KErrNone == aResult ) + { + CompleteNotifyStatusChange( RPacketContext::EStatusInactive ); + if((aDataChannel != NULL) && (iDataChannelV2 != NULL)) + { + *iDataChannelV2 = *aDataChannel; + iDataChannelV2 = NULL; + } + // Set Dynamic Caps + iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag( + RPacketService::KCapsActivate, iIsActivateAllowed ); + } + else + { + iIsInitialiseAllowed = ETrue; + } + + // Reset the req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodePacketContextInitialiseContext ); + + if ( EMultimodePacketContextReqHandleUnknown != reqHandle ) + { + // Complete the client request + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ActivateL +// Activate a context. This function activates a context that has been +// previously configured using the SetConfig() method from RPacketMbmsContext. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::ActivateL() + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::ActivateL. Context name:%S", &iContextName ); + + TInt ret( KErrNotReady ); + + if ( iIsActivateAllowed ) + { + // verify that max activate context is not exceed + if( iMmPacketService->MaximumActiveServices() > + iMmPacketService->EnumerateMbmsActiveServices() ) + { + // mbmscontext activation + CMmDataPackage data; + data.PackData( &iContextName ); + + ret = iMmPacketService->MessageManager()->HandleRequestL( + EPacketContextActivate, &data ); + } + else + { + // max number of possible active context exceed + ret = KErrUmtsMaxNumOfContextExceededByPhone; + } + if ( KErrNone == ret ) + { + iIsActivateAllowed = EFalse; + CompleteNotifyStatusChange( RPacketContext::EStatusActivating ); + } + } + + if ( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = EMultimodeMbmsContextActivate; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteActivate +// Complete the asynchronous Activate request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteActivate(TInt aResult) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteActivate. Error: %d", aResult ); + + // Reset the req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextActivate ); + + if ( KErrNone == aResult ) + { + + CompleteNotifyConfigChanged(); + + // Notify status change + CompleteNotifyStatusChange( RPacketContext::EStatusActive ); + } + else + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteActivate. ErrorCause: %d", + aResult ); + // Re-activation is allowed because activation has not succeeded + iIsActivateAllowed = ETrue; + } + + + if ( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) + { + + // Complete the client request + CMmMBMSContextTsy::ReqCompleted( reqHandle, aResult ); + } + } + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::Deactivate +// Deactivate a context previously configured on the phone. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::DeactivateL() + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::DeactivateL. Context name:%S", &iContextName ); + + TInt ret( KErrArgument ); + + CMmDataPackage data; + data.PackData( &iContextName, &iServicesArray ); + ret = iMmPacketService->MessageManager()->HandleRequestL( + EPacketContextDeactivate, &data ); + + if ( KErrNone == ret ) + { + iContextStatusBeforeDeactivation = ContextStatus(); + // Notify status change + CompleteNotifyStatusChange( RPacketContext::EStatusDeactivating ); + + // Store the request handle + iReqHandleType = EMultimodeMbmsContextDeactivate; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteDeactivate +// Complete the asynchronous Deactivate request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// + +void CMmMBMSContextTsy::CompleteDeactivate( + CMmDataPackage* aDataPackage, + TInt aResult ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteDeactivate. Error: %d", aResult ); + // Reset the req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextDeactivate ); + + // Notify status change + if ( KErrNone == aResult ) + { + CompleteNotifyStatusChange( RPacketContext::EStatusInactive ); + // and reset possible session list + if( iServicesArray ) + { + iServicesArray->iSessionIdList.Reset(); + iServicesArray->iSessionIdList.Compress(); + } + } + else + { + CompleteNotifyStatusChange( iContextStatusBeforeDeactivation ); + + // remove only entries which were succesfully removed + if( (aDataPackage) && (aResult == KErrMbmsImpreciseServiceEntries) ) + { + TInfoName* contextName = NULL; + RPacketMbmsContext::CMbmsSession* listOfFailedEntries = NULL; + aDataPackage->UnPackData( &contextName, &listOfFailedEntries); + if( listOfFailedEntries ) + { + for( TInt i = 0; i < listOfFailedEntries->iSessionIdList.Count(); i++ ) + { + for( TInt ii = 0; ii < iServicesArray->iSessionIdList.Count(); ii++ ) + { + if( listOfFailedEntries->iSessionIdList[i] == iServicesArray->iSessionIdList[ii] ) + { + iServicesArray->iSessionIdList.Remove(ii); + iServicesArray->iSessionIdList.Compress(); + ii = iServicesArray->iSessionIdList.Count(); + } + } + } + } + } + } + + // Complete the client request + if ( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) + { + CMmMBMSContextTsy::ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::DeleteL +// Delete a context id previously created on the phone. +// Note that although the context is considered as 'deleted', the +// client's RPacketMbmsContext subsession remains. To remove this, a client must +// call Close() from RPacketMbmsContext. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::DeleteL() + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::DeleteL. Context name:%S", &iContextName ); + + TInt ret( KErrNotReady ); + if( RPacketContext::EStatusUnknown != ContextStatus() ) + { + CMmDataPackage data; + data.PackData( &iContextName ); + + ret = iMmPacketService->MessageManager()->HandleRequestL( + EPacketContextDelete, &data ); + + } + + if ( KErrNone == ret ) + { + // Store the request handle + iReqHandleType = EMultimodeMbmsContextDelete; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteDelete +// Complete the asynchronous Delete request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// + +void CMmMBMSContextTsy::CompleteDelete( + TInt aResult ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteDelete. Error: %d", aResult ); + + if( KErrNone == aResult ) + { + iContextStatusBeforeDeactivation = RPacketContext::EStatusDeleted; + + // Notify status change + CompleteNotifyStatusChange( RPacketContext::EStatusDeleted ); + + delete iConfig; + iConfig = NULL; + } + + // Reset the req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextDelete ); + + if ( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) + { + // Complete the client request + CMmMBMSContextTsy::ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::GetConfig +// Requests the current configuration of the context. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::GetConfig( + TTsyReqHandle aTsyReqHandle, + TPacketDataConfigBase* aConfig ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::GetConfig. Context name:%S", &iContextName ); + TInt ret( KErrNone ); + + // Check that the mode given in aConfig is KConfigMBMS + if ( TPacketDataConfigBase::KConfigMBMS == aConfig->ExtensionId() ) + { + // Set configuration data to ETel side memory + *( RPacketMbmsContext::TContextConfigMbmsV1* )aConfig = + *iConfig; + } + else + { + // Given mode is not supported + ret = KErrArgument; + } + + // Complete Request + CMmMBMSContextTsy::ReqCompleted( aTsyReqHandle, ret ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::GetLastErrorCause +// This function retrieves the last error cause to have occurred. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::GetLastErrorCause( + TTsyReqHandle aTsyReqHandle, + TInt* aError ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::GetLastErrorCause. Context name:%S Last error cause: %d", &iContextName, iLastErrorCause ); + + *aError = iLastErrorCause; + CMmMBMSContextTsy::ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::SetLastErrorCause +// Set the last error cause. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::SetLastErrorCause( + TInt aErrorCause ) + { + + iLastErrorCause = aErrorCause; + +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::SetLastErrorCause. aErrorCause: %d iLastErrorCause:%d", + aErrorCause, iLastErrorCause ); + + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::GetStatus +// Allows a client to get the current status of the context. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::GetStatus( + TTsyReqHandle aTsyReqHandle, + RPacketContext::TContextStatus* aContextStatus ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::GetStatus. Context name: %S Context Status:%d", &iContextName, iContextStatus ); + *aContextStatus = iContextStatus; + CMmMBMSContextTsy::ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::NotifyConfigChanged +// Requests notification when configuration of context changes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::NotifyConfigChanged( + TPacketDataConfigBase* aConfig ) + { +TFLOGSTRING( "TSY: CMmMBMSContextTsy::NotifyConfigChanged." ); + + // Check that used mode is MBMS + if ( TPacketDataConfigBase::KConfigMBMS != aConfig->ExtensionId() ) + { + return KErrArgument; + } + + // Store pointer + iRetNotifyConfig = aConfig; + // Store req handle type + iReqHandleType = EMultimodeMbmsContextNotifyConfigChanged; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteNotifyConfigChanged +// Complete notification when the context configuration changes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteNotifyConfigChanged(const CMmDataPackage* aDataPackage, + TInt aResult) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteNotifyConfigChanged. Context name:%S", + &iContextName ); + if(aDataPackage != NULL) + { + if ( KErrNone == aResult ) + { + RPacketMbmsContext::TContextConfigMbmsV1* aConfig = NULL; + TInfoName* name = NULL; + aDataPackage->UnPackData( &name, &aConfig ); + + if( NULL != aConfig ) + { + iConfig->iTmgi = aConfig->iTmgi; + iConfig->iMbmsAccessBearer = aConfig->iMbmsAccessBearer; + iConfig->iMbmsServicePriority = aConfig->iMbmsServicePriority; + iConfig->iMbmsServiceMode = aConfig->iMbmsServiceMode; + iConfig->iMbmsSessionFlag = aConfig->iMbmsSessionFlag; + + } + } + } + + // Get and reset req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextNotifyConfigChanged ); + + if ( EMultimodePacketContextReqHandleUnknown != reqHandle ) + { +#ifdef USING_CTSY_DISPATCHER + //CTSY defect, request is completed with KErrNone, aResult ignored. + if( (iConfig) && (aResult == KErrNone) ) +#else + if( NULL != iConfig ) +#endif //USING_CTSY_DISPATCHER + { + + *( RPacketMbmsContext::TContextConfigMbmsV1* )iRetNotifyConfig = *iConfig; + // Null ret pointer + iRetNotifyConfig = NULL; + } + + // Complete the client request +#ifdef USING_CTSY_DISPATCHER + CMmMBMSContextTsy::ReqCompleted( reqHandle, aResult ); +#else + CMmMBMSContextTsy::ReqCompleted( reqHandle, KErrNone ); +#endif //USING_CTSY_DISPATCHER + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::NotifyStatusChange +// Requests notification when the status of the context changes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::NotifyStatusChange( + RPacketContext::TContextStatus* aContextStatus ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::NotifyStatusChange. Context name:%S", &iContextName ); + iRetNotifyStatus = aContextStatus; + iReqHandleType = EMultimodeMbmsContextNotifyStatusChange; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteNotifyStatusChange +// Complete the notification when the context status changes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteNotifyStatusChange( + RPacketContext::TContextStatus aContextStatus ) + { + if ( aContextStatus != iContextStatus ) + { + iContextStatus = aContextStatus; +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::CompleteNotifyStatusChange. Context name: %S Context status:%d", + &iContextName, iContextStatus ); + + if ( RPacketContext::EStatusActive == iContextStatus || + RPacketContext::EStatusInactive == iContextStatus || + RPacketContext::EStatusDeleted == iContextStatus ) + { + iMmPacketService->ContextStatusChanged( iContextStatus ); + if( RPacketContext::EStatusDeleted == iContextStatus ) + { + iContextStatusBeforeDeactivation = RPacketContext::EStatusDeleted; + } + } + + // if context status is receiving, update dynamic caps + if ( RPacketContext::EStatusReceiving == iContextStatus) + { + iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag( RPacketService::KCapsMBMS, ETrue ); + } + // context status is changing from receiving to something else + else + { + iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag( RPacketService::KCapsMBMS, EFalse ); + } + + // Reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextNotifyStatusChange ); + + if (( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) && (iRetNotifyStatus != NULL)) + { + // Get current status + *iRetNotifyStatus = aContextStatus; + // Null ret pointer + iRetNotifyStatus = NULL; + // Complete the client request + CMmMBMSContextTsy::ReqCompleted( reqHandle, KErrNone ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteNotifyStatusChange +// Complete the notification when the context status changes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteNotifyStatusChange( + const CMmDataPackage* aDataPackage, + TInt aResult ) + { + if( KErrNone != aResult ) + { + SetLastErrorCause( aResult ); + } + else + { + TInfoName* null= NULL; + RPacketContext::TContextStatus contextStatus; + + //initialise struct for completion params + TContextMisc misc; + + aDataPackage->UnPackData( null, misc ); + contextStatus = misc.iStatus; + + CMmMBMSContextTsy::CompleteNotifyStatusChange(contextStatus); + } + + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::SetConfigL +// Configure a context to the phone. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::SetConfigL( + TPacketDataConfigBase* aConfig ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::SetConfigL. Context name:%S", &iContextName ); + + TInt ret( KErrArgument ); + + if ( TPacketDataConfigBase::KConfigMBMS == aConfig->ExtensionId() ) + { + if( !iIsInitialiseAllowed ) + { + + RPacketMbmsContext::TContextConfigMbmsV1* configMbms = + ( RPacketMbmsContext::TContextConfigMbmsV1* )aConfig; + + if ( NULL == iTempConfig ) + { + // Allocate memory for iTempConfig + iTempConfig = + new ( ELeave ) RPacketMbmsContext::TContextConfigMbmsV1(); + } + + // Temporary store the configMBMS + *iTempConfig = *configMbms; + + CMmDataPackage data; + data.PackData( &( *aConfig ), &iContextName ); + +TFLOGSTRING2("TSY: CMmMBMSContextTsy::SetConfigL. Context: %S", &iContextName); + + ret = iMmPacketService->MessageManager()->HandleRequestL( + EPacketContextSetConfig, &data ); + + if ( KErrNone != ret ) + { + // Release the memory allocated for iTempConfig + delete iTempConfig; + iTempConfig = NULL; + } + } + else + { + ret = KErrNotReady; + } + } + + if ( KErrNone == ret ) + { + // Store the request handle type + iReqHandleType = EMultimodePacketMbmsContextSetConfig; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteSetConfig +// Complete the asynchronous SetConfig request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteSetConfig( + TInt aError ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::CompleteSetConfig. Error: %d", aError ); + + if( (KErrNone == aError) && (iConfig) && (iTempConfig) ) + { + *iConfig = *iTempConfig; + // Release the memory allocated for iTempConfig + delete iTempConfig; + iTempConfig = NULL; + CompleteNotifyConfigChanged(); + } + + TTsyReqHandle reqHandle( EMultimodePacketMbmsReqHandleUnknown ); + reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(EMultimodePacketMbmsContextSetConfig ); + + if ( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) + { + // Complete the client request + CMmMBMSContextTsy::ReqCompleted( reqHandle, aError ); + } + + } + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ContextStatus +// Return current context status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +RPacketContext::TContextStatus CMmMBMSContextTsy::ContextStatus() const + { + return iContextStatus; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ReqCompleted +// Overloads CTelObject::ReqCompleted. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// + +void CMmMBMSContextTsy::ReqCompleted( + TTsyReqHandle aTsyReqHandle, + TInt aError ) + { +TFLOGSTRING3( "TSY: CMmMBMSContextTsy::ReqCompleted. Handle:%d Error:%d", aTsyReqHandle, aError ); + + // Set last error cause + if ( KErrNone != aError ) + { + iLastErrorCause = aError; + } + + CTelObject::ReqCompleted( aTsyReqHandle, aError ); + + } + +#ifdef REQHANDLE_TIMER + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::SetTypeOfResponse +// Sets the type of response for a given request handle. Automatic mode +// includes an automatic response in case of non response from the DOS in a +// specified time. This method is used only if REQHANDLE_TIMER is in use. +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::SetTypeOfResponse( + TInt aReqHandleType, + TTsyReqHandle aTsyReqHandle ) + { + TInt timeOut( 0 ); + + // Set timeout by req handle type + switch ( aReqHandleType ) + { + case EMultimodePacketMbmsInitialiseContext: + timeOut = KMmPacketContextInitialiseContextTimeOut; + break; + case EMultimodePacketMbmsContextSetConfig: + timeOut = KMmPacketContextSetConfigTimeOut; + break; + case EMultimodeMbmsContextActivate: + timeOut = KMmPacketContextActivateTimeOut; + break; + case EMultimodeMbmsContextDeactivate: + timeOut = KMmPacketContextDeactivateTimeOut; + break; + case EMultimodeMbmsContextDelete: + timeOut = KMmPacketContextDeleteTimeOut; + break; + case EMultimodeMbmsContextUpdateMbmsSessionList: + timeOut = KMmPacketContextModifyActiveContext; + break; + // Can't use timer: + // - all notifications + //case EMultimodePacketContextNotifyConfigChanged: + //case EMultimodePacketContextNotifyConnectionSpeedChange: + //case EMultimodePacketContextNotifyStatusChange: + default: + // Do not use timer + iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, + aTsyReqHandle ); + break; + } + + if ( 0 < timeOut ) + { + // The timeout parameter is given in seconds. + iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, aTsyReqHandle, + timeOut ); + } + + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::Complete +// Completes the request due the timer expiration. This method is used only if +// REQHANDLE_TIMER is in use. +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::Complete( + const TInt aReqHandleType, + const TInt aError ) + { +TFLOGSTRING2( "TSY: CMmMBMSContextTsy::Complete. Req type %d", aReqHandleType ); + + + // All possible TSY req handle types are listed in the + // switch case below. + switch ( aReqHandleType ) + { + case EMultimodePacketMbmsInitialiseContext: + CMmMBMSContextTsy::CompleteInitialiseContext( aError, NULL ); + break; + case EMultimodePacketMbmsContextSetConfig: + CMmMBMSContextTsy::CompleteSetConfig( aError ); + break; + case EMultimodeMbmsContextActivate: + CMmMBMSContextTsy::CompleteActivate( aError ); + break; + case EMultimodeMbmsContextDeactivate: + CMmMBMSContextTsy::CompleteDeactivate( NULL, aError ); + break; + case EMultimodeMbmsContextDelete: + CMmMBMSContextTsy::CompleteDelete( aError ); + break; + case EMultimodeMbmsContextUpdateMbmsSessionList: + CMmMBMSContextTsy::CompleteUpdateMbmsSessionList( aError ); + break; + // Can't use timer: + // - all notifications + //case EMultimodePacketContextNotifyConfigChanged: + //case EMultimodePacketContextNotifyConnectionSpeedChange: + //case EMultimodePacketContextNotifyStatusChange: + default: + CMmMBMSContextTsy::ReqCompleted( iTsyReqHandleStore-> + ResetTsyReqHandle( aReqHandleType ), aError ); + break; + } + + } + +#endif // REQHANDLE_TIMER + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::IsContextActivationAllowed +// Tells if context activation is allowed. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CMmMBMSContextTsy::IsContextActivationAllowed() const + { + return iIsActivateAllowed; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ContextName +// This method returns name of this context +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +const TInfoName &CMmMBMSContextTsy::ContextName() const + { + return iContextName; + } + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ContextIndex +// This method returns name of this context +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::ContextIndex() const + { + return iObjectId; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::UpdateMbmsSessionList +// Method to change content of session list +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::UpdateMbmsSessionList( + TMbmsAction* aAction, + TMbmsSessionId* aSession ) + { +TFLOGSTRING3("TSY: CMmMBMSContextTsy::UpdateMbmsSessionList. Context: %S, action: %d", &iContextName, aAction); + TInt ret( KErrNone ); + + if( iConfig->iMbmsSessionFlag ) + { + iAction = *aAction; + iSession = *aSession; + + // changes send to LTSY + TMmMbmsActiveServiceListParams activeServiceList; + activeServiceList.iActionType = iAction; + activeServiceList.iServiceList = iServicesArray; + activeServiceList.iChangedItem = iSession; + + CMmDataPackage data; + data.PackData( &iContextName, &activeServiceList ); + + TRAPD(err, ret = iMmPacketService->MessageManager()->HandleRequestL( + EPacketContextUpdateMbmsSessionList, &data )); + if(err !=KErrNone) + { + ret = err; + } + } + else + // this context does not support sessions + { + ret = KErrNotSupported; + } + + if ( KErrNone == ret ) + { + // Store the request handle type + iReqHandleType = EMultimodeMbmsContextUpdateMbmsSessionList; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CompleteUpdateMbmsSessionList +// Complete change in content of session list to client +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmMBMSContextTsy::CompleteUpdateMbmsSessionList( + const TInt aResult ) + { +TFLOGSTRING3("TSY: CMmMBMSContextTsy::CompleteUpdateMbmsSessionList. Context: %S, result: %d", &iContextName, aResult); + + TInt ret( aResult ); + + if( iMmPacketService->MaximumActiveServices() > iMmPacketService->EnumerateMbmsActiveServices() ) + { + if( KErrNone == ret ) + { + switch( iAction ) + { + case EAddEntries: + { + // verify that item id does not exists + for( TInt i=0; iiSessionIdList.Count(); i++ ) + { + if( iServicesArray->iSessionIdList[i] == iSession ) + { + // item already exists + ret = KErrAlreadyExists; + i = iServicesArray->iSessionIdList.Count(); + } + } + // if ID is a new one; add it to array + if( KErrNone == ret ) + { + iServicesArray->iSessionIdList.Append(iSession); + iServicesArray->iSessionIdList.Compress(); + } + break; + } + case ERemoveEntries: + { + TInt idx( -1 ); + // find index of item to remove + for( TInt i=0; iiSessionIdList.Count(); i++ ) + { + if( iServicesArray->iSessionIdList[i] == iSession ) + { + idx = i; + i = iServicesArray->iSessionIdList.Count(); + } + } + // item is in array, remove it + if( 0 <= idx ) + { + iServicesArray->iSessionIdList.Remove(idx); + iServicesArray->iSessionIdList.Compress(); + } + else + { + ret = KErrNotFound; + } + break; + + } + case ERemoveAllEntries: + { + // just empty array + iServicesArray->iSessionIdList.Reset(); + iServicesArray->iSessionIdList.Compress(); + break; + } + default: + break; + } + } + } + else + { + ret = KErrOverflow; + } + + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + EMultimodeMbmsContextUpdateMbmsSessionList ); + + if ( EMultimodePacketMbmsReqHandleUnknown != reqHandle ) + { + // Complete the client request + CMmMBMSContextTsy::ReqCompleted( reqHandle, ret ); + } + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::GetMbmsActiveServicesPhase1L +// First phase of MBMS session retrieval +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::GetMbmsActiveServicesPhase1L( + TTsyReqHandle aTsyReqHandle, + RMobilePhone::TClientId* aClient, + TInt* aBufSize ) + { + TInt ret( KErrNone ); +TFLOGSTRING("TSY: CMmMBMSContextTsy::GetMbmsActiveServicesPhase1L"); + + if (iServicesArray->iSessionIdList.Count() > 0) + { + // Presently internal attribute, used only by this method. + iClientId = *aClient; + + // Serialize data (RPacketMbmsContext::CMbmsSession) + // into iActiveSessionInfoBuffer + iServicesArray->ExternalizeL( iActiveSessionInfoBuffer ); + + *aBufSize = iActiveSessionInfoBuffer->Length(); + + ReqCompleted( aTsyReqHandle, KErrNone ); + } + else + { + ret = KErrNotFound; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::GetMbmsActiveServicesPhase2L +// Second phase of MBMS session retrieval +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::GetMbmsActiveServicesPhase2L( + TTsyReqHandle aTsyReqHandle, + RMobilePhone::TClientId* aClient, + TDes8* aBuffer ) + { +TFLOGSTRING("TSY: CMmMBMSContextTsy::GetMbmsActiveServicesPhase2L"); + + TInt error = KErrNone; + + // Check client id + if (( aClient->iSessionHandle != iClientId.iSessionHandle + || aClient->iSubSessionHandle != + iClientId.iSubSessionHandle ) || (iActiveSessionInfoBuffer == NULL)) + { + error = KErrBadHandle; + } + else + { + // Copy data to client buffer + TPtr8 bufPtr = iActiveSessionInfoBuffer->Des(); + if ( bufPtr.Length() <= aBuffer->Length() ) + { + aBuffer->Copy( bufPtr ); + } + else + { + error = KErrArgument; + } + + // delete the buffer + if ( iActiveSessionInfoBuffer ) + { + delete iActiveSessionInfoBuffer; + iActiveSessionInfoBuffer = NULL; + } + } + ReqCompleted( aTsyReqHandle, error ); + return KErrNone; + } + + + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::CancelGetMbmsActiveServicesPhase1 +// Cancelling MBMS session retrieval +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::CancelGetMbmsActiveServicesPhase1() + { + // delete the buffer + if ( iActiveSessionInfoBuffer ) + { + delete iActiveSessionInfoBuffer; + iActiveSessionInfoBuffer = NULL; + } + + ReqCompleted( iTsyReqHandle, KErrCancel ); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::SessionCount +// Returns the session count to a MBMS context +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmMBMSContextTsy::SessionCount() + { + + return iServicesArray->iSessionIdList.Count(); + + } + +// --------------------------------------------------------------------------- +// CMmMBMSContextTsy::ContextType +// return the context type +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CMmPacketContextTsy::TPacketContextType CMmMBMSContextTsy::ContextType() const +{ + return EContextTypeMBMS; +} + +// End of File