diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolmultipartyinterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolmultipartyinterface.h Thu Aug 12 13:20:01 2010 +0100 @@ -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 + +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& 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_*/