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 #else

    30 #define SYMBIAN_DEBPRN0(str)

    31 #define SYMBIAN_DEBPRN1(str, val1)

    32 #define SYMBIAN_DEBPRN2(str, val1, val2)

    33 #endif //_DEBUG

    34 

    35 //Assume that we can have two user request and one callback request

    36 //at the same time (maximum).

    37 const TInt KMaxQueueRequest = 3;

    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 // CMMFDevSoundSession::ServiceL

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

   227 //

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

   229 	{

   230 	SYMBIAN_DEBPRN2(_L("\nCMMFDevSoundSession[0x%x] NEW REQUEST %02x while pending=%d"), aMessage.Function(), iOperationCompletePending);

   231 	if( iOperationCompletePending || iAsyncQueueStart->IsActive())

   232 		{

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

   234 		EnqueueRequest(aMessage);

   235 		}

   236 	else

   237 		{

   238 		// If there is no oustanding operation service inmediately

   239 		DoServiceRequestL(aMessage);

   240 		}

   241 	}

   242 	

   243 //

   244 // CMMFDevSoundSession::DoServiceL

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

   246 //

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

   248 	{

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

   250 	TMMFMessageDestinationPckg destinationPckg;

   251 	MmfMessageUtil::ReadL(aMessage, 0, destinationPckg);

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

   253 	    (destinationPckg().InterfaceId() == KUidInterfaceMMFDevSound))

   254 		{

   255 		TBool complete = EFalse;

   256 		switch(aMessage.Function())

   257 			{

   258 			case EMMFDevSoundProxyPostOpen:

   259 				complete = DoPostOpenL(aMessage);

   260 				break;

   261 			case EMMFDevSoundProxyInitialize1:

   262 				complete = DoInitialize1L(aMessage);

   263 				break;

   264 			case EMMFDevSoundProxyInitialize2:

   265 				complete = DoInitialize2L(aMessage);

   266 				break;

   267 			case EMMFDevSoundProxyInitialize4:

   268 				complete = DoInitialize4L(aMessage);

   269 				break;

   270 			case EMMFDevSoundProxyCapabilities:

   271 				complete = DoCapabilitiesL(aMessage);

   272 				break;

   273 			case EMMFDevSoundProxyConfig:

   274 				complete = DoConfigL(aMessage);

   275 				break;

   276 			case EMMFDevSoundProxySetConfig:

   277 				complete = DoSetConfigL(aMessage);

   278 				break;

   279 			case EMMFDevSoundProxyMaxVolume:

   280 				complete = DoMaxVolumeL(aMessage);

   281 				break;

   282 			case EMMFDevSoundProxyVolume:

   283 				complete = DoVolumeL(aMessage);

   284 				break;

   285 			case EMMFDevSoundProxySetVolume:

   286 				complete = DoSetVolumeL(aMessage);

   287 				break;

   288 			case EMMFDevSoundProxyMaxGain:

   289 				complete = DoMaxGainL(aMessage);

   290 				break;

   291 			case EMMFDevSoundProxyGain:

   292 				complete = DoGainL(aMessage);

   293 				break;

   294 			case EMMFDevSoundProxySetGain:

   295 				complete = DoSetGainL(aMessage);

   296 				break;

   297 			case EMMFDevSoundProxyPlayBalance:

   298 				complete = DoGetPlayBalanceL(aMessage);

   299 				break;

   300 			case EMMFDevSoundProxySetPlayBalance:

   301 				complete = DoSetPlayBalanceL(aMessage);

   302 				break;

   303 			case EMMFDevSoundProxyRecordBalance:

   304 				complete = DoGetRecordBalanceL(aMessage);

   305 				break;

   306 			case EMMFDevSoundProxySetRecordBalance:

   307 				complete = DoSetRecordBalanceL(aMessage);

   308 				break;

   309 			case EMMFDevSoundProxyBTBFData:

   310 				complete = DoBufferToBeFilledDataL(aMessage);

   311 				break;

   312 			case EMMFDevSoundProxyBTBEData:

   313 				complete = DoBufferToBeEmptiedDataL(aMessage);

   314 				break;

   315 			case EMMFDevSoundProxyPlayInit:

   316 				complete = DoPlayInitL(aMessage);

   317 				break;

   318 			case EMMFDevSoundProxyRecordInit:

   319 				complete = DoRecordInitL(aMessage);

   320 				break;

   321 			case EMMFDevSoundProxyPlayData:

   322 				complete = DoPlayDataL(aMessage);

   323 				break;

   324 			case EMMFDevSoundProxyRecordData:

   325 				complete = DoRecordDataL(aMessage);

   326 				break;

   327 			case EMMFDevSoundProxyStop:

   328 				complete = DoStopL(aMessage);

   329 				break;

   330 			case EMMFDevSoundProxyPause:

   331 				complete = DoPauseL(aMessage);

   332 				break;

   333 			case EMMFDevSoundProxyPlayTone:

   334 				complete = DoPlayToneL(aMessage);

   335 				break;

   336 			case EMMFDevSoundProxyPlayDualTone:

   337 				complete = DoPlayDualToneL(aMessage);

   338 				break;

   339 			case EMMFDevSoundProxyPlayDTMFString:

   340 				complete = DoPlayDTMFStringL(aMessage);

   341 				break;

   342 			case EMMFDevSoundProxyPlayToneSequence:

   343 				complete = DoPlayToneSequenceL(aMessage);

   344 				break;

   345 			case EMMFDevSoundProxyPlayFixedSequence:

   346 				complete = DoPlayFixedSequenceL(aMessage);

   347 				break;

   348 			case EMMFDevSoundProxySetDTMFLengths:

   349 				complete = DoSetDTMFLengthsL(aMessage);

   350 				break;

   351 			case EMMFDevSoundProxySetVolumeRamp:

   352 				complete = DoSetVolumeRampL(aMessage);

   353 				break;

   354 			case EMMFDevSoundProxyGetSupportedInputDataTypes:

   355 				complete = DoGetSupportedInputDataTypesL(aMessage);

   356 				break;

   357 			case EMMFDevSoundProxyGetSupportedOutputDataTypes:

   358 				complete = DoGetSupportedOutputDataTypesL(aMessage);

   359 				break;

   360 			case EMMFDevSoundProxyCopyFourCCArrayData:

   361 				complete = DoCopyFourCCArrayDataL(aMessage);

   362 				break;

   363 			case EMMFDevSoundProxySamplesRecorded:

   364 				complete = DoSamplesRecordedL(aMessage);

   365 				break;

   366 			case EMMFDevSoundProxySamplesPlayed:

   367 				complete = DoSamplesPlayedL(aMessage);

   368 				break;

   369 			case EMMFDevSoundProxySetToneRepeats:

   370 				complete = DoSetToneRepeatsL(aMessage);

   371 				break;

   372 			case EMMFDevSoundProxySetPrioritySettings:

   373 				complete = DoSetPrioritySettingsL(aMessage);

   374 				break;

   375 			case EMMFDevSoundProxyFixedSequenceCount:

   376 				complete = DoFixedSequenceCountL(aMessage);

   377 				break;

   378 			case EMMFDevSoundProxyCancelInitialize:

   379 				complete = DoCancelInitializeL(aMessage);

   380 				break;

   381 			case EMMFDevSoundProxyEmptyBuffers:

   382 				complete = DoEmptyBuffersL(aMessage);

   383 				break;

   384 			case EMMFDevSoundProxyGetTimePlayed:

   385 				complete = DoGetTimePlayedL(aMessage);

   386 				break;

   387 			case EMMFDevSoundProxyIsResumeSupported:

   388 				complete = DoQueryResumeSupportedL(aMessage);

   389 				break;

   390 			case EMMFDevSoundProxyResume:

   391 				complete = DoResumeL(aMessage);

   392 				break;

   393 

   394 			// DevSound custom command support

   395 			case EMMFDevSoundProxySyncCustomCommand:

   396 			case EMMFDevSoundProxySyncCustomCommandResult:

   397 			case EMMFDevSoundProxyAsyncCustomCommand:

   398 			case EMMFDevSoundProxyAsyncCustomCommandResult:

   399 				complete = DoCustomCommandL(aMessage);

   400 				break;

   401 			case EMMFDevSoundProxyClose:

   402 				complete = DoPrepareCloseL(aMessage);

   403 				break;

   404 			case EMMFDevSoundProxyRequestResourceNotification:

   405 				complete = DoRegisterAsClientL(aMessage);

   406 				break;

   407 			case EMMFDevSoundProxyCancelRequestResourceNotification:

   408 				complete = DoCancelRegisterAsClientL(aMessage);

   409 				break;

   410 			case EMMFDevSoundProxyGetResourceNotificationData:

   411 				complete = DoGetResourceNotificationDataL(aMessage);

   412 				break;

   413 			case EMMFDevSoundProxyWillResumePlay:

   414 				complete = DoWillResumePlayL(aMessage);

   415 				break;

   416 			case EMMFDevSoundProxySetClientThreadInfo:

   417 				complete = DoSetClientThreadInfoL(aMessage);

   418 				break;						

   419 			default:

   420 				User::Leave(KErrNotSupported);

   421 				break;

   422 			}

   423 

   424 		// Check if can complete the message now

   425 		if (complete)

   426 			{

   427 			// Complete the message

   428 			// Synchronous requests & Pseudo-asynchronous

   429 			aMessage.Complete(KErrNone);

   430 			}

   431 		// Note: There are operations that not complete the message using the following flag

   432 		// So if the message is not completed, cannot be assumed that there is an operation pending

   433 		

   434 		if(iOperationCompletePending)

   435 			{

   436 			// Keep a copy of the message for Asynchronous requests & Pseudo-asynchronous

   437 			iRequestBeingServiced.SetMessage(aMessage);

   438 			}

   439 		}

   440 	else

   441 		{

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

   443 		TInt err = KErrNotSupported;

   444 		if (iCIExtension)

   445 			{

   446 			iOperationCompletePending = ETrue;

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

   448 			if (err2)

   449 				{

   450 				err = err2;

   451 				}

   452 			iOperationCompletePending = EFalse;

   453 			}

   454 

   455 		if (err != KErrNone)

   456 			{

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

   458 			aMessage.Complete(KErrNotSupported);

   459 			}

   460 		}

   461 	}

   462 

   463 

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

   465 	{

   466 	// Encapsule the request

   467 	TMMFDevSoundRequest request;

   468 	request.SetMessage(aMessage);

   469 	// Append

   470 	TInt error = iQueuedRequests.Append(request);

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

   472 	}

   473 

   474 //

   475 // CMMFDevSoundSession::DoPostOpenL

   476 //

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

   478 	{

   479 	iAdapter->PostOpenL();

   480 	iOperationCompletePending = ETrue;

   481 	return EFalse;

   482 	}

   483 

   484 //

   485 // CMMFDevSoundSession::DoInitialize1L

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

   487 //

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

   489 	{

   490 	TInt err = iMsgQueue.Open(aMessage, 2); // a global queue.

   491 	User::LeaveIfError(err);

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

   493 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   494 	MmfMessageUtil::ReadL(aMessage,1,devSoundBuf);

   495 	TMMFState mode = devSoundBuf().iMode;

   496 	iAdapter->InitializeL(mode);

   497 	iBufferPlay = NULL;

   498 	iPlayErrorOccured = EFalse;

   499 	// Flag to queue any further request 

   500 	// but the message can be completed now

   501 	iOperationCompletePending = ETrue;

   502 	return ETrue;

   503 	}

   504 

   505 //

   506 // CMMFDevSoundSession::DoInitialize2L

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

   508 //

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

   510 	{

   511 	TInt err = iMsgQueue.Open(aMessage, 2); // a global queue.

   512 	User::LeaveIfError(err);

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

   514 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   515 	MmfMessageUtil::ReadL(aMessage,1,devSoundBuf);

   516 	TUid HWDev = devSoundBuf().iHWDev;

   517 	TMMFState mode = devSoundBuf().iMode;

   518 	iAdapter->InitializeL(HWDev, mode);

   519 	iBufferPlay = NULL;

   520 	iPlayErrorOccured = EFalse;

   521 	return ETrue;

   522 	}

   523 

   524 //

   525 // CMMFDevSoundSession::DoInitialize4L

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

   527 //

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

   529 	{

   530 	TInt err = iMsgQueue.Open(aMessage, 2); // a global queue.

   531 	User::LeaveIfError(err);

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

   533 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   534 	aMessage.ReadL(TInt(1),devSoundBuf);

   535 	TFourCC desiredFourCC = devSoundBuf().iDesiredFourCC;

   536 	TMMFState mode = devSoundBuf().iMode;

   537 	iAdapter->InitializeL(desiredFourCC, mode);

   538 	iBufferPlay = NULL;

   539 	iPlayErrorOccured = EFalse;

   540 	// Flag to queue any further request 

   541 	// but the message can be completed now

   542 	iOperationCompletePending = ETrue;

   543 	return ETrue;

   544 	}

   545 

   546 //

   547 // CMMFDevSoundSession::DoCancelInitialize

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

   549 //

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

   551 	{

   552 	TInt err=iAdapter->CancelInitialize();

   553 

   554 	if (err != KErrNone)

   555 		{

   556 		aMessage.Complete(err);

   557 		iOperationCompletePending = EFalse;

   558 		return ETrue;

   559 		}

   560 	else

   561 		{

   562 		iOperationCompletePending = ETrue;

   563 		}

   564 	return EFalse;

   565 	}

   566 

   567 //

   568 // CMMFDevSoundSession::DoCapabilitiesL

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

   570 //

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

   572 	{

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

   574 	if(err != KErrNone)

   575 		{

   576 		aMessage.Complete(err);

   577 		iOperationCompletePending = EFalse;

   578 		}

   579 	else

   580 		{

   581 		iOperationCompletePending = ETrue;

   582 		}

   583 	return EFalse;

   584 	}

   585 

   586 //

   587 // CMMFDevSoundSession::DoConfigL

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

   589 //

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

   591 	{

   592 	TMMFDevSoundProxySettings devSoundSet;

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

   594 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   595 	aMessage.WriteL(TInt(2),pckg);

   596 	return ETrue;

   597 	}

   598 

   599 //

   600 // CMMFDevSoundSession::DoSetConfigL

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

   602 //

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

   604 	{

   605 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   606 	aMessage.ReadL(TInt(1),devSoundBuf);

   607 	TMMFCapabilities config = devSoundBuf().iConfig;

   608 	iAdapter->SetConfigL(config);

   609 	iOperationCompletePending = ETrue;

   610 	return EFalse;

   611 	}

   612 

   613 //

   614 // CMMFDevSoundSession::axVolumeL

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

   616 //

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

   618 	{

   619 	TMMFDevSoundProxySettings devSoundSet;

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

   621 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   622 	aMessage.WriteL(TInt(2),pckg);

   623 	return ETrue;

   624 	}

   625 

   626 //

   627 // CMMFDevSoundSession::DoVolumeL

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

   629 //

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

   631 	{

   632 	TMMFDevSoundProxySettings devSoundSet;

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

   634 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   635 	aMessage.WriteL(TInt(2),pckg);

   636 	return ETrue;

   637 	}

   638 

   639 //

   640 // CMMFDevSoundSession::DoSetVolumeL

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

   642 //

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

   644 	{

   645 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   646 	aMessage.ReadL(TInt(1),devSoundBuf);

   647 	TInt volume = devSoundBuf().iVolume;

   648 	TBool asyncOperation;

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

   650 	iOperationCompletePending = asyncOperation;

   651 	return !asyncOperation;

   652 	}

   653 

   654 //

   655 // CMMFDevSoundSession::DoMaxGainL

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

   657 //

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

   659 	{

   660 	TMMFDevSoundProxySettings devSoundSet;

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

   662 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   663 	aMessage.WriteL(TInt(2),pckg);

   664 	return ETrue;

   665 	}

   666 

   667 //

   668 // CMMFDevSoundSession::DoGainL

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

   670 //

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

   672 	{

   673 	TMMFDevSoundProxySettings devSoundSet;

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

   675 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   676 	aMessage.WriteL(TInt(2),pckg);

   677 	return ETrue;

   678 	}

   679 

   680 //

   681 // CMMFDevSoundSession::DoSetGainL

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

   683 //

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

   685 	{

   686 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   687 	aMessage.ReadL(TInt(1),devSoundBuf);

   688 	TInt gain = devSoundBuf().iGain;

   689 	TBool asyncOperation;

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

   691 	iOperationCompletePending = asyncOperation;

   692 	return !asyncOperation;

   693 	}

   694 

   695 //

   696 // CMMFDevSoundSession::DoGetPlayBalanceL

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

   698 //

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

   700 	{

   701 	TMMFDevSoundProxySettings devSoundSet;

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

   703 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   704 	aMessage.WriteL(TInt(2),pckg);

   705 	return ETrue;

   706 	}

   707 

   708 //

   709 // CMMFDevSoundSession::DoSetPlayBalanceL

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

   711 //

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

   713 	{

   714 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   715 	aMessage.ReadL(TInt(1),devSoundBuf);

   716 	TInt leftPercentage = devSoundBuf().iLeftPercentage;

   717 	TInt rightPercentage = devSoundBuf().iRightPercentage;

   718 	TBool asyncOperation;

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

   720 	iOperationCompletePending = asyncOperation;

   721 	return !asyncOperation;

   722 	}

   723 

   724 //

   725 // CMMFDevSoundSession::DoGetRecordBalanceL

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

   727 //

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

   729 	{

   730 	TMMFDevSoundProxySettings devSoundSet;

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

   732 	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);

   733 	aMessage.WriteL(TInt(2),pckg);

   734 	return ETrue;

   735 	}

   736 

   737 //

   738 // CMMFDevSoundSession::DoSetRecordBalanceL

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

   740 //

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

   742 	{

   743 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   744 	aMessage.ReadL(TInt(1),devSoundBuf);

   745 	TInt leftPercentage = devSoundBuf().iLeftPercentage;

   746 	TInt rightPercentage = devSoundBuf().iRightPercentage;

   747 	TBool asyncOperation;

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

   749 	iOperationCompletePending = asyncOperation;

   750 	return !asyncOperation;

   751 	}

   752 

   753 //

   754 // CMMFDevSoundSession::DoPlayInitL

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

   756 //

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

   758 	{

   759 	iAdapter->PlayInitL();

   760 	iOperationCompletePending = ETrue;

   761 	return ETrue;

   762 	}

   763 

   764 //

   765 // CMMFDevSoundSession::DoRecordInitL

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

   767 //

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

   769 	{

   770 	iAdapter->RecordInitL();

   771 	iOperationCompletePending = ETrue;

   772 	return ETrue;

   773 	}

   774 

   775 //

   776 // CMMFDevSoundSession::DoPlayDataL

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

   778 //

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

   780 	{

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

   782 

   783 	if( iPlayErrorOccured )

   784 		{

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

   786 		return ETrue;

   787 		}

   788 

   789 	TMMFDevSoundProxyHwBufPckg devSoundBuf;

   790 	aMessage.ReadL(TInt(1),devSoundBuf);

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

   792 

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

   794 	// Copy data over from chunk

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

   796 	iAdapter->PlayData();

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

   798 	return ETrue;

   799 	}

   800 

   801 //

   802 // CMMFDevSoundSession::DoRecordDataL

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

   804 //

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

   806 	{

   807 	iAdapter->RecordData();

   808 	return ETrue;

   809 	}

   810 

   811 //

   812 // CMMFDevSoundSession::DoStopL

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

   814 //

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

   816 	{

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

   818 	TBool completed = iAdapter->Stop();

   819 	if (completed)

   820 		{

   821 		iQueuedRequests.Reset();

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

   823 		iChunk.Close();

   824 		}

   825 	iOperationCompletePending = !completed;

   826 	return completed;

   827 	}

   828 

   829 //

   830 // CMMFDevSoundSession::DoPauseL

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

   832 //

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

   834 	{

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

   836 	iOperationCompletePending = ETrue;

   837 	return EFalse;

   838 	}

   839 

   840 //

   841 // CMMFDevSoundSession::DoPlayToneL

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

   843 //

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

   845 	{

   846 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   847 	aMessage.ReadL(TInt(1),devSoundBuf);

   848 	TInt frequency = devSoundBuf().iFrequencyOne;

   849 	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);

   850 	iAdapter->PlayToneL(frequency, duration);

   851 	iOperationCompletePending = ETrue;

   852 	return ETrue;

   853 	}

   854 

   855 //

   856 // CMMFDevSoundSession::DoPlayDualToneL

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

   858 //

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

   860 	{

   861 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   862 	aMessage.ReadL(TInt(1),devSoundBuf);

   863 	TInt frequencyOne = devSoundBuf().iFrequencyOne;

   864 	TInt frequencyTwo = devSoundBuf().iFrequencyTwo;

   865 	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);

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

   867 	iOperationCompletePending = ETrue;

   868 	return ETrue;

   869 	}

   870 

   871 //

   872 // CMMFDevSoundSession::DoPlayDTMFStringL

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

   874 //

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

   876 	{

   877 	TInt dtmfLength = aMessage.GetDesLength(2);

   878 	

   879 	if(iDtmfString)

   880 		{

   881 		delete iDtmfString;

   882 		iDtmfString = NULL;

   883 		}

   884 

   885 	iDtmfString = HBufC::NewL(dtmfLength);

   886 	TPtr dtmfPtr = iDtmfString->Des();

   887 	aMessage.ReadL(TInt(2), dtmfPtr);

   888 

   889 	iAdapter->PlayDTMFStringL(*iDtmfString);

   890 	iOperationCompletePending = ETrue;

   891 	return ETrue;

   892 	}

   893 

   894 //

   895 // CMMFDevSoundSession::DoPlayToneSequenceL

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

   897 //

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

   899 	{

   900 	TInt toneLength = aMessage.GetDesLength(1);

   901 

   902 	if(iToneSeqBuf)

   903 		{

   904 		delete iToneSeqBuf;

   905 		iToneSeqBuf = NULL;

   906 		}

   907 

   908 	iToneSeqBuf = HBufC8::NewL(toneLength);

   909 	TPtr8 toneSeqPtr = iToneSeqBuf->Des();

   910 	aMessage.ReadL(TInt(1), toneSeqPtr);

   911 

   912 	iAdapter->PlayToneSequenceL(*iToneSeqBuf);

   913 	iOperationCompletePending = ETrue;

   914 	return ETrue;

   915 	}

   916 

   917 //

   918 // CMMFDevSoundSession::DoPlayFixedSequenceL

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

   920 //

   921 TBool CMMFDevSoundSession::DoPlayFixedSequenceL(const RMmfIpcMessage& aMessage)

   922 	{

   923 	TPckgBuf<TInt> buf;

   924 	aMessage.ReadL(TInt(1),buf);

   925 	TInt seqNum = buf();

   926 

   927 	iAdapter->PlayFixedSequenceL(seqNum);

   928 	iOperationCompletePending = ETrue;

   929 	return ETrue;

   930 	}

   931 

   932 //

   933 // CMMFDevSoundSession::DoSetDTMFLengthsL

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

   935 //

   936 TBool CMMFDevSoundSession::DoSetDTMFLengthsL(const RMmfIpcMessage& aMessage)

   937 	{

   938 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   939 	aMessage.ReadL(TInt(1),devSoundBuf);

   940 	TTimeIntervalMicroSeconds32 toneOnLength = devSoundBuf().iToneOnLength;

   941 	TTimeIntervalMicroSeconds32 toneOffLength = devSoundBuf().iToneOffLength;

   942 	TTimeIntervalMicroSeconds32 pauseLength = devSoundBuf().iPauseLength;

   943 	User::LeaveIfError(iAdapter->SetDTMFLengths(toneOnLength, toneOffLength, pauseLength));

   944 	return ETrue;

   945 	}

   946 

   947 //

   948 // CMMFDevSoundSession::DoSetVolumeRampL

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

   950 //

   951 TBool CMMFDevSoundSession::DoSetVolumeRampL(const RMmfIpcMessage& aMessage)

   952 	{

   953 	TMMFDevSoundProxySettingsPckg devSoundBuf;

   954 	aMessage.ReadL(TInt(1),devSoundBuf);

   955 	TTimeIntervalMicroSeconds duration = devSoundBuf().iDuration;

   956 	User::LeaveIfError(iAdapter->SetVolumeRamp(duration));

   957 	iOperationCompletePending = EFalse; // Volume ramp doesn't result on commit

   958 	return ETrue; // operation complete

   959 	}

   960 

   961 //

   962 // CMMFDevSoundSession::DoGetSupportedInputDataTypesL

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

   964 //

   965 TBool CMMFDevSoundSession::DoGetSupportedInputDataTypesL(

   966 							const RMmfIpcMessage& aMessage)

   967 	{

   968 	iArray.Reset();

   969 

   970 	TMMFPrioritySettingsPckg prioritySetBuf;

   971 	aMessage.ReadL(TInt(1),prioritySetBuf);

   972 	TMMFPrioritySettings prioritySet = prioritySetBuf();

   973 

   974 	iAdapter->GetSupportedInputDataTypesL(iArray, prioritySet);

   975 

   976 	TPckgBuf<TInt> pckg;

   977 	pckg() = iArray.Count();

   978 	aMessage.WriteL(TInt(2),pckg);

   979 

   980 	return ETrue;

   981 	}

   982 

   983 //

   984 // CMMFDevSoundSession::DoGetSupportedOutputDataTypesL

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

   986 //

   987 TBool CMMFDevSoundSession::DoGetSupportedOutputDataTypesL(

   988 							const RMmfIpcMessage& aMessage)

   989 	{

   990 	iArray.Reset();

   991 

   992 	TMMFPrioritySettingsPckg prioritySetBuf;

   993 	aMessage.ReadL(TInt(1),prioritySetBuf);

   994 	TMMFPrioritySettings prioritySet = prioritySetBuf();

   995 

   996 	iAdapter->GetSupportedOutputDataTypesL(iArray, prioritySet);

   997 

   998 	TPckgBuf<TInt> pckg;

   999 	pckg() = iArray.Count();

  1000 	aMessage.WriteL(TInt(2),pckg);

  1001 

  1002 	return ETrue;

  1003 	}

  1004 

  1005 //

  1006 // CMMFDevSoundSession::DoSamplesRecordedL

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

  1008 //

  1009 TBool CMMFDevSoundSession::DoSamplesRecordedL(const RMmfIpcMessage& aMessage)

  1010 	{

  1011 	TPckgBuf<TInt> pckg;

  1012 	pckg() = iAdapter->SamplesRecorded();

  1013 	aMessage.WriteL(TInt(2),pckg);

  1014 	return ETrue;

  1015 	}

  1016 

  1017 //

  1018 // CMMFDevSoundSession::DoSamplesPlayedL

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

  1020 //

  1021 TBool CMMFDevSoundSession::DoSamplesPlayedL(const RMmfIpcMessage& aMessage)

  1022 	{

  1023 	TPckgBuf<TInt> pckg;

  1024 	pckg() = iAdapter->SamplesPlayed();

  1025 	aMessage.WriteL(TInt(2),pckg);

  1026 	return ETrue;

  1027 	}

  1028 

  1029 //

  1030 // CMMFDevSoundSession::DoSetToneRepeatsL

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

  1032 //

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

  1034 	{

  1035 	TPckgBuf<TInt> countRepeat;

  1036 	aMessage.ReadL(TInt(1),countRepeat);

  1037 

  1038 	TPckgBuf<TTimeIntervalMicroSeconds> repeatTS;

  1039 	aMessage.ReadL(TInt(2),repeatTS);

  1040 	User::LeaveIfError(iAdapter->SetToneRepeats(countRepeat(), repeatTS()));

  1041 	

  1042 	return ETrue;

  1043 	}

  1044 

  1045 //

  1046 // CMMFDevSoundSession::DoSetPrioritySettingsL

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

  1048 //

  1049 TBool CMMFDevSoundSession::DoSetPrioritySettingsL(

  1050 						const RMmfIpcMessage& aMessage)

  1051 	{

  1052 	TPckgBuf<TMMFPrioritySettings> prioritySet;

  1053 	aMessage.ReadL(TInt(1),prioritySet);

  1054 

  1055 	User::LeaveIfError(iAdapter->SetPrioritySettings(prioritySet()));

  1056 	iOperationCompletePending = EFalse;

  1057 	return ETrue;

  1058 	}

  1059 

  1060 //

  1061 // CMMFDevSoundSession::DoFixedSequenceCountL

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

  1063 //

  1064 TBool CMMFDevSoundSession::DoFixedSequenceCountL(

  1065 					const RMmfIpcMessage& aMessage)

  1066 	{

  1067 	TPckgBuf<TInt> fixSeqCountPckg;

  1068 	TInt fixSeqCount = iAdapter->FixedSequenceCount();

  1069 	fixSeqCountPckg = fixSeqCount;

  1070 

  1071 	aMessage.WriteL(TInt(2),fixSeqCountPckg);

  1072 	return ETrue;

  1073 	}

  1074 

  1075 

  1076 //

  1077 // CMMFDevSoundSession::DoCopyFourCCArrayDataL

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

  1079 //

  1080 TBool CMMFDevSoundSession::DoCopyFourCCArrayDataL(

  1081 						const RMmfIpcMessage& aMessage)

  1082 	{

  1083 	const TInt KBufExpandSize8 = 8;//two TInts

  1084 	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KBufExpandSize8);

  1085 	CleanupStack::PushL(dataCopyBuffer);

  1086 	RBufWriteStream stream;

  1087 	stream.Open(*dataCopyBuffer);

  1088 	CleanupClosePushL(stream);

  1089 	

  1090 	TInt i = 0;

  1091 	TInt count = iArray.Count();

  1092 	

  1093 	while (i < count)

  1094 		{

  1095 		stream.WriteInt32L(iArray[i].FourCC());

  1096 		i++;

  1097 		}

  1098 	aMessage.WriteL(TInt(2), dataCopyBuffer->Ptr(0));

  1099 	stream.Close();

  1100 	CleanupStack::PopAndDestroy(&stream);

  1101 	CleanupStack::PopAndDestroy(dataCopyBuffer);

  1102 	return ETrue;

  1103 	}

  1104 

  1105 

  1106 //

  1107 // CMMFDevSoundSession::DoBufferToBeFilledDataL

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

  1109 //

  1110 TBool CMMFDevSoundSession::DoBufferToBeFilledDataL(

  1111 							const RMmfIpcMessage& aMessage)

  1112 	{

  1113 	// if CMMFDevSoundSession::PlayError() has been called, RChunk would have got closed.

  1114 	// Need to check if Chunk Handle is still valid. If it is not,complete the message immediately and send a error to the Client.

  1115 	if(!iChunk.Handle())

  1116 		{

  1117 		aMessage.Complete(KErrBadHandle);

  1118 		return EFalse;	

  1119 		}

  1120 	TPckgBuf<TInt> requestChunkBuf;

  1121 	MmfMessageUtil::Read(aMessage, TInt(1), requestChunkBuf);

  1122 	TBool requestChunk = requestChunkBuf();

  1123 	if (requestChunk)

  1124 		{

  1125 		// if the client requests, always do EOpen

  1126 		iHwBufPckgFill().iChunkOp = EOpen;

  1127 		}

  1128 	TInt err = MmfMessageUtil::Write(aMessage, TInt(2), iHwBufPckgFill);

  1129 	if ( (err == KErrNone) && (iHwBufPckgFill().iChunkOp == EOpen) )

  1130 		{

  1131 		aMessage.Complete(iChunk);

  1132 		}

  1133 	else

  1134 		{