1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to CallControlMultiparty related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_

    28 #define MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 

    32 class MLtsyDispatchCallControlMultipartyConferenceHangUp : public MLtsyDispatchInterface

    33 	{

    34 public:

    35 

    36 	static const TInt KLtsyDispatchCallControlMultipartyConferenceHangUpApiId = KDispatchCallControlMultipartyFuncUnitId + 1;

    37 

    38 	/**

    39 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallHangUp

    40 	 * request from the CTSY.

    41 	 *

    42 	 * It is a request call that is completed by invoking

    43 	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceHangUpComp()

    44 	 *

    45 	 * Implementation of this interface should terminate the active conference call.

    46 	 *

    47 	 * @param aCallIds Array of all Call IDs, which belong to the conference.

    48 	 * This array will be destroyed after the function call returns.

    49 	 *

    50 	 * @return KErrNone on success, otherwise another error code indicating the

    51 	 * failure.

    52 	 *

    53 	 * @see RMobileConferenceCall::HangUp()

    54 	 */

    55 	virtual TInt HandleConferenceHangUpReqL(const RArray<TInt>& aCallIds) = 0;

    56 

    57 	}; // class MLtsyDispatchCallControlMultipartyConferenceHangUp

    58 

    59 

    60 

    61 class MLtsyDispatchCallControlMultipartyConferenceAddCall : public MLtsyDispatchInterface

    62 	{

    63 public:

    64 

    65 	static const TInt KLtsyDispatchCallControlMultipartyConferenceAddCallApiId = KDispatchCallControlMultipartyFuncUnitId + 2;

    66 

    67 	/**

    68 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallAddCall

    69 	 * request from the CTSY.

    70 	 *

    71 	 * It is a request call that is completed by invoking

    72 	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceAddCallComp()

    73 	 *

    74 	 * Implementation of this interface should add the specified call to the conference

    75 	 * call.  Typically, there will be an ongoing conference call containing at least

    76 	 * 2 remote parties.  The conference call gets swapped into the held state and

    77 	 * either a new call is dialled or an incoming call is answered.  This call can

    78 	 * then be added to the conference call using this API.

    79 	 *

    80 	 *

    81 	 * @param aCallId The Call ID of the connected call to be added to the multiparty (conference) call.

    82 	 * @param aExistingCallId The Call ID of one of the calls which is already a part of the conference call.

    83 	 * This can be the Call ID of any of the existing calls in the conference, not necessarily the first one that was added.

    84 	 *

    85 	 * @return KErrNone on success, otherwise another error code indicating the

    86 	 * failure.

    87 	 *

    88 	 * @see RMobileconferenceCall::AddCall()

    89 	 */

    90 	virtual TInt HandleConferenceAddCallReqL(TInt aCallId, TInt aExistingCallId) = 0;

    91 

    92 	}; // class MLtsyDispatchCallControlMultipartyConferenceAddCall

    93 

    94 

    95 

    96 class MLtsyDispatchCallControlMultipartyCreateConference : public MLtsyDispatchInterface

    97 	{

    98 public:

    99 

   100 	static const TInt KLtsyDispatchCallControlMultipartyCreateConferenceApiId = KDispatchCallControlMultipartyFuncUnitId + 3;

   101 

   102 	/**

   103 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallCreateConference

   104 	 * request from the CTSY.

   105 	 *

   106 	 * It is a request call that is completed by invoking

   107 	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyCreateConferenceComp()

   108 	 *

   109 	 * Implementation of this interface should join the two specified calls into a

   110 	 * multiparty (conference) call.

   111 	 *

   112 	 *

   113 	 * @param aHeldCallId The Call ID of the held call which will be one of the calls

   114 	 * joined to the conference.

   115 	 *

   116 	 * @param aSecondCallId The Call ID of the active / alerting call which will be

   117 	 * the other call joined to the conference.

   118 	 *

   119 	 * @return KErrNone on success, otherwise another error code indicating the

   120 	 * failure.

   121 	 *

   122 	 * @see RMobileConferenceCall::CreateConference()

   123 	 */

   124 	virtual TInt HandleCreateConferenceReqL(TInt aHeldCallId, TInt aSecondCallId) = 0;

   125 

   126 	}; // class MLtsyDispatchCallControlMultipartyCreateConference

   127 

   128 

   129 

   130 class MLtsyDispatchCallControlMultipartyConferenceSwap : public MLtsyDispatchInterface

   131 	{

   132 public:

   133 

   134 	static const TInt KLtsyDispatchCallControlMultipartyConferenceSwapApiId = KDispatchCallControlMultipartyFuncUnitId + 4;

   135 

   136 	/**

   137 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallSwap

   138 	 * request from the CTSY.

   139 	 *

   140 	 * It is a request call that is completed by invoking

   141 	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceSwapComp()

   142 	 *

   143 	 * Implementation of this interface should swap the ongoing conference call and

   144 	 * the other call. If the conference call is on hold,

   145 	 * it will become connected and the other call will be held.

   146 	 *

   147 	 * If it is connected, it will be put on hold and the other call will become

   148 	 * connected.

   149 	 *

   150 	 * @param aHeldCallId The Call ID of the currently held call. If the conference

   151 	 * call is on hold then this will be the call ID of one of the calls in the

   152 	 * conference.

   153 	 *

   154 	 * @param aConnectedCallId The Call ID of the currently connected call.

   155 	 * If the conference call is connected then this will be the call ID of one

   156 	 * of the calls in the conference.

   157 	 *

   158 	 * @return KErrNone on success, otherwise another error code indicating the

   159 	 * failure.

   160 	 *

   161 	 * @see RMobileConferenceCall::Swap()

   162 	 */

   163 	virtual TInt HandleConferenceSwapReqL(TInt aHeldCallId, TInt aConnectedCallId) = 0;

   164 

   165 	}; // class MLtsyDispatchCallControlMultipartyConferenceSwap

   166 

   167 

   168 class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne : public MLtsyDispatchInterface

   169 	{

   170 public:

   171 

   172 	static const TInt KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId = KDispatchCallControlMultipartyFuncUnitId + 5;

   173 

   174 	/**

   175 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallGoOneToOne

   176 	 * request from the CTSY.

   177 	 *

   178 	 * It is a request call that is completed by invoking

   179 	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceGoOneToOneComp()

   180 	 *

   181 	 * Implementation of this interface should setup a private communication with the specified call

   182 	 * in the conference.  This call will then become connected when the call status notification

   183 	 * arrives from the LTSY and the other call(s) will go on hold.

   184 	 *

   185 	 * If at the time of the go one-to-one request, there are two remote parties in the conference

   186 	 * call, after the one to one is successful, the other call will go on hold and the conference

   187 	 * will go idle (as there are not enough participants to be a valid conference anymore). If there

   188 	 * are more than two remote parties in the conference call, then the conference call should go

   189 	 * on hold.

   190 	 *

   191 	 * @param aCallId The Call ID of the call which the client wishes to set up a private communication with.

   192 	 * This should be a call currently in the conference.

   193 	 *

   194 	 * @return KErrNone on success, otherwise another error code indicating the

   195 	 * failure.

   196 	 *

   197 	 * @see RMobileCall::GoOneToOne()

   198 	 */

   199 	virtual TInt HandleConferenceGoOneToOneReqL(TInt aCallId) = 0;

   200 

   201 	}; // class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne

   202 

   203 #endif /*MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_*/