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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "apgaplst.h"

#include "apgstd.h" 

#include "apfdef.h"

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

#include "apgnotif.h"

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

#include <e32math.h>

#include <bautils.h>

#include <s32mem.h>

#include "apgpriv.h"

#include "apgair.h"

#include "apgicnfl.h"

#include "apprivate.h"

#include <e32uid.h>

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

//

const TInt KIdleStartDelay=0;

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

const TInt KBufferExpansionGranularity = 0x100;

const TInt KNumberOfIconsInDefaultMbm = 3;

const TInt KAppListToFileStartDelay = 60000000;

//

// Class CApaLangChangeMonitor

//

NONSHARABLE_CLASS(CApaAppList::CApaLangChangeMonitor) : public CActive

 		{

 	/**

 	Utility class used to monitor locale/language change event.

 	@internalComponent

 	*/

 	public:

 		static CApaLangChangeMonitor* NewL(CApaAppList& aAppList);

 		~CApaLangChangeMonitor();

 		void Start();

 	private:

 		CApaLangChangeMonitor(CApaAppList& aAppList);

 		void ConstructL();

 	private:	//from CActive

 		void RunL();

 		void DoCancel();

 		TInt RunError(TInt aError);

 	private:

 		RChangeNotifier iLangNotifier;

 		CApaAppList& iAppList;

 		TLanguage iPrevLanguage;

 		};

//

// Local functions

//

void CleanupServiceArray(TAny* aServiceArray)

	{

	__ASSERT_DEBUG(aServiceArray, Panic(EPanicNullPointer));

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

	TInt serviceCount = serviceArray->Count();

	if (serviceCount > 0)

		{

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

			{

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

			}

		}

	delete serviceArray;

	serviceArray = 0;

	}

//

// Class CApaAppViewData

//

CApaAppViewData::~CApaAppViewData()

	{

	delete iIcons;

	delete iCaption;

	delete iIconFileName;

	}

CApaAppViewData::CApaAppViewData()

	: iNonMbmIconFile(EFalse)

	{

	}

void CApaAppViewData::ConstructL()

	{

	iIcons=CApaAppIconArray::NewL();

	}

CApaAppViewData* CApaAppViewData::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;	

	}

void CApaAppViewData::SetUid(TUid aUid)

	{

	iUid=aUid;

	}

void CApaAppViewData::SetScreenMode(TInt aScreenMode)

	{

	iScreenMode=aScreenMode;

	}

EXPORT_C TInt CApaAppViewData::ScreenMode() const

	{

	return iScreenMode;

	}

void CApaAppViewData::SetCaptionL(const TDesC& aCaption)

	{

	HBufC* newCaption=aCaption.AllocL();

	delete(iCaption); // after the AllocL succeeds

	iCaption=newCaption;

	}

void CApaAppViewData::SetIconArray(CApaAppIconArray* aIcons)

	{

	delete iIcons;

	iIcons = aIcons;

	}

void CApaAppViewData::SetIconFileNameL(const TDesC& aFileName)

	{

	HBufC* fileName = aFileName.AllocL();

	delete iIconFileName; // after the AllocL succeeds

	iIconFileName = fileName;

	}

void CApaAppViewData::SetNonMbmIconFile(TBool aNonMbmIconFile)

	{

	iNonMbmIconFile = aNonMbmIconFile;

	}

EXPORT_C TUid CApaAppViewData::Uid() const

	{

	return iUid;

	}

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

	{

	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));

	return iIcons->IconBySize(aSize);

	}

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

	{

	__ASSERT_ALWAYS(iIcons, Panic(EPanicNullPointer));

	return iIcons->IconSizesL();

	}

EXPORT_C TPtrC CApaAppViewData::IconFileName() const

	{

	if (iIconFileName)

		{

		return *iIconFileName;

		}

	else

		{

		return TPtrC(KNullDesC);

		}

	}

EXPORT_C TBool CApaAppViewData::NonMbmIconFile() const

	{

	return iNonMbmIconFile;

	}

//

// class CApaAppEntry

//

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

	{ // static

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

	CleanupStack::PushL(self);

	self->ConstructL(aAppEntry.iFullName);

	CleanupStack::Pop(self);

	return self;

	}

CApaAppEntry::~CApaAppEntry()

	{

	delete iFullName;

	}

void CApaAppEntry::Get(TApaAppEntry& aAppEntry) const

	{

	aAppEntry.iFullName=*iFullName;

	aAppEntry.iUidType=iUidType;

	}

CApaAppEntry::CApaAppEntry(const TUidType& aUidType)

	: iUidType(aUidType)

	{

	}

void CApaAppEntry::ConstructL(const TDesC& aFileName)

	{

	iFullName=aFileName.AllocL();

	}

//

// class TApaAppServiceInfo

//

TApaAppServiceInfo::TApaAppServiceInfo()

	: iUid(KNullUid),

	  iDataTypes(0),

	  iOpaqueData(NULL)

	{

	}

TApaAppServiceInfo::TApaAppServiceInfo(TUid aUid, 

	CArrayFixFlat<TDataTypeWithPriority>* aDataTypes, HBufC8* aOpaqueData)

	: iUid(aUid),

	  iDataTypes(aDataTypes),

	  iOpaqueData(aOpaqueData)

	{

	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

	__ASSERT_DEBUG(iOpaqueData, Panic(EPanicNullPointer));

	}

void TApaAppServiceInfo::ExternalizeL(RWriteStream& aStream) const

	{

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

	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

	__ASSERT_DEBUG(iOpaqueData, Panic(EPanicNullPointer));

	aStream << iUid;

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

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

	}

void TApaAppServiceInfo::InternalizeL(RReadStream& aStream)

	{

	aStream >> iUid;

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

	aStream >> *iDataTypes;

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

	}

void TApaAppServiceInfo::Release()

	{

	if (iDataTypes)

		{

		iDataTypes->Reset();

		delete iDataTypes;		

		iDataTypes = NULL;

		}

	if (iOpaqueData)

		{

		delete iOpaqueData;

		iOpaqueData = NULL;

		}

	}

CArrayFixFlat<TDataTypeWithPriority>& TApaAppServiceInfo::DataTypes()

	{

	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));

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

	}

/** Returns the service UID.

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

in a TApaAppServiceInfo object. Such APIs clearly state what

the UID represents.

@return the service UID.

*/

EXPORT_C TUid TApaAppServiceInfo::Uid() const

	{

	return iUid;

	}

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

	{

	__ASSERT_DEBUG(iDataTypes, Panic(EPanicNullPointer));	

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

	}

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

For each service UID registered by an application, the associated

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

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

according to the service.

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

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

@return the service implementation's opaque data.

*/

EXPORT_C const TDesC8& TApaAppServiceInfo::OpaqueData() const

	{

	if (iOpaqueData)

		{

		return *iOpaqueData;

		}

	return KNullDesC8;

	}

//

// class CApaAppServiceInfoArray

//

CApaAppServiceInfoArray::CApaAppServiceInfoArray()

	{

	}

//

// class CApaAppServiceInfoArrayWrapper

//

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

	{

	CApaAppServiceInfoArrayWrapper* self = new CApaAppServiceInfoArrayWrapper(aServiceInfoArray);

	if (!self)

		{

		CleanupServiceArray(aServiceInfoArray);

		User::LeaveNoMemory();

		}

	return self;

	}

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

	: iServiceInfoArray(aServiceInfoArray)

	{

	}

CApaAppServiceInfoArrayWrapper::~CApaAppServiceInfoArrayWrapper()

	{

	CleanupServiceArray(iServiceInfoArray);

	iServiceInfoArray = NULL;

	}

TArray<TApaAppServiceInfo> CApaAppServiceInfoArrayWrapper::Array()

	{

	__ASSERT_ALWAYS(iServiceInfoArray, Panic(EPanicNullPointer));

	return iServiceInfoArray->Array();

	}

//

// Class CApaAppData

//

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aAppEntry, aDefaultAppIconFileName);

	CleanupStack::Pop(); // self

	return self;

	}

CApaAppData::CApaAppData(RFs& aFs)

	:iCaption(NULL), iShortCaption(NULL), 

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

	iNonMbmIconFile(EFalse),

	iApplicationLanguage(ELangNone), iIndexOfFirstOpenService(-1),

	iNonNativeApplicationType(TUid::Null())

	{

	}

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

	{

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

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

		{

		iRegistrationFile = aAppEntry.iFullName.AllocL();

		}

	else

		{

		iFullName = aAppEntry.iFullName.AllocL();

		}

	iCapabilityBuf.FillZ(iCapabilityBuf.MaxLength());

	iIcons = CApaAppIconArray::NewL();

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

	iOwnedFileArray=new(ELeave) CDesCArraySeg(1);

	User::LeaveIfError(StoreApplicationInformation(aDefaultAppIconFileName));

	}

// Return a standard error code

// The value returned only reflect the caption status

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

// All other errors are silently ignored

// General notes:

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

//    in order to maintain behavioural compatibility for V1 apps

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

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

TInt CApaAppData::StoreApplicationInformation(const TDesC& aDefaultAppIconFileName)

	{

	HBufC* caption = NULL;

	HBufC* shortCaption = NULL;

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

	CApaAppInfoReader* appInfoReader = NULL;

	TBool readSuccessful = EFalse;

	TBool isNonNativeApp = EFalse;

	if (iRegistrationFile != NULL)

		{

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

			{

			isNonNativeApp = ETrue;

			}

		__ASSERT_ALWAYS(&aDefaultAppIconFileName,Panic(EPanicNullDefaultAppIconFileName));

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

		if(err != KErrNone)

			{

			appInfoReader = NULL;

			}

		if (appInfoReader == NULL)

			{

			if (iFullName == NULL)

				{

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

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

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

				// of the app binary, so give up

				return KErrNoMemory;

				}

			}

		else

			{

			readSuccessful = appInfoReader->Read();

			HBufC* appBinaryFullName=appInfoReader->AppBinaryFullName();

			if (appBinaryFullName)

				{

				delete iFullName;

				iFullName = appBinaryFullName;

				}

			if (iFullName == NULL)

				{

				delete appInfoReader;

				return KErrNoMemory;

				}

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

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

			TUidType uidType = appInfoReader->AppBinaryUidType();

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

				{

				iUidType = uidType;

				}

			}

		}

	if (appInfoReader != NULL)

		{

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

		// because the V1 reader might have read captions

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

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

		// this is done to maintain behavioural compatibility with V1

		caption = appInfoReader->Caption();

		shortCaption = appInfoReader->ShortCaption();

		CApaAppIconArray* icons = appInfoReader->Icons();

		if(icons)

			{

			delete iIcons;

			iIcons = icons;

			}

		else

			{

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

			if(err == KErrNone)

				{

				delete iIcons;

				iIcons = icons;

				}

			}

		iTimeStamp = appInfoReader->TimeStamp();

		delete iLocalisableResourceFileName;

		iLocalisableResourceFileName = appInfoReader->LocalisableResourceFileName();

		iLocalisableResourceFileTimeStamp = appInfoReader->LocalisableResourceFileTimeStamp();

		if (isNonNativeApp)

			{

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

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

			TEntry entry;

			__ASSERT_ALWAYS(iRegistrationFile, Panic(EPanicNullPointer));

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

			if (error!=KErrNone)

				{

				delete appInfoReader;

				return error;