/*

* Copyright (c) 2006 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:  Class definition for the DataSourceAdapter functions.

*

*/

//  INCLUDES

#include "DataSourceAdapter.h"

#include "DebugMacros.h"

#include <MultimediaDataSourceFactory.h>

#include <mmffile.h>

#include <MultimediaDataSource.h>

#include <AudioOutputControlUtility.h>

// ============================ MEMBER FUNCTIONS ===============================

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

// CDataSourceAdapter::CDataSourceAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C CDataSourceAdapter::CDataSourceAdapter()

	{

    iPosSeekable = EFalse;

    iTimeSeekable = EFalse;

    iDataSource = NULL;

    iIsProtected = EFalse;

    }

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

// CDataSourceAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDataSourceAdapter::ConstructL()

    {

	// should end up doing this for all sources

	iZeroBuffer = CMMFDataBuffer::NewL(0); // this is just for test to allow source seek

	iHdrBuffer = CMMFDataBuffer::NewL(20); // just enough to cover the header lengths create by recorder

	}

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

// CDataSourceAdapter::NewL

// Two-phased constructor.

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

//

EXPORT_C CDataSourceAdapter* CDataSourceAdapter::NewL()

	{

	DP0(_L("CDataSourceAdapter::NewL"));

    CDataSourceAdapter* self = new(ELeave) CDataSourceAdapter();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

EXPORT_C CDataSourceAdapter::~CDataSourceAdapter()

    {

	DP0(_L("CDataSourceAdapter::~CDataSourceAdapter"));

	delete iAsyncProxyFillBuffer;

    delete iZeroBuffer;

    delete iHdrBuffer;

    if (iMMDataSource)

    	{

    	iMMDataSource->Close();

	    delete iMMDataSource;	

    	}

    iAudioOutputControlUtility = NULL;

    }

EXPORT_C void CDataSourceAdapter::SetDataSourceL(MDataSource* aDataSource,

								 MMultimediaDataSourceObserver* aMMultimediaDataSourceObserver,

								 MAsyncEventHandler* aAsyncEventHandler)

	{

	DP0(_L("CDataSourceAdapter::SetDataSourceL"));

	iHeaderOnly = EFalse;

	iDataSource = aDataSource;

	iAsyncEventHandler = aAsyncEventHandler;

    iSourceType = iDataSource->DataSourceType();

	DP1(_L("CDataSourceAdapter::SetDataSourceL DataSourceType[0x%x]"), iSourceType);

    if ((iSourceType == KMmdsStreamingSourceUid) || (iSourceType == KMmdsProgDLSourceUid) ||

        (iSourceType == KMmdsFileSourceUid) || (iSourceType == KMmdsDescriptorSourceUid))

        {

        TInt err = CMultimediaDataSourceFactory::CreateDataSource(*iDataSource, iMMDataSource);

        User::LeaveIfError(err);

        iMMDataSource->SetObserver(*aMMultimediaDataSourceObserver);

        err = iMMDataSource->Open();    

        User::LeaveIfError(err);

        iMMDataSource->GetSeekingSupport(iPosSeekable);

        }

	else if ((iSourceType == KUidMmfFileSource) || (iSourceType == KOldProgDLSourceUid))

    	{

    	iPosSeekable = ETrue;

    	iDataSource->SourcePrimeL();

   		iIsProtected = static_cast<CMMFFile*>(iDataSource)->IsProtectedL();

		iClip = static_cast<CMMFClip*>(iDataSource);

		iClip->SourceThreadLogon(*aAsyncEventHandler);

		iClip->ReadBufferL(iHdrBuffer,0);

		iClip->ReadBufferL(iZeroBuffer, 0); // seek back to 0 position

		const TUint8* ptr = iHdrBuffer->Data().Ptr();

    	if (iClip->Size() == 6)

    		{ // check for just the header from recorder

    		TUint32* w1p = (TUint32*)ptr;

    		TUint16* w2p = (TUint16*)(ptr+4);

    		if (((*w1p & 0x4D412123)==0x4D412123) && 

    			((*w2p & 0x0A52)==0x0A52))

    			{

	  			iHeaderOnly = ETrue;

	  			return;

    			}

    		}

		}

	else if (iSourceType == KUidMmfDescriptorSource)

		{

	    TRAP_IGNORE(iAsyncProxyFillBuffer = new(ELeave) CAsyncProxyFillBuffer(iDataSource));

		}

	}

EXPORT_C TUid CDataSourceAdapter::DataSourceType() 

	{

	DP0(_L("CDataSourceAdapter::DataSourceType"));

	return iDataSource->DataSourceType();

	}

EXPORT_C void CDataSourceAdapter::FillBufferL( CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId aMediaId)

	{

	DP0(_L("CDataSourceAdapter::FillBufferL"));

	if (iAsyncProxyFillBuffer)

		{// mmf descriptor does not have async intfc

		iAsyncProxyFillBuffer->FillBuffer(aBuffer, aConsumer, aMediaId);

		}

	else

		{

		iDataSource->FillBufferL(aBuffer, aConsumer, aMediaId);

		}	

	}

EXPORT_C void CDataSourceAdapter::BufferEmptiedL(CMMFBuffer* aBuffer)

	{

	DP0(_L("CDataSourceAdapter::BufferEmptiedL"));

	iDataSource->BufferEmptiedL(aBuffer);

	}

EXPORT_C TBool CDataSourceAdapter::CanCreateSourceBuffer()

	{

	DP0(_L("CDataSourceAdapter::CanCreateSourceBuffer"));

	return iDataSource->CanCreateSourceBuffer();

	}

EXPORT_C CMMFBuffer* CDataSourceAdapter::CreateSourceBufferL(TMediaId aMediaId, TBool& aReference)

	{

	DP0(_L("CDataSourceAdapter::CreateSourceBufferL"));

	return iDataSource->CreateSourceBufferL(aMediaId, aReference);

	}

EXPORT_C TInt CDataSourceAdapter::SourceThreadLogon(MAsyncEventHandler& aEventHandler)

	{

	DP0(_L("CDataSourceAdapter::SourceThreadLogon"));

	return iDataSource->SourceThreadLogon(aEventHandler);

	}

EXPORT_C void CDataSourceAdapter::SourceThreadLogoff()

	{

	DP0(_L("CDataSourceAdapter::SourceThreadLogoff"));

	iDataSource->SourceThreadLogoff();

	}

EXPORT_C void CDataSourceAdapter::SourcePrimeL()

	{

	DP0(_L("CDataSourceAdapter::SourcePrimeL"));

	iDataSource->SourcePrimeL();

	}

EXPORT_C void CDataSourceAdapter::SourceStopL()

	{

	DP0(_L("CDataSourceAdapter::SourceStopL"));

	iDataSource->SourceStopL();

	if (iAsyncProxyFillBuffer)

		{

		iAsyncProxyFillBuffer->Cancel();

		iAsyncProxyFillBuffer->Reset();

		}

	}

EXPORT_C void CDataSourceAdapter::SourcePlayL()

	{

	DP0(_L("CDataSourceAdapter::SourcePlayL"));

	iDataSource->SourcePlayL();

	}

EXPORT_C TInt CDataSourceAdapter::SeekToPosition(TUint aPosition)

	{

	DP1(_L("CDataSourceAdapter::SeekToPosition [%d]"), aPosition);

	TInt status = KErrNone;

	if (iPosSeekable)

		{

	    if (iSourceType == KUidMmfFileSource)

    		{

			TRAP(status, iClip->ReadBufferL(iZeroBuffer, aPosition)); // seek

    		}

    	else

    	    {

        	status = iMMDataSource->Seek(aPosition);

    	    }	

		}

	else

		{

		status = KErrNotSupported;

		}	

	return status;

	}

EXPORT_C TInt CDataSourceAdapter::SeekToTime(TUint /*aTimeMs*/)

	{

	DP0(_L("CDataSourceAdapter::SeekToTime"));

	TInt status = KErrNotSupported;

	return status;

	}

EXPORT_C TInt CDataSourceAdapter::SeekToTime(TUint /*aTimeMs*/, TUint& /*aFoundTimeMs*/)

	{

	DP0(_L("CDataSourceAdapter::SeekToTime"));

	TInt status = KErrNotSupported;

	return status;

	}

EXPORT_C TBool CDataSourceAdapter::IsTimeSeekable()

	{

	DP1(_L("CDataSourceAdapter::IsTimeSeekable[%d]"), iTimeSeekable);

	return iTimeSeekable;

	}

EXPORT_C TBool CDataSourceAdapter::IsPositonSeekable()

	{

	DP1(_L("CDataSourceAdapter::IsPositonSeekable[%d]"), iPosSeekable);

	if (iMMDataSource)

		{ // source seekability may change after file is downloaded so ask source again.

        iMMDataSource->GetSeekingSupport(iPosSeekable);

		}

	return iPosSeekable;

	}

EXPORT_C TInt CDataSourceAdapter::SourceSize()

	{

	DP0(_L("CDataSourceAdapter::SourceSize"));

	iSourceSize = KErrUnknown;

    if ((iSourceType == KUidMmfFileSource) ||(iSourceType == KUidMmfDescriptorSource))

    	{

   		iSourceSize  = static_cast<CMMFClip*>(iDataSource)->Size();

    	}

	else if (iMMDataSource)

        {

        TUint size;

        TInt stat = iMMDataSource->GetSize(size);

        if (stat == KErrNone)

        	{

        	iSourceSize = size;

        	}

		}

    return iSourceSize;	

	}

EXPORT_C TInt CDataSourceAdapter::IsProtectedL()

	{

	DP0(_L("CDataSourceAdapter::IsProtectedL"));

    return iIsProtected;	

	}

EXPORT_C void CDataSourceAdapter::SetSourcePrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

	DP0(_L("CDataSourceAdapter::SetSourcePrioritySettings"));

	iDataSource->SetSourcePrioritySettings(aPrioritySettings);

	}

EXPORT_C TBool CDataSourceAdapter::OnlyHeaderPresent()

	{

	DP1(_L("CDataSourceAdapter::OnlyHeaderPresent [%d]"), iHeaderOnly);

	return iHeaderOnly;	

	}

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

// CDataSourceAdapter::ExecuteIntent

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

//

EXPORT_C TInt CDataSourceAdapter::ExecuteIntent(ContentAccess::TIntent aIntent)

	{

	DP1(_L("CDataSourceAdapter::ExecuteIntent [%d]"), aIntent);

	TInt status = KErrNone;

	if (iMMDataSource)

		{

	    status = iMMDataSource->ExecuteIntent(aIntent);

		}

	else if (iSourceType == KUidMmfFileSource)

		{

   		CMMFFile* file = static_cast<CMMFFile*>(iDataSource);

   		status = file->ExecuteIntent(aIntent);

		}	

	return status;	

	}

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

// CDataSourceAdapter::SetAgentProperty

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

//

EXPORT_C TInt CDataSourceAdapter::SetAgentProperty(ContentAccess::TAgentProperty aProperty, TInt aValue)

	{

	DP2(_L("CDataSourceAdapter::SetAgentProperty prop[%d] val[%d]"), aProperty, aValue);

	TInt status = KErrNone;

	if (iMMDataSource)

		{

	    status = iMMDataSource->SetAgentProperty(aProperty, aValue);

		}

	else if (iSourceType == KUidMmfFileSource)

		{

		CMMFFile* file = static_cast<CMMFFile*>(iDataSource);

		status = file->SetAgentProperty(aProperty, aValue);

		}

	return status;

	}

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

// CDataSourceAdapter::EvaluateIntent

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

//

EXPORT_C TInt CDataSourceAdapter::EvaluateIntent(ContentAccess::TIntent aIntent)

	{

	DP0(_L("CDataSourceAdapter::EvaluateIntent"));

	TInt status = KErrNone;

	if (iMMDataSource)

		{

	    status = iMMDataSource->EvaluateIntent(aIntent);

		}

	else if (iSourceType == KUidMmfFileSource)

		{

		CMMFFile* file = static_cast<CMMFFile*>(iDataSource);

		status = file->EvaluateIntent(aIntent);

		}	

	DP1(_L("CDataSourceAdapter::EvaluateIntent aIntent[%d]"), aIntent);

	return status;

	}

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

// CDataSourceAdapter::GetInterface

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

//

EXPORT_C TInt CDataSourceAdapter::GetInterface(TUid aInterfaceId, TVersion& aVersion, TAny*& aInterfaceImpl)

	{

	TInt err = KErrNotSupported;

	if (iMMDataSource)

		{		

		err = iMMDataSource->GetInterface(aInterfaceId, aVersion, aInterfaceImpl);

		// This Error check is done because all sources have not Implemented this Interface

		// and the Controller will Leave if we return this Error in Prime()

		// To maintain compatibility untill all the EMC sources implement GetInterface()

		if(err == KErrNotFound)

		    return KErrNone;

		if (err != KErrNone)

			return err;

		}

	return err;	

	}		

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

// CDataSourceAdapter::Event

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

//

EXPORT_C void CDataSourceAdapter::Event(TUid aEvent)

	{

	if (iMMDataSource)

		{

		iMMDataSource->Event(aEvent);

		}

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer

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

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::CAsyncProxyFillBuffer

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

//

CDataSourceAdapter::CAsyncProxyFillBuffer::CAsyncProxyFillBuffer(MDataSource* aDataSource) :

    CActive(EPriorityHigh),

    iDataSource(aDataSource)

	{

    DP0(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::CAsyncProxyFillBuffer"));

	CActiveScheduler::Add(this);

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::~CAsyncProxyFillBuffer

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

//

CDataSourceAdapter::CAsyncProxyFillBuffer::~CAsyncProxyFillBuffer()

	{

    DP0(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::~CAsyncProxyFillBuffer"));

	Cancel();

	iQueuedAsyncBuffers.Close();

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::FillBuffer

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

//

void CDataSourceAdapter::CAsyncProxyFillBuffer::FillBuffer(CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId aMediaId)

	{

    DP2(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::FillBuffer buffer[%x] this=consumer[%d]"),

	    static_cast<CMMFDataBuffer*>(aBuffer)->Data().Ptr(), (aConsumer == (MDataSink*)this));

    iMediaId = aMediaId;

	if (aConsumer == (MDataSink*)this)

		{

	    iBuffer = aBuffer;

	    iStatus = KRequestPending; // service request would be made here and pending set by service provider

		SetActive();

		iRequestStatus = &iStatus;

		User::RequestComplete(iRequestStatus, KErrNone);

		}	

	else

		{

	    iConsumer = aConsumer;

	    if (IsActive()|| (iQueuedAsyncBuffers.Count() > 0))

    		{

		    DP1(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::RunL que[%x]"),

		    		static_cast<CMMFDataBuffer*>(aBuffer)->Data().Ptr());

        	iQueuedAsyncBuffers.Append(aBuffer);

	    	}

   		else

   			{

		    iBuffer = aBuffer;

		    iStatus = KRequestPending; // service request would be made here and pending set by service provider

			SetActive();

			iRequestStatus = &iStatus;

			User::RequestComplete(iRequestStatus, KErrNone);

	   		}

		}

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::RunL

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

//

void CDataSourceAdapter::CAsyncProxyFillBuffer::RunL()

	{

    DP0(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::RunL"));

    if (iDataSource->DataSourceType() == KUidMmfDescriptorSource)

    	{ 

    	// descriptor has no way to set read position back to 0

    	// so we have to always read using position

    	// then we can adjust the read position and send the buffer to the consumer

        static_cast<CMMFFile*>(iDataSource)->ReadBufferL(iBuffer, iReadPos);

    	TInt bytesRead = static_cast<CMMFDataBuffer*>(iBuffer)->Data().Length();

    	iReadPos += bytesRead;

    	iConsumer->BufferFilledL(iBuffer);

    	}

    else

    	{

        iDataSource->FillBufferL(iBuffer,iConsumer,iMediaId);

    	}

	if (iQueuedAsyncBuffers.Count() > 0)

		{

	    DP1(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::RunL que count [%d]"),iQueuedAsyncBuffers.Count());

		FillBuffer(iQueuedAsyncBuffers[0],(MDataSink*)this,iMediaId);

		iQueuedAsyncBuffers.Remove(0);

		}

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::RunError

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

//

TInt CDataSourceAdapter::CAsyncProxyFillBuffer::RunError(TInt aError)

	{

	if (aError)

	    {

	    DP1(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::RunError, aError = %d"), aError);

	    }

	return KErrNone;

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::DoCancel

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

//

void CDataSourceAdapter::CAsyncProxyFillBuffer::DoCancel()

	{

	DP0(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::DoCancel"));

//	Reset();

	}

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

// CDataSourceAdapter::CAsyncProxyFillBuffer::Reset

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

//

void CDataSourceAdapter::CAsyncProxyFillBuffer::Reset()

	{

	DP0(_L("CDataSourceAdapter::CAsyncProxyFillBuffer::Reset"));

	iQueuedAsyncBuffers.Reset();

	iReadPos = 0;