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

    15 

    16 #include "apgaplst.h"

    17 #include "apgstd.h" 

    18 #include "apfdef.h"

    19 #include "..\apparc\trace.h"

    20 #include "apgnotif.h"

    21 #include "..\apfile\aprfndr.h"

    22 #include <e32math.h>

    23 #include <bautils.h>

    24 #include <s32mem.h>

    25 #include "apgpriv.h"

    26 #include "apgair.h"

    27 #include "apgicnfl.h"

    28 #include "apprivate.h"

    29 #include <e32uid.h>

    30 

    31 

    32 // Delays in the pseudo idle object that builds the application list

    33 //

    34 

    35 const TInt KIdleStartDelay=0;

    36 const TInt KMaxOpaqueDataLength = 0x1000; // maximum length of opaque data that can be passed between client and apparc server via a TApaAppServiceInfo object - this can be increased in future if needed

    37 const TInt KBufferExpansionGranularity = 0x100;

    38 const TInt KNumberOfIconsInDefaultMbm = 3;

    39 const TInt KAppListToFileStartDelay = 60000000;

    40 

    41 

    42 //

    43 // Class CApaLangChangeMonitor

    44 //

    45 

    46 NONSHARABLE_CLASS(CApaAppList::CApaLangChangeMonitor) : public CActive

    47  		{

    48  	/**

    49  	Utility class used to monitor locale/language change event.

    50  	@internalComponent

    51  	*/

    52  	public:

    53  		static CApaLangChangeMonitor* NewL(CApaAppList& aAppList);

    54  		~CApaLangChangeMonitor();

    55  		void Start();

    56  		

    57  	private:

    58  		CApaLangChangeMonitor(CApaAppList& aAppList);

    59  		void ConstructL();

    60  		

    61  	private:	//from CActive

    62  		void RunL();

    63  		void DoCancel();

    64  		TInt RunError(TInt aError);

    65  		

    66  	private:

    67  		RChangeNotifier iLangNotifier;

    68  		CApaAppList& iAppList;

    69  		TLanguage iPrevLanguage;

    70  		};

    71  

    72  		

    73  

    74 //

    75 // Local functions

    76 //

    77 

    78 void CleanupServiceArray(TAny* aServiceArray)

    79 	{

    80 	__ASSERT_DEBUG(aServiceArray, Panic(EPanicNullPointer));

    81 	CArrayFixFlat<TApaAppServiceInfo>* serviceArray = static_cast<CArrayFixFlat<TApaAppServiceInfo>*>(aServiceArray);

    82 	TInt serviceCount = serviceArray->Count();

    83 	if (serviceCount > 0)

    84 		{

    85 		for (TInt i = serviceCount - 1; i >= 0; i--)

    86 			{

    87 			(*serviceArray)[i].Release();

    88 			}

    89 		}

    90 	delete serviceArray;

    91 	serviceArray = 0;

    92 	}

    93 

    94 

    95 //

    96 // Class CApaAppViewData

    97 //

    98 

    99 CApaAppViewData::~CApaAppViewData()

   100 	{

   101 	delete iIcons;

   102 	delete iCaption;

   103 	delete iIconFileName;

   104 	}

   105 

   106 CApaAppViewData::CApaAppViewData()

   107 	: iNonMbmIconFile(EFalse)

   108 	{

   109 	}

   110 

   111 void CApaAppViewData::ConstructL()

   112 	{

   113 	iIcons=CApaAppIconArray::NewL();

   114 	}

   115 

   116 CApaAppViewData* CApaAppViewData::NewLC()

   117 	{

   118 	CApaAppViewData* self=new(ELeave) CApaAppViewData();

   119 	CleanupStack::PushL(self);

   120 	self->ConstructL();

   121 	return self;	

   122 	}

   123 

   124 void CApaAppViewData::SetUid(TUid aUid)

   125 	{

   126 	iUid=aUid;

   127 	}

   128 

   129 void CApaAppViewData::SetScreenMode(TInt aScreenMode)

   130 	{

   131 	iScreenMode=aScreenMode;

   132 	}

   133 

   134 EXPORT_C TInt CApaAppViewData::ScreenMode() const

   135 	{

   136 	return iScreenMode;

   137 	}

   138 

   139 void CApaAppViewData::SetCaptionL(const TDesC& aCaption)

   140 	{

   141 	HBufC* newCaption=aCaption.AllocL();

   142 	delete(iCaption); // after the AllocL succeeds

   143 	iCaption=newCaption;

   144 	}

   145 

   146 void CApaAppViewData::SetIconArray(CApaAppIconArray* aIcons)

   147 	{

   148 	delete iIcons;

   149 	iIcons = aIcons;

   150 	}

   151 

   152 void CApaAppViewData::SetIconFileNameL(const TDesC& aFileName)

   153 	{

   154 	HBufC* fileName = aFileName.AllocL();

   155 	delete iIconFileName; // after the AllocL succeeds

   156 	iIconFileName = fileName;

   157 	}

   158 

   159 void CApaAppViewData::SetNonMbmIconFile(TBool aNonMbmIconFile)

   160 	{

   161 	iNonMbmIconFile = aNonMbmIconFile;

   162 	}

   163 

   164 EXPORT_C TUid CApaAppViewData::Uid() const

   165 	{

   166 	return iUid;

   167 	}

   168 

   169 EXPORT_C CApaMaskedBitmap* CApaAppViewData::Icon(const TSize& aSize) const

   170 	{

   171 	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));

   172 	return iIcons->IconBySize(aSize);

   173 	}

   174 

   175 EXPORT_C CArrayFixFlat<TSize>* CApaAppViewData::IconSizesL() const

   176 	{

   177 	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));

   178 	return iIcons->IconSizesL();

   179 	}

   180 

   181 EXPORT_C TPtrC CApaAppViewData::IconFileName() const

   182 	{

   183 	if (iIconFileName)

   184 		{

   185 		return *iIconFileName;

   186 		}

   187 	else

   188 		{

   189 		return TPtrC(KNullDesC);

   190 		}

   191 	}

   192 

   193 EXPORT_C TBool CApaAppViewData::NonMbmIconFile() const

   194 	{

   195 	return iNonMbmIconFile;

   196 	}

   197 

   198 

   199 //

   200 // class CApaAppEntry

   201 //

   202 

   203 CApaAppEntry* CApaAppEntry::NewL(const TApaAppEntry& aAppEntry)

   204 	{ // static

   205 	CApaAppEntry* self=new(ELeave) CApaAppEntry(aAppEntry.iUidType);

   206 	CleanupStack::PushL(self);

   207 	self->ConstructL(aAppEntry.iFullName);

   208 	CleanupStack::Pop(self);

   209 	return self;

   210 	}

   211 

   212 CApaAppEntry::~CApaAppEntry()

   213 	{

   214 	delete iFullName;

   215 	}

   216 

   217 void CApaAppEntry::Get(TApaAppEntry& aAppEntry) const

   218 	{

   219 	aAppEntry.iFullName=*iFullName;

   220 	aAppEntry.iUidType=iUidType;

   221 	}

   222 

   223 CApaAppEntry::CApaAppEntry(const TUidType& aUidType)

   224 	: iUidType(aUidType)

   225 	{

   226 	}

   227 

   228 void CApaAppEntry::ConstructL(const TDesC& aFileName)

   229 	{

   230 	iFullName=aFileName.AllocL();

   231 	}

   232 

   233 

   234 //

   235 // class TApaAppServiceInfo

   236 //

   237 

   238 TApaAppServiceInfo::TApaAppServiceInfo()

   239 	: iUid(KNullUid),

   240 	  iDataTypes(0),

   241 	  iOpaqueData(NULL)

   242 	{

   243 	}

   244 

   245 TApaAppServiceInfo::TApaAppServiceInfo(TUid aUid, 

   246 	CArrayFixFlat<TDataTypeWithPriority>* aDataTypes, HBufC8* aOpaqueData)

   247 	: iUid(aUid),

   248 	  iDataTypes(aDataTypes),

   249 	  iOpaqueData(aOpaqueData)

   250 	{

   251 	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

   252 	__ASSERT_DEBUG(iOpaqueData, Panic(EPanicNullPointer));

   253 	}

   254 

   255 void TApaAppServiceInfo::ExternalizeL(RWriteStream& aStream) const

   256 	{

   257 	__ASSERT_DEBUG(iDataTypes, User::Invariant());

   258 	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

   259 	__ASSERT_DEBUG(iOpaqueData, Panic(EPanicNullPointer));

   260 	aStream << iUid;

   261 	aStream << *iDataTypes; //lint !e613 Possible use of null pointer - Asserted above

   262 	aStream << *iOpaqueData;//lint !e613 Possible use of null pointer - Asserted above

   263 	}

   264 

   265 void TApaAppServiceInfo::InternalizeL(RReadStream& aStream)

   266 	{

   267 	aStream >> iUid;

   268 	iDataTypes = new(ELeave) CArrayFixFlat<TDataTypeWithPriority>(1);

   269 	aStream >> *iDataTypes;

   270 	iOpaqueData = HBufC8::NewL(aStream, KMaxOpaqueDataLength);

   271 	}

   272 

   273 void TApaAppServiceInfo::Release()

   274 	{

   275 	if (iDataTypes)

   276 		{

   277 		iDataTypes->Reset();

   278 		delete iDataTypes;		

   279 		iDataTypes = NULL;

   280 		}

   281 	if (iOpaqueData)

   282 		{

   283 		delete iOpaqueData;

   284 		iOpaqueData = NULL;

   285 		}

   286 	}

   287 

   288 CArrayFixFlat<TDataTypeWithPriority>& TApaAppServiceInfo::DataTypes()

   289 	{

   290 	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

   291 	return *iDataTypes; //lint !e613 Possible use of null pointer - Asserted above

   292 	}

   293 

   294 /** Returns the service UID.

   295 

   296 Note that some APIs may store a UID other than a service UID

   297 in a TApaAppServiceInfo object. Such APIs clearly state what

   298 the UID represents.

   299 

   300 @return the service UID.

   301 */

   302 EXPORT_C TUid TApaAppServiceInfo::Uid() const

   303 	{

   304 	return iUid;

   305 	}

   306 	

   307 EXPORT_C const CArrayFixFlat<TDataTypeWithPriority>& TApaAppServiceInfo::DataTypes() const

   308 	{

   309 	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));	

   310 	return *iDataTypes; //lint !e613 Possible use of null pointer - Asserted above

   311 	}

   312 

   313 /** Returns the service implementation's opaque data.

   314 

   315 For each service UID registered by an application, the associated

   316 opaque data indicates how the service is implemented by that application.

   317 

   318 The meaning of the opaque data is not known to the framework, it will vary

   319 according to the service.

   320 

   321 For some services the opaque data may be a name intended for user display,

   322 for others it may be structured data that the service's client-side code can interpret.

   323 

   324 @return the service implementation's opaque data.

   325 */

   326 EXPORT_C const TDesC8& TApaAppServiceInfo::OpaqueData() const

   327 	{

   328 	if (iOpaqueData)

   329 		{

   330 		return *iOpaqueData;

   331 		}

   332 	return KNullDesC8;

   333 	}

   334 

   335 //

   336 // class CApaAppServiceInfoArray

   337 //

   338 

   339 CApaAppServiceInfoArray::CApaAppServiceInfoArray()

   340 	{

   341 	}

   342 

   343 //

   344 // class CApaAppServiceInfoArrayWrapper

   345 //

   346 

   347 CApaAppServiceInfoArrayWrapper* CApaAppServiceInfoArrayWrapper::NewL(CArrayFix<TApaAppServiceInfo>* aServiceInfoArray)

   348 	{

   349 	CApaAppServiceInfoArrayWrapper* self = new CApaAppServiceInfoArrayWrapper(aServiceInfoArray);

   350 	if (!self)

   351 		{

   352 		CleanupServiceArray(aServiceInfoArray);

   353 		User::LeaveNoMemory();

   354 		}

   355 	return self;

   356 	}

   357 

   358 CApaAppServiceInfoArrayWrapper::CApaAppServiceInfoArrayWrapper(CArrayFix<TApaAppServiceInfo>* aServiceInfoArray)

   359 	: iServiceInfoArray(aServiceInfoArray)

   360 	{

   361 	}

   362 

   363 CApaAppServiceInfoArrayWrapper::~CApaAppServiceInfoArrayWrapper()

   364 	{

   365 	CleanupServiceArray(iServiceInfoArray);

   366 	iServiceInfoArray = NULL;

   367 	}

   368 

   369 TArray<TApaAppServiceInfo> CApaAppServiceInfoArrayWrapper::Array()

   370 	{

   371 	__ASSERT_ALWAYS(iServiceInfoArray, Panic(EPanicNullPointer));

   372 	return iServiceInfoArray->Array();

   373 	}

   374 

   375 

   376 //

   377 // Class CApaAppData

   378 //

   379 

   380 EXPORT_C CApaAppData* CApaAppData::NewL(const TApaAppEntry& aAppEntry, RFs& aFs, const TDesC& aDefaultAppIconFileName)

   381 	{

   382 	CApaAppData* self=new(ELeave) CApaAppData(aFs);

   383 	CleanupStack::PushL(self);

   384 	self->ConstructL(aAppEntry, aDefaultAppIconFileName);

   385 	CleanupStack::Pop(); // self

   386 	return self;

   387 	}

   388 

   389 CApaAppData::CApaAppData(RFs& aFs)

   390 	:iCaption(NULL), iShortCaption(NULL), 

   391 	iIsPresent(CApaAppData::EIsPresent), iFs(aFs),

   392 	iNonMbmIconFile(EFalse),

   393 	iApplicationLanguage(ELangNone), iIndexOfFirstOpenService(-1),

   394 	iNonNativeApplicationType(TUid::Null())

   395 	{

   396 	}

   397 

   398 void CApaAppData::ConstructL(const TApaAppEntry& aAppEntry, const TDesC& aDefaultAppIconFileName)

   399 	{

   400 	iUidType = aAppEntry.iUidType; // if the 2nd UID is KUidAppRegistrationFile, iUidType will be updated in StoreApplicationInformation to reflect the TUidType for the application binary

   401 	if (ApaUtils::HandleAsRegistrationFile(aAppEntry.iUidType))

   402 		{

   403 		iRegistrationFile = aAppEntry.iFullName.AllocL();

   404 		}

   405 	else

   406 		{

   407 		iFullName = aAppEntry.iFullName.AllocL();

   408 		}

   409 

   410 	iCapabilityBuf.FillZ(iCapabilityBuf.MaxLength());

   411 	iIcons = CApaAppIconArray::NewL();

   412 	iViewDataArray=new(ELeave) CArrayPtrFlat<CApaAppViewData>(1);

   413 	iOwnedFileArray=new(ELeave) CDesCArraySeg(1);

   414 	User::LeaveIfError(StoreApplicationInformation(aDefaultAppIconFileName));

   415 	}

   416 

   417 

   418 

   419 // Return a standard error code

   420 // The value returned only reflect the caption status

   421 // If there is errors setting up captions the old values are retained

   422 // All other errors are silently ignored

   423 // General notes:

   424 // 1. This method is deliberately very similar to the old CApaAppData::GetAifData

   425 //    in order to maintain behavioural compatibility for V1 apps

   426 // 2. Be very careful in this method, because it can be called on a newly constructed object,

   427 //    or on an existing object, so don't assume member data pointers will be NULL

   428 TInt CApaAppData::StoreApplicationInformation(const TDesC& aDefaultAppIconFileName)

   429 	{

   430 	HBufC* caption = NULL;

   431 	HBufC* shortCaption = NULL;

   432 

   433 	iTimeStamp = TTime(0); // cannot init in constructor because this function can be called on an existing CApaAppData object

   434 

   435 	CApaAppInfoReader* appInfoReader = NULL;

   436 	TBool readSuccessful = EFalse;

   437 	TBool isNonNativeApp = EFalse;

   438 	if (iRegistrationFile != NULL)

   439 		{

   440 		if (TParsePtrC(*iRegistrationFile).Path().CompareF(KLitPathForNonNativeResourceAndIconFiles)==0)

   441 			{

   442 			isNonNativeApp = ETrue;

   443 			}

   444 		__ASSERT_ALWAYS(&aDefaultAppIconFileName,Panic(EPanicNullDefaultAppIconFileName));

   445 

   446 		TRAPD(err,appInfoReader = CApaAppInfoReaderV2::NewL(iFs, *iRegistrationFile, iUidType[2], aDefaultAppIconFileName));

   447 		if(err != KErrNone)

   448 			{

   449 			appInfoReader = NULL;

   450 			}

   451 

   452 		if (appInfoReader == NULL)

   453 			{

   454 			if (iFullName == NULL)

   455 				{

   456 				// assume that if iFullName is NULL, this method has been called as part

   457 				// of constructing a new app data object. The CApaAppInfoReader derived object

   458 				// could not be created, therefore we have no way to determine the full filename

   459 				// of the app binary, so give up

   460 				return KErrNoMemory;

   461 				}

   462 			}

   463 		else

   464 			{

   465 			readSuccessful = appInfoReader->Read();

   466 			HBufC* appBinaryFullName=appInfoReader->AppBinaryFullName();

   467 			if (appBinaryFullName)

   468 				{

   469 				delete iFullName;

   470 				iFullName = appBinaryFullName;

   471 				}

   472 			if (iFullName == NULL)

   473 				{

   474 				delete appInfoReader;

   475 				return KErrNoMemory;

   476 				}

   477 			// if this object has just been constructed, iUidType is currently the TUidType

   478 			// of the registration file, it should be the TUidType of the app binary file

   479 			TUidType uidType = appInfoReader->AppBinaryUidType();

   480 			if (uidType[1].iUid != KNullUid.iUid)

   481 				{

   482 				iUidType = uidType;

   483 				}

   484 			}

   485 		}

   486 

   487 	if (appInfoReader != NULL)

   488 		{

   489 		// must get captions and icons regardless of value of readSuccessful,

   490 		// because the V1 reader might have read captions

   491 		// and default icons from a caption file/default AIF, even if other info wasn't read

   492 		// from an application specific AIF file (!readSuccessful)

   493 		// this is done to maintain behavioural compatibility with V1

   494 		caption = appInfoReader->Caption();

   495 		shortCaption = appInfoReader->ShortCaption();

   496 

   497 		CApaAppIconArray* icons = appInfoReader->Icons();

   498 		if(icons)

   499 			{

   500 			delete iIcons;

   501 			iIcons = icons;

   502 			}

   503 		else

   504 			{

   505 			TRAPD(err,icons = CApaAppIconArray::NewL());

   506 			if(err == KErrNone)

   507 				{

   508 				delete iIcons;

   509 				iIcons = icons;

   510 				}

   511 			}

   512 			

   513 		iTimeStamp = appInfoReader->TimeStamp();

   514 		delete iLocalisableResourceFileName;

   515 		iLocalisableResourceFileName = appInfoReader->LocalisableResourceFileName();

   516 		iLocalisableResourceFileTimeStamp = appInfoReader->LocalisableResourceFileTimeStamp();

   517 

   518 		if (isNonNativeApp)

   519 			{

   520 			// In the case of a non-native app, the resource file has been prefixed with a

   521 			// TCheckedUid, the second of whose UIDs is the non-native application type uid.

   522 			TEntry entry;

   523 			__ASSERT_ALWAYS(iRegistrationFile, Panic(EPanicNullPointer));

   524 			const TInt error=iFs.Entry(*iRegistrationFile, entry);

   525 			if (error!=KErrNone)

   526 				{

   527 				delete appInfoReader;

   528 				return error;

   529 				}

   530 			__ASSERT_DEBUG(entry.iType[0].iUid==KUidPrefixedNonNativeRegistrationResourceFile, Panic(EPanicUnexpectedUid));

   531 			iNonNativeApplicationType=entry.iType[1];

   532 			}

   533 

   534 		delete iOpaqueData;

   535 		iOpaqueData = appInfoReader->OpaqueData();

   536 

   537 		if (readSuccessful)

   538 			{

   539 			appInfoReader->Capability(iCapabilityBuf);

   540 

   541 			iDefaultScreenNumber = appInfoReader->DefaultScreenNumber();

   542 

   543 			delete iIconFileName;

   544 			iIconFileName = appInfoReader->IconFileName();

   545 			iNonMbmIconFile = appInfoReader->NonMbmIconFile();

   546 			iApplicationLanguage = appInfoReader->AppLanguage();

   547 					

   548 			// views

   549 			iViewDataArray->ResetAndDestroy();

   550 			CArrayPtrFlat<CApaAppViewData>* viewDataArray = appInfoReader->Views();

   551 			if (viewDataArray)

   552 				{

   553 				delete iViewDataArray;

   554 				iViewDataArray = viewDataArray;

   555 				}

   556 

   557 			// owned files

   558 			iOwnedFileArray->Reset();

   559 			CDesCArray* ownedFileArray = appInfoReader->OwnedFiles();

   560 			if (ownedFileArray)

   561 				{

   562 				delete iOwnedFileArray;

   563 				iOwnedFileArray = ownedFileArray;

   564 				}

   565 			

   566 			UpdateServiceArray(appInfoReader->ServiceArray(iIndexOfFirstOpenService));

   567 			}

   568 		delete appInfoReader;

   569 		}

   570 

   571 	if (!caption)

   572 		{

   573 		TParsePtrC parse (*iFullName);

   574 		caption = parse.Name().Alloc();

   575 		}

   576 

   577 	// Put the captions into place

   578 	if (caption)

   579 		{

   580 		if (!shortCaption)

   581 			{

   582 			shortCaption = caption->Alloc();

   583 			if (!shortCaption)

   584 				{

   585 				delete caption;

   586 				caption = NULL;

   587 				}

   588 			}

   589 		}

   590 	if (caption)

   591 		{

   592 		delete iCaption;

   593 		iCaption = caption;

   594 		delete iShortCaption;

   595 		iShortCaption = shortCaption;

   596 		}

   597 

   598 	return caption ? KErrNone : KErrNoMemory;

   599 	}

   600 

   601 EXPORT_C CApaAppData::~CApaAppData()

   602 // Just delete components, NOT iNext (next CApaAppData in the list).

   603 	{

   604 	delete iSuccessor;

   605 	delete iCaption;

   606 	delete iShortCaption;

   607 	delete iFullName;

   608 	delete iIcons;

   609 

   610 	if(iViewDataArray)

   611 		{

   612 		iViewDataArray->ResetAndDestroy();

   613 		delete iViewDataArray;

   614 		}

   615 	delete iOwnedFileArray;

   616 	delete iIconFileName;

   617 	delete iLocalisableResourceFileName;

   618 	if (iServiceArray)

   619 		{

   620 		CleanupServiceArray(iServiceArray);

   621 		iServiceArray = NULL;

   622 		}

   623 	delete iOpaqueData;

   624 	delete iRegistrationFile;

   625 	iNext = NULL;

   626 	}

   627 

   628 void CApaAppData::UpdateServiceArray(CArrayFixFlat<TApaAppServiceInfo>* aNewServiceArray)

   629 	{

   630 	// clear out any existing service info

   631 	if (iServiceArray)

   632 		{

   633 		CleanupServiceArray(iServiceArray);

   634 		iServiceArray = NULL;

   635 		}

   636 	// store new service array

   637 	iServiceArray = aNewServiceArray;

   638 	}

   639 	

   640 TDataTypePriority CApaAppData::DataType(const TDataType& aDataType, const CArrayFixFlat<TDataTypeWithPriority>& aDataTypeArray) const

   641 	{

   642 	TInt count=aDataTypeArray.Count();

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

   644 		{

   645 		const TDataTypeWithPriority& type=aDataTypeArray[ii];

   646 		if (type.iDataType==aDataType)

   647 			{

   648 			return type.iPriority;

   649 			}

   650 		else

   651 			{

   652 			TPtrC8 src=type.iDataType.Des8();

   653 			TPtrC8 trg=aDataType.Des8();

   654 			if (src.Match(trg)==0 || trg.Match(src)==0)

   655 				{

   656 				if (type.iPriority == KDataTypePrioritySystem)

   657 					{

   658 					// This is more or less a magic number so don't decrement

   659 					return KDataTypePrioritySystem;

   660 					}

   661 				else

   662 					{

   663 					return (TInt16)(type.iPriority-1);

   664 					}

   665 				}

   666 			}

   667 		}

   668 	return KDataTypePriorityNotSupported;

   669 	}

   670 

   671 /**

   672  * Returns the CApaMaskedBitmap of size aSize for the application associated

   673  * with this CApaAppData. If there is not a bitmap of exact size aSize then 

   674  * the icon closest to but smaller than the one asked for is returned, or NULL if

   675  * none is smaller.

   676  * 

   677  * @since Uikon1.2

   678  */

   679 EXPORT_C CApaMaskedBitmap* CApaAppData::Icon(TSize aSize) const

   680 	{

   681 	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));

   682 	return iIcons->IconBySize(aSize);

   683 	}

   684 

   685 /**

   686  * Returns a pointer to the small, medium or large application icon for aIconIndex equal to 0, 1 or 2 respectively.

   687  * Panics if aIconIndex is not one of these three values.

   688  *

   689  * This method is superseded by an overload which returns the icon by finding the closest match to a specified size.

   690  *

   691  * @deprecated

   692  */

   693 EXPORT_C CApaMaskedBitmap* CApaAppData::Icon(TInt aIconIndex) const

   694 	{

   695 	__ASSERT_DEBUG(aIconIndex>-1 && aIconIndex<3, Panic(EDPanicBadIconSize)); //only support old behaviour

   696 	TSize sizeExpected;

   697 	switch(aIconIndex)

   698 		{

   699 	case KApaIconIndexSmall:

   700 		sizeExpected=TSize(24,24);

   701 		break;

   702 	case KApaIconIndexMedium:

   703 		sizeExpected=TSize(32,32);

   704 		break;

   705 	case KApaIconIndexLarge:

   706 		sizeExpected=TSize(48,48);

   707 		break;

   708 	default:

   709 		break;

   710 		}

   711 	return Icon(sizeExpected);

   712 	}

   713 

   714 EXPORT_C CArrayFixFlat<TSize>* CApaAppData::IconSizesL() const

   715 /** Gets the sizes of icons available for the application. 

   716 

   717 @return A pointer to an array of the icon sizes. The caller takes ownership. */

   718 	{

   719 	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));;

   720 	return iIcons->IconSizesL();

   721 	}

   722 

   723 EXPORT_C TApaAppEntry CApaAppData::AppEntry() const

   724 /** Constructs an application entry based on this object.

   725 

   726 @return The application entry. */

   727 	{

   728 	return TApaAppEntry(iUidType,*iFullName);

   729 	}

   730 

   731 

   732 EXPORT_C void CApaAppData::Capability(TDes8& aCapabilityBuf)const

   733 /** Gets the application's capabilities.

   734 

   735 @param aCapabilityBuf On return, contains the application's capabilities, 

   736 specified as a TApaAppCapabilityBuf object. */

   737 	{

   738 	TApaAppCapability::CopyCapability(aCapabilityBuf,iCapabilityBuf);

   739 	}

   740 

   741 /**

   742  * Returns a pointer to the array of view data objects current for this application. Does not imply transfer of ownership.

   743  *

   744  * @since App-Framework_6.1

   745  */

   746 EXPORT_C CArrayPtrFlat<CApaAppViewData>* CApaAppData::Views() const

   747 	{

   748 	return iViewDataArray;

   749 	}

   750 

   751 /**

   752  * Returns a pointer to the array of files for which this application claims ownership. Does not imply transfer of ownership.

   753  *

   754  * @since App-Framework_6.1

   755  */

   756 EXPORT_C CDesCArray* CApaAppData::OwnedFiles() const

   757 	{

   758 	return iOwnedFileArray;

   759 	}

   760 

   761 TBool CApaAppData::Update(const TDesC& aDefaultAppIconFileName)

   762 // returns true if changes were made to the cached data

   763 	{

   764 	__APA_PROFILE_START(17);

   765 	TBool changed=EFalse;

   766 

   767 	// Get app info file entry

   768 	TEntry entry;

   769 	TInt ret;

   770 	if (iRegistrationFile != NULL)

   771 		{

   772 		ret = iFs.Entry(*iRegistrationFile, entry);

   773 		if (ret==KErrNone && entry.iModified!=iTimeStamp)

   774 			{

   775 			// assume registration file may have changed

   776 			changed = ETrue;

   777 			}

   778 		else

   779 			{

   780 			if (iLocalisableResourceFileName)

   781 				{

   782 				// see if localisable resource information might have changed

   783 				TParse parse;

   784 				ret = parse.SetNoWild(KAppResourceFileExtension, iLocalisableResourceFileName, NULL);

   785 				if (ret == KErrNone)

   786 					{

   787 					TFileName resourceFileName(parse.FullName());

   788 					BaflUtils::NearestLanguageFile(iFs, resourceFileName);

   789 					if (resourceFileName.CompareF(*iLocalisableResourceFileName)!=0)

   790 						{

   791 						changed = ETrue;

   792 						}

   793 					else

   794 						{

   795 						ret = iFs.Entry(*iLocalisableResourceFileName, entry);

   796 						if ((ret==KErrNotFound && iLocalisableResourceFileTimeStamp!=TTime(0)) ||

   797 							(ret==KErrNone && entry.iModified!=iLocalisableResourceFileTimeStamp))

   798 							{

   799 							changed = ETrue;

   800 							}

   801 						}

   802 					}

   803 				}

   804 			}

   805 		}

   806 	if (changed)

   807 		{

   808 		// Ignore result, nothing we can do in case failure

   809 		// and the old values should be preserved

   810         const TInt ignore = StoreApplicationInformation(aDefaultAppIconFileName);

   811 		} //lint !e529 Suppress symbol 'ignore' not subsequently referenced

   812 		

   813 	__APA_PROFILE_END(17);

   814 	return changed;

   815 	}

   816 

   817 EXPORT_C TDataTypePriority CApaAppData::DataType(const TDataType& aDataType) const

   818 // returns the priority of the data type

   819 /** If the application supports the specified data type, the function returns 

   820 the priority with which it should be selected for handling it.

   821 

   822 If the application does not support the specified data type, 

   823 KDataTypePriorityNotSupported is returned.

   824 

   825 Note that the function supports wildcard matching, using "*" and "?". In the case 

   826 of a wildcard match, the priority value returned is reduced by 1, so that in this 

   827 case, the application could never have the maximum priority 

   828 (KDataTypePriorityUserSpecified).

   829 

   830 @param aDataType The data type of interest.

   831 @return The priority with which the application should be selected for handling 

   832 the specified data type, or KDataTypePriorityNotSupported if the data type is 

   833 not supported. */

   834 	{

   835 	if (iIndexOfFirstOpenService >= 0)

   836 		{

   837 		__ASSERT_ALWAYS(iServiceArray, Panic(EPanicNullPointer));

   838 		const CArrayFixFlat<TDataTypeWithPriority>& dataTypeArray = 

   839 			(*iServiceArray)[iIndexOfFirstOpenService].DataTypes();

   840 		return DataType(aDataType, dataTypeArray);

   841 		}

   842 	return KDataTypePriorityNotSupported;

   843 	}

   844 

   845 

   846 EXPORT_C TBool CApaAppData::IsPending() const

   847 	{

   848 	return (iIsPresent==CApaAppData::EPresentPendingUpdate 

   849 		|| iIsPresent==CApaAppData::ENotPresentPendingUpdate);

   850 	}

   851 

   852 EXPORT_C TBool CApaAppData::CanUseScreenMode(TInt aScreenMode)

   853 /** Tests whether the specified screen mode is valid for any of 

   854 this application's views. If the app has no views, the function 

   855 assumes that only the default screen mode (at screen mode index 

   856 zero) is allowed. This function is used by CApaAppList to create 

   857 a list of valid applications.

   858 

   859 @param aScreenMode The index of the screen mode.

   860 @return True if screen mode is valid, otherwise false. */

   861 	{

   862 	const TInt count=iViewDataArray->Count();

   863 	// If there are no views, assume only the default screen mode is allowed

   864 	TBool ret=(count==0 && aScreenMode==0);

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

   866 		{

   867 		const CApaAppViewData* data=(*iViewDataArray)[ii];

   868 		if(data->ScreenMode()==aScreenMode)

   869 			{

   870 			ret=ETrue;

   871 			break;

   872 			}

   873 		}

   874 	return ret;

   875 	}

   876 

   877 EXPORT_C void CApaAppData::GetIconInfo(TInt& aIconCount, TInt& aDefaultIconsUsed) const

   878 /** Gets icon information for the app

   879 

   880 @param aIconCount On return, this contains the number of app icons

   881 @param aDefaultIconsUsed On return, this indicates whether the default icons have been used

   882 */

   883 	{

   884 	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));;

   885 	aIconCount = iIcons->Count();

   886 	aDefaultIconsUsed = iIcons->DefaultIconsUsed();

   887 	}

   888 

   889 /** Gets the default screen number used by the application.

   890 

   891 A device may have more than once screen. This function

   892 returns the number associated with the screen which will

   893 be the default screen used by the application.

   894 

   895 @return The default screen number

   896 */

   897 EXPORT_C TUint CApaAppData::DefaultScreenNumber() const

   898 	{

   899 	return iDefaultScreenNumber;

   900 	}

   901 

   902 /** Returns true if app info was provided by a registration file

   903 

   904 @return true if app info was provided by a registration file

   905 */

   906 EXPORT_C TBool CApaAppData::RegistrationFileUsed() const

   907 	{

   908 	return iRegistrationFile != NULL;

   909 	}

   910 

   911 /** Returns the full filename of the registration resource file

   912 

   913 @return The full path and filename of the registration resource file.

   914 @internalTechnology

   915 */

   916 EXPORT_C TPtrC CApaAppData::RegistrationFileName() const

   917 	{

   918 	if (iRegistrationFile)

   919 		{

   920 		return *iRegistrationFile;

   921 		}

   922 	else

   923 		{

   924 		return TPtrC(KNullDesC);

   925 		}

   926 	}

   927 

   928 

   929 /** Returns the full filename of the localisable resource file

   930 

   931 @return The full path and filename of the localisable resource file.

   932 @internalTechnology

   933 */

   934 EXPORT_C TPtrC CApaAppData::LocalisableResourceFileName() const

   935 	{

   936 	if (iLocalisableResourceFileName)

   937 		{

   938 		return *iLocalisableResourceFileName;

   939 		}

   940 	else

   941 		{

   942 		return TPtrC(KNullDesC);

   943 		}

   944 	}

   945 

   946 

   947 /** Returns the non-native application opaque data

   948 

   949 @return The non-native application opaque data.

   950 @internalComponent

   951 */

   952 EXPORT_C TPtrC8 CApaAppData::OpaqueData() const

   953 	{

   954 	if (iOpaqueData)

   955 		{

   956 		return *iOpaqueData;

   957 		}

   958 	else

   959 		{

   960 		return TPtrC8(KNullDesC8);

   961 		}

   962 	}

   963 

   964 EXPORT_C TUid CApaAppData::NonNativeApplicationType() const

   965 /** @internalComponent */

   966 	{

   967 	return iNonNativeApplicationType;

   968 	}

   969 

   970 /** Returns the full filename of the file containing application icons

   971 

   972 @return The full path and filename of the icon file.

   973 */

   974 EXPORT_C TPtrC CApaAppData::IconFileName() const

   975 	{

   976 	if (iIconFileName)

   977 		{

   978 		return *iIconFileName;

   979 		}

   980 	else

   981 		{

   982 		return TPtrC(KNullDesC);

   983 		}

   984 	}

   985 

   986 /** Returns true if the application provides a non-MBM icon filename.

   987 

   988 If this function returns false, this does not necessarily mean

   989 an MBM icon filename is provided.

   990 

   991 @return true if the application provides a non-MBM icon filename.

   992 */

   993 EXPORT_C TBool CApaAppData::NonMbmIconFile() const

   994 	{

   995 	return iNonMbmIconFile;

   996 	}

   997 

   998 

   999 /** Determines the current language the application is using to display its

  1000 user interface.

  1001 @return The current language.

  1002 */	

  1003 EXPORT_C TLanguage CApaAppData::ApplicationLanguage() const

  1004 	{

  1005 	return iApplicationLanguage;

  1006 	}

  1007 

  1008 /** Returns true if the application implements the specified service.

  1009 @param aServiceUid The service UID.

  1010 @return true if the application implements the specified service.

  1011 @internalComponent

  1012 */

  1013 EXPORT_C TBool CApaAppData::ImplementsService(TUid aServiceUid) const

  1014 	{

  1015 	if (iServiceArray)

  1016 		{

  1017 		TInt count = iServiceArray->Count();

  1018 		for (TInt i = count-1; i >= 0; i--)

  1019 			{

  1020 			if ((*iServiceArray)[i].Uid() == aServiceUid)

  1021 				{

  1022 				return ETrue;

  1023 				}

  1024 			}

  1025 		}

  1026 	return EFalse;

  1027 	}

  1028 	

  1029 /** Checks if the application implements the specified service and if the 

  1030 service explicitly supports the datatype. Explicitly means that the datatype is

  1031 listed in the service's list of datatype in the registration file and is

  1032 not the general datatype associated with the application (aka the Open service).

  1033 @param aServiceUid The service UID.

  1034 @param aDataType The datattype

  1035 @return The priority. KDataTypePriorityNotSupported if the app doesn't support

  1036 this service with this datatype.

  1037 @internalComponent

  1038 */

  1039 TInt CApaAppData::ImplementsServiceWithDataType(TUid aServiceUid, const TDataType& aDataType) const

  1040 	{

  1041 	TInt result = KDataTypePriorityNotSupported;

  1042 	if (iServiceArray)

  1043 		{

  1044 		TInt count = iServiceArray->Count();

  1045 		for (TInt i = count-1; i >= 0; i--)

  1046 			{

  1047 			// There can be more than one instance of a given service so we iterate

  1048 			// through the whole service list even if we have already found a suitable

  1049 			// service.

  1050 			if ((*iServiceArray)[i].Uid() == aServiceUid)

  1051 				{

  1052 				const CArrayFixFlat<TDataTypeWithPriority>& datatypes =

  1053 					(*iServiceArray)[i].DataTypes();

  1054 				TInt priority = DataType(aDataType, datatypes);

  1055 				if (priority > result)

  1056 					{

  1057 					result = priority;

  1058 					}

  1059 				}

  1060 			}

  1061 		}

  1062 	return result;

  1063 	}

  1064 

  1065 EXPORT_C void CApaAppData::SetShortCaptionL(const TDesC& aShortCaption)

  1066 	{

  1067 	__ASSERT_ALWAYS(iShortCaption, Panic(EPanicNullPointer));

  1068 	if(iShortCaption->Compare(aShortCaption) != 0)

  1069 		{

  1070 		HBufC* newShortCaption=aShortCaption.AllocL();

  1071 		delete iShortCaption; // after the AllocL succeeds

  1072 		iShortCaption = newShortCaption;

  1073 		}

  1074 	}

  1075 

  1076 //

  1077 // Class CApaAppList

  1078 //

  1079 

  1080 EXPORT_C CApaAppList* CApaAppList::NewL(RFs& aFs,CApaAppRegFinder* aAppRegFinder,TBool aLoadMbmIconsOnDemand, TInt aIdlePeriodicDelay)

  1081 	{

  1082 	CApaAppList* self=new CApaAppList(aFs, aAppRegFinder,aLoadMbmIconsOnDemand, aIdlePeriodicDelay);

  1083 	if (!self)

  1084 		{

  1085 		delete aAppRegFinder;

  1086 		User::LeaveNoMemory();

  1087 		}

  1088 	else

  1089 		{

  1090 		CleanupStack::PushL(self);

  1091 		self->ConstructL();

  1092 		CleanupStack::Pop(self);

  1093 		}

  1094 	return self;

  1095 	}

  1096 

  1097 CApaAppList::CApaAppList(RFs& aFs, CApaAppRegFinder* aAppRegFinder,TBool aLoadMbmIconsOnDemand, TInt aIdlePeriodicDelay)

  1098 	:iFs(aFs),

  1099 	iFlags(0),

  1100 	iAppRegFinder(aAppRegFinder),

  1101 	iIdlePeriodicDelay(aIdlePeriodicDelay),

  1102 	iLoadMbmIconsOnDemand(aLoadMbmIconsOnDemand)

  1103 	{

  1104 	}

  1105 	

  1106 void CApaAppList::ConstructL()

  1107 	{

  1108 	User::LeaveIfError(iFsShareProtected.Connect());

  1109 	User::LeaveIfError(iFsShareProtected.ShareProtected());

  1110 	User::LeaveIfError(Dll::SetTls(this));

  1111 	

  1112 	//Start language change monitor.

  1113 	iAppLangMonitor = CApaLangChangeMonitor::NewL(*this);

  1114 	}

  1115 	

  1116 EXPORT_C CApaAppList::~CApaAppList()

  1117 /** Frees all resources prior to destruction, including the application data list. */

  1118 	{

  1119 	iValidFirstAppData = NULL;

  1120 	iFlags&=~EFirstScanComplete;

  1121 	CApaAppData* next = NULL;

  1122 	for (CApaAppData* appData=iAppData; appData; appData = next)

  1123 		{

  1124 		next = appData->iNext;

  1125 		delete appData;

  1126 		}

  1127 	iAppData = NULL;

  1128 	iObserver = NULL;

  1129 	

  1130 	iFsShareProtected.Close();

  1131 	

  1132 	delete iDefaultIconArray;

  1133 	delete iDefaultAppIcon;

  1134 	delete iAppRegFinder;