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

equal deleted inserted replaced

-:82b66994846c
+:dbb8300717f7
 #include <e32property.h>
 #include <bautils.h>
 #include <swi/sisregistrysession.h>
 #include <swi/sisregistryentry.h>
 #include <swi/sisregistrypackage.h>
+#include <usif/scr/screntries.h>
 #include <WidgetRegistryClient.h>
 #include "cadef.h"
 #include "casrvappscanner.h"
 #include "cautils.h"
 #include "cainnerquery.h"
 #include "cainnerentry.h"
 #include "caarraycleanup.inl"
 #include "castorageproxy.h"
+#include "caarraycleanup.inl"
+using namespace Usif;
 // ==================== LOCAL FUNCTIONS ====================
 /**
 * Identity function to search in an array of CCaInnerEntry.
 }
 // ==================== MEMBER FUNCTIONS ====================
 // ---------------------------------------------------------
-// CCaSrvAppScanner::NewL
+//
 // ---------------------------------------------------------
 //
 CCaSrvAppScanner* CCaSrvAppScanner::NewL( CCaStorageProxy& aCaStorageProxy,
 CCaSrvEngUtils& aUtils )
 {
 CleanupStack::Pop( scanner );
 return scanner;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::~CCaSrvAppScanner
+//
 // ---------------------------------------------------------
 //
 CCaSrvAppScanner::~CCaSrvAppScanner()
 {
 Cancel();
+iSoftwareRegistry.Close();
 iApaLsSession.Close();
 iInstalledPackages.Close();
 delete iInstallNotifier;
 delete iNotifier;
 delete iMmcHistory;
 iFs.Close();
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::CCaSrvAppScanner
+//
 // ---------------------------------------------------------
 //
 CCaSrvAppScanner::CCaSrvAppScanner( CCaStorageProxy& aCaStorageProxy,
 CCaSrvEngUtils& aUtils ) :
 CActive( CActive::EPriorityStandard ),
 {
 CActiveScheduler::Add( this );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::ConstructL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::ConstructL()
 {
 User::LeaveIfError( iFs.Connect() );
 TFileName path;
 User::LeaveIfError( iFs.PrivatePath( path ) );
 TUint attribute;
-if( iFs.Att( path, attribute) == KErrNotFound )
+if( iFs.Att( path, attribute ) == KErrNotFound )
 {
 TInt mdRes = iFs.MkDirAll( path );
 if ( mdRes != KErrNone )
 {
 User::Leave( mdRes );
 }
 }
-iMmcHistory = new (ELeave) CCaSrvMmcHistory();
+iMmcHistory = CCaSrvMmcHistory::NewL();
 iMmcHistory->LoadL( iFs, KCaMmcHistoryFname() );
-// The notifier has its own session to apparc, instead of taking
-// it as argument... :(
 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 );
 iCollectionDownloadId = 0;
 iAllCollectionId = 0;
 SetActive();
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RunL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::RunL()
 {
-User::LeaveIfError( iStatus.Int() ); // Handle errors in RunL.
+User::LeaveIfError( iStatus.Int() );
 // AppArc app scan complete, we have the app list.
 UpdateApplicationEntriesL();
 InstallationNotifyL();
 MakeNotEmptyCollectionsVisibleL();
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::DoCancel
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::DoCancel()
 {
 iApaLsSession.CancelListPopulationCompleteObserver();
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RunError
+//
 // ---------------------------------------------------------
 //
 TInt CCaSrvAppScanner::RunError( TInt /*aError*/)
 {
 // Ignore the error (what else could we do?).
-// When next AppArc update occurs, we will run again.
+// When next update occurs, we will run again.
 return KErrNone;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::UpdateApplicationItemL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::UpdateApplicationEntryL(
 RPointerArray<CCaInnerEntry>& aCaEntries,
-const TCaAppAtributes& aApaItem, TUint aMmcId )
+TUint aAppUid, TUint aMmcId )
 {
-TInt appuid = aApaItem.GetUid();
 RPointerArray<CCaInnerEntry> resultArray;
 CleanupResetAndDestroyPushL( resultArray );
-GetCaAppEntriesL( appuid, resultArray );
+GetCaAppEntriesL( aAppUid, resultArray );
 // This app is not in the storage, add it now.
 // We don't add hidden items, there are too many of them!
 // do not display Menu app
 if( !resultArray.Count() )
 {
-AddAppEntryL( appuid, aMmcId );
+AddAppEntryL( aAppUid, aMmcId );
 }//if
 // "removable", "missing" and "visible"  flags update
 for( TInt j = 0; j < resultArray.Count(); j++ )
 {
-//we need to handle first run of appscanner,
+//We need to handle first run of appscanner,
-//there might be some incorrect data in content xml file
+//there might be some incorrect data. If this will have impact
-//if this will have impact on performance we may run this methods only at start up
+//on performance we may run this methods only at start up.
 UpdateAppEntryL( resultArray[j], aMmcId );
 TInt index = aCaEntries.Find( resultArray[j],
 TIdentityRelation<CCaInnerEntry>( IdMatch ) );
 if( index != KErrNotFound )
 }//for
 CleanupStack::PopAndDestroy( &resultArray );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::UpdateAppEntryL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::UpdateAppEntryL( CCaInnerEntry* aEntry, TUint aMmcId )
 {
 TBool toUpdate = HandleMmcAttrUpdateL( aEntry, aMmcId );
 TBool missingVisibleFlagChanged =
 HandleMissingVisibleFlagsUpdate( aEntry );
 toUpdate = missingVisibleFlagChanged || toUpdate;
-toUpdate = HandleLockDeleteFlagUpdateL( aEntry ) || toUpdate;
+toUpdate = HandleRemovableVisibleFlagsUpdateL( aEntry ) || toUpdate;
 toUpdate = SetApaAppInfoL( aEntry ) || toUpdate;
 if( iInstalledPackages.Find( aEntry->GetUid() ) != KErrNotFound )
 {
 AddEntryToDownloadedCollectionL( aEntry->GetId() );
 toUpdate = HandleUsedFlagUpdate( aEntry ) || toUpdate;
 AddEntryToPredefinedCollectionL( aEntry, ETrue );
 }
 iCaStorageProxy.AddL( aEntry, EFalse, itemAppearanceChange );
 RemoveFromInstalledPackages( aEntry->GetUid() );
 }
 }
-// ---------------------------------------------------------
-//
+// ---------------------------------------------------------
-// ---------------------------------------------------------
+//
-//
-TBool CCaSrvAppScanner::HandleVisibleFlagUpdate( CCaInnerEntry* aItem )
-{
-TBool toChange( EFalse );
-if( !( aItem->GetFlags() & EVisible ) )
-{
-aItem->SetFlags( aItem->GetFlags() | EVisible );
-toChange = ETrue;
-}
-return toChange;
-}
-// ---------------------------------------------------------
-//
-// ---------------------------------------------------------
-//
-TBool CCaSrvAppScanner::HandleUsedFlagUpdate( CCaInnerEntry* aItem )
-{
-TBool changed( EFalse );
-if( aItem->GetFlags() & EUsed )
-{
-aItem->SetFlags( aItem->GetFlags() & ~EUsed );
-changed = ETrue;
-}
-return changed;
-}
-// ---------------------------------------------------------
-// CCaSrvAppScanner::HandleMmcAttrUpdateL
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::HandleMmcAttrUpdateL(
 CCaInnerEntry* aItem, TUint aMmcId )
 {
 TBool toUpdate( ETrue );
 if( IsInMmcL( TUid::Uid( aItem->GetUid() ) ) )
 {
 //app is instaled on mmc - KCaAttrMmcId attribute update
-TBuf<KUidChars> uidString;
+RBuf uidString;
+uidString.CleanupClosePushL();
+uidString.CreateL(KUidChars);
 uidString.Format( KHexFormat, aMmcId );
 aItem->AddAttributeL( KCaAttrMmcId, uidString );
+CleanupStack::PopAndDestroy( &uidString );
 }
 else if ( IsInMassStorageL( TUid::Uid( aItem->GetUid() ) ) )
 {
 //its app installed on mass storage, we need to leave it
 //in case of connecting usb in mass storage mode
 }
 return toUpdate;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::UpdateApplicationItemsL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::InstallationNotifyL()
 {
 for( TInt i = iInstalledPackages.Count() - 1; i >= 0; i-- )
 iInstalledPackages.Remove( i );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::UpdateApplicationItemsL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::UpdateApplicationEntriesL()
 {
 TUint currentMmcId = UpdateMmcHistoryL();
 CleanupResetAndDestroyPushL( resultArray );
 GetCaAppEntriesL( resultArray );
 HandleHsAppEntryL( resultArray );
 RemoveSatAppL( resultArray );
-RArray<TCaAppAtributes> apaItems;
+RArray<TUint> appUids;
-CleanupClosePushL( apaItems );
+CleanupClosePushL( appUids );
-GetApaItemsL( apaItems );
+GetApaItemsL( appUids );
-RemoveApp( apaItems, KSatUid.iUid );
+RemoveApp( appUids, KSatUid.iUid );
-RemoveApp( apaItems, KHsAppUid.iUid );
+RemoveApp( appUids, KHsAppUid.iUid );
 //for every item in apaAndCrItems array
-for( TInt i = 0; i < apaItems.Count(); i++ )
+for( TInt i = 0; i < appUids.Count(); i++ )
 {
 // if there was leave for any item we ignore it
 // and proceed to the next one
 TRAP_IGNORE(UpdateApplicationEntryL(
-resultArray, apaItems[i], currentMmcId));
+resultArray, appUids[i], currentMmcId));
 }
-// Here the big list cwith items that refer to missing apps.
+// Here the big list with items that refer to missing apps.
 HandleMissingItemsL( resultArray );
-CleanupStack::PopAndDestroy( &apaItems );
+CleanupStack::PopAndDestroy( &appUids );
 CleanupStack::PopAndDestroy( &resultArray );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleLockDeleteFlagUpdateL
+//
 // ---------------------------------------------------------
 //
-TBool CCaSrvAppScanner::HandleLockDeleteFlagUpdateL( CCaInnerEntry* aItem )
+TBool CCaSrvAppScanner::HandleRemovableVisibleFlagsUpdateL(
+CCaInnerEntry* aItem )
 {
 TBool toChange( EFalse );
-TBool isVisible = ( ( aItem->GetFlags() & EVisible ) != 0 );
+if( ( aItem->GetFlags() & EVisible ) && IsInRomL( aItem->GetUid() ) )
-if( isVisible && IsInRomL( aItem->GetUid() ) )
 {
 if( ( aItem->GetFlags() & ERemovable ) != 0 )
 {
 aItem->SetFlags( aItem->GetFlags() & ~ERemovable );
 toChange = ETrue;
 }
 return toChange;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleMissingFlagUpdateL
+//
 // ---------------------------------------------------------
 //
-TBool CCaSrvAppScanner::HandleMissingVisibleFlagsUpdate( CCaInnerEntry* aItem )
+TBool CCaSrvAppScanner::HandleMissingVisibleFlagsUpdate(
+CCaInnerEntry* aItem )
 {
 TBool ret( EFalse );
 if( aItem->GetFlags() & EMissing ||
 !( aItem->GetFlags() & EVisible ) )
 {
 }
 return ret;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RemoveApp
+//
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::RemoveApp( RArray<TCaAppAtributes>& aArray, TInt32 aUid )
+TBool CCaSrvAppScanner::HandleVisibleFlagUpdate( CCaInnerEntry* aItem )
 {
-TCaAppAtributes app( aUid );
+TBool toChange( EFalse );
-TInt id = aArray.Find( app, TCaAppAtributes::MatchItems );
+if( !( aItem->GetFlags() & EVisible ) )
+{
+aItem->SetFlags( aItem->GetFlags() | EVisible );
+toChange = ETrue;
+}
+return toChange;
+}
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CCaSrvAppScanner::HandleUsedFlagUpdate( CCaInnerEntry* aItem )
+{
+TBool changed( EFalse );
+if( aItem->GetFlags() & EUsed )
+{
+aItem->SetFlags( aItem->GetFlags() & ~EUsed );
+changed = ETrue;
+}
+return changed;
+}
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CCaSrvAppScanner::RemoveApp( RArray<TUint>& aArray, TInt32 aUid )
+{
+TInt id = aArray.Find( aUid );
 if( id != KErrNotFound )
 {
 aArray.Remove( id );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RemoveSatApp
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::RemoveSatAppL( RPointerArray<CCaInnerEntry>& aArray )
 {
 CCaInnerEntry* sat = CCaInnerEntry::NewL();
 }
 delete sat;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleHsAppEntryL
+//
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::HandleHsAppEntryL( RPointerArray<CCaInnerEntry>& aArray )
+void CCaSrvAppScanner::HandleHsAppEntryL(
+RPointerArray<CCaInnerEntry>& aArray )
 {
 CCaInnerEntry* appEntry = CCaInnerEntry::NewLC();
 appEntry->SetUid( KHsAppUid.iUid );
 TInt index = aArray.Find(
 appEntry, TIdentityRelation<CCaInnerEntry>( UidMatch ) );
 CleanupStack::PopAndDestroy( appEntry );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::GetApaItemsL
+//
 // ---------------------------------------------------------
 //
-void CCaSrvAppScanner::GetApaItemsL( RArray<TCaAppAtributes>& aArray )
+void CCaSrvAppScanner::GetApaItemsL( RArray<TUint>& aArray )
 {
-TApaAppInfo* appInfo = new(ELeave) TApaAppInfo();
+TApaAppInfo* appInfo = new ( ELeave ) TApaAppInfo();
 CleanupStack::PushL(appInfo);
 TApaAppCapabilityBuf appCap;
 User::LeaveIfError( iApaLsSession.GetAllApps( 0 ) );
 // for every application get uid, hidden and missing attribute
 User::LeaveIfError( iApaLsSession.GetAppCapability(
 appCap, appInfo->iUid ) );
 // "Hidden" status according to AppArc.
 if( !appCap().iAppIsHidden )
 {
-TCaAppAtributes appAtributes( appInfo->iUid.iUid );
+aArray.AppendL( appInfo->iUid.iUid );
-aArray.AppendL( appAtributes );
 }
 }
 CleanupStack::PopAndDestroy(appInfo);
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::GetMcsItemsL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::GetCaAppEntriesL(
 RPointerArray<CCaInnerEntry>& aArray )
 {
 CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();
-CDesC16ArrayFlat* appType = new ( ELeave ) CDesC16ArrayFlat( 1 );
+CDesC16ArrayFlat* appType =
+new ( ELeave ) CDesC16ArrayFlat( KGranularityOne );
 CleanupStack::PushL( appType );
 appType->AppendL( KCaTypeApp );
 allAppQuery->SetEntryTypeNames( appType );
 CleanupStack::Pop( appType );
 iCaStorageProxy.GetEntriesL( allAppQuery, aArray );
 CleanupStack::PopAndDestroy( allAppQuery );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::GetMcsItemsL
+//
 // ---------------------------------------------------------
 //
 TInt CCaSrvAppScanner::GetCollectionDownloadIdL()
 {
 if( iCollectionDownloadId == 0 )
 {
 RPointerArray<CCaInnerEntry> resultArray;
 CleanupResetAndDestroyPushL( resultArray );
 CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();
-CDesC16ArrayFlat* appType = new ( ELeave ) CDesC16ArrayFlat( 1 );
+CDesC16ArrayFlat* appType =
+new ( ELeave ) CDesC16ArrayFlat( KGranularityOne );
 CleanupStack::PushL( appType );
 appType->AppendL( KCaTypeCollectionDownload );
 allAppQuery->SetEntryTypeNames( appType );
 CleanupStack::Pop( appType );
 iCaStorageProxy.GetEntriesL( allAppQuery, resultArray );
 }
 return iCollectionDownloadId;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::GetAllCollectionIdL
+//
 // ---------------------------------------------------------
 //
 TInt CCaSrvAppScanner::GetAllCollectionIdL()
 {
 if( iAllCollectionId == 0 )
 {
 CCaInnerQuery *getAllCollectionIdQuery = CCaInnerQuery::NewLC();
 CDesC16ArrayFlat *typenameArray = new(ELeave) CDesC16ArrayFlat(
-KDefaultGranularity );
+KGranularityOne );
 CleanupStack::PushL( typenameArray );
 typenameArray->AppendL( KCaTypeMenuCollections );
 getAllCollectionIdQuery->SetEntryTypeNames( typenameArray );
 CleanupStack::Pop( typenameArray );
 }
 return iAllCollectionId;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::GetMcsItemsL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::GetCaAppEntriesL( TInt aUid,
 RPointerArray<CCaInnerEntry>& aArray )
 {
 iCaStorageProxy.GetEntriesL( allAppQuery, aArray );
 CleanupStack::PopAndDestroy( allAppQuery );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleAppListEvent
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::HandleAppListEvent( TInt /*aEvent*/)
 {
 // We only have one event, EAppListChanged.
 ScheduleScan();
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleInstallNotifyL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::HandleInstallNotifyL( TInt aUid )
 {
 NotifyL( aUid );
 RArray<TUid> uids;
 CleanupClosePushL( uids );
 Swi::RSisRegistrySession iSisRegSession;
+CleanupClosePushL( iSisRegSession );
 User::LeaveIfError( iSisRegSession.Connect() );
-CleanupClosePushL( iSisRegSession );
 // 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;
-CleanupClosePushL( 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 )
 {
 // There are no embaddes sis', so we can notify storage
 // of changes in apps included in packageEntry
 NotifyL( packageEntry );
 }
-embedded.ResetAndDestroy();
 CleanupStack::PopAndDestroy( &embedded );
 CleanupStack::PopAndDestroy( &packageEntry );
 }
 CleanupStack::PopAndDestroy( &iSisRegSession );
 CleanupStack::PopAndDestroy( &uids );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::NotifyL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::NotifyL( Swi::RSisRegistryEntry & aPackageEntry )
 {
 // Get sids ( == uids of exetucables included in aPackageEntry )
 }
 CleanupStack::PopAndDestroy( &sids );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::NotifyL
+//
 // ---------------------------------------------------------
 //
 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 );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::AddEntryToDownloadedCollectionL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::AddEntryToDownloadedCollectionL( TInt aEntryId )
 {
-TCaOperationParams params = { TCaOperationParams::EPrepend, GetCollectionDownloadIdL(), 0 // not used
+TCaOperationParams params;
-};
+params.iOperationType = TCaOperationParams::EPrepend;
+params.iGroupId = GetCollectionDownloadIdL();
+params.iBeforeEntryId = 0; // Not used.
 RArray<TInt> entryIds;
 CleanupClosePushL( entryIds );
 entryIds.AppendL( aEntryId );
 iCaStorageProxy.OrganizeL( entryIds, params );
 CleanupStack::PopAndDestroy( &entryIds );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::AddEntryToPredefinedCollectionL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::AddEntryToPredefinedCollectionL(
 CCaInnerEntry* aEntry, TBool aUpdate )
 {
 CleanupResetAndDestroyPushL( resultArrayItems );
 iCaStorageProxy.GetEntriesL( innerQuery, resultArrayItems );
 RArray<TInt> entryIds;
 CleanupClosePushL( entryIds );
-TInt entryId = aEntry->GetId();
+entryIds.AppendL( aEntry->GetId() );
-entryIds.AppendL( entryId );
 TCaOperationParams organizeParams;
 organizeParams.iBeforeEntryId = 0;
+organizeParams.iOperationType = TCaOperationParams::EAppend;
 if( resultArrayItems.Count() )
 {
 // collection with appgroup_name exist - add entry
 // to this collection
 // add new collection to all collection
 AddCollectionToAllCollectionL( predefinedCollectionId );
 if( aUpdate )
 {
-organizeParams.iOperationType = TCaOperationParams::EAppend;
 iCaStorageProxy.OrganizeL( entryIds, organizeParams );
 }
 }
 if( !aUpdate )
 {
-organizeParams.iOperationType = TCaOperationParams::EAppend;
 iCaStorageProxy.OrganizeL( entryIds, organizeParams );
 }
 CleanupStack::PopAndDestroy( &entryIds );
 CleanupStack::PopAndDestroy( &resultArrayItems );
 CleanupStack::PopAndDestroy( innerQuery );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::CreatePredefinedCollectionL
+//
 // ---------------------------------------------------------
 //
 TInt CCaSrvAppScanner::CreatePredefinedCollectionL( const TDesC& aGroupName )
 {
 CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
 innerEntry->SetTextL( aGroupName );
 innerEntry->SetEntryTypeNameL( KCaTypeCollection );
 innerEntry->SetRole( CCaInnerQuery::Group );
 innerEntry->AddAttributeL( KCaAppGroupName, aGroupName );
-innerEntry->SetFlags( EVisible );
+innerEntry->SetFlags( EVisible | ERemovable );
-innerEntry->SetFlags( innerEntry->GetFlags() | ERemovable );
-_LIT( KCollectionIconFileName, "qtg_large_applications_user");
 innerEntry->SetIconDataL( KCollectionIconFileName,
 KNullDesC, KNullDesC );
 iCaStorageProxy.AddL( innerEntry );
 // Get new collection Id
 TInt newCollectionId = innerEntry->GetId();
 return newCollectionId;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::AddCollectionToAllCollectionL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::AddCollectionToAllCollectionL( TInt aCollectionId )
 {
 RArray<TInt> entryIds;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RemoveToDownloadedCollectionL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::RemoveEntryFromDownloadedL( TInt aEntryId )
 {
-TCaOperationParams params = { TCaOperationParams::ERemove, GetCollectionDownloadIdL(), 0 // not used
+TCaOperationParams params;
-};
+params.iOperationType = TCaOperationParams::ERemove;
+params.iGroupId = GetCollectionDownloadIdL();
+params.iBeforeEntryId = 0; // Not Used
 RArray<TInt> entryIds;
 CleanupClosePushL( entryIds );
 entryIds.AppendL( aEntryId );
 iCaStorageProxy.OrganizeL( entryIds, params );
 CleanupStack::PopAndDestroy( &entryIds );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::ScheduleScan
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::ScheduleScan()
 {
 if( !IsActive() )
 User::RequestComplete( ownStatus, KErrNone );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::AddAppItemL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::AddAppEntryL( TUint aUid, TUint aCurrentMmcId )
 {
 // Now add the app entry.
 appEntry->SetUid( aUid );
 appEntry->SetFlags( EVisible );
 appEntry->SetRole( EItemEntryRole );
 SetApaAppInfoL( appEntry );
-HandleLockDeleteFlagUpdateL( appEntry );
+HandleRemovableVisibleFlagsUpdateL( appEntry );
 HandleMmcAttrUpdateL( appEntry, aCurrentMmcId );
 iCaStorageProxy.AddL( appEntry );
 AddEntryToPredefinedCollectionL( appEntry );
 if( iInstalledPackages.Find( aUid ) != KErrNotFound )
 {
 AddEntryToDownloadedCollectionL( appEntry->GetId() );
-}
+RemoveFromInstalledPackages( aUid );
-RemoveFromInstalledPackages( aUid );
+}
 CleanupStack::PopAndDestroy( appEntry );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RemoveFromInstalledPackages
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::RemoveFromInstalledPackages( TUint aUid )
 {
 TInt appIndex = iInstalledPackages.Find( aUid );
 iInstalledPackages.Remove( appIndex );
 }
 }
 // ---------------------------------------------------------------------------
-// CCaSrvAppScanner::IsMidletL
+//
-// Checks if given app is midlet by reading the apptype uid (2nd uid)
 // ---------------------------------------------------------------------------
 //
 TBool CCaSrvAppScanner::SetApaAppInfoL( CCaInnerEntry* aEntry )
 {
 TBool changed( EFalse );
-TApaAppInfo info;
+TApaAppInfo* info = new ( ELeave ) TApaAppInfo();
-if( KErrNone == iSrvEngUtils.GetAppInfo( *aEntry, info ) )
+CleanupStack::PushL(info);
+if( KErrNone == iSrvEngUtils.GetAppInfo( *aEntry, *info ) )
 {
 RBuf attrVal;
 attrVal.CleanupClosePushL();
 attrVal.CreateL( KCaMaxAttrValueLen );
 aEntry->FindAttribute( KCaAttrLongName, attrVal );
-if( attrVal.Compare( info.iCaption ) != KErrNone
+if( attrVal.Compare( info->iCaption ) != KErrNone
-|| aEntry->GetText().Compare( info.iCaption )
+|| aEntry->GetText().Compare( info->iCaption )
 != KErrNone )
 {
-aEntry->SetTextL( info.iCaption );
+aEntry->SetTextL( info->iCaption );
-aEntry->AddAttributeL( KCaAttrLongName, info.iCaption );
+aEntry->AddAttributeL( KCaAttrLongName, info->iCaption );
 changed = ETrue;
 }
+if ( UpdateComponentIdL( *info, *aEntry ) )
+{
+changed = ETrue;
+}
 CleanupStack::PopAndDestroy( &attrVal );
-// check if its java app and add attr for entrys
+// check if its java app and add attr for entries
 TUid appTypeUid;
-if( KErrNone == iApaLsSession.GetAppType( appTypeUid, info.iUid ) )
+if( KErrNone == iApaLsSession.GetAppType( appTypeUid, info->iUid ) )
 {
 if( appTypeUid == KMidletApplicationTypeUid )
 {
-aEntry->AddAttributeL( KCaAttrAppType, KCaAttrAppTypeValueJava );
+aEntry->AddAttributeL(
-aEntry->AddAttributeL( KCaAttrAppSettingsPlugin, KCaAttrJavaAppSettingsPluginValue );
+KCaAttrAppType,
+KCaAttrAppTypeValueJava );
+aEntry->AddAttributeL(
+KCaAttrAppSettingsPlugin,
+KCaAttrJavaAppSettingsPluginValue );
 }
 else if (appTypeUid == KCWRTApplicationTypeUid)
 {
-aEntry->AddAttributeL( KCaAttrAppType, KCaAttrAppTypeValueCWRT );
+aEntry->AddAttributeL(
-aEntry->AddAttributeL( KCaAttrAppWidgetUri, KCaAttrAppWidgetUriCWRTValue );
+KCaAttrAppType,
+KCaAttrAppTypeValueCWRT );
+aEntry->AddAttributeL(
+KCaAttrAppWidgetUri,
+KCaAttrAppWidgetUriCWRTValue );
 // web id should be taken from SCR when supported
 RWidgetRegistryClientSession wrtSession;
 CleanupClosePushL(wrtSession);
 User::LeaveIfError( wrtSession.Connect());
 TFileName bundleId;
-wrtSession.GetWidgetBundleId(info.iUid, bundleId);
+wrtSession.GetWidgetBundleId(info->iUid, bundleId);
-aEntry->AddAttributeL( KCaAttrAppWidgetParamWebAppId, bundleId );
+aEntry->AddAttributeL(
+KCaAttrAppWidgetParamWebAppId,
+bundleId );
 CleanupStack::PopAndDestroy(&wrtSession);
 }
 }
 }
+CleanupStack::PopAndDestroy( info );
 return changed;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::HandleMissingItemsL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::HandleMissingItemsL(
 RPointerArray<CCaInnerEntry>& aCaEntries )
 {
 for( TInt i = 0; i < aCaEntries.Count(); i++ )
 {
-const TInt id = aCaEntries[i]->GetId();
 RBuf attrVal;
 attrVal.CleanupClosePushL();
 attrVal.CreateL( KCaMaxAttrValueLen );
 if( aCaEntries[i]->FindAttribute( KCaAttrMmcId(), attrVal ) )
 {
 CleanupStack::PopAndDestroy( &attrVal );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::RemoveAppL
+//
 // ---------------------------------------------------------
 //
 void CCaSrvAppScanner::RemoveAppL( CCaInnerEntry* aAppEntry )
 {
 RArray<TInt> idsToRemove;
 //
 void CCaSrvAppScanner::ClearVisibleFlagL( CCaInnerEntry* aEntry )
 {
 if( aEntry->GetFlags() & EVisible )
 {
-aEntry->SetFlags( aEntry->GetFlags() & ~EVisible & ~EMissing & ~EUsed );
+aEntry->SetFlags(
+aEntry->GetFlags() &
+~EVisible &
+~EMissing &
+~EUsed );
 iCaStorageProxy.AddL( aEntry, EFalse, EItemDisappeared );
 }
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::UpdateMmcHistoryL
+//
 // ---------------------------------------------------------
 //
 TUint CCaSrvAppScanner::UpdateMmcHistoryL()
 {
 TUint mmcId = CurrentMmcId();
 }
 return mmcId;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::CurrentMmcId
+//
 // ---------------------------------------------------------
 //
 TUint CCaSrvAppScanner::CurrentMmcId() const
 {
 // Get mmc id. Errors are ignored.
 TUint mmcId = 0;
 TInt mmcDrive;
-TInt err;
+TInt err = DriveInfo::GetDefaultDrive(
-err = DriveInfo::GetDefaultDrive(
 DriveInfo::EDefaultRemovableMassStorage, mmcDrive );
 if( !err )
 {
 TVolumeInfo volumeInfo;
 err = iFs.Volume( volumeInfo, mmcDrive );
 }
 return mmcId;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsFileInDrive
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsFileInDrive(
 const TDesC& aFileName,
 const DriveInfo::TDefaultDrives& aDefaultDrive ) const
 {
-if ( aFileName.Length() )
+TBool retVal( EFalse );
-{
+if ( aFileName.Length()>0 )
-TInt mmcDrive;
+{
+TInt mmcDrive;
 TInt err = DriveInfo::GetDefaultDrive( aDefaultDrive, mmcDrive );
 if( !err )
 {
 TInt fileDrive;
 err = RFs::CharToDrive( aFileName[0], fileDrive );
 if( !err && fileDrive == mmcDrive )
 {
-return ETrue;
+retVal = ETrue;
 }
 }
 }
-return EFalse;
+return retVal;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsAppInDriveL
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsAppInDriveL(
 const TUid aUid,
 const DriveInfo::TDefaultDrives& aDefaultDrive ) const
 {
 TBool ret( EFalse );
-TApaAppInfo* appInfo = new( ELeave ) TApaAppInfo();
+TApaAppInfo* appInfo = new ( ELeave ) TApaAppInfo();
 TInt err = iApaLsSession.GetAppInfo( *appInfo, aUid );
 if( !err && IsFileInDrive( appInfo->iFullName, aDefaultDrive ) )
 {
 ret = ETrue;
 }
 delete appInfo;
 return ret;
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsInMmcL
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsInMmcL( const TUid aUid ) const
 {
 return IsAppInDriveL( aUid, DriveInfo::EDefaultRemovableMassStorage );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsInMassStorageL
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsInMassStorageL( const TUid aUid ) const
 {
 return IsAppInDriveL( aUid, DriveInfo::EDefaultMassStorage );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsInRomL
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsInRomL( TInt aUid )
 {
 return IsAppInDriveL( TUid::Uid( aUid ), DriveInfo::EDefaultRom );
 }
 // ---------------------------------------------------------
-// CCaSrvAppScanner::IsDriveInUse
+//
 // ---------------------------------------------------------
 //
 TBool CCaSrvAppScanner::IsDriveInUse(
 const DriveInfo::TDefaultDrives& aDefaultDrive )
 {
 }
 return inUse;
 }
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
 void CCaSrvAppScanner::MakeNotEmptyCollectionsVisibleL()
 {
 RPointerArray<CCaInnerEntry> resultArray;
 CleanupResetAndDestroyPushL( resultArray );
 CCaInnerQuery* hiddenCollectionsQuery = CCaInnerQuery::NewLC();
 }
 }
 CleanupStack::PopAndDestroy( &resultArray );
 }
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
 void CCaSrvAppScanner::MakeCollectionVisibleIfHasVisibleEntryL(
 CCaInnerEntry* aEntry )
 {
 RPointerArray<CCaInnerEntry> resultEntriesArray;
 CleanupResetAndDestroyPushL( resultEntriesArray );
 }
 CleanupStack::PopAndDestroy( visibleEntriesQuery );
 CleanupStack::PopAndDestroy( &resultEntriesArray );
 }
+// ---------------------------------------------------------
-// ==================== MEMBER FUNCTIONS ====================
+//
+// ---------------------------------------------------------//
-// ---------------------------------------------------------
+TBool CCaSrvAppScanner::UpdateComponentIdL( TApaAppInfo& appInfo,
-// TAppAtributes::TAppAtributes
+CCaInnerEntry& aEntry ) const
-// ---------------------------------------------------------
+{
-//
+TBool updated( EFalse );
-TCaAppAtributes::TCaAppAtributes( TUint aUid )
-{
+CComponentFilter* const fileNameFilter = CComponentFilter::NewLC();
-iUid = aUid;
-}
+fileNameFilter->SetFileL( appInfo.iFullName );
-// ---------------------------------------------------------
+RArray<TComponentId> componentIds;
-// TAppAtributes::GetUid
+CleanupClosePushL( componentIds );
-// ---------------------------------------------------------
+iSoftwareRegistry.GetComponentIdsL( componentIds, fileNameFilter );
-//
-TUint TCaAppAtributes::GetUid() const
+if ( componentIds.Count() == 0 )
 {
-return iUid;
+CComponentFilter* const uidFilter = CComponentFilter::NewLC();
-}
+uidFilter->AddPropertyL(_L("Uid"), aEntry.GetUid());
+iSoftwareRegistry.GetComponentIdsL( componentIds, uidFilter );
-// ---------------------------------------------------------
+CleanupStack::PopAndDestroy( uidFilter );
-// TAppAtributes::MatchItems
+}
-// ---------------------------------------------------------
-//
+if ( componentIds.Count() == 1 )
-TBool TCaAppAtributes::MatchItems( const TCaAppAtributes& item1,
+{
-const TCaAppAtributes& item2 )
+RBuf newComponentId;
-{
+newComponentId.CleanupClosePushL();
-return item1.GetUid() == item2.GetUid();
+newComponentId.CreateL( sizeof(TComponentId) + 1 );
-}
+newComponentId.AppendNum( componentIds[0] );
+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 );
+}
+CleanupStack::PopAndDestroy( &componentIds );
+CleanupStack::PopAndDestroy( fileNameFilter );
+return updated;
+}

changeset 94	dbb8300717f7
parent 93	82b66994846c
child 96	5d243a69bdda