--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolmultipartyinterface.h	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,203 @@
+// 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:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to CallControlMultiparty related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_
+#define MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+
+class MLtsyDispatchCallControlMultipartyConferenceHangUp : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceHangUpApiId = KDispatchCallControlMultipartyFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallHangUp
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceHangUpComp()
+	 *
+	 * Implementation of this interface should terminate the active conference call.
+	 *
+	 * @param aCallIds Array of all Call IDs, which belong to the conference.
+	 * This array will be destroyed after the function call returns.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::HangUp()
+	 */
+	virtual TInt HandleConferenceHangUpReqL(const RArray<TInt>& aCallIds) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceHangUp
+
+
+
+class MLtsyDispatchCallControlMultipartyConferenceAddCall : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceAddCallApiId = KDispatchCallControlMultipartyFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallAddCall
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceAddCallComp()
+	 *
+	 * Implementation of this interface should add the specified call to the conference
+	 * call.  Typically, there will be an ongoing conference call containing at least
+	 * 2 remote parties.  The conference call gets swapped into the held state and
+	 * either a new call is dialled or an incoming call is answered.  This call can
+	 * then be added to the conference call using this API.
+	 *
+	 *
+	 * @param aCallId The Call ID of the connected call to be added to the multiparty (conference) call.
+	 * @param aExistingCallId The Call ID of one of the calls which is already a part of the conference call.
+	 * This can be the Call ID of any of the existing calls in the conference, not necessarily the first one that was added.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileconferenceCall::AddCall()
+	 */
+	virtual TInt HandleConferenceAddCallReqL(TInt aCallId, TInt aExistingCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceAddCall
+
+
+
+class MLtsyDispatchCallControlMultipartyCreateConference : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyCreateConferenceApiId = KDispatchCallControlMultipartyFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallCreateConference
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyCreateConferenceComp()
+	 *
+	 * Implementation of this interface should join the two specified calls into a
+	 * multiparty (conference) call.
+	 *
+	 *
+	 * @param aHeldCallId The Call ID of the held call which will be one of the calls
+	 * joined to the conference.
+	 *
+	 * @param aSecondCallId The Call ID of the active / alerting call which will be
+	 * the other call joined to the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::CreateConference()
+	 */
+	virtual TInt HandleCreateConferenceReqL(TInt aHeldCallId, TInt aSecondCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyCreateConference
+
+
+
+class MLtsyDispatchCallControlMultipartyConferenceSwap : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceSwapApiId = KDispatchCallControlMultipartyFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallSwap
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceSwapComp()
+	 *
+	 * Implementation of this interface should swap the ongoing conference call and
+	 * the other call. If the conference call is on hold,
+	 * it will become connected and the other call will be held.
+	 *
+	 * If it is connected, it will be put on hold and the other call will become
+	 * connected.
+	 *
+	 * @param aHeldCallId The Call ID of the currently held call. If the conference
+	 * call is on hold then this will be the call ID of one of the calls in the
+	 * conference.
+	 *
+	 * @param aConnectedCallId The Call ID of the currently connected call.
+	 * If the conference call is connected then this will be the call ID of one
+	 * of the calls in the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::Swap()
+	 */
+	virtual TInt HandleConferenceSwapReqL(TInt aHeldCallId, TInt aConnectedCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceSwap
+
+
+class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId = KDispatchCallControlMultipartyFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallGoOneToOne
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceGoOneToOneComp()
+	 *
+	 * Implementation of this interface should setup a private communication with the specified call
+	 * in the conference.  This call will then become connected when the call status notification
+	 * arrives from the LTSY and the other call(s) will go on hold.
+	 *
+	 * If at the time of the go one-to-one request, there are two remote parties in the conference
+	 * call, after the one to one is successful, the other call will go on hold and the conference
+	 * will go idle (as there are not enough participants to be a valid conference anymore). If there
+	 * are more than two remote parties in the conference call, then the conference call should go
+	 * on hold.
+	 *
+	 * @param aCallId The Call ID of the call which the client wishes to set up a private communication with.
+	 * This should be a call currently in the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::GoOneToOne()
+	 */
+	virtual TInt HandleConferenceGoOneToOneReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne
+
+#endif /*MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_*/