// 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:

//

#include "../apserv/APSCLSV.H"

#include "APGCLI.H"

#include "APACMDLN.H"

#include "APGSTD.H"

#include "APGICNFL.H"

#include <apsserv.h>

#include <apmrec.h>

#include <s32mem.h>

#include "APGPRIV.H"

#include <apadef.h>

#include "apprivate.h"

#if defined(USE_IH_RAISE_EVENT)

#include <SystemMonitor/RaiseEvent.h>

#include <test/testinstrumentation.h>

#endif

class CApaLsSessionExtension;

const TUint KInitialIconBufSize=sizeof(TSize)*6+sizeof(TInt);

const TUint KInitialViewDataBufSize=sizeof(TApaAppViewInfo)*6+sizeof(TInt);

const TUint KInitialOwnedFilesBufSize=sizeof(TFileName)*6+sizeof(TInt);

const TUint KDefaultBufSize = 0x400;

const TUint KAsyncMessageSlots=4; //one slot each for, RApaLsSession::SetNotify, RApaLsSession::

                                  //RegisterListPopulationCompleteObserver and RApaLsSession::NotifyOnDataMappingChange

                                  //CAsyncFileRecognition::Start makes an asynch request of apparc server.

_LIT8(KAllDataTypes,"*");

extern void CleanupServiceArray(TAny* aServiceArray);

IMPORT_C extern const TInt KMinApplicationStackSize;

class MArrayFiller

	{

public:

	virtual void AppendItemL(RReadStream& aReadStream)=0;

	};

class TSizeArrayFiller : public MArrayFiller

	{

public:

	inline TSizeArrayFiller(CArrayFixFlat<TSize>& aArray) :iArray(aArray) {}

	virtual void AppendItemL(RReadStream& aReadStream);

private:

	CArrayFixFlat<TSize>& iArray;

	};

class TViewDataArrayFiller : public MArrayFiller

	{

public:

	inline TViewDataArrayFiller(CApaAppViewArray& aArray) :iArray(aArray) {}

	virtual void AppendItemL(RReadStream& aReadStream);

private:

	CApaAppViewArray& iArray;

	};

class TDesCArrayFiller : public MArrayFiller

	{

public:

	inline TDesCArrayFiller(CDesCArray& aArray) :iArray(aArray) {}

	virtual void AppendItemL(RReadStream& aReadStream);

private:

	CDesCArray& iArray;

	};

/**

This class is used to simplify the usage of the asynchronous RApaLsSession::RecognizeFilesL() function.

@internalComponent

*/

class CAsyncFileRecognition : public CActive

	{

public:

	CAsyncFileRecognition(CDataRecognitionResultArray& aResult, TRequestStatus& aUsersRequestStatus, CApaLsSessionExtension& aSession);

	~CAsyncFileRecognition();

	void Start(const TDesC& aPath, const TDesC8& aDataType);

private:

	void RunL();

	void DoCancel();

private: // data

	TPckgBuf<TUint> iRequiredBufferSizePckg;

	CDataRecognitionResultArray& iResult;

	TRequestStatus& iUsersRequestStatus;

	CApaLsSessionExtension& iSession;

	const TDesC* iPath;

	const TDesC8* iDataType;

	};

/**

This class is an extension class for RApaLsSession. It was added to reduce the need

of BC breaks in later releases.

@internalComponent

*/

class CApaLsSessionExtension : public CBase

	{

public:

	CApaLsSessionExtension(RApaLsSession& aSession);

	~CApaLsSessionExtension();

	void SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;

	TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;

	// file recognition functions

	void RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus);

	void CancelRecognizeFiles();

	void FilesRecognized(const TDesC& aPath, TInt aRequiredBufferSize, CDataRecognitionResultArray& aResult, TRequestStatus& aUsersRequestStatus, const TRequestStatus& aErrorCode);

	TBool RecognitionActive() const;

private:

	RApaLsSession& iSession;	// we are a friend of this class!

	CAsyncFileRecognition* iAsyncFileRecognition;

	};

/**

An entry of a CDataRecognitionResultArray object. Stores TDataRecognitionResult and the file name

in a compact format.

@internalComponent

*/

class CDataRecognitionResultArrayEntry : public CBase

	{

public:

	CDataRecognitionResultArrayEntry(HBufC* aFileName, HBufC8* aDataType, TUid aUid, TInt aConfidence);

	~CDataRecognitionResultArrayEntry();

	void GetDataRecognitionResult(TDataRecognitionResult& aResult) const;

	const TDesC& FileName() const;

private:

	HBufC* iFileName;

	HBufC8* iDataType;

	TUid iUid;

	TInt iConfidence;

	};

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

// CAsyncFileRecognition

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

CAsyncFileRecognition::CAsyncFileRecognition(CDataRecognitionResultArray& aResult, TRequestStatus& aUsersRequestStatus, CApaLsSessionExtension& aSession)

	: CActive(EPriorityStandard),

	  iResult(aResult),

	  iUsersRequestStatus(aUsersRequestStatus),

	  iSession(aSession)

	{

	CActiveScheduler::Add(this);

	}

void CAsyncFileRecognition::Start(const TDesC& aPath, const TDesC8& aDataType)

	{

	iPath = &aPath;

	iDataType = &aDataType;

	iStatus = KRequestPending;

	iSession.SendReceive(EAppListServRecognizeFilesAsync,TIpcArgs(&aPath,&iRequiredBufferSizePckg,&aDataType),iStatus);

	SetActive();

	}

CAsyncFileRecognition::~CAsyncFileRecognition()

	{

	Cancel();

	iPath = NULL;

	iDataType = NULL;

	}

void CAsyncFileRecognition::RunL()

	{

	iSession.FilesRecognized(*iPath, iRequiredBufferSizePckg(), iResult, iUsersRequestStatus, iStatus);

	}

void CAsyncFileRecognition::DoCancel()

	{

	iSession.SendReceive(ECancelRecognizeFiles,TIpcArgs(TIpcArgs::ENothing));

	TRequestStatus* status = &iUsersRequestStatus;

	User::RequestComplete( status, KErrCancel );

	}

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

// CApaLsSessionExtension

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

CApaLsSessionExtension::CApaLsSessionExtension(RApaLsSession& aSession)

	: iSession(aSession),

	  iAsyncFileRecognition(NULL)

	{

	}

CApaLsSessionExtension::~CApaLsSessionExtension()

	{

	delete iAsyncFileRecognition;

	}

void CApaLsSessionExtension::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const

	{

	iSession.SendReceive(aFunction,aArgs,aStatus); //lint !e1060 Suppress protected member is not accessible to non-member non-friend

	}

TInt CApaLsSessionExtension::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

	{

	return iSession.SendReceive(aFunction,aArgs); //lint !e1060 Suppress protected member is not accessible to non-member non-friend

	}

/**

Asynchronous recognition of a directory.

Function uses an internal CAsyncFileRecognition object to hide the 

second server message (transferring the data to the client) from the user.

When the path is not correct or the server is already busy with another 

recognition request, the function completes the request with an error.

@internalComponent

*/

void CApaLsSessionExtension::RecognizeFilesL(const TDesC& aPath, const TDesC8& aDataType, CDataRecognitionResultArray& aResult, TRequestStatus& aStatus)

	{

	_LIT(KBackslash,"\\");

	if(aPath.Right(1) != KBackslash)

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status,KErrPathNotFound);

		}

	aResult.SetPath(aPath);

	aStatus = KRequestPending;

	if(!iAsyncFileRecognition)

		{

		iAsyncFileRecognition = new (ELeave) CAsyncFileRecognition(aResult, aStatus, *this);

		iAsyncFileRecognition->Start(aPath, aDataType);

		}

	else

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status,KErrInUse);

		}

	}

TBool CApaLsSessionExtension::RecognitionActive() const

	{

	return iAsyncFileRecognition ? ETrue : EFalse;

	}

void CApaLsSessionExtension::CancelRecognizeFiles()

	{

	if(iAsyncFileRecognition)

		{

		iAsyncFileRecognition->Cancel();

		delete iAsyncFileRecognition;

		iAsyncFileRecognition = NULL;

		}

	}

void CApaLsSessionExtension::FilesRecognized(const TDesC& aPath, TInt aRequiredBufferSize, CDataRecognitionResultArray& aResult, TRequestStatus& aUsersRequestStatus, const TRequestStatus& aErrorCode)

/**

Callback function called by an CAsyncFileRecognition object, when an asynchronous

recognition has finished. If the recognition was successful, the data is transferred

to the client-side.

@internalComponent

*/

	{

	TRequestStatus* status = &aUsersRequestStatus;

	if(aErrorCode == KErrNone)

		{

		// transfer the result

		TRAPD(error,iSession.TransferAndInternalizeDataL(aPath, aRequiredBufferSize, aResult));

		User::RequestComplete(status, error);

		}

	else

		{

		User::RequestComplete(status, aErrorCode.Int());

		}

	delete iAsyncFileRecognition;

	iAsyncFileRecognition = 0;

	}

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

// CDataRecognitionResultArrayEntry

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

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

	: iFileName(aFileName), 

	  iDataType(aDataType), 

	  iUid(aUid), 

	  iConfidence(aConfidence)

	{

	}

CDataRecognitionResultArrayEntry::~CDataRecognitionResultArrayEntry()

	{

	delete iFileName;

	delete iDataType;

	}

void CDataRecognitionResultArrayEntry::GetDataRecognitionResult(TDataRecognitionResult& aResult) const

	{

	TDataRecognitionResult result;

	if(iDataType->Length() != 0)

		{

		TDataType dataType(*iDataType);

		result.iDataType = dataType;

		}

	else

		{

		TDataType dataType(iUid);

		result.iDataType = dataType;

		}

	result.iConfidence = iConfidence;

	aResult = result;

	}

const TDesC& CDataRecognitionResultArrayEntry::FileName() const

	{

	if (iFileName == NULL)

		return KNullDesC;

	else

		return *iFileName;

	}

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

// CDataRecognitionResultArray

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

/**

Constructor

@publishedAll

@released

*/

EXPORT_C CDataRecognitionResultArray::CDataRecognitionResultArray()

	{

	}

/**

Destructor

@publishedAll

@released

*/

EXPORT_C CDataRecognitionResultArray::~CDataRecognitionResultArray()

	{

	iEntries.ResetAndDestroy();

	}

/**

Returns the path of the recognition results.

@publishedAll

@released

@return The path of the recognition results

*/

EXPORT_C const TFileName& CDataRecognitionResultArray::Path() const

	{

	return iPath;

	}

/**

Returns the number of entries in the CDataRecognitionResultArray.

@publishedAll

@released

@return The number of entries in the CDataRecognitionResultArray.

*/

EXPORT_C TUint CDataRecognitionResultArray::Count() const

	{

	return iEntries.Count();

	}

/**

Returns the recognition result of the given index.

@publishedAll

@released

@param aResult On successful completion, this parameter contains the recognition result at the given index.

@param aIndex The index of the recognition result to be returned. An invalid index causes

the function to leave with KErrNotFound.

@return The requested TDataRecognitionResult object

@leave KErrNotFound An invalid index is passed

*/

EXPORT_C void CDataRecognitionResultArray::GetDataRecognitionResultL(TDataRecognitionResult& aResult, const TUint aIndex) const

	{

	if( aIndex >= iEntries.Count() )

		{

		User::Leave(KErrNotFound);

		}

	iEntries[aIndex]->GetDataRecognitionResult(aResult);

	}

/**

Returns the file name of the object at the given index.

@publishedAll

@released

@param aFileName On successful completion, this parameter contains the file name of the object at the given index. 

@param aIndex Specifies which file name to be returned. An invalid index causes

the function to leave with KErrNotFound.

@return The requested file name

@leave KErrNotFound An invalid index is passed

*/

EXPORT_C void CDataRecognitionResultArray::GetFileNameL(TFileName& aFileName, const TUint aIndex) const

	{

	if( aIndex >= iEntries.Count() )

		{

		User::Leave(KErrNotFound);

		}

	aFileName.Zero();

	aFileName.Copy( (iEntries[aIndex]->FileName()) );

	}

TUint CDataRecognitionResultArray::InternalizeL(const CBufFlat& aBuffer)

	{

	RBufReadStream readStream;

	readStream.Open(aBuffer);

	const TInt count=readStream.ReadUint32L();

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

		{

		const TInt fileNameLength = readStream.ReadUint8L();

		HBufC* const fileName = HBufC::NewLC(fileNameLength);

		TPtr fileNamePtr = fileName->Des();

		readStream.ReadL(fileNamePtr,fileNameLength);

		const TInt dataTypeLength = readStream.ReadUint8L();

		HBufC8* const dataType = HBufC8::NewLC(dataTypeLength);

		TPtr8 dataTypePtr = dataType->Des();

		readStream.ReadL(dataTypePtr,dataTypeLength);

		TUid uid;

		uid.iUid = readStream.ReadInt32L();

		TInt const confidence = readStream.ReadInt32L();

		CDataRecognitionResultArrayEntry* entry = new (ELeave) CDataRecognitionResultArrayEntry(fileName,dataType,uid,confidence);

		iEntries.Append(entry);

		CleanupStack::Pop(dataType);	// ownership was transferred to "entry"

		CleanupStack::Pop(fileName);	// ownership was transferred to "entry"

		}

	readStream.Close();

	return KErrNone;

	}

void CDataRecognitionResultArray::SetPath(const TFileName& aPath)

	{

	iPath.Copy(aPath);

	}

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

//RApaLsSession

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

EXPORT_C RApaLsSession::RApaLsSession()

	: iExtension(0)

	{}

/** Connects a client to the application architecture server, creating a session 

with it.

@return KErrNone if successful; otherwise, one of the system-wide error codes. 

*/

EXPORT_C TInt RApaLsSession::Connect()

	{

	TInt r=CreateSession(KAppListServerName,Version(),KAsyncMessageSlots);

	return(r); 

	}

/** Gets the version of the application architecture server.

@return The version number. 

*/

EXPORT_C TVersion RApaLsSession::Version(void) const

	{

	return(TVersion(KAppListServMajorVersionNumber,KAppListServMinorVersionNumber,KAppListServBuildVersionNumber));

	}

/** Gets the total number of applications.

Control panel applications are excluded.

@param aCount On return, the total number of applications.

@return KErrNone if successful, otherwise one of the system-wide error codes. 

*/

EXPORT_C TInt RApaLsSession::AppCount(TInt& aCount) const

	{

	return DoAppCount(aCount,EAppListServAppCount);

	}

/** Gets the total number of embeddable applications.

Control panel applications are excluded.

@param aCount On return, the total number of embeddable applications.

@return KErrNone, if successful, otherwise one of the system-wide error codes. 

*/

EXPORT_C TInt RApaLsSession::EmbeddableAppCount(TInt& aCount) const

	{

	return DoAppCount(aCount,EAppListServEmbedCount);

	}

TInt RApaLsSession::DoAppCount(TInt& aCount,TInt aCommand) const

// returns the number of embeddable apps in the server side list

	{

	__ASSERT_DEBUG(aCommand==EAppListServEmbedCount || aCommand==EAppListServAppCount,Panic(EDPanicWrongCommand));

	const TInt returnValue=SendReceiveWithReconnect(aCommand,TIpcArgs());

	if (returnValue<0)

		{

		return returnValue;

		}

	aCount=returnValue;

	return KErrNone;

	}

/** Initialises the process of getting all applications in the cached list.