/*

* Copyright (c)  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:  Audio Play Controller Recognizer

*

*/

#include	<f32file.h> // for RDebug

#include   	<implementationproxy.h>

#include	"HXAudioPlayControllerRecognizer.h"

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

#include    <hxmetadatakeys.h>

#include    <hxmetadatautil.h>

_LIT(KRAVideoType, "video/"); //Moved inside Flag for build warining

#endif

const TUid KUidMimeRARecognizer = {0x10207B62};

_LIT8(KRAMimeType, "audio/x-pn-realaudio");

_LIT(KRAMimeType1, "audio/x-pn-realaudio");

_LIT(KRAMimeType2, "audio/x-realaudio");

_LIT(KRAMimeType3, "audio/vnd.rn-realaudio");

_LIT(KASFMimeType1, "audio/x-hx-wma");

_LIT(KASFMimeType2, "video/x-hx-wmv");

_LIT8(KASFAudioMimeType, "audio/x-ms-wma");

_LIT8(KASFVideoMimeType, "video/x-ms-wmv");

_LIT(KDotASF, ".asf");

_LIT(KDotWMA, ".wma");

_LIT(KDotWMV, ".wmv");

_LIT8(KRMFileHeader, ".RMF");

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

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

// CHXAudioPlayControllerRecognizer::CHXAudioPlayControllerRecognizer()

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

// might leave.

// Call base constructor with the recognizer's UID and confidence level

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

//

CHXAudioPlayControllerRecognizer::CHXAudioPlayControllerRecognizer()

	:	CApaDataRecognizerType(KUidMimeRARecognizer, CApaDataRecognizerType::EHigh)

	{

	// Set the number of data (MIME) types supported by this recognizer.

	iCountDataTypes = 1;

	}

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

// CHXAudioPlayControllerRecognizer::ConstructL()

// Symbian 2nd phase constructor can leave.

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

void CHXAudioPlayControllerRecognizer::ConstructL()

	{

	}

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

// CHXAudioPlayControllerRecognizer::NewL()

// Two-phased constructor.

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

CHXAudioPlayControllerRecognizer* CHXAudioPlayControllerRecognizer::NewL()

	{

#ifdef _DEBUG

	RDebug::Print(_L("CHXAudioPlayControllerRecognizer::NewL"));

#endif

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

// Destructor

CHXAudioPlayControllerRecognizer::~CHXAudioPlayControllerRecognizer()

	{

	}

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

// CHXAudioPlayControllerRecognizer::SupportedDataTypeL

// Return the MimeType of the DataType depending on

// mime type of the file

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

TDataType CHXAudioPlayControllerRecognizer::SupportedDataTypeL(

	TInt aIndex ) const

	{

#ifdef _DEBUG

	RDebug::Print(_L("CHXAudioPlayControllerRecognizer::SupportedDataTypeL [%d]"), aIndex);

#endif

	TDataType dataType;

	switch ( aIndex )

		{

		case 0:

			dataType = TDataType(KRAMimeType);

			break;

		default:

			User::Leave(KErrArgument);

			break;

		}

	return dataType;

	}

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

// CHXAudioPlayControllerRecognizer::PreferredBufSize()

// Return the supposed minimum buffer size we need to

// successfully recognize the data

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

TUint CHXAudioPlayControllerRecognizer::PreferredBufSize()

	{

	return 0;

	}

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

// CHXAudioPlayControllerRecognizer::DoRecognizeL

// Attempt to recognize the data

// this recognizer only attempts to match the data and/or file suffix

//

// NB if the file is not recognized, this function should NOT leave :

// it should instead set iConfidence = ENotRecognized and return

// the function should only leave if there is an out-of-memory condition

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

void CHXAudioPlayControllerRecognizer::DoRecognizeL(

	const TDesC& aName,

	const TDesC8& aBuffer )

	{

#ifdef _DEBUG

	RDebug::Print(_L("CHXAudioPlayControllerRecognizer::DoRecognizeL: "));

	RDebug::RawPrint(aName);

	RDebug::Print(_L(" "));

#endif

	// assume match will fail

	iConfidence = CApaDataRecognizerType::ENotRecognized;

    // Checks for only RA files with .RMF header and files with .ASF extension

    if (( aBuffer.Length() >= KRMFileHeader().Length()

        && (aBuffer.Left( KRMFileHeader().Length()).CompareF(KRMFileHeader()) == 0 ))

        || aName.Right( KDotASF.iTypeLength ).CompareF(KDotASF) == 0

        || aName.Right( KDotWMV.iTypeLength ).CompareF(KDotWMV) == 0

        || aName.Right( KDotWMA.iTypeLength ).CompareF(KDotWMA) == 0)

        {

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

        CHXMetaDataUtility *putil;

        putil = CHXMetaDataUtility::NewL();

        CleanupStack::PushL(putil);

        RFile *pHandle = NULL;

        TRAPD(err, pHandle = FilePassedByHandleL());

        if(pHandle)

            {

            TRAP(err,putil->OpenFileL((RFile &)*pHandle));

            }

        else

            {

            TRAP(err,putil->OpenFileL((TDesC &)aName));

            }

        if(err != KErrNone)

        	{

	        CleanupStack::Pop(putil);

	        putil->ResetL();

	        delete putil;

			return;

        	}

        TUint count = 0;

        putil->GetMetaDataCount(count);

        TUint i;

        HXMetaDataKeys::EHXMetaDataId  id;

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

            {

            HBufC* pDes = NULL;

            putil->GetMetaDataAt(i, id, pDes);

            if(id == HXMetaDataKeys::EHXMimeType)

                {

                TPtr des = pDes->Des();

                TInt res = des.Find(KRAVideoType());

                if(res == KErrNotFound)

                    {

                    if(IsRealMimeTypeSupported(*pDes))

                        {

                        iDataType = TDataType(KRAMimeType);

                        iConfidence = ECertain;

                        }

                    else if(IsASFTypeSupported(*pDes))

                        {

                        iDataType = TDataType(KASFAudioMimeType);

                        iConfidence = ECertain;

                        }

                    }

                else

                    {

                    if(IsASFTypeSupported(*pDes))

                        {

                        iDataType = TDataType(KASFVideoMimeType);

                        iConfidence = ECertain;

                        }

                    else

                        {

                        iDataType = TDataType(KNullUid);

                        iConfidence = CApaDataRecognizerType::ENotRecognized;

                        }

                    break;

                    }

                }

            }

        CleanupStack::Pop(putil);

        putil->ResetL();

        delete putil;

#endif // RD_RA_SUPPORT_FOR_MUSIC_PLAYER

        }

  	}

TBool CHXAudioPlayControllerRecognizer::IsRealMimeTypeSupported(const TDesC& aMimeType)

    {

    TBool match = false;

    if(!aMimeType.Compare(KRAMimeType1()))

        {

            match = true;

            return match;

        }

    if(!aMimeType.Compare(KRAMimeType2()))

        {

            match = true;

            return match;

        }

    if(!aMimeType.Compare(KRAMimeType3()))

        {

            match = true;

            return match;

        }

    return match;

    }

TBool CHXAudioPlayControllerRecognizer::IsASFTypeSupported(const TDesC& aMimeType)

    {

    TBool match = false;

    if((aMimeType.Compare(KASFMimeType1()) == 0) || (aMimeType.Compare(KASFMimeType2()) == 0))

        {

        match = true;

        return match;

        }

    return match;

    }

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

// CApaDataRecognizerType* CreateRecognizerL()

// Used to create an instance of a CApaDataRecognizerType-derived class

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

CApaDataRecognizerType* CHXAudioPlayControllerRecognizer::CreateRecognizerL()

	{

	return new (ELeave) CHXAudioPlayControllerRecognizer ();

	}

const TImplementationProxy ImplementationTable[] =

	{

	IMPLEMENTATION_PROXY_ENTRY(0x10207B63, CHXAudioPlayControllerRecognizer::CreateRecognizerL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

// End of file