diff -r 6b1d113cdff3 -r 6638e7f4bd8f telephonyserver/etelmultimode/CETEL/mm_conference.cpp --- a/telephonyserver/etelmultimode/CETEL/mm_conference.cpp Mon May 03 13:37:20 2010 +0300 +++ b/telephonyserver/etelmultimode/CETEL/mm_conference.cpp Thu May 06 15:10:38 2010 +0100 @@ -1,376 +1,376 @@ -// Copyright (c) 1997-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 -#include -#include -#include "mm_hold.h" - -/************************************************************************/ -// -// RMobileConferenceCall -// -/************************************************************************/ - - -EXPORT_C RMobileConferenceCall::RMobileConferenceCall() - : iMmPtrHolder(NULL) -/** Default constructor. */ - { - } - -EXPORT_C void RMobileConferenceCall::ConstructL() -/** Constructs and initializes the RMobileConferenceCall object. -@capability None -*/ - { - __ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed)); - iMmPtrHolder = CMobileConferenceCallPtrHolder::NewL(CMobileConferenceCallPtrHolder::EMaxNumberConferenceCallPtrSlots, - CMobileConferenceCallPtrHolder::EMaxNumberConferenceCallPtrCSlots); - } - -EXPORT_C void RMobileConferenceCall::Destruct() -/** C++ destructor. -@capability None -*/ - { - delete iMmPtrHolder; - iMmPtrHolder = NULL; - ResetSessionHandle(); - } - -EXPORT_C TInt RMobileConferenceCall::Open(RMobilePhone& aPhone) -/** Opens a RMobileConferenceCall conference call sub-session from RMobilePhone. - - The name of the sub-session opened in the TSY will equal the string defined - by the KETelConferenceCall LIT definition. - - This API currently supports only one conference call object in the TSY - so - this means only one conference call can be ongoing at any one time. The conference - call sub-session is opened from the phone (rather than from a line) in order - not to place any restrictions on the types of call that could be added to - the conference. It is up to the TSY to inform clients which calls can be added - to a conference by setting each call's dynamic KCapsJoin capability. - - @param aPhone The phone sub-session used to open the conference call. - @return KErrNone if successful, a system wide error code if not. - -@capability None -*/ - { - RSessionBase* session=&aPhone.SessionHandle(); - __ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle)); - TInt subSessionHandle=aPhone.SubSessionHandle(); - __ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle)); - - TRAPD(ret,ConstructL()); - if (ret) - return ret; - TPtrC name(KETelConferenceCall); - - SetSessionHandle(*session); - TIpcArgs args(&name,TIpcArgs::ENothing,subSessionHandle); - - ret = CreateSubSession(*session,EEtelOpenFromSubSession,args); - if (ret) - Destruct(); - return ret; - } - -EXPORT_C void RMobileConferenceCall::Close() -/** Closes a RMobileConferenceCall sub-session. -@capability None -*/ - { - CloseSubSession(EEtelClose); - Destruct(); - } - -EXPORT_C TInt RMobileConferenceCall::GetCaps(TUint32& aCaps) const -/** - Gets the current capabilities of the conference call. - - @param aCaps On completion, a descriptor that will contain the conference - call capabilities; this consists of the sum of the TMobileConferenceCallCaps - constants. - @return KErrNone - -@capability None -*/ - { - TPckg ptr1(aCaps); - return Get(EMobileConferenceCallGetCaps,ptr1); - } - -EXPORT_C void RMobileConferenceCall::NotifyCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const -/** - Allows clients to be notified when the conference call capabilities change. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyCapsChange) - to cancel a previously placed asynchronous NotifyCapsChange() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - @param aCaps On completion, a descriptor that will contain the new conference - call capabilities, this consists of the sum of the TMobileConferenceCallCaps - constants. - -@capability None -*/ - { - __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); - - TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceCallCapsChange,aCaps); - - Get(EMobileConferenceCallNotifyCapsChange,aReqStatus,ptr1); - } - -EXPORT_C void RMobileConferenceCall::CreateConference(TRequestStatus& aReqStatus) const -/** - Allows clients to create the initial 3-way conference call. - - The phone must be in a state where there are two single voice calls, one on - hold and the other connected or alerting the remote, called party. - - The TSY will reflect the conference creation capability by setting the KCapsJoin - flags of the individual calls and the KCapsCreate flag of the conference call - sub-session. - - In GSM mode, this function member will complete when the TSY has received - confirmation from the network that the conference call service has been successfully - invoked. - - In CDMA mode, this function member will complete when the TSY has sent the - conference create request to the network. There is no response from CDMA networks - to ascertain whether the request failed or succeeded. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallCreateConference) - to cancel a previously placed asynchronous CreateConference() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - -@capability NetworkServices -*/ - { - Blank(EMobileConferenceCallCreateConference,aReqStatus); - } - -EXPORT_C void RMobileConferenceCall::AddCall(TRequestStatus& aReqStatus, const TName& aCallName) const -/** - Adds the single voice call to an existing conference call. - - Only calls whose call control capabilities include KCapsJoin can be added - to a conference call. - - In GSM mode, this function member will complete when the TSY has received - confirmation from the network that the conference call service has been successfully - invoked and the call added. - - In CDMA mode, only 3-way conference calls are currently possible, so after - the initial conference creation it is not possible to add further calls. Therefore - single calls outside of the conference will never have the KCapsJoin capability - set during CDMA mode. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallAddCall) to - cancel a previously placed asynchronous AddCall() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - @param aCallName The call sub-session to add to the conference call. - -@capability NetworkServices -*/ - { - Set(EMobileConferenceCallAddCall,aReqStatus,aCallName); - } - -EXPORT_C void RMobileConferenceCall::Swap(TRequestStatus& aReqStatus) const -/** - Allows a client to switch a conference call between "Active" and "Hold" states. - - This function member will complete either when the conference call has successfully - moved to the opposite state or if the action failed due to some reason. Can - be called by any client that has a handle on the conference call (i.e. not - necessarily the client that first created the conference). - - This action is possible under two circumstances: - - There is just a conference call. This implies that there are no single calls - already in the state to which the client wishes to toggle the conference call. - The client will call Swap on the conference call and if it is active it will - move to the held state and if it is held it will move to the active state. - - There is a conference call and a single call, one currently active and one - on hold. This function member therefore swaps the conference call with the - single call, simultaneously placing the active one on hold and resuming the - held one. - - In either circumstance, the conference call capabilities will include the - KCapsSwap flag. In GSM mode, this function member will complete when the TSY - has received confirmation from the network that the conference call has been - successfully moved to its opposite state. In CDMA mode, this function member - will complete when the TSY has sent the swap request to the network. There - is no response from CDMA networks to ascertain whether the request failed - or succeeded. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallSwap) to cancel - a previously placed asynchronous Swap() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - -@capability NetworkServices -*/ - { - Blank(EMobileConferenceCallSwap,aReqStatus); - } - -EXPORT_C void RMobileConferenceCall::HangUp(TRequestStatus& aReqStatus) const -/** - Terminates the whole conference. - - All calls that are currently part of the conference will also be terminated. - Can be called by any client that has a handle on the conference call (i.e. - not necessarily the client that first created the conference). - - This action is possible if the conference call capabilities include the KCapsHangUp - flag. In GSM mode, this function member will complete when the TSY has received - confirmation from the network that the conference call has been fully released. - - - In CDMA mode, this function member will complete when the TSY has sent the - hang-up request to the network. There is no response from CDMA networks to - ascertain whether the request failed or succeeded. - - After termination, the conference call will consist of zero calls and will - return to the EConferenceIdle state. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallHangUp) to - cancel a previously placed asynchronous HangUp() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - -@capability NetworkServices -*/ - { - Blank(EMobileConferenceCallHangUp,aReqStatus); - } - -EXPORT_C TInt RMobileConferenceCall::EnumerateCalls(TInt& aCount) const -/** - Gets the number of calls (i.e. call objects) that are - currently part of the conference call. - - This number may be zero if a conference call is not active or equal to two - or more if a conference call exists. - - @param aCount On return, the number of calls - will be equal to 0 or >=2. - @return KErrNone - -@capability None -*/ - { - TPckg ptr1(aCount); - return Get(EMobileConferenceCallEnumerateCalls,ptr1); - } - -EXPORT_C TInt RMobileConferenceCall::GetMobileCallInfo(TInt aIndex, TDes8& aCallInfo) const -/** - Gets a current snapshot of the call information associated - with the call specified by the aIndex parameter. - - @param aIndex The index of the call = 0 to aCount-1 where aCount is the returned - value from EnumerateCalls() - @param aCallInfo On completion, a RMobileCall::TMobileCallInfoV1Pckg containing - the large block of call information. - @return KErrNone, if successful, KErrNotFound if call information is not available. - -@capability ReadDeviceData -*/ - { - TPckg ptr1(aIndex); - return Get(EMobileConferenceCallGetMobileCallInfo,ptr1,aCallInfo); - } - -EXPORT_C TInt RMobileConferenceCall::GetConferenceStatus(TMobileConferenceStatus& aStatus) const -/** - Allows clients to retrieve the current status of the conference call. - - @param aStatus On completion, the new conference status. - @return KErrNone if successful, a system wide error code if not. - -@capability None -*/ - { - TPckg ptr1(aStatus); - return Get(EMobileConferenceCallGetConferenceStatus,ptr1); - } - -EXPORT_C void RMobileConferenceCall::NotifyConferenceStatusChange(TRequestStatus& aReqStatus, TMobileConferenceStatus& aStatus) const -/** - Allows clients to be notified of a change in the status - of a conference call. - - The notification completes when the TSY recognizes that a conference call - has changed state. - - Conference calls may change state either as a result of a direct client action - on the conference call sub-session (e.g. client puts the conference on hold - or terminates the whole conference) or as a result of a client action on an - individual call (e.g. a private communication with one call in a conference - will put the rest of the conference on hold). - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyConferenceStatusChange) - to cancel a previously placed asynchronous NotifyCapsChange() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - @param aStatus On return, the conference status. - -@capability None -*/ - { - __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); - - TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceStatusChange,aStatus); - - Get(EMobileConferenceCallNotifyConferenceStatusChange,aReqStatus,ptr1); - } - -EXPORT_C void RMobileConferenceCall::NotifyConferenceEvent(TRequestStatus& aReqStatus, TMobileConferenceEvent& aEvent, TName& aCallName) const -/** - This notification will complete when a conference call event occurs. - - Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyConferenceEvent) - to cancel a previously placed asynchronous NotifyConferenceEvent() request. - - @param aReqStatus On return, KErrNone if successful, a system wide error code - if not. - @param aEvent On completion, contains the conference event. - @param aCallName On completion, contains the name of the individual call, if - the event is a call added or dropped from a conference. - -@capability None -*/ - { - __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); - - TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceEvent,aEvent); - - Get(EMobileConferenceCallNotifyConferenceEvent,aReqStatus,ptr1,aCallName); - } - +// Copyright (c) 1997-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 +#include +#include +#include "mm_hold.h" + +/************************************************************************/ +// +// RMobileConferenceCall +// +/************************************************************************/ + + +EXPORT_C RMobileConferenceCall::RMobileConferenceCall() + : iMmPtrHolder(NULL) +/** Default constructor. */ + { + } + +EXPORT_C void RMobileConferenceCall::ConstructL() +/** Constructs and initializes the RMobileConferenceCall object. +@capability None +*/ + { + __ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed)); + iMmPtrHolder = CMobileConferenceCallPtrHolder::NewL(CMobileConferenceCallPtrHolder::EMaxNumberConferenceCallPtrSlots, + CMobileConferenceCallPtrHolder::EMaxNumberConferenceCallPtrCSlots); + } + +EXPORT_C void RMobileConferenceCall::Destruct() +/** C++ destructor. +@capability None +*/ + { + delete iMmPtrHolder; + iMmPtrHolder = NULL; + ResetSessionHandle(); + } + +EXPORT_C TInt RMobileConferenceCall::Open(RMobilePhone& aPhone) +/** Opens a RMobileConferenceCall conference call sub-session from RMobilePhone. + + The name of the sub-session opened in the TSY will equal the string defined + by the KETelConferenceCall LIT definition. + + This API currently supports only one conference call object in the TSY - so + this means only one conference call can be ongoing at any one time. The conference + call sub-session is opened from the phone (rather than from a line) in order + not to place any restrictions on the types of call that could be added to + the conference. It is up to the TSY to inform clients which calls can be added + to a conference by setting each call's dynamic KCapsJoin capability. + + @param aPhone The phone sub-session used to open the conference call. + @return KErrNone if successful, a system wide error code if not. + +@capability None +*/ + { + RSessionBase* session=&aPhone.SessionHandle(); + __ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle)); + TInt subSessionHandle=aPhone.SubSessionHandle(); + __ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle)); + + TRAPD(ret,ConstructL()); + if (ret) + return ret; + TPtrC name(KETelConferenceCall); + + SetSessionHandle(*session); + TIpcArgs args(&name,TIpcArgs::ENothing,subSessionHandle); + + ret = CreateSubSession(*session,EEtelOpenFromSubSession,args); + if (ret) + Destruct(); + return ret; + } + +EXPORT_C void RMobileConferenceCall::Close() +/** Closes a RMobileConferenceCall sub-session. +@capability None +*/ + { + CloseSubSession(EEtelClose); + Destruct(); + } + +EXPORT_C TInt RMobileConferenceCall::GetCaps(TUint32& aCaps) const +/** + Gets the current capabilities of the conference call. + + @param aCaps On completion, a descriptor that will contain the conference + call capabilities; this consists of the sum of the TMobileConferenceCallCaps + constants. + @return KErrNone + +@capability None +*/ + { + TPckg ptr1(aCaps); + return Get(EMobileConferenceCallGetCaps,ptr1); + } + +EXPORT_C void RMobileConferenceCall::NotifyCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const +/** + Allows clients to be notified when the conference call capabilities change. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyCapsChange) + to cancel a previously placed asynchronous NotifyCapsChange() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + @param aCaps On completion, a descriptor that will contain the new conference + call capabilities, this consists of the sum of the TMobileConferenceCallCaps + constants. + +@capability None +*/ + { + __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); + + TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceCallCapsChange,aCaps); + + Get(EMobileConferenceCallNotifyCapsChange,aReqStatus,ptr1); + } + +EXPORT_C void RMobileConferenceCall::CreateConference(TRequestStatus& aReqStatus) const +/** + Allows clients to create the initial 3-way conference call. + + The phone must be in a state where there are two single voice calls, one on + hold and the other connected or alerting the remote, called party. + + The TSY will reflect the conference creation capability by setting the KCapsJoin + flags of the individual calls and the KCapsCreate flag of the conference call + sub-session. + + In GSM mode, this function member will complete when the TSY has received + confirmation from the network that the conference call service has been successfully + invoked. + + In CDMA mode, this function member will complete when the TSY has sent the + conference create request to the network. There is no response from CDMA networks + to ascertain whether the request failed or succeeded. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallCreateConference) + to cancel a previously placed asynchronous CreateConference() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + +@capability NetworkServices +*/ + { + Blank(EMobileConferenceCallCreateConference,aReqStatus); + } + +EXPORT_C void RMobileConferenceCall::AddCall(TRequestStatus& aReqStatus, const TName& aCallName) const +/** + Adds the single voice call to an existing conference call. + + Only calls whose call control capabilities include KCapsJoin can be added + to a conference call. + + In GSM mode, this function member will complete when the TSY has received + confirmation from the network that the conference call service has been successfully + invoked and the call added. + + In CDMA mode, only 3-way conference calls are currently possible, so after + the initial conference creation it is not possible to add further calls. Therefore + single calls outside of the conference will never have the KCapsJoin capability + set during CDMA mode. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallAddCall) to + cancel a previously placed asynchronous AddCall() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + @param aCallName The call sub-session to add to the conference call. + +@capability NetworkServices +*/ + { + Set(EMobileConferenceCallAddCall,aReqStatus,aCallName); + } + +EXPORT_C void RMobileConferenceCall::Swap(TRequestStatus& aReqStatus) const +/** + Allows a client to switch a conference call between "Active" and "Hold" states. + + This function member will complete either when the conference call has successfully + moved to the opposite state or if the action failed due to some reason. Can + be called by any client that has a handle on the conference call (i.e. not + necessarily the client that first created the conference). + + This action is possible under two circumstances: + + There is just a conference call. This implies that there are no single calls + already in the state to which the client wishes to toggle the conference call. + The client will call Swap on the conference call and if it is active it will + move to the held state and if it is held it will move to the active state. + + There is a conference call and a single call, one currently active and one + on hold. This function member therefore swaps the conference call with the + single call, simultaneously placing the active one on hold and resuming the + held one. + + In either circumstance, the conference call capabilities will include the + KCapsSwap flag. In GSM mode, this function member will complete when the TSY + has received confirmation from the network that the conference call has been + successfully moved to its opposite state. In CDMA mode, this function member + will complete when the TSY has sent the swap request to the network. There + is no response from CDMA networks to ascertain whether the request failed + or succeeded. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallSwap) to cancel + a previously placed asynchronous Swap() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + +@capability NetworkServices +*/ + { + Blank(EMobileConferenceCallSwap,aReqStatus); + } + +EXPORT_C void RMobileConferenceCall::HangUp(TRequestStatus& aReqStatus) const +/** + Terminates the whole conference. + + All calls that are currently part of the conference will also be terminated. + Can be called by any client that has a handle on the conference call (i.e. + not necessarily the client that first created the conference). + + This action is possible if the conference call capabilities include the KCapsHangUp + flag. In GSM mode, this function member will complete when the TSY has received + confirmation from the network that the conference call has been fully released. + + + In CDMA mode, this function member will complete when the TSY has sent the + hang-up request to the network. There is no response from CDMA networks to + ascertain whether the request failed or succeeded. + + After termination, the conference call will consist of zero calls and will + return to the EConferenceIdle state. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallHangUp) to + cancel a previously placed asynchronous HangUp() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + +@capability NetworkServices +*/ + { + Blank(EMobileConferenceCallHangUp,aReqStatus); + } + +EXPORT_C TInt RMobileConferenceCall::EnumerateCalls(TInt& aCount) const +/** + Gets the number of calls (i.e. call objects) that are + currently part of the conference call. + + This number may be zero if a conference call is not active or equal to two + or more if a conference call exists. + + @param aCount On return, the number of calls - will be equal to 0 or >=2. + @return KErrNone + +@capability None +*/ + { + TPckg ptr1(aCount); + return Get(EMobileConferenceCallEnumerateCalls,ptr1); + } + +EXPORT_C TInt RMobileConferenceCall::GetMobileCallInfo(TInt aIndex, TDes8& aCallInfo) const +/** + Gets a current snapshot of the call information associated + with the call specified by the aIndex parameter. + + @param aIndex The index of the call = 0 to aCount-1 where aCount is the returned + value from EnumerateCalls() + @param aCallInfo On completion, a RMobileCall::TMobileCallInfoV1Pckg containing + the large block of call information. + @return KErrNone, if successful, KErrNotFound if call information is not available. + +@capability ReadDeviceData +*/ + { + TPckg ptr1(aIndex); + return Get(EMobileConferenceCallGetMobileCallInfo,ptr1,aCallInfo); + } + +EXPORT_C TInt RMobileConferenceCall::GetConferenceStatus(TMobileConferenceStatus& aStatus) const +/** + Allows clients to retrieve the current status of the conference call. + + @param aStatus On completion, the new conference status. + @return KErrNone if successful, a system wide error code if not. + +@capability None +*/ + { + TPckg ptr1(aStatus); + return Get(EMobileConferenceCallGetConferenceStatus,ptr1); + } + +EXPORT_C void RMobileConferenceCall::NotifyConferenceStatusChange(TRequestStatus& aReqStatus, TMobileConferenceStatus& aStatus) const +/** + Allows clients to be notified of a change in the status + of a conference call. + + The notification completes when the TSY recognizes that a conference call + has changed state. + + Conference calls may change state either as a result of a direct client action + on the conference call sub-session (e.g. client puts the conference on hold + or terminates the whole conference) or as a result of a client action on an + individual call (e.g. a private communication with one call in a conference + will put the rest of the conference on hold). + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyConferenceStatusChange) + to cancel a previously placed asynchronous NotifyCapsChange() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + @param aStatus On return, the conference status. + +@capability None +*/ + { + __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); + + TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceStatusChange,aStatus); + + Get(EMobileConferenceCallNotifyConferenceStatusChange,aReqStatus,ptr1); + } + +EXPORT_C void RMobileConferenceCall::NotifyConferenceEvent(TRequestStatus& aReqStatus, TMobileConferenceEvent& aEvent, TName& aCallName) const +/** + This notification will complete when a conference call event occurs. + + Use RTelSubSessionBase::CancelAsyncRequest(EMobileConferenceCallNotifyConferenceEvent) + to cancel a previously placed asynchronous NotifyConferenceEvent() request. + + @param aReqStatus On return, KErrNone if successful, a system wide error code + if not. + @param aEvent On completion, contains the conference event. + @param aCallName On completion, contains the name of the individual call, if + the event is a call added or dropped from a conference. + +@capability None +*/ + { + __ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle)); + + TPtr8& ptr1 = iMmPtrHolder->Set(CMobileConferenceCallPtrHolder::ESlot1NotifyConferenceEvent,aEvent); + + Get(EMobileConferenceCallNotifyConferenceEvent,aReqStatus,ptr1,aCallName); + } +