1 // Copyright (c) 2006-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 //

    15 

    16 #include <s32mem.h>

    17 #include "mmfaudioclientserver.h"

    18 #include "mmfaudioserver.h"

    19 #include "mmfdevsoundserver.h"

    20 #include "mmfdevsoundsession.h"

    21 #include <mmf/plugin/mmfdevsoundcustominterface.hrh>

    22 #include <mm/mmpluginutils.h>

    23 #ifdef _DEBUG

    24 #include "e32debug.h"

    25 

    26 #define SYMBIAN_DEBPRN0(str)                RDebug::Print(str, this)

    27 #define SYMBIAN_DEBPRN1(str, val1)          RDebug::Print(str, this, val1)

    28 #define SYMBIAN_DEBPRN2(str, val1, val2)    RDebug::Print(str, this, val1, val2)

    29 #define SYMBIAN_DEBPRN3(str, val1, val2, val3)    RDebug::Print(str, this, val1, val2, val3)

    30 #else

    31 #define SYMBIAN_DEBPRN0(str)

    32 #define SYMBIAN_DEBPRN1(str, val1)

    33 #define SYMBIAN_DEBPRN2(str, val1, val2)

    34 #define SYMBIAN_DEBPRN3(str, val1, val2, val3)

    35 #endif //_DEBUG

    36 

    37 const TInt KMaxQueueRequest = 6;

    38 

    39 //	MEMBER FUNCTIONS 

    40 

    41 TMMFDevSoundRequest::TMMFDevSoundRequest() 

    42 	: iMessageCompleted(EFalse), 

    43 	iRequestType(EUndefinedType),

    44 	iCallBackPF(KCallbackNone)

    45 	{

    46 	}

    47 

    48 TMMFDevSoundRequest::TMMFDevSoundRequest(TInt aIsCallBack)

    49 	: iMessageCompleted(EFalse), 

    50 	iRequestType(ECallBackType),

    51 	iCallBackPF(aIsCallBack)

    52 	{

    53 	}

    54 

    55 TMMFDevSoundRequest::TMMFDevSoundRequest(const TMMFDevSoundRequest& aRequest)

    56 	: iMessageCompleted(EFalse), 

    57 	iMessage(aRequest.iMessage),

    58 	iCallBackPF(aRequest.iCallBackPF)

    59 	{

    60 	iRequestType = ResolveType();

    61 	}

    62 

    63 TBool TMMFDevSoundRequest::operator==(const TMMFDevSoundRequest& aRequest) const

    64 	{

    65 	TBool retval = EFalse;

    66 	if ( aRequest.Function() == Function() )

    67 		{

    68 		retval = ETrue;

    69 		}

    70 	else

    71 		{

    72 		retval = EFalse;

    73 		}

    74 	return retval;

    75 	}

    76 

    77 const RMmfIpcMessage& TMMFDevSoundRequest::Message() 

    78 	{ 

    79 	return iMessage; 

    80 	}

    81 

    82 void TMMFDevSoundRequest::SetMessage(const RMmfIpcMessage& aMessage) 

    83 	{

    84 	iMessageCompleted = EFalse;

    85 	iMessage = aMessage;

    86 	iRequestType = ResolveType();

    87 	}

    88 	

    89 void TMMFDevSoundRequest::SetMessageCallback() 

    90 	{

    91 	iMessageCompleted = EFalse;

    92 	iRequestType = ECallBackType;

    93 	}	

    94 

    95 TInt TMMFDevSoundRequest::IsCallBack() const

    96 	{

    97 	return iCallBackPF;	

    98 	}

    99 

   100 TMMFDevSoundRequest::TA3FDevSoundRequestType TMMFDevSoundRequest::ResolveType()

   101 	{

   102 	TA3FDevSoundRequestType type = EUndefinedType;

   103 	switch(iMessage.Function())

   104 		{

   105 		case EMMFDevSoundProxyInitialize1:

   106 		case EMMFDevSoundProxyInitialize2:

   107 		case EMMFDevSoundProxyInitialize4:

   108 		case EMMFDevSoundProxyPlayInit:

   109 		case EMMFDevSoundProxyRecordInit:

   110 		case EMMFDevSoundProxyPlayTone:

   111 		case EMMFDevSoundProxyPlayDualTone:

   112 		case EMMFDevSoundProxyPlayDTMFString:

   113 		case EMMFDevSoundProxyPlayToneSequence:

   114 		case EMMFDevSoundProxyPlayFixedSequence:

   115 			type = EAction_PseudoAsynchronous;

   116 			break;

   117 

   118 		case EMMFDevSoundProxyStop:

   119 		case EMMFDevSoundProxyPause:

   120 		case EMMFDevSoundProxyClose:

   121 		case EMMFDevSoundProxyCancelInitialize:

   122 		case EMMFDevSoundProxyResume:

   123 		case EMMFDevSoundProxyEmptyBuffers:

   124 			type = EAction_Asynchronous;

   125 			break;

   126 

   127 		case EMMFDevSoundProxySetConfig:

   128 		case EMMFDevSoundProxyPostOpen: // Although this is not a configure operation technically, it has same calling pattern.

   129 		case EMMFDevSoundProxySetVolume:

   130 		case EMMFDevSoundProxySetGain:

   131 		case EMMFDevSoundProxySetPlayBalance:

   132 		case EMMFDevSoundProxySetRecordBalance:

   133 		case EMMFDevSoundProxySetVolumeRamp:

   134 		case EMMFDevSoundProxySetPrioritySettings:

   135 			type = EConfigure_Asynchronous;

   136 			break;

   137 			

   138 		case EMMFDevSoundProxySetDTMFLengths:

   139 		case EMMFDevSoundProxySetToneRepeats:

   140 			type = EConfigure_Synchronous;	

   141 			break;

   142 		case EMMFDevSoundProxyCapabilities:

   143 			type = EQuery_Asynchronous;

   144 			break;

   145 		case EMMFDevSoundProxyMaxVolume:

   146 		case EMMFDevSoundProxyMaxGain:

   147 		case EMMFDevSoundProxyConfig:

   148 		case EMMFDevSoundProxyVolume:

   149 		case EMMFDevSoundProxyGain:

   150 		case EMMFDevSoundProxyPlayBalance:

   151 		case EMMFDevSoundProxyRecordBalance:

   152 		case EMMFDevSoundProxyGetSupportedInputDataTypes:

   153 		case EMMFDevSoundProxyGetSupportedOutputDataTypes:

   154 		case EMMFDevSoundProxyFixedSequenceName:

   155 		case EMMFDevSoundProxyFixedSequenceCount:

   156 		case EMMFDevSoundProxySamplesRecorded:

   157 		case EMMFDevSoundProxySamplesPlayed:

   158 		case EMMFDevSoundProxyCopyFourCCArrayData:

   159 		case EMMFDevSoundProxyGetTimePlayed:

   160 		case EMMFDevSoundProxyIsResumeSupported:

   161 			type = EQuery_Synchronous;

   162 			break;

   163 		

   164 		case EMMFDevSoundProxyBTBFData:

   165 		case EMMFDevSoundProxyBTBEData:

   166 		case EMMFDevSoundProxyPlayData:

   167 		case EMMFDevSoundProxyRecordData:

   168 			type = EBufferExchangeRelated;

   169 			break;

   170 

   171 		// Custom Interfaces

   172 		case EMMFDevSoundProxySyncCustomCommand:

   173 		case EMMFDevSoundProxySyncCustomCommandResult:

   174 		case EMMFDevSoundProxyAsyncCustomCommand:

   175 		case EMMFDevSoundProxyAsyncCustomCommandResult:

   176 		case EMMFDevSoundProxyCustomInterface:

   177 			type = ECustomInterfacesRelated;

   178 			break;

   179 		case RMessage2::EDisConnect:

   180 			type = ESessionEvents;

   181 			break;

   182 		default:

   183 			break;

   184 		}

   185 	return type;

   186 	}

   187 

   188 

   189 void TMMFDevSoundRequest::Complete(TInt aError)	

   190 	{

   191 	if(!iMessageCompleted && iRequestType != EUndefinedType && iRequestType != ECallBackType)	

   192 		{

   193 		iMessage.Complete(aError);

   194 		iMessageCompleted = ETrue;

   195 		iRequestType = EUndefinedType;

   196 		}

   197 	}

   198 

   199 TInt TMMFDevSoundRequest::Function() const 

   200 	{

   201 	return iMessage.Function(); 

   202 	}

   203 

   204 TMMFDevSoundRequest::TA3FDevSoundRequestType TMMFDevSoundRequest::Type() const

   205 	{

   206 	return iRequestType;

   207 	}

   208 

   209 

   210 // 

   211 // CMMFDevSoundSession::CreateL

   212 // Creates a new object

   213 // 

   214 void CMMFDevSoundSession::CreateL(const CMmfIpcServer& aServer)

   215 	{

   216 	CMmfIpcSession::CreateL(aServer);

   217 	CMMFDevSoundServer& server =

   218 	const_cast<CMMFDevSoundServer&>(

   219 			static_cast<const CMMFDevSoundServer&>(aServer));

   220 	server.IncrementSessionId();

   221 	iDevSoundSessionId = server.DevSoundSessionId();

   222 	}

   223 

   224 //

   225 // NeedToQueue - mid-commit cycle or async queue start AO is active

   226 //

   227 TBool CMMFDevSoundSession::NeedToQueue() const

   228     {

   229     return iOperationCompletePending || iAsyncQueueStart->IsActive();

   230     }

   231 

   232 //

   233 // CMMFDevSoundSession::ServiceL

   234 // (other items were commented in a header).

   235 //

   236 void CMMFDevSoundSession::ServiceL(const RMmfIpcMessage& aMessage)

   237 	{

   238 	SYMBIAN_DEBPRN2(_L("\nCMMFDevSoundSession[0x%x] NEW REQUEST %02x while pending=%d"),

   239 	        aMessage.Function(), NeedToQueue());

   240 	

   241 	if(NeedToQueue())

   242 		{

   243 		// if not possible to service now, then queue request

   244 		EnqueueRequest(aMessage);

   245 		}

   246 	else

   247 		{

   248 		// If there is no oustanding operation service inmediately

   249 		TRAPD(err, DoServiceRequestL(aMessage));

   250 		if (err)

   251 		    {

   252             aMessage.Complete(err); // repeat normal ServiceL() behaviour since we may keep going

   253 		    }

   254 	    if (!iOperationCompletePending && iQueuedRequests.Count() != 0)

   255 	        {

   256 	        //dequeue next

   257 	        DequeueRequest();

   258 	        }

   259 		}

   260 	}

   261 	

   262 //

   263 // CMMFDevSoundSession::DoServiceL

   264 // (other items were commented in a header).

   265 //

   266 void CMMFDevSoundSession::DoServiceRequestL(const RMmfIpcMessage& aMessage)

   267 	{

   268 	iRequestBeingServiced.SetMessage(aMessage);

   269 	iAsyncQueueStart->Cancel(); // just in case.

   270     ResetNotifiedError();

   271 

   272     if (aMessage.Function() == RMessage2::EDisConnect)

   273         {

   274         TBool complete = iAdapter->CloseDevSound();

   275         if(!complete)

   276             {

   277             iRequestBeingServiced.SetMessage(aMessage);

   278             iOperationCompletePending = ETrue;

   279             ResetNotifiedError();

   280             }

   281         else

   282             {

   283             // if we get here, iClosing wait will have been started and we'd be waiting

   284             iClosingWait->AsyncStop();

   285             }

   286         return;

   287         }

   288     

   289     TMMFMessageDestinationPckg destinationPckg;

   290 	User::LeaveIfError(MessageRead(aMessage, 0, destinationPckg));

   291 	SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - DestinationHandle [%d] InterfaceId [%d] "), destinationPckg().DestinationHandle(), destinationPckg().InterfaceId());

   292 	if ((destinationPckg().DestinationHandle() == KMMFObjectHandleDevSound) &&

   293 	    (destinationPckg().InterfaceId() == KUidInterfaceMMFDevSound))

   294 		{

   295         SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - Request [%d]"), aMessage.Function());

   296 		TBool complete = EFalse;

   297 		switch(aMessage.Function())

   298 			{

   299 			case EMMFDevSoundProxyPostOpen:

   300 				complete = DoPostOpenL(aMessage);

   301 				break;

   302 			case EMMFDevSoundProxyInitialize1:

   303 				complete = DoInitialize1L(aMessage);

   304 				break;

   305 			case EMMFDevSoundProxyInitialize2:

   306 				complete = DoInitialize2L(aMessage);

   307 				break;

   308 			case EMMFDevSoundProxyInitialize4:

   309 				complete = DoInitialize4L(aMessage);

   310 				break;

   311 			case EMMFDevSoundProxyCapabilities:

   312 				complete = DoCapabilitiesL(aMessage);

   313 				break;

   314 			case EMMFDevSoundProxyConfig:

   315 				complete = DoConfigL(aMessage);

   316 				break;

   317 			case EMMFDevSoundProxySetConfig:

   318 				complete = DoSetConfigL(aMessage);

   319 				break;

   320 			case EMMFDevSoundProxyMaxVolume:

   321 				complete = DoMaxVolumeL(aMessage);

   322 				break;

   323 			case EMMFDevSoundProxyVolume:

   324 				complete = DoVolumeL(aMessage);

   325 				break;

   326 			case EMMFDevSoundProxySetVolume:

   327 				complete = DoSetVolumeL(aMessage);

   328 				break;

   329 			case EMMFDevSoundProxyMaxGain:

   330 				complete = DoMaxGainL(aMessage);

   331 				break;

   332 			case EMMFDevSoundProxyGain:

   333 				complete = DoGainL(aMessage);

   334 				break;

   335 			case EMMFDevSoundProxySetGain:

   336 				complete = DoSetGainL(aMessage);

   337 				break;

   338 			case EMMFDevSoundProxyPlayBalance:

   339 				complete = DoGetPlayBalanceL(aMessage);

   340 				break;

   341 			case EMMFDevSoundProxySetPlayBalance:

   342 				complete = DoSetPlayBalanceL(aMessage);

   343 				break;

   344 			case EMMFDevSoundProxyRecordBalance:

   345 				complete = DoGetRecordBalanceL(aMessage);

   346 				break;

   347 			case EMMFDevSoundProxySetRecordBalance:

   348 				complete = DoSetRecordBalanceL(aMessage);

   349 				break;

   350 			case EMMFDevSoundProxyBTBFData:

   351 				complete = DoBufferToBeFilledDataL(aMessage);

   352 				break;

   353 			case EMMFDevSoundProxyBTBEData:

   354 				complete = DoBufferToBeEmptiedDataL(aMessage);

   355 				break;

   356 			case EMMFDevSoundProxyPlayInit:

   357 				complete = DoPlayInitL(aMessage);

   358 				break;

   359 			case EMMFDevSoundProxyRecordInit:

   360 				complete = DoRecordInitL(aMessage);

   361 				break;

   362 			case EMMFDevSoundProxyPlayData:

   363 				complete = DoPlayDataL(aMessage);

   364 				break;

   365 			case EMMFDevSoundProxyRecordData:

   366 				complete = DoRecordDataL(aMessage);

   367 				break;

   368 			case EMMFDevSoundProxyStop:

   369 				complete = DoStopL(aMessage);

   370 				break;

   371 			case EMMFDevSoundProxyPause:

   372 				complete = DoPauseL(aMessage);

   373 				break;

   374 			case EMMFDevSoundProxyPlayTone:

   375 				complete = DoPlayToneL(aMessage);

   376 				break;

   377 			case EMMFDevSoundProxyPlayDualTone:

   378 				complete = DoPlayDualToneL(aMessage);

   379 				break;

   380 			case EMMFDevSoundProxyPlayDTMFString:

   381 				complete = DoPlayDTMFStringL(aMessage);

   382 				break;

   383 			case EMMFDevSoundProxyPlayToneSequence:

   384 				complete = DoPlayToneSequenceL(aMessage);

   385 				break;

   386 			case EMMFDevSoundProxyPlayFixedSequence:

   387 				complete = DoPlayFixedSequenceL(aMessage);

   388 				break;

   389 			case EMMFDevSoundProxySetDTMFLengths:

   390 				complete = DoSetDTMFLengthsL(aMessage);

   391 				break;

   392 			case EMMFDevSoundProxySetVolumeRamp:

   393 				complete = DoSetVolumeRampL(aMessage);

   394 				break;

   395 			case EMMFDevSoundProxyGetSupportedInputDataTypes:

   396 				complete = DoGetSupportedInputDataTypesL(aMessage);

   397 				break;

   398 			case EMMFDevSoundProxyGetSupportedOutputDataTypes:

   399 				complete = DoGetSupportedOutputDataTypesL(aMessage);

   400 				break;

   401 			case EMMFDevSoundProxyCopyFourCCArrayData:

   402 				complete = DoCopyFourCCArrayDataL(aMessage);

   403 				break;

   404 			case EMMFDevSoundProxySamplesRecorded:

   405 				complete = DoSamplesRecordedL(aMessage);

   406 				break;

   407 			case EMMFDevSoundProxySamplesPlayed:

   408 				complete = DoSamplesPlayedL(aMessage);

   409 				break;

   410 			case EMMFDevSoundProxySetToneRepeats:

   411 				complete = DoSetToneRepeatsL(aMessage);

   412 				break;

   413 			case EMMFDevSoundProxySetPrioritySettings:

   414 				complete = DoSetPrioritySettingsL(aMessage);

   415 				break;

   416 			case EMMFDevSoundProxyFixedSequenceCount:

   417 				complete = DoFixedSequenceCountL(aMessage);

   418 				break;

   419 			case EMMFDevSoundProxyCancelInitialize:

   420 				complete = DoCancelInitializeL(aMessage);

   421 				break;

   422 			case EMMFDevSoundProxyEmptyBuffers:

   423 				complete = DoEmptyBuffersL(aMessage);

   424 				break;

   425 			case EMMFDevSoundProxyGetTimePlayed:

   426 				complete = DoGetTimePlayedL(aMessage);

   427 				break;

   428 			case EMMFDevSoundProxyIsResumeSupported:

   429 				complete = DoQueryResumeSupportedL(aMessage);

   430 				break;

   431 			case EMMFDevSoundProxyResume:

   432 				complete = DoResumeL(aMessage);

   433 				break;

   434 

   435 			// DevSound custom command support

   436 			case EMMFDevSoundProxySyncCustomCommand:

   437 			case EMMFDevSoundProxySyncCustomCommandResult:

   438 			case EMMFDevSoundProxyAsyncCustomCommand:

   439 			case EMMFDevSoundProxyAsyncCustomCommandResult:

   440 				complete = DoCustomCommandL(aMessage);

   441 				break;

   442 			case EMMFDevSoundProxyClose:

   443 				complete = DoPrepareCloseL(aMessage);

   444 				break;

   445 			case EMMFDevSoundProxyRequestResourceNotification:

   446 				complete = DoRegisterAsClientL(aMessage);

   447 				break;

   448 			case EMMFDevSoundProxyCancelRequestResourceNotification:

   449 				complete = DoCancelRegisterAsClientL(aMessage);

   450 				break;

   451 			case EMMFDevSoundProxyGetResourceNotificationData:

   452 				complete = DoGetResourceNotificationDataL(aMessage);

   453 				break;

   454 			case EMMFDevSoundProxyWillResumePlay:

   455 				complete = DoWillResumePlayL(aMessage);

   456 				break;

   457 			case EMMFDevSoundProxySetClientThreadInfo:

   458 				complete = DoSetClientThreadInfoL(aMessage);

   459 				break;						

   460 			default:

   461 				User::Leave(KErrNotSupported);

   462 				break;

   463 			}

   464 

   465 		// Check if can complete the message now

   466 		if (complete)

   467 			{

   468 			// Complete the message

   469 			// Synchronous requests & Pseudo-asynchronous

   470 			aMessage.Complete(KErrNone);

   471 

   472 			// Store function if we need to re-apply it again due to pre-emption clash

   473 			if(iRequestBeingServiced.Type() == TMMFDevSoundRequest::EAction_PseudoAsynchronous)

   474 				{

   475 				iRedoFunction = aMessage.Function();

   476 				}

   477 			}

   478 		}

   479 	else

   480 		{

   481 		// If there's a CI extension, see if that handles this request

   482 		TInt err = KErrNotSupported;

   483 		if (iCIExtension)

   484 			{

   485             SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - CIExtensionRequest [%d]"), aMessage.Function());

   486             iOperationCompletePending = ETrue;

   487 			iHandlingExtdCI = ETrue;

   488 			TRAPD(err2, err = iCIExtension->HandleMessageL(aMessage));

   489 			if (err2)

   490 				{

   491 				err = err2;

   492 				}

   493 			iOperationCompletePending = EFalse;

   494 			iHandlingExtdCI = EFalse;

   495 			SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - CIExtensionRequest[%d] - Exit with Error[%d] "), aMessage.Function(),err);

   496 			}

   497 

   498 		if (err != KErrNone)

   499 			{

   500 			// Not been handled, the request is not supported

   501 			aMessage.Complete(KErrNotSupported);

   502 			}

   503 		}

   504 	}

   505 

   506 void CMMFDevSoundSession::DoServiceAlreadyCompletedRequestL(const TInt aFunction)

   507 	{

   508     ResetNotifiedError();

   509 

   510 	switch(aFunction)

   511 		{

   512 		case EMMFDevSoundProxyInitialize1:

   513 			DoAlreadyCompletedInitialize1L();

   514 			break;

   515 		case EMMFDevSoundProxyInitialize2:

   516 			DoAlreadyCompletedInitialize2L();

   517 			break;

   518 		case EMMFDevSoundProxyInitialize4:

   519 			DoAlreadyCompletedInitialize4L();

   520 			break;

   521 		case EMMFDevSoundProxyPlayInit:

   522 			DoAlreadyCompletedPlayInitL();

   523 			break;

   524 		case EMMFDevSoundProxyRecordInit:

   525 			DoAlreadyCompletedRecordInitL();

   526 			break;

   527 		case EMMFDevSoundProxyPlayTone:

   528 			DoAlreadyCompletedPlayToneL();

   529 			break;

   530 		case EMMFDevSoundProxyPlayDualTone:

   531 			DoAlreadyCompletedPlayDualToneL();

   532 			break;

   533 		case EMMFDevSoundProxyPlayDTMFString:

   534 			DoAlreadyCompletedPlayDTMFStringL();

   535 			break;

   536 		case EMMFDevSoundProxyPlayToneSequence:

   537 			DoAlreadyCompletedPlayToneSequenceL();

   538 			break;

   539 		case EMMFDevSoundProxyPlayFixedSequence:

   540 			DoAlreadyCompletedPlayFixedSequenceL();

   541 			break;

   542 		default:

   543 			User::Leave(KErrNotSupported);

   544 			break;

   545 		}

   546 

   547 	}

   548 

   549 void CMMFDevSoundSession::HandleAlreadyCompletedRequest()

   550 	{

   551 	TRAPD(err,DoServiceAlreadyCompletedRequestL(iRedoFunction));

   552 

   553 	if (err != KErrNone)

   554 		{

   555 		switch(iRedoFunction)

   556 			{

   557 			case EMMFDevSoundProxyInitialize1:

   558 			case EMMFDevSoundProxyInitialize2:

   559 			case EMMFDevSoundProxyInitialize4:

   560 				InitializeComplete(err);

   561 				break;

   562 			case EMMFDevSoundProxyPlayInit:

   563 				PlayError(err);

   564 				break;

   565 			case EMMFDevSoundProxyRecordInit:

   566 				RecordError(err);

   567 				break;

   568 			case EMMFDevSoundProxyPlayTone:

   569 			case EMMFDevSoundProxyPlayDualTone:

   570 			case EMMFDevSoundProxyPlayDTMFString:

   571 			case EMMFDevSoundProxyPlayToneSequence:

   572 			case EMMFDevSoundProxyPlayFixedSequence:

   573 				ToneFinished(err);

   574 				break;

   575 			default:

   576 				break;

   577 			}

   578 		}

   579 	}

   580 

   581 void CMMFDevSoundSession::EnqueueRequest(const RMmfIpcMessage& aMessage)

   582 	{

   583     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::EnqueueRequest - Enter"));

   584 	// Encapsule the request

   585 	TMMFDevSoundRequest request;

   586 	request.SetMessage(aMessage);

   587 	// Append

   588 	TInt error = iQueuedRequests.Append(request);

   589 	__ASSERT_DEBUG(error == KErrNone, Panic(EQueueRequestsFailedToAppend));

   590 	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::EnqueueRequest - Exit"));

   591 	}

   592 

   593 //

   594 // CMMFDevSoundSession::DoPostOpenL

   595 //

   596 TBool CMMFDevSoundSession::DoPostOpenL(const RMmfIpcMessage& /*aMessage*/)

   597 	{

   598 	iAdapter->PostOpenL();

   599 	iOperationCompletePending = ETrue;

   600 	return EFalse;

   601 	}

   602 

   603 //

   604 // CMMFDevSoundSession::DoInitialize1L

   605 // (other items were commented in a header).

   606 //

   607 TBool CMMFDevSoundSession::DoInitialize1L(const RMmfIpcMessage& aMessage)

   608 	{

   609     iMsgQueue.Close(); // close if already open

   610 	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread

   611 	User::LeaveIfError(err);

   612 	DoSetClientConfigL();// added here instead of the CreateL()

   613 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   614 	User::LeaveIfError(MessageRead(aMessage,1,devSoundBuf));

   615 	iCachedClientData = devSoundBuf;

   616 	TMMFState mode = devSoundBuf().iMode;

   617 	iAdapter->InitializeL(mode);

   618 	iBufferPlay = NULL;

   619 	iPlayErrorOccured = EFalse;

   620 	// Flag to queue any further request 

   621 	// but the message can be completed now

   622 	iOperationCompletePending = ETrue;

   623 	return ETrue;

   624 	}

   625 

   626 //

   627 // CMMFDevSoundSession::DoAlreadyCompletedInitialize1L

   628 // (other items were commented in a header).

   629 //

   630 void CMMFDevSoundSession::DoAlreadyCompletedInitialize1L()

   631 	{

   632 	TMMFState mode = iCachedClientData().iMode;

   633 	iAdapter->InitializeL(mode);

   634 	iBufferPlay = NULL;

   635 	iPlayErrorOccured = EFalse;

   636 	// Flag to queue any further request

   637 	iOperationCompletePending = ETrue;

   638 	}

   639 

   640 //

   641 // CMMFDevSoundSession::DoInitialize2L

   642 // (other items were commented in a header).

   643 //

   644 TBool CMMFDevSoundSession::DoInitialize2L(const RMmfIpcMessage& aMessage)

   645 	{

   646     iMsgQueue.Close(); // close if already open

   647 	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread

   648 	User::LeaveIfError(err);

   649 	DoSetClientConfigL();// added here instead of the CreateL()

   650 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   651 	User::LeaveIfError(MessageRead(aMessage,1,devSoundBuf));

   652 	iCachedClientData = devSoundBuf;

   653 	TUid HWDev = devSoundBuf().iHWDev;

   654 	TMMFState mode = devSoundBuf().iMode;

   655 	iAdapter->InitializeL(HWDev, mode);

   656 	iBufferPlay = NULL;

   657 	iPlayErrorOccured = EFalse;

   658 	return ETrue;

   659 	}

   660 

   661 //

   662 // CMMFDevSoundSession::DoAlreadyCompletedInitialize2L

   663 // (other items were commented in a header).

   664 //

   665 void CMMFDevSoundSession::DoAlreadyCompletedInitialize2L()

   666 	{

   667 	TUid HWDev = iCachedClientData().iHWDev;

   668 	TMMFState mode = iCachedClientData().iMode;

   669 	iAdapter->InitializeL(HWDev, mode);

   670 	iBufferPlay = NULL;

   671 	iPlayErrorOccured = EFalse;

   672 	}

   673 

   674 //

   675 // CMMFDevSoundSession::DoInitialize4L

   676 // (other items were commented in a header).

   677 //

   678 TBool CMMFDevSoundSession::DoInitialize4L(const RMmfIpcMessage& aMessage)

   679 	{

   680     iMsgQueue.Close();

   681 	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread

   682 	User::LeaveIfError(err);

   683 	DoSetClientConfigL();// added here instead of the CreateL()

   684 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   685 	User::LeaveIfError(MessageRead(aMessage, TInt(1), devSoundBuf));

   686 	iCachedClientData = devSoundBuf;

   687 	TFourCC desiredFourCC = devSoundBuf().iDesiredFourCC;

   688 	TMMFState mode = devSoundBuf().iMode;

   689 	iAdapter->InitializeL(desiredFourCC, mode);

   690 	iBufferPlay = NULL;

   691 	iPlayErrorOccured = EFalse;

   692 	// Flag to queue any further request 

   693 	// but the message can be completed now

   694 	iOperationCompletePending = ETrue;

   695 	return ETrue;

   696 	}

   697 

   698 //

   699 // CMMFDevSoundSession::DoAlreadyCompletedInitialize4L

   700 // (other items were commented in a header).

   701 //

   702 void CMMFDevSoundSession::DoAlreadyCompletedInitialize4L()

   703 	{

   704 	TFourCC desiredFourCC = iCachedClientData().iDesiredFourCC;

   705 	TMMFState mode = iCachedClientData().iMode;

   706 	iAdapter->InitializeL(desiredFourCC, mode);

   707 	iBufferPlay = NULL;

   708 	iPlayErrorOccured = EFalse;

   709 	// Flag to queue any further request

   710 	iOperationCompletePending = ETrue;

   711 	}

   712 

   713 //

   714 // CMMFDevSoundSession::DoCancelInitialize

   715 // (other items were commented in a header).

   716 //

   717 TBool CMMFDevSoundSession::DoCancelInitializeL(const RMmfIpcMessage& aMessage)

   718 	{

   719 	TInt err=iAdapter->CancelInitialize();

   720 

   721 	if (err != KErrNone)

   722 		{

   723 		aMessage.Complete(err);

   724 		iOperationCompletePending = EFalse;

   725 		return ETrue;

   726 		}

   727 	else

   728 		{

   729 		iOperationCompletePending = ETrue;

   730 		}

   731 	return EFalse;

   732 	}

   733 

   734 //

   735 // CMMFDevSoundSession::DoCapabilitiesL

   736 // (other items were commented in a header).

   737 //

   738 TBool CMMFDevSoundSession::DoCapabilitiesL(const RMmfIpcMessage& aMessage)

   739 	{

   740 	TInt err = iAdapter->Capabilities(iDevSoundCapabilities);

   741 	if(err != KErrNone)

   742 		{

   743 		aMessage.Complete(err);

   744 		iOperationCompletePending = EFalse;

   745 		}

   746 	else

   747 		{

   748 		iOperationCompletePending = ETrue;

   749 		}

   750 	return EFalse;

   751 	}

   752 

   753 //

   754 // CMMFDevSoundSession::DoConfigL

   755 // (other items were commented in a header).

   756 //

   757 TBool CMMFDevSoundSession::DoConfigL(const RMmfIpcMessage& aMessage)

   758 	{

   759 	TMMFDevSoundProxySettings devSoundSet;

   760 	devSoundSet.iConfig = iAdapter->Config();

   761 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   762 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   763 	return ETrue;

   764 	}

   765 

   766 //

   767 // CMMFDevSoundSession::DoSetConfigL

   768 // (other items were commented in a header).

   769 //

   770 TBool CMMFDevSoundSession::DoSetConfigL(const RMmfIpcMessage& aMessage)

   771 	{

   772 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   773 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

   774 	TMMFCapabilities config = devSoundBuf().iConfig;

   775 	iAdapter->SetConfigL(config);

   776 	iOperationCompletePending = ETrue;

   777 	return EFalse;

   778 	}

   779 

   780 //

   781 // CMMFDevSoundSession::axVolumeL

   782 // (other items were commented in a header).

   783 //

   784 TBool CMMFDevSoundSession::DoMaxVolumeL(const RMmfIpcMessage& aMessage)

   785 	{

   786 	TMMFDevSoundProxySettings devSoundSet;

   787 	devSoundSet.iMaxVolume = iAdapter->MaxVolume();

   788 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   789 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   790 	return ETrue;

   791 	}

   792 

   793 //

   794 // CMMFDevSoundSession::DoVolumeL

   795 // (other items were commented in a header).

   796 //

   797 TBool CMMFDevSoundSession::DoVolumeL(const RMmfIpcMessage& aMessage)

   798 	{

   799 	TMMFDevSoundProxySettings devSoundSet;

   800 	devSoundSet.iVolume = iAdapter->Volume();

   801 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   802 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   803 	return ETrue;

   804 	}

   805 

   806 //

   807 // CMMFDevSoundSession::DoSetVolumeL

   808 // (other items were commented in a header).

   809 //

   810 TBool CMMFDevSoundSession::DoSetVolumeL(const RMmfIpcMessage& aMessage)

   811 	{

   812 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   813 	User::LeaveIfError(MessageRead(aMessage, TInt(1),devSoundBuf));

   814 	TInt volume = devSoundBuf().iVolume;

   815 	TBool asyncOperation;

   816 	User::LeaveIfError(iAdapter->SetVolume(volume, asyncOperation));

   817 	iOperationCompletePending = asyncOperation;

   818 	return !asyncOperation;

   819 	}

   820 

   821 //

   822 // CMMFDevSoundSession::DoMaxGainL

   823 // (other items were commented in a header).

   824 //

   825 TBool CMMFDevSoundSession::DoMaxGainL(const RMmfIpcMessage& aMessage)

   826 	{

   827 	TMMFDevSoundProxySettings devSoundSet;

   828 	devSoundSet.iMaxGain = iAdapter->MaxGain();

   829 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   830 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   831 	return ETrue;

   832 	}

   833 

   834 //

   835 // CMMFDevSoundSession::DoGainL

   836 // (other items were commented in a header).

   837 //

   838 TBool CMMFDevSoundSession::DoGainL(const RMmfIpcMessage& aMessage)

   839 	{

   840 	TMMFDevSoundProxySettings devSoundSet;

   841 	devSoundSet.iGain = iAdapter->Gain();

   842 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   843 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   844 	return ETrue;

   845 	}

   846 

   847 //

   848 // CMMFDevSoundSession::DoSetGainL

   849 // (other items were commented in a header).

   850 //

   851 TBool CMMFDevSoundSession::DoSetGainL(const RMmfIpcMessage& aMessage)

   852 	{

   853 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   854 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

   855 	TInt gain = devSoundBuf().iGain;

   856 	TBool asyncOperation;

   857 	User::LeaveIfError(iAdapter->SetGain(gain, asyncOperation));

   858 	iOperationCompletePending = asyncOperation;

   859 	return !asyncOperation;

   860 	}

   861 

   862 //

   863 // CMMFDevSoundSession::DoGetPlayBalanceL

   864 // (other items were commented in a header).

   865 //

   866 TBool CMMFDevSoundSession::DoGetPlayBalanceL(const RMmfIpcMessage& aMessage)

   867 	{

   868 	TMMFDevSoundProxySettings devSoundSet;

   869 	iAdapter->GetPlayBalanceL(devSoundSet.iLeftPercentage, devSoundSet.iRightPercentage);

   870 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   871 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   872 	return ETrue;

   873 	}

   874 

   875 //

   876 // CMMFDevSoundSession::DoSetPlayBalanceL

   877 // (other items were commented in a header).

   878 //

   879 TBool CMMFDevSoundSession::DoSetPlayBalanceL(const RMmfIpcMessage& aMessage)

   880 	{

   881 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   882     User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

   883 	TInt leftPercentage = devSoundBuf().iLeftPercentage;

   884 	TInt rightPercentage = devSoundBuf().iRightPercentage;

   885 	TBool asyncOperation;

   886 	iAdapter->SetPlayBalanceL(leftPercentage, rightPercentage, asyncOperation);

   887 	iOperationCompletePending = asyncOperation;

   888 	return !asyncOperation;

   889 	}

   890 

   891 //

   892 // CMMFDevSoundSession::DoGetRecordBalanceL

   893 // (other items were commented in a header).

   894 //

   895 TBool CMMFDevSoundSession::DoGetRecordBalanceL(const RMmfIpcMessage& aMessage)

   896 	{

   897 	TMMFDevSoundProxySettings devSoundSet;

   898 	iAdapter->GetRecordBalanceL(devSoundSet.iLeftPercentage, devSoundSet.iRightPercentage);

   899 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   900 	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

   901 	return ETrue;

   902 	}

   903 

   904 //

   905 // CMMFDevSoundSession::DoSetRecordBalanceL

   906 // (other items were commented in a header).

   907 //

   908 TBool CMMFDevSoundSession::DoSetRecordBalanceL(const RMmfIpcMessage& aMessage)

   909 	{

   910 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   911 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

   912 	TInt leftPercentage = devSoundBuf().iLeftPercentage;

   913 	TInt rightPercentage = devSoundBuf().iRightPercentage;

   914 	TBool asyncOperation;

   915 	iAdapter->SetRecordBalanceL(leftPercentage, rightPercentage, asyncOperation);

   916 	iOperationCompletePending = asyncOperation;

   917 	return !asyncOperation;

   918 	}

   919 

   920 //

   921 // CMMFDevSoundSession::DoPlayInitL

   922 // (other items were commented in a header).

   923 //

   924 TBool CMMFDevSoundSession::DoPlayInitL(const RMmfIpcMessage& /*aMessage*/)

   925 	{

   926 	iAdapter->PlayInitL();

   927 	iOperationCompletePending = ETrue;

   928 	return ETrue;

   929 	}

   930 

   931 //

   932 // CMMFDevSoundSession::DoAlreadyCompletedPlayInitL

   933 // (other items were commented in a header).

   934 //

   935 void CMMFDevSoundSession::DoAlreadyCompletedPlayInitL()

   936 	{

   937 	iAdapter->PlayInitL();

   938 	iOperationCompletePending = ETrue;

   939 	}

   940 

   941 //

   942 // CMMFDevSoundSession::DoRecordInitL

   943 // (other items were commented in a header).

   944 //

   945 TBool CMMFDevSoundSession::DoRecordInitL(const RMmfIpcMessage& /*aMessage*/)

   946 	{

   947 	iAdapter->RecordInitL();

   948 	iOperationCompletePending = ETrue;

   949 	return ETrue;

   950 	}

   951 

   952 //

   953 // CMMFDevSoundSession::DoAlreadyCompletedRecordInitL

   954 // (other items were commented in a header).

   955 //

   956 void CMMFDevSoundSession::DoAlreadyCompletedRecordInitL()

   957 	{

   958 	iAdapter->RecordInitL();

   959 	iOperationCompletePending = ETrue;

   960 	}

   961 

   962 //

   963 // CMMFDevSoundSession::DoPlayDataL

   964 // (other items were commented in a header).

   965 //

   966 TBool CMMFDevSoundSession::DoPlayDataL(const RMmfIpcMessage& aMessage)

   967 	{

   968 	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Enter"));

   969 

   970 	if( iPlayErrorOccured )

   971 		{

   972 		SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Ignore and Exit"));

   973 		return ETrue;

   974 		}

   975 

   976 	TMMFDevSoundProxyHwBufPckg devSoundBuf;

   977 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

   978 	iBufferPlay->SetLastBuffer(devSoundBuf().iLastBuffer);

   979 

   980 	TPtr8 dataPtr(iChunk.Base(), devSoundBuf().iBufferSize, devSoundBuf().iBufferSize);

   981 	// Copy data over from chunk

   982 	iBufferPlay->Data().Copy(dataPtr);

   983 	iAdapter->PlayData();

   984 	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Exit"));

   985 	return ETrue;

   986 	}

   987 

   988 //

   989 // CMMFDevSoundSession::DoRecordDataL

   990 // (other items were commented in a header).

   991 //

   992 TBool CMMFDevSoundSession::DoRecordDataL(const RMmfIpcMessage& /*aMessage*/)

   993 	{

   994 	iAdapter->RecordData();

   995 	return ETrue;

   996 	}

   997 

   998 //

   999 // CMMFDevSoundSession::DoStopL

  1000 // (other items were commented in a header).

  1001 //

  1002 TBool CMMFDevSoundSession::DoStopL(const RMmfIpcMessage& /*aMessage*/)

  1003 	{

  1004     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoStopL - Enter"));

  1005     // Sometimes Stop is not involved on a commit cycle

  1006 	TBool completed = iAdapter->Stop();

  1007 	if (completed)

  1008 		{

  1009         FlushQueuedRequests();

  1010 		FlushEventQueue(); // completed returned here means we were idle to start with. TODO could possibly skip this flush

  1011 		iChunk.Close();

  1012 		}

  1013 	iOperationCompletePending = !completed;

  1014 	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoStopL - Exit. Return value is [%d]"), completed);

  1015 	return completed;

  1016 	}

  1017 

  1018 //

  1019 // CMMFDevSoundSession::DoPauseL

  1020 // (other items were commented in a header).

  1021 //

  1022 TBool CMMFDevSoundSession::DoPauseL(const RMmfIpcMessage& /*aMessage*/)

  1023 	{

  1024 	User::LeaveIfError(iAdapter->Pause());

  1025 	iOperationCompletePending = ETrue;

  1026 	return EFalse;

  1027 	}

  1028 

  1029 //

  1030 // CMMFDevSoundSession::DoPlayToneL

  1031 // (other items were commented in a header).

  1032 //

  1033 TBool CMMFDevSoundSession::DoPlayToneL(const RMmfIpcMessage& aMessage)

  1034 	{

  1035     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayToneL - Enter"));

  1036     TMMFDevSoundProxySettingsPckg devSoundBuf;

  1037 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

  1038 	iCachedClientData = devSoundBuf;

  1039 	TInt frequency = devSoundBuf().iFrequencyOne;

  1040 	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);

  1041 	iAdapter->PlayToneL(frequency, duration);

  1042 	iOperationCompletePending = ETrue;

  1043 	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayToneL - Exit. Return value is [%d]"), ETrue);

  1044 	return ETrue;

  1045 	}

  1046 

  1047 //

  1048 // CMMFDevSoundSession::DoAlreadyCompletedPlayToneL

  1049 // (other items were commented in a header).

  1050 //

  1051 void CMMFDevSoundSession::DoAlreadyCompletedPlayToneL()

  1052 	{

  1053 	TInt frequency = iCachedClientData().iFrequencyOne;

  1054 	TTimeIntervalMicroSeconds duration(iCachedClientData().iDuration);

  1055 	iAdapter->PlayToneL(frequency, duration);

  1056 	iOperationCompletePending = ETrue;

  1057 	}

  1058 

  1059 //

  1060 // CMMFDevSoundSession::DoPlayDualToneL

  1061 // (other items were commented in a header).	

  1062 //

  1063 TBool CMMFDevSoundSession::DoPlayDualToneL(const RMmfIpcMessage& aMessage)

  1064 	{

  1065     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDualToneL - Enter"));

  1066     TMMFDevSoundProxySettingsPckg devSoundBuf;

  1067 	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));

  1068 	iCachedClientData = devSoundBuf;

  1069 	TInt frequencyOne = devSoundBuf().iFrequencyOne;

  1070 	TInt frequencyTwo = devSoundBuf().iFrequencyTwo;

  1071 	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);

  1072 	iAdapter->PlayDualToneL(frequencyOne, frequencyTwo, duration);

  1073 	iOperationCompletePending = ETrue;

  1074 	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayDualToneL - Exit. Return value is [%d]"), ETrue);

  1075 	return ETrue;

  1076 	}

  1077 

  1078 //

  1079 // CMMFDevSoundSession::DoAlreadyCompletedPlayDualToneL

  1080 // (other items were commented in a header).

  1081 //

  1082 void CMMFDevSoundSession::DoAlreadyCompletedPlayDualToneL()

  1083 	{

  1084 	TInt frequencyOne = iCachedClientData().iFrequencyOne;

  1085 	TInt frequencyTwo = iCachedClientData().iFrequencyTwo;

  1086 	TTimeIntervalMicroSeconds duration(iCachedClientData().iDuration);

  1087 	iAdapter->PlayDualToneL(frequencyOne, frequencyTwo, duration);

  1088 	iOperationCompletePending = ETrue;

  1089 	}

  1090 

  1091 //

  1092 // CMMFDevSoundSession::DoPlayDTMFStringL

  1093 // (other items were commented in a header).

  1094 //

  1095 TBool CMMFDevSoundSession::DoPlayDTMFStringL(const RMmfIpcMessage& aMessage)

  1096 	{

  1097     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDTMFStringL - Enter"));

  1098     TInt dtmfLength = aMessage.GetDesLength(2);

  1099 	

  1100 	if(iDtmfString)

  1101 		{

  1102 		delete iDtmfString;

  1103 		iDtmfString = NULL;

  1104 		}

  1105 

  1106 	iDtmfString = HBufC::NewL(dtmfLength);

  1107 	TPtr dtmfPtr = iDtmfString->Des();

  1108     User::LeaveIfError(MessageRead(aMessage, TInt(2), dtmfPtr));

  1109 	iAdapter->PlayDTMFStringL(*iDtmfString);

  1110 	iOperationCompletePending = ETrue;

  1111 	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayDTMFStringL - Exit. Return value is [%d]"), ETrue);

  1112 	return ETrue;

  1113 	}

  1114 

  1115 //

  1116 // CMMFDevSoundSession::DoAlreadyCompletedPlayDTMFStringL

  1117 // (other items were commented in a header).

  1118 //

  1119 void CMMFDevSoundSession::DoAlreadyCompletedPlayDTMFStringL()

  1120 	{

  1121 	iAdapter->PlayDTMFStringL(*iDtmfString);

  1122 	iOperationCompletePending = ETrue;

  1123 	}

  1124 

  1125 //

  1126 // CMMFDevSoundSession::DoPlayToneSequenceL

  1127 // (other items were commented in a header).

  1128 //

  1129 TBool CMMFDevSoundSession::DoPlayToneSequenceL(const RMmfIpcMessage& aMessage)

  1130 	{

  1131     SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayToneSequenceL - Enter"));

  1132     TInt toneLength = aMessage.GetDesLength(1);

  1133 

  1134 	if(iToneSeqBuf)