1 // Copyright (c) 1997-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 // CONFERENCE.CPP

    15 // 

    16 //

    17 

    18 

    19 #include "mmtsy.h"

    20 #include "testdef.h"

    21 #include "ETELMM.H"

    22 #include <et_clsvr.h>

    23 #include "Dmmlog.h"

    24 

    25 CMobileConferenceCallDMmTsy* CMobileConferenceCallDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,const TDesC& aName)

    26 	{

    27 	CMobileConferenceCallDMmTsy* This=new(ELeave) CMobileConferenceCallDMmTsy(aPhone,aFac,aName);

    28 	CleanupStack::PushL(This);

    29 	This->ConstructL();

    30 	CleanupStack::Pop();

    31 	return This;

    32 	}

    33 

    34 CMobileConferenceCallDMmTsy::CMobileConferenceCallDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,const TDesC& aName) :

    35 	CSubSessionExtDummyBase(aFac), iPhone(aPhone), iNotifyCapsChange(0),iNotifyConferenceStatusChange(0),

    36 		iNotifyConferenceEvent(0)

    37 	{

    38 	iConferenceName = aName;

    39 	}

    40 

    41 void CMobileConferenceCallDMmTsy::ConstructL()

    42 	{

    43 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy created"));

    44 	}

    45 

    46 CMobileConferenceCallDMmTsy::~CMobileConferenceCallDMmTsy()

    47 	{

    48 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy destroyed"));

    49 	}

    50 

    51 CTelObject* CMobileConferenceCallDMmTsy::OpenNewObjectByNameL(const TDesC& /*aName*/)

    52 	{

    53 	User::Leave(KErrNotSupported);

    54 	return NULL;

    55 	}

    56 

    57 CTelObject* CMobileConferenceCallDMmTsy::OpenNewObjectL(TDes& /*aNewName*/)

    58 	{

    59 	User::Leave(KErrNotSupported);

    60 	return NULL;

    61 	}

    62 

    63 

    64 CTelObject::TReqMode CMobileConferenceCallDMmTsy::ReqModeL(const TInt aIpc)

    65 	{

    66 	CTelObject::TReqMode ret=0;

    67 	switch (aIpc)

    68 		{

    69 

    70 		case EMobileConferenceCallGetCaps:

    71 		case EMobileConferenceCallCreateConference:

    72 		case EMobileConferenceCallAddCall:

    73 		case EMobileConferenceCallSwap:

    74 		case EMobileConferenceCallHangUp:

    75 		case EMobileConferenceCallEnumerateCalls:

    76 		case EMobileConferenceCallGetMobileCallInfo:

    77 		case EMobileConferenceCallGetConferenceStatus:

    78 

    79 		break;

    80 

    81 //

    82 // Flow Controlled Services

    83 //

    84 

    85 //

    86 // Multiple Completion Services with Immediate Server Repost

    87 // (Usually Notifications)

    88 //

    89 		case EMobileConferenceCallNotifyCapsChange:

    90 		case EMobileConferenceCallNotifyConferenceStatusChange:

    91 		case EMobileConferenceCallNotifyConferenceEvent:

    92 

    93 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

    94 			break;

    95 //

    96 // Cancel Requests

    97 //	

    98 		case EMobileConferenceCallNotifyCapsChangeCancel:

    99 		case EMobileConferenceCallCreateConferenceCancel:

   100 		case EMobileConferenceCallAddCallCancel:

   101 		case EMobileConferenceCallSwapCancel:

   102 		case EMobileConferenceCallHangUpCancel:

   103 		case EMobileConferenceCallNotifyConferenceStatusChangeCancel:

   104 		case EMobileConferenceCallNotifyConferenceEventCancel:

   105 		default:

   106 		User::Leave(KErrNotSupported);

   107 		break;

   108 		}

   109 	return ret;

   110 	}

   111 

   112 void CMobileConferenceCallDMmTsy::Init()

   113 	{

   114 

   115 	}

   116 

   117 TInt CMobileConferenceCallDMmTsy::RegisterNotification(const TInt aIpc)

   118 	{

   119 	switch (aIpc)

   120 		{

   121 	case EMobileConferenceCallNotifyCapsChange:

   122 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: RegisterNotification - Notify Caps Change "));

   123 		return KErrNone;

   124 	case EMobileConferenceCallNotifyConferenceStatusChange:

   125 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: RegisterNotification - Notify Conference Status Change "));

   126 		return KErrNone;

   127 	case EMobileConferenceCallNotifyConferenceEvent:

   128 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: RegisterNotification - Notify Conference Event "));

   129 		return KErrNone;

   130 	default:

   131 		// Unknown or invalid IPC

   132 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: Register error, unknown IPC"));

   133 		return KErrNotSupported;

   134 		}

   135 	}

   136 

   137 TInt CMobileConferenceCallDMmTsy::DeregisterNotification(const TInt aIpc)

   138 	{

   139 	switch (aIpc)

   140 		{

   141 	case EMobileConferenceCallNotifyCapsChange:

   142 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: DeregisterNotification - Notify Caps Change "));

   143 		return KErrNone;

   144 	case EMobileConferenceCallNotifyConferenceStatusChange:

   145 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: DeregisterNotification - Notify Conference Status Change "));

   146 		return KErrNone;

   147 	case EMobileConferenceCallNotifyConferenceEvent:

   148 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: DeregisterNotification - Notify Conference Event "));

   149 		return KErrNone;

   150 	default:

   151 		// Unknown or invalid IPC

   152 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: Deregister error, unknown IPC"));

   153 		return KErrNotSupported;

   154 		}

   155 	}

   156 

   157 TInt CMobileConferenceCallDMmTsy::NumberOfSlotsL(const TInt aIpc)

   158 	{

   159 	TInt numberOfSlots=1;

   160 	switch (aIpc)

   161 		{

   162 	case EMobileConferenceCallNotifyCapsChange:

   163 	case EMobileConferenceCallNotifyConferenceStatusChange:

   164 	case EMobileConferenceCallNotifyConferenceEvent:

   165 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: Registered with 2 slot"));

   166 		numberOfSlots=2;

   167 		break;

   168 	default:

   169 		// Unknown or invalid Phone IPC

   170 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy: Number of Slots error, unknown IPC"));

   171 		User::Leave(KErrNotSupported);

   172 		break;

   173 		} 

   174 	return numberOfSlots;

   175 	}

   176 

   177 TInt CMobileConferenceCallDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,const TDataPackage& aPackage)

   178 	{

   179 	TAny* dataPtr=aPackage.Ptr1();

   180 

   181 	switch (aIpc)

   182 		{

   183 		case EMobileConferenceCallGetCaps:

   184 			return GetCaps(aTsyReqHandle,REINTERPRET_CAST(TUint32*,dataPtr));

   185 		case EMobileConferenceCallNotifyCapsChange:

   186 			return NotifyCapsChange(aTsyReqHandle,REINTERPRET_CAST(TUint32*,dataPtr));

   187 		case EMobileConferenceCallCreateConference:

   188 			return CreateConference(aTsyReqHandle);

   189 		case EMobileConferenceCallAddCall:

   190 			return AddCall(aTsyReqHandle,aPackage.Des1u());

   191 		case EMobileConferenceCallSwap:

   192 			return Swap(aTsyReqHandle);

   193 		case EMobileConferenceCallHangUp:

   194 			return HangUp(aTsyReqHandle);

   195 		case EMobileConferenceCallEnumerateCalls:

   196 			return EnumerateCalls(aTsyReqHandle,REINTERPRET_CAST(TUint*,dataPtr));

   197 		case EMobileConferenceCallGetMobileCallInfo:

   198 			return GetMobileCallInfo(aTsyReqHandle,REINTERPRET_CAST(TInt*,dataPtr),aPackage.Des2n());

   199 		case EMobileConferenceCallGetConferenceStatus:

   200 			return GetConferenceStatus(aTsyReqHandle,REINTERPRET_CAST(RMobileConferenceCall::TMobileConferenceStatus*,dataPtr));

   201 		case EMobileConferenceCallNotifyConferenceStatusChange:

   202 			return NotifyConferenceStatusChange(aTsyReqHandle,REINTERPRET_CAST(RMobileConferenceCall::TMobileConferenceStatus*,dataPtr));

   203 		case EMobileConferenceCallNotifyConferenceEvent:

   204 			return NotifyConferenceEvent(aTsyReqHandle,REINTERPRET_CAST(RMobileConferenceCall::TMobileConferenceEvent*,dataPtr),aPackage.Des2u());

   205 

   206 		default:

   207 			return KErrGeneral;

   208 		}

   209 	}

   210 

   211 

   212 TInt CMobileConferenceCallDMmTsy::CancelService(const TInt aIpc, const TTsyReqHandle aTsyReqHandle)

   213 	{

   214 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy: - CancelService called"));

   215 	switch (aIpc)

   216 		{

   217 		case EMobileConferenceCallNotifyCapsChange:

   218 			return NotifyCapsChangeCancel(aTsyReqHandle);

   219 		case EMobileConferenceCallCreateConference:

   220 			return CreateConferenceCancel(aTsyReqHandle);

   221 		case EMobileConferenceCallAddCall:

   222 			return AddCallCancel(aTsyReqHandle);

   223 		case EMobileConferenceCallSwap:

   224 			return SwapCancel(aTsyReqHandle);

   225 		case EMobileConferenceCallHangUp:

   226 			return HangUpCancel(aTsyReqHandle);

   227 		case EMobileConferenceCallNotifyConferenceStatusChange:

   228 			return NotifyConferenceStatusChangeCancel(aTsyReqHandle);

   229 		case EMobileConferenceCallNotifyConferenceEvent:

   230 			return NotifyConferenceEventCancel(aTsyReqHandle);

   231 

   232 		default:

   233 			return KErrGeneral;

   234 		}

   235 	}

   236 

   237 TInt CMobileConferenceCallDMmTsy::GetCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aCaps)

   238 	{

   239 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::GetCaps Called"));

   240 	*aCaps = DMMTSY_CONFERENCE_CAPS;

   241 	ReqCompleted(aTsyReqHandle,KErrNone);

   242 	return KErrNone;

   243 	}

   244 

   245 TInt CMobileConferenceCallDMmTsy::NotifyCapsChange(const TTsyReqHandle aTsyReqHandle, TUint32* aCaps)

   246 	{

   247 	if (!iNotifyCapsChange++)

   248 		{

   249 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyCapsChange Called"));

   250 		*aCaps = DMMTSY_CONFERENCE_CAPS;

   251 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   252 		}

   253 	return KErrNone;

   254 	}

   255 

   256 TInt CMobileConferenceCallDMmTsy::NotifyCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)

   257 	{

   258 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyCapsChangeCancel Called"));

   259 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   260 	ReqCompleted(aTsyReqHandle,KErrCancel);

   261 	return KErrNone;

   262 	}

   263 

   264 TInt CMobileConferenceCallDMmTsy::CreateConference(const TTsyReqHandle aTsyReqHandle)

   265 	{

   266 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::CreateConference Called"));

   267 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   268 	return KErrNone;

   269 	}

   270 

   271 TInt CMobileConferenceCallDMmTsy::CreateConferenceCancel(const TTsyReqHandle aTsyReqHandle)

   272 	{

   273 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::CreateConferenceCancel Called"));

   274 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   275 	ReqCompleted(aTsyReqHandle,KErrCancel);

   276 	return KErrNone;

   277 	}

   278 

   279 TInt CMobileConferenceCallDMmTsy::AddCall(const TTsyReqHandle aTsyReqHandle, TDes* aCallName)

   280 	{

   281 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::AddCall Called"));

   282 	if (aCallName->Compare(DMMTSY_CONFERENCE_CALL_NAME) != 0)

   283 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   284 	else

   285 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   286 	return KErrNone;

   287 	}

   288 

   289 TInt CMobileConferenceCallDMmTsy::AddCallCancel(const TTsyReqHandle aTsyReqHandle)

   290 	{

   291 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::AddCallCancel Called"));

   292 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   293 	ReqCompleted(aTsyReqHandle,KErrCancel);

   294 	return KErrNone;

   295 	}

   296 

   297 TInt CMobileConferenceCallDMmTsy::Swap(const TTsyReqHandle aTsyReqHandle)

   298 	{

   299 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::Swap Called"));

   300 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   301 	return KErrNone;

   302 	}

   303 

   304 TInt CMobileConferenceCallDMmTsy::SwapCancel(const TTsyReqHandle aTsyReqHandle)

   305 	{

   306 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::SwapCancel Called"));

   307 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   308 	ReqCompleted(aTsyReqHandle,KErrCancel);

   309 	return KErrNone;

   310 	}

   311 

   312 TInt CMobileConferenceCallDMmTsy::HangUp(const TTsyReqHandle aTsyReqHandle)

   313 	{

   314 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::HangUp Called"));

   315 	iPhone->AddDelayedReq(aTsyReqHandle,this);

   316 	return KErrNone;

   317 	}

   318 

   319 TInt CMobileConferenceCallDMmTsy::HangUpCancel(const TTsyReqHandle aTsyReqHandle)

   320 	{

   321 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::HangUpCancel Called"));

   322 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   323 	ReqCompleted(aTsyReqHandle,KErrCancel);

   324 	return KErrNone;

   325 	}

   326 

   327 TInt CMobileConferenceCallDMmTsy::EnumerateCalls(const TTsyReqHandle aTsyReqHandle, TUint* aCount)

   328 	{

   329 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::EnumerateCalls Called"));

   330 	*aCount = DMMTSY_CONFERENCE_CALL_COUNT;

   331 	ReqCompleted(aTsyReqHandle,KErrNone);

   332 	return KErrNone;

   333 	}

   334 

   335 TInt CMobileConferenceCallDMmTsy::GetMobileCallInfo(const TTsyReqHandle aTsyReqHandle, TInt *aIndex, TDes8* aCallInfo)

   336 	{

   337 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::GetMobileCallInfo Called"));

   338 	if (*aIndex != DMMTSY_CONFERENCE_CALL_INDEX)

   339 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   340 	else

   341 		{

   342 		RMobileCall::TMobileCallInfoV1Pckg* ciPckg = STATIC_CAST(RMobileCall::TMobileCallInfoV1Pckg*,aCallInfo);

   343 		RMobileCall::TMobileCallInfoV1& ci = (*ciPckg)();

   344 

   345 		ci.iCallName = DMMTSY_CONFERENCE_CALL_NAME;

   346 		ci.iLineName = DMMTSY_CONFERENCE_CALL_LINE;

   347 

   348 		ReqCompleted(aTsyReqHandle,KErrNone);

   349 		}

   350 	return KErrNone;

   351 	}

   352 

   353 TInt CMobileConferenceCallDMmTsy::GetConferenceStatus(const TTsyReqHandle aTsyReqHandle, RMobileConferenceCall::TMobileConferenceStatus* aStatus)

   354 	{

   355 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::GetConferenceStatus Called"));

   356 	*aStatus = DMMTSY_CONFERENCE_CALL_STATUS;

   357 	ReqCompleted(aTsyReqHandle,KErrNone);

   358 	return KErrNone;

   359 	}

   360 

   361 TInt CMobileConferenceCallDMmTsy::NotifyConferenceStatusChange(const TTsyReqHandle aTsyReqHandle, RMobileConferenceCall::TMobileConferenceStatus* aStatus)

   362 	{

   363 	if (!iNotifyConferenceStatusChange++)

   364 		{

   365 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyConferenceStatusChange Called"));

   366 		*aStatus = DMMTSY_CONFERENCE_CALL_STATUS;

   367 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   368 		}

   369 	return KErrNone;

   370 	}

   371 

   372 TInt CMobileConferenceCallDMmTsy::NotifyConferenceStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

   373 	{

   374 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyConferenceStatusChangeCancel Called"));

   375 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   376 	ReqCompleted(aTsyReqHandle,KErrCancel);

   377 	return KErrNone;	

   378 	}

   379 

   380 TInt CMobileConferenceCallDMmTsy::NotifyConferenceEvent(const TTsyReqHandle aTsyReqHandle, RMobileConferenceCall::TMobileConferenceEvent* aEvent, TDes* aCallName)

   381 	{

   382 	if (!iNotifyConferenceEvent++)

   383 		{

   384 		LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyConferenceEvent Called"));

   385 		*aEvent = DMMTSY_CONFERENCE_CALL_EVENT;

   386 		*aCallName = DMMTSY_CONFERENCE_CALL_NAME;

   387 		iPhone->AddDelayedReq(aTsyReqHandle,this);

   388 		}

   389 	return KErrNone;

   390 	}

   391 

   392 TInt CMobileConferenceCallDMmTsy::NotifyConferenceEventCancel(const TTsyReqHandle aTsyReqHandle)

   393 	{

   394 	LOGTEXT(_L8("CMobileConferenceCallDMmTsy::NotifyConferenceEventCancel Called"));

   395 	iPhone->RemoveDelayedReq(aTsyReqHandle);

   396 	ReqCompleted(aTsyReqHandle,KErrCancel);

   397 	return KErrNone;

   398 	}

   399