// Copyright (c) 2006-2010 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 <bautils.h>			// BaflUtils::NearestLanguageFile()

#include <s32mem.h>				// RBufWriteStream

#include "aplappinforeader.h"

#include "apsiconcaptionoverride.h"

#ifdef SYMBIAN_BAFL_SYSUTIL

#include <bafl/sysutil.h>

#endif

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include<usif/scr/scr.h>

#include<usif/scr/appregentries.h>

#else

#include "aplappregfinder.h"    // CApaAppRegFinder

#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

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

const TInt KNumAppEntriesFromSCR=10;

const TInt KSCRConnectionWaitTime=20000; //Time to wait if SCR is busy

const TUid KUidSisLaunchServer={0x1020473f};

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

	};

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

enum TApaSCRFetchAction

    {

    EGetAllAppsInfo, //Fetch all application the information from SCR

    EGetSpecificAppsInfo //Fetch only provided application uids information

    };

/*

 * Contain information about appliations to be fetched from SCR.

 */

NONSHARABLE_CLASS(CApaAppSCRFetchInfo : public CBase)

    { 

public:

    static CApaAppSCRFetchInfo* NewL(TApaSCRFetchAction aSCRFetchAction, RArray<TApaAppUpdateInfo>* aAppUpdateInfo);

    ~CApaAppSCRFetchInfo();

    RArray<TApaAppUpdateInfo>* AppUpdateInfo();

    TApaSCRFetchAction SCRFetchAction();

private:

    CApaAppSCRFetchInfo(TApaSCRFetchAction aSCRFetchAction, RArray<TApaAppUpdateInfo>* aAppUpdateInfo);

private:

    TApaSCRFetchAction iSCRFetchAction;

    RArray<TApaAppUpdateInfo>* iAppUpdateInfo;

    };

/*

 * Reads multiple application information from SCR and caches it. When requested provides one application

 * information at a time.

 */

NONSHARABLE_CLASS(CApaAppList::CApaScrAppInfo)

    {

public:

    static CApaScrAppInfo* NewL(const Usif::RSoftwareComponentRegistry& aScrCon, TInt aNumEntries);    

    void GetAllAppsInfoL();

    void GetSpecificAppsInfoL(RArray<TApaAppUpdateInfo>* aAppUpdateInfo);    

    TUid GetNextApplicationInfo(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData);

    TApaSCRFetchAction GetSCRFetchAction();    

    ~CApaScrAppInfo();

private:

    void ConstructL();

    CApaScrAppInfo(const Usif::RSoftwareComponentRegistry& aScr, TInt aNumEntries);

    void GetAppUidListL(RArray<TApaAppUpdateInfo>& aAppUpdateInfoArr, RArray<TUid>& aAppUids);

    TUid GetAllAppsNextApplicationInfoL(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData); 

    TUid GetSpecificAppsNextApplicationInfoL(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData);  

private:

    Usif::RApplicationRegistryView iScrAppView;

    RPointerArray<Usif::CApplicationRegistrationData> iAppInfo;

    RPointerArray<CApaAppSCRFetchInfo> iSCRFetchInfoQueue;

    const Usif::RSoftwareComponentRegistry& iSCR;   

    TBool iIsSCRRegViewOpen;

    TInt iSpecificAppsIndex;

    CApaAppSCRFetchInfo* iAppSCRFetchInfo;

    TBool iMoreAppInfo;

    TInt iNumEntriesToFetch;

    };

CApaAppSCRFetchInfo* CApaAppSCRFetchInfo::NewL(TApaSCRFetchAction aSCRFetchAction, RArray<TApaAppUpdateInfo>* aAppUpdateInfo)

            {

            //Ownership of aAppUpdateInfo is transfered to this object.

            CApaAppSCRFetchInfo* self=new (ELeave) CApaAppSCRFetchInfo(aSCRFetchAction, aAppUpdateInfo);

            return(self);

            }

CApaAppSCRFetchInfo::CApaAppSCRFetchInfo(TApaSCRFetchAction aSCRFetchAction, RArray<TApaAppUpdateInfo>* aAppUpdateInfo):

        iSCRFetchAction(aSCRFetchAction),        

        iAppUpdateInfo(aAppUpdateInfo)

        {

        }

CApaAppSCRFetchInfo::~CApaAppSCRFetchInfo()

    {

    delete iAppUpdateInfo;

    }

RArray<TApaAppUpdateInfo>* CApaAppSCRFetchInfo::AppUpdateInfo()

            {

            return iAppUpdateInfo;

            }

TApaSCRFetchAction CApaAppSCRFetchInfo::SCRFetchAction()

    {

    return iSCRFetchAction;

    }

//CApaAppList::CApaScrAppInfo

CApaAppList::CApaScrAppInfo* CApaAppList::CApaScrAppInfo::NewL(const Usif::RSoftwareComponentRegistry& aScrCon, TInt aNumEntries)

    { 

    CApaScrAppInfo* self=new(ELeave) CApaScrAppInfo(aScrCon, aNumEntries);

    CleanupStack::PushL(self);    

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CApaAppList::CApaScrAppInfo::CApaScrAppInfo(const Usif::RSoftwareComponentRegistry& aScr, TInt aNumEntries):

        iSCR(aScr),

        iIsSCRRegViewOpen(EFalse),

        iSpecificAppsIndex(-1),

        iAppSCRFetchInfo(NULL),

        iMoreAppInfo(EFalse),

        iNumEntriesToFetch(aNumEntries)

    {

    }

void CApaAppList::CApaScrAppInfo::ConstructL()

    {

    }

CApaAppList::CApaScrAppInfo::~CApaScrAppInfo()

    {

    if(iAppSCRFetchInfo)

        {

        delete iAppSCRFetchInfo; 

        iAppSCRFetchInfo=NULL;

        }

    iAppInfo.ResetAndDestroy();

    iSCRFetchInfoQueue.ResetAndDestroy();

    iScrAppView.Close();

    }

/*

 * Gets all the application information available in the SCR. It adds SCR fetch info with action EGetAllAppsInfo to a queue 

 * to get all the application information. The information can be obtained one at a time by calling GetNextApplicationInfoL 

 * function.

 */

void CApaAppList::CApaScrAppInfo::GetAllAppsInfoL()

    {

    CApaAppSCRFetchInfo* appSCRFetchInfo = CApaAppSCRFetchInfo::NewL(EGetAllAppsInfo, NULL);

    CleanupStack::PushL(appSCRFetchInfo);      

    iSCRFetchInfoQueue.AppendL(appSCRFetchInfo);

    CleanupStack::Pop();

    }

/*

 * Gets specific application information from the SCR. It adds SCR fetch info request with action EGetSpecificAppsInfo 

 * along with the required uid list to the queue. The information can be obtained one at a time by calling GetNextApplicationInfoL 

 * function.

 */

void CApaAppList::CApaScrAppInfo::GetSpecificAppsInfoL(RArray<TApaAppUpdateInfo>* aAppUpdateInfo)

    {

    CApaAppSCRFetchInfo* appSCRFetchInfo=CApaAppSCRFetchInfo::NewL(EGetSpecificAppsInfo, aAppUpdateInfo);

    CleanupStack::PushL(appSCRFetchInfo);

    iSCRFetchInfoQueue.AppendL(appSCRFetchInfo);

    CleanupStack::Pop();   

    }

/*

 * Create array of uids from TApaAppUpdateInfo array.

 */

void CApaAppList::CApaScrAppInfo::GetAppUidListL(RArray<TApaAppUpdateInfo>& aAppUpdateInfoArr, RArray<TUid>& aAppUids)

    {

    TInt count=aAppUpdateInfoArr.Count();

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

        {

        TApaAppUpdateInfo appUpdateInfo=aAppUpdateInfoArr[index];

        aAppUids.AppendL(appUpdateInfo.iAppUid);

        }

    }

TApaSCRFetchAction CApaAppList::CApaScrAppInfo::GetSCRFetchAction()

{

    return iAppSCRFetchInfo->SCRFetchAction();

}

/*

 * Provides one application information at a time. Returns Null UID if no more application information available.

 * Ownership of aAppData is transfered to calling function.

 */

TUid CApaAppList::CApaScrAppInfo::GetNextApplicationInfo(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData)

    {

    aAppData=NULL;

    TUid appUid=KNullUid;

    while(appUid==KNullUid)

        {

        //If there is no valid current SCR fetch information, get it from SCR fetch info queue

        if(!iAppSCRFetchInfo)

            {

            if(iSCRFetchInfoQueue.Count()>0)

                {

                //Get next SCR fetch info

                iAppSCRFetchInfo=iSCRFetchInfoQueue[0]; 

                iSCRFetchInfoQueue.Remove(0); 

                iMoreAppInfo=ETrue;               

                }

            else

                {

                //No more SCR fetch information avaialable.

                break;

                }

            }

        //Get next application information        

        if(iAppSCRFetchInfo->SCRFetchAction()==EGetAllAppsInfo)

            {

            //If there is a leave with current SCR fetch info, ignore and proceed with next SCR fetch info

            TRAP_IGNORE(appUid=GetAllAppsNextApplicationInfoL(aAppAction, aAppData));

            }

        else

            {

            //If there is a leave with current SCR fetch info, ignore and proceed with next SCR fetch info        

            TRAP_IGNORE(appUid=GetSpecificAppsNextApplicationInfoL(aAppAction, aAppData));       

            }

        if(appUid==KNullUid)

            {

            //If no application information avaialble with current fetch action reset the values for next SCR fetch action.

            delete iAppSCRFetchInfo;

            iAppSCRFetchInfo=NULL;

            iScrAppView.Close();

            iIsSCRRegViewOpen=EFalse;            

            }

        }

    return(appUid);

    }

TUid CApaAppList::CApaScrAppInfo::GetAllAppsNextApplicationInfoL(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData)

    {

    TUid appUid=KNullUid;

    if(iAppInfo.Count()==0 && iMoreAppInfo)

        {

        //Open registry view if its not open.

        if(!iIsSCRRegViewOpen)

            {

            TInt err=KErrNone;

            TInt timeOut=KSCRConnectionWaitTime;

            //Retry if an error occurs while opening a SCR view. 

            while(timeOut < KSCRConnectionWaitTime*8)

            {

            TRAP(err, iScrAppView.OpenViewL(iSCR));

            if(err != KErrNone)

                {

                User::After(timeOut);

                timeOut= (2*timeOut); 

                }

            else

                {

                break;

                }

            }

            User::LeaveIfError(err);

            iIsSCRRegViewOpen=ETrue;

            }

        //Get next available applications information.

        iScrAppView.GetNextApplicationRegistrationInfoL(iNumEntriesToFetch, iAppInfo);

        if(iAppInfo.Count()<KNumAppEntriesFromSCR)

            iMoreAppInfo=EFalse;

        }

    //If no application information avaialble, return Null UID.

    if(iAppInfo.Count()==0)

        return KNullUid;

    aAppData=iAppInfo[0];

    aAppAction=TApaAppUpdateInfo::EAppPresent;

    iAppInfo.Remove(0);

    appUid=aAppData->AppUid();

    return appUid;

    }

/*

 * Gets next application information when specific applications information requested.

 */

TUid CApaAppList::CApaScrAppInfo::GetSpecificAppsNextApplicationInfoL(TApaAppUpdateInfo::TApaAppAction& aAppAction, Usif::CApplicationRegistrationData*& aAppData)

    {

    TUid appUid=KNullUid;

    TApaAppUpdateInfo::TApaAppAction action = TApaAppUpdateInfo::EAppNotPresent; //To make compiler happy

    Usif::CApplicationRegistrationData* appData=NULL;

    while(appUid==KNullUid)

        {

        if(iAppInfo.Count()==0 && iMoreAppInfo)

            {

            //Open registry view if its not open and also provides application uid list for which applist needs to be updated.

            if(!iIsSCRRegViewOpen)

                {

                RArray<TUid> appUids;

                CleanupClosePushL(appUids);

                //Get application uids list.

                GetAppUidListL(*iAppSCRFetchInfo->AppUpdateInfo(), appUids);

                TInt err=KErrNone;

                do

                    {

                    TRAP(err, iScrAppView.OpenViewL(iSCR, appUids));

                    if(err)

                        User::After(KSCRConnectionWaitTime);

                    }

                while(err!=KErrNone);

                CleanupStack::PopAndDestroy();

                iIsSCRRegViewOpen=ETrue;

                iSpecificAppsIndex=0;

                }

            //Get next available applications information.

            iScrAppView.GetNextApplicationRegistrationInfoL(iNumEntriesToFetch,iAppInfo);

            if(iAppInfo.Count()<KNumAppEntriesFromSCR)

                iMoreAppInfo=EFalse;

            }

        RArray<TApaAppUpdateInfo>& appUpdateInfo=*iAppSCRFetchInfo->AppUpdateInfo();

        if(iSpecificAppsIndex<appUpdateInfo.Count())

            {

            appUid=appUpdateInfo[iSpecificAppsIndex].iAppUid;

            action=appUpdateInfo[iSpecificAppsIndex].iAction;

            //If application information avaialable, and if application action is not uninstalled or

            //If application action is uninstalled and the uninstalled application exists in SCR,

            //then get the info and assign to aAppData.

            if(iAppInfo.Count()>0)

                {

                if(iAppInfo[0]->AppUid()==appUid)

                    {

                    appData=iAppInfo[0];

                    iAppInfo.Remove(0);

                    }

                }

            iSpecificAppsIndex++;

            //If action is not uninstalled, there should be application data in SCR. Otherwise skip the application action.

            if((action!=TApaAppUpdateInfo::EAppNotPresent) && appData==NULL)

                {

                appUid=KNullUid;

                }

            }

            //If there are no more applications in the current update applist, break the loop;     

            if(appUpdateInfo.Count()==iSpecificAppsIndex)

                break;        

        }

    aAppData=appData;

    aAppAction=action;

    return appUid;

    }

#endif

//

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