FCL/sf/mw/appinstall: comparison appinstaller/AppMngr2/src/appmngr2model.cpp

equal deleted inserted replaced

-:aba6b8104af3
+:51c0f5edf5ef
 /*
-* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2008-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".
 // ---------------------------------------------------------------------------
 // CAppMngr2Model::PackageInfo()
 // ---------------------------------------------------------------------------
 //
 CAppMngr2PackageInfo& CAppMngr2Model::PackageInfo( TInt aIndex ) const
 {
 return *( reinterpret_cast< CAppMngr2PackageInfo* >( iInstallationFiles->At( aIndex ) ) );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::LoadIconsL( CAknIconArray& aIconArray )
 {
 LoadDefaultIconsL( aIconArray );
 TInt pluginCount = iPlugins.Count();
 for( TInt index = 0; index < pluginCount; index++ )
 {
 iPlugins[ index ]->LoadIconsL( aIconArray );
 }
 // ---------------------------------------------------------------------------
 //
 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
 }
 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 )
 {
 // CAppMngr2Model::StartFetchingInstallationFilesL()
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::StartFetchingInstallationFilesL()
 {
-FLOG( "CAppMngr2Model::StartFetchingInstallationFilesL" );
+FLOG( "CAppMngr2Model::StartFetchingInstallationFilesL, fetching %d",
-FLOG_PERF_START( FetchInstallationFiles )
+iFetchingInstallationFiles );
+if( !iFetchingInstallationFiles )
-// Installation files cache must be enabled until scanner has completed.
+{
-// This ensures that scanner has time to call GetInstallationFilesL() for
+FLOG_PERF_START( FetchInstallationFiles )
-// each plugin and for each directory before the first call completes.
+iFetchingInstallationFiles = ETrue;
-// If the first call completes before scanner has made all these requets,
-// cache will be turned off and partial results are displayed.
+// Installation files cache must be enabled until scanner has completed.
-iInstallationFiles->IncrementCacheUseStartingNewRoundL();
+// This ensures that scanner has time to call GetInstallationFilesL() for
+// each plugin and for each directory before the first call completes.
-iScanner->StartScanningL();
+// 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( "CAppMngr2Model::StartFetchingInstalledAppsL, fetching %d",
-FLOG_PERF_START( FetchInstalledApps )
+iFetchingInstalledApps );
+if( !iFetchingInstalledApps )
-// Additional cache increment to ensure that iInstalledApps cache is
+{
-// used until GetInstalledAppsL() function is called for each plugin.
+FLOG_PERF_START( FetchInstalledApps )
-// Without this, the fastest plugin might get it's list complete before
+iFetchingInstalledApps = ETrue;
-// other IncrementCacheUseL() calls and iInstalledApps would display
-// partial list.
+// Additional cache increment to ensure that iInstalledApps cache is
-iInstalledApps->IncrementCacheUseStartingNewRoundL();
+// used until GetInstalledAppsL() function is called for each plugin.
+// Without this, the fastest plugin might get it's list complete before
-TInt pluginCount = iPlugins.Count();
+// other IncrementCacheUseL() calls and iInstalledApps would display
-for( TInt pluginIndex = 0; pluginIndex < pluginCount; pluginIndex++ )
+// partial list.
-{
+iInstalledApps->IncrementCacheUseStartingNewRoundL();
-CAppMngr2AppInfoMaker* appInfoMaker = CAppMngr2AppInfoMaker::NewLC(
-iPlugins[ pluginIndex ]->Runtime(), *this, iFs );
+TInt pluginCount = iPlugins.Count();
+for( TInt pluginIndex = 0; pluginIndex < pluginCount; pluginIndex++ )
-TRAPD( err, appInfoMaker->StartGettingInstalledAppsL() );
+{
-FLOG( "CAppMngr2Model::StartFetchingInstalledAppsL, plugin 0x%08x, err = %d",
+CAppMngr2AppInfoMaker* appInfoMaker = CAppMngr2AppInfoMaker::NewLC(
-iPlugins[ pluginIndex ]->Runtime().RuntimeUid().iUid, err );
+iPlugins[ pluginIndex ]->Runtime(), *this, iFs );
-if( err == KErrNone )
-{
+TRAPD( err, appInfoMaker->StartGettingInstalledAppsL() );
-iInfoMakers.AppendL( appInfoMaker );
+FLOG( "CAppMngr2Model::StartFetchingInstalledAppsL, plugin 0x%08x, err = %d",
-CleanupStack::Pop( appInfoMaker );
+iPlugins[ pluginIndex ]->Runtime().RuntimeUid().iUid, err );
-iInstalledApps->IncrementCacheUseL();
+if( err == KErrNone )
-}
+{
-else
+iInfoMakers.AppendL( appInfoMaker );
-{
+CleanupStack::Pop( appInfoMaker );
-CleanupStack::PopAndDestroy( appInfoMaker );
+iInstalledApps->IncrementCacheUseL();
 }
-}
+else
+{
-// All GetInstalledAppsL() requests have been issued
+CleanupStack::PopAndDestroy( appInfoMaker );
-iInstalledApps->DecrementCacheUse();
+}
+}
+// 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 )
 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.
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::RefreshInstalledApps()
 {
 FLOG( "CAppMngr2Model::RefreshInstalledApps" );
 TRAP_IGNORE( StartFetchingInstalledAppsL() );
 }
 // ---------------------------------------------------------------------------
 // CAppMngr2Model::RefreshInstallationFiles()
 // ---------------------------------------------------------------------------
 //
 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();
 // ---------------------------------------------------------------------------
 //
 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.
 // ---------------------------------------------------------------------------
 //
 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 );
 }
 TInt /*aError*/ )
 #endif
 {
 FLOG( "CAppMngr2Model::ErrorInCreatingAppsL, plugin 0x%08x: error = %d",
 aMaker.RuntimeUid().iUid, aError );
 iInstalledApps->DecrementCacheUse();
 CloseInfoMaker( aMaker );
 }
 // ---------------------------------------------------------------------------
 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 );
 }
 TInt /*aError*/ )
 #endif
 {
 FLOG( "CAppMngr2Model::ErrorInCreatingPackagesL, plugin 0x%08x: error = %d",
 aMaker.RuntimeUid().iUid, aError );
 iInstallationFiles->DecrementCacheUse();
 CloseInfoMaker( aMaker );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::ArrayContentChanged( CAppMngr2InfoArray* aArray,
 TInt aMoreRefreshesExpected )
 {
+FLOG( "CAppMngr2Model::ArrayContentChanged, more = %d", aMoreRefreshesExpected );
 if( aArray == iInstalledApps )
 {
 FLOG_PERF_STOP( FetchInstalledApps )
 FLOG_PERF_PRINT( FetchInstalledApps )
 iObs.InstalledAppsChanged( aMoreRefreshesExpected );
+if( !aMoreRefreshesExpected )
+{
+FLOG( "CAppMngr2Model::ArrayContentChanged: StartFetchingInstalledAppsL done" );
+iFetchingInstalledApps = EFalse;
+}
 }
 if( aArray == iInstallationFiles )
 {
 FLOG_PERF_STOP( FetchInstallationFiles )
 FLOG_PERF_PRINT( FetchInstallationFiles )
 iObs.InstallationFilesChanged( aMoreRefreshesExpected );
+if( !aMoreRefreshesExpected )
+{
+FLOG( "CAppMngr2Model::ArrayContentChanged: StartFetchingInstallationFilesL done" );
+iFetchingInstallationFiles = EFalse;
+}
 }
 }
 // ---------------------------------------------------------------------------
 // CAppMngr2Model::CAppMngr2Model()
 FLOG( "CAppMngr2Model::ConstructL" );
 iClosing = EFalse;
 iInstalledApps = CAppMngr2AppInfoArray::NewL( *this );
 iInstallationFiles = CAppMngr2PackageInfoArray::NewL( *this );
 FLOG_PERF_STATIC_BEGIN( LoadPluginsL )
 LoadPluginsL();
 FLOG_PERF_STATIC_END( LoadPluginsL )
 FLOG_PERF_STATIC_BEGIN( CreateScannerL )
 CreateScannerL();
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::LoadDefaultIconsL( CAknIconArray& aIconArray )
 {
 FLOG( "CAppMngr2Model::LoadDefaultIconsL" );
 MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
 HBufC* bitmapFile = TAppMngr2DriveUtils::FullBitmapFileNameLC( KAppMngr2BitmapFile, iFs );
 CFbsBitmap* bitmap = NULL;
 CFbsBitmap* mask = NULL;
 CGulIcon* icon = NULL;
 // Note that icons can be graphically-skinned (icon graphic defined in theme)
 // or color-skinned (icon colors change depending on background color defined
 // in theme). Normal icons are graphically-skinned and indicator icons are
 // color-skinned. AknsUtils::CreateGulIconL() creates graphically-skinned icons,
 // and AknsUtils::CreateColorIconL() creates color-skinned icons. Hence both
 // of these functions are used below.
 // Icon 0: EAppMngr2IconIndex_QgnIndiAmInstMmcAdd
 // Indicator icon for items stored/installed in memory card
 AknsUtils::CreateColorIconLC( skinInstance,
 KAknsIIDQgnIndiMmcAdd, KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13,
 bitmap, mask, *bitmapFile,
 EMbmAppmngr2Qgn_indi_mmc_add,
 EMbmAppmngr2Qgn_indi_mmc_add_mask,
 KRgbBlack );
 icon = CGulIcon::NewL( bitmap, mask );
 icon->SetBitmapsOwnedExternally( EFalse );
 aIconArray.AppendL( icon );
 CleanupStack::Pop( icon );
 // Icon 1: EAppMngr2IconIndex_QgnIndiFmgrMsAdd
 // Indicator icon for items stored/installed in mass memory
 AknsUtils::CreateColorIconLC( skinInstance,
 KAknsIIDQgnIndiFmgrMsAdd, KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13,
 bitmap, mask, *bitmapFile,
 EMbmAppmngr2Qgn_indi_fmgr_ms_add,
 EMbmAppmngr2Qgn_indi_fmgr_ms_add_mask,
 KRgbBlack );
 icon = CGulIcon::NewL( bitmap, mask );
 icon->SetBitmapsOwnedExternally( EFalse );
 // Icon 2: EAppMngr2IconIndex_QgnPropUnknown
 // List icon for items that are not known
 icon = AknsUtils::CreateGulIconL( skinInstance,
 KAknsIIDQgnPropUnknown, *bitmapFile,
 EMbmAppmngr2Qgn_prop_unknown,
 EMbmAppmngr2Qgn_prop_unknown_mask );
 CleanupStack::PushL( icon );
 aIconArray.AppendL( icon );
 CleanupStack::Pop( icon );
 CleanupStack::PopAndDestroy( bitmapFile );
 // Additionally some unknown indicator icon could be defined.
 // Now, if some plugin gives incorrect index fox indicator icon,
 // then no indicator icon is displayed.
 }
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::LoadPluginsL()
 {
 FLOG( "CAppMngr2Model::LoadPluginsL" );
 RImplInfoPtrArray implInfoArray;
 CleanupResetAndDestroyPushL( implInfoArray  );
 REComSession::ListImplementationsL( KAppMngr2PluginInterface, implInfoArray );
 CAppMngr2PluginHolder* pluginHolder = NULL;
 iScanner->AddDirectoryL( dirName );
 }
 }
 CleanupStack::PopAndDestroy( &dirsToScan );
 }
 // KSWInstallerPackageFolder directory if defined in CenRep
 CRepository* cenrep = CRepository::NewLC( KCRUidSWInstallerLV );
 err = cenrep->Get( KSWInstallerPackageFolder, path );
 CleanupStack::PopAndDestroy( cenrep );
 if( err == KErrNone )
 TChar driveLetter;
 if( RFs::DriveToChar( driveNumber, driveLetter ) == KErrNone )
 {
 TFileName fullPath;
 fullPath.Format( KDriveSpec, static_cast<TUint>( driveLetter ) );
 fullPath.Append( path );
 iScanner->AddDirectoryL( fullPath );
 }
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CAppMngr2Model::FetchDataTypesL()
 {
 FLOG( "CAppMngr2Model::FetchDataTypesL" );
 TInt pluginCount = iPlugins.Count();
 for( TInt pluginIndex = 0; pluginIndex < pluginCount; pluginIndex++ )
 {
 FLOG( "CAppMngr2Model::FetchDataTypesL: pluginIndex = %d", pluginIndex );
 TRAP_IGNORE( iPlugins[ pluginIndex ]->FetchDataTypesL() );
 void CAppMngr2Model::CloseInfoMaker( const CAppMngr2InfoMaker& aMaker )
 {
 const CAppMngr2InfoMaker* makerToClose = &aMaker;
 for( TInt index = iInfoMakers.Count() - 1; index >= 0; index-- )
 {
 CAppMngr2InfoMaker* maker = iInfoMakers[ index ];
 if( maker == makerToClose )
 {
 iInfoMakers.Remove( index );
 delete maker;
 break;

branch	RCL_3
changeset 15	51c0f5edf5ef
parent 0	ba25891c3a9e
child 19	7ca52d38f8c3