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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// aplapplist.cpp

//

#include "aplapplist.h"

#include "APGAPLST.H"			// KDefaultAppIconMbm

#include "aplapplistitem.h"

#include "../apgrfx/APGSTD.H"	// EPanicNullPointer

#include "APFDEF.H"

#include "../apparc/TRACE.H"

#include "apgnotif.h"			// MApaAppListServObserver

#include "aplappregfinder.h"	// CApaAppRegFinder

#include <bautils.h>			// BaflUtils::NearestLanguageFile()

#include <s32mem.h>				// RBufWriteStream

#include "aplappinforeader.h"

#include "apsiconcaptionoverride.h"

#ifdef SYMBIAN_BAFL_SYSUTIL

#include <bafl/sysutil.h>

#endif

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

//

const TInt KIdleStartDelay=0;

const TInt KBufferExpansionGranularity = 0x100;

const TInt KNumberOfIconsInDefaultMbm = 3;

const TInt KAppListToFileStartDelay = 60000000;

#ifdef SYMBIAN_BAFL_SYSUTIL

const TInt KInfoBufLength=KSysUtilVersionTextLength;

//This file is used for storing the rom version. If actual rom version differs from the one stored here the applist is not restored.

//This file is versioned to avoid a data compatability break on adding further information to this file.

//On adding further info to this file, KROMVersionCacheFileMajorVersion or KROMVersionCacheFileMinorVersion or KROMVersionCacheFileBuildVersion needs to be incremented appropriately.

_LIT(KROMVersionStringCacheFileName, "ROMVersionCache.bin");

const TInt8 KROMVersionCacheFileMajorVersion=1;

const TInt8 KROMVersionCacheFileMinorVersion=0;

const TInt16 KROMVersionCacheFileBuildVersion=0;

#endif

GLDEF_C void Panic(TApgPanic aPanic)

	{

	_LIT(KApGrfxPanic,"APGRFX");

	User::Panic(KApGrfxPanic,aPanic);

	}

//

// Class CApaLangChangeMonitor

//

/**

Utility class used to monitor locale/language change event.

@internalComponent

*/

NONSHARABLE_CLASS(CApaAppList::CApaLangChangeMonitor) : public CActive

	{

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

	const TInt serviceCount = serviceArray->Count();

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

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

	delete serviceArray;

	serviceArray = 0;

	}

//

// Class CApaAppList

//

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CApaAppList::CApaAppList(RFs& aFs, TBool aLoadMbmIconsOnDemand, TInt aIdlePeriodicDelay)

	:iFs(aFs),

	iFlags(0),

	iIdlePeriodicDelay(aIdlePeriodicDelay),

	iLoadMbmIconsOnDemand(aLoadMbmIconsOnDemand),

    iUninstalledApps(NULL)	

	{

	}

void CApaAppList::ConstructL()

	{

	iAppRegFinder = CApaAppRegFinder::NewL(iFs);

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

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

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

	//Start language change monitor.

	iAppLangMonitor = CApaLangChangeMonitor::NewL(*this);

	const TInt KArrayGranularity = 128;

	iForcedRegistrations = new (ELeave) CDesCArraySeg(KArrayGranularity);

	// Init the AppsList cache paths

	_LIT(KAppsListCacheFileName, ":\\private\\10003a3f\\AppsListCache\\AppsList.bin");

	_LIT(KAppsListCacheBackUpFileName, ":\\private\\10003a3f\\AppsListCache\\AppsList_Backup.bin");

	_LIT(KAppsListCachePath, ":\\private\\10003a3f\\AppsListCache\\");

	const TChar sysDrive = RFs::GetSystemDriveChar();

	TInt maxSizeofFileName = KAppsListCacheFileName().Length() + 1;

	iAppsListCacheFileName.CreateL(maxSizeofFileName);

	iAppsListCacheFileName.Append(sysDrive);

	iAppsListCacheFileName.Append(KAppsListCacheFileName());

	maxSizeofFileName = KAppsListCacheBackUpFileName().Length() + 1;

	iAppsListCacheBackUpFileName.CreateL(maxSizeofFileName);

	iAppsListCacheBackUpFileName.Append(sysDrive);

	iAppsListCacheBackUpFileName.Append(KAppsListCacheBackUpFileName());

	maxSizeofFileName = KAppsListCachePath().Length() + 1;

	iAppsListCachePath.CreateL(maxSizeofFileName);

	iAppsListCachePath.Append(sysDrive);

	iAppsListCachePath.Append(KAppsListCachePath());

	iIconCaptionOverrides = new(ELeave) CApaIconCaptionOverrides();

	iIconCaptionObserver = CApaIconCaptionCenrepObserver::NewL(*iIconCaptionOverrides);

	iIconCaptionObserver->LoadOverridesL();

	}

EXPORT_C CApaAppList::~CApaAppList()

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

	{

	iValidFirstAppData = NULL;

	DeleteAppData();

	iAppData = NULL;

	iObserver = NULL;

	iFsShareProtected.Close();

	delete iDefaultIconArray;

	delete iDefaultAppIconMbmFileName;

	delete iAppRegFinder;

	delete iAppIdler;

	delete iAppListStorer;

	delete iAppIconLoader;

	delete iAppLangMonitor;

	delete iForcedRegistrations;

	delete iIconCaptionObserver;

	delete iIconCaptionOverrides;

	iAppsListCacheFileName.Close();

	iAppsListCacheBackUpFileName.Close();

	iAppsListCachePath.Close();

	iCustomAppList.ResetAndDestroy();

	iCustomAppList.Close();

	}

// Stop scanning applications if installation or uninstallation has started	

EXPORT_C void CApaAppList::StopScan(TBool aNNAInstall)

	{

	if (aNNAInstall)

		{

		iNNAInstallation = ETrue;

		}

	if (iAppIdler)

		{

		delete iAppIdler;

		iAppIdler=NULL;

		}

	UndoSetPending(iAppData);

	}

// Allow scanning when installation or uninstallation is complete

EXPORT_C void CApaAppList::RestartScanL()

	{

	TRAP_IGNORE(PurgeL());

	StartIdleUpdateL();

	}

EXPORT_C TBool CApaAppList::AppListUpdatePending()

	{

	return iNNAInstallation;

	}

void CApaAppList::UndoSetPending(CApaAppData* aAppData)

	// Reset all apps to pevious pending state so they don't get purged

	{

  	for (; aAppData; aAppData = aAppData->iNext)

		{

		if (aAppData->iIsPresent == CApaAppData::EPresentPendingUpdate)

			{

			aAppData->iIsPresent = CApaAppData::EIsPresent;

			}

		}

	}

EXPORT_C void CApaAppList::StartIdleUpdateL()

/** Updates the list asynchronously, using an idle time active object, 

and no observer. When the update is finished, the resulting app 

list is stored. */

	{

	// find the default icons (.mbm file) for applications, wrt current locale

	CreateDefaultAppIconFileNameL();

	// File operation is abandoned if it is in progress.

	if (iAppListStorer && iAppListStorer->IsActive())

		{

		delete iAppListStorer;

		iAppListStorer = NULL;

		}

	// Stops icon loading if it is in progress.

	if (iAppIconLoader && iAppIconLoader->IsActive())

		{

		delete iAppIconLoader;

		iAppIconLoader = NULL;

		}

	// DEF076594 - if changing locale, need to update the default icons here

	// If updating the default icons array fails, the array is left in the state

	// it was in before the call.

	if(iDefaultIconArray)

		{

		TRAP_IGNORE(UpdateDefaultIconsL());

		}

	// start to scan.

	if (iAppIdler)

		{

		delete iAppIdler;

		iAppIdler=NULL;

		}

	// DEF072701

	// When performing the update scan let the idle object have lower priority.

	if (IsFirstScanComplete())

		{

		iAppIdler=CPeriodic::NewL(CActive::EPriorityLow);

		}

	else

		{

		iAppIdler=CPeriodic::NewL(CActive::EPriorityStandard);

		}

	SetPending(iAppData);

	iAppRegFinder->FindAllAppsL(CApaAppRegFinder::EScanAllDrives);

 	// DEF072701

 	// If this is the first scan i.e the boot scan then it may take some time. Thus

 	// the periodic delay value should be used so that this process will stop periodically 

 	// to allow time for other processes.

 	// If this is just a re-scan it should take much less time. Therefore it should just

 	// be completed in one go rather than periodically delayed. Thus the delay value

 	// should be set to 0.

	iAppIdler->Start(KIdleStartDelay, IsFirstScanComplete()? 0 : iIdlePeriodicDelay, TCallBack(IdleUpdateCallbackL, this));

	}

EXPORT_C void CApaAppList::StartIdleUpdateL(MApaAppListObserver* aObserver)

/** Updates the list asynchronously, using an idle time active object 

and an observer. When the update is finished, the resulting app list 

is stored and the observer is notified with an MApaAppListServObserver::EAppListChanged 

message, if the list changed.

@param aObserver Observer to be notified when the update has finished. */

	{

	iObserver=aObserver;

	// Rename Appslist.bin file to AppsList_Backup.bin, so that it can be renamed back, if rescan/update scan does not change applist.

	TInt replaceError = iFs.Replace(iAppsListCacheFileName, iAppsListCacheBackUpFileName);

	if (replaceError != KErrNone)

		{

		iFs.Delete(iAppsListCacheFileName);

		}

	StartIdleUpdateL();

	}

void CApaAppList::CreateDefaultAppIconFileNameL()

	{

	TFileName tempFileName(KDefaultAppIconMbm);

	TLanguage language;

	BaflUtils::NearestLanguageFileV2(iFs, tempFileName, language);

	(void)language;

	delete iDefaultAppIconMbmFileName;

	iDefaultAppIconMbmFileName = NULL;

	iDefaultAppIconMbmFileName = tempFileName.AllocL();

	}

EXPORT_C void CApaAppList::InitListL(MApaAppListObserver* aObserver)

/** It Restores the data present in the AppsList.bin file and updates the applist. 

 * If Restore operation fails then it 

 * starts updating the list asynchronously, by calling StartIdleUpdateL().

@param aObserver Observer to be notified when the update has finished. */

	{

	DeleteAppsListBackUpAndTempFiles();

	TInt ret = KErrGeneral;

#ifndef __WINS__ // on the emulator, don't read app list from file, as doing so means apps

                 // built while the emulator isn't running won't appear in the list

	TRAP(ret, RestoreL());

#endif

	if (ret != KErrNone)

		{

		// There was an error during restore, so update the list asynchronously.

		DeleteAppData();

		iFs.Delete(iAppsListCacheFileName);

		StartIdleUpdateL(aObserver);

		}

	else

		{

		iObserver = aObserver;

		if (iLoadMbmIconsOnDemand)

			{

			InitiateStoringOfAppList();

			}

		else

			{

			StartIconLoadingL();

			}

		}

	}

void CApaAppList::StartIconLoadingL()

	{

	iAppIconLoader = new(ELeave) CApaIdleIconLoader(iAppData, iFs, *this);

	iAppIconLoader->Start();

	}

void CApaAppList::ScanRemovableDrivesAndUpdateL()

/** Rename Appslist.bin file to AppsList_Backup.bin, so that it can be renamed back, 

     if the update scan on removable media drives does not change applist. */

	{

	const TArray<const TDriveUnitInfo> listOfRemovableMediaDrives = iAppRegFinder->DriveList();

	const TInt count = listOfRemovableMediaDrives.Count();

	// Removable media scan would take place only if removable drives are present.

	if (count)

		{

		CApaAppData* appData = iAppData;

		while (appData)

			{

			for (TInt driveIndex = 0; driveIndex < count; ++driveIndex)

				{

				if (TParsePtrC(*appData->iRegistrationFile).Drive() == listOfRemovableMediaDrives[driveIndex].iUnit.Name())

					{

					appData->SetAppPending();

					break;

					}

				}

			appData = appData->iNext;

			}

		while (IdleUpdateL())

			{ // It updates the removable media apps present in AppList if it has changed.

			};

		}

	}

void CApaAppList::DeleteAppsListBackUpAndTempFiles()

/** Deletes all files inside AppsListCache folder except AppsList.bin */

	{

	_LIT(KTemp, "AppsList.bin");

	CDir* cache = NULL;

	TInt ret = iFs.GetDir(iAppsListCachePath, KEntryAttNormal, ESortNone, cache);

	if (ret == KErrNone)

		{

		const TInt count = cache->Count();

		TBufC<KMaxFileName> cacheFileName;

		TEntry entry;

		for (TInt i = 0; i < count; ++i)

			{

			entry=(*cache)[i];

			cacheFileName=entry.iName;

	#if defined (SYMBIAN_BAFL_SYSUTIL)

			if ((cacheFileName.Match(KTemp) == KErrNotFound) && (cacheFileName.Match(KROMVersionStringCacheFileName) == KErrNotFound)) 

	#else

			if ((cacheFileName.Match(KTemp) == KErrNotFound)) 

	#endif

				{

				TFileName fileNameToDelete;

				fileNameToDelete.Append(iAppsListCachePath);

				fileNameToDelete.Append(cacheFileName);

				iFs.Delete(fileNameToDelete);

				}

			}

		delete cache;

		}

	}

void CApaAppList::RestoreL()

/** It restores the data present in the AppsList.bin file */

	{

	RFileReadStream theReadStream;

	User::LeaveIfError(theReadStream.Open(iFs, iAppsListCacheFileName, EFileRead));

	CleanupClosePushL(theReadStream);

	TLanguage appListFileLanguage = (TLanguage)theReadStream.ReadInt32L();

	if (appListFileLanguage != User::Language())

		{

		User::Leave(KErrNotSupported);

		}

#if defined (SYMBIAN_BAFL_SYSUTIL)

	//Build the filename for the cache file

	TInt maxSizeofFileName = iAppsListCachePath.Length() + KROMVersionStringCacheFileName().Length();

	RBuf romVersionCacheFileName;

	romVersionCacheFileName.CreateL(maxSizeofFileName);

	romVersionCacheFileName.CleanupClosePushL();

	romVersionCacheFileName.Append(iAppsListCachePath);

	romVersionCacheFileName.Append(KROMVersionStringCacheFileName());

	RFileReadStream romVerStream;

	User::LeaveIfError(romVerStream.Open(iFs,romVersionCacheFileName,EFileRead));

	CleanupClosePushL(romVerStream);

	TVersion actualROMVersionCacheFileVersion(KROMVersionCacheFileMajorVersion, KROMVersionCacheFileMinorVersion, KROMVersionCacheFileBuildVersion);

	TVersionName actualROMVersionCacheFileVersionName = actualROMVersionCacheFileVersion.Name();

	//read the rom file version

	TInt8 romVersionCacheFileMajorVersion = romVerStream.ReadInt8L();

	TInt8 romVersionCacheFileMinorVersion = romVerStream.ReadInt8L();

	TInt16 romVersionCacheFileBuildVersion = romVerStream.ReadInt16L();

	TVersion romVersionCacheFileVersion(romVersionCacheFileMajorVersion, romVersionCacheFileMinorVersion, romVersionCacheFileBuildVersion);

	TVersionName romVersionCacheFileVersionName = romVersionCacheFileVersion.Name();

	//If persisted file version differs from what apparc can handle, recreate rom version file and applist.bin

	if (romVersionCacheFileVersionName.Compare(actualROMVersionCacheFileVersionName) != 0)

		{

		User::Leave(KErrGeneral);

		}

	//Read the length & value of software version from it.

	TBuf<KInfoBufLength> softwareVersion;

	TUint32 length = romVerStream.ReadUint32L();

	if (length>KInfoBufLength)

		{

		//File must be corrupt, an attempt to read will panic

		User::Leave(KErrCorrupt);

		}	

	romVerStream.ReadL(softwareVersion, length);

	//the persisted version has been successfully read

	//read the actual current version string

	TBuf<KInfoBufLength> actualSoftwareVersion;

	TInt err = SysUtil::GetSWVersion(actualSoftwareVersion); //use the SysUtil implementation

	if(err == KErrNone)

		{

		if (softwareVersion.Compare(actualSoftwareVersion) != 0)

			{

			//Leave if the current version is different from the previous stored version and recreate applist.

#ifdef _DEBUG

			RDebug::Print(_L("!!Firmware update detected!! Rebuilding AppList"));

#endif

			User::Leave(KErrGeneral);

			}

		}

	else

		{

		//Leave if any error reading the version information, except if file is not present

		if (err != KErrPathNotFound && err != KErrNotFound)

			{

#ifdef _DEBUG

			RDebug::Print(_L("!!Error %d reading Firmware version.  Rebuilding AppList"),err);

#endif

			User::Leave(err);

			}

		}

	CleanupStack::PopAndDestroy(2); //romVerStream, romVersionCacheFileName

#endif

	// Create Default Icon File Name

	CreateDefaultAppIconFileNameL();

	TInt ret = KErrNone;

	while (ret == KErrNone)

		{

		CApaAppData* const pApp = new (ELeave) CApaAppData(iFs);

		CleanupStack::PushL(pApp);

		// Restore entries till we leave

		TRAP(ret, pApp->InternalizeL(theReadStream));

		if (ret != KErrNone && ret != KErrEof)

			{

			User::Leave(ret);

			}

		// Check that the app has not been added to the list twice

		if (ret == KErrNone && !AppDataByUid(pApp->iUidType[2]))

			{

			AddToList(pApp);

			CleanupStack::Pop(pApp);

			}

		else