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

// AppArc server session

// 

// apsses.cpp

//

#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 "../aplist/aplappregfinder.h"

#include "ApLaunchChecker.h"

#include "apsnnapps.h"

#include "../aplist/aplapplistitem.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;

	};

NONSHARABLE_CLASS(TSizeArrayItemWriter) : public MArrayItemWriter

	{

public:

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

public: // from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

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

private:

	const CArrayFix<TSize>& iArray;

	};

NONSHARABLE_CLASS(TViewDataArrayItemWriter) : public MArrayItemWriter

	{

public:

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

public:	// from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

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

private:

	const CArrayPtr<CApaAppViewData>& iArray;

	};

NONSHARABLE_CLASS(TDesCArrayItemWriter) : public MArrayItemWriter

	{

public:

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

public:	// from MArrayItemWriter

	TInt ArrayItemCount() const;

	TInt ArrayItemSize() const;

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

private:

	const CDesCArray& iArray;

	};

NONSHARABLE_CLASS(CApaAppListServSession::CApaAppInfo) : public CBase

	{

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(RFs& aFs, CApaAppArcServer& aAppArcSrv, CApaAppList& aAppList)

	{

	CApaAppListServSession* self = new (ELeave) CApaAppListServSession(aFs, aAppArcSrv, aAppList);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CApaAppListServSession::CApaAppListServSession(RFs& aFs, CApaAppArcServer& aAppArcSrv, CApaAppList& aAppList)

 : iFs(aFs), iAppArcSrv(aAppArcSrv), iAppList(aAppList), iApaAppInfoArray(KApaAppInfoArrayGranularity)

	{

	}

void CApaAppListServSession::ConstructL()

	{

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

	}

CApaAppListServSession::~CApaAppListServSession()

	{

	delete iNonNativeApplicationsManager;

	iApaAppInfoArray.ResetAndDestroy();

	iApaAppInfoArray.Close();

	}

CApaAppList& CApaAppListServSession::AppList()

	{

	return iAppList;

	}

void CApaAppListServSession::DoServiceL(const RMessage2& aMessage)

	{

	TBool completeMessage = ETrue;

	const TInt opcode = aMessage.Function();

	switch (opcode)

		{

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

		IconForAppL(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 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 EMatchesSecurityPolicy:

		MatchesSecurityPolicyL(aMessage);

		break;

	case EAppListServSetAppShortCaption:

		SetAppShortCaptionL(aMessage);

		break;

	case EDebugClearAppInfoArray:

	#ifdef _DEBUG

		iApaAppInfoArray.ResetAndDestroy();

		iApaAppInfoArray.Compress();

	#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);

	}

// CApaAppArcServSession

CApaAppArcServSession* CApaAppArcServSession::NewL(CApaAppArcServer& aServer, RFs& aFs)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CApaAppArcServSession::CApaAppArcServSession(CApaAppArcServer& aServer, RFs& aFs)

	: CSession2(),

	iServ(aServer),

	iFs(aFs),

	iMaxBufSize(KApaAppListServMaxBuffer),

	iOpaqueData_pendingDispatchToClient(NULL)

	{}

void CApaAppArcServSession::ConstructL()

	{

	iAppListSession = CApaAppListServSession::NewL(iFs, iServ, iServ.AppList());

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

	}

CApaAppArcServSession::~CApaAppArcServSession()

	{

	delete iAppListSession;

	delete iBuffer;

	delete iFileRecognitionUtility;

	delete iRecognitionResult;

	delete iOpaqueData_pendingDispatchToClient;

	}

void CApaAppArcServSession::ServiceL(const RMessage2& aMessage)

	{

	TBool completeMessage = ETrue;

	switch (aMessage.Function())

		{

	case EAppListServStartAppWithoutReturningThreadId:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

		break;

	case EAppListServStartAppReturningThreadId:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

		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:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

		break;

	case EAppListServStartDocumentByDataType:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

		break;

	case EAppListServStartDocumentByUid:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

		break;

	case EAppListServCreateDocumentByUid:

		ASSERT(0);	// panic debug only

		User::Leave(KErrNotSupported);

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

		AquirePermissionToLaunchAppL(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 EDebugFlushRecognitionCache:

	#ifdef _DEBUG

		iServ.FlushRecognitionCache();

	#endif

		break;

	case EDebugSetLoadRecognizersOnDemand:

	#ifdef _DEBUG

		iServ.SetLoadRecognizersOnDemandL(aMessage.Int0());