FCL/sf/mw/homescreensrv: comparison contentstorage/casrv/caappscanner/src/casrvappscanner.cpp

equal deleted inserted replaced

-:b99b84bcd2d1
+:9b022b1f357c
 *
 */
 #include <e32property.h>
 #include <bautils.h>
-#include <swi/sisregistrysession.h>
-#include <swi/sisregistryentry.h>
-#include <swi/sisregistrypackage.h>
 #include <usif/scr/screntries.h>
 #include "cadef.h"
 #include "casrvappscanner.h"
 #include "cautils.h"
 CCaSrvAppScanner::~CCaSrvAppScanner()
 {
 Cancel();
 iSoftwareRegistry.Close();
 iApaLsSession.Close();
-iInstalledPackages.Close();
-delete iInstallNotifier;
-delete iNotifier;
 delete iMmcHistory;
 iFs.Close();
 }
 // ---------------------------------------------------------
 User::Leave( mdRes );
 }
 }
 iMmcHistory = CCaSrvMmcHistory::NewL();
 iMmcHistory->LoadL( iFs, KCaMmcHistoryFname() );
-iNotifier = CApaAppListNotifier::NewL(
-this, CActive::EPriorityStandard );
-iInstallNotifier = CCaInstallNotifier::NewL(
-*this, CCaInstallNotifier::ESisInstallNotification );
 User::LeaveIfError( iApaLsSession.Connect() );
-User::LeaveIfError( iApaLsSession.GetAllApps() ); // This is async.
 User::LeaveIfError( iSoftwareRegistry.Connect() );
-iApaLsSession.RegisterListPopulationCompleteObserver( iStatus );
+iApaLsSession.SetNotify( EFalse, iStatus );
 iCollectionDownloadId = 0;
 iAllCollectionId = 0;
-//TODO temporary sollution for fake uninstall progres notification
+UpdateApplicationEntriesL();
-ClearUninstallFlagL();
+MakeNotEmptyCollectionsVisibleL();
 SetActive();
 }
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
-//TODO temporary sollution for fake uninstall progres notification
-void CCaSrvAppScanner::ClearUninstallFlagL()
-{
-CCaInnerQuery* uninstallQuery = CCaInnerQuery::NewLC();
-uninstallQuery->SetFlagsOn( EUninstall );
-RPointerArray<CCaInnerEntry> resultArray;
-CleanupResetAndDestroyPushL( resultArray );
-iCaStorageProxy.GetEntriesL( uninstallQuery, resultArray );
-for( TInt i = 0; i < resultArray.Count(); i++ )
-{
-resultArray[i]->SetFlags( resultArray[i]->GetFlags() & ~EUninstall );
-iCaStorageProxy.AddL( resultArray[i] );
-}
-CleanupStack::PopAndDestroy( &resultArray );
-CleanupStack::PopAndDestroy( uninstallQuery );
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
 void CCaSrvAppScanner::RunL()
 {
 User::LeaveIfError( iStatus.Int() );
 // AppArc app scan complete, we have the app list.
-UpdateApplicationEntriesL();
+RArray<TApaAppUpdateInfo> updatedAppsInfo;
-InstallationNotifyL();
+CleanupClosePushL( updatedAppsInfo );
-MakeNotEmptyCollectionsVisibleL();
+iApaLsSession.UpdatedAppsInfoL( updatedAppsInfo );
+for( TInt i = 0; i < updatedAppsInfo.Count(); i++ )
+	{
+		TApaAppUpdateInfo::TApaAppAction action = updatedAppsInfo[i].iAction;
+RPointerArray<CCaInnerEntry> resultArray;
+CleanupResetAndDestroyPushL( resultArray );
+GetCaAppEntriesL( updatedAppsInfo[i].iAppUid.iUid, resultArray );
+		if( action == TApaAppUpdateInfo::EAppPresent
+				|| action == TApaAppUpdateInfo::EAppInfoChanged )
+			{
+			TInt id;
+			if( !resultArray.Count() )
+				{
+id = AddAppEntryL(
+updatedAppsInfo[i].iAppUid.iUid, UpdateMmcHistoryL() );
+				}
+			else
+			    {
+ASSERT( resultArray.Count() == 1 );
+id = resultArray[0]->GetId();
+UpdateAppEntryL( resultArray[0], UpdateMmcHistoryL(), ETrue );
+AddEntryToPredefinedCollectionL( resultArray[0], ETrue );
+			    }
+AddEntryToDownloadedCollectionL( id );
+MakeNotEmptyCollectionsVisibleL();
+			}
+		else if( action == TApaAppUpdateInfo::EAppNotPresent )
+			{
+			HandleMissingItemsL( resultArray );
+			}
+		else
+			{
+			User::Leave( KErrNotSupported );
+			}
+CleanupStack::PopAndDestroy( &resultArray );
+	}
+CleanupStack::PopAndDestroy( &updatedAppsInfo );
+iApaLsSession.SetNotify( EFalse, iStatus );
+SetActive();
 }
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::DoCancel()
 {
-iApaLsSession.CancelListPopulationCompleteObserver();
+iApaLsSession.CancelNotify();
 }
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::UpdateAppEntryL( CCaInnerEntry* aEntry, TUint aMmcId )
+void CCaSrvAppScanner::UpdateAppEntryL(
+CCaInnerEntry* aEntry, TUint aMmcId, TBool aAlwaysUpdate  )
 {
 TBool toUpdate = HandleMmcAttrUpdateL( aEntry, aMmcId );
 TBool missingVisibleFlagChanged =
 HandleMissingVisibleFlagsUpdate( aEntry );
 toUpdate = missingVisibleFlagChanged || toUpdate;
 toUpdate = HandleRemovableVisibleFlagsUpdateL( aEntry ) || toUpdate;
 toUpdate = SetApaAppInfoL( aEntry ) || toUpdate;
+toUpdate = RemoveUninstallFlagL( aEntry ) || toUpdate;
-if( iInstalledPackages.Find( aEntry->GetUid() ) != KErrNotFound )
-{
+if( toUpdate || aAlwaysUpdate )
-AddEntryToDownloadedCollectionL( aEntry->GetId() );
-toUpdate = HandleUsedFlagUpdate( aEntry ) || toUpdate;
-AddEntryToPredefinedCollectionL( aEntry, ETrue );
-}
-if( toUpdate )
 {
 //update app in storage
+HandleUsedFlagUpdate( aEntry );
 TItemAppearance itemAppearanceChange = EItemAppearanceNotChanged;
 if( missingVisibleFlagChanged )
 {
 itemAppearanceChange = EItemAppeared;
 }
 iCaStorageProxy.AddL( aEntry, EFalse, itemAppearanceChange );
-RemoveFromInstalledPackages( aEntry->GetUid() );
 }
 }
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::InstallationNotifyL()
-{
-for( TInt i = iInstalledPackages.Count() - 1; i >= 0; i-- )
-{
-NotifyL( iInstalledPackages[i] );
-iInstalledPackages.Remove( i );
-}
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
 void CCaSrvAppScanner::UpdateApplicationEntriesL()
 {
 TUint currentMmcId = UpdateMmcHistoryL();
 // get all Content arsenal enties with type application
 RPointerArray<CCaInnerEntry> resultArray;
 if( ( aItem->GetFlags() & ERemovable ) == 0 )
 {
 aItem->SetFlags( aItem->GetFlags() | ERemovable );
 toChange = ETrue;
 }
+}
+return toChange;
+}
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CCaSrvAppScanner::RemoveUninstallFlagL( CCaInnerEntry* aItem )
+{
+TBool toChange( EFalse );
+if( aItem->GetFlags() & EUninstall )
+{
+		aItem->SetFlags( aItem->GetFlags() & ~EUninstall );
+		toChange = ETrue;
 }
 return toChange;
 }
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::HandleAppListEvent( TInt /*aEvent*/)
-{
-// We only have one event, EAppListChanged.
-// Call back RunL async, to requeue and initiate rescan.
-if( !IsActive() )
-{
-ScheduleScan();
-}
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-void CCaSrvAppScanner::HandleInstallNotifyL( TInt aUid )
-{
-NotifyL( aUid );
-RArray<TUid> uids;
-CleanupClosePushL( uids );
-Swi::RSisRegistrySession iSisRegSession;
-CleanupClosePushL( iSisRegSession );
-User::LeaveIfError( iSisRegSession.Connect() );
-// Open sis package entry related to aUid
-Swi::RSisRegistryEntry packageEntry;
-if( KErrNone
-== packageEntry.Open( iSisRegSession, TUid::Uid( aUid ) ) )
-{
-CleanupClosePushL( packageEntry );
-// Get packageEntry's embedded sis'
-RPointerArray<Swi::CSisRegistryPackage> embedded;
-CleanupResetAndDestroyPushL( embedded );
-packageEntry.EmbeddedPackagesL( embedded );
-if( embedded.Count() )
-{
-// For each embadded sis we notify storage - recursive call
-for( TInt i = 0; i < embedded.Count(); ++i )
-{
-HandleInstallNotifyL( embedded[i]->Uid().iUid );
-}
-}
-else
-{
-// There are no embaddes sis', so we can notify storage
-// of changes in apps included in packageEntry
-NotifyL( packageEntry );
-}
-CleanupStack::PopAndDestroy( &embedded );
-CleanupStack::PopAndDestroy( &packageEntry );
-}
-CleanupStack::PopAndDestroy( &iSisRegSession );
-CleanupStack::PopAndDestroy( &uids );
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-void CCaSrvAppScanner::NotifyL( Swi::RSisRegistryEntry & aPackageEntry )
-{
-// Get sids ( == uids of exetucables included in aPackageEntry )
-RArray<TUid> sids;
-CleanupClosePushL( sids );
-aPackageEntry.SidsL( sids );
-if( sids.Count() )
-{
-// For each sid we notify storage
-for( TInt i = 0; i < sids.Count(); ++i )
-{
-iInstalledPackages.Append( sids[i].iUid );
-}
-}
-CleanupStack::PopAndDestroy( &sids );
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-void CCaSrvAppScanner::NotifyL( TInt aAppUid )
-{
-// Get entries for given aAppUid
-RPointerArray<CCaInnerEntry> resultArray;
-CleanupResetAndDestroyPushL( resultArray );
-GetCaAppEntriesL( aAppUid, resultArray );
-if( resultArray.Count() && ( resultArray[0]->GetFlags() & EVisible ) )
-{//TODO: this only for icons. This functionality should be change
-iCaStorageProxy.AddL( resultArray[0] );
-}
-CleanupStack::PopAndDestroy( &resultArray );
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
 void CCaSrvAppScanner::AddEntryToDownloadedCollectionL( TInt aEntryId )
 {
 TCaOperationParams params;
 params.iOperationType = TCaOperationParams::EPrepend;
 params.iGroupId = GetCollectionDownloadIdL();
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::ScheduleScan()
+TInt CCaSrvAppScanner::AddAppEntryL( TUint aUid, TUint aCurrentMmcId )
 {
-if( !IsActive() )
+TInt id(KErrNotFound);
-{
-TRequestStatus* ownStatus = &iStatus;
-*ownStatus = KRequestPending;
-SetActive();
-User::RequestComplete( ownStatus, KErrNone );
-}
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-void CCaSrvAppScanner::AddAppEntryL( TUint aUid, TUint aCurrentMmcId )
-{
 // Now add the app entry.
 CCaInnerEntry* appEntry = CCaInnerEntry::NewLC();
 appEntry->SetEntryTypeNameL( KCaTypeApp );
 appEntry->SetUid( aUid );
 SetApaAppInfoL( appEntry );
 HandleRemovableVisibleFlagsUpdateL( appEntry );
 HandleMmcAttrUpdateL( appEntry, aCurrentMmcId );
 iCaStorageProxy.AddL( appEntry );
+id = appEntry->GetId();
 AddEntryToPredefinedCollectionL( appEntry );
-if( iInstalledPackages.Find( aUid ) != KErrNotFound )
-{
-AddEntryToDownloadedCollectionL( appEntry->GetId() );
-RemoveFromInstalledPackages( aUid );
-}
 CleanupStack::PopAndDestroy( appEntry );
-}
+return id;
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-void CCaSrvAppScanner::RemoveFromInstalledPackages( TUint aUid )
-{
-TInt appIndex = iInstalledPackages.Find( aUid );
-if( appIndex != KErrNotFound )
-{
-iInstalledPackages.Remove( appIndex );
-}
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 {
 aEntry->SetTextL( info->iCaption );
 aEntry->AddAttributeL( KCaAttrShortName, info->iShortCaption );
 changed = ETrue;
 }
 if ( UpdateComponentIdL( *aEntry ) )
 {
 changed = ETrue;
 }
 CleanupStack::PopAndDestroy( &attrVal );
 // check if its java app and add attr for entries
 TUid appTypeUid;
 if( KErrNone == iApaLsSession.GetAppType( appTypeUid, info->iUid ) )
 {
 if( appTypeUid == KMidletApplicationTypeUid )
 {
 aEntry->AddAttributeL(
 KCaAttrAppType,
 KCaAttrAppTypeValueJava );
 TComponentId compId =
 iSoftwareRegistry.GetComponentIdForAppL( info->iUid );
 CPropertyEntry* propertyEntry =
 iSoftwareRegistry.GetComponentPropertyL( compId, KCaScrPropertyAppSettings );
 CleanupStack::PushL( propertyEntry );
 if ( propertyEntry &&
 propertyEntry->PropertyType() == CPropertyEntry::ELocalizedProperty )
 {
 aEntry->AddAttributeL(
 KCaAttrAppSettingsPlugin,
 static_cast<CLocalizablePropertyEntry*>(propertyEntry)->StrValue() );
 }
 else if ( appTypeUid == KCWRTApplicationTypeUid )
 {
 aEntry->AddAttributeL(
 KCaAttrAppType,
 KCaAttrAppTypeValueCWRT );
 TComponentId compId =
 iSoftwareRegistry.GetComponentIdForAppL( info->iUid );
 CPropertyEntry* isMiniview =
 iSoftwareRegistry.GetComponentPropertyL( compId,
 KCaScrPropertyIsMiniviewSupported );
 CleanupStack::PushL( isMiniview );
 // check first if we support mini view
 if (isMiniview && isMiniview->PropertyType() == CPropertyEntry::EIntProperty &&
 static_cast<CIntPropertyEntry*>(isMiniview)->IntValue())
 {
 CPropertyEntry* appId =
 iSoftwareRegistry.GetComponentPropertyL( compId, KCaScrPropertyAppId );
 CleanupStack::PushL( appId );
 if ( appId &&
 appId->PropertyType() == CPropertyEntry::ELocalizedProperty )
 {
 aEntry->AddAttributeL(
 KCaAttrAppWidgetUri,
 KCaAttrAppWidgetUriCWRTValue );
 aEntry->AddAttributeL(
 KCaAttrAppWidgetParamWebAppId,
 static_cast<CLocalizablePropertyEntry*>(appId)->StrValue() );
 }
 CleanupStack::PopAndDestroy( appId );
 }
 CleanupStack::PopAndDestroy( isMiniview );
 }
 }
 }
 CleanupStack::PopAndDestroy( info );
 if( aCaEntries[i]->FindAttribute( KCaAttrMmcId(), attrVal ) )
 {
 TUint mmcId = 0;
 MenuUtils::GetTUint( attrVal, mmcId );
 if( ( mmcId && KErrNotFound != iMmcHistory->Find( mmcId )
 && mmcId != CurrentMmcId() )
 || ( attrVal == KCaMassStorage()
 && IsDriveInUse( DriveInfo::EDefaultMassStorage ) ) )
 {
 // This item is on an MMC which is currently
 // in the MMC history or on a mass storage in use.
 // Set it "missing" but keep it.
 //
 // ---------------------------------------------------------//
 TBool CCaSrvAppScanner::UpdateComponentIdL( CCaInnerEntry& aEntry ) const
 {
 TBool updated( EFalse );
 TUid uid;
 TInt err(KErrNone);
 TComponentId componentId( 0 );
 TRAP(err, componentId =
 iSoftwareRegistry.GetComponentIdForAppL(
 uid.Uid( aEntry.GetUid() ) ) )
 if ( componentId > 0 && err == KErrNone )
 {
 RBuf newComponentId;
 newComponentId.CleanupClosePushL();
 newComponentId.CreateL( sizeof(TComponentId) + 1 );
 newComponentId.AppendNum( componentId );
 RBuf oldComponentId;
 oldComponentId.CleanupClosePushL();
 oldComponentId.CreateL( KCaMaxAttrValueLen );
 const TBool componentIdAttributeFound =
 aEntry.FindAttribute( KCaComponentId, oldComponentId );
 if ( !componentIdAttributeFound
 || oldComponentId.Compare( newComponentId ) != 0 )
 {
 // 'add' or 'update' the component id attribute value
 aEntry.AddAttributeL( KCaComponentId,
 newComponentId );
 updated = ETrue;
 }
 CleanupStack::PopAndDestroy( &oldComponentId );
 CleanupStack::PopAndDestroy( &newComponentId );
 }
 return updated;
 }

changeset 104	9b022b1f357c
parent 103	b99b84bcd2d1
child 109	e0aa398e6810