// Copyright (c) 2005-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:

//

/**    @file

   @internalComponent */

#include "ImageDisplayFramework.h"

#include "ImageDisplay.hrh"

#include "../../src/ImageUtils.h"

#include "ImageDisplayResolvrUtils.h"

#include "ImageDisplayRecognizer.h"

NONSHARABLE_CLASS( CImgDisplayMimeTypeRecognizer::CBody) : public CActive

   	{

public:

   	static CBody* NewL();

   	~CBody();

   	TBool GetTypeByFileDataL(const TDesC8& aImageData, TDes8& aMimeType);

   	TBool GetTypeByFileNameL(const TDesC& aFileName, TDes8& aMimeType);

   	void GetFileTypesL(RFileExtensionMIMETypeArray& aExtArray);

protected:

	//from CActive

	virtual void DoCancel();

	virtual void RunL();

private:

	CBody();

	void ConstructL();

	void StartNotification();

	void BuildPluginListL();

private:

   	/** an array of pointers to CImplementationInformation objects */

   	RImplInfoPtrArray iPluginArray;

   	/** for opening a session to the ECom server */

   	REComSession iEcomSession;

    /** used when creating decoders */

    RFs iFs;

	};

/**

 	object factory function

 	@return class instance pointer

*/

EXPORT_C CImgDisplayMimeTypeRecognizer* CImgDisplayMimeTypeRecognizer::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CImgDisplayMimeTypeRecognizer::CImgDisplayMimeTypeRecognizer()

	{

	}

/**

	destructor

*/

CImgDisplayMimeTypeRecognizer::~CImgDisplayMimeTypeRecognizer()

	{

	delete iBody;

	}

void CImgDisplayMimeTypeRecognizer::ConstructL()

	{

	iBody = CBody::NewL();

	}

/**

	@param aExtArray array that will be filled with supported file extension information. Information is appended to existing array.

*/

EXPORT_C void CImgDisplayMimeTypeRecognizer::GetFileTypesL(RFileExtensionMIMETypeArray& aExtArray)

	{

	iBody->GetFileTypesL(aExtArray);

	}

/**

	determines Mime type by using filename and its content

	@param aImageData file data

	@param aFileName  file name

	@param aMimeType reference to a buffer that would be given mime type value upon successfull recognition

	@return ETrue if Mime type has been recognized

*/

EXPORT_C TBool CImgDisplayMimeTypeRecognizer::GetMimeTypeL(const TDesC8& aImageData, const TDesC& aFileName, TDes8& aMimeType)

	{

	TBool gotType=EFalse;

	aMimeType.SetLength(0);

	if (aImageData.Length()!=0)

		{

		gotType=iBody->GetTypeByFileDataL(aImageData, aMimeType);

		}

	if (!gotType && aFileName.Length()!=0)

		{

		gotType=iBody->GetTypeByFileNameL(aFileName, aMimeType);

		}

	return gotType;

	}

CImgDisplayMimeTypeRecognizer::CBody* CImgDisplayMimeTypeRecognizer::CBody::NewL()

	{

	CImgDisplayMimeTypeRecognizer::CBody* self=new (ELeave) CImgDisplayMimeTypeRecognizer::CBody();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CImgDisplayMimeTypeRecognizer::CBody::CBody():

	CActive(CActive::EPriorityStandard)

	{

	}

CImgDisplayMimeTypeRecognizer::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 CImgDisplayMimeTypeRecognizer::CBody::StartNotification()

	{

	iEcomSession.NotifyOnChange(iStatus);

	SetActive();

	}

// build a list of interface implementation objects

void CImgDisplayMimeTypeRecognizer::CBody::BuildPluginListL()

	{

	iPluginArray.ResetAndDestroy();

	REComSession::ListImplementationsL(

		TUid::Uid(KUidDisplayInterface), 

		iPluginArray);

	}

inline

TBool IsExtAlreadyAdded(const RFileExtensionMIMETypeArray& aExtArray, const TDesC8& aExt)

	{

	TFileName extU;

	extU.Copy(aExt);

	for (TInt i=aExtArray.Count(); i--;)

		{

		const TDesC& ext=(*aExtArray[i]).FileExtension();

		if (ext.Length()==extU.Length() && extU.CompareF(ext)==0)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

inline

TBool IsMimeAlreadyAdded(const RFileExtensionMIMETypeArray& aExtArray, const TDesC8& aMime)

	{

	for (TInt i=aExtArray.Count(); i--;)

		{

		const TDesC8& mime=(*aExtArray[i]).MIMEType();

		if (mime.Length()==aMime.Length() &&  aMime.CompareF(mime)==0)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

void CImgDisplayMimeTypeRecognizer::CBody::GetFileTypesL(RFileExtensionMIMETypeArray& aExtArray)

	{

	for (TInt i=iPluginArray.Count(); i--;)

		{

		const CImplementationInformation& impData = *(iPluginArray[i]);

		COpaqueDataParse* parse = COpaqueDataParse::NewLC(impData.OpaqueData());

		parse->EnsureMIMETypesReadL();

		if (parse->MIMEType(0).Length() && !IsMimeAlreadyAdded(aExtArray, parse->MIMEType(0)))

			{

			parse->EnsureExtnsReadL();

			for (TInt extN=parse->ExtnsCount(); extN--;)

				{

				if (parse->Extn(extN).Length()==0 || IsExtAlreadyAdded(aExtArray, parse->Extn(extN)))

					{

					continue;

					}

				CFileExtensionMIMEType* ext=CFileExtensionMIMEType::NewLC(

												parse->Extn(extN),

												parse->MIMEType(0), // we always use the FIRST MIME type

												impData.DisplayName(),

												parse->ImageTypeUid(),

												parse->ImageSubTypeUid(),

												impData.ImplementationUid()

											);

				User::LeaveIfError( aExtArray.Append(ext) );

				CleanupStack::Pop(ext);

				}

			}

		CleanupStack::PopAndDestroy(parse);

		}

	}

void CImgDisplayMimeTypeRecognizer::CBody::ConstructL()

	{

	BuildPluginListL();

	CActiveScheduler::Add(this);

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

    iEcomSession = REComSession::OpenL();

	// request notification from ECOM of any file system changes

	StartNotification();

	}

void CImgDisplayMimeTypeRecognizer::CBody::RunL()

	{

	BuildPluginListL();

	StartNotification();

	}

void CImgDisplayMimeTypeRecognizer::CBody::DoCancel()

	{

	if (iStatus == KRequestPending)

		{

		iEcomSession.CancelNotifyOnChange(iStatus);

		}

	}

TBool CImgDisplayMimeTypeRecognizer::CBody::GetTypeByFileNameL(

	const TDesC& aFileName,

	TDes8& aMimeType)

	{

	aMimeType.SetLength(0);

	TParse fileName;

	fileName.Set(aFileName,NULL,NULL);

	//No file extension

	if (!fileName.ExtPresent())	

		{

		return EFalse;

		}

	const TPtrC suffix(fileName.Ext());

	for (TInt i=iPluginArray.Count(); i--;)

		{

		const CImplementationInformation& impData = *(iPluginArray[i]);

		COpaqueDataParse* parse = COpaqueDataParse::NewLC(impData.OpaqueData());

		parse->EnsureExtnsReadL();

		TFileName ext;

		TBool match=EFalse;

		for (TInt extN=0; !match && extN<parse->ExtnsCount(); ++extN)

			{

			ext.Copy(parse->Extn(extN));

			match=(ext.Length()==suffix.Length() && ext.CompareF(suffix)==0);

			}

		if (match)

			{			

			parse->EnsureMIMETypesReadL();

			aMimeType.Copy(parse->MIMEType(0)); // we always use the FIRST MIME type

			}

		CleanupStack::PopAndDestroy(parse);

		if (match)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

TBool CImgDisplayMimeTypeRecognizer::CBody::GetTypeByFileDataL(const TDesC8& aImageData, TDes8& aMimeType)

	{

	aMimeType.SetLength(0);

	for (TInt i=iPluginArray.Count(); i--;)

		{

		const CImplementationInformation& impData = *(iPluginArray[i]);

		TInt bytesMatched=0;

		TBool match=CImageDisplayResolverUtils::Match(aImageData, impData.DataType(), bytesMatched);

		if (match && bytesMatched==impData.DataType().Length())

			{

			COpaqueDataParse* parse = COpaqueDataParse::NewLC(impData.OpaqueData());

			parse->EnsureMIMETypesReadL();

			aMimeType.Copy(parse->MIMEType(0)); // we always use the FIRST MIME type

			CleanupStack::PopAndDestroy(parse);

			if (aMimeType.Length()==0)

				{

				// we've got plug-in with empty MIME type i.e. generic one, so

				// it doesn't have MIME type and can't be used to recognize data

				continue;

				}

			return ETrue;

			}

		}

	return EFalse;

	}