/*

* Copyright (c) 2008-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:   Model implementation

*

*/

#include "appmngr2model.h"              // CAppMngr2Model

#include "appmngr2modelobserver.h"      // CAppMngr2ModelObserver

#include "appmngr2infomaker.h"          // CAppMngr2InfoMaker

#include "appmngr2appinfomaker.h"       // CAppMngr2AppInfoMaker

#include "appmngr2packageinfomaker.h"   // CAppMngr2PackageInfoMaker

#include "appmngr2appinfoarray.h"       // CAppMngr2AppInfoArray

#include "appmngr2packageinfoarray.h"   // CAppMngr2PackageInfoArray

#include "appmngr2scanner.h"            // CAppMngr2Scanner

#include "appmngr2pluginholder.h"       // CAppMngr2PluginHolder

#include <appmngr2runtime.h>            // CAppMngr2Runtime

#include <appmngr2infobase.h>           // CAppMngrInfoBase

#include <appmngr2appinfo.h>            // CAppMngr2AppInfo

#include <appmngr2packageinfo.h>        // CAppMngr2PackageInfo

#include <appmngr2recognizedfile.h>     // CAppMngr2RecognizedFile

#include <appmngr2cleanuputils.h>       // CleanupResetAndDestroyPushL

#include <appmngr2driveutils.h>         // TAppMngr2DriveUtils

#include <appmngr2common.hrh>           // generic command ids

#include <ecom/implementationinformation.h>  // CImplementationInformation

#include <ecom/ecom.h>                  // REComSession

#include <AknIconArray.h>               // CAknIconArray

#include <gulicon.h>                    // CGulIcon

#include <driveinfo.h>                  // DriveInfo

#include <pathinfo.h>                   // Pathinfo

#include <centralrepository.h>          // CRepository

#include <SWInstallerInternalCRKeys.h>  // KCRUidSWInstallerLV

#include <AknsUtils.h>                  // AknsUtils

#include <appmngr2.mbg>                 // icon IDs

_LIT( KAppMngr2BitmapFile, "appmngr2.mif" );

_LIT( KDriveSpec, "%c:" );

// ======== LOCAL FUNCTIONS =========

// ---------------------------------------------------------------------------

// FindDataType()

// ---------------------------------------------------------------------------

//

TBool FindDataType( const TDataType& aDataType, CDataTypeArray& aArray )

    {

    TInt count = aArray.Count();

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

        {

        if( aArray[ index ] == aDataType )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CAppMngr2Model::NewL()

// ---------------------------------------------------------------------------

//

CAppMngr2Model* CAppMngr2Model::NewL( RFs& aFsSession,

        MAppMngr2ModelObserver& aObserver )

    {

    CAppMngr2Model* self = new (ELeave) CAppMngr2Model( aFsSession, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::~CAppMngr2Model()

// ---------------------------------------------------------------------------

//

CAppMngr2Model::~CAppMngr2Model()

    {

    FLOG( "CAppMngr2Model::~CAppMngr2Model" );

    iClosing = ETrue;   // to disable notifications

    Cancel();

    delete iApaAppListNotifier;

    iInfoMakers.ResetAndDestroy();

    delete iScanner;

    delete iInstalledApps;

    delete iInstallationFiles;

    iPlugins.ResetAndDestroy();     // unloads plugin DLLs

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::AppInfoCount()

// ---------------------------------------------------------------------------

//

TInt CAppMngr2Model::AppInfoCount() const

    {

    return iInstalledApps->Count();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::AppInfo()

// ---------------------------------------------------------------------------

//

CAppMngr2AppInfo& CAppMngr2Model::AppInfo( TInt aIndex ) const

    {

    return *( reinterpret_cast< CAppMngr2AppInfo* >( iInstalledApps->At( aIndex ) ) );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::PackageInfoCount()

// ---------------------------------------------------------------------------

//

TInt CAppMngr2Model::PackageInfoCount() const

    {

    return iInstallationFiles->Count();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::PackageInfo()

// ---------------------------------------------------------------------------

//

CAppMngr2PackageInfo& CAppMngr2Model::PackageInfo( TInt aIndex ) const 

    {

    return *( reinterpret_cast< CAppMngr2PackageInfo* >( iInstallationFiles->At( aIndex ) ) );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::LoadIconsL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::LoadIconsL( CAknIconArray& aIconArray )

    {

    LoadDefaultIconsL( aIconArray );

    TInt pluginCount = iPlugins.Count();

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

        {

        iPlugins[ index ]->LoadIconsL( aIconArray );

        }

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::GetIconIndexesL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::GetIconIndexesL( TUid aUid, TInt& aIconIndexBase, TInt& aIconIndexMax ) const

    {

    TInt pluginCount = iPlugins.Count();

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

        {

        if( iPlugins[ index ]->Runtime().RuntimeUid() == aUid )

            {

            aIconIndexBase = iPlugins[ index ]->IconIndexBase();

            aIconIndexMax = iPlugins[ index ]->IconIndexMax();

            return;

            }

        }

    User::Leave( KErrNotFound );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::HandleCommandL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::HandleCommandL( CAppMngr2InfoBase& aInfo, TInt aCommand )

    {

    FLOG( "CAppMngr2Model::HandleCommandL( %d ), IsActive() = %d", aCommand, IsActive() );

    if( !IsActive() )

        {

        // About to start plugin specific command. Note that when the command completes

        // we need to call CAppMngr2InfoBase::CommandComplete() function. For this (and

        // to indicate that there is a plugin specific command on-going) we take the

        // address of CAppMngr2InfoBase item into iActiveItem. Because plugin specific

        // command (like delete or uninstall) may trigger new scanning, it is necessary

        // to disable iInstalledApps and iInstallationFiles array refreshing temporarily.

        // When refreshing is disabled, the item which address is stored in iActiveItem

        // is maintained in arrays and we can call iActiveItem->CommandComplete() when

        // the command is complete. If arrays could be refreshed during plugin specific

        // command, then calling iActiveItem->CommandComplete() would panic.

        if( iObs.InstalledAppsDisplayed() )

            {

            iInstalledApps->DisableRefreshNotificationsL();

            }

        if( iObs.InstallationFilesDisplayed() )

            {

            iInstallationFiles->DisableRefreshNotificationsL();

            }

        iActiveItem = &aInfo;

        iActiveCommand = aCommand;

        FLOG( "CAppMngr2Model::HandleCommandL, iActiveItem = 0x%08x '%S'",

                iActiveItem, &( iActiveItem->Name() ) ); 

        TRAPD( err, iActiveItem->HandleCommandL( aCommand, iStatus ) );

        FLOG( "CAppMngr2Model::HandleCommandL, command started, err = %d", err );

        SetActive();

        if( err )

            {

            TRequestStatus* statusPtr = &iStatus;

            User::RequestComplete( statusPtr, err );

            }

        }

    // Ignore the command silently if already active. This may happen when user

    // cancels previous installation command. Because cancelling installation can

    // take long time, user may be able to issue new commands while model is still

    // active (i.e. previous installation command is being cancalled).

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::StartFetchingInstallationFilesL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::StartFetchingInstallationFilesL()

    {

    FLOG( "CAppMngr2Model::StartFetchingInstallationFilesL" );

    FLOG_PERF_START( FetchInstallationFiles )

    // Installation files cache must be enabled until scanner has completed.

    // This ensures that scanner has time to call GetInstallationFilesL() for

    // each plugin and for each directory before the first call completes.

    // If the first call completes before scanner has made all these requets,

    // cache will be turned off and partial results are displayed.

    iInstallationFiles->IncrementCacheUseStartingNewRoundL();

    iScanner->StartScanningL();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::StartFetchingInstalledAppsL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::StartFetchingInstalledAppsL()

    {

    FLOG( "CAppMngr2Model::StartFetchingInstalledAppsL" );

    FLOG_PERF_START( FetchInstalledApps )

    // Additional cache increment to ensure that iInstalledApps cache is

    // used until GetInstalledAppsL() function is called for each plugin.

    // Without this, the fastest plugin might get it's list complete before

    // other IncrementCacheUseL() calls and iInstalledApps would display

    // partial list.

    iInstalledApps->IncrementCacheUseStartingNewRoundL();

    TInt pluginCount = iPlugins.Count();

    for( TInt pluginIndex = 0; pluginIndex < pluginCount; pluginIndex++ )

        {

        CAppMngr2AppInfoMaker* appInfoMaker = CAppMngr2AppInfoMaker::NewLC(

                iPlugins[ pluginIndex ]->Runtime(), *this, iFs );

        TRAPD( err, appInfoMaker->StartGettingInstalledAppsL() );

        FLOG( "CAppMngr2Model::StartFetchingInstalledAppsL, plugin 0x%08x, err = %d",

                iPlugins[ pluginIndex ]->Runtime().RuntimeUid().iUid, err );

        if( err == KErrNone )

            {

            iInfoMakers.AppendL( appInfoMaker );

            CleanupStack::Pop( appInfoMaker );

            iInstalledApps->IncrementCacheUseL();

            }

        else

            {

            CleanupStack::PopAndDestroy( appInfoMaker );

            }

        }

    // All GetInstalledAppsL() requests have been issued

    iInstalledApps->DecrementCacheUse();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::DoCancel()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::DoCancel()

    {

    FLOG( "CAppMngr2Model::DoCancel, iActiveItem = 0x%08x", iActiveItem );

    if( iActiveItem )

        {

        iActiveItem->CancelCommand();

        iActiveItem = NULL;

        if( !iClosing )

            {

            TRAP_IGNORE( iInstalledApps->EnableRefreshNotificationsL() );

            TRAP_IGNORE( iInstallationFiles->EnableRefreshNotificationsL() );

            }

        }

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::RunL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::RunL()

    {

    FLOG( "CAppMngr2Model::RunL, iActiveItem = 0x%08x, iStatus = %d",

            iActiveItem, iStatus.Int() );

    if( iActiveItem )

        {

        TInt completionCode = iStatus.Int();

        TRAPD( err, iActiveItem->HandleCommandResultL( completionCode ) );

        FLOG( "CAppMngr2Model::RunL, HandleCommandResultL err = %d", err );

        CAppMngr2InfoBase* itemToDelete = iActiveItem;

        iActiveItem = NULL;

        // Enable refresh notifications. No need to check which view is active

        // because notifications can be enabled even if they were not disabled.

        iInstalledApps->EnableRefreshNotificationsL();

        iInstallationFiles->EnableRefreshNotificationsL();

        // Leave on error. This displays error note (if error notes are enabled).

        User::LeaveIfError( err );

        // If the command is EAppMngr2CmdUninstall or EAppMngr2CmdRemove, and it

        // completed without errors, then we remove the current item immediatelty

        // from the displayed list. Otherwise it may take quite long time until

        // the item is removed from the UI, and in worst case it may not be removed

        // at all.

        // For example when an installation file is deleted, scanner notices change

        // in directories and re-scans everything. UI is updated when the scanning

        // completes. Delay between delete command and UI update (deleted item is

        // removed from UI) depends on how quickly scanning completes.

        if( completionCode == KErrNone )

            {

            if( iActiveCommand == EAppMngr2CmdUninstall && iObs.InstalledAppsDisplayed() )

                {

                iInstalledApps->ImmediateDelete( itemToDelete );

                }

            if( iActiveCommand == EAppMngr2CmdRemove && iObs.InstallationFilesDisplayed() )

                {

                iInstallationFiles->ImmediateDelete( itemToDelete );

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::RefreshInstalledApps()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::RefreshInstalledApps()

    {

    FLOG( "CAppMngr2Model::RefreshInstalledApps" );

    TRAP_IGNORE( StartFetchingInstalledAppsL() );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::RefreshInstallationFiles()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::RefreshInstallationFiles()

    {

    FLOG( "CAppMngr2Model::RefreshInstallationFiles" );

    TRAP_IGNORE( StartFetchingInstallationFilesL() );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::ScanningResultL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::ScanningResultL( RPointerArray<CAppMngr2RecognizedFile>& aResult )

    {

    FLOG( "CAppMngr2Model::ScanningResultL, begin: aResult.Count() = %d", aResult.Count() );

    // Split recognition result array into smaller (plugin specific) arrays. Plugin

    // specific arrays are maintained by CAppMngr2PackageInfoMaker objects, so one

    // CAppMngr2PackageInfoMaker object is needed for each plugin that has recognized

    // files.

    TInt pluginCount = iPlugins.Count();

    for( TInt pluginIndex = 0; pluginIndex < pluginCount; pluginIndex++ )

        {

        CAppMngr2PackageInfoMaker* packageInfoMaker = CAppMngr2PackageInfoMaker::NewLC(

                iPlugins[ pluginIndex ]->Runtime(), *this, iFs );

        TInt fileCount = 0;

        TInt resultCount = aResult.Count();

        for( TInt resultIndex = resultCount - 1; resultIndex >= 0; resultIndex-- )

            {

            CAppMngr2RecognizedFile* recFile = aResult[ resultIndex ];

            if( FindDataType( recFile->DataType(), iPlugins[ pluginIndex ]->DataTypes() ) )

                {

                packageInfoMaker->AddFileL( recFile );  // takes ownership

                aResult.Remove( resultIndex );

                fileCount++;

                }

            }

        FLOG( "CAppMngr2Model::ScanningResultL, plugin 0x%08x: fileCount = %d",

                iPlugins[ pluginIndex ]->Runtime().RuntimeUid().iUid, fileCount );

        if( fileCount > 0 )

            {

            packageInfoMaker->StartGettingInstallationFilesL();

            iInfoMakers.AppendL( packageInfoMaker );

            CleanupStack::Pop( packageInfoMaker );

            iInstallationFiles->IncrementCacheUseL();

            }

        else

            {

            CleanupStack::PopAndDestroy( packageInfoMaker );

            }

        }

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::ScanningComplete()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::ScanningComplete()

    {

    FLOG( "CAppMngr2Model::ScanningComplete" );

    iInstallationFiles->DecrementCacheUse();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::DirectoryChangedL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::DirectoryChangedL( const TDesC& /*aChangedDir*/ )

    {

    FLOG( "CAppMngr2Model::DirectoryChangedL" );

    // This might be improved by scanning the changed directory only. Model

    // could record which items are got from which directory, so that it could

    // remove those items that were created from the changed directory and

    // re-scan only the changed directory. Scanner should also support

    // scanning one directory only. Now, we just scan all again.

    StartFetchingInstallationFilesL();

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::HandleAppListEvent()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::HandleAppListEvent( TInt /*aEvent*/ )

    {

    FLOG( "CAppMngr2Model::HandleAppListEvent" );

    TRAP_IGNORE( StartFetchingInstalledAppsL() );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::NewAppsCreatedL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::NewAppsCreatedL( const CAppMngr2InfoMaker& aMaker,

        RPointerArray<CAppMngr2AppInfo>& aAppInfos )

    {

    FLOG( "CAppMngr2Model::NewAppsCreatedL, plugin 0x%08x: packageCount = %d",

            aMaker.RuntimeUid().iUid, aAppInfos.Count() );

    iInstalledApps->AddItemsInOrderL( aAppInfos );

    iInstalledApps->DecrementCacheUse();

    CloseInfoMaker( aMaker );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::ErrorInCreatingAppsL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::ErrorInCreatingAppsL( const CAppMngr2InfoMaker& aMaker,

#ifdef FLOG_DEBUG_TRACES

        TInt aError )

#else

        TInt /*aError*/ )

#endif

    {

    FLOG( "CAppMngr2Model::ErrorInCreatingAppsL, plugin 0x%08x: error = %d",

            aMaker.RuntimeUid().iUid, aError );

    iInstalledApps->DecrementCacheUse();

    CloseInfoMaker( aMaker );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::NewPackagesCreatedL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::NewPackagesCreatedL( const CAppMngr2InfoMaker& aMaker,

            RPointerArray<CAppMngr2PackageInfo>& aPackageInfos )

    {

    FLOG( "CAppMngr2Model::NewPackagesCreatedL, plugin 0x%08x: packageCount = %d",

            aMaker.RuntimeUid().iUid, aPackageInfos.Count() );

    iInstallationFiles->AddItemsInOrderL( aPackageInfos );

    iInstallationFiles->DecrementCacheUse();

    CloseInfoMaker( aMaker );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::ErrorInCreatingPackagesL()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::ErrorInCreatingPackagesL( const CAppMngr2InfoMaker& aMaker,

#ifdef FLOG_DEBUG_TRACES

        TInt aError )

#else

        TInt /*aError*/ )

#endif

    {

    FLOG( "CAppMngr2Model::ErrorInCreatingPackagesL, plugin 0x%08x: error = %d",

            aMaker.RuntimeUid().iUid, aError );

    iInstallationFiles->DecrementCacheUse();

    CloseInfoMaker( aMaker );

    }

// ---------------------------------------------------------------------------

// CAppMngr2Model::ArrayContentChanged()

// ---------------------------------------------------------------------------

//

void CAppMngr2Model::ArrayContentChanged( CAppMngr2InfoArray* aArray,