// 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)

#else

#define SYMBIAN_DEBPRN0(str)

#define SYMBIAN_DEBPRN1(str, val1)

#define SYMBIAN_DEBPRN2(str, val1, val2)

#endif //_DEBUG

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

//at the same time (maximum).

const TInt KMaxQueueRequest = 3;

//	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();

	}

//

// 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(), iOperationCompletePending || iAsyncQueueStart->IsActive());

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

		{

		// 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)

	{

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

	TMMFMessageDestinationPckg destinationPckg;

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

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

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

		{

		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);

			}

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

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

		if(iOperationCompletePending)

			{

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

			iRequestBeingServiced.SetMessage(aMessage);

			}

		}

	else

		{

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

		TInt err = KErrNotSupported;

		if (iCIExtension)

			{

			iHandlingExtdCI = ETrue;

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

			if (err2)

				{

				err = err2;

				}

			iOperationCompletePending = EFalse;

			iHandlingExtdCI = EFalse;

			}

		if (err != KErrNone)

			{

			// Not been handled, the request is not supported

			aMessage.Complete(KErrNotSupported);

			}

		}

	}

void CMMFDevSoundSession::EnqueueRequest(const RMmfIpcMessage& aMessage)

	{

	// Encapsule the request

	TMMFDevSoundRequest request;

	request.SetMessage(aMessage);

	// Append

	TInt error = iQueuedRequests.Append(request);

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

	}

//

// 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)

	{

	User::LeaveIfError(err);

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

	TMMFDevSoundProxySettingsPckg devSoundBuf;

	MmfMessageUtil::ReadL(aMessage,1,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::DoInitialize2L

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