--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/src/ccallcontrolmultipartydispatcher.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,426 @@
+// 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 "ccallcontrolmultipartydispatcher.h"
+
+#include <ctsy/ltsy/mltsydispatchcallcontrolmultipartyinterface.h>
+#include <ctsy/pluginapi/mmmessagemanagercallback.h>
+
+#include <ctsy/ltsy/ltsylogger.h>
+#include "ctsydispatcherpanic.h"
+#include "tdispatcherholder.h"
+
+CCallControlMultipartyDispatcher::CCallControlMultipartyDispatcher(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ : iLtsyFactoryV1(aLtsyFactory),
+ iMessageManagerCallback(aMessageManagerCallback),
+ iRequestAsyncOneShot(aRequestAsyncOneShot)
+ {
+ } // CCallControlMultipartyDispatcher::CCallControlMultipartyDispatcher
+
+
+CCallControlMultipartyDispatcher::~CCallControlMultipartyDispatcher()
+ {
+ } // CCallControlMultipartyDispatcher::~CCallControlMultipartyDispatcher
+
+
+CCallControlMultipartyDispatcher* CCallControlMultipartyDispatcher::NewLC(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ {
+ TSYLOGENTRYEXIT;
+ CCallControlMultipartyDispatcher* self =
+ new (ELeave) CCallControlMultipartyDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ } // CCallControlMultipartyDispatcher::NewLC
+
+
+CCallControlMultipartyDispatcher* CCallControlMultipartyDispatcher::NewL(
+ MLtsyDispatchFactoryV1& aLtsyFactory,
+ MmMessageManagerCallback& aMessageManagerCallback,
+ CRequestQueueOneShot& aRequestAsyncOneShot)
+ {
+ TSYLOGENTRYEXIT;
+ CCallControlMultipartyDispatcher* self =
+ CCallControlMultipartyDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+ CleanupStack::Pop (self);
+ return self;
+ } // CCallControlMultipartyDispatcher::NewL
+
+
+void CCallControlMultipartyDispatcher::ConstructL()
+/**
+ * Second phase constructor.
+ */
+ {
+ TSYLOGENTRYEXIT;
+
+ // Get the Licensee LTSY interfaces related to CallControlMultiparty functionality
+ // from the factory
+
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlMultipartyFuncUnitId, MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId))
+ {
+ TAny* conferenceHangUpInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId,
+ conferenceHangUpInterface);
+ iLtsyDispatchCallControlMultipartyConferenceHangUp =
+ static_cast<MLtsyDispatchCallControlMultipartyConferenceHangUp*>(conferenceHangUpInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlMultipartyConferenceHangUp, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlMultipartyFuncUnitId, MLtsyDispatchCallControlMultipartyConferenceAddCall::KLtsyDispatchCallControlMultipartyConferenceAddCallApiId))
+ {
+ TAny* conferenceAddCallInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlMultipartyConferenceAddCall::KLtsyDispatchCallControlMultipartyConferenceAddCallApiId,
+ conferenceAddCallInterface);
+ iLtsyDispatchCallControlMultipartyConferenceAddCall =
+ static_cast<MLtsyDispatchCallControlMultipartyConferenceAddCall*>(conferenceAddCallInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlMultipartyConferenceAddCall, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlMultipartyFuncUnitId, MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId))
+ {
+ TAny* createConferenceInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId,
+ createConferenceInterface);
+ iLtsyDispatchCallControlMultipartyCreateConference =
+ static_cast<MLtsyDispatchCallControlMultipartyCreateConference*>(createConferenceInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlMultipartyCreateConference, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlMultipartyFuncUnitId, MLtsyDispatchCallControlMultipartyConferenceSwap::KLtsyDispatchCallControlMultipartyConferenceSwapApiId))
+ {
+ TAny* conferenceSwapInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlMultipartyConferenceSwap::KLtsyDispatchCallControlMultipartyConferenceSwapApiId,
+ conferenceSwapInterface);
+ iLtsyDispatchCallControlMultipartyConferenceSwap =
+ static_cast<MLtsyDispatchCallControlMultipartyConferenceSwap*>(conferenceSwapInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlMultipartyConferenceSwap, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+
+ if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchCallControlMultipartyFuncUnitId, MLtsyDispatchCallControlMultipartyConferenceGoOneToOne::KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId))
+ {
+ TAny* conferenceGoOneToOneInterface = NULL;
+ iLtsyFactoryV1.GetDispatchHandler(
+ MLtsyDispatchCallControlMultipartyConferenceGoOneToOne::KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId,
+ conferenceGoOneToOneInterface);
+ iLtsyDispatchCallControlMultipartyConferenceGoOneToOne =
+ static_cast<MLtsyDispatchCallControlMultipartyConferenceGoOneToOne*>(conferenceGoOneToOneInterface);
+ __ASSERT_DEBUG(iLtsyDispatchCallControlMultipartyConferenceGoOneToOne, CtsyDispatcherPanic(EInvalidNullPtr));
+ }
+ } // CCallControlMultipartyDispatcher::ConstructL
+
+void CCallControlMultipartyDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)
+/**
+ * Set the dispatcher holder.
+ *
+ * @param aDispatcherHolder Reference to dispatcher holder.
+ */
+ {
+ TSYLOGENTRYEXIT;
+
+ iDispatcherHolder = &aDispatcherHolder;
+ } // CCallControlMultipartyDispatcher::SetDispatcherHolder
+
+TInt CCallControlMultipartyDispatcher::DispatchConferenceHangUpL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileConferenceCallHangUp
+ * 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 (iLtsyDispatchCallControlMultipartyConferenceHangUp)
+ {
+ RArray<TInt>* pCallIds = NULL;
+ aDataPackage->UnPackData(&pCallIds);
+ ret = iLtsyDispatchCallControlMultipartyConferenceHangUp->HandleConferenceHangUpReqL(*pCallIds);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CCallControlMultipartyDispatcher::DispatchConferenceHangUpL
+
+TInt CCallControlMultipartyDispatcher::DispatchConferenceAddCallL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileConferenceCallAddCall
+ * 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 (iLtsyDispatchCallControlMultipartyConferenceAddCall)
+ {
+ TInt callId;
+ RMobilePhone::TMobileService mode;
+ const CCallDataPackage& callDataPackage = *static_cast<const CCallDataPackage*>(aDataPackage);
+ callDataPackage.GetCallIdAndMode(callId, mode);
+ TInt existingCallId;
+ callDataPackage.UnPackData(existingCallId);
+
+ ret = iLtsyDispatchCallControlMultipartyConferenceAddCall->HandleConferenceAddCallReqL(callId, existingCallId);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CCallControlMultipartyDispatcher::DispatchConferenceAddCallL
+
+TInt CCallControlMultipartyDispatcher::DispatchCreateConferenceL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileConferenceCallCreateConference
+ * 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 (iLtsyDispatchCallControlMultipartyCreateConference)
+ {
+ TInt heldCallId;
+ TInt secondCallId;
+ RMobilePhone::TMobileService mode;
+ const CCallDataPackage& callDataPackage = *static_cast<const CCallDataPackage*>(aDataPackage);
+ callDataPackage.GetCallIdAndMode(heldCallId, mode);
+ callDataPackage.UnPackData(secondCallId);
+
+ ret = iLtsyDispatchCallControlMultipartyCreateConference->HandleCreateConferenceReqL(heldCallId, secondCallId);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CCallControlMultipartyDispatcher::DispatchCreateConferenceL
+
+TInt CCallControlMultipartyDispatcher::DispatchConferenceSwapL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileConferenceCallSwap
+ * 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 (iLtsyDispatchCallControlMultipartyConferenceSwap)
+ {
+ TInt callId;
+ TInt heldCallId;
+ TInt connectedCallId;
+ RMobilePhone::TMobileService mode;
+ const CCallDataPackage& callDataPackage = *static_cast<const CCallDataPackage*>(aDataPackage);
+ callDataPackage.GetCallIdAndMode(callId, mode);
+ callDataPackage.UnPackData(heldCallId, connectedCallId);
+ ret = iLtsyDispatchCallControlMultipartyConferenceSwap->HandleConferenceSwapReqL(heldCallId, connectedCallId);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CCallControlMultipartyDispatcher::DispatchConferenceSwapL
+
+TInt CCallControlMultipartyDispatcher::DispatchConferenceGoOneToOneL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobileCallGoOneToOne
+ * 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 (iLtsyDispatchCallControlMultipartyConferenceGoOneToOne)
+ {
+ TInt callId;
+ RMobilePhone::TMobileService mode;
+ const CCallDataPackage& callDataPackage = *static_cast<const CCallDataPackage*>(aDataPackage);
+ callDataPackage.GetCallIdAndMode(callId, mode);
+ ret = iLtsyDispatchCallControlMultipartyConferenceGoOneToOne->HandleConferenceGoOneToOneReqL(callId);
+ }
+
+ return TSYLOGSETEXITERR(ret);
+ } // CCallControlMultipartyDispatcher::DispatchConferenceGoOneToOneL
+
+
+//
+// Callback handlers follow
+//
+
+void CCallControlMultipartyDispatcher::CallbackConferenceHangUp(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceHangUpComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ // Only need to complete IPC to CTSY on a failure because
+ // call status change notifications (to idle) will signify that the
+ // conference has been hung up.
+ if (aError != KErrNone)
+ {
+ iMessageManagerCallback.Complete(EMobileConferenceCallHangUp, aError);
+ }
+
+ } // CCallControlMultipartyDispatcher::CallbackConferenceHangUp
+
+void CCallControlMultipartyDispatcher::CallbackConferenceAddCall(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceAddCallComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ *
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ // Only complete failure to CTSY. Success is indicated by change in call
+ // status via mobile call status change notifications.
+ if (aError != KErrNone)
+ {
+ iMessageManagerCallback.Complete(EMobileConferenceCallAddCall, aError);
+ }
+
+ } // CCallControlMultipartyDispatcher::CallbackConferenceAddCall
+
+void CCallControlMultipartyDispatcher::CallbackCreateConference(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackCallControlMultipartyCreateConferenceComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ // Only complete IPC back to CTSY in the case of an error.
+ // If the create conference request was made successfully, CTSY will be
+ // notified of successful completion of this request when the call statuses
+ // of the calls in the conference call change.
+ if (aError != KErrNone)
+ {
+ iMessageManagerCallback.Complete(EMobileConferenceCallCreateConference, aError);
+ }
+
+ } // CCallControlMultipartyDispatcher::CallbackCreateConference
+
+void CCallControlMultipartyDispatcher::CallbackConferenceSwap(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceSwapComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ *
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+ // Only complete IPC back to CTSY in the case of an error.
+ // If the swap request was made successfully, CTSY will be
+ // notified of successful completion of this request when the call statuses
+ // of the calls in the conference call change.
+ if (aError != KErrNone)
+ {
+ iMessageManagerCallback.Complete(EMobileConferenceCallSwap, aError);
+ }
+
+ } // CCallControlMultipartyDispatcher::CallbackConferenceSwap
+
+void CCallControlMultipartyDispatcher::CallbackConferenceGoOneToOne(TInt aError, TInt aCallId)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceGoOneToOneComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ *
+ * @param aCallId The Call ID to which the One-To-One request refers.
+ */
+ {
+ TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);
+
+ if (aError != KErrNone)
+ {
+ CCallDataPackage dataPackage;
+ dataPackage.SetCallIdAndMode(aCallId, RMobilePhone::EServiceUnspecified);
+ iMessageManagerCallback.Complete(EMobileCallGoOneToOne, &dataPackage, aError);
+ }
+
+ } // CCallControlMultipartyDispatcher::CallbackConferenceGoOneToOne
+
+
+
+void CCallControlMultipartyDispatcher::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: CCallControlMultipartyDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc);
+ __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc));
+ break;
+ } // switch (aIpcDataPackage.iIpc)
+
+ } // CCallControlMultipartyDispatcher::CallbackSync
+
+
+