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

// devsoundadaptationinfoimpl.cpp

//

// INCLUDE FILES

#include <e32base.h>

#include <e32std.h>

#include <mmf/plugin/mmfplugininterfaceuids.hrh> // for KMmfUidPluginInterfaceHwDevice

#include <mm/mmcleanup.h> 						//needed for CleanupResetAndDestroyPushL()

#include "devsoundadaptationinfoimplbody.h"

#include "devsoundadaptationinfoconsts.h"

#include <a3f/mdevsoundadaptationinfoobserver.h>

#include <a3f/audioformatuids.h>

const TInt KHwDeviceDefaultDataLength= 9;

//-------------------------------------------------------------------

// 	CA3FDevSoundAdaptationInfoImpl::CA3FDevSoundAdaptationInfoImpl

//	C++ default constructor.

//-------------------------------------------------------------------

//

CA3FDevSoundAdaptationInfoImpl::CBody* CA3FDevSoundAdaptationInfoImpl::CBody::NewL(MA3FDevSoundAdaptationInfoObserver& aAdaptationInfoObserver, CFourCCConvertor& aFourCcConvertor)

	{

	CBody* self = new (ELeave) CBody;

	CleanupStack::PushL(self);

	self->ConstructL(aAdaptationInfoObserver, aFourCcConvertor);

	CleanupStack::Pop(self);

	return self;

	}

//-------------------------------------------------------------------

// 	CA3FDevSoundAdaptationInfoImpl::CA3FDevSoundAdaptationInfoImpl

//	C++ default constructor.

//-------------------------------------------------------------------

//

CA3FDevSoundAdaptationInfoImpl::CBody::CBody(): CActive(EPriorityStandard)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody()::CBody() *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CActiveScheduler::Add(this);

	DP_OUT();

	}

//----------------------------------------------------

// 	CA3FDevSoundAdaptationInfoImpl::ConstructL

// 	Symbian 2nd phase constructor can leave.

//----------------------------------------------------

//

void CA3FDevSoundAdaptationInfoImpl::CBody::ConstructL(MA3FDevSoundAdaptationInfoObserver& aAdaptationInfoObserver, CFourCCConvertor& aFourCcConvertor)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iAdaptationInfoObserver = &aAdaptationInfoObserver;

	iFourCcConvertor = &aFourCcConvertor;

	DP_OUT();

	}

//--------------------------------------------------------------

//	CA3FDevSoundAdaptationInfoImpl::~CA3FDevSoundAdaptationInfoImpl

//	Destructor

//--------------------------------------------------------------

//

CA3FDevSoundAdaptationInfoImpl::CBody::~CBody()

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::~CBody *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	}

//---------------------------------------------------------

// 	CA3FDevSoundAdaptationInfoImpl::CBody::RequestMaxGain

// 	Retrieves Maximum Valid Gain/Volume

//---------------------------------------------------------

//

TInt CA3FDevSoundAdaptationInfoImpl::CBody::RequestMaxGain(TUid aCodecType)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::RequestMaxGain *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iCodecType = aCodecType;

	iMaxGainRequested = ETrue;

	// Simulate an asyncronous response

	if (!IsActive())

		{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		SetActive();

		}

	DP0_RET(KErrNone, "%d");

	}

//-----------------------------------------------------

// 	CA3FDevSoundAdaptationInfoImpl::CBody::RequestSupportedFormatsL

//  Retrieves supported formats (in this version hwDevices).

//-----------------------------------------------------

//

TInt CA3FDevSoundAdaptationInfoImpl::CBody::RequestSupportedFormats(TUid aCodecType, RArray<TUid>& aSupportedFormats)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::RequestSupportedFormats *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err=KErrNone;

	iCodecType = aCodecType;

	TRAP(err, ReadSupportedFormatsL(aCodecType, aSupportedFormats));

	if(err==KErrNone)

		{

		iFormatsRequested = ETrue;

		// Simulate an asyncronous response

		if (!IsActive())

			{

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrNone);

			SetActive();

			}

		}

	DP0_RET(err, "%d");

	}

TInt CA3FDevSoundAdaptationInfoImpl::CBody::Extension_(TUint aExtensionId, TAny*& aExtPtr, TAny*)

	{

	if (aExtensionId == KTruePauseCustomInterfaceTypeUid.iUid)

		{

		aExtPtr = static_cast<MTruePauseCustomInterface*>(this);

		return KErrNone;

		}

	else

		{

		return CActive::Extension_(aExtensionId, aExtPtr, NULL);

		}

	}

// from MTruePauseCustomInterface

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::IsResumeSupported

// ---------------------------------------------------------------------------

TBool CA3FDevSoundAdaptationInfoImpl::CBody::IsResumeSupported(TUid aCodecType, TUid aFormat)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::IsTruePauseSupported *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	const TUid supportedDecoders [] = 

		{

		KUidFormatPCM16, 

		KUidFormatPCMU16B, 

		KUidFormatPCMU16,

		KUidFormatPCM16B, 

		KUidFormatPCM8, 

		KUidFormatPCMU8, 

		KUidFormatAlaw,

		KUidFormatMulaw,

		KUidFormatGSM610,

		KUidFormatIMAADPCM,

		KUidFormatTone,

		KNullUid,  // Indicates end of array

		};

	TBool supported = EFalse;

	// PCM16 Encoder

	if(aFormat == KUidFormatPCM16 && aCodecType == KUidAudioEncoder)

		{

		supported = ETrue;

		}

	// Only certain decoders

	else if(aCodecType == KUidAudioDecoder)

		{

		TInt i = 0;

		TUid supportedDecoderUid = supportedDecoders[i];

		do

			{

			if (supportedDecoderUid == aFormat)

				{

				supported = ETrue;

				break;

				}

			supportedDecoderUid = supportedDecoders[i++];

			}

		while(supportedDecoderUid != KNullUid);

		}

	DP0_RET(supported, "%d");

	}

//From CActive

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::RunL

// ---------------------------------------------------------------------------

void CA3FDevSoundAdaptationInfoImpl::CBody::RunL()

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::RunL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	if(iMaxGainRequested)

		{

		TInt maxgain = 0;

		if (iCodecType == KUidAudioDecoder)

			{

			maxgain = DevSoundAdaptationInfoConsts::MaxVolume();

			}

		else if (iCodecType == KUidAudioEncoder)

			{

			maxgain = DevSoundAdaptationInfoConsts::MaxGain();

			}

		else

			{

			err = KErrArgument;

			}

		iMaxGainRequested = EFalse;

		// Send the callback

		iAdaptationInfoObserver->RequestMaxGainComplete(iCodecType, err, maxgain);

		}

	if(iFormatsRequested)

		{

		err = KErrNone;

		if(iCodecType != KUidAudioDecoder && iCodecType != KUidAudioEncoder)

			{

			err = KErrArgument;

			}

		iFormatsRequested = EFalse;

		// Send the callback

		iAdaptationInfoObserver->RequestSupportedFormatsComplete(iCodecType, err);

		}

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::RunError

// ---------------------------------------------------------------------------

TInt CA3FDevSoundAdaptationInfoImpl::CBody::RunError(TInt aError)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::RunError *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP0_RET(aError, "%d");

	}

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::DoCancel

// ---------------------------------------------------------------------------

void CA3FDevSoundAdaptationInfoImpl::CBody::DoCancel()

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::DoCancel *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::ReadSupportedFormats

// ---------------------------------------------------------------------------

void CA3FDevSoundAdaptationInfoImpl::CBody::ReadSupportedFormatsL(TUid aCodecType, RArray<TUid>& aSupportedFormats)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::ReadSupportedFormatsL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	RArray<TFourCC> supportedDataTypes;

	CleanupClosePushL(supportedDataTypes);

	SeekHwDevicePluginsL(supportedDataTypes, aCodecType);

	TInt maxFourCCElements = supportedDataTypes.Count();

	//clear any existing data in iSupportedFormats array

	aSupportedFormats.Reset();

	for(TInt typeIndex=0; typeIndex<maxFourCCElements; typeIndex++)

		{

		TUid format;

		TInt error = iFourCcConvertor->FourCCToFormat(supportedDataTypes[typeIndex], format);

		if(error == KErrNone)

			{

			aSupportedFormats.AppendL(format);

			}

		}

	CleanupStack::PopAndDestroy(&supportedDataTypes);

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::SeekHwDevicePluginsL

// This method looks for hwDevicePlugins that support the codec given in aCodecType

// which must be either EMMFStatePlaying or EMMFStateRecording.

// For each HwDevice plugin found the datatype as indicated by its fourCC code

// from the default_data field in the resource file is added to the array of

// aSupportedDataTypes

// -----------------------------------------------------------------------------

//

void CA3FDevSoundAdaptationInfoImpl::CBody::SeekHwDevicePluginsL(

	RArray<TFourCC>& aSupportedDataTypes,

	TUid aCodecType)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::SeekHwDevicePluginsL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(aCodecType == KUidAudioDecoder || aCodecType == KUidAudioEncoder);

	//clear any existing data in aSupportedDataTypes array

	aSupportedDataTypes.Reset();

	// Array to return hw device plugin resource info(place on cleanupstack

	// _after_ ListImplementationsL() )

	RImplInfoPtrArray plugInArray;

	CleanupResetAndDestroyPushL(plugInArray);

	TUid KUidMmfHWPluginInterfaceCodec = {KMmfUidPluginInterfaceHwDevice};

	REComSession::ListImplementationsL(KUidMmfHWPluginInterfaceCodec, plugInArray);

	TUint numberOfHwDevicePlugins = plugInArray.Count();

	// if there are hwdevice plugin resource entries then scan entries

	// matching on a datatype of pcm16 as the destination datatype for play and

	// the source datatype for record. If a match is found and isn't already in

	// the list of supported data types, then add it to the list

	if (numberOfHwDevicePlugins > 0)

		{

		CImplementationInformation* hwDeviceResourceEntry = NULL;

		_LIT8(KPCM16FourCCString, " P16");

		// check each resource entry for dst 4CC = P16 for play and

		// src 4CC = P16 for record

		for (TUint hwDeviceEntry = 0; hwDeviceEntry<numberOfHwDevicePlugins; hwDeviceEntry++)

			{

			hwDeviceResourceEntry = plugInArray[hwDeviceEntry];

			TFourCC fourCCLeft;

			TFourCC fourCCRight;

			ReadFourCC(hwDeviceResourceEntry, fourCCLeft, fourCCRight);

			TFourCC fourCCPCM16(KPCM16FourCCString);		

			if(aCodecType == KUidAudioDecoder)

				{

				if(IsDataTypeMatch(fourCCPCM16, fourCCRight))

					{

					if(!FourCCExists(aSupportedDataTypes, fourCCLeft))

						{

						aSupportedDataTypes.AppendL(fourCCLeft);

						}

					}

				}

			else if (aCodecType == KUidAudioEncoder)

				{

				if(IsDataTypeMatch(fourCCPCM16, fourCCLeft))

					{

					if(!FourCCExists(aSupportedDataTypes, fourCCRight))

						{

						aSupportedDataTypes.AppendL(fourCCRight);

						}

					}	

				}			

			}

		}

	CleanupStack::PopAndDestroy(&plugInArray);

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::FourCCExists

// ---------------------------------------------------------------------------

TBool CA3FDevSoundAdaptationInfoImpl::CBody::FourCCExists(RArray<TFourCC>& aSupportedDataTypes, TFourCC aFourCCEntry)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::FourCCExists *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TBool alreadyExists = EFalse;

	for (TUint fourCCEntryNumber=0; fourCCEntryNumber< aSupportedDataTypes.Count(); fourCCEntryNumber++)

		{

		if (aSupportedDataTypes[fourCCEntryNumber] == aFourCCEntry)

			{

			// we already have this 4CC in the supported data types

			alreadyExists = ETrue;

			break;

			}

		}

	DP0_RET(alreadyExists, "0x%x");

	}

// ---------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::CBody::ReadFourCC

// ---------------------------------------------------------------------------

void CA3FDevSoundAdaptationInfoImpl::CBody::ReadFourCC(CImplementationInformation* aHwDeviceResourceEntry, TFourCC& aFourCCLeft, TFourCC& aFourCCRight)

	{

	DP_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::ReadFourCC *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TPtrC8 fourCCPtr(0,0);

	// Check for resource entry lenght since for HwDeviceAdaptor it is just "*"

	if (aHwDeviceResourceEntry->DataType().Length()>=KHwDeviceDefaultDataLength)

		{

		// datatype supported 4CC is left 4 chars

		fourCCPtr.Set(aHwDeviceResourceEntry->DataType().Left(KFOURCCLENGTH));

		aFourCCLeft.Set(fourCCPtr);

		// datatype supported 4CC is right 4 chars

		fourCCPtr.Set(aHwDeviceResourceEntry->DataType().Right(KFOURCCLENGTH));

		aFourCCRight.Set(fourCCPtr);

		}

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CA3FDevSoundAdaptationInfoImpl::IsDataTypeMatch

// -----------------------------------------------------------------------------

TBool CA3FDevSoundAdaptationInfoImpl::CBody::IsDataTypeMatch(TFourCC aFourCCPCM16,TFourCC aFourCC)

	{

	DP_STATIC_CONTEXT(CA3FDevSoundAdaptationInfoImpl::CBody::IsDataTypeMatch *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TBool match = EFalse;

	if(aFourCCPCM16 == aFourCC)

		{

		match = ETrue;

		}

	DP0_RET(match, "0x%x");

	}

// End of file