// Copyright (c) 2007-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:

// Test step definitions for the ConferenceCallControl functional unit.

// 

//

/**

 @internalTechnology

*/

#include "cctsyintegrationtestconferencecallcontrol.h"

#include "cctsyinidata.h"

#include "etelmmerr.h"

#include "cctsytestlogging.h"

#include <stdlib.h>

CCTSYIntegrationTestConferenceCallControlBase::CCTSYIntegrationTestConferenceCallControlBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

		iCallControlTsyTestHelper(*this),

		iNetworkTsyTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestConferenceCallControlBase::~CCTSYIntegrationTestConferenceCallControlBase()

/*

 * Destructor

 */

	{

	}

/**

* Make a call and verify the new status

* @param aCall Call object

* @param aNumber Number is be used

* @return Status of conference call

*/

RMobileCall::TMobileCallStatus CCTSYIntegrationTestConferenceCallControlBase::MakeCallL(RMobileCall& aCall, TPtrC& aNumber)

	{

	// set up notification for call status changes

	TExtEtelRequestStatus notifyCallStatus(aCall,EMobileCallNotifyMobileCallStatusChange);

	CleanupStack::PushL(notifyCallStatus);

	RMobileCall::TMobileCallStatus callStatus;	

	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	// Dial the number

	TCoreEtelRequestStatus<RMobileCall> dialStatus(aCall, &RCall::DialCancel);

	CleanupStack::PushL(dialStatus);

	aCall.Dial(dialStatus, aNumber); 

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial returned an error") );

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusDialling, KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusConnecting, KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusConnected, KErrNone);

	// Pop

	// notifyCallStatus

	// dialStatus

	CleanupStack::PopAndDestroy(2, &notifyCallStatus);

	return callStatus;

	}

/**

* Place a call on hold and verify the new status

* @param aCall Call object

* @return Status of conference call

*/

RMobileCall::TMobileCallStatus CCTSYIntegrationTestConferenceCallControlBase::HoldCallL( RMobileCall& aCall)

	{

    // Post notification for call status change

	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(aCall, EMobileCallNotifyMobileCallStatusChange);

	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

	RMobileCall::TMobileCallStatus mobileCallStatus;	

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

    // Hold call

	TExtEtelRequestStatus reqHoldStatus(aCall, EMobileCallHold);

	CleanupStack::PushL(reqHoldStatus);

	aCall.Hold(reqHoldStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(reqHoldStatus, ETimeMedium), KErrNone, _L("RMobileCall::Hold timed-out"));

	ASSERT_EQUALS(reqHoldStatus.Int(), KErrNone, _L("RMobileCall::Hold returned an error"));

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusHold.

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															RMobileCall::EStatusHold,

															KErrNone);

    // Pop

	// notifyMobileCallStatusChangeStatus

	// reqHoldStatus

	CleanupStack::PopAndDestroy(2, &notifyMobileCallStatusChangeStatus);

	return mobileCallStatus;

	}

/**

* Add a call to a conference. Leaves on failure.

* @param aConfCall Conference call object

* @param aCall Call object to use

* @param aNumber Number to dial

*

*/

void CCTSYIntegrationTestConferenceCallControlBase::AddCallToConferenceL( RMobileConferenceCall& aConfCall, 

																				RMobileCall& aCall, TPtrC& aNumber,

																				TInt aIndex )

	{

	DEBUG_PRINTF3(_L("Adding call %d to conference : %S"), aIndex, &aNumber );

	// Swap the conference call. 

	TExtEtelRequestStatus reqSwapConfStatus(aConfCall,EMobileConferenceCallSwap);

	CleanupStack::PushL(reqSwapConfStatus);

	aConfCall.Swap(reqSwapConfStatus);

	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSwapConfStatus,ETimeShort),KErrNone, _L("RMobileConferenceCall::Swap timed out"));

	ASSERT_EQUALS( reqSwapConfStatus.Int(),KErrNone, _L("RMobileConferenceCall::Swap returned error"));

	TEST_CHECK_POINT_L(_L("RMobileConferenceCall::Swap failed"));

	// Dial a number that answers 

	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

	RMobileCall::TMobileCallStatus callStatus = MakeCallL(aCall, aNumber);

	ASSERT_EQUALS(callStatus,RMobileCall::EStatusConnected,_L("Failed to connect call"));

	TEST_CHECK_POINT_L(_L("Failed to connect call"));

	// Set up notification

	TExtEtelRequestStatus notifyConfEventStatus(aConfCall,EMobileConferenceCallNotifyConferenceEvent);

	RMobileConferenceCall::TMobileConferenceEvent confEvent;

	TName confEventCallName;

	aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confEventCallName);

	// Add call to the conference 

	TExtEtelRequestStatus reqAddCallStatus(aConfCall,EMobileConferenceCallAddCall);

	CleanupStack::PushL(reqAddCallStatus);

	// Get the call info (need the name)

	RCall::TCallInfo callInfo;

	TInt err = aCall.GetInfo(callInfo);

	ASSERT_EQUALS(err, KErrNone, _L("RCall::GetInfo returned error"));	

	aConfCall.AddCall(reqAddCallStatus,callInfo.iCallName);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(reqAddCallStatus,ETimeShort),KErrNone, _L("RMobileConferenceCall::AddCall timed out"));

	ASSERT_EQUALS(reqAddCallStatus.Int(),KErrNone, _L("RMobileConferenceCall::AddCall returned error"));

	TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));

	// Check RMobileConferenceCall::NotifyConferenceEvent completes with EConferenceCallAdded

	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyConferenceEvent( aConfCall, 

								notifyConfEventStatus,

								confEvent,

								RMobileConferenceCall::EConferenceCallAdded,

								confEventCallName,

								KErrNone);

	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceActive

	RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;	

	ASSERT_EQUALS(aConfCall.GetConferenceStatus(confCallConfStatus), KErrNone, _L("RMobileConferenceCall::GetConferenceStatus returned an error"));

	ASSERT_EQUALS(confCallConfStatus, RMobileConferenceCall::EConferenceActive, _L("RMobileConferenceCall::GetConferenceStatus did not return EConferenceActive"));

	TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));

	// Pop								

	// reqAddCallStatus

	// reqSwapConfStatus

	CleanupStack::PopAndDestroy(2,&reqSwapConfStatus);				

	}

/**

* Check the conference call information returned 

* @param aConfCall Conference call object

* @param aNumber Dialled number for comparison

* @param aCallCount 1-based call number 

*/

void CCTSYIntegrationTestConferenceCallControlBase::CheckConfCallInfo(RMobileConferenceCall& aConfCall, 

																	TPtrC& aNumber,

																	TInt aCallCount)

	{	

	DEBUG_PRINTF2(_L("Checking call info from conf call for call %d"), aCallCount);

	// Check RMobileConferenceCall::GetMobileCallInfo returns

	RMobileCall::TMobileCallInfoV3 mobileCallInfo;

	RMobileCall::TMobileCallInfoV3Pckg mobileCallInfoPkg(mobileCallInfo);

	TInt err = aConfCall.GetMobileCallInfo(aCallCount-1, mobileCallInfoPkg);

	ASSERT_EQUALS(err, KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

	// Valid iCallName 

	ASSERT_TRUE(mobileCallInfo.iCallName.Length() > 0, 

						_L("RMobileConferenceCall::GetMobileCallInfo returned empty iCallName"));

	// Correct number in iDialledParty 

	TPtrC dialledPartyNumber(mobileCallInfo.iDialledParty.iTelNumber);

	ASSERT_EQUALS_DES16( dialledPartyNumber, aNumber, 

					_L("RMobileConferenceCall::GetMobileCallInfo iDialledParty number does not match called number"));

	// Valid iLineName 

	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0, _L("RMobileConferenceCall::GetMobileCallInfo returned empty iLineName"));

	// iStatus of EStatusConnected 

	ASSERT_EQUALS(mobileCallInfo.iStatus, RMobileCall::EStatusConnected, _L("RMobileConferenceCall::GetMobileCallInfo iDialledParty number does not match called number"));

	//  Relevant bits set in iValid based on the above parameters 

	// $CTSYProblem CTSY does not return the RMobileCall::KCallRemoteParty bit 

	ASSERT_BITS_SET(mobileCallInfo.iValid, RMobileCall::KCallDialledParty, // | RMobileCall::KCallRemoteParty,

						KNoUnwantedBits, _L("RMobileConferenceCall::GetMobileCallInfo returned invalid iValid"));

	}

CCTSYIntegrationTestConferenceCallControl0001::CCTSYIntegrationTestConferenceCallControl0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0001::GetTestStepName());

	}

CCTSYIntegrationTestConferenceCallControl0001::~CCTSYIntegrationTestConferenceCallControl0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestConferenceCallControl0001::doTestStepL()

/**

 * @SYMTestCaseID BA-CTSY-INT-CONC-0001

 * @SYMFssID BA/CTSY/CONC-0001

 * @SYMTestCaseDesc Create a conference call with no calls.

 * @SYMTestPriority High

 * @SYMTestActions RMobileConferenceCall::NotifyConferenceStatusChange, RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::GetCaps, RMobileConferenceCall::GetConferenceStatus, RMobileConferenceCall::CreateConference, RMobileConferenceCall::NotifyCapsChange

 * @SYMTestExpectedResults Pass - Conference creation fails with KErrNotReady.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Verify creating a conference fails.

 * Verify conference call related notifications do not complete.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	// Get conference call subsession. 

	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

	// Make sure we are on the network

	TInt err = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

	CHECK_EQUALS_L( err, KErrNone, _L("Failed to register on home network"));

	// Get conference call subsession.

	RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// ===  Check conference status and information before creating a conference ===

	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

	TUint32 caps; 

	TInt result = confCall.GetCaps(caps);

	ASSERT_EQUALS(result, KErrNone, _L("RMobileConferenceCall::GetCaps failed."));

	TUint unwantedCaps = 	RMobileConferenceCall::KCapsCreate |

						RMobileConferenceCall::KCapsHangUp |

						RMobileConferenceCall::KCapsSwap;

	ASSERT_BITS_SET( caps,  KNoUnwantedBits, unwantedCaps, _L("RMobileConferenceCall::GetCaps returned wrong mask") );

	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

	TInt callCount;

	ASSERT_EQUALS( confCall.EnumerateCalls(callCount), KErrNone, 

						_L("RMobileConferenceCall::EnumerateCalls failed."));

	ASSERT_EQUALS(callCount,0, _L("RMobileConferenceCall::EnumerateCalls returned non-zero"));

	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

	RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;	

	ASSERT_EQUALS(confCall.GetConferenceStatus(confCallConfStatus), KErrNone, 

				_L("RMobileConferenceCall::GetConferenceStatus failed"));

	ASSERT_EQUALS( RMobileConferenceCall::EConferenceIdle,confCallConfStatus,

				_L("RMobileConferenceCall::GetConferenceStatus returned bad state"));

	// Request notification for RMobileConferenceCall::NotifyCapsChange 

	TExtEtelRequestStatus notifyCapsChangeStatus(confCall, EMobileConferenceCallNotifyCapsChange);

	CleanupStack::PushL(notifyCapsChangeStatus);

	TUint32 confCallCaps;

	confCall.NotifyCapsChange(notifyCapsChangeStatus, confCallCaps);	

	// Request notification for RMobileConferenceCall::NotifyConferenceEvent 

	TExtEtelRequestStatus notifyConfEventStatus(confCall, EMobileConferenceCallNotifyConferenceEvent);

	CleanupStack::PushL(notifyConfEventStatus);

	RMobileConferenceCall::TMobileConferenceEvent confEvent;

	TName confEventName;

	confCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confEventName);

	// Request notification for RMobileConferenceCall::NotifyConferenceStatusChange 

	TExtEtelRequestStatus notifyConfStatusChange(confCall, EMobileConferenceCallNotifyConferenceStatusChange);

	CleanupStack::PushL(notifyConfStatusChange);

	RMobileConferenceCall::TMobileConferenceStatus confStatus;

	confCall.NotifyConferenceStatusChange(notifyConfStatusChange, confStatus );

	// Create a conference with RMobileConferenceCall::CreateConference 

	TExtEtelRequestStatus createConfStatus(confCall, EMobileConferenceCallCreateConference);

	CleanupStack::PushL(createConfStatus);

	confCall.CreateConference(createConfStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(createConfStatus, ETimeMedium), KErrNone, 

				_L("RMobileConferenceCall::CreateConference timed out."));

	// Check conference creation completes with KErrNotReady	

	ASSERT_EQUALS( createConfStatus.Int(), KErrNotReady,

				_L("RMobileConferenceCall::CreateConference did not return KErrNotReady") );

	// ===  Check conference notifications did not complete ===

	// Check RMobileConferenceCall::NotifyCapsChange is still KRequestPending

	ASSERT_EQUALS( notifyCapsChangeStatus.Int(), KRequestPending, 

					_L("NotifyCapsChange completed unexpectedly"));

	// Check RMobileConferenceCall::NotifyConferenceEvent is still KRequestPending

	ASSERT_EQUALS( notifyConfEventStatus.Int(), KRequestPending,

					_L("NotifyConferenceEvent completed unexpectedly"));

	// Check RMobileConferenceCall::NotifyConferenceStatusChange is still KRequestPending

	ASSERT_EQUALS( notifyConfStatusChange.Int(), KRequestPending,

					_L("NotifyConferenceStatusChange completed unexpectedly"));

	//

	// TEST END

	//

    StartCleanup();

	CleanupStack::PopAndDestroy(4, &notifyCapsChangeStatus);

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestConferenceCallControl0001::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestConferenceCallControl0001");

	}

CCTSYIntegrationTestConferenceCallControl0002::CCTSYIntegrationTestConferenceCallControl0002(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0002::GetTestStepName());

	}

CCTSYIntegrationTestConferenceCallControl0002::~CCTSYIntegrationTestConferenceCallControl0002()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestConferenceCallControl0002::doTestStepL()

/**

 * @SYMTestCaseID BA-CTSY-INT-CONC-0002

 * @SYMFssID BA/CTSY/CONC-0002

 * @SYMTestCaseDesc Create a conference call with only one call.

 * @SYMTestPriority High

 * @SYMTestActions RMobileConferenceCall::NotifyConferenceStatusChange, RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::GetCaps, RMobileConferenceCall::GetConferenceStatus, RMobileConferenceCall::CreateConference, RMobileConferenceCall::NotifyCapsChange, RCall::GetStatus, RCall::HangUp, RCall::Dial, RCall::NotifyStatusChange

 * @SYMTestExpectedResults Pass - Conference creation fails with KErrMMEtelCallForbidden

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Verify creating a conference fails.

Verify conference call related notifications can be cancelled.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

	iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

	// Get conference call subsession. 

	RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

	// Get voice line 1. 

	RMobileLine& voiceLine1 = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

	// Get call 1. 

	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// post a notifier for RCall::NotifyStatusChange

	TCoreEtelRequestStatus<RCall> notifyStatusChangeStatus (call1, &RCall::NotifyStatusChangeCancel);

	CleanupStack::PushL(notifyStatusChangeStatus);

	RCall::TStatus callStatus;

	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

	// Dial a number that answers.

	TPtrC number; 

	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, 

				_L("CTestStep::GetStringFromConfig did not complete as expected"));

	TCoreEtelRequestStatus<RMobileCall> dialStatus(call1, &RCall::DialCancel);

	CleanupStack::PushL(dialStatus);

	call1.Dial(dialStatus, number);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

				_L("RCall::Dial timed-out"))

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RCall::Dial returned an error"));

	// ===  Check call status ===

	// Check RCall::NotifyStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

														 notifyStatusChangeStatus,

														 callStatus,

														 expectedCallStatus,

														 KErrNone);	

	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

	expectedCallStatus = RCall::EStatusConnecting;

	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

													 	notifyStatusChangeStatus,

													 	callStatus,

													 	expectedCallStatus,

													 	KErrNone);

	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

	expectedCallStatus = RCall::EStatusConnected;

	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

													 	notifyStatusChangeStatus,

													 	callStatus,

													 	expectedCallStatus,

													 	KErrNone);														 

	// Check RCall::GetStatus returns EStatusConnected.

	ASSERT_EQUALS(call1.GetStatus(callStatus),KErrNone, _L("RCall::GetStatus returned an error"));

	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, 

				_L("RCall::GetStatus returned an unexpected call status"));

	// ===  Check conference caps, status and info are correct. ===

	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

	TUint32 caps;

	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone,

				_L("RMobileConferenceCall::GetCaps returned an error"));

	TUint32 wantedCaps = KNoWantedBits;

	TUint32 unWantedCaps = RMobileConferenceCall::KCapsCreate | RMobileConferenceCall::KCapsHangUp | RMobileConferenceCall::KCapsSwap;

	ASSERT_BITS_SET(caps, wantedCaps, unWantedCaps,

				_L("RMobileConferenceCall::GetGaps returned unexpected caps"));

	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

	TInt count;

	ASSERT_EQUALS(confCall.EnumerateCalls(count), KErrNone, 

				_L("RMobileConferenceCall::EnumerateCalls returned an error"));

	ASSERT_EQUALS(count,0, _L("RMobileConferenceCall::EnumerateCalls did not return aCount = 0"));				

	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

	RMobileConferenceCall::TMobileConferenceStatus confStatus;

	ASSERT_EQUALS(confCall.GetConferenceStatus(confStatus), KErrNone,

				_L("RMobileConferenceCall::GetConferenceStatus returned an error"));

	ASSERT_EQUALS(confStatus, RMobileConferenceCall::EConferenceIdle,

				_L("RMobileConferenceCall::GetConferenceStatus did not return status of EConferenceIdle"));					

	// Request notification for RMobileConferenceCall::NotifyCapsChange

	TExtEtelRequestStatus notifyCapsChangeStatus (confCall, EMobileConferenceCallNotifyCapsChange);

	CleanupStack::PushL(notifyCapsChangeStatus);	

	confCall.NotifyCapsChange(notifyCapsChangeStatus, caps);

	// Request notification for RMobileConferenceCall::NotifyConferenceEvent 

	TExtEtelRequestStatus notifyConfEventStatus(confCall, EMobileConferenceCallNotifyConferenceEvent);

	CleanupStack::PushL(notifyConfEventStatus);

	RMobileConferenceCall::TMobileConferenceEvent confEvent;

	TName confName;

	confCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confName);	

	// Request notification for RMobileConferenceCall::NotifyConferenceStatusChange 

	TExtEtelRequestStatus notifyMobileConfStatusChangeStatus (confCall, EMobileConferenceCallNotifyConferenceStatusChange);

	CleanupStack::PushL(notifyMobileConfStatusChangeStatus);

	RMobileConferenceCall::TMobileConferenceStatus mobileConfStatus;