// 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 "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// AppArc server session

// 

//

#include <e32svr.h>

#include <apacmdln.h>

#include <apaflrec.h>

#include <apsserv.h>

#include "APSSES.H"

#ifdef _DEBUG

#include "APSSTD.H"

#endif //_DEBUG

#include "APSCLSV.H"

#include <apsscan.h>

#include <apgaplst.h>

#include <apgicnfl.h>

#include <apmrec.h>

#include <apmstd.h>

#include <apmfndr.h>

#include <datastor.h>

#include <s32mem.h>

#include <s32strm.h>

#include <s32file.h>

#include "../apgrfx/apprivate.h"

#include "apgnotif.h"

#include "../apfile/aprfndr.h"

#include "ApLaunchChecker.h"

#include "apsnnapps.h"

#include "apsecutils.h"

const TInt KApaAppListServMaxBuffer=256;

#include "APSRECCACHE.h"

const TInt KApaAppInfoArrayGranularity=4;

const TInt KApaAppInfoDesMaxLength=sizeof(TApaAppInfo);

#if defined(__PROFILE)

_LIT(KProfileAppForDocumentL, "AppForDocumentL - %d.%06d seconds");

_LIT(KProfileAppForDocumentPassedByFileHandleL, "AppForDocumentPassedByFileHandleL - %d.%06d seconds");

#endif

_LIT(KApaPanicCli,"APSERV-CLI");

const TInt KFinishedScanning=-2;

class MArrayItemWriter

	{

public:

	virtual TInt ArrayItemCount() const=0;

	virtual TInt ArrayItemSize() const=0;

	virtual void WriteArrayItemL(RWriteStream& aWriteStream,TInt aIndex) const=0;

	};

class TSizeArrayItemWriter : public MArrayItemWriter

	{

public:

	inline TSizeArrayItemWriter(const CArrayFix<TSize>& aArray) : iArray(aArray) {}

	// from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

	void WriteArrayItemL(RWriteStream& aWriteStream,TInt aIndex) const;

private:

	const CArrayFix<TSize>& iArray;

	};

class TViewDataArrayItemWriter : public MArrayItemWriter

	{

public:

	inline TViewDataArrayItemWriter(const CArrayPtr<CApaAppViewData>& aArray) : iArray(aArray) {}

	// from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

	void WriteArrayItemL(RWriteStream& aWriteStream,TInt aIndex) const;

private:

	const CArrayPtr<CApaAppViewData>& iArray;

	};

class TDesCArrayItemWriter : public MArrayItemWriter

	{

public:

	inline TDesCArrayItemWriter(const CDesCArray& aArray) : iArray(aArray) {}

	// from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

	void WriteArrayItemL(RWriteStream& aWriteStream,TInt aIndex) const;

private:

	const CDesCArray& iArray;

	};

class CApaAppListServSession::CApaAppInfo

	{

public:

	CApaAppInfo();

	~CApaAppInfo();

	void SetUid(const TUid aUid);

	void SetCaptionL(const TDesC& aCaption);

	void SetShortCaptionL(const TDesC& aShortCaption);

	void SetFullNameL(const TDesC& aFullName);

	inline TPtrC Caption() const;

	inline TPtrC ShortCaption() const;

	inline TPtrC FullName() const;

	inline TUid Uid() const;

private:

	TUid iUid;

	HBufC* iCaption;

	HBufC* iShortCaption;

	HBufC* iFullName;

	};

inline TPtrC CApaAppListServSession::CApaAppInfo::Caption() const

	{ return *iCaption; }

inline TPtrC CApaAppListServSession::CApaAppInfo::ShortCaption() const

	{ return *iShortCaption; }

inline TPtrC CApaAppListServSession::CApaAppInfo::FullName() const

	{ return *iFullName; }

inline TUid CApaAppListServSession::CApaAppInfo::Uid() const

	{ return iUid; }

// CApaAppListServSession

CApaAppListServSession* CApaAppListServSession::NewL(CApaAppListServer& aServer, RFs& aFs)

	{

	CApaAppListServSession* self=new(ELeave) CApaAppListServSession(aServer, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CApaAppListServSession::CApaAppListServSession(CApaAppListServer& aServer, RFs& aFs)

	: CSession2(),

	iServ(aServer),

	iFs(aFs),

	iMaxBufSize(KApaAppListServMaxBuffer),

	iApaAppInfoArray(KApaAppInfoArrayGranularity),

	iOpaqueData_pendingDispatchToClient(NULL)

	{}

void CApaAppListServSession::ConstructL()

	{

	iFileRecognitionUtility = new (ELeave) CFileRecognitionUtility(iServ, iMaxBufSize, iFs);

	iNonNativeApplicationsManager = CApsNonNativeApplicationsManager::NewL(iServ,iFs);

	}

CApaAppListServSession::~CApaAppListServSession()

	{

	delete iNonNativeApplicationsManager;

	delete iBuffer;

	iApaAppInfoArray.ResetAndDestroy();

	iApaAppInfoArray.Close();

	delete iFileRecognitionUtility;

	delete iRecognitionResult;

	delete iOpaqueData_pendingDispatchToClient;

	}

void CApaAppListServSession::ServiceL(const RMessage2& aMessage)

	{

	TBool completeMessage=ETrue;

	switch (aMessage.Function())

		{

	case ESetNotify:

		SetNotify(aMessage);

		completeMessage=EFalse;

		break;

	case ERegisterListPopulationCompleteObserver:

		RegisterListPopulationCompleteObserver(aMessage);

		completeMessage=EFalse;

		break;

	case ECancelListPopulationCompleteObserver:

		CancelListPopulationCompleteObserver();

		break;

	case EAppListServInitFullList:

		User::Leave(KErrNotSupported);

	case EAppListServInitEmbedList:

		User::Leave(KErrNotSupported);

	case EAppListServInitFilteredEmbedList:

		InitListL(aMessage,EListFilteredEmbeddedApps);

		break;

	case EAppListServInitAttrFilteredList:

		InitListL(aMessage,EListCapabilityAttrFilteredApps);

		break;

	case EAppListServInitServerAppList:

		InitListL(aMessage,EListServerApps);

		break;

	case EAppListServGetNextApp:

		GetNextAppL(aMessage);

		break;

	case EAppListServEmbedCount:

		EmbedCount(aMessage);

		break;

	case EAppListServAppCount:

		AppCount(aMessage);

		break;

	case EAppListServGetAppInfo:

		GetAppInfoL(aMessage);

		break;

	case EAppListServGetAppCapability:

		GetAppCapabilityL(aMessage);

		break;

	case EAppListServGetDefaultScreenNumber:

		GetDefaultScreenNumberL(aMessage);

		break;

	case EAppListServStartAppWithoutReturningThreadId:

		StartAppL(aMessage,EFalse);

		break;

	case EAppListServStartAppReturningThreadId:

		StartAppL(aMessage,ETrue);

		break;

	case EAppListServRecognizeData:

		RecognizeDataL(aMessage);

		break;

	case EAppListServRecognizeDataPassedByFileHandle:

		RecognizeDataPassedByFileHandleL(aMessage);

		break;

	case EAppListServRecognizeSpecificData:

		RecognizeSpecificDataL(aMessage);

		break;

	case EAppListServRecognizeSpecificDataPassedByFileHandle:

		RecognizeSpecificDataPassedByFileHandleL(aMessage);

		break;

	case EAppListServAppForDataType:

		AppForDataTypeL(aMessage);

		break;

	case EAppListServStartDocument:

		StartDocumentL(aMessage,EStart);

		break;

	case EAppListServStartDocumentByDataType:

		StartDocumentL(aMessage,EStartByDataType);

		break;

	case EAppListServStartDocumentByUid:

		StartDocumentL(aMessage,EStartByUid);

		break;

	case EAppListServCreateDocumentByUid:

		StartDocumentL(aMessage,ECreateByUid);

		break;

	case EAppListServGetExecutableNameGivenDocument:

		GetExecutableNameGivenDocumentL(aMessage);

		break;

	case EAppListServGetExecutableNameGivenDocumentPassedByFileHandle:

		GetExecutableNameGivenDocumentPassedByFileHandleL(aMessage);

		break;

	case EAppListServGetExecutableNameGivenDataType:

		GetExecutableNameGivenDataTypeL(aMessage);

		break;

	case EAppListServGetExecutableNameGivenAppUid:

		GetExecutableNameGivenAppUidL(aMessage);

		break;

	case EAppListServGetOpaqueData:

		GetOpaqueDataL(aMessage);

		break;

	case EAppListServGetNativeExecutableNameIfNonNative:

		GetNativeExecutableNameIfNonNativeL(aMessage);

		break;

	case EAppListServAppIconByUid:

		IconForAppL(aMessage);

		break;

	case EAppListServAppForDocument:

		AppForDocumentL(aMessage, NULL);

		break;

	case EAppListServAppForDocumentPassedByFileHandle:

		AppForDocumentPassedByFileHandleL(aMessage, NULL);

		break;

	case EAppListServGetConfidence:

		GetConfidenceL(aMessage);

		break;

	case EAppListServSetConfidence:

		SetConfidence(aMessage);

		break;

	case EAppListServGetBufSize:

		GetBufSize(aMessage);

		break;

	case EAppListServSetBufSize:

		SetBufSize(aMessage);

		break;

	case EAppListServGetDataTypesPhase1:

		GetDataTypesCountL(aMessage);

		break;

	case EAppListServGetDataTypesPhase2:

		GetDataTypesL(aMessage);

		break;

	case ECancelNotify:

		CancelNotify();

		break;

	case EAppListServAppIconByUidAndSize:

		IconForAppBySizeL(aMessage);

		break;

	case EAppListServAppIconFileHandle:

		IconFileHandleForAppL(aMessage);

		break;	

	case EAppListServGetAppIconSizes:

		AppIconSizesL(aMessage);

		break;

	case EAppListServViewIconByUidAndSize:

		IconForViewBySizeL(aMessage);

		break;

	case EAppListServGetAppViews:

		AppViewsL(aMessage);

		break;

	case EAppListServGetFileOwnershipInfo:

		AppFileOwnershipInfoL(aMessage);

		break;

	case EAppListServNumberOfOwnDefinedIcons:

		NumberOfOwnDefinedIconsL(aMessage);

		break;

	case EAppListServApplicationLanguage:

		ApplicationLanguageL(aMessage);

		break;

	case EAppListServAppInfoProvidedByRegistrationFile: // private OpCode for CEikApplication's use only

		AppInfoProvidedByRegistrationFileL(aMessage);

		break;

	case EAppListServAppIconFileName:

		IconFileNameL(aMessage);

		break;

	case EAppListServAppViewIconFileName:

		ViewIconFileNameL(aMessage);

		break;

	case EAppListInsertDataMapping:

	case EAppListInsertDataMappingIfHigher:

		InsertDataMappingL(aMessage);

		break;

	case EAppListDeleteDataMapping:

		DeleteDataMappingL(aMessage);

		break;

	case EAppListServGetAppByDataType:

		GetAppByDataTypeL(aMessage);

		break;		

	case EAppListServGetAppServices:

	case EAppListServGetServiceImplementations:

	case EAppListServGetServiceImplementationsDataType:

	case EAppListServGetAppServiceUids:

	case EAppListServGetAppServiceOpaqueData:

		GetAppServicesL(aMessage);

		break;

	case EAppListServAppForDataTypeAndService:

		AppForDataTypeAndServiceL(aMessage);

		break;

	case EAppListServAppForDocumentAndService:

		{

		const TUid serviceUid=TUid::Uid(aMessage.Int1());

		AppForDocumentL(aMessage, &serviceUid);

		}

		break;

	case EAppListServAppForDocumentAndServicePassedByFileHandle:

		{

		const TUid serviceUid(TUid::Uid(aMessage.Int1()));

		AppForDocumentPassedByFileHandleL(aMessage, &serviceUid);

		}

		break;

	case EAppListServRegisterNonNativeApplicationType:

		RegisterNonNativeApplicationTypeL(aMessage);

		break;

	case EAppListServDeregisterNonNativeApplicationType:

		DeregisterNonNativeApplicationTypeL(aMessage);

		break;

	case EAppListServPrepareNonNativeApplicationsUpdates:

		iNonNativeApplicationsManager->PrepareNonNativeApplicationsUpdatesL();

		break;

	case EAppListServRegisterNonNativeApplication:

		iNonNativeApplicationsManager->RegisterNonNativeApplicationL(aMessage);

		break;

	case EAppListServDeregisterNonNativeApplication:

		iNonNativeApplicationsManager->DeregisterNonNativeApplicationL(aMessage);

		break;

	case EAppListServCommitNonNativeApplications:

		iNonNativeApplicationsManager->CommitNonNativeApplicationsUpdatesL(aMessage);

		completeMessage=EFalse;

		break;

	case EAppListServRollbackNonNativeApplications:

		iNonNativeApplicationsManager->RollbackNonNativeApplicationsUpdates();

		break;

	case EAppListServGetAppType:

		GetAppTypeL(aMessage);

		break;

	case EAppListServForceRegistration:

		ForceRegistrationL(aMessage);

		completeMessage=EFalse;

		break;

	case EAppListServPreferredBufSize:

		aMessage.Complete(PreferredBufSize());

		break;

	case EAppListServRecognizeFiles:

		RecognizeFilesL(aMessage);

		break;

	case EAppListServTransferRecognitionResult:

		TransferRecognitionResultL(aMessage);

		break;

	case EAppListServRecognizeFilesAsync:

		RecognizeFilesAsyncL(aMessage);

		completeMessage=EFalse;

		break;

	case ECancelRecognizeFiles:

		CancelRecognizeFiles();

		break;

	case EAppListServRuleBasedLaunching:

		RuleBasedLaunchingL(aMessage);

		break;

	case EMatchesSecurityPolicy:

		MatchesSecurityPolicyL(aMessage);

		break;

	case EAppListServSetAppShortCaption:

		SetAppShortCaptionL(aMessage);

		break;

	case ENotifyOnDataMappingChange:

		NotifyOnDataMappingChange(aMessage);

		completeMessage=EFalse;

		break;

	case ECancelNotifyOnDataMappingChange:

		CancelNotifyOnDataMappingChange();

		break;

	case EDebugHeapMark:

	#ifdef _DEBUG

		__UHEAP_MARK;

	#endif

		break;

	case EDebugHeapMarkEnd:

	#ifdef _DEBUG

		__UHEAP_MARKENDC(aMessage.Int0());

	#endif

		break;

	case EDebugHeapFailNext:

	#ifdef _DEBUG

		__UHEAP_FAILNEXT(aMessage.Int0());

	#endif

		break;

	case EDebugClearAppInfoArray:

	#ifdef _DEBUG

		iApaAppInfoArray.ResetAndDestroy();

		iApaAppInfoArray.Compress();

	#endif

		break;

	case EDebugFlushRecognitionCache:

	#ifdef _DEBUG

		iServ.FlushRecognitionCache();

	#endif

		break;

	case EDebugSetLoadRecognizersOnDemand:

	#ifdef _DEBUG

		iServ.SetLoadRecognizersOnDemandL(aMessage.Int0());

	#endif

		break;

	case EDebugPerformOutstandingRecognizerUnloading:

	#ifdef _DEBUG

		iServ.PerformOutstandingRecognizerUnloading();

		REComSession::FinalClose();

	#endif

		break;

	case EDebugAddFailingNonNativeApplicationsUpdate:

	#ifdef _DEBUG

		iNonNativeApplicationsManager->ForceFailInNonNativeApplicationsUpdatesL();

	#endif

		break;

	case EDebugAddPanicingNonNativeApplicationsUpdate:

	#ifdef _DEBUG

		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsUpdatesL();

	#endif

		break;

	case EDebugAddRollbackPanicingNonNativeApplicationsUpdate:

	#ifdef _DEBUG

		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsRollbackL();

	#endif

		break;

	default:

		aMessage.Panic(KApaPanicCli,EClientBadRequest);

		break;

		}

	if (completeMessage && !aMessage.IsNull())

		{

		aMessage.Complete(KErrNone);

		}

	}

void CApaAppListServSession::NotifyOnDataMappingChange(const RMessage2& aMessage)

	{ 

	if (!iMessage_NotifyOnDataMappingChange.IsNull())

			{

			aMessage.Panic(KApaPanicCli,ENotifyOnDataMappingChangeRequestOutstanding);

			}

	else

			{

			iMessage_NotifyOnDataMappingChange=aMessage;

			}

	}

void CApaAppListServSession::CancelNotifyOnDataMappingChange()

	{

	if (!iMessage_NotifyOnDataMappingChange.IsNull())

			{

			iMessage_NotifyOnDataMappingChange.Complete(KErrCancel);

			}

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

TInt CApaAppListServSession::PreferredBufSize() const

	{

	TInt preferredBufferSize = 0;

	TRAPD(err, preferredBufferSize = iServ.DataRecognizerPreferredBufSizeL());

	return (err==KErrNone) ? Min(iMaxBufSize, preferredBufferSize) : iMaxBufSize;

	}

void CApaAppListServSession::RegisterNonNativeApplicationTypeL(const RMessage2& aMessage)

	{

	const TUid applicationType(TUid::Uid(aMessage.Int0()));

	HBufC* const nativeExecutable=HBufC::NewLC(User::LeaveIfError(aMessage.GetDesLength(1)));

	{TPtr nativeExecutable_asWritable(nativeExecutable->Des());

	aMessage.ReadL(1, nativeExecutable_asWritable);}

	iServ.RegisterNonNativeApplicationTypeL(applicationType, *nativeExecutable);

	CleanupStack::PopAndDestroy(nativeExecutable);

	}

void CApaAppListServSession::DeregisterNonNativeApplicationTypeL(const RMessage2& aMessage)