diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/src/ccellbroadcastdispatcher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/src/ccellbroadcastdispatcher.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,488 @@ +// Copyright (c) 2008-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 "ccellbroadcastdispatcher.h" + +#include +#include +#include + + +#include +#include "ctsydispatcherpanic.h" +#include "tdispatcherholder.h" + + + +CCellBroadcastDispatcher::CCellBroadcastDispatcher( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + : iLtsyFactoryV1(aLtsyFactory), + iMessageManagerCallback(aMessageManagerCallback), + iRequestAsyncOneShot(aRequestAsyncOneShot) + { + } // CCellBroadcastDispatcher::CCellBroadcastDispatcher + + +CCellBroadcastDispatcher::~CCellBroadcastDispatcher() + { + if(iCbsMsg) + { + iCbsMsg->ResetAndDestroy(); + delete iCbsMsg; + } + } // CCellBroadcastDispatcher::~CCellBroadcastDispatcher + + +CCellBroadcastDispatcher* CCellBroadcastDispatcher::NewLC( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CCellBroadcastDispatcher* self = + new (ELeave) CCellBroadcastDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } // CCellBroadcastDispatcher::NewLC + + +CCellBroadcastDispatcher* CCellBroadcastDispatcher::NewL( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CCellBroadcastDispatcher* self = + CCellBroadcastDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::Pop (self); + return self; + } // CCellBroadcastDispatcher::NewL + + +void CCellBroadcastDispatcher::ConstructL() +/** + * Second phase constructor. + */ + { + TSYLOGENTRYEXIT; + + // Get the Licensee LTSY interfaces related to CellBroadcast functionality + // from the factory + + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCellBroadcastFuncUnitId, MLtsyDispatchCellBroadcastSetBroadcastFilterSetting::KLtsyDispatchCellBroadcastSetBroadcastFilterSettingApiId)) + { + TAny* setBroadcastFilterSettingInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCellBroadcastSetBroadcastFilterSetting::KLtsyDispatchCellBroadcastSetBroadcastFilterSettingApiId, + setBroadcastFilterSettingInterface); + iLtsyDispatchCellBroadcastSetBroadcastFilterSetting = + static_cast(setBroadcastFilterSettingInterface); + __ASSERT_DEBUG(iLtsyDispatchCellBroadcastSetBroadcastFilterSetting, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCellBroadcastFuncUnitId, MLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage::KLtsyDispatchCellBroadcastActivateBroadcastReceiveMessageApiId)) + { + TAny* activateBroadcastReceiveMessageInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage::KLtsyDispatchCellBroadcastActivateBroadcastReceiveMessageApiId, + activateBroadcastReceiveMessageInterface); + iLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage = + static_cast(activateBroadcastReceiveMessageInterface); + __ASSERT_DEBUG(iLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCellBroadcastFuncUnitId, MLtsyDispatchCellBroadcastReceiveMessageCancel::KLtsyDispatchCellBroadcastReceiveMessageCancelApiId)) + { + TAny* receiveMessageCancelInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCellBroadcastReceiveMessageCancel::KLtsyDispatchCellBroadcastReceiveMessageCancelApiId, + receiveMessageCancelInterface); + iLtsyDispatchCellBroadcastReceiveMessageCancel = + static_cast(receiveMessageCancelInterface); + __ASSERT_DEBUG(iLtsyDispatchCellBroadcastReceiveMessageCancel, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCellBroadcastFuncUnitId, MLtsyDispatchCellBroadcastStartSimCbTopicBrowsing::KLtsyDispatchCellBroadcastStartSimCbTopicBrowsingApiId)) + { + TAny* startSimCbTopicBrowsingInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCellBroadcastStartSimCbTopicBrowsing::KLtsyDispatchCellBroadcastStartSimCbTopicBrowsingApiId, + startSimCbTopicBrowsingInterface); + iLtsyDispatchCellBroadcastStartSimCbTopicBrowsing = + static_cast(startSimCbTopicBrowsingInterface); + __ASSERT_DEBUG(iLtsyDispatchCellBroadcastStartSimCbTopicBrowsing, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCellBroadcastFuncUnitId, MLtsyDispatchCellBroadcastDeleteSimCbTopic::KLtsyDispatchCellBroadcastDeleteSimCbTopicApiId)) + { + TAny* deleteSimCbTopicInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchCellBroadcastDeleteSimCbTopic::KLtsyDispatchCellBroadcastDeleteSimCbTopicApiId, + deleteSimCbTopicInterface); + iLtsyDispatchCellBroadcastDeleteSimCbTopic = + static_cast(deleteSimCbTopicInterface); + __ASSERT_DEBUG(iLtsyDispatchCellBroadcastDeleteSimCbTopic, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + iCbsMsg = new( ELeave ) CArrayPtrFlat< TWcdmaCbsMsg >( 10 ); + + } // CCellBroadcastDispatcher::ConstructL + +void CCellBroadcastDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder) +/** + * Set the dispatcher holder. + * + * @param aDispatcherHolder Reference to dispatcher holder. + */ + { + TSYLOGENTRYEXIT; + + iDispatcherHolder = &aDispatcherHolder; + } // CCellBroadcastDispatcher::SetDispatcherHolder + +TInt CCellBroadcastDispatcher::DispatchSetBroadcastFilterSettingL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileBroadcastMessagingSetFilterSetting + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCellBroadcastSetBroadcastFilterSetting) + { + TCbsCbmiAndLangAndFilter* cbsFilter = NULL; + aDataPackage->UnPackData(&cbsFilter); + + __ASSERT_DEBUG(cbsFilter, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchCellBroadcastSetBroadcastFilterSetting->HandleSetBroadcastFilterSettingReqL(cbsFilter->iSetting); + } + + return TSYLOGSETEXITERR(ret); + } // CCellBroadcastDispatcher::DispatchSetBroadcastFilterSettingL + +TInt CCellBroadcastDispatcher::DispatchActivateBroadcastReceiveMessageL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileBroadcastMessagingReceiveMessage + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage) + { + TCbsCbmiAndLangAndFilter* cbsFilter = NULL; + aDataPackage->UnPackData(&cbsFilter); + + __ASSERT_DEBUG(cbsFilter, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage->HandleActivateBroadcastReceiveMessageReqL(cbsFilter->iSetting); + } + + + return TSYLOGSETEXITERR(ret); + } // CCellBroadcastDispatcher::DispatchActivateBroadcastReceiveMessageL + +TInt CCellBroadcastDispatcher::DispatchReceiveMessageCancelL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EMobileBroadcastMessagingReceiveMessageCancel + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCellBroadcastReceiveMessageCancel) + { + TCbsCbmiAndLangAndFilter* cbsFilter = NULL; + aDataPackage->UnPackData(&cbsFilter); + + __ASSERT_DEBUG(cbsFilter, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchCellBroadcastReceiveMessageCancel->HandleReceiveMessageCancelReqL(cbsFilter->iSetting); + } + + return TSYLOGSETEXITERR(ret); + } // CCellBroadcastDispatcher::DispatchReceiveMessageCancelL + +TInt CCellBroadcastDispatcher::DispatchStartSimCbTopicBrowsingL() +/** + * Pass ECustomStartSimCbTopicBrowsingIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCellBroadcastStartSimCbTopicBrowsing) + { + ret = iLtsyDispatchCellBroadcastStartSimCbTopicBrowsing->HandleStartSimCbTopicBrowsingReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CCellBroadcastDispatcher::DispatchReceiveMessageCancelL + +TInt CCellBroadcastDispatcher::DispatchDeleteSimCbTopicL(const CMmDataPackage* aDataPackage) +/** + * Pass ECustomDeleteSimCbTopicIPC request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchCellBroadcastDeleteSimCbTopic) + { + TUint expIndex; + TBool deleteFlag; + aDataPackage->UnPackData(expIndex, deleteFlag); + ret = iLtsyDispatchCellBroadcastDeleteSimCbTopic->HandleDeleteSimCbTopicReqL(expIndex, deleteFlag); + } + + + return TSYLOGSETEXITERR(ret); + } // CCellBroadcastDispatcher::DispatchActivateBroadcastReceiveMessageL + + +// +// Callback handlers follow +// + + + +void CCellBroadcastDispatcher::CallbackGsmBroadcastNotifyMessageReceived(TInt aError, const TDesC8& aCbsMsg) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastGsmBroadcastNotifyMessageReceivedInd() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aCbsMsg CB message. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + __ASSERT_DEBUG( (aCbsMsg.Length() < RMobileBroadcastMessaging::KBroadcastPageSize) , CtsyDispatcherPanic(EBadLength)); + + // Pack the data to return to the Common TSY + CMmDataPackage data; + TGsmCbsMsg gsmCbsMsg; + gsmCbsMsg.iCbsMsg.Copy(aCbsMsg.Left(RMobileBroadcastMessaging::KBroadcastPageSize)); + data.PackData(&gsmCbsMsg); + + iMessageManagerCallback.Complete(EMmTsyGsmBroadcastNotifyMessageReceived, &data, aError); + + } // CCellBroadcastDispatcher::CallbackGsmBroadcastNotifyMessageReceived + +void CCellBroadcastDispatcher::CallbackWcdmaBroadcastMessageReceived(TInt aError, const TDesC8& aWcdmaCbsData, + const DispatcherCellBroadcast::TWcdmaCbsMsgBase& aWcdmaCbsMsgBase, TBool aMoreToCome) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastWcdmaBroadcastMessageReceivedInd() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aWcdmaCbsData Broadcast message WCDMA. + * @param aWcdmaCbsMsgBase base wcdma cbs data structure. + * @param aIsLast Is it the last WCDMA message to pass to CTSY. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMoreToCome=%d"), aError, aMoreToCome); + if(aError != KErrNone) + { + __ASSERT_DEBUG(aMoreToCome==EFalse, CtsyDispatcherPanic(EInvalidParameter)); + } + + //A TRAP here is expensive, do a non overloaded new operator and check for NULL. + TWcdmaCbsMsg* wcdmaCbsMsgPtr = new TWcdmaCbsMsg(); + if (!wcdmaCbsMsgPtr) + { + // not proceeding + __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EInvalidNullPtr)); + return; + } + // allocation ok: + __ASSERT_DEBUG( (aWcdmaCbsData.Length() < RMobileBroadcastMessaging::KBroadcastPageSize) , CtsyDispatcherPanic(EBadLength)); + wcdmaCbsMsgPtr->iWcdmaCbsData.Copy(aWcdmaCbsData); + wcdmaCbsMsgPtr->iSbNumber = 0; // not used + wcdmaCbsMsgPtr->iNumberOfPages = aWcdmaCbsMsgBase.iNumberOfPages; + wcdmaCbsMsgPtr->iMessageType = aWcdmaCbsMsgBase.iMessageType; + wcdmaCbsMsgPtr->iMessageId = aWcdmaCbsMsgBase.iMessageId; + wcdmaCbsMsgPtr->iSerialNum = aWcdmaCbsMsgBase.iSerialNum; + wcdmaCbsMsgPtr->iDCS = aWcdmaCbsMsgBase.iDCS; + wcdmaCbsMsgPtr->iInfoLength = aWcdmaCbsMsgBase.iInfoLength; + + TRAPD(err,iCbsMsg->AppendL(wcdmaCbsMsgPtr)); + if(err != KErrNone) + { + delete wcdmaCbsMsgPtr; + wcdmaCbsMsgPtr = NULL; + } + + if (!aMoreToCome) + { + TUint8 wcdmaPageNumber = (TUint8)iCbsMsg->Count(); + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&iCbsMsg, &wcdmaPageNumber); + + iMessageManagerCallback.Complete(EMmTsyWcdmaBroadcastNotifyMessageReceived, &dataPackage, aError); + + // handle case, when error on completion: + if(aError != KErrNone) + { + iCbsMsg->ResetAndDestroy(); + } + else + { + iCbsMsg->Reset(); + } + } + + } // CCellBroadcastDispatcher::CallbackWcdmaBroadcastMessageReceived + +void CCellBroadcastDispatcher::CallbackStartSimCbTopicBrowsing(TInt aError, + const CArrayFixFlat& aSimTopicArray ) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastStartSimCbTopicBrowsingComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aSimTopicArray array of TSimCbTopic. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aSimTopicArray.Count()=%d"), aError, aSimTopicArray.Count()); + + CArrayFixFlat* simTopicArrayPtr = &const_cast&>(aSimTopicArray); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&simTopicArrayPtr); + + iMessageManagerCallback.Complete(ECustomStartSimCbTopicBrowsingIPC, &dataPackage, aError); + + } // CCellBroadcastDispatcher::CallbackWcdmaBroadcastMessageReceived + +void CCellBroadcastDispatcher::CallbackDeleteSimCbTopic(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastDeleteSimCbTopicComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(ECustomDeleteSimCbTopicIPC, aError); + + } // CCellBroadcastDispatcher::CallbackWcdmaBroadcastMessageReceived + +void CCellBroadcastDispatcher::CallbackSetBroadcastFilterSetting(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastSetBroadcastFilterSettingComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobileBroadcastMessagingSetFilterSetting, aError); + + } // CCellBroadcastDispatcher::CallbackSetBroadcastFilterSetting + +void CCellBroadcastDispatcher::CallbackActivateBroadcastReceiveMessage(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastActivateBroadcastReceiveMessageComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobileBroadcastMessagingReceiveMessage, aError); + + } // CCellBroadcastDispatcher::CallbackActivateBroadcastReceiveMessage + +void CCellBroadcastDispatcher::CallbackReceiveMessageCancel(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackCellBroadcastReceiveMessageCancelComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EMobileBroadcastMessagingReceiveMessageCancel, aError); + + } // CCellBroadcastDispatcher::CallbackReceiveMessageCancel + +void CCellBroadcastDispatcher::CallbackSync(CRequestQueueOneShot::TIpcDataPackage& aIpcDataPackage) +/** + * Part of the MDispatcherCallback interface. Used to complete requests handled + * synchronously by the Licensee LTSY asynchronously back to the Common TSY. + * + * @param aIpcDataPackage Package encapsulating the request. + * + * @see MDispatcherCallback::CallbackSync + */ + { + TSYLOGENTRYEXIT; + + switch (aIpcDataPackage.iIpc) + { + + default: + LOG(_L8("WARNING: CCellBroadcastDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc); + __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc)); + break; + } // switch (aIpcDataPackage.iIpc) + + } // CCellBroadcastDispatcher::CallbackSync + + +