/*

* 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:  Implementation of the ClientDataBufferSource class.

*

*/

#include "ClientDataBufferSource.h"

#include "DataBufferQueueItem.h"

#include "DataBufferSourceCustomCommands.h"

#include "EventNotifier.h"

#include "DataBufferProcessedEvent.h"

#include "DataBufferSourceUid.h"

#include "DRMConfigIntfcImpl.h"

#include <e32std.h>

#include <MCustomCommand.h>

#include <DataBuffer.h>

#include <MimeTypes.h>

#include <SourceControlObserver.h>

#include "tracemacros.h"

#define RETURN_IF_ERROR(x) if(x != KErrNone) return x

using namespace multimedia;

// CONSTANTS

const TInt KMinBufferSize = 5120;

CClientDataBufferSource::CClientDataBufferSource()

:iDRMType(ENone)

    {

	iFixedDurationSupport = false;

    }

CClientDataBufferSource::~CClientDataBufferSource()

    {

    delete iMimeType;

    EmptyQueue();

    delete iEventNotifier;

    delete iAudioBufferQueue;

    delete iBufTypeSupportEvent;

    iAllowedOutputDeviceList.Close();

    }

TInt CClientDataBufferSource::PostConstructor()

    {

    TInt status(KErrNone);

    // Make sure this doesn't get called second time around.

    if ( !iEventNotifier )

        {

        TRAP(status, iEventNotifier = CEventNotifier::NewL());

        }

    RETURN_IF_ERROR(status);

    iAudioBufferQueue = new TSglQue<CDataBufferQueueItem>(_FOFF(CDataBufferQueueItem, iLink));

    if (!iAudioBufferQueue)

        {

        status = KErrNoMemory;

        }

    RETURN_IF_ERROR(status);

    TRAP(status,iBufTypeSupportEvent  = CBufTypeSupEventAO::NewL(*this)); 

    return status;

    }

TInt CClientDataBufferSource::AddObserver( MControlObserver& aObserver )

    {

    return iEventNotifier->AddObserver( aObserver );

    }

TInt CClientDataBufferSource::RemoveObserver( MControlObserver& aObserver )

    {

    return iEventNotifier->RemoveObserver( aObserver );

    }

TUid CClientDataBufferSource::Type()

    {

    return KDataBufferSourceControl;

    }

TControlType CClientDataBufferSource::ControlType()

    {

    return ESourceControl;

    }

TInt CClientDataBufferSource::GetSize( TUint& aSize )

    {

    TInt status(KErrNone);

    aSize = iSourceSize;

    return status;

    }

TInt CClientDataBufferSource::GetMimeType( TDes8& aMimeType )

    {

    aMimeType.Copy(*iMimeType);

    return KErrNone;

    }

TInt CClientDataBufferSource::Close()

    {

    TInt status(KErrNone);

    iBufferSeqNum = 0;

    return status;

    }

TInt CClientDataBufferSource::Open( TDesC8& aMimeType , MDataBuffer& /*aHeaderData */)

    {

    TInt status(KErrNotSupported);

    // Source is already attached to controller

    if ( iServerSourceExists )

        {

        status = KErrInUse;

        }

    else

        {

        delete iMimeType;

        iMimeType = NULL;

        TRAP( status, iMimeType = aMimeType.AllocL() );

        iBufferSeqNum = 0;

        }

    return status;

    }

TInt CClientDataBufferSource::GetMinimumBufferSize( TUint& aBufferSize )

    {

    TInt status(KErrNone);

    aBufferSize = KMinBufferSize;

    return status;

    }

TInt CClientDataBufferSource::SetSize( TUint aSize )

    {

    TInt status(KErrNone);

    iSourceSize = aSize;

    if ( iServerSourceExists )

        {

        TPckgBuf<TInt> pckg(aSize);

        status = iCustomCommand->CustomCommandSync( iSourceHandlePckg, ESetSize, pckg, KNullDesC8 );

        }

    return status;

    }

TInt CClientDataBufferSource::WriteData(MDataBuffer& aBuffer )

    {

    EMC_TRACE3(_L("CClientDataBufferSource::WriteData:size[%d]lastbuf[%d]"), \

            aBuffer.GetBufferPtr().Length(), aBuffer.IsLastBuffer());

/*

	TUint8* bufPtr = const_cast<TUint8*>(aBuffer.GetBufferPtr().Ptr());

	if ( aBuffer.GetBufferPtr().Length() > 5 )

    	{

    	RDebug::Print(_L("CClientDataBufferSource::WriteData data[0x%x][0x%x][0x%x][0x%x][0x%x]"), \

    	*bufPtr,*(bufPtr+1),*(bufPtr+2),*(bufPtr+3),*(bufPtr+4));

        }

*/

    TInt status(KErrNotReady);

    // For now we can only write audio data only if controller is loaded

    // and source is added to controller.

    if ( iServerSourceExists )

        {

        // Append item to queue

        CDataBufferQueueItem* item(NULL);

        TRAP(status, item  = CDataBufferQueueItem::NewL( *this,

                                                         aBuffer,

                                                         aBuffer.IsLastBuffer(),

                                                         iBufferSeqNum ));

        RETURN_IF_ERROR(status);

        iAudioBufferQueue->AddLast(*item);

        // Send data to server source

        item->SetActive();

        TPckgBuf<TUint> bufSeqNum;

        bufSeqNum() = iBufferSeqNum;

        iCustomCommand->CustomCommandAsync(

            iSourceHandlePckg,

            (TInt)EProcessBuffer,

            aBuffer.GetBufferPtr(),

            item->GetDataBufferAttributesDesc(),

            item->iStatus);

        status = KErrNone;

        iBufferSeqNum++;

        }

    return status;

    }

TInt CClientDataBufferSource::EmptyBuffers()

    {

    TInt status(KErrNone);

    return status;

    }

TInt CClientDataBufferSource::GetBufferingConfig(TBufferingConfig& aConfig)

    {

	TPckgBuf<TBufferingConfig> pckg;

    if(iServerSourceExists)

        {

		iCustomCommand->CustomCommandSync( iSourceHandlePckg, EGetCurrentBufferingConfig, KNullDesC8, KNullDesC8, pckg );

		aConfig = pckg();

		return KErrNone;

        }

    else

        {

		return KErrNotFound;    

        }

    }

TInt CClientDataBufferSource::SetBufferingConfig(TBufferingConfig aConfig)

    {

	TPckgBuf<TBufferingConfig> pckg(aConfig);

	if ( iServerSourceExists)

		{

		iCustomCommand->CustomCommandSync( iSourceHandlePckg, ESetBufferingConfig, pckg, KNullDesC8 );              

		return KErrNone;    

		}

	else

		{

		return KErrNotFound;    

		}

    }

TInt CClientDataBufferSource::GetBitRate(TUint& aRate)

    {

    //Source Custom Command

    TPckgBuf<TUint> pckg;

    if(iServerSourceExists)

        {

		iCustomCommand->CustomCommandSync( iSourceHandlePckg, EGetBitRate, KNullDesC8, KNullDesC8, pckg );

		aRate = pckg();

		return KErrNone;

        }

    else

        {

		aRate = 0;

		return KErrNotFound;    

        }

    }

TInt CClientDataBufferSource::GetBufferingTypesSupported(TArray<TBufferingConfig::TBufferingType>& aArray)

    {

	RArray<TBufferingConfig::TBufferingType> temp;

	temp.Array() = aArray;

	temp.Append(TBufferingConfig::BUFFERINGNONE);

	temp.Append(TBufferingConfig::FIXEDSIZE);

	if(iFixedDurationSupport)

		{

        temp.Append(TBufferingConfig::FIXEDDURATION);

		}

	aArray = temp.Array();

	return KErrNone;

    }

TInt CClientDataBufferSource::GetInterface(

                                TUid aInterfaceId,

                                TVersion& aVer,

                                TAny*& aInterfaceImpl )

    {

    TInt status(KErrNotFound);

    aInterfaceImpl = NULL;

    if ( ( aInterfaceId == KDRMConfigIntfc ) &&

         ( ( aVer.iMajor == KDRMConfigIntfcMajorVer1 ) &&

           ( aVer.iMinor == KDRMConfigIntfcMinorVer1 ) &&

           ( aVer.iBuild == KDRMConfigIntfcBuildVer1 ) ) )

            {

            CDRMConfigIntcfImpl* temp(NULL);

            TRAP(status, temp = CDRMConfigIntcfImpl::NewL(*this));

            if ( status == KErrNone )

                {

                this->SetChild(*((CChildIntfc*)temp));

                temp->SetParent(*(CParentIntfc*)this);

                aInterfaceImpl = (CDRMConfigIntfc*)temp;

                }

            }

    return status;

    }

void CClientDataBufferSource::ServerSourceCreated( MCustomCommand& aCustomCommand,

                                                     TMMFMessageDestination& aSourceHandle )

    {

    iServerSourceExists = ETrue;

    iCustomCommand = &aCustomCommand;

    iSourceHandle = aSourceHandle;    

    iSourceHandlePckg() = aSourceHandle;

    // Send DRM Config to server side plugin

    TRAP_IGNORE( DoCommitDRMConfigL() );

    iBufTypeSupportEvent->SetActive();

    iCustomCommand->CustomCommandAsync(

        iSourceHandlePckg,

        (TInt)EGetBufferingConfigSupported,

        KNullDesC8,

        KNullDesC8,

        iBufTypeSupportEvent->iStatus);

    }

void CClientDataBufferSource::ServerSourceDeleted()

    {

    iServerSourceExists = EFalse;

    iCustomCommand = NULL;

    // Do client buffer cleanup

    // It should've already been done when server side source was deleted.

    // This is just to make sure.

    }

TBool CClientDataBufferSource::IsEncrypted()

    {

	return KErrNotSupported;   

    }

TUid CClientDataBufferSource::GetSourceUid()

    {

	return KMmfDataBufferSource;

    }

TInt CClientDataBufferSource::GetHeaderData(TPtr& /*aPtr*/)

    {

	return KErrNotSupported;      

    }

void CClientDataBufferSource::BufferProcessed( CDataBufferQueueItem* aItem )

    {

    // Create a event object

    CDataBufferProcessedEvent* event = new CDataBufferProcessedEvent(

        &(aItem->DataBuffer()),

        aItem->Error() );

    // Remove the item from the list and delete it.

    iAudioBufferQueue->Remove(*aItem);

    delete aItem;

    // Send event to client that buffer is processed

    iEventNotifier->Event( this, MSourceControlObserver::KBufferProcessedEvent, event );

    }

void CClientDataBufferSource::HandleCancel( CDataBufferQueueItem& aItem )

    {

    EMC_TRACE1(_L("CClientDataBufferSource::HandleCancel:"));

    if ( iServerSourceExists )

        {

        TPckgBuf<TUint> bufSeqPckg(aItem.GetBufferSequenceNumber());

        iCustomCommand->CustomCommandSync(

                iSourceHandlePckg,

                (TInt)ECancel,

                bufSeqPckg,

                KNullDesC8

                );

        }

    else

        {

        aItem.CompleteSelf(KErrDied);

        }

    }

void CClientDataBufferSource::BufferingTypesSupportedChanged()

	{

	iFixedDurationSupport = true;

	}

TInt CClientDataBufferSource::SetDRMType( TDRMType aDRMType )

    {

    TInt status(KErrNone);

    switch (aDRMType)

        {

        case ENone:

        case EOMA1:

        case EOMA2:

        case EWMDRM:

            iDRMType = aDRMType;

            break;

        default:

            status = KErrArgument;

            break;

        };

    return status;

    }

TInt CClientDataBufferSource::GetDRMType( TDRMType& aDRMType )

    {

    TInt status(KErrNone);

    aDRMType = iDRMType;

    return status;

    }

TInt CClientDataBufferSource::AppendAllowedOutputDevice( TDRMAllowedOutputDevice aOutputDevice )

    {

    TInt status(KErrAlreadyExists);

    switch (aOutputDevice)

        {

        case EAudioAllowAll:

        case EAudioAllowAnalog:

        case EAudioAllowFMTx:

        case EAudioAllowBTA2DP:

        case EAudioAllowBTHFPHSP:

        case EAudioAllowUplink:

        case EAudioAllowUSB:

        case EAudioAllowRecording:

        case EAudioAllowVisualization:

		/**

		* RIM CR 417-7642: HDMI with HDCP to Resctricted Audio Output API

		* Due to addition of new ENUMs to CRestrictedAudioOutput::TAllowedOutputPreference for HDMI and HDCP

		* EAllowAudioHDMI and EAllowAudioHdmiHdcpRequired,the same is matched by adding

		* EAudioAllowHDMI and EAudioAllowHdmiHdcpRequired

		*/

		case EAudioAllowHDMI:

		case EAudioAllowHdmiHdcpRequired:

            if ( iAllowedOutputDeviceList.Find( aOutputDevice ) == KErrNotFound )

                {

                status = iAllowedOutputDeviceList.Append( aOutputDevice );

                }

            break;

        default:

            status = KErrArgument;

            break;

        };

    return status;

    }

TInt CClientDataBufferSource::RemoveAllowedOutputDevice( TDRMAllowedOutputDevice aOutputDevice )

    {

    TInt status = iAllowedOutputDeviceList.Find( aOutputDevice );

    if ( status == KErrNotFound )

        {

        iAllowedOutputDeviceList.Remove(status);

        status = KErrNone;

        }

    return status;

    }

TInt CClientDataBufferSource::GetAllowedOutputDeviceCount( TInt& aCount )

    {

    TInt status(KErrNone);

    aCount = iAllowedOutputDeviceList.Count();

    return status;

    }

TInt CClientDataBufferSource::GetAllowedOutputDevice( TInt aIndex, TDRMAllowedOutputDevice& aOutputDevice )

    {

    TInt status(KErrArgument);

    if ( aIndex <= iAllowedOutputDeviceList.Count() )

        {

        aOutputDevice = iAllowedOutputDeviceList[aIndex];

        status = KErrNone;

        }

    return status;

    }

TInt CClientDataBufferSource::ResetDRMConfig()

    {

    iDRMType = ENone;

    iAllowedOutputDeviceList.Reset();

    return KErrNone;

    }

TInt CClientDataBufferSource::CommitDRMConfig()

    {

    TInt status(KErrNone);

    TRAP(status, DoCommitDRMConfigL());

    return status;

    }

void CClientDataBufferSource::EmptyQueue()

    {

    CDataBufferQueueItem* bufferItem;

    while ( !iAudioBufferQueue->IsEmpty() )

        {

        bufferItem = iAudioBufferQueue->First();

        iAudioBufferQueue->Remove(*bufferItem);

        delete bufferItem;

        }

    }

void CClientDataBufferSource::DoCommitDRMConfigL()

    {

    if ( iServerSourceExists )

        {

        // Package DRM Info into a descriptor and send it to server side plugin

        TInt descSize = sizeof(TDRMType); // For iDRMType

        descSize += sizeof(TInt); // For array size

        descSize += (iAllowedOutputDeviceList.Count() * sizeof(TDRMAllowedOutputDevice)); // For array

        HBufC8* buf(NULL);

        buf = HBufC8::NewL(descSize);

        CleanupStack::PushL(buf);

    	RDesWriteStream stream;

        TPtr8 ptr = buf->Des();

    	stream.Open(ptr);

    	CleanupClosePushL(stream);

    	// Write DRM Type

    	stream.WriteInt32L(iDRMType);

    	// Write Allowed Output Device Count

    	stream.WriteInt32L(iAllowedOutputDeviceList.Count());

    	// Write Allowed Output Device enumeration

    	for (TInt i=0;i<iAllowedOutputDeviceList.Count();i++)

    	    {

    		stream.WriteInt32L(iAllowedOutputDeviceList[i]);

    	    }

    	ptr.SetLength(descSize);

        User::LeaveIfError(iCustomCommand->CustomCommandSync( iSourceHandlePckg, ESetDRMConfig, ptr, KNullDesC8 ));

    	// Delete objects

    	CleanupStack::PopAndDestroy(&stream);//stream

    	CleanupStack::PopAndDestroy(buf);//stream

        }

    }

// End of file