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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // AppArc server session

    15 // 

    16 //

    17 

    18 #include <e32svr.h>

    19 #include <apacmdln.h>

    20 #include <apaflrec.h>

    21 #include <apsserv.h>

    22 #include "APSSES.H"

    23 #ifdef _DEBUG

    24 #include "APSSTD.H"

    25 #endif //_DEBUG

    26 #include "APSCLSV.H"

    27 #include <apsscan.h>

    28 #include <apgaplst.h>

    29 #include <apgicnfl.h>

    30 #include <apmrec.h>

    31 #include <apmstd.h>

    32 #include <apmfndr.h>

    33 #include <datastor.h>

    34 #include <s32mem.h>

    35 #include <s32strm.h>

    36 #include <s32file.h>

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

    38 #include "apgnotif.h"

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

    40 #include "ApLaunchChecker.h"

    41 #include "apsnnapps.h"

    42 

    43 #include "apsecutils.h"

    44 

    45 const TInt KApaAppListServMaxBuffer=256;

    46 #include "APSRECCACHE.h"

    47 const TInt KApaAppInfoArrayGranularity=4;

    48 const TInt KApaAppInfoDesMaxLength=sizeof(TApaAppInfo);

    49 

    50 #if defined(__PROFILE)

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

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

    53 #endif

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

    55 const TInt KFinishedScanning=-2;

    56 

    57 

    58 class MArrayItemWriter

    59 	{

    60 public:

    61 	virtual TInt ArrayItemCount() const=0;

    62 	virtual TInt ArrayItemSize() const=0;

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

    64 	};

    65 

    66 class TSizeArrayItemWriter : public MArrayItemWriter

    67 	{

    68 public:

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

    70 	

    71 	// from MArrayItemWriter

    72 	TInt ArrayItemCount() const;

    73 	TInt ArrayItemSize() const;

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

    75 private:

    76 	const CArrayFix<TSize>& iArray;

    77 	};

    78 

    79 class TViewDataArrayItemWriter : public MArrayItemWriter

    80 	{

    81 public:

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

    83 	

    84 	// from MArrayItemWriter

    85 	TInt ArrayItemCount() const;

    86 	TInt ArrayItemSize() const;

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

    88 private:

    89 	const CArrayPtr<CApaAppViewData>& iArray;

    90 	};

    91 

    92 class TDesCArrayItemWriter : public MArrayItemWriter

    93 	{

    94 public:

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

    96 	

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

   106 class CApaAppListServSession::CApaAppInfo

   107 	{

   108 public:

   109 	CApaAppInfo();

   110 	~CApaAppInfo();

   111 	void SetUid(const TUid aUid);

   112 	void SetCaptionL(const TDesC& aCaption);

   113 	void SetShortCaptionL(const TDesC& aShortCaption);

   114 	void SetFullNameL(const TDesC& aFullName);

   115 	inline TPtrC Caption() const;

   116 	inline TPtrC ShortCaption() const;

   117 	inline TPtrC FullName() const;

   118 	inline TUid Uid() const;

   119 private:

   120 	TUid iUid;

   121 	HBufC* iCaption;

   122 	HBufC* iShortCaption;

   123 	HBufC* iFullName;

   124 	};

   125 

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

   127 	{ return *iCaption; }

   128 

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

   130 	{ return *iShortCaption; }

   131 

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

   133 	{ return *iFullName; }

   134 

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

   136 	{ return iUid; }

   137 

   138 // CApaAppListServSession

   139 

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

   141 	{

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

   143 	CleanupStack::PushL(self);

   144 	self->ConstructL();

   145 	CleanupStack::Pop(); // self

   146 	return self;

   147 	}

   148 

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

   150 	: CSession2(),

   151 	iServ(aServer),

   152 	iFs(aFs),

   153 	iMaxBufSize(KApaAppListServMaxBuffer),

   154 	iApaAppInfoArray(KApaAppInfoArrayGranularity),

   155 	iOpaqueData_pendingDispatchToClient(NULL)

   156 	{}

   157 

   158 void CApaAppListServSession::ConstructL()

   159 	{

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

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

   162 	}

   163 

   164 CApaAppListServSession::~CApaAppListServSession()

   165 	{

   166 	delete iNonNativeApplicationsManager;

   167 	delete iBuffer;

   168 	iApaAppInfoArray.ResetAndDestroy();

   169 	iApaAppInfoArray.Close();

   170 	delete iFileRecognitionUtility;

   171 	delete iRecognitionResult;

   172 	delete iOpaqueData_pendingDispatchToClient;

   173 	}

   174 

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

   176 	{

   177 	TBool completeMessage=ETrue;

   178 	switch (aMessage.Function())

   179 		{

   180 	case ESetNotify:

   181 		SetNotify(aMessage);

   182 		completeMessage=EFalse;

   183 		break;

   184 	case ERegisterListPopulationCompleteObserver:

   185 		RegisterListPopulationCompleteObserver(aMessage);

   186 		completeMessage=EFalse;

   187 		break;

   188 	case ECancelListPopulationCompleteObserver:

   189 		CancelListPopulationCompleteObserver();

   190 		break;

   191 	case EAppListServInitFullList:

   192 		User::Leave(KErrNotSupported);

   193 	case EAppListServInitEmbedList:

   194 		User::Leave(KErrNotSupported);

   195 	case EAppListServInitFilteredEmbedList:

   196 		InitListL(aMessage,EListFilteredEmbeddedApps);

   197 		break;

   198 	case EAppListServInitAttrFilteredList:

   199 		InitListL(aMessage,EListCapabilityAttrFilteredApps);

   200 		break;

   201 	case EAppListServInitServerAppList:

   202 		InitListL(aMessage,EListServerApps);

   203 		break;

   204 	case EAppListServGetNextApp:

   205 		GetNextAppL(aMessage);

   206 		break;

   207 	case EAppListServEmbedCount:

   208 		EmbedCount(aMessage);

   209 		break;

   210 	case EAppListServAppCount:

   211 		AppCount(aMessage);

   212 		break;

   213 	case EAppListServGetAppInfo:

   214 		GetAppInfoL(aMessage);

   215 		break;

   216 	case EAppListServGetAppCapability:

   217 		GetAppCapabilityL(aMessage);

   218 		break;

   219 	case EAppListServGetDefaultScreenNumber:

   220 		GetDefaultScreenNumberL(aMessage);

   221 		break;

   222 	case EAppListServStartAppWithoutReturningThreadId:

   223 		StartAppL(aMessage,EFalse);

   224 		break;

   225 	case EAppListServStartAppReturningThreadId:

   226 		StartAppL(aMessage,ETrue);

   227 		break;

   228 	case EAppListServRecognizeData:

   229 		RecognizeDataL(aMessage);

   230 		break;

   231 	case EAppListServRecognizeDataPassedByFileHandle:

   232 		RecognizeDataPassedByFileHandleL(aMessage);

   233 		break;

   234 	case EAppListServRecognizeSpecificData:

   235 		RecognizeSpecificDataL(aMessage);

   236 		break;

   237 	case EAppListServRecognizeSpecificDataPassedByFileHandle:

   238 		RecognizeSpecificDataPassedByFileHandleL(aMessage);

   239 		break;

   240 	case EAppListServAppForDataType:

   241 		AppForDataTypeL(aMessage);

   242 		break;

   243 	case EAppListServStartDocument:

   244 		StartDocumentL(aMessage,EStart);

   245 		break;

   246 	case EAppListServStartDocumentByDataType:

   247 		StartDocumentL(aMessage,EStartByDataType);

   248 		break;

   249 	case EAppListServStartDocumentByUid:

   250 		StartDocumentL(aMessage,EStartByUid);

   251 		break;

   252 	case EAppListServCreateDocumentByUid:

   253 		StartDocumentL(aMessage,ECreateByUid);

   254 		break;

   255 	case EAppListServGetExecutableNameGivenDocument:

   256 		GetExecutableNameGivenDocumentL(aMessage);

   257 		break;

   258 	case EAppListServGetExecutableNameGivenDocumentPassedByFileHandle:

   259 		GetExecutableNameGivenDocumentPassedByFileHandleL(aMessage);

   260 		break;

   261 	case EAppListServGetExecutableNameGivenDataType:

   262 		GetExecutableNameGivenDataTypeL(aMessage);

   263 		break;

   264 	case EAppListServGetExecutableNameGivenAppUid:

   265 		GetExecutableNameGivenAppUidL(aMessage);

   266 		break;

   267 	case EAppListServGetOpaqueData:

   268 		GetOpaqueDataL(aMessage);

   269 		break;

   270 	case EAppListServGetNativeExecutableNameIfNonNative:

   271 		GetNativeExecutableNameIfNonNativeL(aMessage);

   272 		break;

   273 	case EAppListServAppIconByUid:

   274 		IconForAppL(aMessage);

   275 		break;

   276 	case EAppListServAppForDocument:

   277 		AppForDocumentL(aMessage, NULL);

   278 		break;

   279 	case EAppListServAppForDocumentPassedByFileHandle:

   280 		AppForDocumentPassedByFileHandleL(aMessage, NULL);

   281 		break;

   282 	case EAppListServGetConfidence:

   283 		GetConfidenceL(aMessage);

   284 		break;

   285 	case EAppListServSetConfidence:

   286 		SetConfidence(aMessage);

   287 		break;

   288 	case EAppListServGetBufSize:

   289 		GetBufSize(aMessage);

   290 		break;

   291 	case EAppListServSetBufSize:

   292 		SetBufSize(aMessage);

   293 		break;

   294 	case EAppListServGetDataTypesPhase1:

   295 		GetDataTypesCountL(aMessage);

   296 		break;

   297 	case EAppListServGetDataTypesPhase2:

   298 		GetDataTypesL(aMessage);

   299 		break;

   300 	case ECancelNotify:

   301 		CancelNotify();

   302 		break;

   303 	case EAppListServAppIconByUidAndSize:

   304 		IconForAppBySizeL(aMessage);

   305 		break;

   306 	case EAppListServAppIconFileHandle:

   307 		IconFileHandleForAppL(aMessage);

   308 		break;	

   309 	case EAppListServGetAppIconSizes:

   310 		AppIconSizesL(aMessage);

   311 		break;

   312 	case EAppListServViewIconByUidAndSize:

   313 		IconForViewBySizeL(aMessage);

   314 		break;

   315 	case EAppListServGetAppViews:

   316 		AppViewsL(aMessage);

   317 		break;

   318 	case EAppListServGetFileOwnershipInfo:

   319 		AppFileOwnershipInfoL(aMessage);

   320 		break;

   321 	case EAppListServNumberOfOwnDefinedIcons:

   322 		NumberOfOwnDefinedIconsL(aMessage);

   323 		break;

   324 	case EAppListServApplicationLanguage:

   325 		ApplicationLanguageL(aMessage);

   326 		break;

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

   328 		AppInfoProvidedByRegistrationFileL(aMessage);

   329 		break;

   330 	case EAppListServAppIconFileName:

   331 		IconFileNameL(aMessage);

   332 		break;

   333 	case EAppListServAppViewIconFileName:

   334 		ViewIconFileNameL(aMessage);

   335 		break;

   336 	case EAppListInsertDataMapping:

   337 	case EAppListInsertDataMappingIfHigher:

   338 		InsertDataMappingL(aMessage);

   339 		break;

   340 	case EAppListDeleteDataMapping:

   341 		DeleteDataMappingL(aMessage);

   342 		break;

   343 	case EAppListServGetAppByDataType:

   344 		GetAppByDataTypeL(aMessage);

   345 		break;		

   346 	case EAppListServGetAppServices:

   347 	case EAppListServGetServiceImplementations:

   348 	case EAppListServGetServiceImplementationsDataType:

   349 	case EAppListServGetAppServiceUids:

   350 	case EAppListServGetAppServiceOpaqueData:

   351 		GetAppServicesL(aMessage);

   352 		break;

   353 	case EAppListServAppForDataTypeAndService:

   354 		AppForDataTypeAndServiceL(aMessage);

   355 		break;

   356 	case EAppListServAppForDocumentAndService:

   357 		{

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

   359 		AppForDocumentL(aMessage, &serviceUid);

   360 		}

   361 		break;

   362 	case EAppListServAppForDocumentAndServicePassedByFileHandle:

   363 		{

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

   365 		AppForDocumentPassedByFileHandleL(aMessage, &serviceUid);

   366 		}

   367 		break;

   368 	case EAppListServRegisterNonNativeApplicationType:

   369 		RegisterNonNativeApplicationTypeL(aMessage);

   370 		break;

   371 	case EAppListServDeregisterNonNativeApplicationType:

   372 		DeregisterNonNativeApplicationTypeL(aMessage);

   373 		break;

   374 	case EAppListServPrepareNonNativeApplicationsUpdates:

   375 		iNonNativeApplicationsManager->PrepareNonNativeApplicationsUpdatesL();

   376 		break;

   377 	case EAppListServRegisterNonNativeApplication:

   378 		iNonNativeApplicationsManager->RegisterNonNativeApplicationL(aMessage);

   379 		break;

   380 	case EAppListServDeregisterNonNativeApplication:

   381 		iNonNativeApplicationsManager->DeregisterNonNativeApplicationL(aMessage);

   382 		break;

   383 	case EAppListServCommitNonNativeApplications:

   384 		iNonNativeApplicationsManager->CommitNonNativeApplicationsUpdatesL(aMessage);

   385 		completeMessage=EFalse;

   386 		break;

   387 	case EAppListServRollbackNonNativeApplications:

   388 		iNonNativeApplicationsManager->RollbackNonNativeApplicationsUpdates();

   389 		break;

   390 	case EAppListServGetAppType:

   391 		GetAppTypeL(aMessage);

   392 		break;

   393 	case EAppListServForceRegistration:

   394 		ForceRegistrationL(aMessage);

   395 		completeMessage=EFalse;

   396 		break;

   397 	case EAppListServPreferredBufSize:

   398 		aMessage.Complete(PreferredBufSize());

   399 		break;

   400 	case EAppListServRecognizeFiles:

   401 		RecognizeFilesL(aMessage);

   402 		break;

   403 	case EAppListServTransferRecognitionResult:

   404 		TransferRecognitionResultL(aMessage);

   405 		break;

   406 	case EAppListServRecognizeFilesAsync:

   407 		RecognizeFilesAsyncL(aMessage);

   408 		completeMessage=EFalse;

   409 		break;

   410 	case ECancelRecognizeFiles:

   411 		CancelRecognizeFiles();

   412 		break;

   413 	case EAppListServRuleBasedLaunching:

   414 		RuleBasedLaunchingL(aMessage);

   415 		break;

   416 	case EMatchesSecurityPolicy:

   417 		MatchesSecurityPolicyL(aMessage);

   418 		break;

   419 	case EAppListServSetAppShortCaption:

   420 		SetAppShortCaptionL(aMessage);

   421 		break;

   422 	case ENotifyOnDataMappingChange:

   423 		NotifyOnDataMappingChange(aMessage);

   424 		completeMessage=EFalse;

   425 		break;

   426 	case ECancelNotifyOnDataMappingChange:

   427 		CancelNotifyOnDataMappingChange();

   428 		break;

   429 	case EDebugHeapMark:

   430 	#ifdef _DEBUG

   431 		__UHEAP_MARK;

   432 	#endif

   433 		break;

   434 	case EDebugHeapMarkEnd:

   435 	#ifdef _DEBUG

   436 		__UHEAP_MARKENDC(aMessage.Int0());

   437 	#endif

   438 		break;

   439 	case EDebugHeapFailNext:

   440 	#ifdef _DEBUG

   441 		__UHEAP_FAILNEXT(aMessage.Int0());

   442 	#endif

   443 		break;

   444 	case EDebugClearAppInfoArray:

   445 	#ifdef _DEBUG

   446 		iApaAppInfoArray.ResetAndDestroy();

   447 		iApaAppInfoArray.Compress();

   448 	#endif

   449 		break;

   450 	case EDebugFlushRecognitionCache:

   451 	#ifdef _DEBUG

   452 		iServ.FlushRecognitionCache();

   453 	#endif

   454 		break;

   455 	case EDebugSetLoadRecognizersOnDemand:

   456 	#ifdef _DEBUG

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

   458 	#endif

   459 		break;

   460 	case EDebugPerformOutstandingRecognizerUnloading:

   461 	#ifdef _DEBUG

   462 		iServ.PerformOutstandingRecognizerUnloading();

   463 		REComSession::FinalClose();

   464 	#endif

   465 		break;

   466 	case EDebugAddFailingNonNativeApplicationsUpdate:

   467 	#ifdef _DEBUG

   468 		iNonNativeApplicationsManager->ForceFailInNonNativeApplicationsUpdatesL();

   469 	#endif

   470 		break;

   471 	case EDebugAddPanicingNonNativeApplicationsUpdate:

   472 	#ifdef _DEBUG

   473 		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsUpdatesL();

   474 	#endif

   475 		break;

   476 	case EDebugAddRollbackPanicingNonNativeApplicationsUpdate:

   477 	#ifdef _DEBUG

   478 		iNonNativeApplicationsManager->ForcePanicInNonNativeApplicationsRollbackL();

   479 	#endif

   480 		break;

   481 	default:

   482 		aMessage.Panic(KApaPanicCli,EClientBadRequest);

   483 		break;

   484 		}

   485 		

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

   487 		{

   488 		aMessage.Complete(KErrNone);

   489 		}

   490 	}

   491 void CApaAppListServSession::NotifyOnDataMappingChange(const RMessage2& aMessage)

   492 	{ 

   493 	if (!iMessage_NotifyOnDataMappingChange.IsNull())

   494 			{

   495 			aMessage.Panic(KApaPanicCli,ENotifyOnDataMappingChangeRequestOutstanding);

   496 			}

   497 	else

   498 			{

   499 			iMessage_NotifyOnDataMappingChange=aMessage;

   500 			}

   501 	}

   502 void CApaAppListServSession::CancelNotifyOnDataMappingChange()

   503 	{

   504 	if (!iMessage_NotifyOnDataMappingChange.IsNull())

   505 			{

   506 			iMessage_NotifyOnDataMappingChange.Complete(KErrCancel);

   507 			}

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

   509 

   510 

   511 TInt CApaAppListServSession::PreferredBufSize() const

   512 	{

   513 	TInt preferredBufferSize = 0;

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

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

   516 	}

   517 

   518 void CApaAppListServSession::RegisterNonNativeApplicationTypeL(const RMessage2& aMessage)

   519 	{

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

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

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

   523 	aMessage.ReadL(1, nativeExecutable_asWritable);}

   524 	iServ.RegisterNonNativeApplicationTypeL(applicationType, *nativeExecutable);

   525 	CleanupStack::PopAndDestroy(nativeExecutable);

   526 	}

   527 

   528 void CApaAppListServSession::DeregisterNonNativeApplicationTypeL(const RMessage2& aMessage)

   529 	{

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

   531 	iServ.DeregisterNonNativeApplicationTypeL(applicationType);

   532 	}

   533 

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

   535 	{

   536 	TInt uid = aMessage.Int0();

   537 	CApaAppData* appData = iServ.AppList().AppDataByUid(TUid::Uid(uid));

   538 	if (!appData)

   539 		{

   540 		aMessage.Complete(KErrNotFound);

   541 		return;

   542 		}

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

   544 	aMessage.WriteL(1,typeUid);

   545 	aMessage.Complete(KErrNone);

   546 	}

   547 	

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

   549 	{

   550 	TInt bufferSize = aMessage.GetDesLength(0);

   551 	User::LeaveIfError(bufferSize);

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

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

   554 	aMessage.ReadL(0,buffer_asWritable);

   555 		

   556 	RDesReadStream readStream(*buffer);

   557 	CleanupClosePushL(readStream);

   558 	const TUint count=readStream.ReadUint32L();

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

   560 		{

   561 		TUint length = readStream.ReadUint32L();

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

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

   564   		readStream.ReadL(ptr, length);

   565 		iServ.AppList().AddForcedRegistrationL(regFile);

   566 		CleanupStack::Pop(regFile);

   567 		}

   568 	CleanupStack::PopAndDestroy(&readStream);

   569 	

   570 	CleanupStack::PopAndDestroy(buffer);

   571 	

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

   573 	iNotifyOnScanCompleteMsg=aMessage;

   574 	iServ.UpdateApps();

   575 	}

   576 	

   577 void CApaAppListServSession::AppForDocumentPassedByFileHandleL(const RMessage2& aMessage, const TUid* aServiceUid)

   578 	{

   579 #if defined(__PROFILE)

   580 	TProfile profile;

   581 	RDebug::ProfileReset(5,1);

   582 	RDebug::ProfileStart(5);

   583 #endif

   584 	RFile file;

   585 	CleanupClosePushL(file);

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

   587 	SReturnData_AppForDocument returnData;

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

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

   590 	CleanupStack::PopAndDestroy(&file);

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

   592 #if defined(__PROFILE)

   593 	RDebug::ProfileEnd(5);

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

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

   596 	RDebug::ProfileStart(5);

   597 #endif

   598 	}

   599 

   600 void CApaAppListServSession::AppForDocumentL(const RMessage2& aMessage, const TUid* aServiceUid)

   601 	{

   602 #if defined(__PROFILE)

   603 	TProfile profile;

   604 	RDebug::ProfileReset(5,1);

   605 	RDebug::ProfileStart(5);

   606 #endif

   607 	HBufC* const fileName=HBufC::NewLC(User::LeaveIfError(aMessage.GetDesLength(2)));

   608 	{TPtr fileName_asWritable(fileName->Des());

   609 	aMessage.ReadL(2,fileName_asWritable);}

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

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

   612 	aMessage.ReadL(3,buffer_asWritable);}

   613 	SReturnData_AppForDocument returnData;

   614 	returnData.iDataType=iServ.RecognizeDataL(*fileName, *buffer).iDataType;

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

   616 #if defined(__PROFILE)

   617 	RDebug::ProfileEnd(5);

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

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

   620 	RDebug::ProfileStart(5);

   621 #endif

   622 	CleanupStack::PopAndDestroy(2, fileName);

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

   624 	}

   625 

   626 void CApaAppListServSession::GetConfidenceL(const RMessage2& aMessage)

   627 // void GetAcceptedConfidence(TInt& aConfidence);

   628 	{

   629 	aMessage.WriteL(0,TPckgBuf<TInt>(iServ.DataRecognizer()->AcceptedConfidence()));

   630 	}

   631 

   632 void CApaAppListServSession::SetConfidence(const RMessage2& aMessage)

   633 // SetAcceptedConfidence(TInt aConfidence);

   634 	{

   635 	__ASSERT_DEBUG(iServ.DataRecognizer(), Panic(EPanicNullPointer));

   636 	iServ.DataRecognizer()->SetAcceptedConfidence(aMessage.Int0());

   637 	}

   638 

   639 void CApaAppListServSession::GetBufSize(const RMessage2& aMessage)

   640 // GetMaxDataBufSize(TInt& aBufSize);

   641 	{

   642 	aMessage.Complete(iMaxBufSize);

   643 	}

   644 

   645 void CApaAppListServSession::SetBufSize(const RMessage2& aMessage)

   646 // SetMaxDataBufSize(TInt aBufSize);

   647 	{

   648 	iMaxBufSize=aMessage.Int0();

   649 	}

   650 

   651 void CApaAppListServSession::GetDataTypesCountL(const RMessage2& aMessage)

   652 	{

   653 	delete iBuffer;

   654 	iBuffer=NULL;

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

   656 	CleanupStack::PushL(dataTypes);

   657 	iServ.DataTypeL(*dataTypes);

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

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

   660 		{

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

   662 		CleanupStack::PushL(buffer); 

   663 		RBufWriteStream writeStream(*buffer); 

   664 		writeStream<<*dataTypes; 

   665 		CleanupStack::Pop(buffer); 

   666 		iBuffer=buffer;

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

   668 		}

   669 	CleanupStack::PopAndDestroy(dataTypes);

   670 	aMessage.Complete(completionCode);

   671 	}

   672 

   673 void CApaAppListServSession::GetDataTypesL(const RMessage2& aMessage)

   674 // GetSupportedDataTypes(CDataTypeArray& aDataTypes);

   675 	{

   676 	if(iBuffer==NULL)

   677 		{

   678 		aMessage.Panic(KApaPanicCli,ENoSupportedDataTypes);

   679 		}

   680 	else

   681 		{

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

   683 		delete iBuffer;

   684 		iBuffer=NULL;

   685 		}

   686 	}

   687 

   688 CApaAppData& CApaAppListServSession::FindAppInListL(TUid aUid)

   689 	{

   690 	TApaAppEntry dummy;

   691 	CApaAppData* app=NULL;

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

   693 		{

   694 		User::Leave(KErrNotFound);

   695 		}

   696 	return *app;

   697 	}

   698 

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

   700 	{

   701 	const TInt sizeOfBuffer=aMessage.Int1();

   702 	const TInt arrayItemCount=aArrayItemWriter.ArrayItemCount();

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

   704 	__ASSERT_DEBUG(sizeRequired>0,User::Invariant());

   705 	if (sizeRequired>sizeOfBuffer)

   706 		{

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

   708 		}

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

   710 	CleanupStack::PushL(buf);

   711 	buf->ExpandL(0,sizeRequired);

   712 	RBufWriteStream writeStream;

   713 	writeStream.Open(*buf);

   714 	writeStream.WriteUint32L(arrayItemCount);

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

   716 		{

   717 		aArrayItemWriter.WriteArrayItemL(writeStream,i);

   718 		}

   719 	writeStream.CommitL();

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

   721 	CleanupStack::PopAndDestroy(buf);

   722 	}

   723 

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

   725 	{

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

   727 	CApaAppData& app = FindAppInListL(uid);

   728 	if (app.NonMbmIconFile())

   729 		{

   730 		User::Leave(KErrNotSupported);

   731 		}

   732 		

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

   734 	CleanupStack::PushL(array);

   735 	TSizeArrayItemWriter arrayItemWriter(*array);		

   736 	SendArrayL(arrayItemWriter, aMessage);

   737 	CleanupStack::PopAndDestroy(array);

   738 	}

   739 

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

   741 	{

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

   743 	CApaAppData& app = FindAppInListL(uid);

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

   745 	SendArrayL(arrayItemWriter,aMessage);

   746 	}

   747 

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

   749 	{

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

   751 	CApaAppData& app = FindAppInListL(uid);

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

   753 	SendArrayL(arrayItemWriter,aMessage);

   754 	}

   755 

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

   757 	{

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

   759 	TApaAppEntry entry;

   760 	CApaAppData* app=NULL;

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

   762 		{

   763 		User::Leave(KErrNotFound);

   764 		}

   765 	if (app->NonMbmIconFile())

   766 		{

   767 		User::Leave(KErrNotSupported);

   768 		}

   769 	TInt count, defaultIconsUsed;

   770 	app->GetIconInfo(count, defaultIconsUsed);

   771 	if (defaultIconsUsed)

   772 		{

   773 		count=0;

   774 		}

   775 	TPckgC<TInt> pckg(count); 

   776 	aMessage.Write(1,pckg);

   777 	}

   778 	

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

   780 	{

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

   782 	TApaAppEntry appEntry;

   783 	CApaAppData* appData = NULL;

   784 	if (!FindAppInList(appData, appEntry, appUid))

   785 		{

   786 		User::Leave(KErrNotFound);

   787 		}

   788 	const TLanguage appLanguage = appData->ApplicationLanguage();

   789 	TPckgC<TLanguage> pckg(appLanguage); 

   790 	aMessage.Write(1,pckg);

   791 	}

   792 	

   793 

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

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

   796 	{

   797 	TApaAppViewIconSizeData appViewIconSizeData;

   798 	{TPckg<TApaAppViewIconSizeData> appViewIconSizeData_asDescriptor(appViewIconSizeData);

   799 	aMessage.ReadL(0,appViewIconSizeData_asDescriptor);}

   800 	TApaAppEntry entry;

   801 	CApaAppData* app=NULL;

   802 	if (!FindAppInList(app,entry,appViewIconSizeData.iAppUid))

   803 		{

   804 		User::Leave(KErrNotFound);

   805 		}

   806 	ASSERT(app->Views());

   807 	const CArrayPtr<CApaAppViewData>& viewDataArray=*app->Views();

   808 	CApaMaskedBitmap* icon=NULL;

   809 	const TInt count=viewDataArray.Count();

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

   811 		{

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

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

   814 			{

   815 			if (appViewData.NonMbmIconFile())

   816 				{

   817 				User::Leave(KErrNotSupported);

   818 				}

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

   820 			break;

   821 			}

   822 		}

   823 	if (icon==NULL)

   824 		{

   825 		User::Leave(KErrNotFound);

   826 		}

   827 	SReturnData_ViewIconByUidAndSize returnData;

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

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

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

   831 	}

   832 

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

   834 	{

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

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

   837 	TApaAppEntry entry;

   838 	CApaAppData* app=NULL;

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

   840 		{

   841 		User::Leave(KErrNotFound);

   842 		}

   843 	if (app->NonMbmIconFile())

   844 		{

   845 		User::Leave(KErrNotSupported);

   846 		}

   847 	CApaMaskedBitmap* const icon=app->Icon(size);

   848 	if (icon==NULL)

   849 		{

   850 		User::Leave(KErrNotFound);

   851 		}

   852 	SReturnData_AppIconByUidAndSize returnData;

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

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

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

   856 

   857 	}

   858 

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

   860 	{

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

   862 	TApaAppEntry entry;

   863 	CApaAppData* app=NULL;

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

   865 		{

   866 		User::Leave(KErrNotFound);

   867 		}

   868 	TPtrC iconFileName = app->IconFileName();

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

   870 		{

   871 		User::Leave(KErrNotFound);

   872 		}

   873 	RFs fs;

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

   875 	CleanupClosePushL(fs);

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

   877 	RFile file;

   878 	CleanupClosePushL(file);

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

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

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

   882 	}

   883 

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

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

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

   887 // and avoiding IPC overhead

   888 	{

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

   890 	const TInt side=aMessage.Int1();

   891 	TApaAppEntry entry;

   892 	CApaAppData* app=NULL;

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

   894 		{

   895 		User::Leave(KErrNotFound);

   896 		}

   897 	if (app->NonMbmIconFile())

   898 		{

   899 		User::Leave(KErrNotSupported);

   900 		}

   901 	CApaMaskedBitmap* const icon=app->Icon(side);

   902 	if (icon==NULL)

   903 		{

   904 		User::Leave(KErrNotFound);

   905 		}

   906 	SReturnData_AppIconByUid returnData;

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

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

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

   910 	}

   911 

   912 void CApaAppListServSession::AppForDataTypeL(const RMessage2& aMessage)

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

   914 	{

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

   916 		{

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

   918 		User::Leave(KErrArgument);

   919 		}

   920 	TDataType dataType;

   921 	{TPckg<TDataType> dataType_asDescriptor(dataType);

   922 	aMessage.ReadL(0,dataType_asDescriptor);}

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

   924 	aMessage.WriteL(1,uid_asDescriptor);

   925 	aMessage.Complete(KErrNone);

   926 	}

   927 

   928 void CApaAppListServSession::AppForDataTypeAndServiceL(const RMessage2& aMessage)

   929 	{

   930 	TDataType dataType;

   931 	{TPckg<TDataType> dataType_asDescriptor(dataType);

   932 	aMessage.ReadL(0,dataType_asDescriptor);}

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

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

   935 	aMessage.WriteL(2,uid);

   936 	aMessage.Complete(KErrNone);

   937 	}

   938 

   939 TUid CApaAppListServSession::AppForDataTypeL(const TDataType& aDataType, const TUid* aServiceUid)

   940 	{

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

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

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

   944 	// priority

   945 	TUid uid;

   946 	TInt priority;

   947 	uid=AppList().PreferredDataHandlerL(aDataType, aServiceUid, priority);

   948 	if (priority == KDataTypePrioritySystem)

   949 		{

   950 		// We have found a handler with system priority

   951 		return uid;

   952 		}

   953 		

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

   955 	TUid userUid = KNullUid;

   956 	if (aServiceUid)

   957 		{

   958 		iServ.GetAppByDataType(aDataType,*aServiceUid,userUid);

   959 		}

   960 	else

   961 		{

   962 		iServ.GetAppByDataType(aDataType,userUid);

   963 		}

   964 	TApaAppEntry entry;

   965 	CApaAppData* app=NULL;

   966 	if ((userUid.iUid!=0) && FindAppInList(app,entry,userUid))

   967 		{

   968 		// The user mapping is valid

   969 		return userUid;

   970 		}

   971 		

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

   973 	// the uid returned by PreferredDataHandlerL.

   974 	if (uid.iUid==0 && aDataType.IsNative())

   975 		{

   976 		uid=aDataType.Uid();

   977 		}

   978 	return uid;

   979 	}

   980 

   981 void CApaAppListServSession::InsertDataMappingL(const RMessage2& aMessage)

   982 	{

   983 	TPckgBuf<TDataType> dataType;

   984 	aMessage.ReadL(0, dataType);

   985 	TDataTypePriority priority = aMessage.Int1();

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

   987 

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

   989 	   {   

   990 	   CApaAppData* appData = AppList().AppDataByUid(appUid);

   991 	   if( appData )	

   992 		  {

   993           TBool hasWriteDeviceDataCap( EFalse );

   994           TBool isSidTrusted( EFalse );

   995           

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

   997                                                hasWriteDeviceDataCap,

   998                                                isSidTrusted);

   999           

  1000           if (priority == KDataTypePrioritySystem )

  1001               {

  1002               // Check if the app has capability WriteDeviceData

  1003               if ( !hasWriteDeviceDataCap )

  1004                   {

  1005                   priority = KDataTypePriorityNormal;

  1006                   }

  1007               }

  1008           else

  1009               {

  1010               TPtrC registrationFilePath = appData->RegistrationFileName ( );

  1011               TInt match = registrationFilePath.MatchF (

  1012                                           KLitPathForUntrustedRegistrationResourceFiles );

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

  1014               //and its SID is untrusted

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

  1016                   {

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

  1018                   // than UnTrusted apps Threshold priority

  1019                   priority = KDataTypeUnTrustedPriorityThreshold;

  1020                   }

  1021               }

  1022           }

  1023 	   else

  1024 		  {

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

  1026               //then the priority will be reduced to Threshold

  1027               priority = KDataTypeUnTrustedPriorityThreshold;

  1028 		  }

  1029 	   }

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

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

  1032 		{

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

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

  1035 

  1036 		}

  1037 	else

  1038 		{

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

  1040 		}

  1041 	}

  1042 

  1043 void CApaAppListServSession::DeleteDataMappingL(const RMessage2& aMessage)

  1044 	{

  1045 	TPckgBuf<TDataType> dataType;

  1046 	aMessage.ReadL(0, dataType);

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

  1048 	TUid uid;

  1049 	iServ.GetAppByDataType(dataType(),serviceUid,uid);

  1050 	if (uid != KNullUid)

  1051 		{

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

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

  1054 		aMessage.Complete(KErrNone);

  1055 		}

  1056 	else

  1057 		{

  1058 		aMessage.Complete(KErrNotFound);

  1059 		}

  1060 	}

  1061 	

  1062 void CApaAppListServSession::GetAppByDataTypeL(const RMessage2& aMessage) const

  1063 	{

  1064 	TPckgBuf<TDataType> dataType;

  1065 	aMessage.ReadL(0,dataType);

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

  1067 	TUid uid;

  1068 	iServ.GetAppByDataType(dataType(),serviceUid,uid);

  1069 	TPckgC<TUid> uidpckg(uid);

  1070 	aMessage.WriteL(2,uidpckg);

  1071 	aMessage.Complete(KErrNone);

  1072 	}

  1073 

  1074 void CApaAppListServSession::StartDocumentL(const RMessage2& aMessage,TAppListDocumentStart aStartType)

  1075 // from StartDocument(const TDesC& aFileName, TThreadId& aId, TLaunchType aLaunchType);

  1076 // from StartDocument(const TDesC& aFileName, const TDataType& aDataType, TThreadId& aId, TLaunchType aLaunchType);

  1077 // from StartDocument(const TDesC& aFileName, TUid aAppUid, TThreadId& aId, TLaunchType aLaunchType);

  1078 // from CreateDocument(const TDesC& aFileName, TUid aAppUid, TThreadId& aId, TLaunchType aLaunchType);

  1079 // This method needs to open the file, mime type it then launch it.

  1080 	{

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

  1082 	{TPtr fileName_asWritable(fileName->Des());

  1083 	aMessage.ReadL(1,fileName_asWritable);}

  1084 

  1085 	TUid uid;

  1086 	if ((aStartType==EStartByUid) || (aStartType==ECreateByUid))

  1087 		{

  1088 		uid.iUid=aMessage.Int2();

  1089 		}

  1090 	else

  1091 		{

  1092 		TDataType* const dataType=new(ELeave) TDataType();

  1093 		CleanupStack::PushL(dataType);

  1094 		if (aStartType==EStart)

  1095 			{

  1096 			HBufC8* const buffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(2)));

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

  1098 			aMessage.ReadL(2,buffer_asWritable);}

  1099 			*dataType=iServ.RecognizeDataL(*fileName, *buffer).iDataType;

  1100 			CleanupStack::PopAndDestroy(buffer);

  1101 			}

  1102 		else

  1103 			{

  1104 			__ASSERT_DEBUG(aStartType==EStartByDataType,User::Invariant());

  1105 			TPckg<TDataType> dataType_asDescriptor(*dataType);

  1106 			aMessage.ReadL(2,dataType_asDescriptor);

  1107 			}

  1108 		uid=AppForDataTypeL(*dataType, NULL);

  1109 		CleanupStack::PopAndDestroy(dataType);

  1110 		}

  1111 	const TThreadId threadId=StartDocumentL(*fileName,uid,(aStartType==ECreateByUid)? EApaCommandCreate: EApaCommandOpen);

  1112 	CleanupStack::PopAndDestroy(fileName);

  1113 	aMessage.WriteL(0, TPckgC<TThreadId>(threadId));

  1114 	}

  1115 

  1116 TThreadId CApaAppListServSession::StartDocumentL(const TDesC& aFileName, TUid aUid, TApaCommand aCommand)

  1117 // Launch the document of aFileName with the app with Uid aUid

  1118 	{

  1119 	CApaAppData* app=NULL;

  1120 	CApaFileRecognizerType* type=NULL;

  1121 	TApaAppEntry entry;

  1122 	const TBool findApp=FindAppInList(app,entry,aUid);

  1123 	if (findApp)

  1124 	    {

  1125 	    if (app->RegistrationFileUsed())

  1126 			{

  1127 			TApaAppCapabilityBuf buf;

  1128 			app->Capability(buf);

  1129 	 		if (((buf().iEmbeddability == TApaAppCapability::EEmbeddableOnly) || (buf().iEmbeddability == TApaAppCapability::EEmbeddableUiNotStandAlone)) && !(buf().iAttributes & TApaAppCapability::EBuiltAsDll))

  1130 	              {

  1131 				   User::Leave(KErrNotSupported);		

  1132                   }

  1133 	 		}

  1134 	    }