// 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();

 	}