// Copyright (c) 2003-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 <f32file.h>

 #include <barsread.h>

 #include "RecMmf.h"

 #include "mmfcontrollerpluginresolver.h"

 const TInt KMimeMmfRecognizerValue = 0x101F7C0C;

 const TUid KUidMimeMmfRecognizer = {KMimeMmfRecognizerValue};

 const TInt KMmfRecognizerPriority = 10; // The recognizer priority is set to 10(a value between ENormal and EHigh)

 // the minimum buffer size that will theoretically guarantee recognition 

 const TInt KPreferredBufSize = 256;

 // the granularity of the internal MIME type array 

 const TInt KMimeArrayGranularity = 4;

 // CApaMmfRecognizer

 /**

  * @internalAll

  *

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

  * The MMF recognizer priority is set to 10(a value between ENormal and EHigh) to allow 

  * third-party recognizers to specify high priority.

  */

 CApaMmfRecognizer::CApaMmfRecognizer()

 	:CApaDataRecognizerType(KUidMimeMmfRecognizer,KMmfRecognizerPriority)

 	{

 	}

 CApaMmfRecognizer::~CApaMmfRecognizer()

 	{

 	delete iMmfRecognizer;

 	}

 /**

  * @internalAll

  *

  * Return the supposed minimum buffer size we need to 

  * successfully recognize the data

  */

 TUint CApaMmfRecognizer::PreferredBufSize()

 	{

 	return KPreferredBufSize;

 	}

 /**

  * @internalAll

  *

  * Gets one of the data (MIME) types that the recognizer can recognize.

  */

 TDataType CApaMmfRecognizer::SupportedDataTypeL(TInt aIndex) const

 	{

 	return (iMmfRecognizer->SupportedDataTypeL(aIndex));

 	}

 /**

  * @internalAll

  *

  * Attempt to recognize the data.

  * This recognizer only attempts to match the data header on its own,

  * or the data header plus the file suffix together.

  *

  * 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 CApaMmfRecognizer::DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer)

 	{

 	// assume Match will fail :

 	iConfidence = CApaDataRecognizerType::ENotRecognized;

 	CMmfRecognizer::TMatchMethod matchMethod = iMmfRecognizer->MatchL(aName,aBuffer);

 	// return whether the data was matched by setting iConfidence

 	// if matched the MIME type is returned in iDataType

 	if (matchMethod == CMmfRecognizer::ENotMatched)

 		{	

 		iConfidence = CApaDataRecognizerType::ENotRecognized;

 		}

 	else

 		{

 		iDataType = iMmfRecognizer->MimeString();

 		//Match on data only

 		if (matchMethod == CMmfRecognizer::EBySignature)

 			iConfidence = CApaDataRecognizerType::EPossible;

 		else

 			{//Match on data and suffix

 			ASSERT(matchMethod == CMmfRecognizer::EByName);

 			iConfidence = CApaDataRecognizerType::EProbable;

 			}

 		}

 	}

 void CApaMmfRecognizer::ConstructL()

 	{

 	iMmfRecognizer = CMmfRecognizer::NewL();

     iCountDataTypes = iMmfRecognizer->NumMimeTypes();

 	}

 CApaMmfRecognizer* CApaMmfRecognizer::NewL()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 // CMmfRecognizer - the main utility class owner by CApaMmfRecognizer

 CMmfRecognizer::CMmfRecognizer()

 	{

 	}

 CMmfRecognizer::~CMmfRecognizer()

 	{

 	delete iMmfRecognizerUtil;

 	delete iMimeTypes;

 	}

 void CMmfRecognizer::ConstructL()

 	{

 	iMimeTypes = new (ELeave) CDesC8ArrayFlat(KMimeArrayGranularity);

 	BuildListL();

 	iMmfRecognizerUtil = CMmfRecognizerUtil::NewL();

 	}

 CMmfRecognizer* CMmfRecognizer::NewL()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

  * @internalAll

  *

  * Return the number of MIME types supported 

  */

 TInt CMmfRecognizer::NumMimeTypes() const

 	{

 	return(iMimeTypes->Count());

 	}

 /**

  * @internalAll

  *

  * Call into the MMF Controller Framework DLL to get

  * a list of supported MIME types

  */

 void CMmfRecognizer::BuildListL()

 	{

 	iMimeTypes->Reset();

 	CMmfRecognizerUtil::GetMimeTypesL(iMimeTypes);

 	}

 /**

  * @internalAll

  *

  * Get one of the data (MIME) types that MMF can recognize.

  */

 const TPtrC8 CMmfRecognizer::SupportedDataTypeL(TInt aIndex) const

 	{

 	if ((aIndex < 0) || (aIndex >= iMimeTypes->Count()))

 		User::Leave(KErrArgument);

 	return(iMimeTypes->MdcaPoint(aIndex));

 	}

 /**

  * @internalAll

  *

  * Get a reference to the last MIME type string successfully matched

  */

 const TDesC8& CMmfRecognizer::MimeString() const

 	{

 	return iMimeString;

 	}

 /**

  * @internalAll

  *

  * Attempt to recognize the data

  */

 CMmfRecognizer::TMatchMethod CMmfRecognizer::MatchL(const TDesC& aFileName, const TDesC8& aBuffer)

 	{

 	CMmfRecognizerUtil::TMatchLevel matchLevel = CMmfRecognizerUtil::EMatchNone;

 	matchLevel = iMmfRecognizerUtil->GetMimeTypeL(aFileName, aBuffer, iMimeString);

 	TMatchMethod bestMatchMethod = ENotMatched;

 	if(matchLevel==CMmfRecognizerUtil::EMatchData)

 		bestMatchMethod = EBySignature;

 	else if(matchLevel==CMmfRecognizerUtil::EMatchName)

 		bestMatchMethod = EByName;

 	return bestMatchMethod;

 	}

 #include <ecom/ecom.h>

 #include <ecom/implementationproxy.h>

 const TImplementationProxy ImplementationTable[] = 

 	{

 	IMPLEMENTATION_PROXY_ENTRY(0x101F7C41, CApaMmfRecognizer::NewL)

 	};

 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

     {

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

     return ImplementationTable;

     }