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

//

#include "sounddevicebody.h"

#include <a3f/mmfdevsoundcustominterfaceextensions.h>

#include <mmf/plugin/mmfdevsoundcustominterface.hrh>

#include <mm/mmpluginutils.h>

/*

 *  Default Constructor.

 */

CMMFDevSound::CBody::CBody()

	{

	}

/*

 *  Destructor.

 *

 *  Deletes all objects and releases all resource owned by this

 *  instance.

 */

CMMFDevSound::CBody::~CBody()

	{

	// Clear the array of custom interfaces

	TInt numIfs = iCustomInterfaceArray.Count();

	for (TInt i = 0; i < numIfs; i++)

		{

		if(iCustomInterfaceArray[i].iInterface)

			{

			iCustomInterfaceArray[i].iInterface->Release();

			}

		}

	iCustomInterfaceArray.Reset();

	iCustomInterfaceArray.Close();

	// Delete the MUX utility

	delete iMuxUtility;

	if (iDevSoundProxy)

		{

		iDevSoundProxy->Close();

		delete iDevSoundProxy;

		}

	// Delete the CI extension

	if (iCIExtension)

		{

		iCIExtension->Release();

		}

	}

/*

 *  Constructs, and returns a pointer to, a new CMMFDevSound::CBody object.

 *

 *  Leaves on failure.

 */

CMMFDevSound::CBody* CMMFDevSound::CBody::NewL()

	{

	CBody* self = new (ELeave) CBody;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/*

 *  Second phase constructor.

 */

void CMMFDevSound::CBody::ConstructL()

	{

	// all these data properties should be NULL, but add ASSERTs to verify.

	ASSERT(!iDevSoundProxy);

	iDevSoundProxy = new (ELeave) RMMFDevSoundProxy();

	TInt err = iDevSoundProxy->Open();

	User::LeaveIfError(err);

	User::LeaveIfError(iDevSoundProxy->PostOpen());

	// create Custom Interface MUX utility

	iMuxUtility = CMMFDevSoundCIMuxUtility::NewL(this);

	// Create Custom Interface extension

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	TUid interfaceUid = {KUidDevSoundCIClientExtension};

	REComSession::ListImplementationsL(interfaceUid, pluginArray);

	TUid destructorKey;

	if (pluginArray.Count() > 0)

		{

		// One or more exists - use the 1st one found

		iCIExtension = static_cast<MDevSoundCIClientExtension*>

						(REComSession::CreateImplementationL(pluginArray[0]->ImplementationUid(), destructorKey));

		}

	CleanupStack::PopAndDestroy(&pluginArray);

	if (iCIExtension)

		{

		// Extension exists. Complete the setup

		iCIExtension->PassDestructorKey(destructorKey);

		User::LeaveIfError(iCIExtension->Setup(*iDevSoundProxy));

		}

	}

/*

 *  CMMFDevSound::InitializeL

 *

 *  Initializes CMMFDevSound object. On completion of Initialization will

 *  call InitializeComplete() on aDevSoundObserver.

 *

 *  Leaves on failure.

 *

 *  @param  MDevSoundObserver&

 *          A reference to the DevSound Observer instance.

 *

 *  @param  TMMFState

 *          A mode for which this object will be used.

 */

void CMMFDevSound::CBody::InitializeL(MDevSoundObserver& aDevSoundObserver,

                                      TMMFState aMode)

	{

	ASSERT(iDevSoundProxy);

	iDevSoundProxy->InitializeL(aDevSoundObserver, aMode, *this);

	}

/*

 *  CMMFDevSound::InitializeL

 *

 *  Initializes CMMFDevSound object with hardware device with hardware

 *  device's FourCC code. On completion of Initialization will call

 *  InitializeComplete() on aDevSoundObserver.

 *

 *  Leaves on failure.

 *

 *  @param  MDevSoundObserver&

 *          A reference to the DevSound Observer instance.

 *

 *  @param  TFourCC

 *          CMMFHwDevice implementation FourCC.

 *

 *  @param  TMMFState

 *          A mode for which this object will be used.

 *

 */

void CMMFDevSound::CBody::InitializeL(MDevSoundObserver& aDevSoundObserver,

                                      TFourCC aDesiredFourCC,

                                      TMMFState aMode)

	{

	ASSERT(iDevSoundProxy);

	iDevSoundProxy->InitializeL(aDevSoundObserver, aDesiredFourCC, aMode, *this);

	}

/**

 *  CMMFDevSound::CBody::CustomInterface

 *

 *  Returns custom interface proxy object created by Proxy Custom Interface

 *  Utility.

 *

 *  @param  TUid

 *          UID of the custom interface object to be started.

 *

 *  @return TAny*

 *          Pointer to the Interface Returned by the DevSoundProxy member.

 */

TAny* CMMFDevSound::CBody::CustomInterface(TUid aInterfaceId)

	{

	// check if this UID refers to CancelInitialize()

	if (aInterfaceId == KMmfUidDevSoundCancelInitializeCustomInterface)

		{

		MMMFDevSoundCancelInitialize* result = this; 

		return result;

		}

	// check if this UID refers to EmptyBuffers()

	if (aInterfaceId == KMmfUidDevSoundEmptyBuffersCustomInterface)

		{

		MMMFDevSoundEmptyBuffers* result = this; 

		return result;

		}

	if (aInterfaceId == KMmfUidDevSoundAudioResourceCustomInterface)

		{

		MAutoPauseResumeSupport* result = this; 

		return result;

		}		

	if (aInterfaceId == KMmfUidDevSoundTimePlayedCustomInterface)

		{

		MMMFDevSoundTimePlayed* result = this; 

		return result;

		}

	if (aInterfaceId == KMmfUidDevSoundQueryIgnoresUnderflowCustomInterface)

		{

		MMMFDevSoundQueryIgnoresUnderflow* result = this;

		return result;

		}

	if (aInterfaceId == KMmfUidDevSoundAudioClientThreadInfoCustomInterface)

		{

		MAudioClientThreadInfo* result = this; 

		return result;

		}

	if (aInterfaceId == KMmfUidDevSoundTruePauseCustomInterface)

		{

		MMMFDevSoundTruePause* result = this;

		return result;

		}

	// first check if we already have resolved a custom interface of this type

	TInt index = FindCustomInterface(aInterfaceId);

	MMMFDevSoundCustomInterfaceMuxPlugin* ptr = NULL;

	// if we found the interface, take a copy of this instead

	if (index != KNullHandle)

		{

		// check our index is valid

		ptr = iCustomInterfaceArray[index-1].iInterface;

		if (ptr)		

			{

			return ptr->CustomInterface(aInterfaceId);

			}

		}

	else

		{

		// else try and instantiate a plugin tunnelling

		// pair to support this Custom Interface

		TRAPD(err, ptr = iMuxUtility->CreateCustomInterfaceMuxL(aInterfaceId));

		if (ptr && (err == KErrNone))

			{

			TMMFDevSoundCustomInterfaceData data;

			data.iInterface = ptr;

			data.iId = aInterfaceId;

			// attempt to open remote demux

			// this will store a handle in the mux plugin if successful

			// and also return it here - invalid handle = -1

			data.iHandle = ptr->OpenInterface(aInterfaceId);

			// if the handle is greater than zero then we know we have

			// successfully opened the interface

			if (data.iHandle > KNullHandle)

				{	

				// append this to the current interface list

				TInt err = KErrNone;

				err = iCustomInterfaceArray.Append(data);

				if (err == KErrNone)

					{

					// return the custom interface on the ptr

					return ptr->CustomInterface(aInterfaceId);

					}

				}

				// no memory or other problem so shut down interface

				ptr->Release();

				ptr = NULL;

			}

		}

	if (iCIExtension)

		{

		// CI Extension exists, see if it supports the interface

		TAny* interface;

		TInt err = iCIExtension->CustomInterfaceExtension(aInterfaceId, interface);

		if (err == KErrNone)

			{

			return interface;

			}

		}

	// No Mux/DeMux support & no support from CI Extension, if here

	// So, its not supported	

	return NULL;

	}

TInt CMMFDevSound::CBody::FindCustomInterface(TUid aInterfaceId)

	{

	TInt index = KNullHandle;

	TInt count = iCustomInterfaceArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		if (iCustomInterfaceArray[i].iId == aInterfaceId)

			{

			index = i+1; // use index+1 as the handle, so 0 is undefined/not-found

			break;

			}

		}

	return index;

	}

void CMMFDevSound::CBody::CloseCustomInterface(TInt aIndex)

	{

	TInt count = iCustomInterfaceArray.Count();

	for (TInt i = 0; i < count; i++)

		{

		if(iCustomInterfaceArray[i].iHandle == aIndex)

			{

			iCustomInterfaceArray[i].iInterface->Release();

			iCustomInterfaceArray.Remove(i);

			break;

			}

		}

	}

TInt CMMFDevSound::CBody::GetTimePlayed(TTimeIntervalMicroSeconds& aTime)

	{

	return iDevSoundProxy->GetTimePlayed(aTime);

	}

TBool CMMFDevSound::CBody::QueryIgnoresUnderflow()

	{

	return ETrue;

	}

TInt CMMFDevSound::CBody::SetClientThreadInfo(TThreadId aTid)

	{

	return iDevSoundProxy->SetClientThreadInfo(aTid);

	}

// End of File