// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <apfrec.h>

#include <e32uid.h>

#include <f32file.h>

#include <apadef.h>

#include "APFSTD.H" // Panics etc.

#ifdef USING_ECOM_RECOGS

#include <ecom/ecom.h>

#endif

//

// class TRecognizer

//

CApaScanningFileRecognizer::TRecognizer::TRecognizer(HBufC* aName)

	: iName(aName)

	{

	}

///////////////////////////////

// CApaRecognizerDll

///////////////////////////////

class CApaRecognizerDll : public CBase

	{

public:

	CApaRecognizerDll(HBufC* aName);

	~CApaRecognizerDll(); // closes lib and deletes next

	enum TPresence { ENotPresent, EIsPresent, ESuperseded };

	inline TPresence Present() const { return iPresent; }

	inline void Present(TPresence aPresence) { iPresent = aPresence; }

	inline CApaFileRecognizerType* Recognizer() { return iRec; }

	inline void SetRecognizer(CApaFileRecognizerType& aRec) { iRec = &aRec; }

public:

	//lint --e{1925} Suppress "public data member" - bad OO but handy

	CApaRecognizerDll* iNext;

	CApaScanningFileRecognizer::TRecognizer iId; // cached so that this data can be accessed from other threads (RLibrary cant be used in this case)

private:

	RLibrary iLibrary;

	TPresence iPresent;

	CApaFileRecognizerType* iRec; // not ownership

	};

CApaRecognizerDll::~CApaRecognizerDll()

	{

	delete iId.iName;

	iLibrary.Close();

	delete iNext;

	iRec = NULL;

	}

CApaRecognizerDll::CApaRecognizerDll(HBufC* aName)

	: iId(aName)

	{

	}

#ifdef USING_ECOM_RECOGS

// CleanupEComArray function is 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

CApaScanningFileRecognizer::CApaBackupOperationObserver::CApaBackupOperationObserver(CApaScanningFileRecognizer& aRecognizer)

	: iRecognizer(aRecognizer)

	{

	TRAP_IGNORE(iSession = CBaBackupSessionWrapper::NewL());

	}

CApaScanningFileRecognizer::CApaBackupOperationObserver::~CApaBackupOperationObserver()

	{

	if (iSession)

		{

		iSession->DeRegisterBackupOperationObserver(*this);

		delete iSession;

		}

	}

void CApaScanningFileRecognizer::CApaBackupOperationObserver::RegisterObserverL()

	{

	if (iSession)

		{

		iSession->RegisterBackupOperationObserverL(*this);

		}

	}

void CApaScanningFileRecognizer::CApaBackupOperationObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)

	{

	if ((aBackupOperationAttributes.iFileFlag == MBackupObserver::EReleaseLockReadOnly ||

		aBackupOperationAttributes.iFileFlag == MBackupObserver::EReleaseLockNoAccess)

		&& aBackupOperationAttributes.iOperation == EStart)

		{

		// release recognizers not in rom

		CApaRecognizerDll* rec=iRecognizer.iRecognizerLib;

		while (rec)

			{

			CApaRecognizerDll* next=rec->iNext;

			TDriveUnit drive(rec->iId.iDrive);

			const TChar driveName=drive.Name()[0];

			if(driveName != TChar('Z'))

				{

				iRecognizer.RemoveRecognizer(*rec);// ignore errors

				}

			rec = next;

			}

		}

	if (aBackupOperationAttributes.iFileFlag == MBackupObserver::ETakeLock &&

		(aBackupOperationAttributes.iOperation == EEnd ||

		aBackupOperationAttributes.iOperation == EAbort))

		{

		iRecognizer.ScanForRecognizersL();

		}

	}

TInt CApaScanningFileRecognizer::CApaBackupOperationObserver::UpdateCounter() const

	{

	return iUpdateCounter;

	}

void CApaScanningFileRecognizer::CApaBackupOperationObserver::SetUpdateCounter(TInt aValue)

	{

	iUpdateCounter = aValue;

	}

///////////////////////////////

// CApaScanningFileRecognizer

///////////////////////////////

EXPORT_C CApaScanningFileRecognizer* CApaScanningFileRecognizer::NewL(RFs& aFs,MApaAppStarter* aAppStarter)

	{

	CApaScanningFileRecognizer* self=new(ELeave) CApaScanningFileRecognizer(aFs,aAppStarter);

	CleanupStack::PushL(self);

	self->ConstructL();

	self->ScanForRecognizersL();

	CleanupStack::Pop(); // self

	return self;

	}

EXPORT_C CApaScanningFileRecognizer::CApaScanningFileRecognizer(RFs& aFs,MApaAppStarter* aAppStarter)

	: CApaFileRecognizer(aFs), iAppStarter(aAppStarter)

	{}

EXPORT_C void CApaScanningFileRecognizer::ConstructL()

	{

	iObserver = new (ELeave) CApaBackupOperationObserver(*this);

	iObserver->RegisterObserverL();

	}

EXPORT_C CApaScanningFileRecognizer::~CApaScanningFileRecognizer()

	{

	DestroyRecognizerList();

	delete iRecognizerLib;

	delete iObserver;

	iAppStarter = NULL;

	}

EXPORT_C void CApaScanningFileRecognizer::ScanForRecognizersL()

	{

	// set all recognizers to not present - pending rediscoivery

	CApaRecognizerDll* rec=iRecognizerLib;

	while (rec)

		{

		rec->Present(CApaRecognizerDll::ENotPresent);

		rec = rec->iNext;

		}

	ScanForEcomRecognizersL();

	//

	// remove any recognizers that are no longer present

	rec=iRecognizerLib;

	while (rec)

		{

		CApaRecognizerDll* next=rec->iNext;

		if (rec->Present()==CApaRecognizerDll::ENotPresent)

			RemoveRecognizer(*rec);

		rec = next;

		}

	}

TInt CApaScanningFileRecognizer::RemoveRecognizer(CApaRecognizerDll& aDll)

	{

	// try to remove the recognizer from the list

	TInt ret=RemoveFileRecognizerType(aDll.Recognizer());

	if (ret!=KErrNone && ret!=KErrNotFound)

		return ret;

	//

	// get a handle to the previous entry in the list

	CApaRecognizerDll* prev=NULL;

	CApaRecognizerDll* dll=iRecognizerLib;

	while (dll && (dll != &aDll))

		{

		prev = dll;

		dll = dll->iNext;

		}

	if (!dll)

		{

		Panic(EPanicLibraryNotInList);

		}

	else

		{

		// remove the dll

		if (prev)

			prev->iNext = dll->iNext;

		else

			iRecognizerLib = dll->iNext;

		dll->iNext = NULL;

		delete dll;

		iObserver->SetUpdateCounter( iObserver->UpdateCounter()+ 1 );

		}

	return KErrNone;

	}

EXPORT_C TInt CApaScanningFileRecognizer::RecognizerCount()

	{

	CApaRecognizerDll* lib=iRecognizerLib;

	TInt count=0;

	while (lib)

		{

		count++;

		lib = lib->iNext;

		}

	return count;

	}

EXPORT_C CApaScanningFileRecognizer::CRecognizerArray* CApaScanningFileRecognizer::RecognizerListLC()const

	{

	CRecognizerArray* list=new(ELeave) CArrayFixFlat<TRecognizer>(1);

	CleanupStack::PushL(list);

	CApaRecognizerDll* dll=iRecognizerLib;

	while (dll)

		{

		list->AppendL(dll->iId);

		dll = dll->iNext;

		}

	return list;

	}

EXPORT_C const CApaScanningFileRecognizer::TRecognizer& CApaScanningFileRecognizer::operator[](TInt aIndex)const

	{

	__ASSERT_ALWAYS(aIndex>=0,Panic(EPanicNegativeIndex));

	// scan to correct dll

	TInt num=0;

	CApaRecognizerDll* dll=iRecognizerLib;

	while (dll && num++<aIndex)

		dll = dll->iNext;

	__ASSERT_ALWAYS(dll,Panic(EPanicIndexOutOfRange));

	//

	// get info from dll

	return dll->iId; //lint !e613 Suppress possible use of null pointer - asserted above

	}

EXPORT_C TInt CApaScanningFileRecognizer::UpdateCounter()const

	{

	return iObserver->UpdateCounter();

	}

EXPORT_C void CApaScanningFileRecognizer::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 CApaScanningFileRecognizer::SetEcomRecognizerL(const TRecognizer& aRecognizer)

	{

	//for ecom style 

	TDriveUnit drive(aRecognizer.iDrive);

	LoadEcomRecognizerL(drive,aRecognizer.iUid);

	}

//to find the name of  ecom style file recognizer corresponding to aImplUID

#ifdef USING_ECOM_RECOGS

HBufC* RecognizerNameL(TUid aImplUID)

	{

	RImplInfoPtrArray implementationInfoArray;

	TCleanupItem cleanup(CleanUpEComInfoArray, &implementationInfoArray);

	CleanupStack::PushL(cleanup);

	REComSession::ListImplementationsL(KUidFileRecogInterfaceUid,implementationInfoArray);

	const TInt availCount = implementationInfoArray.Count();

	for (TInt ii=0;ii<availCount;++ii)

		{

		CImplementationInformation* info = implementationInfoArray[ii];

		TUid uid = info->ImplementationUid();

		if(uid.iUid == aImplUID.iUid )

			{

			HBufC* recogName = info->DisplayName().AllocL();

			CleanupStack::PopAndDestroy(&implementationInfoArray);

			return recogName;

			}

		}

	CleanupStack::PopAndDestroy(&implementationInfoArray);

	return KNullDesC().AllocL();

	}

//load the ecom file recognizer

void CApaScanningFileRecognizer::LoadEcomRecognizerL(TDriveUnit& aDrive,TUid aUid)

	{

	// check we haven't loaded this one already

	CApaRecognizerDll* lib=iRecognizerLib;

	CApaRecognizerDll* last=NULL; // the previous one in the list

	while (lib)

		{

		if (lib->iId.iUid==aUid)

			{// we may have to override one

			if (lib->Present()!=CApaRecognizerDll::ENotPresent)

				{

				return; // already found

				}

			else

				{

				lib->Present(CApaRecognizerDll::EIsPresent);

				return;

				}

			}			

		last = lib;

		lib = lib->iNext;

		}

	// load the library

	HBufC* recogName=RecognizerNameL(aUid);

	CleanupStack::PushL(recogName);

	lib = new(ELeave) CApaRecognizerDll(recogName);

	CleanupStack::Pop(recogName);

	CleanupStack::PushL(lib);

	TRAPD(error,lib->SetRecognizer(*CApaFileRecognizerType::CreateFileRecognizerL(aUid)));

	if(!error && lib->Recognizer())

		{

		lib->Present(CApaRecognizerDll::EIsPresent);

		SetAppStarter(lib->Recognizer(),iAppStarter);

		AddFileRecognizerType(lib->Recognizer());

		lib->iId.iUid = aUid;

		lib->iId.iDrive = aDrive;

		iObserver->SetUpdateCounter( iObserver->UpdateCounter() + 1 );

		//

		// add lib to the library list

		if (last)

			{

			while (last->iNext)

				{

				last=last->iNext;

				}

			__ASSERT_ALWAYS(last->iNext==NULL,Panic(EPanicIndexOutOfRange));

			last->iNext = lib;

			}

		else

			{

			iRecognizerLib = lib;

			}

		CleanupStack::Pop(lib); // lib

		}

	else

		{

		CleanupStack::PopAndDestroy(lib); // lib

		}

	}

#else

void CApaScanningFileRecognizer::LoadEcomRecognizerL(TDriveUnit&,TUid)

	{

	} //lint !e1762 Suppress member function could be made const

#endif

void CApaScanningFileRecognizer::ScanForEcomRecognizersL()

	{

#ifdef USING_ECOM_RECOGS

	//scan ecom plugin

	RImplInfoPtrArray implementationArray;

	TCleanupItem cleanup(CleanUpEComInfoArray, &implementationArray);

	CleanupStack::PushL(cleanup);

	REComSession::ListImplementationsL(KUidFileRecogInterfaceUid,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

	} //lint !e1762 Suppress member function could be made const