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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // AppArc server session

    15 // 

    16 // apsses.cpp

    17 //

    18 

    19 #include <e32svr.h>

    20 #include <apacmdln.h>

    21 

    22 #include <apaflrec.h>

    23 #include "apsserv.h"

    24 #include "APSSES.H"

    25 #ifdef _DEBUG

    26 #include "APSSTD.H"

    27 #endif //_DEBUG

    28 #include "APSCLSV.H"

    29 #include <apsscan.h>

    30 #include <apgaplst.h>

    31 #include <apgicnfl.h>

    32 #include <apmrec.h>

    33 #include <apmstd.h>

    34 #include <apmfndr.h>

    35 #include <datastor.h>

    36 #include <s32mem.h>

    37 #include <s32strm.h>

    38 #include <s32file.h>

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

    40 #include "apgnotif.h"

    41 #include "../aplist/aplappregfinder.h"

    42 #include "ApLaunchChecker.h"

    43 #include "apsnnapps.h"

    44 #include "../aplist/aplapplistitem.h"

    45 

    46 #include "apsecutils.h"

    47 

    48 const TInt KApaAppListServMaxBuffer=256;

    49 #include "APSRECCACHE.h"

    50 const TInt KApaAppInfoArrayGranularity = 4;

    51 const TInt KApaAppInfoDesMaxLength = sizeof(TApaAppInfo);

    52 

    53 #if defined(__PROFILE)

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

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

    56 #endif

    57 _LIT(KApaPanicCli,"APSERV-CLI");

    58 const TInt KFinishedScanning=-2;

    59 

    60 

    61 class MArrayItemWriter

    62 	{

    63 public:

    64 	virtual TInt ArrayItemCount() const=0;

    65 	virtual TInt ArrayItemSize() const=0;

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

    67 	};

    68 

    69 NONSHARABLE_CLASS(TSizeArrayItemWriter) : public MArrayItemWriter

    70 	{

    71 public:

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

    73 public: // from MArrayItemWriter

    74 	TInt ArrayItemCount() const;

    75 	TInt ArrayItemSize() const;

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

    77 private:

    78 	const CArrayFix<TSize>& iArray;

    79 	};

    80 

    81 NONSHARABLE_CLASS(TViewDataArrayItemWriter) : public MArrayItemWriter

    82 	{

    83 public:

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

    85 public:	// from MArrayItemWriter

    86 	TInt ArrayItemCount() const;

    87 	TInt ArrayItemSize() const;

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

    89 private:

    90 	const CArrayPtr<CApaAppViewData>& iArray;

    91 	};

    92 

    93 NONSHARABLE_CLASS(TDesCArrayItemWriter) : public MArrayItemWriter

    94 	{

    95 public:

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

    97 public:	// from MArrayItemWriter

    98 	TInt ArrayItemCount() const;

    99 	TInt ArrayItemSize() const;

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

   101 private:

   102 	const CDesCArray& iArray;

   103 	};

   104 

   105 NONSHARABLE_CLASS(CApaAppListServSession::CApaAppInfo) : public CBase

   106 	{

   107 public:

   108 	CApaAppInfo();

   109 	~CApaAppInfo();

   110 	void SetUid(const TUid aUid);

   111 	void SetCaptionL(const TDesC& aCaption);

   112 	void SetShortCaptionL(const TDesC& aShortCaption);

   113 	void SetFullNameL(const TDesC& aFullName);

   114 	inline TPtrC Caption() const;

   115 	inline TPtrC ShortCaption() const;

   116 	inline TPtrC FullName() const;

   117 	inline TUid Uid() const;

   118 private:

   119 	TUid iUid;

   120 	HBufC* iCaption;

   121 	HBufC* iShortCaption;

   122 	HBufC* iFullName;

   123 	};

   124 

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

   126 	{ return *iCaption; }

   127 

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

   129 	{ return *iShortCaption; }

   130 

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

   132 	{ return *iFullName; }

   133 

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

   135 	{ return iUid; }

   136 

   137 //

   138 // CApaAppListServSession

   139 //

   140 

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

   142 	{

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

   144 	CleanupStack::PushL(self);

   145 	self->ConstructL();

   146 	CleanupStack::Pop(self);

   147 	return self;

   148 	}

   149 

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

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

   152 	{

   153 

   154 	}

   155 

   156 void CApaAppListServSession::ConstructL()

   157 	{

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

   159 	}

   160 	

   161 

   162 CApaAppListServSession::~CApaAppListServSession()

   163 	{

   164 	delete iNonNativeApplicationsManager;

   165 	iApaAppInfoArray.ResetAndDestroy();

   166 	iApaAppInfoArray.Close();

   167 	}

   168 

   169 CApaAppList& CApaAppListServSession::AppList()

   170 	{

   171 	return iAppList;

   172 	}

   173 

   174 	

   175 void CApaAppListServSession::DoServiceL(const RMessage2& aMessage)

   176 	{

   177 	TBool completeMessage = ETrue;

   178 	const TInt opcode = aMessage.Function();

   179 	switch (opcode)

   180 		{

   181 	case ESetNotify:

   182 		SetNotify(aMessage);

   183 		completeMessage=EFalse;

   184 		break;

   185 	case ERegisterListPopulationCompleteObserver:

   186 		RegisterListPopulationCompleteObserver(aMessage);

   187 		completeMessage=EFalse;

   188 		break;

   189 	case ECancelListPopulationCompleteObserver:

   190 		CancelListPopulationCompleteObserver();

   191 		break;

   192 	case EAppListServInitFullList:

   193 		User::Leave(KErrNotSupported);

   194 	case EAppListServInitEmbedList:

   195 		User::Leave(KErrNotSupported);

   196 	case EAppListServInitFilteredEmbedList:

   197 		InitListL(aMessage,EListFilteredEmbeddedApps);

   198 		break;

   199 	case EAppListServInitAttrFilteredList:

   200 		InitListL(aMessage,EListCapabilityAttrFilteredApps);

   201 		break;

   202 	case EAppListServInitServerAppList:

   203 		InitListL(aMessage,EListServerApps);

   204 		break;

   205 	case EAppListServGetNextApp:

   206 		GetNextAppL(aMessage);

   207 		break;

   208 	case EAppListServEmbedCount:

   209 		EmbedCount(aMessage);

   210 		break;

   211 	case EAppListServAppCount:

   212 		AppCount(aMessage);

   213 		break;

   214 	case EAppListServGetAppInfo:

   215 		GetAppInfoL(aMessage);

   216 		break;

   217 	case EAppListServGetAppCapability:

   218 		GetAppCapabilityL(aMessage);

   219 		break;

   220 	case EAppListServGetDefaultScreenNumber:

   221 		GetDefaultScreenNumberL(aMessage);

   222 		break;

   223 	case EAppListServAppIconByUid:

   224 		IconForAppL(aMessage);

   225 		break;

   226 	case ECancelNotify:

   227 		CancelNotify();

   228 		break;

   229 	case EAppListServAppIconByUidAndSize:

   230 		IconForAppBySizeL(aMessage);

   231 		break;

   232 	case EAppListServAppIconFileHandle:

   233 		IconFileHandleForAppL(aMessage);

   234 		break;	

   235 	case EAppListServGetAppIconSizes:

   236 		AppIconSizesL(aMessage);

   237 		break;

   238 	case EAppListServViewIconByUidAndSize:

   239 		IconForViewBySizeL(aMessage);

   240 		break;

   241 	case EAppListServGetAppViews:

   242 		AppViewsL(aMessage);

   243 		break;

   244 	case EAppListServGetFileOwnershipInfo:

   245 		AppFileOwnershipInfoL(aMessage);

   246 		break;

   247 	case EAppListServNumberOfOwnDefinedIcons:

   248 		NumberOfOwnDefinedIconsL(aMessage);

   249 		break;

   250 	case EAppListServApplicationLanguage:

   251 		ApplicationLanguageL(aMessage);

   252 		break;

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

   254 		AppInfoProvidedByRegistrationFileL(aMessage);

   255 		break;

   256 	case EAppListServAppIconFileName:

   257 		IconFileNameL(aMessage);

   258 		break;

   259 	case EAppListServAppViewIconFileName:

   260 		ViewIconFileNameL(aMessage);

   261 		break;	

   262 	case EAppListServPrepareNonNativeApplicationsUpdates:

   263 		iNonNativeApplicationsManager->PrepareNonNativeApplicationsUpdatesL();

   264 		break;

   265 	case EAppListServRegisterNonNativeApplication:

   266 		iNonNativeApplicationsManager->RegisterNonNativeApplicationL(aMessage);

   267 		break;

   268 	case EAppListServDeregisterNonNativeApplication:

   269 		iNonNativeApplicationsManager->DeregisterNonNativeApplicationL(aMessage);

   270 		break;

   271 	case EAppListServCommitNonNativeApplications:

   272 		iNonNativeApplicationsManager->CommitNonNativeApplicationsUpdatesL(aMessage);

   273 		completeMessage=EFalse;

   274 		break;

   275 	case EAppListServRollbackNonNativeApplications:

   276 		iNonNativeApplicationsManager->RollbackNonNativeApplicationsUpdates();

   277 		break;

   278 	case EAppListServGetAppType:

   279 		GetAppTypeL(aMessage);

   280 		break;

   281 	case EAppListServForceRegistration:

   282 		ForceRegistrationL(aMessage);

   283 		completeMessage=EFalse;

   284 		break;

   285 	case EMatchesSecurityPolicy:

   286 		MatchesSecurityPolicyL(aMessage);

   287 		break;

   288 	case EAppListServSetAppShortCaption:

   289 		SetAppShortCaptionL(aMessage);

   290 		break;

   291 	case EDebugClearAppInfoArray:

   292 	#ifdef _DEBUG

   293 		iApaAppInfoArray.ResetAndDestroy();

   294 		iApaAppInfoArray.Compress();

   295 	#endif

   296 		break;

   297 	case EDebugAddFailingNonNativeApplicationsUpdate:

   298 	#ifdef _DEBUG

   299 		iNonNativeApplicationsManager->ForceFailInNonNativeApplicationsUpdatesL();

   300 	#endif

   301 		break;

   302 	case EDebugAddPanicingNonNativeApplicationsUpdate:

   303 	#ifdef _DEBUG

   304 		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsUpdatesL();

   305 	#endif

   306 		break;

   307 	case EDebugAddRollbackPanicingNonNativeApplicationsUpdate:

   308 	#ifdef _DEBUG

   309 		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsRollbackL();

   310 	#endif

   311 		break;

   312 	default:

   313 		aMessage.Panic(KApaPanicCli,EClientBadRequest);

   314 		break;

   315 		}

   316 		

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

   318 		aMessage.Complete(KErrNone);

   319 	}

   320 

   321 

   322 // CApaAppArcServSession

   323 

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

   325 	{

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

   327 	CleanupStack::PushL(self);

   328 	self->ConstructL();

   329 	CleanupStack::Pop(); // self

   330 	return self;

   331 	}

   332 

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

   334 	: CSession2(),

   335 	iServ(aServer),

   336 	iFs(aFs),

   337 	iMaxBufSize(KApaAppListServMaxBuffer),

   338 	iOpaqueData_pendingDispatchToClient(NULL)

   339 	{}

   340 

   341 void CApaAppArcServSession::ConstructL()

   342 	{

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

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

   345 	}

   346 

   347 CApaAppArcServSession::~CApaAppArcServSession()

   348 	{

   349 	delete iAppListSession;

   350 	delete iBuffer;

   351 	delete iFileRecognitionUtility;

   352 	delete iRecognitionResult;

   353 	delete iOpaqueData_pendingDispatchToClient;

   354 	}

   355 

   356 void CApaAppArcServSession::ServiceL(const RMessage2& aMessage)

   357 	{

   358 	TBool completeMessage = ETrue;

   359 	switch (aMessage.Function())

   360 		{

   361 	case EAppListServStartAppWithoutReturningThreadId:

   362 		ASSERT(0);	// panic debug only

   363 		User::Leave(KErrNotSupported);

   364 		break;

   365 	case EAppListServStartAppReturningThreadId:

   366 		ASSERT(0);	// panic debug only

   367 		User::Leave(KErrNotSupported);

   368 		break;

   369 	case EAppListServRecognizeData:

   370 		RecognizeDataL(aMessage);

   371 		break;

   372 	case EAppListServRecognizeDataPassedByFileHandle:

   373 		RecognizeDataPassedByFileHandleL(aMessage);

   374 		break;

   375 	case EAppListServRecognizeSpecificData:

   376 		RecognizeSpecificDataL(aMessage);

   377 		break;

   378 	case EAppListServRecognizeSpecificDataPassedByFileHandle:

   379 		RecognizeSpecificDataPassedByFileHandleL(aMessage);

   380 		break;

   381 	case EAppListServAppForDataType:

   382 		AppForDataTypeL(aMessage);

   383 		break;

   384 	case EAppListServStartDocument:

   385 		ASSERT(0);	// panic debug only

   386 		User::Leave(KErrNotSupported);

   387 		break;

   388 	case EAppListServStartDocumentByDataType:

   389 		ASSERT(0);	// panic debug only

   390 		User::Leave(KErrNotSupported);

   391 		break;

   392 	case EAppListServStartDocumentByUid:

   393 		ASSERT(0);	// panic debug only

   394 		User::Leave(KErrNotSupported);

   395 		break;

   396 	case EAppListServCreateDocumentByUid:

   397 		ASSERT(0);	// panic debug only

   398 		User::Leave(KErrNotSupported);

   399 		break;

   400 	case EAppListServGetExecutableNameGivenDocument:

   401 		GetExecutableNameGivenDocumentL(aMessage);

   402 		break;

   403 	case EAppListServGetExecutableNameGivenDocumentPassedByFileHandle:

   404 		GetExecutableNameGivenDocumentPassedByFileHandleL(aMessage);

   405 		break;

   406 	case EAppListServGetExecutableNameGivenDataType:

   407 		GetExecutableNameGivenDataTypeL(aMessage);

   408 		break;

   409 	case EAppListServGetExecutableNameGivenAppUid:

   410 		GetExecutableNameGivenAppUidL(aMessage);

   411 		break;

   412 	case EAppListServGetOpaqueData:

   413 		GetOpaqueDataL(aMessage);

   414 		break;

   415 	case EAppListServGetNativeExecutableNameIfNonNative:

   416 		GetNativeExecutableNameIfNonNativeL(aMessage);

   417 		break;

   418 	case EAppListServAppForDocument:

   419 		AppForDocumentL(aMessage, NULL);

   420 		break;

   421 	case EAppListServAppForDocumentPassedByFileHandle:

   422 		AppForDocumentPassedByFileHandleL(aMessage, NULL);

   423 		break;

   424 	case EAppListServGetConfidence:

   425 		GetConfidenceL(aMessage);

   426 		break;

   427 	case EAppListServSetConfidence:

   428 		SetConfidence(aMessage);

   429 		break;

   430 	case EAppListServGetBufSize:

   431 		GetBufSize(aMessage);

   432 		break;

   433 	case EAppListServSetBufSize:

   434 		SetBufSize(aMessage);

   435 		break;

   436 	case EAppListServGetDataTypesPhase1:

   437 		GetDataTypesCountL(aMessage);

   438 		break;

   439 	case EAppListServGetDataTypesPhase2:

   440 		GetDataTypesL(aMessage);

   441 		break;

   442 	case EAppListInsertDataMapping:

   443 	case EAppListInsertDataMappingIfHigher:

   444 		InsertDataMappingL(aMessage);

   445 		break;

   446 	case EAppListDeleteDataMapping:

   447 		DeleteDataMappingL(aMessage);

   448 		break;

   449 	case EAppListServGetAppByDataType:

   450 		GetAppByDataTypeL(aMessage);

   451 		break;		

   452 	case EAppListServGetAppServices:

   453 	case EAppListServGetServiceImplementations:

   454 	case EAppListServGetServiceImplementationsDataType:

   455 	case EAppListServGetAppServiceUids:

   456 	case EAppListServGetAppServiceOpaqueData:

   457 		GetAppServicesL(aMessage);

   458 		break;

   459 	case EAppListServAppForDataTypeAndService:

   460 		AppForDataTypeAndServiceL(aMessage);

   461 		break;

   462 	case EAppListServAppForDocumentAndService:

   463 		{

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

   465 		AppForDocumentL(aMessage, &serviceUid);

   466 		}

   467 		break;

   468 	case EAppListServAppForDocumentAndServicePassedByFileHandle:

   469 		{

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

   471 		AppForDocumentPassedByFileHandleL(aMessage, &serviceUid);

   472 		}

   473 		break;

   474 	case EAppListServRegisterNonNativeApplicationType:

   475 		RegisterNonNativeApplicationTypeL(aMessage);

   476 		break;

   477 	case EAppListServDeregisterNonNativeApplicationType:

   478 		DeregisterNonNativeApplicationTypeL(aMessage);

   479 		break;

   480 	case EAppListServPreferredBufSize:

   481 		aMessage.Complete(PreferredBufSize());

   482 		break;

   483 	case EAppListServRecognizeFiles:

   484 		RecognizeFilesL(aMessage);

   485 		break;

   486 	case EAppListServTransferRecognitionResult:

   487 		TransferRecognitionResultL(aMessage);

   488 		break;

   489 	case EAppListServRecognizeFilesAsync:

   490 		RecognizeFilesAsyncL(aMessage);

   491 		completeMessage=EFalse;

   492 		break;

   493 	case ECancelRecognizeFiles:

   494 		CancelRecognizeFiles();

   495 		break;

   496 	case EAppListServRuleBasedLaunching:

   497 		AquirePermissionToLaunchAppL(aMessage);

   498 		break;

   499 	case ENotifyOnDataMappingChange:

   500 		NotifyOnDataMappingChange(aMessage);

   501 		completeMessage=EFalse;

   502 		break;

   503 	case ECancelNotifyOnDataMappingChange:

   504 		CancelNotifyOnDataMappingChange();

   505 		break;

   506 	case EDebugHeapMark:

   507 	#ifdef _DEBUG

   508 		__UHEAP_MARK;

   509 	#endif

   510 		break;

   511 	case EDebugHeapMarkEnd:

   512 	#ifdef _DEBUG

   513 		__UHEAP_MARKENDC(aMessage.Int0());

   514 	#endif

   515 		break;

   516 	case EDebugHeapFailNext:

   517 	#ifdef _DEBUG

   518 		__UHEAP_FAILNEXT(aMessage.Int0());

   519 	#endif

   520 		break;

   521 	case EDebugFlushRecognitionCache:

   522 	#ifdef _DEBUG

   523 		iServ.FlushRecognitionCache();

   524 	#endif

   525 		break;

   526 	case EDebugSetLoadRecognizersOnDemand:

   527 	#ifdef _DEBUG

   528 		iServ.SetLoadRecognizersOnDemandL(aMessage.Int0());

   529 	#endif

   530 		break;

   531 	case EDebugPerformOutstandingRecognizerUnloading:

   532 	#ifdef _DEBUG

   533 		iServ.PerformOutstandingRecognizerUnloading();

   534 		REComSession::FinalClose();

   535 	#endif

   536 		break;

   537 	default:

   538 		iAppListSession->DoServiceL(aMessage);

   539 		return;

   540 		}

   541 		

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

   543 		aMessage.Complete(KErrNone);

   544 	}

   545 

   546 

   547 void CApaAppArcServSession::NotifyOnDataMappingChange(const RMessage2& aMessage)

   548 	{ 

   549 	if (!iMessage_NotifyOnDataMappingChange.IsNull())

   550 		aMessage.Panic(KApaPanicCli,ENotifyOnDataMappingChangeRequestOutstanding);

   551 	else

   552 		iMessage_NotifyOnDataMappingChange=aMessage;

   553 	}

   554 

   555 void CApaAppArcServSession::CancelNotifyOnDataMappingChange()

   556 	{

   557 	if (!iMessage_NotifyOnDataMappingChange.IsNull())

   558 		iMessage_NotifyOnDataMappingChange.Complete(KErrCancel);

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

   560 

   561 

   562 TInt CApaAppArcServSession::PreferredBufSize() const

   563 	{

   564 	TInt preferredBufferSize = 0;

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

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

   567 	}

   568 

   569 void CApaAppArcServSession::RegisterNonNativeApplicationTypeL(const RMessage2& aMessage)

   570 	{

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

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

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

   574 	aMessage.ReadL(1, nativeExecutable_asWritable);}

   575 	iServ.RegisterNonNativeApplicationTypeL(applicationType, *nativeExecutable);

   576 	CleanupStack::PopAndDestroy(nativeExecutable);

   577 	}

   578 

   579 void CApaAppArcServSession::DeregisterNonNativeApplicationTypeL(const RMessage2& aMessage)

   580 	{

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

   582 	iServ.DeregisterNonNativeApplicationTypeL(applicationType);

   583 	}

   584 

   585 void CApaAppListServSession::GetAppTypeL(const RMessage2& aMessage)

   586 	{

   587 	TInt uid = aMessage.Int0();

   588 	CApaAppData* appData = iAppList.AppDataByUid(TUid::Uid(uid));

   589 	if (!appData)

   590 		aMessage.Complete(KErrNotFound);

   591 	else

   592 		{

   593 		TPckgBuf<TUid> typeUid(appData->NonNativeApplicationType());

   594 		aMessage.WriteL(1,typeUid);

   595 		aMessage.Complete(KErrNone);

   596 		}

   597 	}

   598 	

   599 void CApaAppListServSession::ForceRegistrationL(const RMessage2& aMessage)

   600 	{

   601 	TInt bufferSize = aMessage.GetDesLength(0);

   602 	User::LeaveIfError(bufferSize);

   603 	HBufC8* const buffer=HBufC8::NewLC(bufferSize);

   604 	TPtr8 buffer_asWritable(buffer->Des());

   605 	aMessage.ReadL(0,buffer_asWritable);

   606 		

   607 	RDesReadStream readStream(*buffer);

   608 	CleanupClosePushL(readStream);

   609 	const TUint count=readStream.ReadUint32L();

   610 	for (TUint i = 0; i < count; ++i)

   611 		{

   612 		TUint length = readStream.ReadUint32L();

   613 		HBufC* regFile = HBufC::NewLC(length);

   614   		TPtr ptr(regFile->Des());

   615   		readStream.ReadL(ptr, length);

   616 		iAppList.AddForcedRegistrationL(*regFile);

   617 		CleanupStack::PopAndDestroy(regFile);

   618 		}

   619 	

   620 	CleanupStack::PopAndDestroy(&readStream);

   621 	CleanupStack::PopAndDestroy(buffer);

   622 	

   623 	// Trigger a rescan, when rescan completes it will complete iNotifyOnScanCompleteMsg

   624 	iNotifyOnScanCompleteMsg=aMessage;

   625 	iAppArcSrv.UpdateAppsByForceRegistration();

   626 	}

   627 	

   628 void CApaAppArcServSession::AppForDocumentPassedByFileHandleL(const RMessage2& aMessage, const TUid* aServiceUid)

   629 	{

   630 #if defined(__PROFILE)

   631 	TProfile profile;

   632 	RDebug::ProfileReset(5,1);

   633 	RDebug::ProfileStart(5);

   634 #endif

   635 	RFile file;

   636 	CleanupClosePushL(file);

   637 	User::LeaveIfError(file.AdoptFromClient(aMessage, 2, 3));

   638 	SReturnData_AppForDocument returnData;

   639 	returnData.iDataType=iServ.RecognizeDataL(file, PreferredBufSize()).iDataType;

   640 	returnData.iUid=(returnData.iDataType!=TDataType())? AppForDataTypeL(returnData.iDataType, aServiceUid): TUid::Null();

   641 	CleanupStack::PopAndDestroy(&file);

   642 	aMessage.WriteL(0,TPckgC<SReturnData_AppForDocument>(returnData));

   643 #if defined(__PROFILE)

   644 	RDebug::ProfileEnd(5);

   645 	RDebug::ProfileResult(&profile,5,1);

   646 	RDebug::Print(KProfileAppForDocumentPassedByFileHandleL,profile.iTime/1000000,profile.iTime%1000000);

   647 	RDebug::ProfileStart(5);

   648 #endif

   649 	}

   650 

   651 /**

   652 Call the recognizer framework to find the MIME-type of the data buffer,

   653 then find and return the UID of the "best" application to handle that data.

   654 */

   655 void CApaAppArcServSession::AppForDocumentL(const RMessage2& aMessage, const TUid* aServiceUid)

   656 	{

   657 #if defined(__PROFILE)

   658 	TProfile profile;

   659 	RDebug::ProfileReset(5,1);

   660 	RDebug::ProfileStart(5);

   661 #endif

   662 

   663 	// Get the document file name from the IPC message

   664 	HBufC* const docFileName = HBufC::NewLC(User::LeaveIfError(aMessage.GetDesLength(2)));

   665 	{TPtr docFileName_asWritable(docFileName->Des());

   666 	aMessage.ReadL(2, docFileName_asWritable);}

   667 	

   668 	// Get the data read from the document that will be used for recognition from the IPC message

   669 	HBufC8* const buffer = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(3)));

   670 	{TPtr8 buffer_asWritable(buffer->Des());

   671 	aMessage.ReadL(3,buffer_asWritable);}

   672 	

   673 	// Call the recognizer framework to get the MIME-type

   674 	SReturnData_AppForDocument returnData;

   675 	returnData.iDataType = iServ.RecognizeDataL(*docFileName, *buffer).iDataType;

   676 	// If a MIME-type was found, get the UID of the "best" app registered for that type

   677 	returnData.iUid = (returnData.iDataType!=TDataType() ? AppForDataTypeL(returnData.iDataType, aServiceUid) : TUid::Null());

   678 	

   679 #if defined(__PROFILE)

   680 	RDebug::ProfileEnd(5);

   681 	RDebug::ProfileResult(&profile,5,1);

   682 	RDebug::Print(KProfileAppForDocumentL,profile.iTime/1000000,profile.iTime%1000000);

   683 	RDebug::ProfileStart(5);

   684 #endif

   685 	

   686 	// Send back the answer

   687 	CleanupStack::PopAndDestroy(2, docFileName);

   688 	aMessage.WriteL(0,TPckgC<SReturnData_AppForDocument>(returnData));

   689 	}

   690 

   691 void CApaAppArcServSession::GetConfidenceL(const RMessage2& aMessage)

   692 // void GetAcceptedConfidence(TInt& aConfidence);

   693 	{

   694 	aMessage.WriteL(0,TPckgBuf<TInt>(iServ.MimeTypeRecognizer()->AcceptedConfidence()));

   695 	}

   696 

   697 void CApaAppArcServSession::SetConfidence(const RMessage2& aMessage)

   698 // SetAcceptedConfidence(TInt aConfidence);

   699 	{

   700 	__ASSERT_DEBUG(iServ.MimeTypeRecognizer(), Panic(EPanicNullPointer));

   701 	iServ.MimeTypeRecognizer()->SetAcceptedConfidence(aMessage.Int0());

   702 	}

   703 

   704 void CApaAppArcServSession::GetBufSize(const RMessage2& aMessage)

   705 // GetMaxDataBufSize(TInt& aBufSize);

   706 	{

   707 	aMessage.Complete(iMaxBufSize);

   708 	}

   709 

   710 void CApaAppArcServSession::SetBufSize(const RMessage2& aMessage)

   711 // SetMaxDataBufSize(TInt aBufSize);

   712 	{

   713 	iMaxBufSize=aMessage.Int0();

   714 	}

   715 

   716 void CApaAppArcServSession::GetDataTypesCountL(const RMessage2& aMessage)

   717 	{

   718 	delete iBuffer;

   719 	iBuffer = NULL;

   720 	CDataTypeArray* const dataTypes = new(ELeave) CDataTypeArray(5);

   721 	CleanupStack::PushL(dataTypes);

   722 	iServ.DataTypeL(*dataTypes);

   723 	

   724 	TInt completionCode=0; // not KErrNone, as completion code of zero tells the client that zero data types were found

   725 	if (dataTypes->Count()>0)

   726 		{

   727 		CBufBase* const buffer = CBufFlat::NewL(sizeof(TDataType)); 

   728 		CleanupStack::PushL(buffer); 

   729 		RBufWriteStream writeStream(*buffer); 

   730 		writeStream << *dataTypes; 

   731 		CleanupStack::Pop(buffer); 

   732 		iBuffer = buffer;

   733 		completionCode = iBuffer->Ptr(0).Size(); // number of bytes in buffer (not number of data types)

   734 		}

   735 	

   736 	CleanupStack::PopAndDestroy(dataTypes);

   737 	aMessage.Complete(completionCode);

   738 	}

   739 

   740 void CApaAppArcServSession::GetDataTypesL(const RMessage2& aMessage)

   741 // GetSupportedDataTypes(CDataTypeArray& aDataTypes);

   742 	{

   743 	if(!iBuffer)

   744 		aMessage.Panic(KApaPanicCli,ENoSupportedDataTypes);

   745 	else

   746 		{

   747 		aMessage.WriteL(0,iBuffer->Ptr(0));

   748 		delete iBuffer;

   749 		iBuffer=NULL;

   750 		}

   751 	}

   752 

   753 CApaAppData& CApaAppListServSession::FindAppInListL(TUid aUid)

   754 	{

   755 	TApaAppEntry dummy;

   756 	CApaAppData* app = NULL;

   757 	if (!FindAppInList(app, dummy, aUid))

   758 		User::Leave(KErrNotFound);

   759 

   760 	return *app;

   761 	}

   762 

   763 void CApaAppListServSession::SendArrayL(const MArrayItemWriter& aArrayItemWriter,const RMessage2& aMessage) const

   764 	{

   765 	const TInt sizeOfBuffer=aMessage.Int1();

   766 	const TInt arrayItemCount=aArrayItemWriter.ArrayItemCount();

   767 	const TInt sizeRequired=sizeof(TInt)+(arrayItemCount*aArrayItemWriter.ArrayItemSize());

   768 	ASSERT(sizeRequired > 0);

   769 	if (sizeRequired>sizeOfBuffer)

   770 		User::Leave(sizeRequired); // causes aMessage to complete with sizeRequired

   771 

   772 	CBufFlat* const buf=CBufFlat::NewL(sizeRequired);

   773 	CleanupStack::PushL(buf);

   774 	buf->ExpandL(0,sizeRequired);

   775 	RBufWriteStream writeStream;

   776 	writeStream.Open(*buf);

   777 	writeStream.WriteUint32L(arrayItemCount);

   778 	for (TInt i=0; i<arrayItemCount; ++i)

   779 		aArrayItemWriter.WriteArrayItemL(writeStream,i);

   780 

   781 	writeStream.CommitL();

   782 	aMessage.WriteL(2,buf->Ptr(0));

   783 	CleanupStack::PopAndDestroy(buf);

   784 	}

   785 

   786 void CApaAppListServSession::AppIconSizesL(const RMessage2& aMessage)

   787 	{

   788 	const TUid uid=TUid::Uid(aMessage.Int0());

   789 	const CApaAppData& app = FindAppInListL(uid);

   790 	if (app.NonMbmIconFile())

   791 		User::Leave(KErrNotSupported);

   792 		

   793 	CArrayFixFlat<TSize>* array = app.IconSizesL();

   794 	CleanupStack::PushL(array);

   795 	TSizeArrayItemWriter arrayItemWriter(*array);		

   796 	SendArrayL(arrayItemWriter, aMessage);

   797 	CleanupStack::PopAndDestroy(array);

   798 	}

   799 

   800 void CApaAppListServSession::AppViewsL(const RMessage2& aMessage)

   801 	{

   802 	const TUid uid=TUid::Uid(aMessage.Int0());

   803 	const CApaAppData& app = FindAppInListL(uid);

   804 	TViewDataArrayItemWriter arrayItemWriter(*app.Views());

   805 	SendArrayL(arrayItemWriter,aMessage);

   806 	}

   807 

   808 void CApaAppListServSession::AppFileOwnershipInfoL(const RMessage2& aMessage)

   809 	{

   810 	const TUid uid=TUid::Uid(aMessage.Int0());

   811 	const CApaAppData& app = FindAppInListL(uid);

   812 	TDesCArrayItemWriter arrayItemWriter(*app.OwnedFiles());

   813 	SendArrayL(arrayItemWriter,aMessage);

   814 	}

   815 

   816 void CApaAppListServSession::NumberOfOwnDefinedIconsL(const RMessage2& aMessage)

   817 	{

   818 	const TUid uid = TUid::Uid(aMessage.Int0());

   819 	const CApaAppData& app = FindAppInListL(uid);

   820 	if (app.NonMbmIconFile())

   821 		User::Leave(KErrNotSupported);

   822 

   823 	TInt count, defaultIconsUsed;

   824 	app.GetIconInfo(count, defaultIconsUsed);

   825 	if (defaultIconsUsed)

   826 		count=0;

   827 

   828 	TPckgC<TInt> pckg(count); 

   829 	aMessage.Write(1,pckg);

   830 	}

   831 	

   832 void CApaAppListServSession::ApplicationLanguageL(const RMessage2& aMessage)

   833 	{

   834 	const TUid appUid = TUid::Uid(aMessage.Int0());

   835 	const CApaAppData& appData = FindAppInListL(appUid);

   836 

   837 	const TLanguage appLanguage = appData.ApplicationLanguage();

   838 	TPckgC<TLanguage> pckg(appLanguage); 

   839 	aMessage.Write(1,pckg);

   840 	}

   841 	

   842 

   843 void CApaAppListServSession::IconForViewBySizeL(const RMessage2& aMessage)

   844 	// Passes back handles to the icon and mask bitmaps for bitmap sharing 

   845 	{

   846 	TApaAppViewIconSizeData appViewIconSizeData;

   847 	{TPckg<TApaAppViewIconSizeData> appViewIconSizeData_asDescriptor(appViewIconSizeData);

   848 	aMessage.ReadL(0,appViewIconSizeData_asDescriptor);}

   849 	const CApaAppData& app = FindAppInListL(appViewIconSizeData.iAppUid);

   850 	

   851 	ASSERT(app.Views());

   852 	const CArrayPtr<CApaAppViewData>& viewDataArray = *app.Views();

   853 	CApaMaskedBitmap* icon = NULL;

   854 	const TInt count = viewDataArray.Count();

   855 	for (TInt ii=0; ii<count; ii++)

   856 		{

   857 		const CApaAppViewData& appViewData = *viewDataArray[ii];

   858 		if (appViewData.Uid() == appViewIconSizeData.iViewUid)

   859 			{

   860 			if (appViewData.NonMbmIconFile())

   861 				User::Leave(KErrNotSupported);

   862 

   863 			icon=appViewData.Icon(appViewIconSizeData.iSize);

   864 			break;

   865 			}

   866 		}

   867 		

   868 	if (!icon)

   869 		User::Leave(KErrNotFound);

   870 

   871 	SReturnData_ViewIconByUidAndSize returnData;

   872 	returnData.iIcon = icon->Handle();

   873 	returnData.iIconMask = icon->Mask()->Handle();

   874 	aMessage.WriteL(1,TPckgC<SReturnData_ViewIconByUidAndSize>(returnData));

   875 	}

   876 

   877 void CApaAppListServSession::IconForAppBySizeL(const RMessage2& aMessage)

   878 	{

   879 	const TUid uid=TUid::Uid(aMessage.Int0());

   880 	const TSize size(aMessage.Int1(),aMessage.Int2());

   881 	const CApaAppData& app=FindAppInListL(uid);

   882 

   883 	if (app.NonMbmIconFile())

   884 		User::Leave(KErrNotSupported);

   885 

   886 	CApaMaskedBitmap* const icon=app.Icon(size);

   887 	if (!icon)

   888 		User::Leave(KErrNotFound);

   889 

   890 	SReturnData_AppIconByUidAndSize returnData;

   891 	returnData.iIcon=icon->Handle();

   892 	returnData.iIconMask=icon->Mask()->Handle();

   893 	aMessage.WriteL(3,TPckgC<SReturnData_AppIconByUidAndSize>(returnData));

   894 	}

   895 

   896 void CApaAppListServSession::IconFileHandleForAppL(const RMessage2& aMessage)

   897 	{

   898 	const TUid uid=TUid::Uid(aMessage.Int0());

   899 	TApaAppEntry entry;

   900 	CApaAppData* app=NULL;

   901 	if (!FindAppInList(app,entry,uid))

   902 		User::Leave(KErrNotFound);

   903 

   904 	TPtrC iconFileName = app->IconFileName();

   905 	if (iconFileName.Length()==0)

   906 		User::Leave(KErrNotFound);

   907 

   908 	RFs fs;

   909 	User::LeaveIfError(fs.Connect());

   910 	CleanupClosePushL(fs);

   911 	User::LeaveIfError(fs.ShareProtected());

   912 

   913 	RFile file;

   914 	CleanupClosePushL(file);

   915 	User::LeaveIfError(file.Open(fs, iconFileName, EFileShareReadersOnly));

   916 	User::LeaveIfError(file.TransferToClient(aMessage, 1));

   917 	CleanupStack::PopAndDestroy(2, &fs); //file and fs

   918 	}

   919 

   920 void CApaAppListServSession::IconForAppL(const RMessage2& aMessage)

   921 // from GetAppIcon(TUid aAppUid, TInt aSideInPixels, CApaMaskedBitmap& aAppBitmap);

   922 // BUT!  It's interface is uid, side, icon handle, mask handle for bitmap sharing 

   923 // and avoiding IPC overhead

   924 	{

   925 	const TUid uid = TUid::Uid(aMessage.Int0());

   926 	const CApaAppData& app = FindAppInListL(uid);

   927 

   928 	if (app.NonMbmIconFile())

   929 		User::Leave(KErrNotSupported);

   930 	

   931 	const TInt side = aMessage.Int1();

   932 	CApaMaskedBitmap* const icon = app.Icon(side);

   933 	if (!icon)

   934 		User::Leave(KErrNotFound);

   935 

   936 	SReturnData_AppIconByUid returnData;

   937 	returnData.iIcon = icon->Handle();

   938 	returnData.iIconMask = icon->Mask()->Handle();

   939 	aMessage.WriteL(2,TPckgC<SReturnData_AppIconByUid>(returnData));

   940 	}

   941 

   942 void CApaAppArcServSession::AppForDataTypeL(const RMessage2& aMessage)

   943 // from AppForDataType(const TDataType& aDataType, TUid& aAppUid);

   944 	{

   945 	if (sizeof(TDataType) != aMessage.GetDesLengthL(0))

   946 		{

   947 		//Leave with KErrArgument if client passes other than TDataType

   948 		User::Leave(KErrArgument);

   949 		}

   950 	TDataType dataType;

   951 	{TPckg<TDataType> dataType_asDescriptor(dataType);

   952 	aMessage.ReadL(0,dataType_asDescriptor);}

   953 	TPckgBuf<TUid> uid_asDescriptor(AppForDataTypeL(dataType, NULL));

   954 	aMessage.WriteL(1,uid_asDescriptor);

   955 	aMessage.Complete(KErrNone);

   956 	}

   957 

   958 void CApaAppArcServSession::AppForDataTypeAndServiceL(const RMessage2& aMessage)

   959 	{

   960 	TDataType dataType;

   961 	{TPckg<TDataType> dataType_asDescriptor(dataType);

   962 	aMessage.ReadL(0,dataType_asDescriptor);}

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

   964 	TPckgBuf<TUid> uid(AppForDataTypeL(dataType, &serviceUid));

   965 	aMessage.WriteL(2,uid);

   966 	aMessage.Complete(KErrNone);

   967 	}

   968 

   969 TUid CApaAppArcServSession::AppForDataTypeL(const TDataType& aDataType, const TUid* aServiceUid)

   970 	{

   971 	// It is possible to register apps as datatype handlers with system priority,

   972 	// which means that they are not overridable by user mappings.

   973 	// So search the list of apps for a datahandler and get the associated

   974 	// priority

   975 	 

   976 	TInt priority = KDataTypePriorityNormal;

   977 	TUid uid = iAppListSession->AppList().PreferredDataHandlerL(aDataType, aServiceUid, priority);

   978 	if (priority == KDataTypePrioritySystem)

   979 		return uid;	// We have found a handler with system priority

   980 		

   981 	// No handler with system priority so see if there is a user mapping

   982 	TUid userUid = KNullUid;

   983 	if (aServiceUid)

   984 		iServ.GetAppForMimeType(aDataType,*aServiceUid,userUid);

   985 	else

   986 		iServ.GetAppForMimeType(aDataType,userUid);

   987 

   988 	TApaAppEntry entry;

   989 	const CApaAppData* app = NULL;

   990 	if (userUid.iUid && iAppListSession->FindAppInList(app,entry,userUid))

   991 		return userUid;	// The user mapping is valid

   992 		

   993 	// A user mapping was not found or is invalid so try to use

   994 	// the uid returned by PreferredDataHandlerL.

   995 	if (!uid.iUid && aDataType.IsNative())

   996 		uid = aDataType.Uid();

   997 

   998 	return uid;

   999 	}

  1000 

  1001 void CApaAppArcServSession::InsertDataMappingL(const RMessage2& aMessage)

  1002 	{

  1003 	TPckgBuf<TDataType> dataType;

  1004 	aMessage.ReadL(0, dataType);

  1005 	TDataTypePriority priority = aMessage.Int1();

  1006 	const TUid appUid = { aMessage.Int2() };

  1007 

  1008 	if(priority>KDataTypeUnTrustedPriorityThreshold || priority == KDataTypePrioritySystem ) 

  1009 	   {   

  1010 	   CApaAppData* appData = iAppListSession->AppList().AppDataByUid(appUid);

  1011 	   if( appData )	

  1012 		  {

  1013           TBool hasWriteDeviceDataCap( EFalse );

  1014           TBool isSidTrusted( EFalse );

  1015           

  1016           CApaSecurityUtils::CheckAppSecurity( appData->AppEntry().iFullName, 

  1017                                                hasWriteDeviceDataCap,

  1018                                                isSidTrusted);

  1019           

  1020           if (priority == KDataTypePrioritySystem )

  1021               {

  1022               // Check if the app has capability WriteDeviceData

  1023               if ( !hasWriteDeviceDataCap )

  1024                   {

  1025                   priority = KDataTypePriorityNormal;

  1026                   }

  1027               }

  1028           else

  1029               {

  1030               TPtrC registrationFilePath = appData->RegistrationFileName();

  1031               TInt match = registrationFilePath.MatchF (

  1032                                           KLitPathForUntrustedRegistrationResourceFiles );

  1033               //Check if registration file is in path for untrusted apps 

  1034               //and its SID is untrusted

  1035               if (match != KErrNotFound && !isSidTrusted )

  1036                   {

  1037                   // "cap" the priority if UnTrusted apps claim for priority higher 

  1038                   // than UnTrusted apps Threshold priority

  1039                   priority = KDataTypeUnTrustedPriorityThreshold;

  1040                   }

  1041               }

  1042           }

  1043 	   else

  1044 		  {

  1045               //if the application is not present in the applist 

  1046               //then the priority will be reduced to Threshold

  1047               priority = KDataTypeUnTrustedPriorityThreshold;

  1048 		  }

  1049 	   }

  1050 

  1051 	const TUid serviceUid = { aMessage.Int3() };

  1052 	if(aMessage.Function() == EAppListInsertDataMappingIfHigher)

  1053 		{

  1054 		const TBool response = iServ.InsertAndStoreIfHigherL(dataType(), priority, appUid);

  1055 		aMessage.WriteL(3, TPckgC<TBool>(response));

  1056 		}

  1057 	else

  1058 		iServ.InsertAndStoreDataMappingL(dataType(), priority, appUid, serviceUid);

  1059 	}

  1060 

  1061 void CApaAppArcServSession::DeleteDataMappingL(const RMessage2& aMessage)

  1062 	{

  1063 	TPckgBuf<TDataType> dataType;

  1064 	aMessage.ReadL(0, dataType);

  1065 	const TUid serviceUid = { aMessage.Int1() };

  1066 	TUid uid;

  1067 	iServ.GetAppForMimeType(dataType(),serviceUid,uid);

  1068 	if (uid != KNullUid)

  1069 		{

  1070 		// TypeStore doesn't support deletion of an inexistent mapping

  1071 		iServ.DeleteAndStoreDataMappingL(dataType(), serviceUid);

  1072 		aMessage.Complete(KErrNone);

  1073 		}

  1074 	else

  1075 		aMessage.Complete(KErrNotFound);

  1076 	}

  1077 	

  1078 void CApaAppArcServSession::GetAppByDataTypeL(const RMessage2& aMessage) const

  1079 	{

  1080 	TPckgBuf<TDataType> dataType;

  1081 	aMessage.ReadL(0,dataType);

  1082 	const TUid serviceUid = { aMessage.Int1() };

  1083 	TUid uid;

  1084 	iServ.GetAppForMimeType(dataType(),serviceUid,uid);

  1085 	TPckgC<TUid> uidpckg(uid);

  1086 	aMessage.WriteL(2,uidpckg);

  1087 	aMessage.Complete(KErrNone);

  1088 	}

  1089 

  1090 void CApaAppArcServSession::GetExecutableNameGivenDocumentL(const RMessage2& aMessage)

  1091 	{

  1092 	HBufC* const name=HBufC::NewLC(User::LeaveIfError(aMessage.GetDesLength(2)));

  1093 	{TPtr name_asWritable(name->Des());

  1094 	aMessage.ReadL(2, name_asWritable);}

  1095 	HBufC8* const buffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(3)));

  1096 	{TPtr8 buffer_asWritable(buffer->Des());

  1097 	aMessage.ReadL(3, buffer_asWritable);}

  1098 	const TDataType dataType(iServ.RecognizeDataL(*name, *buffer).iDataType);

  1099 	CleanupStack::PopAndDestroy(2, name);

  1100 

  1101 	const TUid appUid(AppForDataTypeL(dataType, NULL));

  1102 	GetExecutableNameL(aMessage, appUid);

  1103 	}

  1104 

  1105 void CApaAppArcServSession::GetExecutableNameGivenDocumentPassedByFileHandleL(const RMessage2& aMessage)

  1106 	{

  1107 	RFile file;

  1108 	CleanupClosePushL(file);

  1109 	User::LeaveIfError(file.AdoptFromClient(aMessage, 2, 3));

  1110 	const TDataType dataType(iServ.RecognizeDataL(file, PreferredBufSize()).iDataType);

  1111 	CleanupStack::PopAndDestroy(&file);

  1112 

  1113 	const TUid appUid(AppForDataTypeL(dataType, NULL));

  1114 	GetExecutableNameL(aMessage, appUid);

  1115 	}

  1116 

  1117 void CApaAppArcServSession::GetExecutableNameGivenDataTypeL(const RMessage2& aMessage)

  1118 	{

  1119 	if (sizeof(TDataType) != aMessage.GetDesLengthL(2))

  1120 		{

  1121 		//Leave with KErrArgument if client passes other than TDataType

  1122 		User::Leave(KErrArgument);

  1123 		}

  1124 	TDataType dataType;

  1125 	{TPckg<TDataType> dataType_asDescriptor(dataType);

  1126 	aMessage.ReadL(2, dataType_asDescriptor);}

  1127 	const TUid appUid(AppForDataTypeL(dataType, NULL));

  1128 	GetExecutableNameL(aMessage, appUid);

  1129 	}

  1130 

  1131 void CApaAppArcServSession::GetExecutableNameGivenAppUidL(const RMessage2& aMessage)

  1132 	{

  1133 	const TUid appUid(TUid::Uid(aMessage.Int2()));

  1134 	GetExecutableNameL(aMessage, appUid);