// Copyright (c) 2002-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 <mmf/common/mmfaudio.h>

#include "mmfstandardcustomcommands.h"

#include "MMFVideoFrameMessage.h"

#include "MMFSCCPanicCodes.h"

#include <badesca.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfstandardcustomcommandsenums.h>

#include <mmf/common/mmfstandardcustomcommandsimpl.h>

#include <mmf/common/mmfvideoenums.h>

#endif

const TInt KBufExpandSize8 = 8;//two TInts!

const TInt KBufExpandSize32 = 32;

const TInt KBufMimeTypeGranularity = 4;

const TInt KMaxMimeTypeLength = 256;

class TMimeTypeBufferInfo 

	{

public:

	TInt32 count;

	TInt32 bufferLen;

	};

EXPORT_C RMMFAudioPlayDeviceCustomCommands::RMMFAudioPlayDeviceCustomCommands(RMMFController& aController) :

	RMMFCustomCommandsBase(aController, KUidInterfaceMMFAudioPlayDevice)

	{

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::SetVolume(TInt aVolume) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iVolume = aVolume;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioPlayDeviceSetVolume, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::GetMaxVolume(TInt& aMaxVolume) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error =  iController.CustomCommandSync(iDestinationPckg, 

												EMMFAudioPlayDeviceGetMaxVolume, 

												KNullDesC8,

												KNullDesC8,

												configPackage);

	if (!error)

		aMaxVolume = configPackage().iMaxVolume;

	return error;

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::GetVolume(TInt& aVolume) const 

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error =  iController.CustomCommandSync(iDestinationPckg, 

												EMMFAudioPlayDeviceGetVolume, 

												KNullDesC8,

												KNullDesC8,

												configPackage);

	if (!error)

		aVolume = configPackage().iVolume;

	return error;

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iRampDuration = aRampDuration;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioPlayDeviceSetVolumeRamp, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::SetBalance(TInt aBalance) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iBalance = aBalance;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioPlayDeviceSetBalance, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioPlayDeviceCustomCommands::GetBalance(TInt& aBalance) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error =  iController.CustomCommandSync(iDestinationPckg, 

												EMMFAudioPlayDeviceGetBalance, 

												KNullDesC8,

												KNullDesC8,

												configPackage);

	if (!error)

		aBalance = configPackage().iBalance;

	return error;

	}

EXPORT_C CMMFAudioPlayDeviceCustomCommandParser* CMMFAudioPlayDeviceCustomCommandParser::NewL(MMMFAudioPlayDeviceCustomCommandImplementor& aImplementor)

	{

	return new(ELeave) CMMFAudioPlayDeviceCustomCommandParser(aImplementor);

	}

EXPORT_C CMMFAudioPlayDeviceCustomCommandParser::~CMMFAudioPlayDeviceCustomCommandParser()

	{

	}

CMMFAudioPlayDeviceCustomCommandParser::CMMFAudioPlayDeviceCustomCommandParser(MMMFAudioPlayDeviceCustomCommandImplementor& aImplementor) : 

	CMMFCustomCommandParserBase(KUidInterfaceMMFAudioPlayDevice),

	iImplementor(aImplementor)

	{

	}

void CMMFAudioPlayDeviceCustomCommandParser::HandleRequest(TMMFMessage& aMessage)

	{

	if (aMessage.Destination().InterfaceId() == KUidInterfaceMMFAudioPlayDevice)

		{

		TRAPD(error, DoHandleRequestL(aMessage));

		if (error)

			aMessage.Complete(error);

		}

	else

		{

		aMessage.Complete(KErrNotSupported);

		}

	}

void CMMFAudioPlayDeviceCustomCommandParser::DoHandleRequestL(TMMFMessage& aMessage)

	{

	TBool complete = ETrue;

	switch (aMessage.Function())

		{

	case EMMFAudioPlayDeviceSetVolume:

		complete = DoSetVolumeL(aMessage);

		break;

	case EMMFAudioPlayDeviceGetMaxVolume:

		complete = DoGetMaxVolumeL(aMessage);

		break;

	case EMMFAudioPlayDeviceGetVolume:

		complete = DoGetVolumeL(aMessage);

		break;

	case EMMFAudioPlayDeviceSetVolumeRamp:

		complete = DoSetVolumeRampL(aMessage);

		break;

	case EMMFAudioPlayDeviceSetBalance:

		complete = DoSetBalanceL(aMessage);

		break;

	case EMMFAudioPlayDeviceGetBalance:

		complete = DoGetBalanceL(aMessage);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	if (complete)

		aMessage.Complete(KErrNone);

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoSetVolumeL(TMMFMessage& aMessage)

	{

	TPckgBuf<TMMFAudioConfig> pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MapdSetVolumeL(pckg().iVolume);

	return ETrue;

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoGetMaxVolumeL(TMMFMessage& aMessage)

	{

	TInt maxVol = 0;

	iImplementor.MapdGetMaxVolumeL(maxVol);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iMaxVolume = maxVol;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoGetVolumeL(TMMFMessage& aMessage)

	{

	TInt vol = 0;

	iImplementor.MapdGetVolumeL(vol);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iVolume = vol;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoSetVolumeRampL(TMMFMessage& aMessage)

	{

	TPckgBuf<TMMFAudioConfig> pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MapdSetVolumeRampL(pckg().iRampDuration);

	return ETrue;

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoSetBalanceL(TMMFMessage& aMessage)

	{

	TPckgBuf<TMMFAudioConfig> pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MapdSetBalanceL(pckg().iBalance);

	return ETrue;

	}

TBool CMMFAudioPlayDeviceCustomCommandParser::DoGetBalanceL(TMMFMessage& aMessage)

	{

	TInt bal = 0;

	iImplementor.MapdGetBalanceL(bal);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iBalance = bal;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

EXPORT_C RMMFAudioRecordDeviceCustomCommands::RMMFAudioRecordDeviceCustomCommands(RMMFController& aController) :

	RMMFCustomCommandsBase(aController, KUidInterfaceMMFAudioRecordDevice)

	{

	}

EXPORT_C TInt RMMFAudioRecordDeviceCustomCommands::SetGain(TInt aGain) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iGain = aGain;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioRecordDeviceSetGain, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioRecordDeviceCustomCommands::GetMaxGain(TInt& aMaxGain) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error = iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioRecordDeviceGetMaxGain, 

										 KNullDesC8,

										 KNullDesC8,

										 configPackage);

	if (!error)

		aMaxGain = configPackage().iMaxGain;

	return error;

	}

EXPORT_C TInt RMMFAudioRecordDeviceCustomCommands::GetGain(TInt& aGain) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error = iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioRecordDeviceGetGain, 

										 KNullDesC8,

										 KNullDesC8,

										 configPackage);

	if (!error)

		aGain = configPackage().iGain;

	return error;

	}

EXPORT_C TInt RMMFAudioRecordDeviceCustomCommands::SetBalance(TInt aBalance) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iBalance = aBalance;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioRecordDeviceSetBalance, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioRecordDeviceCustomCommands::GetBalance(TInt& aBalance) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error =  iController.CustomCommandSync(iDestinationPckg, 

												EMMFAudioRecordDeviceGetBalance, 

												KNullDesC8,

												KNullDesC8,

												configPackage);

	if (!error)

		aBalance = configPackage().iBalance;

	return error;

	}

EXPORT_C CMMFAudioRecordDeviceCustomCommandParser* CMMFAudioRecordDeviceCustomCommandParser::NewL(MMMFAudioRecordDeviceCustomCommandImplementor& aImplementor) 

	{

	return new(ELeave) CMMFAudioRecordDeviceCustomCommandParser(aImplementor);

	}

CMMFAudioRecordDeviceCustomCommandParser::CMMFAudioRecordDeviceCustomCommandParser(MMMFAudioRecordDeviceCustomCommandImplementor& aImplementor) :

	CMMFCustomCommandParserBase(KUidInterfaceMMFAudioRecordDevice),

	iImplementor(aImplementor)

	{

	}

EXPORT_C CMMFAudioRecordDeviceCustomCommandParser::~CMMFAudioRecordDeviceCustomCommandParser()

	{

	}

void CMMFAudioRecordDeviceCustomCommandParser::HandleRequest(TMMFMessage& aMessage)

	{

	if (aMessage.Destination().InterfaceId() == KUidInterfaceMMFAudioRecordDevice)

		{

		TRAPD(error, DoHandleRequestL(aMessage));

		if (error)

			aMessage.Complete(error);

		}

	else

		{

		aMessage.Complete(KErrNotSupported);

		}

	}

void CMMFAudioRecordDeviceCustomCommandParser::DoHandleRequestL(TMMFMessage& aMessage)

	{

	TBool complete = ETrue;

	switch (aMessage.Function())

		{

	case EMMFAudioRecordDeviceSetGain:

		complete = DoSetGainL(aMessage);

		break;

	case EMMFAudioRecordDeviceGetMaxGain:

		complete = DoGetMaxGainL(aMessage);

		break;

	case EMMFAudioRecordDeviceGetGain:

		complete = DoGetGainL(aMessage);

		break;

	case EMMFAudioRecordDeviceSetBalance:

		complete = DoSetBalanceL(aMessage);

		break;

	case EMMFAudioRecordDeviceGetBalance:

		complete = DoGetBalanceL(aMessage);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	if (complete)

		aMessage.Complete(KErrNone);

	}

TBool CMMFAudioRecordDeviceCustomCommandParser::DoSetGainL(TMMFMessage& aMessage)

	{

	TPckgBuf<TMMFAudioConfig> pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MardSetGainL(pckg().iGain);

	return ETrue;

	}

TBool CMMFAudioRecordDeviceCustomCommandParser::DoGetMaxGainL(TMMFMessage& aMessage)

	{

	TInt maxGain = 0;

	iImplementor.MardGetMaxGainL(maxGain);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iMaxGain = maxGain;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

TBool CMMFAudioRecordDeviceCustomCommandParser::DoGetGainL(TMMFMessage& aMessage)

	{

	TInt gain = 0;

	iImplementor.MardGetGainL(gain);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iGain = gain;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

TBool CMMFAudioRecordDeviceCustomCommandParser::DoSetBalanceL(TMMFMessage& aMessage)

	{

	TPckgBuf<TMMFAudioConfig> pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MardSetBalanceL(pckg().iBalance);

	return ETrue;

	}

TBool CMMFAudioRecordDeviceCustomCommandParser::DoGetBalanceL(TMMFMessage& aMessage)

	{

	TInt balance = 0;

	iImplementor.MardGetBalanceL(balance);

	TPckgBuf<TMMFAudioConfig> pckg;

	pckg().iBalance = balance;

	aMessage.WriteDataToClientL(pckg);

	return ETrue;

	}

EXPORT_C RMMFAudioPlayControllerCustomCommands::RMMFAudioPlayControllerCustomCommands(RMMFController& aController) :

	RMMFCustomCommandsBase(aController, KUidInterfaceMMFAudioPlayController)

	{

	}

EXPORT_C TInt RMMFAudioPlayControllerCustomCommands::SetPlaybackWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	configPackage().iStartPosition = aStart;

	configPackage().iEndPosition = aEnd;

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioPlayControllerSetPlaybackWindow, 

										 configPackage,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioPlayControllerCustomCommands::DeletePlaybackWindow()

	{

	return iController.CustomCommandSync(iDestinationPckg, 

										 EMMFAudioPlayControllerDeletePlaybackWindow, 

										 KNullDesC8,

										 KNullDesC8);

	}

EXPORT_C TInt RMMFAudioPlayControllerCustomCommands::GetLoadingProgress(TInt& aPercentageComplete) const

	{

	TPckgBuf<TMMFAudioConfig> configPackage;

	TInt error =  iController.CustomCommandSync(iDestinationPckg, 

												EMMFAudioPlayControllerGetLoadingProgress, 

												KNullDesC8,

												KNullDesC8,

												configPackage);

	if (!error)

		aPercentageComplete = configPackage().iLoadingCompletePercentage;

	return error;

	}

EXPORT_C CMMFAudioPlayControllerCustomCommandParser* CMMFAudioPlayControllerCustomCommandParser::NewL(MMMFAudioPlayControllerCustomCommandImplementor& aImplementor)

	{

	return new(ELeave) CMMFAudioPlayControllerCustomCommandParser(aImplementor);

	}

CMMFAudioPlayControllerCustomCommandParser::CMMFAudioPlayControllerCustomCommandParser(MMMFAudioPlayControllerCustomCommandImplementor& aImplementor) :

	CMMFCustomCommandParserBase(KUidInterfaceMMFAudioPlayController),

	iImplementor(aImplementor)

	{

	}

EXPORT_C CMMFAudioPlayControllerCustomCommandParser::~CMMFAudioPlayControllerCustomCommandParser()

	{

	}

void CMMFAudioPlayControllerCustomCommandParser::HandleRequest(TMMFMessage& aMessage)

	{

	if (aMessage.Destination().InterfaceId() == KUidInterfaceMMFAudioPlayController)

		{

		TRAPD(error, DoHandleRequestL(aMessage));

		if (error)

			aMessage.Complete(error);

		}

	else

		{

		aMessage.Complete(KErrNotSupported);

		}

	}

void CMMFAudioPlayControllerCustomCommandParser::DoHandleRequestL(TMMFMessage& aMessage)

	{

	TBool complete = ETrue;

	switch (aMessage.Function())

		{

	case EMMFAudioPlayControllerSetPlaybackWindow:

		complete = DoSetPlaybackWindowL(aMessage);

		break;

	case EMMFAudioPlayControllerDeletePlaybackWindow:

		complete = DoDeletePlaybackWindowL(aMessage);

		break;

	case EMMFAudioPlayControllerGetLoadingProgress:

		complete = DoGetLoadingProgressL(aMessage);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}