// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include <s32mem.h>
#include "mmfaudioclientserver.h"
#include "mmfaudioserver.h"
#include "mmfdevsoundserver.h"
#include "mmfdevsoundsession.h"
#include <mmf/plugin/mmfdevsoundcustominterface.hrh>
#include <mm/mmpluginutils.h>
#ifdef _DEBUG
#include "e32debug.h"

#define SYMBIAN_DEBPRN0(str)                RDebug::Print(str, this)
#define SYMBIAN_DEBPRN1(str, val1)          RDebug::Print(str, this, val1)
#define SYMBIAN_DEBPRN2(str, val1, val2)    RDebug::Print(str, this, val1, val2)
#define SYMBIAN_DEBPRN3(str, val1, val2, val3)    RDebug::Print(str, this, val1, val2, val3)
#else
#define SYMBIAN_DEBPRN0(str)
#define SYMBIAN_DEBPRN1(str, val1)
#define SYMBIAN_DEBPRN2(str, val1, val2)
#define SYMBIAN_DEBPRN3(str, val1, val2, val3)
#endif //_DEBUG

const TInt KMaxQueueRequest = 6;

//	MEMBER FUNCTIONS 

TMMFDevSoundRequest::TMMFDevSoundRequest() 
	: iMessageCompleted(EFalse), 
	iRequestType(EUndefinedType),
	iCallBackPF(KCallbackNone)
	{
	}

TMMFDevSoundRequest::TMMFDevSoundRequest(TInt aIsCallBack)
	: iMessageCompleted(EFalse), 
	iRequestType(ECallBackType),
	iCallBackPF(aIsCallBack)
	{
	}

TMMFDevSoundRequest::TMMFDevSoundRequest(const TMMFDevSoundRequest& aRequest)
	: iMessageCompleted(EFalse), 
	iMessage(aRequest.iMessage),
	iCallBackPF(aRequest.iCallBackPF)
	{
	iRequestType = ResolveType();
	}

TBool TMMFDevSoundRequest::operator==(const TMMFDevSoundRequest& aRequest) const
	{
	TBool retval = EFalse;
	if ( aRequest.Function() == Function() )
		{
		retval = ETrue;
		}
	else
		{
		retval = EFalse;
		}
	return retval;
	}

const RMmfIpcMessage& TMMFDevSoundRequest::Message() 
	{ 
	return iMessage; 
	}

void TMMFDevSoundRequest::SetMessage(const RMmfIpcMessage& aMessage) 
	{
	iMessageCompleted = EFalse;
	iMessage = aMessage;
	iRequestType = ResolveType();
	}
	
void TMMFDevSoundRequest::SetMessageCallback() 
	{
	iMessageCompleted = EFalse;
	iRequestType = ECallBackType;
	}	

TInt TMMFDevSoundRequest::IsCallBack() const
	{
	return iCallBackPF;	
	}

TMMFDevSoundRequest::TA3FDevSoundRequestType TMMFDevSoundRequest::ResolveType()
	{
	TA3FDevSoundRequestType type = EUndefinedType;
	switch(iMessage.Function())
		{
		case EMMFDevSoundProxyInitialize1:
		case EMMFDevSoundProxyInitialize2:
		case EMMFDevSoundProxyInitialize4:
		case EMMFDevSoundProxyPlayInit:
		case EMMFDevSoundProxyRecordInit:
		case EMMFDevSoundProxyPlayTone:
		case EMMFDevSoundProxyPlayDualTone:
		case EMMFDevSoundProxyPlayDTMFString:
		case EMMFDevSoundProxyPlayToneSequence:
		case EMMFDevSoundProxyPlayFixedSequence:
			type = EAction_PseudoAsynchronous;
			break;

		case EMMFDevSoundProxyStop:
		case EMMFDevSoundProxyPause:
		case EMMFDevSoundProxyClose:
		case EMMFDevSoundProxyCancelInitialize:
		case EMMFDevSoundProxyResume:
		case EMMFDevSoundProxyEmptyBuffers:
			type = EAction_Asynchronous;
			break;

		case EMMFDevSoundProxySetConfig:
		case EMMFDevSoundProxyPostOpen: // Although this is not a configure operation technically, it has same calling pattern.
		case EMMFDevSoundProxySetVolume:
		case EMMFDevSoundProxySetGain:
		case EMMFDevSoundProxySetPlayBalance:
		case EMMFDevSoundProxySetRecordBalance:
		case EMMFDevSoundProxySetVolumeRamp:
		case EMMFDevSoundProxySetPrioritySettings:
			type = EConfigure_Asynchronous;
			break;
			
		case EMMFDevSoundProxySetDTMFLengths:
		case EMMFDevSoundProxySetToneRepeats:
			type = EConfigure_Synchronous;	
			break;
		case EMMFDevSoundProxyCapabilities:
			type = EQuery_Asynchronous;
			break;
		case EMMFDevSoundProxyMaxVolume:
		case EMMFDevSoundProxyMaxGain:
		case EMMFDevSoundProxyConfig:
		case EMMFDevSoundProxyVolume:
		case EMMFDevSoundProxyGain:
		case EMMFDevSoundProxyPlayBalance:
		case EMMFDevSoundProxyRecordBalance:
		case EMMFDevSoundProxyGetSupportedInputDataTypes:
		case EMMFDevSoundProxyGetSupportedOutputDataTypes:
		case EMMFDevSoundProxyFixedSequenceName:
		case EMMFDevSoundProxyFixedSequenceCount:
		case EMMFDevSoundProxySamplesRecorded:
		case EMMFDevSoundProxySamplesPlayed:
		case EMMFDevSoundProxyCopyFourCCArrayData:
		case EMMFDevSoundProxyGetTimePlayed:
		case EMMFDevSoundProxyIsResumeSupported:
			type = EQuery_Synchronous;
			break;
		
		case EMMFDevSoundProxyBTBFData:
		case EMMFDevSoundProxyBTBEData:
		case EMMFDevSoundProxyPlayData:
		case EMMFDevSoundProxyRecordData:
			type = EBufferExchangeRelated;
			break;

		// Custom Interfaces
		case EMMFDevSoundProxySyncCustomCommand:
		case EMMFDevSoundProxySyncCustomCommandResult:
		case EMMFDevSoundProxyAsyncCustomCommand:
		case EMMFDevSoundProxyAsyncCustomCommandResult:
		case EMMFDevSoundProxyCustomInterface:
			type = ECustomInterfacesRelated;
			break;
		case RMessage2::EDisConnect:
			type = ESessionEvents;
			break;
		default:
			break;
		}
	return type;
	}


void TMMFDevSoundRequest::Complete(TInt aError)	
	{
	if(!iMessageCompleted && iRequestType != EUndefinedType && iRequestType != ECallBackType)	
		{
		iMessage.Complete(aError);
		iMessageCompleted = ETrue;
		iRequestType = EUndefinedType;
		}
	}

TInt TMMFDevSoundRequest::Function() const 
	{
	return iMessage.Function(); 
	}

TMMFDevSoundRequest::TA3FDevSoundRequestType TMMFDevSoundRequest::Type() const
	{
	return iRequestType;
	}


// 
// CMMFDevSoundSession::CreateL
// Creates a new object
// 
void CMMFDevSoundSession::CreateL(const CMmfIpcServer& aServer)
	{
	CMmfIpcSession::CreateL(aServer);
	CMMFDevSoundServer& server =
	const_cast<CMMFDevSoundServer&>(
			static_cast<const CMMFDevSoundServer&>(aServer));
	server.IncrementSessionId();
	iDevSoundSessionId = server.DevSoundSessionId();
	}

//
// NeedToQueue - mid-commit cycle or async queue start AO is active
//
TBool CMMFDevSoundSession::NeedToQueue() const
    {
    return iOperationCompletePending || iAsyncQueueStart->IsActive();
    }

//
// CMMFDevSoundSession::ServiceL
// (other items were commented in a header).
//
void CMMFDevSoundSession::ServiceL(const RMmfIpcMessage& aMessage)
	{
	SYMBIAN_DEBPRN2(_L("\nCMMFDevSoundSession[0x%x] NEW REQUEST %02x while pending=%d"),
	        aMessage.Function(), NeedToQueue());
	
	if(NeedToQueue())
		{
		// if not possible to service now, then queue request
		EnqueueRequest(aMessage);
		}
	else
		{
		// If there is no oustanding operation service inmediately
		TRAPD(err, DoServiceRequestL(aMessage));
		if (err)
		    {
            aMessage.Complete(err); // repeat normal ServiceL() behaviour since we may keep going
		    }
	    if (!iOperationCompletePending && iQueuedRequests.Count() != 0)
	        {
	        //dequeue next
	        DequeueRequest();
	        }
		}
	}
	
//
// CMMFDevSoundSession::DoServiceL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoServiceRequestL(const RMmfIpcMessage& aMessage)
	{
	iRequestBeingServiced.SetMessage(aMessage);
	iAsyncQueueStart->Cancel(); // just in case.
    ResetNotifiedError();

    if (aMessage.Function() == RMessage2::EDisConnect)
        {
        TBool complete = iAdapter->CloseDevSound();
        if(!complete)
            {
            iRequestBeingServiced.SetMessage(aMessage);
            iOperationCompletePending = ETrue;
            ResetNotifiedError();
            }
        else
            {
            // if we get here, iClosing wait will have been started and we'd be waiting
            iClosingWait->AsyncStop();
            }
        return;
        }
    
    TMMFMessageDestinationPckg destinationPckg;
	User::LeaveIfError(MessageRead(aMessage, 0, destinationPckg));
	SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - DestinationHandle [%d] InterfaceId [%d] "), destinationPckg().DestinationHandle(), destinationPckg().InterfaceId());
	if ((destinationPckg().DestinationHandle() == KMMFObjectHandleDevSound) &&
	    (destinationPckg().InterfaceId() == KUidInterfaceMMFDevSound))
		{
        SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - Request [%d]"), aMessage.Function());
		TBool complete = EFalse;
		switch(aMessage.Function())
			{
			case EMMFDevSoundProxyPostOpen:
				complete = DoPostOpenL(aMessage);
				break;
			case EMMFDevSoundProxyInitialize1:
				complete = DoInitialize1L(aMessage);
				break;
			case EMMFDevSoundProxyInitialize2:
				complete = DoInitialize2L(aMessage);
				break;
			case EMMFDevSoundProxyInitialize4:
				complete = DoInitialize4L(aMessage);
				break;
			case EMMFDevSoundProxyCapabilities:
				complete = DoCapabilitiesL(aMessage);
				break;
			case EMMFDevSoundProxyConfig:
				complete = DoConfigL(aMessage);
				break;
			case EMMFDevSoundProxySetConfig:
				complete = DoSetConfigL(aMessage);
				break;
			case EMMFDevSoundProxyMaxVolume:
				complete = DoMaxVolumeL(aMessage);
				break;
			case EMMFDevSoundProxyVolume:
				complete = DoVolumeL(aMessage);
				break;
			case EMMFDevSoundProxySetVolume:
				complete = DoSetVolumeL(aMessage);
				break;
			case EMMFDevSoundProxyMaxGain:
				complete = DoMaxGainL(aMessage);
				break;
			case EMMFDevSoundProxyGain:
				complete = DoGainL(aMessage);
				break;
			case EMMFDevSoundProxySetGain:
				complete = DoSetGainL(aMessage);
				break;
			case EMMFDevSoundProxyPlayBalance:
				complete = DoGetPlayBalanceL(aMessage);
				break;
			case EMMFDevSoundProxySetPlayBalance:
				complete = DoSetPlayBalanceL(aMessage);
				break;
			case EMMFDevSoundProxyRecordBalance:
				complete = DoGetRecordBalanceL(aMessage);
				break;
			case EMMFDevSoundProxySetRecordBalance:
				complete = DoSetRecordBalanceL(aMessage);
				break;
			case EMMFDevSoundProxyBTBFData:
				complete = DoBufferToBeFilledDataL(aMessage);
				break;
			case EMMFDevSoundProxyBTBEData:
				complete = DoBufferToBeEmptiedDataL(aMessage);
				break;
			case EMMFDevSoundProxyPlayInit:
				complete = DoPlayInitL(aMessage);
				break;
			case EMMFDevSoundProxyRecordInit:
				complete = DoRecordInitL(aMessage);
				break;
			case EMMFDevSoundProxyPlayData:
				complete = DoPlayDataL(aMessage);
				break;
			case EMMFDevSoundProxyRecordData:
				complete = DoRecordDataL(aMessage);
				break;
			case EMMFDevSoundProxyStop:
				complete = DoStopL(aMessage);
				break;
			case EMMFDevSoundProxyPause:
				complete = DoPauseL(aMessage);
				break;
			case EMMFDevSoundProxyPlayTone:
				complete = DoPlayToneL(aMessage);
				break;
			case EMMFDevSoundProxyPlayDualTone:
				complete = DoPlayDualToneL(aMessage);
				break;
			case EMMFDevSoundProxyPlayDTMFString:
				complete = DoPlayDTMFStringL(aMessage);
				break;
			case EMMFDevSoundProxyPlayToneSequence:
				complete = DoPlayToneSequenceL(aMessage);
				break;
			case EMMFDevSoundProxyPlayFixedSequence:
				complete = DoPlayFixedSequenceL(aMessage);
				break;
			case EMMFDevSoundProxySetDTMFLengths:
				complete = DoSetDTMFLengthsL(aMessage);
				break;
			case EMMFDevSoundProxySetVolumeRamp:
				complete = DoSetVolumeRampL(aMessage);
				break;
			case EMMFDevSoundProxyGetSupportedInputDataTypes:
				complete = DoGetSupportedInputDataTypesL(aMessage);
				break;
			case EMMFDevSoundProxyGetSupportedOutputDataTypes:
				complete = DoGetSupportedOutputDataTypesL(aMessage);
				break;
			case EMMFDevSoundProxyCopyFourCCArrayData:
				complete = DoCopyFourCCArrayDataL(aMessage);
				break;
			case EMMFDevSoundProxySamplesRecorded:
				complete = DoSamplesRecordedL(aMessage);
				break;
			case EMMFDevSoundProxySamplesPlayed:
				complete = DoSamplesPlayedL(aMessage);
				break;
			case EMMFDevSoundProxySetToneRepeats:
				complete = DoSetToneRepeatsL(aMessage);
				break;
			case EMMFDevSoundProxySetPrioritySettings:
				complete = DoSetPrioritySettingsL(aMessage);
				break;
			case EMMFDevSoundProxyFixedSequenceCount:
				complete = DoFixedSequenceCountL(aMessage);
				break;
			case EMMFDevSoundProxyCancelInitialize:
				complete = DoCancelInitializeL(aMessage);
				break;
			case EMMFDevSoundProxyEmptyBuffers:
				complete = DoEmptyBuffersL(aMessage);
				break;
			case EMMFDevSoundProxyGetTimePlayed:
				complete = DoGetTimePlayedL(aMessage);
				break;
			case EMMFDevSoundProxyIsResumeSupported:
				complete = DoQueryResumeSupportedL(aMessage);
				break;
			case EMMFDevSoundProxyResume:
				complete = DoResumeL(aMessage);
				break;

			// DevSound custom command support
			case EMMFDevSoundProxySyncCustomCommand:
			case EMMFDevSoundProxySyncCustomCommandResult:
			case EMMFDevSoundProxyAsyncCustomCommand:
			case EMMFDevSoundProxyAsyncCustomCommandResult:
				complete = DoCustomCommandL(aMessage);
				break;
			case EMMFDevSoundProxyClose:
				complete = DoPrepareCloseL(aMessage);
				break;
			case EMMFDevSoundProxyRequestResourceNotification:
				complete = DoRegisterAsClientL(aMessage);
				break;
			case EMMFDevSoundProxyCancelRequestResourceNotification:
				complete = DoCancelRegisterAsClientL(aMessage);
				break;
			case EMMFDevSoundProxyGetResourceNotificationData:
				complete = DoGetResourceNotificationDataL(aMessage);
				break;
			case EMMFDevSoundProxyWillResumePlay:
				complete = DoWillResumePlayL(aMessage);
				break;
			case EMMFDevSoundProxySetClientThreadInfo:
				complete = DoSetClientThreadInfoL(aMessage);
				break;						
			default:
				User::Leave(KErrNotSupported);
				break;
			}

		// Check if can complete the message now
		if (complete)
			{
			// Complete the message
			// Synchronous requests & Pseudo-asynchronous
			aMessage.Complete(KErrNone);

			// Store function if we need to re-apply it again due to pre-emption clash
			if(iRequestBeingServiced.Type() == TMMFDevSoundRequest::EAction_PseudoAsynchronous)
				{
				iRedoFunction = aMessage.Function();
				}
			}
		}
	else
		{
		// If there's a CI extension, see if that handles this request
		TInt err = KErrNotSupported;
		if (iCIExtension)
			{
            SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - CIExtensionRequest [%d]"), aMessage.Function());
            iOperationCompletePending = ETrue;
			iHandlingExtdCI = ETrue;
			TRAPD(err2, err = iCIExtension->HandleMessageL(aMessage));
			if (err2)
				{
				err = err2;
				}
			iOperationCompletePending = EFalse;
			iHandlingExtdCI = EFalse;
			SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x]::DoServiceRequestL - CIExtensionRequest[%d] - Exit with Error[%d] "), aMessage.Function(),err);
			}

		if (err != KErrNone)
			{
			// Not been handled, the request is not supported
			aMessage.Complete(KErrNotSupported);
			}
		}
	}

void CMMFDevSoundSession::DoServiceAlreadyCompletedRequestL(const TInt aFunction)
	{
    ResetNotifiedError();

	switch(aFunction)
		{
		case EMMFDevSoundProxyInitialize1:
			DoAlreadyCompletedInitialize1L();
			break;
		case EMMFDevSoundProxyInitialize2:
			DoAlreadyCompletedInitialize2L();
			break;
		case EMMFDevSoundProxyInitialize4:
			DoAlreadyCompletedInitialize4L();
			break;
		case EMMFDevSoundProxyPlayInit:
			DoAlreadyCompletedPlayInitL();
			break;
		case EMMFDevSoundProxyRecordInit:
			DoAlreadyCompletedRecordInitL();
			break;
		case EMMFDevSoundProxyPlayTone:
			DoAlreadyCompletedPlayToneL();
			break;
		case EMMFDevSoundProxyPlayDualTone:
			DoAlreadyCompletedPlayDualToneL();
			break;
		case EMMFDevSoundProxyPlayDTMFString:
			DoAlreadyCompletedPlayDTMFStringL();
			break;
		case EMMFDevSoundProxyPlayToneSequence:
			DoAlreadyCompletedPlayToneSequenceL();
			break;
		case EMMFDevSoundProxyPlayFixedSequence:
			DoAlreadyCompletedPlayFixedSequenceL();
			break;
		default:
			User::Leave(KErrNotSupported);
			break;
		}

	}

void CMMFDevSoundSession::HandleAlreadyCompletedRequest()
	{
	TRAPD(err,DoServiceAlreadyCompletedRequestL(iRedoFunction));

	if (err != KErrNone)
		{
		switch(iRedoFunction)
			{
			case EMMFDevSoundProxyInitialize1:
			case EMMFDevSoundProxyInitialize2:
			case EMMFDevSoundProxyInitialize4:
				InitializeComplete(err);
				break;
			case EMMFDevSoundProxyPlayInit:
				PlayError(err);
				break;
			case EMMFDevSoundProxyRecordInit:
				RecordError(err);
				break;
			case EMMFDevSoundProxyPlayTone:
			case EMMFDevSoundProxyPlayDualTone:
			case EMMFDevSoundProxyPlayDTMFString:
			case EMMFDevSoundProxyPlayToneSequence:
			case EMMFDevSoundProxyPlayFixedSequence:
				ToneFinished(err);
				break;
			default:
				break;
			}
		}
	}

void CMMFDevSoundSession::EnqueueRequest(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::EnqueueRequest - Enter"));
	// Encapsule the request
	TMMFDevSoundRequest request;
	request.SetMessage(aMessage);
	// Append
	TInt error = iQueuedRequests.Append(request);
	__ASSERT_DEBUG(error == KErrNone, Panic(EQueueRequestsFailedToAppend));
	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::EnqueueRequest - Exit"));
	}

//
// CMMFDevSoundSession::DoPostOpenL
//
TBool CMMFDevSoundSession::DoPostOpenL(const RMmfIpcMessage& /*aMessage*/)
	{
	iAdapter->PostOpenL();
	iOperationCompletePending = ETrue;
	return EFalse;
	}

//
// CMMFDevSoundSession::DoInitialize1L
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoInitialize1L(const RMmfIpcMessage& aMessage)
	{
    iMsgQueue.Close(); // close if already open
	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread
	User::LeaveIfError(err);
	DoSetClientConfigL();// added here instead of the CreateL()
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,1,devSoundBuf));
	iCachedClientData = devSoundBuf;
	TMMFState mode = devSoundBuf().iMode;
	iAdapter->InitializeL(mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	// Flag to queue any further request 
	// but the message can be completed now
	iOperationCompletePending = ETrue;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedInitialize1L
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedInitialize1L()
	{
	TMMFState mode = iCachedClientData().iMode;
	iAdapter->InitializeL(mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	// Flag to queue any further request
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoInitialize2L
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoInitialize2L(const RMmfIpcMessage& aMessage)
	{
    iMsgQueue.Close(); // close if already open
	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread
	User::LeaveIfError(err);
	DoSetClientConfigL();// added here instead of the CreateL()
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,1,devSoundBuf));
	iCachedClientData = devSoundBuf;
	TUid HWDev = devSoundBuf().iHWDev;
	TMMFState mode = devSoundBuf().iMode;
	iAdapter->InitializeL(HWDev, mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedInitialize2L
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedInitialize2L()
	{
	TUid HWDev = iCachedClientData().iHWDev;
	TMMFState mode = iCachedClientData().iMode;
	iAdapter->InitializeL(HWDev, mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	}

//
// CMMFDevSoundSession::DoInitialize4L
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoInitialize4L(const RMmfIpcMessage& aMessage)
	{
    iMsgQueue.Close();
	TInt err = iMsgQueue.Open(aMessage, 2, EOwnerThread); // a global queue but owned by thread
	User::LeaveIfError(err);
	DoSetClientConfigL();// added here instead of the CreateL()
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage, TInt(1), devSoundBuf));
	iCachedClientData = devSoundBuf;
	TFourCC desiredFourCC = devSoundBuf().iDesiredFourCC;
	TMMFState mode = devSoundBuf().iMode;
	iAdapter->InitializeL(desiredFourCC, mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	// Flag to queue any further request 
	// but the message can be completed now
	iOperationCompletePending = ETrue;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedInitialize4L
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedInitialize4L()
	{
	TFourCC desiredFourCC = iCachedClientData().iDesiredFourCC;
	TMMFState mode = iCachedClientData().iMode;
	iAdapter->InitializeL(desiredFourCC, mode);
	iBufferPlay = NULL;
	iPlayErrorOccured = EFalse;
	// Flag to queue any further request
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoCancelInitialize
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoCancelInitializeL(const RMmfIpcMessage& aMessage)
	{
	TInt err=iAdapter->CancelInitialize();

	if (err != KErrNone)
		{
		aMessage.Complete(err);
		iOperationCompletePending = EFalse;
		}
	else
		{
		iOperationCompletePending = ETrue;
		}
	return EFalse;
	}

//
// CMMFDevSoundSession::DoCapabilitiesL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoCapabilitiesL(const RMmfIpcMessage& aMessage)
	{
	TInt err = iAdapter->Capabilities(iDevSoundCapabilities);
	if(err != KErrNone)
		{
		aMessage.Complete(err);
		iOperationCompletePending = EFalse;
		}
	else
		{
		iOperationCompletePending = ETrue;
		}
	return EFalse;
	}

//
// CMMFDevSoundSession::DoConfigL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoConfigL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	devSoundSet.iConfig = iAdapter->Config();
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetConfigL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetConfigL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TMMFCapabilities config = devSoundBuf().iConfig;
	iAdapter->SetConfigL(config);
	iOperationCompletePending = ETrue;
	return EFalse;
	}

//
// CMMFDevSoundSession::axVolumeL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoMaxVolumeL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	devSoundSet.iMaxVolume = iAdapter->MaxVolume();
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoVolumeL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoVolumeL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	devSoundSet.iVolume = iAdapter->Volume();
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetVolumeL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetVolumeL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage, TInt(1),devSoundBuf));
	TInt volume = devSoundBuf().iVolume;
	TBool asyncOperation;
	User::LeaveIfError(iAdapter->SetVolume(volume, asyncOperation));
	iOperationCompletePending = asyncOperation;
	return !asyncOperation;
	}

//
// CMMFDevSoundSession::DoMaxGainL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoMaxGainL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	devSoundSet.iMaxGain = iAdapter->MaxGain();
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoGainL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGainL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	devSoundSet.iGain = iAdapter->Gain();
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetGainL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetGainL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TInt gain = devSoundBuf().iGain;
	TBool asyncOperation;
	User::LeaveIfError(iAdapter->SetGain(gain, asyncOperation));
	iOperationCompletePending = asyncOperation;
	return !asyncOperation;
	}

//
// CMMFDevSoundSession::DoGetPlayBalanceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGetPlayBalanceL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	iAdapter->GetPlayBalanceL(devSoundSet.iLeftPercentage, devSoundSet.iRightPercentage);
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetPlayBalanceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetPlayBalanceL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg devSoundBuf;
    User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TInt leftPercentage = devSoundBuf().iLeftPercentage;
	TInt rightPercentage = devSoundBuf().iRightPercentage;
	TBool asyncOperation;
	iAdapter->SetPlayBalanceL(leftPercentage, rightPercentage, asyncOperation);
	iOperationCompletePending = asyncOperation;
	return !asyncOperation;
	}

//
// CMMFDevSoundSession::DoGetRecordBalanceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGetRecordBalanceL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettings devSoundSet;
	iAdapter->GetRecordBalanceL(devSoundSet.iLeftPercentage, devSoundSet.iRightPercentage);
	TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetRecordBalanceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetRecordBalanceL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TInt leftPercentage = devSoundBuf().iLeftPercentage;
	TInt rightPercentage = devSoundBuf().iRightPercentage;
	TBool asyncOperation;
	iAdapter->SetRecordBalanceL(leftPercentage, rightPercentage, asyncOperation);
	iOperationCompletePending = asyncOperation;
	return !asyncOperation;
	}

//
// CMMFDevSoundSession::DoPlayInitL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayInitL(const RMmfIpcMessage& /*aMessage*/)
	{
	iAdapter->PlayInitL();
	iOperationCompletePending = ETrue;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayInitL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayInitL()
	{
	iAdapter->PlayInitL();
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoRecordInitL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoRecordInitL(const RMmfIpcMessage& /*aMessage*/)
	{
	iAdapter->RecordInitL();
	iOperationCompletePending = ETrue;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedRecordInitL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedRecordInitL()
	{
	iAdapter->RecordInitL();
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoPlayDataL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayDataL(const RMmfIpcMessage& aMessage)
	{
	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Enter"));

	if( iPlayErrorOccured )
		{
		SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Ignore and Exit"));
		return ETrue;
		}

	TMMFDevSoundProxyHwBufPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	iBufferPlay->SetLastBuffer(devSoundBuf().iLastBuffer);

	TPtr8 dataPtr(iChunk.Base(), devSoundBuf().iBufferSize, devSoundBuf().iBufferSize);
	// Copy data over from chunk
	iBufferPlay->Data().Copy(dataPtr);
	iAdapter->PlayData();
	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDataL - Exit"));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoRecordDataL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoRecordDataL(const RMmfIpcMessage& /*aMessage*/)
	{
	iAdapter->RecordData();
	return ETrue;
	}

//
// CMMFDevSoundSession::DoStopL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoStopL(const RMmfIpcMessage& /*aMessage*/)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoStopL - Enter"));
    // Sometimes Stop is not involved on a commit cycle
	TBool completed = iAdapter->Stop();
	if (completed)
		{
        FlushQueuedRequests();
		FlushEventQueue(); // completed returned here means we were idle to start with. TODO could possibly skip this flush
		iChunk.Close();
		}
	iOperationCompletePending = !completed;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoStopL - Exit. Return value is [%d]"), completed);
	return completed;
	}

//
// CMMFDevSoundSession::DoPauseL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPauseL(const RMmfIpcMessage& /*aMessage*/)
	{
	User::LeaveIfError(iAdapter->Pause());
	iOperationCompletePending = ETrue;
	return EFalse;
	}

//
// CMMFDevSoundSession::DoPlayToneL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayToneL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayToneL - Enter"));
    TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	iCachedClientData = devSoundBuf;
	TInt frequency = devSoundBuf().iFrequencyOne;
	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);
	iAdapter->PlayToneL(frequency, duration);
	iOperationCompletePending = ETrue;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayToneL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayToneL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayToneL()
	{
	TInt frequency = iCachedClientData().iFrequencyOne;
	TTimeIntervalMicroSeconds duration(iCachedClientData().iDuration);
	iAdapter->PlayToneL(frequency, duration);
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoPlayDualToneL
// (other items were commented in a header).	
//
TBool CMMFDevSoundSession::DoPlayDualToneL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDualToneL - Enter"));
    TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	iCachedClientData = devSoundBuf;
	TInt frequencyOne = devSoundBuf().iFrequencyOne;
	TInt frequencyTwo = devSoundBuf().iFrequencyTwo;
	TTimeIntervalMicroSeconds duration(devSoundBuf().iDuration);
	iAdapter->PlayDualToneL(frequencyOne, frequencyTwo, duration);
	iOperationCompletePending = ETrue;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayDualToneL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayDualToneL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayDualToneL()
	{
	TInt frequencyOne = iCachedClientData().iFrequencyOne;
	TInt frequencyTwo = iCachedClientData().iFrequencyTwo;
	TTimeIntervalMicroSeconds duration(iCachedClientData().iDuration);
	iAdapter->PlayDualToneL(frequencyOne, frequencyTwo, duration);
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoPlayDTMFStringL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayDTMFStringL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayDTMFStringL - Enter"));
    TInt dtmfLength = aMessage.GetDesLength(2);
	
	if(iDtmfString)
		{
		delete iDtmfString;
		iDtmfString = NULL;
		}

	iDtmfString = HBufC::NewL(dtmfLength);
	TPtr dtmfPtr = iDtmfString->Des();
    User::LeaveIfError(MessageRead(aMessage, TInt(2), dtmfPtr));
	iAdapter->PlayDTMFStringL(*iDtmfString);
	iOperationCompletePending = ETrue;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayDTMFStringL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayDTMFStringL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayDTMFStringL()
	{
	iAdapter->PlayDTMFStringL(*iDtmfString);
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoPlayToneSequenceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayToneSequenceL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayToneSequenceL - Enter"));
    TInt toneLength = aMessage.GetDesLength(1);

	if(iToneSeqBuf)
		{
		delete iToneSeqBuf;
		iToneSeqBuf = NULL;
		}

	iToneSeqBuf = HBufC8::NewL(toneLength);
	TPtr8 toneSeqPtr = iToneSeqBuf->Des();
	User::LeaveIfError(MessageRead(aMessage,TInt(1), toneSeqPtr));

	iAdapter->PlayToneSequenceL(*iToneSeqBuf);
	iOperationCompletePending = ETrue;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayToneSequenceL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayToneSequenceL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayToneSequenceL()
	{
	iAdapter->PlayToneSequenceL(*iToneSeqBuf);
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoPlayFixedSequenceL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoPlayFixedSequenceL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoPlayFixedSequenceL - Enter"));
    TPckgBuf<TInt> buf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),buf));
	TInt seqNum = buf();
	iSeqNum = seqNum;
	iAdapter->PlayFixedSequenceL(seqNum);
	iOperationCompletePending = ETrue;
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoPlayFixedSequenceL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoAlreadyCompletedPlayFixedSequenceL
// (other items were commented in a header).
//
void CMMFDevSoundSession::DoAlreadyCompletedPlayFixedSequenceL()
	{
	iAdapter->PlayFixedSequenceL(iSeqNum);
	iOperationCompletePending = ETrue;
	}

//
// CMMFDevSoundSession::DoSetDTMFLengthsL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetDTMFLengthsL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoSetDTMFLengthsL - Enter"));
    TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TTimeIntervalMicroSeconds32 toneOnLength = devSoundBuf().iToneOnLength;
	TTimeIntervalMicroSeconds32 toneOffLength = devSoundBuf().iToneOffLength;
	TTimeIntervalMicroSeconds32 pauseLength = devSoundBuf().iPauseLength;
	User::LeaveIfError(iAdapter->SetDTMFLengths(toneOnLength, toneOffLength, pauseLength));
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoSetDTMFLengthsL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetVolumeRampL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetVolumeRampL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoSetVolumeRampL - Enter"));
    TMMFDevSoundProxySettingsPckg devSoundBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),devSoundBuf));
	TTimeIntervalMicroSeconds duration = devSoundBuf().iDuration;
	User::LeaveIfError(iAdapter->SetVolumeRamp(duration));
	iOperationCompletePending = EFalse; // Volume ramp doesn't result on commit
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoSetVolumeRampL - Exit. Return value is [%d]"), ETrue);
	return ETrue; // operation complete
	}

//
// CMMFDevSoundSession::DoGetSupportedInputDataTypesL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGetSupportedInputDataTypesL(
							const RMmfIpcMessage& aMessage)
	{
	iArray.Reset();

	TMMFPrioritySettingsPckg prioritySetBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),prioritySetBuf));
	TMMFPrioritySettings prioritySet = prioritySetBuf();

	iAdapter->GetSupportedInputDataTypesL(iArray, prioritySet);

	TPckgBuf<TInt> pckg;
	pckg() = iArray.Count();
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

	return ETrue;
	}

//
// CMMFDevSoundSession::DoGetSupportedOutputDataTypesL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGetSupportedOutputDataTypesL(
							const RMmfIpcMessage& aMessage)
	{
	iArray.Reset();

	TMMFPrioritySettingsPckg prioritySetBuf;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),prioritySetBuf));
	TMMFPrioritySettings prioritySet = prioritySetBuf();

	iAdapter->GetSupportedOutputDataTypesL(iArray, prioritySet);

	TPckgBuf<TInt> pckg;
	pckg() = iArray.Count();
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));

	return ETrue;
	}

//
// CMMFDevSoundSession::DoSamplesRecordedL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSamplesRecordedL(const RMmfIpcMessage& aMessage)
	{
	TPckgBuf<TInt> pckg;
	pckg() = iAdapter->SamplesRecorded();
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSamplesPlayedL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSamplesPlayedL(const RMmfIpcMessage& aMessage)
	{
	TPckgBuf<TInt> pckg;
	pckg() = iAdapter->SamplesPlayed();
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),pckg));
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetToneRepeatsL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetToneRepeatsL(const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoSetToneRepeatsL - Enter"));
    TPckgBuf<TInt> countRepeat;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),countRepeat));

	TPckgBuf<TTimeIntervalMicroSeconds> repeatTS;
	User::LeaveIfError(MessageRead(aMessage,TInt(2),repeatTS));
	User::LeaveIfError(iAdapter->SetToneRepeats(countRepeat(), repeatTS()));
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoSetToneRepeatsL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}

//
// CMMFDevSoundSession::DoSetPrioritySettingsL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoSetPrioritySettingsL(
						const RMmfIpcMessage& aMessage)
	{
	TPckgBuf<TMMFPrioritySettings> prioritySet;
	User::LeaveIfError(MessageRead(aMessage,TInt(1),prioritySet));

	User::LeaveIfError(iAdapter->SetPrioritySettings(prioritySet()));
	iOperationCompletePending = EFalse;
	return ETrue;
	}

//
// CMMFDevSoundSession::DoFixedSequenceCountL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoFixedSequenceCountL(
					const RMmfIpcMessage& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DoFixedSequenceCountL - Enter"));
    TPckgBuf<TInt> fixSeqCountPckg;
	TInt fixSeqCount = iAdapter->FixedSequenceCount();
	fixSeqCountPckg = fixSeqCount;

	User::LeaveIfError(MessageWrite(aMessage,TInt(2),fixSeqCountPckg));
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::DoFixedSequenceCountL - Exit. Return value is [%d]"), ETrue);
	return ETrue;
	}


//
// CMMFDevSoundSession::DoCopyFourCCArrayDataL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoCopyFourCCArrayDataL(
						const RMmfIpcMessage& aMessage)
	{
	const TInt KBufExpandSize8 = 8;//two TInts
	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KBufExpandSize8);
	CleanupStack::PushL(dataCopyBuffer);
	RBufWriteStream stream;
	stream.Open(*dataCopyBuffer);
	CleanupClosePushL(stream);
	
	TInt i = 0;
	TInt count = iArray.Count();
	
	while (i < count)
		{
		stream.WriteInt32L(iArray[i].FourCC());
		i++;
		}
	User::LeaveIfError(MessageWrite(aMessage, TInt(2), dataCopyBuffer->Ptr(0)));
	stream.Close();
	CleanupStack::PopAndDestroy(&stream);
	CleanupStack::PopAndDestroy(dataCopyBuffer);
	return ETrue;
	}


//
// CMMFDevSoundSession::DoBufferToBeFilledDataL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoBufferToBeFilledDataL(
							const RMmfIpcMessage& aMessage)
	{
	// if CMMFDevSoundSession::PlayError() has been called, RChunk would have got closed.
	// Need to check if Chunk Handle is still valid. If it is not,complete the message immediately and send a error to the Client.
	if(!iChunk.Handle())
		{
		aMessage.Complete(KErrBadHandle);
		return EFalse;	
		}
	TPckgBuf<TInt> requestChunkBuf;
	User::LeaveIfError(MessageRead(aMessage, TInt(1), requestChunkBuf));
	TBool requestChunk = requestChunkBuf();
	if (requestChunk)
		{
		// if the client requests, always do EOpen
		iHwBufPckgFill().iChunkOp = EOpen;
		}
	TInt err = MessageWrite(aMessage, TInt(2), iHwBufPckgFill);
	if ( (err == KErrNone) && (iHwBufPckgFill().iChunkOp == EOpen) )
		{
		aMessage.Complete(iChunk);
		}
	else
		{
		aMessage.Complete(err);
		}
	return EFalse;
	}

// CMMFDevSoundSession::DoBufferToBeEmptiedDataL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoBufferToBeEmptiedDataL(
						const RMmfIpcMessage& aMessage)
	{
	// if CMMFDevSoundSession::RecordError() has been called, RChunk would have got closed.
	// Need to check if Chunk Handle is still valid. If it is not,complete the message immediately and send a error to the Client.
	if(!iChunk.Handle())
		{
		aMessage.Complete(KErrBadHandle);
		return EFalse;	
		}
	
	TInt err = MessageWrite(aMessage, TInt(2), iHwBufPckgEmpty);
	if ( (err == KErrNone) && (iHwBufPckgEmpty().iChunkOp == EOpen) )
		{
		aMessage.Complete(iChunk);
		}
	else
		{
		aMessage.Complete(err);
		}
	return EFalse;
	}

//
// CMMFDevSoundSession::DoEmptyBuffersL
// (other items were commented in a header).
//

TBool CMMFDevSoundSession::DoEmptyBuffersL(const RMmfIpcMessage& aMessage)
	{
	TInt err = KErrNone;
	FilterQueueEvent(EMMFDevSoundProxyBTBFEvent);
	// This is now asynchronous
	err = iAdapter->EmptyBuffers();
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;
		}
	iOperationCompletePending = ETrue;
	return EFalse;
	}
//
// CMMFDevSoundSession::DoGetTimePlayedL
// (other items were commented in a header).
//
TBool CMMFDevSoundSession::DoGetTimePlayedL(const RMmfIpcMessage& aMessage)
	{
	TInt err = KErrNone;
	TTimeIntervalMicroSeconds time(0);
	TPckgBuf<TTimeIntervalMicroSeconds> timePckg(time);
	err = iAdapter->GetTimePlayed(timePckg());
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;		
		}
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),timePckg));
	return ETrue;
	}

TBool CMMFDevSoundSession::DoQueryResumeSupportedL(const RMmfIpcMessage& aMessage)
	{
	TBool isSupported = EFalse;
	TPckgBuf<TBool> isSupportedPckg(isSupported);
	isSupportedPckg() = iAdapter->IsResumeSupported();
	User::LeaveIfError(MessageWrite(aMessage,TInt(2),isSupportedPckg));
	return ETrue;
	}

TBool CMMFDevSoundSession::DoResumeL(const RMmfIpcMessage& /*aMessage*/)
	{
	User::LeaveIfError( iAdapter->Resume() );
	iOperationCompletePending = ETrue;
	FilterQueueEvent(EMMFDevSoundProxyPausedRecordCompleteEvent);
	return EFalse;
	}

TBool CMMFDevSoundSession::DoPrepareCloseL(const RMmfIpcMessage& /*aMessage*/)
	{
	TBool complete = iAdapter->CloseDevSound();
	if(!complete)
		{
		iOperationCompletePending = ETrue;	
		}
	return complete;
	}


TBool CMMFDevSoundSession::DoCustomCommandL(const RMmfIpcMessage& aMessage)
	{
	TInt retVal = KErrNone;
	TRAPD(err, retVal = iDeMuxUtility->ProcessCustomInterfaceCommandL(aMessage));
	if (err != KErrNone)
		{
		// the framework left with an error condition
		// so we complete the message with this error
		// irrespective of whether its a Sync or Async custom command
		aMessage.Complete(err);
		}
	else
		{
		TInt messageType = aMessage.Function();
		if ((messageType == EMMFDevSoundProxySyncCustomCommand) ||
			(messageType == EMMFDevSoundProxySyncCustomCommandResult))
			{
			// If its a sync custom command
			// we can pass back valid values here since command
			// has been handled by the DeMux framework
			aMessage.Complete(retVal);	
			}
		}
	
	// we complete our own message so don't need the framework to do so
	return EFalse;
	}
	

//
// CMMFDevSoundSession::CMMFDevSoundSession
// (other items were commented in a header).
//
CMMFDevSoundSession::CMMFDevSoundSession() :
	iSetClientConfigApplied (EFalse),
	iDisconnecting (EFalse)
	{
	}

//
// CMMFDevSoundSession::~CMMFDevSoundSession
// (other items were commented in a header).
//
CMMFDevSoundSession::~CMMFDevSoundSession()
	{
	delete iAsyncQueueStart;
	// clear the array of custom interfaces
	TInt count = iCustomInterfaceArray.Count();
	for (TInt i = 0; i < count; i++)
		{
		// we could have already deleted interfaces without
		// removing them from the array so check for this
		// and only delete release plugin if non-null
		MMMFDevSoundCustomInterfaceDeMuxPlugin* ptr = iCustomInterfaceArray[i].iInterface;
		if (ptr)
			{
			iCustomInterfaceArray[i].iInterface->Release();	
			}
		}
	iCustomInterfaceArray.Reset();
	iCustomInterfaceArray.Close();
		
	delete iDeMuxUtility;
	
	if (iCIExtension)
		{
		iCIExtension->Release();
		iCIExtension = NULL;
		}

	iMsgQueue.Close();
	iArray.Close();
	iQueuedRequests.Close();
	delete iDtmfString;
	delete iToneSeqBuf;
	delete iAdapter;
	delete iClosingWait;

	CMMFDevSoundServer* server =
			const_cast<CMMFDevSoundServer*>(
			static_cast<const CMMFDevSoundServer*>(Server()));

	if (server)
		{
		server->DecrementSessionId();
		}

//	delete iCustomCommandParserManager;
//	delete iMMFObjectContainer;

	// Close chunk
	iChunk.Close();
	}

//
// CMMFDevSoundSession::FlushEventQueue()
//
void CMMFDevSoundSession::FlushEventQueue()
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::FlushEventQueue - Enter"));
    if(iMsgQueue.Handle() != 0)
		{
		TMMFDevSoundQueueItem queueItem;
		TInt err = KErrNone;
		while(err != KErrUnderflow)
			{
			err = iMsgQueue.Receive(queueItem);
			}
		}
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::FlushEventQueue - Exit"));
	}

void CMMFDevSoundSession::FilterQueueEvent(TMMFDevSoundProxyRequest aRequest)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::FilterQueueEvent - Enter"));
    if(iMsgQueue.Handle() != 0)
		{
		// Pop and push events result at the queue 
		// can be seen as "circular list"
		// set a mark to traverse it safely 
		TMMFDevSoundQueueItem markItem;
		markItem.iRequest = EMMFDevSoundProxyMarkEvent;
		// assumes sufficient space in the queue
		TInt err = iMsgQueue.Send(markItem);
		__ASSERT_DEBUG(err == KErrNone, Panic(EMsgQueueFailedToSendMsg));
		
		while(ETrue)
			{
			// At least the markEvent is at the queue so ignore the error
			TMMFDevSoundQueueItem queueItem;
			err = iMsgQueue.Receive(queueItem);
			if(queueItem.iRequest == EMMFDevSoundProxyMarkEvent)
				{
				break;
				}
			// Look for the specific event
			else if(queueItem.iRequest != aRequest)
				{
				// assumes sufficient space in the queue
				err = iMsgQueue.Send(queueItem);
				}
			}
		}
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::FilterQueueEvent - Exit"));
	}

//
// CMMFDevSoundSession::Disconnect
// (other items were commented in a header).
//
void CMMFDevSoundSession::Disconnect(const RMessage2& aMessage)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::Disconnect - Enter"));
    iDisconnecting = ETrue;
	
    if (NeedToQueue())
        {
        // if we are in the middle of something, enqueue and wait
        SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::Disconnect - Add to queue"));
        EnqueueRequest(aMessage);
        iClosingWait->Start();
        }
    else
        {
        // else do now. Enter ActiveSchedulerWait to wait for AsyncOpComplete
        TBool complete = iAdapter->CloseDevSound();
        if(!complete)
            {
            iRequestBeingServiced.SetMessage(aMessage);
            iOperationCompletePending = ETrue;
            ResetNotifiedError();
            iClosingWait->Start();
            }
        }
	CSession2::Disconnect(aMessage);
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::Disconnect - Exit"));
	}


//
// CMMFDevSoundSession::NewL
// (other items were commented in a header).
//
CMMFDevSoundSession* CMMFDevSoundSession::NewL(MGlobalProperties& aGlobalProperties)
	{
	CMMFDevSoundSession* self = new (ELeave) CMMFDevSoundSession;
	CleanupStack::PushL(self);
	self->ConstructL(aGlobalProperties);
	CleanupStack::Pop(self);
	return self;
	}

//
// CMMFDevSoundSession::ConstructL
// (other items were commented in a header).
//
void CMMFDevSoundSession::ConstructL(MGlobalProperties& aGlobalProperties)
	{
	iAdapter = CMMFDevSoundAdaptation::NewL(*this, aGlobalProperties);

	iClosingWait = new(ELeave) CActiveSchedulerWait();
	
	// Create the Custom Interface DeMux Utility
	iDeMuxUtility = CMMFDevSoundCIDeMuxUtility::NewL(this);
	
	// Create the Custom Interface extension
	TUid implUid = {KMmfUidCIServerExtensionImpl};
	TInt uidAsInteger = implUid.iUid;
	const TInt KCIExtTempBufferSize = 20;
	TBuf8<KCIExtTempBufferSize> tempBuffer;
	tempBuffer.Num(uidAsInteger, EHex);
	TUid interfaceUid = {KUidDevSoundCIServerExtension};
	TUid destructorKey;
	TRAPD(err, iCIExtension = static_cast<MDevSoundCIServerExtension*>
		 (MmPluginUtils::CreateImplementationL(interfaceUid, destructorKey, tempBuffer, KRomOnlyResolverUid)));
	if (KErrNotSupported == err)
		{
		iCIExtension = NULL;
		}
	else
		{
		User::LeaveIfError(err);
		}
	if (iCIExtension)
		{
		// Extension exists. Complete the setup
		iCIExtension->PassDestructorKey(destructorKey);
		User::LeaveIfError(iCIExtension->Setup(*this));
		}

	iQueuedRequests.ReserveL(KMaxQueueRequest);
	iAsyncQueueStart = new (ELeave) CAsyncCallBack(CActive::EPriorityStandard);
	TCallBack asyncCallback(AsyncQueueStartCallback, this);
	iAsyncQueueStart->Set(asyncCallback);
	}

// CMMFDevSoundSession::InitializeComplete
// (other items were commented in a header).
//
void CMMFDevSoundSession::InitializeComplete(TInt aError)
	{
	// this may be a re-initialization and so we need to
	// re-get our custom interfaces on the DeMux plugins
	TInt count = iCustomInterfaceArray.Count();
	for (TInt i = 0; i < count; i++)
		{
		// we could have already deleted interfaces without
		// removing them from the array so check for this
		// and only refresh plugin if non-null
		MMMFDevSoundCustomInterfaceDeMuxPlugin* ptr = iCustomInterfaceArray[i].iInterface;
		if (ptr)
			{
			// we can't keep track of..
			// 1. where a custom interface is implemented
			// 2. the uid of the custom interface to be refreshed
			// so assume all have to be refreshed
			TRAPD(err, ptr->RefreshL());	
			
			// Error indicates this is no longer a valid interface
			if (err != KErrNone)
				{
				TMMFEvent event;
				TMMFDevSoundQueueItem item;
				item.iRequest = EMMFDevSoundCustomCommandCloseMuxDemuxPair;
				item.iErrorCode = err;
				event.iEventType.iUid = i+1;
				item.iEventPckg() = event;
				TInt lErr = iMsgQueue.Send(item);
				__ASSERT_DEBUG(lErr == KErrNone, Panic(EMsgQueueFailedToSendMsg));

// NB proper panic code required here for this part.
				}
			}
		}
	TMMFDevSoundQueueItem item;
	item.iRequest = EMMFDevSoundProxyICEvent;
	item.iErrorCode = aError;
	// assumes sufficient space in the queue so ignores the return value
	iMsgQueue.Send(item); 
	}

// 
// CMMFDevSoundSession::ToneFinished
// (other items were commented in a header).
//
void CMMFDevSoundSession::ToneFinished(TInt aError)
	{
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::ToneFinished - Enter. Error [%d]"), aError);
    TMMFDevSoundQueueItem item;
	item.iRequest = EMMFDevSoundProxyTFEvent;
	item.iErrorCode = aError;
	// assumes sufficient space in the queue so ignores the return value
	iMsgQueue.Send(item);
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::ToneFinished - Exit"));
	}

//
// CMMFDevSoundSession::BufferToBeFilled
// (other items were commented in a header).
//
void CMMFDevSoundSession::BufferToBeFilled(CMMFBuffer* aBuffer)
	{
	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::BufferToBeFilled - Enter"));

	// Set play error flag to false 
	iPlayErrorOccured = EFalse;

	// Store pointer to the buffer to use it later with PlayData
	iBufferPlay = reinterpret_cast<CMMFDataBuffer*>(aBuffer);
	TInt status = CreateChunk(iHwBufPckgFill, iBufferPlay->RequestSize());
	iHwBufPckgFill().iRequestSize = iBufferPlay->RequestSize();
	iHwBufPckgFill().iBufferSize = iBufferPlay->Data().MaxLength();
	iHwBufPckgFill().iLastBuffer = iBufferPlay->LastBuffer();
	TMMFDevSoundQueueItem queueItem;
	if ( status != KErrNone )
		{
		BufferErrorEvent();
		PlayError(status);
		}
	else
		{
		queueItem.iRequest = EMMFDevSoundProxyBTBFEvent;
		// assumes sufficient space in the queue so ignores the return value
		status = iMsgQueue.Send(queueItem);
		}

	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::BufferToBeFilled - Exit [%d]"), status);
	}

//
// CMMFDevSoundSession::PlayError
// (other items were commented in a header).
//
void CMMFDevSoundSession::PlayError(TInt aError)
	{
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::PlayError - Enter [%d]"), aError);

	// Set play error flag to ignore following PlayData requests
	iPlayErrorOccured = ETrue;

	TMMFDevSoundQueueItem item;
	item.iRequest = EMMFDevSoundProxyPEEvent;
	item.iErrorCode = aError;
	iChunk.Close();
	// assumes sufficient space in the queue so ignores the return value
	iMsgQueue.Send(item);
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PlayError - Exit"));
	}

//
// CMMFDevSoundSession::BufferToBeEmptied
// (other items were commented in a header).
//
void CMMFDevSoundSession::BufferToBeEmptied(CMMFBuffer* aBuffer)
	{
	// Store pointer to the buffer to use it later with RecordData
	iBufferRecord = reinterpret_cast<CMMFDataBuffer*>(aBuffer);
	TInt status = CreateChunk(iHwBufPckgEmpty, iBufferRecord->RequestSize());
	
	if ( status != KErrNone )
		{
		BufferErrorEvent();
		RecordError(status);
		}
	else
		{
		iHwBufPckgEmpty().iRequestSize = iBufferRecord->RequestSize();
		iHwBufPckgEmpty().iBufferSize = iBufferRecord->Data().MaxLength();
		iHwBufPckgEmpty().iLastBuffer = iBufferRecord->LastBuffer();
		//copy the data into the chunk    
		Mem::Copy(iChunk.Base(),iBufferRecord->Data().Ptr(),iBufferRecord->RequestSize());
	    TMMFDevSoundQueueItem queueItem;
		queueItem.iRequest = EMMFDevSoundProxyBTBEEvent;
		// assumes sufficient space in the queue so ignores the return value
		iMsgQueue.Send(queueItem);
		}
	}

// CMMFDevSoundSession::RecordError
// (other items were commented in a header).
//
void CMMFDevSoundSession::RecordError(TInt aError)
	{
	SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::Record Error [%d]"), aError);
	TMMFDevSoundQueueItem item;
	item.iRequest = EMMFDevSoundProxyREEvent;
	item.iErrorCode = aError;
	iChunk.Close();
	// assumes sufficient space in the queue so ignores the return value
	iMsgQueue.Send(item);
	}

//
// CMMFDevSoundSession::DeviceMessage
// (other items were commented in a header).
//
void CMMFDevSoundSession::DeviceMessage(TUid /*aMessageType*/,
									const TDesC8& /*aMsg*/)
	{
	// Not used
	}

void CMMFDevSoundSession::InterfaceDeleted(TUid aInterfaceId)
	{
	MMMFDevSoundCustomInterfaceDeMuxPlugin* ptr = InterfaceFromUid(aInterfaceId);
	if (ptr == NULL)
		{
		// Not found
		return;
		}
	TRAPD(err, ptr->RefreshL());
	if (err != KErrNone)
		{
		// Refresh failed, so tear down Mux/DeMux pair
		TMMFEvent event;
		TMMFDevSoundQueueItem item;
		item.iRequest = EMMFDevSoundCustomCommandCloseMuxDemuxPair;
		item.iErrorCode = err;
		event.iEventType = aInterfaceId;
		item.iEventPckg() = event;
		iMsgQueue.Send(item);
		}
	}

//
// CMMFDevSoundSession::CallbackFromAdaptorReceived
// (other items were commented in a header).
//
void CMMFDevSoundSession::CallbackFromAdaptorReceived(TInt aType, TInt aError)
	{
    SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x]::CallbackFromAdaptorReceived - Enter. Type[%d] Error[%d]"), aType, aError);
	if(aType == KCallbackRecordPauseComplete)
		{
		TMMFDevSoundQueueItem item;
		item.iRequest = EMMFDevSoundProxyPausedRecordCompleteEvent;
		item.iErrorCode = KErrNone;
		TInt status = iMsgQueue.Send(item);
		}
	else if(aType == KCallbackAutoPauseResume)
		{
		TMMFEvent event;
		event.iErrorCode = KErrNone;
		event.iEventType = KMMFEventCategoryAudioResourceAvailable;
		SendEventToClient(event);
		//coverity[uninit_use_in_call]
		// Disabled Coverity warning, since it complains about iReserved1 member in TMMFEvent being uninitialised
		}
	else if (aType == KCallbackFlushComplete)
		{
		if(!iHandlingExtdCI && iRequestBeingServiced.Function()==EMMFDevSoundProxyEmptyBuffers)
			{
			//If we come here then it is due to a EMMFDevSoundProxyEmptyBuffers request from client.
			SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::CallbackFromAdaptorReceived - Calling TMMFDevSoundRequest::Complete on iRequestBeingServiced"));
		    iRequestBeingServiced.Complete(aError);
		    iOperationCompletePending = EFalse;
			}
		}
	else
		{
		if( NeedToQueue() )
			{
			// If not possible to service now, then queue request
			// Encapsule the request
			TMMFDevSoundRequest request(aType);
			// assumes sufficient space in the queue so ignores the return value
			iQueuedRequests.Insert(request, 0);
			}
		else
			{
			// If there is no oustanding operation service inmediately
			if (aType == KCallbackProcessingFinished)
				{
				DoProcessingFinished();
				}
			else if(aType == KCallbackProcessingUnitError)
				{
				DoProcessingError();
				}
			}
		}
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::CallbackFromAdaptorReceived - Exit"));
	}


//
// CMMFDevSoundSession::PreemptionStartedCallbackReceived
// (other items were commented in a header).
//
void CMMFDevSoundSession::PreemptionStartedCallbackReceived()
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PreemptionStartedCallbackReceived - Enter"));
    // Solution: Enqueue any request that arrives before preemption is completed
	iOperationCompletePending = ETrue;
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PreemptionStartedCallbackReceived - Exit"));
	}

//
// CMMFDevSoundSession::PreemptionFinishedCallbackReceived
// (other items were commented in a header).
//
void CMMFDevSoundSession::PreemptionFinishedCallbackReceived(TBool aCanStartNewOperation)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PreemptionFinishedCallbackReceived - Enter"));
    if (iHandlingExtdCI)
        {
        // we are in the middle of handling a CI, so ignore - will handle later when unwinding
        SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PreemptionFinishedCallbackReceived - Exit. Exiting from if block for CI"));
		return;
        }
	iOperationCompletePending = EFalse;
	if ( aCanStartNewOperation && iQueuedRequests.Count() != 0 )
		{
		DequeueRequest();
		}
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::PreemptionFinishedCallbackReceived - Exit"));
	}

//
// CMMFDevSoundSession::PreemptionClash
// (other items were commented in a header).
//
void CMMFDevSoundSession::PreemptionClash()
	{
	//assumes sufficient space in the queue so ignore the return value
	iQueuedRequests.Insert(iRequestBeingServiced, 0);
	iPreemptionClash=ETrue;
	}

//
// CMMFDevSoundSession::PreemptionClashWithStateChange
// (other items were commented in a header).
//
void CMMFDevSoundSession::PreemptionClashWithStateChange()
	{
	#ifdef _DEBUG
		TMMFDevSoundRequest msg = iQueuedRequests[0];
		// message being removed should be the one we previously pushed via PreemptionClash()
		__ASSERT_DEBUG(iRequestBeingServiced==msg, Panic(ERequestBeingServicedMismatch));
	#endif
	// remove without processing request with AsynchronousOperationComplete() completing the message
	iQueuedRequests.Remove(0);
	iPreemptionClash=EFalse;
	}

//
// CMMFDevSoundSession::AdaptorControlsContext()
//

TBool CMMFDevSoundSession::AdaptorControlsContext() const
    {
    return !iHandlingExtdCI;
    }

MMMFDevSoundCustomInterfaceDeMuxPlugin* CMMFDevSoundSession::InterfaceFromUid(TUid aUid)
	{
	TInt count = iCustomInterfaceArray.Count();
	TInt id = aUid.iUid;
	MMMFDevSoundCustomInterfaceDeMuxPlugin* interface = NULL;
	for (TInt i = 0; i < count; i++)
		{
		if (id == iCustomInterfaceArray[i].iId.iUid)
			{
			interface = iCustomInterfaceArray[i].iInterface;
			break;
			}
		}
	return interface;
	}

//
// CMMFDevSoundSession::SendEventToClient
// (other items were commented in a header).
//
void CMMFDevSoundSession::SendEventToClient(const TMMFEvent& aEvent)
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::SendEventToClient - Enter"));
    TMMFDevSoundQueueItem item;
	item.iRequest = EMMFDevSoundProxySETCEvent;
	item.iErrorCode = KErrNone;
	item.iEventPckg() = aEvent;
	// assumes sufficient space in the queue so ignores the return value
	TInt err = iMsgQueue.Send(item);
    __ASSERT_DEBUG(err == KErrNone, Panic(EMsgQueueFailedToSendMsg));
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::SendEventToClient - Exit"));
	}

void CMMFDevSoundSession::AsynchronousOperationComplete(TInt aError, TBool aCanStartNewOperation)
	{
    __ASSERT_DEBUG(!iHandlingExtdCI, Panic(EUnexpectedAsyncOpCompleteHandlingCI));
        // when handling CIs we should not reach here

    TInt error = aError;
    if (!error)
        {
        // if have no error payload, use notified error. It will be KErrNone if not set, so just use.
        error = NotifiedError();
        }

	switch (iRequestBeingServiced.Type())
		{
		case TMMFDevSoundRequest::ESessionEvents:
			{
			SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x] ==== ClosingDueException ==== "));
			iOperationCompletePending = EFalse;
			if(iClosingWait->IsStarted())
				{
				iClosingWait->AsyncStop();
				}
			return;
			}
		// Complete the message for asynchronous requests
		case TMMFDevSoundRequest::EConfigure_Asynchronous:
		case TMMFDevSoundRequest::EAction_Asynchronous:
		case TMMFDevSoundRequest::EQuery_Asynchronous:
		case TMMFDevSoundRequest::ECustomInterfacesRelated:
			{
			if(iOperationCompletePending && aCanStartNewOperation)
				{
				if (iRequestBeingServiced.Function()==EMMFDevSoundProxyStop)
					{
					// flush the queue - will have removed any stale items added between initial call and MMRC's reaction
                    FlushQueuedRequests();
					FlushEventQueue();
					iChunk.Close();
					}
					
				if(iRequestBeingServiced.Function()==EMMFDevSoundProxyCapabilities)
					{
					TMMFDevSoundProxySettings devSoundSet;
					devSoundSet.iCaps = iDevSoundCapabilities;
					TMMFDevSoundProxySettingsPckg pckg(devSoundSet);
					MessageWrite(iRequestBeingServiced.Message(),TInt(2),pckg);
					}
				
				if(iRequestBeingServiced.Function()==EMMFDevSoundProxyCancelInitialize)
					{
					FlushEventQueue();
					}
				
				iRequestBeingServiced.Complete(error);
				iOperationCompletePending = EFalse;
				}
			}
			break;
		case TMMFDevSoundRequest::EAction_PseudoAsynchronous:
			{
			if(iOperationCompletePending && aCanStartNewOperation)
				{
				iOperationCompletePending = EFalse;
				}
			}
			break;
		case TMMFDevSoundRequest::EQuery_Synchronous:
		case TMMFDevSoundRequest::EConfigure_Synchronous:
		case TMMFDevSoundRequest::EBufferExchangeRelated:
			break;
		case TMMFDevSoundRequest::ECallBackType:
			{
			if(iOperationCompletePending && aCanStartNewOperation)
				{
				iOperationCompletePending = EFalse;
				}	
			}
			break;
		default:
			break;
		}
	
	if(iRequestBeingServiced.Type() == TMMFDevSoundRequest::ECallBackType )
	    {	    
	    SYMBIAN_DEBPRN2(_L("CMMFDevSoundSession[0x%x] AsynchronousOperationComplete CallbackPF=%d pending=%d"),
	            iRequestBeingServiced.IsCallBack(), iOperationCompletePending );
	    }
	else
	    {
	    SYMBIAN_DEBPRN3(_L("CMMFDevSoundSession[0x%x] AsynchronousOperationComplete %x pending=%d Requestype=%d"),
	            iRequestBeingServiced.Function(), iOperationCompletePending, iRequestBeingServiced.Type() );
	    }

	    
	if ( aCanStartNewOperation && iQueuedRequests.Count() != 0 )
		{
		DequeueRequest();
		}
	}

void CMMFDevSoundSession::DequeueRequest()
	{
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DequeueRequest - Enter"));
    iAsyncQueueStart->Cancel(); // if we're in here cancel any background request

	TMMFDevSoundRequest msg = iQueuedRequests[0];

	if (msg.IsCallBack() > 0)
		{
		iRequestBeingServiced.SetMessageCallback();
		//Call iPf function
		SYMBIAN_DEBPRN0(_L("\n CMMFDevSoundSession[0x%x] ======== Service a queued request\n"));
		if (msg.IsCallBack() == KCallbackProcessingFinished)
			{
			iQueuedRequests.Remove(0);
			DoProcessingFinished();
			}
		else if(msg.IsCallBack() == KCallbackProcessingUnitError)
		    {
		    iQueuedRequests.Remove(0);
		    DoProcessingError();
		    }

		}

	if (iQueuedRequests.Count()>0)
		{
		// Some rules about what request can be followed
		SYMBIAN_DEBPRN0(_L("\n CMMFDevSoundSession[0x%x]======== Flag can service new request\n"));
		iAsyncQueueStart->CallBack();
		}
	SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::DequeueRequest - Exit"));
	}
	
// 	AsyncQueueStartCallback


TInt CMMFDevSoundSession::AsyncQueueStartCallback(TAny* aPtr)
	{
	CMMFDevSoundSession* self = static_cast<CMMFDevSoundSession*>(aPtr);
	self->AsyncQueueStartCallback();
	return KErrNone;
	}
	
void CMMFDevSoundSession::AsyncQueueStartCallback()
	{
	SYMBIAN_DEBPRN0(_L("\n CMMFDevSoundSession[0x%x]======== Service a queued request\n"));
	TMMFDevSoundRequest msg = iQueuedRequests[0];
	iQueuedRequests.Remove(0);
	TInt err = KErrNone;
	TBool doRequest = ETrue;
	if(iPreemptionClash)
		{
		SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::AsyncQueueStartCallback - Re-applying client request due to Pre-emption clash"));
		iPreemptionClash=EFalse; // clear flag before reading next request in queue
		iAdapter->RollbackAdaptorActiveStateToBeforeCommit();
		if ((iRequestBeingServiced.Type() == TMMFDevSoundRequest::EAction_PseudoAsynchronous))
			{
		    doRequest = EFalse;
		    HandleAlreadyCompletedRequest();
			}
		}

	if (doRequest)
		{
		TRAP(err,DoServiceRequestL(msg.Message()));
		if(err != KErrNone)
			{
			msg.Complete(err);
			}
		}

	if (!iOperationCompletePending && iQueuedRequests.Count() != 0)
		{
		//dequeue next
		DequeueRequest();
		}
	}

// CMMFDevSoundSession::CustomInterface()
// Returns a pointer reference to custom interface implementation returned by
// adaptation::CustomInterface method.
// Note this method is called indirectly by CI server-side plugins - both DeMux and 
// CIServerExtension call this variously via MMMFDevSoundCustomInterfaceTarget or MCustomInterface 
//
TAny* CMMFDevSoundSession::CustomInterface(TUid aInterfaceId)
	{
	TInt err = DoSetClientConfig(); // if required, this will connect to MMRC etc
	if (err)
		{
		return NULL; // on any error, return NULL - not much more we can do
		}
	return iAdapter->CustomInterface(aInterfaceId);
	}

//
// CMMFDevSoundSession::DoProcessingFinished()
//
void CMMFDevSoundSession::DoProcessingFinished()
	{
    ResetNotifiedError();

	TBool asyncOperation = EFalse;
	//ProcessingFinished should never fail
	__ASSERT_ALWAYS(KErrNone, iAdapter->ProcessingFinishedReceived(asyncOperation));
	iOperationCompletePending = asyncOperation;
	if (iOperationCompletePending)
		{
		iRequestBeingServiced.SetMessageCallback();
		}
	}

//
// CMMFDevSoundSession::DoProcessingError()
//
void CMMFDevSoundSession::DoProcessingError()
    {
    ResetNotifiedError();

    TBool asyncOperation = EFalse;
    //ProcessingFinished should never fail
    __ASSERT_ALWAYS(KErrNone, iAdapter->ProcessingError(asyncOperation));
    iOperationCompletePending = asyncOperation;
    if (iOperationCompletePending)
        {
        iRequestBeingServiced.SetMessageCallback();
        }
    }

//
// CMMFDevSoundSession::DoSetClientConfigL()
// Sets client configuration information to Adaptation.
//
TInt CMMFDevSoundSession::DoSetClientConfig()
	{
	TInt err = KErrNone;
	if(!iSetClientConfigApplied)
		{
		CMMFDevSoundServer* server =
			const_cast<CMMFDevSoundServer*>(
				static_cast<const CMMFDevSoundServer*>(Server()));
			
		ASSERT(server); // session should always have a server!
		
		TProcessId actualProcessId = server->ActualProcessId();
		TProcessId processId = server->ProcessId();
		
		if (actualProcessId!=processId)
		    {
            // we have a differing actual process id, so pass that to the adaptor too
            err = iAdapter->SetClientConfig(actualProcessId, processId);
		    }
		else
		    {
            err = iAdapter->SetClientConfig(processId);
		    }

		if (!err)
			{
			iSetClientConfigApplied = ETrue;
			}
		}
	return err;
	}

// CMMFDevSoundSession::DoSetClientConfigL()
// Sets client configuration information to Adaptation.
//
void CMMFDevSoundSession::DoSetClientConfigL()
	{
	User::LeaveIfError(DoSetClientConfig());
	}

// 
// CMMFDevSoundSession::CreateChunk()
// Requests kernel to create global RChunk
// 
TInt CMMFDevSoundSession::CreateChunk(TMMFDevSoundProxyHwBufPckg& aBufPckg, TInt aRequestedSize)
	{
	TInt status(KErrNone);
	
	if ( iChunk.Handle() )
		{
		// If the DevSound Adaptation component requests a buffer size
		// that can fit into current chunk's size, then re-use chunk.
		if ( aRequestedSize <= iChunk.Size() )
			{
			if (iForceSendOfChunkHandle)
				{
				iForceSendOfChunkHandle = EFalse;
				aBufPckg().iChunkOp = EOpen;
				}
			else
				{
				aBufPckg().iChunkOp = ENull;
				}
			return status;
			}
		// The new request size exceeds the current chunk's area, close it. We
		// will be creating new one in the following sequences. Note we could
		// try to Adjust() the chunk, and see if the existing chunk could be
		// extended instead, but this is assumed too rare an event for this 
		// optimisation
		else
			{
			iChunk.Close();
			}
		}
	
	// Request kernel to create global RChunk if needed
	if ( !iChunk.Handle() )
		{
		status = iChunk.CreateGlobal(KNullDesC, aRequestedSize, aRequestedSize, EOwnerThread);
		if ( status == KErrNone )
			{
			aBufPckg().iChunkOp = EOpen;
			}
		else
			{
			aBufPckg().iChunkOp = ENull;
			}
		}
	iForceSendOfChunkHandle = EFalse;
	return status;
	}


// Custom Interface //
TInt CMMFDevSoundSession::DoOpenSlaveL(TUid aInterface, const TDesC8& aPackageBuf)
	{
	// it shouldn't be necessary to check if we have already instantiated this
	// interface since the client would already know - however this is something
	// that a licensee could implement if they required additional functionality
	// e.g. many : 1 mappings between client and DevSound.

	MMMFDevSoundCustomInterfaceDeMuxPlugin* ptr = NULL;
		
	// try and instantiate a plugin tunnelling
	// pair to support this Custom Interface
	ptr = iDeMuxUtility->CreateCustomInterfaceDeMuxL(aInterface);
	
	TInt handle = KNullHandle;
	
	if (ptr)
		{
		TMMFDevSoundCustomInterfaceDeMuxData data;
		data.iInterface = ptr;
		data.iId = aInterface;
			
		CleanupReleasePushL(*ptr);
			
		// setup demux plugin
		ptr->SetInterfaceTarget(this);
			
		// try and open interface
		// this will fetch the interface from the svr implementation
		ptr->DoOpenSlaveL(aInterface, aPackageBuf);
		User::LeaveIfError(iCustomInterfaceArray.Append(data));
			
		CleanupStack::Pop();	// ptr
			
		handle = iCustomInterfaceArray.Count();
		return handle;
		}

	// we couldn't set up the interface correctly so return a NULL
	// handle to the client
	return KNullHandle;
	}
	
void CMMFDevSoundSession::DoCloseSlaveL(TInt aHandle)
	{
	if (aHandle==KNullHandle)
		{
		// null-handle -> NOP
		return;
		}
		
	if (aHandle<KNullHandle || aHandle > iCustomInterfaceArray.Count())
		{
		// handle out of range - should not happen, but leave to show error
		User::Leave(KErrBadHandle);
		}
		
	TMMFDevSoundCustomInterfaceDeMuxData& data = iCustomInterfaceArray[aHandle-1];
	
	// close and delete the plugin
	MMMFDevSoundCustomInterfaceDeMuxPlugin* ptr = data.iInterface;
	ptr->DoCloseSlaveL(aHandle);
	ptr->Release();
	
	// clear the entry
	data.iInterface = NULL;
	data.iId.iUid = 0;
	}
	
TInt CMMFDevSoundSession::DoSendSlaveSyncCommandL(const RMmfIpcMessage& aMessage)
	{
	// use the demux utility to get the handle
	TMMFDevSoundCIMessageData data;
	iDeMuxUtility->GetSyncMessageDataL(aMessage, data);
	
	TInt handle = data.iHandle;
	
	if ((handle <= 0) || (handle > (iCustomInterfaceArray.Count())))
		{
		
		User::Leave(KErrBadHandle);
		}
	
	// call on demux plugin
	return iCustomInterfaceArray[handle-1].iInterface->DoSendSlaveSyncCommandL(aMessage);	
	}
	
TInt CMMFDevSoundSession::DoSendSlaveSyncCommandResultL(const RMmfIpcMessage& aMessage)
	{
	// use the demux utility to get the handle
	TMMFDevSoundCIMessageData data;
	iDeMuxUtility->GetSyncMessageDataL(aMessage, data);
	
	TInt handle = data.iHandle;
	
	if ((handle <= 0) || (handle > (iCustomInterfaceArray.Count())))
		{
		
		User::Leave(KErrBadHandle);
		}
	
	// call on demux plugin
	return iCustomInterfaceArray[handle-1].iInterface->DoSendSlaveSyncCommandResultL(aMessage);	
	}
	
void CMMFDevSoundSession::DoSendSlaveAsyncCommandL(const RMmfIpcMessage& aMessage)
	{
	// use the demux utility to get the handle
	TMMFDevSoundCIMessageData data;
	iDeMuxUtility->GetAsyncMessageDataL(aMessage, data);
	
	TInt handle = data.iHandle;
	
	if ((handle <= 0) || (handle > (iCustomInterfaceArray.Count())))
		{
		User::Leave(KErrBadHandle);
		}
	
	// call on demux plugin
	iCustomInterfaceArray[handle-1].iInterface->DoSendSlaveAsyncCommandL(aMessage);	
	}
	
void CMMFDevSoundSession::DoSendSlaveAsyncCommandResultL(const RMmfIpcMessage& aMessage)
	{
	// use the demux utility to get the handle
	TMMFDevSoundCIMessageData data;
	iDeMuxUtility->GetAsyncMessageDataL(aMessage, data);
	
	TInt handle = data.iHandle;
	
	if ((handle <= 0) || (handle > (iCustomInterfaceArray.Count())))
		{
		User::Leave(KErrBadHandle);
		}
	
	// call on demux plugin
	iCustomInterfaceArray[handle-1].iInterface->DoSendSlaveAsyncCommandResultL(aMessage);	
	}


TBool CMMFDevSoundSession::DoRegisterAsClientL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg buf;
	User::LeaveIfError(MessageRead(aMessage,0,buf));
	HBufC8* notificationRegistrationData = NULL;
	notificationRegistrationData = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLengthL(1)));
	TPtr8 dataPtr(notificationRegistrationData->Des());  	
	User::LeaveIfError(MessageRead(aMessage,1,dataPtr));
	DoSetClientConfigL();// added here instead of the CreateL()
	TInt err = KErrNone;
	err = iAdapter->RegisterAsClient(buf().iNotificationEventUid,dataPtr);
	CleanupStack::PopAndDestroy(1); // Notification Registeration data
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;		
		}
	return ETrue;
	}
	
TBool CMMFDevSoundSession::DoCancelRegisterAsClientL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg buf;
	User::LeaveIfError(MessageRead(aMessage,0,buf));
	TInt err = KErrNone;
	err = iAdapter->CancelRegisterAsClient(buf().iNotificationEventUid);
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;		
		}
	return ETrue;
	}

TBool CMMFDevSoundSession::DoGetResourceNotificationDataL(const RMmfIpcMessage& aMessage)
	{
	TMMFDevSoundProxySettingsPckg buf;
	User::LeaveIfError(MessageRead(aMessage,0,buf));
	HBufC8* notificationData = NULL;
	notificationData = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesMaxLengthL(2)));
	TPtr8 dataPtr(notificationData->Des());  	
	User::LeaveIfError(MessageRead(aMessage,2,dataPtr));
	TInt err = KErrNone;
	err = iAdapter->GetResourceNotificationData(buf().iNotificationEventUid,dataPtr);
	User::LeaveIfError(MessageWrite(aMessage,2,*notificationData));
	CleanupStack::PopAndDestroy(1); // Notification data
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;		
		}
	return ETrue;
	}

TBool CMMFDevSoundSession::DoWillResumePlayL(const RMmfIpcMessage& aMessage)
	{
	TInt err = KErrNone;
	err = iAdapter->WillResumePlay();
	if (err != KErrNone)
		{
		aMessage.Complete(err);
		return EFalse;		
		}
	return ETrue;
	}

TBool CMMFDevSoundSession::DoSetClientThreadInfoL(const RMmfIpcMessage& aMessage)
	{
	if(!iSetClientConfigApplied)
		{
		if (aMessage.HasCapability(ECapabilityMultimediaDD) && aMessage.HasCapability(ECapabilityUserEnvironment))
			{
			TPckgBuf<TThreadId> threadId;
			User::LeaveIfError(MessageRead(aMessage, 1, threadId));
			
			CMMFDevSoundServer* server = 
				const_cast<CMMFDevSoundServer*>(static_cast<const CMMFDevSoundServer*>(Server()));
			server->SetClientProcessIdL(threadId()); 
			}
		else
			{
			User::Leave(KErrPermissionDenied);
			}
		}
	else
		{
		User::Leave(KErrNotReady);
		}
	return ETrue;
	}
	
void CMMFDevSoundSession::Panic(TMMFDevSoundSessionPanicCodes aCode)
	{
    User::Panic(KMMFDevSoundSessionPanicCategory, aCode);
	}

void CMMFDevSoundSession::BufferErrorEvent()
	{
	// this will generate an processing error event and callback
	iAdapter->BufferErrorEvent();
	}

void CMMFDevSoundSession::FlushQueuedRequests()
    {
    for (TInt queueIndex = (iQueuedRequests.Count() - 1); queueIndex >= 0; --queueIndex)
        {
        if ((iQueuedRequests[queueIndex].Type() == TMMFDevSoundRequest::ESessionEvents) && 
                (iQueuedRequests[queueIndex].Function() == RMessage2::EDisConnect))
            {
            continue;
            }
        iQueuedRequests.Remove(queueIndex);
        }    
    }

TInt CMMFDevSoundSession::MessageRead(const RMmfIpcMessage& aMessage, TInt aParam, TDes8& aResult)
    {
    if (!iDisconnecting)
        {
        return MmfMessageUtil::Read(aMessage, aParam, aResult);    
        }
    return KErrBadHandle;
    }

TInt CMMFDevSoundSession::MessageRead(const RMmfIpcMessage& aMessage, TInt aParam, TDes16& aResult)
    {
    if (!iDisconnecting)
        {
        return aMessage.Read(aParam, aResult);    
        }
    return KErrBadHandle;
    }

TInt CMMFDevSoundSession::MessageWrite(const RMmfIpcMessage& aMessage, TInt aParam, const TDesC8& aValue)
    {
    if (!iDisconnecting)
        {
        return MmfMessageUtil::Write(aMessage, aParam, aValue);
        }
    return KErrBadHandle;
    }

void CMMFDevSoundSession::ResetNotifiedError()
// called at beginning of commit cycle, so any error will be from callbacks
    {
    SYMBIAN_DEBPRN0(_L("CMMFDevSoundSession[0x%x]::ResetNotifiedError"));
    iNotifiedError = KErrNone;
    }

TInt CMMFDevSoundSession::NotifiedError() const
// NotifiedError property
    {
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::NotifiedError(%d)"), iNotifiedError);
    return iNotifiedError;
    }

void CMMFDevSoundSession::NotifyError(TInt aError)
// cache notified error
    {
    SYMBIAN_DEBPRN1(_L("CMMFDevSoundSession[0x%x]::NotifyError(%d)"), aError);
    iNotifiedError = aError;
    }

// End of file
