// 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:
// This is the body of the ICL recognizer utility class
// 
//

#include "ImageConversion.h"
#include "ImageResolverAPI.h"
#include "ImageConvResolvrUtils.h"
#include "ImageRelay.h"
#include "EnDecoderUtils.h"
#include "RecIclUtilBody.h"

// ICL Recognizer Utility class body constructor
CIclRecognizerUtil::CBody::CBody():
	CActive(CActive::EPriorityStandard)
	{
	}

CIclRecognizerUtil::CBody::~CBody()
	{
	Cancel();
	iEcomSession.Close();
	iFs.Close();
	iPluginArray.ResetAndDestroy();
	}

// Request ECom to be notified when interface implementation registration 
// data changes so that we can refresh the list of interface implementations.
void CIclRecognizerUtil::CBody::StartNotification()
	{
	iEcomSession.NotifyOnChange(iStatus);
	SetActive();
	}

// build a list of interface implementation objects
void CIclRecognizerUtil::CBody::BuildControllerListL()
	{
	iPluginArray.ResetAndDestroy();
	REComSession::ListImplementationsL(
		KImageDecoderInterfaceUid, 
		iPluginArray);
	}

void CIclRecognizerUtil::CBody::ConstructL()
	{
	BuildControllerListL();

	CActiveScheduler::Add(this);

	User::LeaveIfError(iFs.Connect());

    iEcomSession = REComSession::OpenL();

	// request notification from ECOM of any file system changes
	StartNotification();
	}

void CIclRecognizerUtil::CBody::RunL()
	{
	BuildControllerListL();
	StartNotification();
	}

void CIclRecognizerUtil::CBody::DoCancel()
	{
	if (iStatus == KRequestPending)
		iEcomSession.CancelNotifyOnChange(iStatus);
	}

// Determine whether the supplied data header or file extension is recognized
// and if so return the associated MIME type
// @param	aImageData
//          A descriptor containing the header. Set to KNullDesC8 for match by file extension.
// @param	aFileName
//			A file name for file extension matching. Set to KNullDesC for match by image data
// @param   aMimeType
//          A user-supplied descriptor in which the MIME type is returned
// @return	ETrue if a match was found.
//			EFalse if a match was not found.
// @leave	This method may also leave with one of the system-wide error codes.
// @post    If recognized, the caller's descriptor is filled with the MIME types
TBool CIclRecognizerUtil::CBody::GetMimeTypeL(const TDesC8& aImageData, const TDesC& aFileName, TDes8& aMimeType)
	{
	TBool matchImageData = ETrue;
	HBufC* fileSuffix = NULL;

	if(aFileName==KNullDesC)
		{// match on image data
		if (aImageData.Length() < KImageHeaderSize) // There is not enough data in this source
			return EFalse; 
		}
	else
		{// match on file extension
		// Ensure aFileName is < KMaxFileName
		if ( aFileName.Length() > KMaxFileName )
			{
			User::Leave(KErrBadName);
			}
		
		TParse fileName;
 
 		TDes* const fName = new(ELeave) TFileName;
 		
 		CleanupStack::PushL(fName);
 		
 		fName->Copy(aFileName);
 
 		// if illegalifier character has been added to the file name,
 		// remove the illegalifier and pass the file name only to the parser.
 		if (fName->Match(_L("::*")) == 0)
 			{
 			fName->Delete(0, 2);
 			}
 
 		fileName.Set(*fName, NULL, NULL);
 
 		CleanupStack::PopAndDestroy(fName);


		//No file extension
		if (!fileName.ExtPresent())	
			return EFalse;
		
		//Get the suffix
		fileSuffix = fileName.Ext().AllocLC();

		matchImageData = EFalse;
		}

	TBool matchFound = EFalse;

	// loop through every plugin
	// until we find one that matches the file extension
	const TInt count = iPluginArray.Count();
	TInt oldMatchLevel = 0; // number of characters matched in best match

	for(TInt index = 0; index < count && !matchFound; index++)
		{
		const CImplementationInformation& impData = *(iPluginArray[index]);

		COpaqueDataParse *parse = NULL;
		TRAPD(error, parse = COpaqueDataParse::NewL(impData.OpaqueData()));
		if (error != KErrNone)
			{
			if (error==KErrNotSupported)
				continue;
			else
				User::Leave(error);
			}
		CleanupStack::PushL(parse);

		// we can assume the version is valid as it is checked in 
		// COpaqueDataParse::ConstructL() which leaves if not valid
		ASSERT(parse->Version() <= KIclPluginFrameworkVersionMax);
		
		if (!impData.Disabled() && !parse->OnlyUidsAvail())
			{
			if(matchImageData)
				{// match image data 
				TInt matchLevel = 0;
				if (CImageConversionResolverUtils::Match(aImageData, impData.DataType(), matchLevel))
					{
					TInt error = KErrNone;
					// do we need to create a decoder to fully verify the header data ?
					if (parse->IsOpenNeededToRecognize())
						{
						CImageDecoder* decoder = NULL;
           				TRAP(error, decoder = CImageDecoder::DataNewL(iFs, aImageData));
						delete decoder;
						if (error==KErrNoMemory) // handle OOM, but assume everything else is a do not recognize
							User::Leave(KErrNoMemory);
						else if (error==KErrUnderflow && aImageData.Length()>=KImageHeaderSize) 
							{
							// assuming we have enough data, means the format requires more
							// might as well assume OK
							error=KErrNone;
							}
						}
					if(error == KErrNone && oldMatchLevel < matchLevel)
						{
						// either found a match or a better match
						oldMatchLevel = matchLevel;
						parse->EnsureMIMETypesReadL();
						aMimeType = (parse->MIMETypesCount()==0) ? KNullDesC8() : parse->MIMEType(0);
						}
					}
				}
			else
				{// match file extension
				ASSERT(!matchImageData);
				ASSERT(fileSuffix!=NULL);

				if(parse->IsRecognizeAgainstSuffix())
					{ //If codec has file extensions and allow matching on them
					parse->EnsureExtnsReadL();
					const TInt numExtns = parse->ExtnsCount();
					for (TInt index2 = 0; index2 < numExtns; index2++)
						{
						const TDesC8& extn = parse->Extn(index2);
						if (COpaqueDataParse::CompareFileSuffixL(*fileSuffix, extn))
							{
							// return the first MIME type listed for this plugin
							matchFound = ETrue;
							parse->EnsureMIMETypesReadL();
							aMimeType = (parse->MIMETypesCount()==0) ? KNullDesC8() : parse->MIMEType(0);
							break;
							}
						}
					}
				}
			}
		CleanupStack::PopAndDestroy(parse);
		}
	
	if(oldMatchLevel>0) 
			{
			// looked at all plugins now 
			// return the best MIME type listed for this plugin
			matchFound = ETrue;
			}

	if(!matchImageData)
		CleanupStack::PopAndDestroy(fileSuffix);

	return matchFound;
	}


// Static factory constructor. Uses two phase
// construction and leaves nothing on the cleanup stack
// 
// @leave KErrNoMemory
// @return A pointer to the newly created CIclRecognizerUtil::CBody object
// 
CIclRecognizerUtil::CBody* CIclRecognizerUtil::CBody::NewL()
	{
	CBody* self=new (ELeave) CBody();   
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}