// 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

 @publishedPartner

 @released

*/

#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_*/