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