// 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 the License "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:

// Classes for synchronous and asynchronous file recognitions (of a directory)

// 

//

#include "APSRECUTIL.H"

#include "APSRECCACHE.h"

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

// CRecognitionResult

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

CRecognitionResult* CRecognitionResult::NewL(const TDesC& aFileName, const TDataRecognitionResult& aRecognitionResult)

	{

	ASSERT(aFileName.Find(_L("\\")) == KErrNotFound); // the filename should not contain any path

	HBufC* fileName = aFileName.AllocLC();

	HBufC8* dataType = aRecognitionResult.iDataType.Des8().AllocLC();	

	CRecognitionResult* self = new(ELeave) CRecognitionResult(fileName, dataType, aRecognitionResult.iDataType.Uid(), aRecognitionResult.iConfidence);

	CleanupStack::Pop(2, fileName);

	return self;

	}

CRecognitionResult::CRecognitionResult(HBufC* aFileName, HBufC8* aDataType, TUid aUid, TInt aConfidence)

	: iFileName(aFileName),

	  iDataType(aDataType),

 	  iUid(aUid), 

	  iConfidence(aConfidence)

	{

	}

CRecognitionResult::~CRecognitionResult()

	{

	delete iFileName;

	delete iDataType;

	}

void CRecognitionResult::Get(TDataRecognitionResult& aRecognitionResult)

	{

	if(iUid == KNullUid)

		{

		aRecognitionResult.iDataType = TDataType(*iDataType);

		}

	else

		{

		aRecognitionResult.iDataType = TDataType(iUid);

		}

	aRecognitionResult.iConfidence = iConfidence;

	}

TUint CRecognitionResult::GetRequiredBufferSize() const

	{

	return iFileName->Size() + iDataType->Size() + sizeof(TUid) + sizeof(TInt) + 2;

	}

void CRecognitionResult::WriteToStreamL(RWriteStream& aWriteStream)

	{

	aWriteStream.WriteUint8L(iFileName->Length());

	aWriteStream.WriteL(*iFileName);

	aWriteStream.WriteUint8L(iDataType->Length());

	aWriteStream.WriteL(*iDataType);

	aWriteStream.WriteInt32L(iUid.iUid);

	aWriteStream.WriteInt32L(iConfidence);

	}

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

// CDirectoryRecognitionResult

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

CDirectoryRecognitionResult::CDirectoryRecognitionResult(HBufC* aPath, HBufC8* aDataTypeFilter)

	: iPath(aPath), iDataTypeFilter(aDataTypeFilter)

	{

	iRequiredBufferSize = sizeof(TUint);

	}

CDirectoryRecognitionResult::~CDirectoryRecognitionResult()

	{

	delete iPath;

	delete iDataTypeFilter;

	const TInt count = iEntries.Count();

	for(TInt i = 0; i < count; i++)

		{

		iEntries[i]->Close();

		}

	iEntries.Reset();

	}

void CDirectoryRecognitionResult::AppendL(CRecognitionResult* aEntry)

	{

	if(iDataTypeFilter)

		{

		if(aEntry->DataType().Match(*iDataTypeFilter) == KErrNotFound)

			{

			aEntry->Close(); //if we don't take ownership we must decrease reference count

			return;

			}

		}

	iEntries.AppendL(aEntry);

	iRequiredBufferSize += aEntry->GetRequiredBufferSize();

	} //lint !e818: Pointer parameter could be declared as pointing to const

void CDirectoryRecognitionResult::WriteToStreamL(RWriteStream& aWriteStream)

	{

	aWriteStream.WriteUint32L(iEntries.Count());

	for (TInt i=0; i < iEntries.Count(); i++)

		{

		iEntries[i]->WriteToStreamL(aWriteStream);

		}

	aWriteStream.CommitL();

	}

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

// CFileRecognitionUtility

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

CFileRecognitionUtility::CFileRecognitionUtility(CApaAppListServer& aServer, TInt aMaxBufSize, RFs& aFs)

	: CActive(0), 

	  iServer(aServer), 

	  iMaxBufSize(aMaxBufSize), 

	  iFs(aFs),

	  iIndex(0),

	  iStep(0)

	{

	CActiveScheduler::Add(this);

	}

CFileRecognitionUtility::~CFileRecognitionUtility()

	{

	Cancel();

	delete iEntryList;

	iPath = NULL;

	iResult = NULL;

	}

void CFileRecognitionUtility::RecognizeSynchronouslyL(CDirectoryRecognitionResult& aResult)

	{

	iPath = &(aResult.Path());

	iResult = &aResult;

	User::LeaveIfError(iFs.IsValidName(iPath->Des()));

	ReadDirectoryL();

	// recognize files and calculate size of buffer

	for(iIndex=0;iIndex<iEntryList->Count();iIndex++)

		{

		RecognizeFileL();

		}

	delete iEntryList;

	iEntryList = NULL;

	}

void CFileRecognitionUtility::RecognizeAsynchronously(CDirectoryRecognitionResult& aResult, const RMessage2& aMessage)

	{

	iIndex = 0;

	iStep = 0;

	iPath = &(aResult.Path());

	iResult = &aResult;

	iMessage = aMessage;

	NextStep();

	}

void CFileRecognitionUtility::ReadDirectoryL()

	{

	delete iEntryList;

	iEntryList = NULL;

	// read directory content

	User::LeaveIfError(iFs.GetDir(iPath->Des(),KEntryAttNormal,EDirsAnyOrder,iEntryList));

	}

TInt CFileRecognitionUtility::BufferSizeL() const

	{

	const TInt preferredBufferSize = iServer.DataRecognizerPreferredBufSizeL();

	TInt bufSize=Min(preferredBufferSize,iMaxBufSize);

	if (bufSize<1)

		{

		bufSize=8; // sensible minimum.

		}

	return bufSize;

	}

void CFileRecognitionUtility::RecognizeFileL()

	{

	TFileName fullFileName(*iPath);

	fullFileName.Append((*iEntryList)[iIndex].iName);

	RFile file;

	User::LeaveIfError(file.Open(iFs, fullFileName, EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(file);

	CRecognitionResult* result = NULL;

	TRAP_IGNORE(result = iServer.RecognizeDataAsCRecognitionResultL(file, BufferSizeL()));

	if(result)

		{

		CleanupClosePushL(*result);

		iResult->AppendL(result);

		CleanupStack::Pop(result);

		}

	CleanupStack::PopAndDestroy(&file);

	}

void CFileRecognitionUtility::CancelRecognitionRequest()

	{

	if(iStep <= 1)

		{

		Cancel();

		iMessage.Complete(KErrCancel);	

		}

	}

void CFileRecognitionUtility::NextStep()

	{

	TRequestStatus* pStatus = &iStatus;

	User::RequestComplete(pStatus, KErrNone);

	SetActive();

	}

void CFileRecognitionUtility::RunL()

	{

	switch(iStep)

		{

		case 0:		// first step: read the directory content

			ReadDirectoryL();

			iIndex=0;

			iStep++;

			NextStep();

			break;

		case 1:		// read current file and recognize it

			if(iIndex < iEntryList->Count())

				{

				RecognizeFileL();

				iIndex++;

				NextStep();

				}

			else	// finished

				{

				iMessage.WriteL(1,TPckgBuf<TUint>(iResult->RequiredBufferSize()));

				iMessage.Complete(KErrNone);

				iStep++;	// to show that we have completed the request

				delete iEntryList;

				iEntryList = NULL;

				}

			break;

		default:

			break;

		}

	}

void CFileRecognitionUtility::DoCancel()

	{

	iIndex = 0;

	iStep = 0;

	}