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

    TMMFMessageDestinationPckg destinationPckg;

	MmfMessageUtil::ReadL(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 (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();

            }

	    }

	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;