// Copyright (c) 1997-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:
// concrete file finders for MIME type recognizers
// 
//

#include "APMFNDR.H"

#include <e32uid.h>
#include "APMPAN.H"

#ifdef USING_ECOM_RECOGS
#include <ecom/ecom.h>
#endif

const TInt KRecognizerDllGranularity=2;

#ifdef USING_ECOM_RECOGS
const TUid KUidDataRecogInterFaceUid = {0x101F7D87};
#endif

//
// class TRecognizer
//

CApaScanningDataRecognizer::TRecognizer::TRecognizer(HBufC* aName)
	{
	iName=aName;
	}
	
//
// class CApaRecognizerDll
//

CApaRecognizerDll::~CApaRecognizerDll()
	{
	delete iId.iName;
	iLibrary.Close();
	delete iNext;
	}

CApaRecognizerDll::CApaRecognizerDll(HBufC* aName) 
	: iId(aName)
	{
	}

#ifdef USING_ECOM_RECOGS
// Used for cleanup support of locally declared arrays
void CleanUpEComInfoArray(TAny* aInfoArray)
	{
	RImplInfoPtrArray* infoArray = (static_cast<RImplInfoPtrArray*>(aInfoArray));
	infoArray->ResetAndDestroy();
	infoArray->Close();
	}
#endif

// class CApaBackupOperationObserver
CApaScanningDataRecognizer::CApaBackupOperationObserver::CApaBackupOperationObserver(CApaScanningDataRecognizer& aRecognizer)
	: iRecognizer(aRecognizer)
	{
	TRAP_IGNORE(iSession = CBaBackupSessionWrapper::NewL());
	}

CApaScanningDataRecognizer::CApaBackupOperationObserver::~CApaBackupOperationObserver()
	{
	if( iSession )
		{
		iSession->DeRegisterBackupOperationObserver(*this);
		delete iSession;
		}
	}

void CApaScanningDataRecognizer::CApaBackupOperationObserver::RegisterObserverL()
	{
	if(iSession)
		{
		iSession->RegisterBackupOperationObserverL(*this);
		}
	}

void CApaScanningDataRecognizer::CApaBackupOperationObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)
	{
	if (!iRecognizer.iExtra->iRecognizersLoaded)
		{
		// Then the recognizers have been unloaded, so there's nothing to do
		return;
		}

	if ((aBackupOperationAttributes.iFileFlag == MBackupObserver::EReleaseLockReadOnly ||
		aBackupOperationAttributes.iFileFlag == MBackupObserver::EReleaseLockNoAccess)
		&& aBackupOperationAttributes.iOperation == EStart)
		{
		// release recognisers not in rom
		TInt count = iRecognizer.RecognizerCount();
		for (TInt i=count-1; i>=0; i--)
			{
				CApaRecognizerDll* lib=iRecognizer.iRecognizerLib[i];
				TDriveUnit drive(lib->iId.iDrive);
				TChar driveName=drive.Name()[0];
				if(driveName != TChar('Z'))
					{
					iRecognizer.RemoveRecognizer(lib); // ignore any errors
					}
			}
		}

	if (aBackupOperationAttributes.iFileFlag == MBackupObserver::ETakeLock &&
		(aBackupOperationAttributes.iOperation == EEnd ||
		aBackupOperationAttributes.iOperation == EAbort))
		{
		iRecognizer.ScanForRecognizersL();
		}
	}

TInt CApaScanningDataRecognizer::CApaBackupOperationObserver::UpdateCounter() const
	{
	return iUpdateCounter;
	}

void CApaScanningDataRecognizer::CApaBackupOperationObserver::SetUpdateCounter(TInt aValue)
	{
	iUpdateCounter = aValue;
	}


//
// class CApaScanningDataRecognizer
// 

EXPORT_C CApaScanningDataRecognizer* CApaScanningDataRecognizer::NewL(RFs& aFs)
	{
	return NewL(aFs,ETrue);
	}

/**
@internalTechnology
*/
EXPORT_C CApaScanningDataRecognizer* CApaScanningDataRecognizer::NewL(RFs& aFs, TBool aLoadDataRecognizers)
	{
	CApaScanningDataRecognizer* self=new(ELeave) CApaScanningDataRecognizer(aFs);
	CleanupStack::PushL(self);
	self->ConstructL(aLoadDataRecognizers);
	CleanupStack::Pop(); // self
	return self;
	}

EXPORT_C CApaScanningDataRecognizer::~CApaScanningDataRecognizer()
	{
	UnloadRecognizers();
	delete iExtra->iObserver;
	delete iExtra;
	}

EXPORT_C void CApaScanningDataRecognizer::ScanForRecognizersL()
	{
	// set all recognizers to not present - pending rediscovery
	TInt count=iRecognizerLib.Count();
	TInt i;
	for (i=0; i<count; i++)
		iRecognizerLib[i]->iPresent=CApaRecognizerDll::ENotPresent;

	ScanForEcomRecognizersL();
	//
	// remove any recognizers that are no longer present
	for (TInt ii=iRecognizerLib.Count()-1;ii>=0;ii--)
		{
		CApaRecognizerDll* lib=iRecognizerLib[ii];
		if (lib->iPresent==CApaRecognizerDll::ENotPresent)
			{
			RemoveRecognizer(lib); // ignore any errors
			}
		}
	iMaxBufferSize = -1; // Recognizers were re-loaded so need to recalculate the maximum buffer size
	}

EXPORT_C TInt CApaScanningDataRecognizer::RecognizerCount()
	{
	return iRecognizerLib.Count();
	}

EXPORT_C CApaScanningDataRecognizer::CRecognizerArray* CApaScanningDataRecognizer::RecognizerListLC()const
	{
	CRecognizerArray* list=new(ELeave) CArrayFixFlat<TRecognizer>(2);
	CleanupStack::PushL(list);
	TInt count=iRecognizerLib.Count();
	for (TInt i=0; i<count; i++)
		list->AppendL(iRecognizerLib[i]->iId);
	return list;
	}

EXPORT_C const CApaScanningDataRecognizer::TRecognizer& CApaScanningDataRecognizer::operator[](TInt aIndex)const
	{
	return iRecognizerLib[aIndex]->iId;	
	}

EXPORT_C TInt CApaScanningDataRecognizer::UpdateCounter()const
	{
	return iExtra->iObserver->UpdateCounter();
	}


EXPORT_C CApaScanningDataRecognizer::CApaScanningDataRecognizer(RFs& aFs)
	:CApaDataRecognizer(aFs),
	iRecognizerLib(KRecognizerDllGranularity)
	{
	__DECLARE_NAME(_S("CApaScanningDataRecognizer"));
	}

EXPORT_C void CApaScanningDataRecognizer::ConstructL()
	{
	ConstructL(ETrue);
	}

void CApaScanningDataRecognizer::ConstructL(TBool aLoadDataRecognizers)
	{
	iExtra = new (ELeave) CApaScanningDataRecognizerExtra();
	iExtra->iObserver = new (ELeave) CApaBackupOperationObserver( *this );
	iExtra->iObserver->RegisterObserverL();
	if(aLoadDataRecognizers)
		{
		LoadRecognizersL();
		}
	}

EXPORT_C void CApaScanningDataRecognizer::SetEcomRecognizersFromListL(const CRecognizerArray& aList)
	{
	//for ecom style
	for (TInt i=0 ; i<aList.Count() ; i++)
		{
		TDriveUnit drive(aList[i].iDrive);
		TRAPD(ret, LoadEcomRecognizerL(drive,aList[i].iUid));
		if (ret==KErrNoMemory)
			{
			User::Leave(ret); 
			}
		}
	}

EXPORT_C void CApaScanningDataRecognizer::SetEcomRecognizerL(const TRecognizer& aRecognizer)
	{
	//for ecom style 
	TDriveUnit drive(aRecognizer.iDrive);
	LoadEcomRecognizerL(drive,aRecognizer.iUid);
	}

TInt CApaScanningDataRecognizer::RemoveRecognizer(CApaRecognizerDll* aDll)
	{
	__ASSERT_DEBUG(iRecognizerLib.Count()>0,User::Invariant());
	// try to remove the recognizer from the list
	TInt ret=RemoveDataRecognizerType(aDll->iRec);
	if (ret!=KErrNone && ret!=KErrNotFound)
		return ret;
	//
	// get a handle to the previous entry in the list
	TInt count=iRecognizerLib.Count();
	TInt i;
	for (i=0; i<count; i++)
		{
		if (iRecognizerLib[i]==aDll)
			break;
		}
	__ASSERT_ALWAYS(i<count,Panic(EPanicLibraryNotInList));
	
	// remove the dll
	delete iRecognizerLib[i];
	iRecognizerLib.Remove(i);
	iRecognizerLib.Compress();
	if(iExtra->iObserver)
		iExtra->iObserver->SetUpdateCounter(iExtra->iObserver->UpdateCounter() +1);
	return KErrNone;
	}

#ifdef USING_ECOM_RECOGS

//load the ecom style data recognizer
void CApaScanningDataRecognizer::LoadEcomRecognizerL(TDriveUnit& aDrive,TUid aUid)
	{
	//Get implementation information of the recognizer with UID aUid
	RImplInfoPtrArray implementationInfoArray;
	TCleanupItem cleanup(CleanUpEComInfoArray, &implementationInfoArray);
	CleanupStack::PushL(cleanup);
	REComSession::ListImplementationsL(KUidDataRecogInterFaceUid,implementationInfoArray);
	const TInt availCount = implementationInfoArray.Count();
	CImplementationInformation* info=NULL;
	TInt ii;
	for (ii=0;ii<availCount;++ii)
		{
		info = implementationInfoArray[ii];
		TUid uid = info->ImplementationUid();
		
		if(uid.iUid == aUid.iUid )
			{
			break;
			}
		}

	//If the implementation not found just return
	if(ii==availCount)
		{
		CleanupStack::PopAndDestroy(&implementationInfoArray);		
		return;
		}
	
	//Get the version of implementation
	TInt version=info->Version();
	
	// check we haven't loaded this one already
	TInt count=iRecognizerLib.Count();
	TInt i;
	CApaRecognizerDll* lib=NULL; // the previous one in the list
	for (i=0; i<count; i++)
		{
		lib=iRecognizerLib[i];
		if (lib->iId.iUid==aUid)
			{// we may have to override one
			if (lib->iPresent!=CApaRecognizerDll::ENotPresent)
				{
				CleanupStack::PopAndDestroy(&implementationInfoArray);				
				return; // already found
				}
			else
				{
				if (lib->iVersion < version)
					{
					//Upgrade a plugin if a plugin with higher version than loaded plugin is installed.  
					lib->iPresent = CApaRecognizerDll::ESuperseded;
					break;
					}
				else
					{
					CleanupStack::PopAndDestroy(&implementationInfoArray);					
					lib->iPresent = CApaRecognizerDll::EIsPresent;
					return;
					}
				}
			}			
		}
	//Remove the old version and let it continue to load new version
	if ((i<count)&&(lib->iPresent==CApaRecognizerDll::ESuperseded))
		{
		RemoveRecognizer(lib);
		}

	// load the library
	HBufC* recogName=info->DisplayName().AllocL();
	CleanupStack::PushL(recogName);
	lib=NULL;
	lib = new(ELeave) CApaRecognizerDll(recogName);
	CleanupStack::Pop(recogName);
	CleanupStack::PushL(lib);
	TRAPD(error,lib->iRec = CApaDataRecognizerType::CreateDataRecognizerL(aUid));
	if(!error && lib->iRec)
		{
		lib->iPresent = CApaRecognizerDll::EIsPresent;
		AddDataRecognizerTypeL(lib->iRec);
		lib->iId.iUid = aUid;
		lib->iId.iDrive = aDrive;
		lib->iVersion=version;
		iExtra->iObserver->SetUpdateCounter(iExtra->iObserver->UpdateCounter() + 1);
		//
		// add lib to the library list
		iRecognizerLib.AppendL(lib);
		CleanupStack::Pop(lib); // lib
		}
	else
		{
		CleanupStack::PopAndDestroy(lib); // lib
		}
	CleanupStack::PopAndDestroy(&implementationInfoArray);	
	}
#else
void CApaScanningDataRecognizer::LoadEcomRecognizerL(TDriveUnit&,TUid)
	{
	}
#endif

void CApaScanningDataRecognizer::ScanForEcomRecognizersL()
	{
#ifdef USING_ECOM_RECOGS
	//scan ecom plugin
	RImplInfoPtrArray implementationArray;
	TCleanupItem cleanup(CleanUpEComInfoArray, &implementationArray);
	CleanupStack::PushL(cleanup);
	REComSession::ListImplementationsL(KUidDataRecogInterFaceUid,implementationArray);
	const TInt availCount = implementationArray.Count();
	for (TInt count=0;count<availCount;++count)
		{
		const CImplementationInformation* info = implementationArray[count];
		TUid uid = info->ImplementationUid();
		TDriveUnit drive=info-> Drive();
		TRAP_IGNORE(LoadEcomRecognizerL(drive,uid));
		}
	CleanupStack::PopAndDestroy(&implementationArray);
#endif
	}

/**
@internalTechnology
*/
EXPORT_C void CApaScanningDataRecognizer::LoadRecognizersL()
	{
	iExtra->iRecognizersLoaded = ETrue;
	ScanForRecognizersL();
	UpdateDataTypesL();
	}

/**
@internalTechnology
*/
EXPORT_C void CApaScanningDataRecognizer::UnloadRecognizers()
	{	
	iExtra->iRecognizersLoaded = EFalse;
	DestroyRecognizerList();
	iRecognizerLib.ResetAndDestroy();
	}