menucontentsrv/srvsrc/menusrvappscanner.cpp
branchRCL_3
changeset 78 1b207dd38b72
parent 1 844b978f8d5e
child 82 ace62b58f4b2
equal deleted inserted replaced
74:edd621764147 78:1b207dd38b72
    25 #include "menulogger.h"
    25 #include "menulogger.h"
    26 #include "centralrepository.h"
    26 #include "centralrepository.h"
    27 #include "mcssathandler.h"
    27 #include "mcssathandler.h"
    28 #include "menusrvengutils.h"
    28 #include "menusrvengutils.h"
    29 #include "bautils.h"
    29 #include "bautils.h"
       
    30 #include "menuutil.h"
    30 
    31 
    31 _LIT( KMenuOne, "1" );
    32 _LIT( KMenuOne, "1" );
    32 _LIT( KMenuAttrMmcId, "mmc_id" );
    33 _LIT( KMenuAttrMmcId, "mmc_id" );
    33 _LIT( KMenuMassStorage, "mass_storage" );
    34 _LIT( KMenuMassStorage, "mass_storage" );
    34 _LIT( KMenuMmcHistoryFname, "mmchistory" );
    35 _LIT( KMenuMmcHistoryFname, "mmchistory" );
    35 _LIT( KZDrive, "Z" );
       
    36 
    36 
    37 // ==================== LOCAL FUNCTIONS ====================
    37 // ==================== LOCAL FUNCTIONS ====================
    38 
    38 
    39 /**
    39 /**
    40 * Identity function to search in an array of TMenuItems.
    40 * Identity function to search in an array of TMenuItems.
    52 
    52 
    53 // ---------------------------------------------------------
    53 // ---------------------------------------------------------
    54 // CMenuSrvAppScanner::NewL
    54 // CMenuSrvAppScanner::NewL
    55 // ---------------------------------------------------------
    55 // ---------------------------------------------------------
    56 //
    56 //
    57 CMenuSrvAppScanner* CMenuSrvAppScanner::NewL( CMenuEng& aEng )
    57 CMenuSrvAppScanner* CMenuSrvAppScanner::NewL(
    58     {
    58         CMenuEng& aEng, CMenuSrvEngUtils& aSrvEngUtils  )
    59     CMenuSrvAppScanner* scanner = new (ELeave) CMenuSrvAppScanner( aEng );
    59     {
       
    60     CMenuSrvAppScanner* scanner = new (ELeave) CMenuSrvAppScanner(
       
    61             aEng, aSrvEngUtils );
    60     CleanupStack::PushL( scanner );
    62     CleanupStack::PushL( scanner );
    61     scanner->ConstructL();
    63     scanner->ConstructL();
    62     CleanupStack::Pop( scanner );
    64     CleanupStack::Pop( scanner );
    63     return scanner;
    65     return scanner;
    64     }
    66     }
    68 // ---------------------------------------------------------
    70 // ---------------------------------------------------------
    69 //
    71 //
    70 CMenuSrvAppScanner::~CMenuSrvAppScanner()
    72 CMenuSrvAppScanner::~CMenuSrvAppScanner()
    71     {
    73     {
    72     Cancel();
    74     Cancel();
    73     iApaLsSession.Close();
       
    74     delete iMcsSatNotifier;
    75     delete iMcsSatNotifier;
    75     delete iNotifier;
    76     delete iNotifier;
    76     iEng.DequeueOperation( *this );
    77     iEng.DequeueOperation( *this );
    77     delete iMmcHistory;
    78     delete iMmcHistory;
    78     iFs.Close();
    79     iFs.Close();
    79 	iWidgetSession.Close();
       
    80 
    80 
    81     if( iCenRepNotifyHandlerHiddenApps )
    81     if( iCenRepNotifyHandlerHiddenApps )
    82         {
    82         {
    83         iCenRepNotifyHandlerHiddenApps->StopListening();
    83         iCenRepNotifyHandlerHiddenApps->StopListening();
    84         }
    84         }
   102 
   102 
   103 // ---------------------------------------------------------
   103 // ---------------------------------------------------------
   104 // CMenuSrvAppScanner::CMenuSrvAppScanner
   104 // CMenuSrvAppScanner::CMenuSrvAppScanner
   105 // ---------------------------------------------------------
   105 // ---------------------------------------------------------
   106 //
   106 //
   107 CMenuSrvAppScanner::CMenuSrvAppScanner( CMenuEng& aEng )
   107 CMenuSrvAppScanner::CMenuSrvAppScanner(
   108 : CActive( CActive::EPriorityStandard ), iEng( aEng )
   108         CMenuEng& aEng, CMenuSrvEngUtils& aSrvEngUtils )
       
   109 : CActive( CActive::EPriorityStandard ), iEng( aEng ),
       
   110   iSrvEngUtils( aSrvEngUtils )
   109     {
   111     {
   110     CActiveScheduler::Add( this );
   112     CActiveScheduler::Add( this );
   111     }
   113     }
   112 
   114 
   113 // ---------------------------------------------------------
   115 // ---------------------------------------------------------
   133     iMmcHistory = new (ELeave) CMenuSrvMmcHistory();
   135     iMmcHistory = new (ELeave) CMenuSrvMmcHistory();
   134     iMmcHistory->LoadL( iFs, KMenuMmcHistoryFname() );
   136     iMmcHistory->LoadL( iFs, KMenuMmcHistoryFname() );
   135     // The notifier has its own session to apparc, instead of taking
   137     // The notifier has its own session to apparc, instead of taking
   136     // it as argument... :(
   138     // it as argument... :(
   137     iNotifier = CApaAppListNotifier::NewL( this, CActive::EPriorityStandard );
   139     iNotifier = CApaAppListNotifier::NewL( this, CActive::EPriorityStandard );
   138     User::LeaveIfError( iApaLsSession.Connect() );
       
   139     User::LeaveIfError( iApaLsSession.GetAllApps() ); // This is async.
       
   140 	User::LeaveIfError( iWidgetSession.Connect() );
       
   141 
   140 
   142    	iCenRepSession = CRepository::NewL( KCRUidMenu );
   141    	iCenRepSession = CRepository::NewL( KCRUidMenu );
   143 
   142 
   144 	iCenRepNotifyHandlerHiddenApps = CCenRepNotifyHandler::NewL(
   143 	iCenRepNotifyHandlerHiddenApps = CCenRepNotifyHandler::NewL(
   145 	    *this, *iCenRepSession,
   144 	    *this, *iCenRepSession,
   159 	iMcsSatNotifier = CMcsSatNotifier::NewL(
   158 	iMcsSatNotifier = CMcsSatNotifier::NewL(
   160 	                this, KCRUidMenu, KMenuShowSatUI );
   159 	                this, KCRUidMenu, KMenuShowSatUI );
   161 
   160 
   162 	iFreeSpaceObserver = CMcsFreeSpaceObserver::NewL( *this );
   161 	iFreeSpaceObserver = CMcsFreeSpaceObserver::NewL( *this );
   163 
   162 
   164     iApaLsSession.RegisterListPopulationCompleteObserver( iStatus );
   163     //SetActive();
   165     SetActive();
   164 	ScheduleScan();
   166     iOpStatus = ETrue;
   165     //iOpStatus = ETrue;
   167     }
   166     }
   168 
   167 
   169 // ---------------------------------------------------------
   168 // ---------------------------------------------------------
   170 // CMenuSrvAppScanner::RunL
   169 // CMenuSrvAppScanner::RunL
   171 // ---------------------------------------------------------
   170 // ---------------------------------------------------------
   173 void CMenuSrvAppScanner::RunL()
   172 void CMenuSrvAppScanner::RunL()
   174     {
   173     {
   175     User::LeaveIfError( iStatus.Int() ); // Handle errors in RunL.
   174     User::LeaveIfError( iStatus.Int() ); // Handle errors in RunL.
   176     // AppArc app scan complete, we have the app list.
   175     // AppArc app scan complete, we have the app list.
   177     // Now queue this operation to be executed by the Engine.
   176     // Now queue this operation to be executed by the Engine.
   178     iEng.QueueOperationL( *this );
   177     if ( !MenuUtil::BackupInProgressL() )
       
   178         {
       
   179         iEng.QueueOperationL( *this );
       
   180         }
       
   181     else
       
   182         {
       
   183         iOpStatus = EFalse;
       
   184         }
   179     }
   185     }
   180 
   186 
   181 // ---------------------------------------------------------
   187 // ---------------------------------------------------------
   182 // CMenuSrvAppScanner::DoCancel
   188 // CMenuSrvAppScanner::DoCancel
   183 // ---------------------------------------------------------
   189 // ---------------------------------------------------------
   184 //
   190 //
   185 void CMenuSrvAppScanner::DoCancel()
   191 void CMenuSrvAppScanner::DoCancel()
   186     {
   192     {
   187     iApaLsSession.CancelListPopulationCompleteObserver();
       
   188     }
   193     }
   189 
   194 
   190 // ---------------------------------------------------------
   195 // ---------------------------------------------------------
   191 // CMenuSrvAppScanner::RunError
   196 // CMenuSrvAppScanner::RunError
   192 // ---------------------------------------------------------
   197 // ---------------------------------------------------------
   476 // ---------------------------------------------------------
   481 // ---------------------------------------------------------
   477 // CMenuSrvAppScanner::UpdateApplicationItemL
   482 // CMenuSrvAppScanner::UpdateApplicationItemL
   478 // ---------------------------------------------------------
   483 // ---------------------------------------------------------
   479 //
   484 //
   480 void CMenuSrvAppScanner::UpdateApplicationItemL(
   485 void CMenuSrvAppScanner::UpdateApplicationItemL(
   481 		RArray<TMenuItem>& aMcsItems, const TAppAtributes& aApaItem,
   486 		RArray<TMenuItem>& aMcsItems, const CMenuSrvAppAttributes& aApaItem,
   482 		TUint aMmcId, TBool isLegacy)
   487 		TUint aMmcId, TBool isLegacy)
   483     {
   488     {
   484     RArray<TMenuItem> mcsUidItems;
   489     RArray<TMenuItem> mcsUidItems;
   485     CleanupClosePushL( mcsUidItems );
   490     CleanupClosePushL( mcsUidItems );
   486     TInt appuid = aApaItem.GetUid();
   491     TUid appuid = aApaItem.GetUid();
   487     GetMcsAppItemsL( isLegacy, appuid, mcsUidItems );
   492     GetMcsAppItemsL( isLegacy, appuid.iUid, mcsUidItems );
   488     TBool isApaItemHidden( aApaItem.IsHidden() );
   493     TBool isApaItemHidden( aApaItem.IsHidden() );
   489 
   494 
   490     // This app is not in the menu, add it now.
   495     // This app is not in the menu, add it now.
   491     // We don't add hidden items, there are too many of them!
   496     // We don't add hidden items, there are too many of them!
   492     // do not display Menu app
   497     // do not display Menu app
   493     if ( !mcsUidItems.Count()
   498     if ( !mcsUidItems.Count()
   494     		&& !isApaItemHidden
   499     		&& !isApaItemHidden
   495     		&& appuid !=  KMmUid3.iUid  )
   500     		&& appuid !=  KMmUid3  )
   496         {
   501         {
   497         if( appuid == KSatUid.iUid )
   502         if( appuid == KSatUid )
   498             {
   503             {
   499             if( CMcsSatHandler::CheckVisibility() )
   504             if( CMcsSatHandler::CheckVisibility() )
   500              	{
   505              	{
   501               	AddAppItemL( appuid, aMmcId );
   506               	AddAppItemL( aApaItem, aMmcId );
   502                	}
   507                	}
   503             }
   508             }
   504         else
   509         else
   505           	{
   510           	{
   506           	AddAppItemL( appuid, aMmcId );
   511           	AddAppItemL( aApaItem, aMmcId );
   507             GetMcsAppItemsL( isLegacy, appuid, mcsUidItems );
   512             GetMcsAppItemsL( isLegacy, appuid.iUid, mcsUidItems );
   508            	}
   513            	}
   509         }//if
   514         }//if
   510 
   515 
   511     // if there are any items with legacy UID format
   516     // if there are any items with legacy UID format
   512     // update them to new uid format
   517     // update them to new uid format
   516         for (TInt j=0; j < mcsUidItems.Count(); j++)
   521         for (TInt j=0; j < mcsUidItems.Count(); j++)
   517      		{
   522      		{
   518        		CMenuEngObject& object =
   523        		CMenuEngObject& object =
   519       		                iEng.ModifiableObjectL( mcsUidItems[j].Id() );
   524       		                iEng.ModifiableObjectL( mcsUidItems[j].Id() );
   520             TBuf<KUidChars> uidString;
   525             TBuf<KUidChars> uidString;
   521             MenuSrvUtil::UidToStringL( appuid, uidString, EFalse, EHex );
   526             MenuSrvUtil::UidToStringL( appuid.iUid, uidString, EFalse, EHex );
   522        	    object.SetAttributeL( KMenuAttrUid(), uidString, EFalse );
   527        	    object.SetAttributeL( KMenuAttrUid(), uidString, EFalse );
   523        		}//for
   528        		}//for
   524         }//else if
   529         }//else if
   525     // "hidden", "missing" and "lock_delete"  flags update
   530     // "hidden", "missing" and "lock_delete"  flags update
   526     for ( TInt j = 0; j < mcsUidItems.Count(); j++ )
   531     for ( TInt j = 0; j < mcsUidItems.Count(); j++ )
   528         const TMenuItem& item = mcsUidItems[j];
   533         const TMenuItem& item = mcsUidItems[j];
   529 
   534 
   530         //we need to handle first run of appscanner,
   535         //we need to handle first run of appscanner,
   531         //there might be some incorrect data in content xml file
   536         //there might be some incorrect data in content xml file
   532         //if this will have impact on performance we may run this methods only at start up
   537         //if this will have impact on performance we may run this methods only at start up
   533        	HandleMmcAttrUpdateL( item, appuid, aMmcId );
   538        	HandleMmcAttrUpdateL( item, aApaItem, aMmcId );
   534 		HandleNativeAttrUpdateL( item, appuid );
   539 		HandleNativeAttrUpdateL( item, aApaItem );
   535 
   540 
   536         // "hidden" flag handling.
   541         // "hidden" flag handling.
   537         HandleHiddenFlagUpdateL( item, appuid, isApaItemHidden );
   542         HandleHiddenFlagUpdateL( item, aApaItem );
   538 
   543 
   539         // "missing" flag handling
   544         // "missing" flag handling
   540         HandleMissingFlagUpdateL( item );
   545         HandleMissingFlagUpdateL( item );
   541 
   546 
   542         //"lock_delete" flag handling
   547         //"lock_delete" flag handling
   543         HandleLockDeleteFlagUpdateL(item, appuid);
   548         HandleLockDeleteFlagUpdateL(item, aApaItem );
   544         // if item was just added to MCS  it is not present in aMcsItems
   549         // if item was just added to MCS  it is not present in aMcsItems
   545         // so we cannot remove it
   550         // so we cannot remove it
   546         TInt index = aMcsItems.Find( item, TIdentityRelation<TMenuItem>( IdMatch ) );
   551         TInt index = aMcsItems.Find( item, TIdentityRelation<TMenuItem>( IdMatch ) );
   547         if ( index != KErrNotFound )
   552         if ( index != KErrNotFound )
   548         	{
   553         	{
   555 // ---------------------------------------------------------
   560 // ---------------------------------------------------------
   556 // CMenuSrvAppScanner::HandleHiddenFlagUpdateL
   561 // CMenuSrvAppScanner::HandleHiddenFlagUpdateL
   557 // ---------------------------------------------------------
   562 // ---------------------------------------------------------
   558 //
   563 //
   559 void CMenuSrvAppScanner::HandleHiddenFlagUpdateL( const TMenuItem & aItem,
   564 void CMenuSrvAppScanner::HandleHiddenFlagUpdateL( const TMenuItem & aItem,
   560 		TInt & aAppUid, TBool aApaItemHidden )
   565         const CMenuSrvAppAttributes& aApaItem )
   561 	{
   566 	{
   562 	TBool itemHidden = (0 != (aItem.Flags() & TMenuItem::EHidden));
   567 	TBool itemHidden = (0 != (aItem.Flags() & TMenuItem::EHidden));
   563 	if (aAppUid == KSatUid.iUid)
   568 	if ( aApaItem.GetUid() == KSatUid )
   564 		{
   569 		{
   565 		if (itemHidden == CMcsSatHandler::CheckVisibility())
   570 		if (itemHidden == CMcsSatHandler::CheckVisibility())
   566 			{
   571 			{
   567 			iEng.ModifiableObjectL(aItem.Id(), RMenuNotifier::EItemsAddedRemoved).
   572 			iEng.ModifiableObjectL(aItem.Id(), RMenuNotifier::EItemsAddedRemoved).
   568 				SetFlags( TMenuItem::EHidden, !CMcsSatHandler::CheckVisibility());
   573 				SetFlags( TMenuItem::EHidden, !CMcsSatHandler::CheckVisibility());
   569 			}
   574 			}
   570 		}
   575 		}
   571 	else if (itemHidden != aApaItemHidden)
   576 	else if ( itemHidden != aApaItem.IsHidden() )
   572 		{
   577 		{
   573 		iEng.ModifiableObjectL(aItem.Id(), RMenuNotifier::EItemsAddedRemoved).
   578 		iEng.ModifiableObjectL(aItem.Id(), RMenuNotifier::EItemsAddedRemoved).
   574 			SetFlags( TMenuItem::EHidden, aApaItemHidden );
   579 			SetFlags( TMenuItem::EHidden, aApaItem.IsHidden() );
   575 		}
   580 		}
   576 	}
   581 	}
   577 
   582 
   578 // ---------------------------------------------------------
   583 // ---------------------------------------------------------
   579 // CMenuSrvAppScanner::HandleNativeAttrUpdateL
   584 // CMenuSrvAppScanner::HandleNativeAttrUpdateL
   580 // ---------------------------------------------------------
   585 // ---------------------------------------------------------
   581 //
   586 //
   582 void CMenuSrvAppScanner::HandleNativeAttrUpdateL(
   587 void CMenuSrvAppScanner::HandleNativeAttrUpdateL(
   583 		const TMenuItem& aItem, TInt aUid )
   588 		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
   584 	{
   589 	{
   585     //we need this to delete uninstalled java app item
   590     //we need this to delete uninstalled java app item
   586 	if( ( IsMidlet( TUid::Uid( aUid ) )
   591     if( aApaItem.GetAppType() != iEng.ObjectL( aItem.Id() ).GetAppType() )
   587 	        || iWidgetSession.IsWidget( TUid::Uid( aUid ) ) )
       
   588     		&& iEng.ObjectL( aItem.Id() ).GetNative() )
       
   589     	{
   592     	{
   590     	iEng.ModifiableObjectL( aItem.Id(),
   593     	iEng.ModifiableObjectL( aItem.Id(),
   591     			RMenuNotifier::EItemsNone ).SetNative( EFalse );
   594     			RMenuNotifier::EItemsNone ).SetAppType( aApaItem.GetAppType() );
   592     	}
   595     	}
   593 	}
   596 	}
   594 
   597 
   595 
   598 
   596 // ---------------------------------------------------------
   599 // ---------------------------------------------------------
   597 // CMenuSrvAppScanner::HandleMmcAttrUpdateL
   600 // CMenuSrvAppScanner::HandleMmcAttrUpdateL
   598 // ---------------------------------------------------------
   601 // ---------------------------------------------------------
   599 //
   602 //
   600 void CMenuSrvAppScanner::HandleMmcAttrUpdateL(
   603 void CMenuSrvAppScanner::HandleMmcAttrUpdateL(
   601 		const TMenuItem& aItem, TInt aUid, TUint aMmcId )
   604 		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem, TUint aMmcId )
   602 	{
   605 	{
   603     if ( IsMmcApp( TUid::Uid( aUid ) ) )
   606     if ( IsInMmc( aApaItem ) )
   604     	{
   607     	{
   605     	//app is instaled on mmc - KMenuAttrMmcId attribute update
   608     	//app is instaled on mmc - KMenuAttrMmcId attribute update
   606     	TBuf<KUidChars> uidString;
   609     	TBuf<KUidChars> uidString;
   607         uidString.Format( KHexFormat, aMmcId );
   610         uidString.Format( KHexFormat, aMmcId );
   608         iEng.ModifiableObjectL( aItem.Id(), RMenuNotifier::EItemsAddedRemoved ).
   611         iEng.ModifiableObjectL( aItem.Id(), RMenuNotifier::EItemsAddedRemoved ).
   609 			SetAttributeL( KMenuAttrMmcId, uidString, EFalse );
   612 			SetAttributeL( KMenuAttrMmcId, uidString, EFalse );
   610     	}
   613     	}
   611     else if ( IsMassStorageApp( TUid::Uid( aUid ) )
   614     else if ( IsInMassStorage( aApaItem )
   612     		&& IsMidlet( TUid::Uid( aUid ) ) )
   615     		&& aApaItem.GetAppType() == CMenuEngObject::EWidgetApp )
   613     	{
   616     	{
   614     	//its java app installed on mass storage, we need to leave it in xml
   617     	//its java app installed on mass storage, we need to leave it in xml
   615     	//in case of connecting usb in mass storage mode
   618     	//in case of connecting usb in mass storage mode
   616         iEng.ModifiableObjectL( aItem.Id(), RMenuNotifier::EItemsAddedRemoved ).
   619         iEng.ModifiableObjectL( aItem.Id(), RMenuNotifier::EItemsAddedRemoved ).
   617 			SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
   620 			SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
   632     TUint currentMmcId = UpdateMmcHistoryL();
   635     TUint currentMmcId = UpdateMmcHistoryL();
   633     // get all MCS items
   636     // get all MCS items
   634     RArray<TMenuItem> mcsItems;
   637     RArray<TMenuItem> mcsItems;
   635     CleanupClosePushL( mcsItems );
   638     CleanupClosePushL( mcsItems );
   636     GetMcsAppItemsL( mcsItems );
   639     GetMcsAppItemsL( mcsItems );
   637     RArray<TAppAtributes> apaAndCrItems;
   640     iSrvEngUtils.ReloadApaItemsL();
   638     CleanupClosePushL( apaAndCrItems );
   641     GetCrItemsL( iSrvEngUtils.GetAppItemsL() );
   639     GetApaItemsL( apaAndCrItems );
       
   640     GetCrItemsL( apaAndCrItems );
       
   641     TBool isLegacy = iEng.GetOnceLegacyFormat();
   642     TBool isLegacy = iEng.GetOnceLegacyFormat();
   642 
   643 
   643 
   644 
   644     //for every item in apaAndCrItems array
   645     //for every item in apaAndCrItems array
   645     for ( TInt i = ( apaAndCrItems.Count() - 1 ); i >= 0 ; i-- )
   646     for ( TInt i = ( iSrvEngUtils.GetAppItemsL().Count() - 1 ); i >= 0 ; i-- )
   646         {
   647         {
   647         // if there was leave for any item we ignore it
   648         // if there was leave for any item we ignore it
   648         // and proceed to the next one
   649         // and proceed to the next one
   649         TRAP_IGNORE(UpdateApplicationItemL(
   650         TRAP_IGNORE(UpdateApplicationItemL(
   650         		mcsItems, apaAndCrItems[i], currentMmcId, isLegacy));
   651         		mcsItems, *iSrvEngUtils.GetAppItemsL()[i], currentMmcId, isLegacy));
   651         }
   652         }
   652     // Here the big list contains menu items that refer to missing apps.
   653     // Here the big list contains menu items that refer to missing apps.
   653     HandleMissingItemsL( mcsItems );
   654     HandleMissingItemsL( mcsItems );
   654     CleanupStack::PopAndDestroy( &apaAndCrItems );
       
   655     CleanupStack::PopAndDestroy( &mcsItems );
   655     CleanupStack::PopAndDestroy( &mcsItems );
   656     }
   656     }
   657 
   657 
   658 // ---------------------------------------------------------
   658 // ---------------------------------------------------------
   659 // CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL
   659 // CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL
   660 // ---------------------------------------------------------
   660 // ---------------------------------------------------------
   661 //
   661 //
   662 void CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL(
   662 void CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL(
   663 		const TMenuItem& aItem, TInt aUid )
   663 		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
   664 	{
   664 	{
   665 	TBool isHidden = ( ( iEng.ObjectL( aItem.Id() )
   665 	TBool isHidden = ( ( iEng.ObjectL( aItem.Id() )
   666 							.Flags() & TMenuItem::EHidden ) != 0 );
   666 							.Flags() & TMenuItem::EHidden ) != 0 );
   667 	if ( !isHidden && IsInRomL( aUid ) )
   667 	if ( !isHidden && IsInRomL( aApaItem ) )
   668 		{
   668 		{
   669 		if ( ( aItem.Flags() & TMenuItem::ELockDelete ) == 0 )
   669 		if ( ( aItem.Flags() & TMenuItem::ELockDelete ) == 0 )
   670 			{
   670 			{
   671 			iEng.ModifiableObjectL(aItem.Id())
   671 			iEng.ModifiableObjectL(aItem.Id())
   672 					.SetFlags( TMenuItem::ELockDelete, ETrue );
   672 					.SetFlags( TMenuItem::ELockDelete, ETrue );
   696             SetFlags( TMenuItem::EMissing, EFalse );
   696             SetFlags( TMenuItem::EMissing, EFalse );
   697         }
   697         }
   698 	}
   698 	}
   699 
   699 
   700 // ---------------------------------------------------------
   700 // ---------------------------------------------------------
   701 // CMenuSrvAppScanner::IsInRomL
       
   702 // ---------------------------------------------------------
       
   703 //
       
   704 TBool CMenuSrvAppScanner::IsInRomL( TInt aUid )
       
   705     {
       
   706     TBool inROM = EFalse;
       
   707     TApaAppInfo appInfo;
       
   708     if( iApaLsSession.GetAppInfo( appInfo, TUid::Uid( aUid ) ) == KErrNone )
       
   709         {
       
   710         RBuf path;
       
   711         CleanupClosePushL( path );
       
   712         path.CreateL( appInfo.iFullName );
       
   713         path.Replace( 0, 1, KZDrive );
       
   714         if( BaflUtils::FileExists( iFs, path ) )
       
   715             {
       
   716             inROM = ETrue;
       
   717             }
       
   718         CleanupStack::PopAndDestroy( &path );
       
   719         }
       
   720     return inROM;
       
   721     }
       
   722 
       
   723 // ---------------------------------------------------------
       
   724 // CMenuSrvAppScanner::GetCrItemsL
   701 // CMenuSrvAppScanner::GetCrItemsL
   725 // ---------------------------------------------------------
   702 // ---------------------------------------------------------
   726 //
   703 //
   727 void CMenuSrvAppScanner::GetCrItemsL( RArray<TAppAtributes>& aArray )
   704 void CMenuSrvAppScanner::GetCrItemsL( RPointerArray<CMenuSrvAppAttributes>& aArray )
   728     {
   705     {
   729  	TBuf<KCenRepBufferSize> buf;
   706  	TBuf<KCenRepBufferSize> buf;
   730 	iCenRepSession->Get( KMenuHideCPApplication, buf );
   707 	iCenRepSession->Get( KMenuHideCPApplication, buf );
   731 	ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
   708 	ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
   732 	iCenRepSession->Get( KMenuHideApplication, buf );
   709 	iCenRepSession->Get( KMenuHideApplication, buf );
   736 // ---------------------------------------------------------
   713 // ---------------------------------------------------------
   737 // CMenuSrvAppScanner::ParseUidsL
   714 // CMenuSrvAppScanner::ParseUidsL
   738 // ---------------------------------------------------------
   715 // ---------------------------------------------------------
   739 //
   716 //
   740 void CMenuSrvAppScanner::ParseUidsL( const TDesC& aHiddenApplications,
   717 void CMenuSrvAppScanner::ParseUidsL( const TDesC& aHiddenApplications,
   741                                         RArray<TAppAtributes>& aArray )
   718                                         RPointerArray<CMenuSrvAppAttributes>& aArray )
   742     {
   719     {
   743     TLex input( aHiddenApplications );
   720     TLex input( aHiddenApplications );
   744     TLexMark startMark;
   721     TLexMark startMark;
   745     input.Mark( startMark );
   722     input.Mark( startMark );
   746     TBool notEmpty = EFalse;
   723     TBool notEmpty = EFalse;
   753             input.Mark( startMark );
   730             input.Mark( startMark );
   754             }
   731             }
   755         input.Inc();
   732         input.Inc();
   756         notEmpty = ETrue;
   733         notEmpty = ETrue;
   757         }
   734         }
   758         if ( notEmpty )
   735 	if ( notEmpty )
   759             {
   736 		{
   760             SetHidden(input.MarkedToken( startMark ), aArray);
   737 		SetHidden(input.MarkedToken( startMark ), aArray);
   761             }
   738 		}
   762 
   739 
   763 
   740 
   764     }
   741     }
   765 
   742 
   766 // ---------------------------------------------------------
   743 // ---------------------------------------------------------
   767 // CMenuSrvAppScanner::SetHidden
   744 // CMenuSrvAppScanner::SetHidden
   768 // ---------------------------------------------------------
   745 // ---------------------------------------------------------
   769 //
   746 //
   770 void CMenuSrvAppScanner::SetHidden( const TDesC& aHiddenAppUid,
   747 void CMenuSrvAppScanner::SetHidden(
   771                                             RArray<TAppAtributes>& aArray )
   748         const TDesC& aHiddenAppUid, RPointerArray<CMenuSrvAppAttributes>& aArray )
   772     {
   749     {
   773     TLex appUidDescriptor(aHiddenAppUid);
   750     TLex appUidDescriptor(aHiddenAppUid);
   774     TUint hiddenAppUid( 0 );
   751     TUint hiddenAppUid( 0 );
   775     appUidDescriptor.Val( hiddenAppUid, EHex );
   752     appUidDescriptor.Val( hiddenAppUid, EHex );
   776     if ( hiddenAppUid )
   753     if ( hiddenAppUid )
   777        {
   754         {
   778        //all applications in descriptor are hidden
   755         TApaAppCapabilityBuf capability;
   779        TAppAtributes appAtributes( hiddenAppUid,  ETrue );
   756         TApaAppInfo appInfo;
   780        TInt id = aArray.Find(appAtributes, TAppAtributes::MatchItems );
   757         appInfo.iUid = TUid::Uid( hiddenAppUid );
   781        if ( id != KErrNotFound )
   758         CMenuSrvAppAttributes* attribute = CMenuSrvAppAttributes::NewLC( capability, appInfo );
   782            {
   759         TInt index = aArray.Find( attribute,
   783            aArray[id].SetHidden( ETrue );
   760                 TIdentityRelation<CMenuSrvAppAttributes>( CMenuSrvAppAttributes::MatchItems ) );
   784            }
   761         if( index >= 0 && !aArray[index]->IsHidden() )
   785        }
   762             {
   786     }
   763             aArray[index]->SetHidden( ETrue );
   787 
   764             }
   788 // ---------------------------------------------------------
   765         CleanupStack::PopAndDestroy( attribute );
   789 // CMenuSrvAppScanner::GetApaItemsL
   766         }
   790 // ---------------------------------------------------------
   767     }
   791 //
   768 
   792 void CMenuSrvAppScanner::GetApaItemsL( RArray<TAppAtributes>& aArray )
       
   793     {
       
   794     TApaAppInfo appInfo;
       
   795     TApaAppCapabilityBuf appCap;
       
   796     TInt screenNumber;
       
   797 
       
   798     User::LeaveIfError( iApaLsSession.GetAllApps() );
       
   799     // for every application get uid, hidden and missing attribute
       
   800     // and add to aArray.
       
   801     while ( KErrNone == iApaLsSession.GetNextApp( appInfo ) )
       
   802         {
       
   803         User::LeaveIfError( iApaLsSession.GetAppCapability
       
   804             ( appCap, appInfo.iUid ) );
       
   805         User::LeaveIfError( iApaLsSession.GetDefaultScreenNumber
       
   806             ( screenNumber, appInfo.iUid ) );
       
   807         // "Hidden" status according to AppArc.
       
   808         TBool appHidden = appCap().iAppIsHidden || screenNumber != 0;
       
   809 
       
   810         TAppAtributes appAtributes( appInfo.iUid.iUid,  appHidden );
       
   811         aArray.AppendL( appAtributes );
       
   812         }
       
   813     }
       
   814 
   769 
   815 // ---------------------------------------------------------
   770 // ---------------------------------------------------------
   816 // CMenuSrvAppScanner::GetMcsItemsL
   771 // CMenuSrvAppScanner::GetMcsItemsL
   817 // ---------------------------------------------------------
   772 // ---------------------------------------------------------
   818 //
   773 //
   882 // -----------------------------------------------------------------------------
   837 // -----------------------------------------------------------------------------
   883 //
   838 //
   884 void CMenuSrvAppScanner::HandleNotifyString( TUint32 aKey,
   839 void CMenuSrvAppScanner::HandleNotifyString( TUint32 aKey,
   885         const TDesC16& /*aNewValue*/ )
   840         const TDesC16& /*aNewValue*/ )
   886     {
   841     {
   887     if((aKey ==KMenuHideApplication )||(aKey == KMenuHideCPApplication))
   842     if((aKey == KMenuHideApplication )||(aKey == KMenuHideCPApplication))
   888         {
   843         {
   889         if ( !IsActive() && !iOpStatus )
   844         if ( !IsActive() && !iOpStatus )
   890             {
   845             {
   891             iOpStatus = ETrue;
   846             iOpStatus = ETrue;
   892            TRequestStatus* ownStatus = &iStatus;
   847             TRequestStatus* ownStatus = &iStatus;
   893             *ownStatus = KRequestPending;
   848             *ownStatus = KRequestPending;
   894             SetActive();
   849             SetActive();
   895             User::RequestComplete( ownStatus, KErrNone );
   850             User::RequestComplete( ownStatus, KErrNone );
   896             }
   851             }
   897         }
   852         }
   924 
   879 
   925 // ---------------------------------------------------------
   880 // ---------------------------------------------------------
   926 // CMenuSrvAppScanner::CreateInstallFolderL
   881 // CMenuSrvAppScanner::CreateInstallFolderL
   927 // ---------------------------------------------------------
   882 // ---------------------------------------------------------
   928 //
   883 //
   929 TInt CMenuSrvAppScanner::CreateInstallFolderL( TUint aUid )
   884 TInt CMenuSrvAppScanner::CreateInstallFolderL( const CMenuSrvAppAttributes& aApaItem )
   930 	{
   885 	{
   931     // Find a folder for this app.
   886     // Find a folder for this app.
   932     TInt folder(0);
   887     TInt folder(0);
   933 
   888     if ( aApaItem.GetGroupName().Length() )
   934     TApaAppCapabilityBuf capability;
       
   935     User::LeaveIfError(iApaLsSession.GetAppCapability( capability, TUid::Uid( aUid )));
       
   936 
       
   937     if ( capability().iGroupName.Length() )
       
   938         {
   889         {
   939         // appgroup_name is defined for this app. Find or create folder.
   890         // appgroup_name is defined for this app. Find or create folder.
   940         AppGroupFolderL( capability().iGroupName, folder );
   891         AppGroupFolderL( aApaItem.GetGroupName(), folder );
   941         }
   892         }
   942     else
   893     else
   943         {
   894         {
   944         // No appgroup_name, use default folder, if any.
   895         // No appgroup_name, use default folder, if any.
   945         DefaultFolderL( folder );
   896         DefaultFolderL( folder );
   955 // ---------------------------------------------------------
   906 // ---------------------------------------------------------
   956 // CMenuSrvAppScanner::AddAppItemL
   907 // CMenuSrvAppScanner::AddAppItemL
   957 // ---------------------------------------------------------
   908 // ---------------------------------------------------------
   958 //
   909 //
   959 void CMenuSrvAppScanner::AddAppItemL(
   910 void CMenuSrvAppScanner::AddAppItemL(
   960         TUint aUid,
   911         const CMenuSrvAppAttributes& aApaItem,
   961         TUint aCurrentMmcId )
   912         TUint aCurrentMmcId )
   962     {
   913     {
   963     TInt folder = CreateInstallFolderL( aUid );
   914     TInt folder = CreateInstallFolderL( aApaItem );
   964     // Now add the app item.
   915     // Now add the app item.
   965     CMenuEngObject* object = iEng.NewObjectL( KMenuTypeApp() );
   916     CMenuEngObject* object = iEng.NewObjectL( KMenuTypeApp() );
   966     CleanupStack::PushL( object );
   917     CleanupStack::PushL( object );
   967     TBuf<KUidChars> uidString;
   918     TBuf<KUidChars> uidString;
   968     _LIT(KHexFormat, "0x%X");
   919     _LIT(KHexFormat, "0x%X");
   969     uidString.Format( KHexFormat, aUid );
   920     uidString.Format( KHexFormat, aApaItem.GetUid().iUid );
   970 
   921 
   971     object->SetAttributeL( KMenuAttrUid(), uidString, EFalse );
   922     object->SetAttributeL( KMenuAttrUid(), uidString, EFalse );
   972     if ( aCurrentMmcId && IsMmcApp( TUid::Uid( aUid ) ) )
   923     if ( aCurrentMmcId && IsInMmc( aApaItem ) )
   973         {
   924         {
   974         // This app is on the MMC, set the "mmc_id" attribute.
   925         // This app is on the MMC, set the "mmc_id" attribute.
   975         uidString.Format( KHexFormat, aCurrentMmcId );
   926         uidString.Format( KHexFormat, aCurrentMmcId );
   976         object->SetAttributeL( KMenuAttrMmcId, uidString, EFalse );
   927         object->SetAttributeL( KMenuAttrMmcId, uidString, EFalse );
   977         }
   928         }
   978     if( IsMidlet( TUid::Uid( aUid ) ) 
   929     if( aApaItem.GetAppType() == CMenuEngObject::EWidgetApp )
   979 	    || iWidgetSession.IsWidget( TUid::Uid( aUid ) ) )
       
   980     	{
   930     	{
   981     	//we need this to delete uninstalled java or wrt widget app item
   931     	//we need this to delete uninstalled java or wrt widget app item
   982     	object->SetNative( EFalse );
   932     	if ( !IsInMmc( aApaItem )
   983     	if ( !IsMmcApp( TUid::Uid( aUid ) )
   933     			&& IsInMassStorage( aApaItem ) )
   984     			&& IsMassStorageApp( TUid::Uid( aUid ) ) )
       
   985     		{
   934     		{
   986     		object->SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
   935     		object->SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
   987     		}
   936     		}
   988     	}
   937     	}
       
   938     object->SetAppType( aApaItem.GetAppType() );
   989     EnsureFolderWritableL( folder );
   939     EnsureFolderWritableL( folder );
   990     iEng.AddL( *object, folder, 0 );
   940     iEng.AddL( *object, folder, 0 );
   991     CleanupStack::Pop( object );
   941     CleanupStack::Pop( object );
   992     }
   942     }
   993 
       
   994 // ---------------------------------------------------------------------------
       
   995 // CMenuSrvAppScanner::IsMidletL
       
   996 // Checks if given app is midlet by reading the apptype uid (2nd uid)
       
   997 // ---------------------------------------------------------------------------
       
   998 //
       
   999 TBool CMenuSrvAppScanner::IsMidlet( const TUid aAppUid )
       
  1000 	{
       
  1001     const TUid KMidletType = { 0x10210E26 };
       
  1002     TUid typeuid = KNullUid;
       
  1003 
       
  1004     if ( KErrNone == iApaLsSession.GetAppType( typeuid, aAppUid  ) )
       
  1005         {
       
  1006         if ( typeuid == KMidletType )
       
  1007             {
       
  1008             return ETrue;
       
  1009             }
       
  1010         }
       
  1011     return EFalse;
       
  1012 	}
       
  1013 
       
  1014 
   943 
  1015 // ---------------------------------------------------------
   944 // ---------------------------------------------------------
  1016 // CMenuSrvAppScanner::AppGroupFolderL
   945 // CMenuSrvAppScanner::AppGroupFolderL
  1017 // ---------------------------------------------------------
   946 // ---------------------------------------------------------
  1018 //
   947 //
  1140             {
  1069             {
  1141             // This item is not on MMC or its MMC has been purged from the MMC
  1070             // This item is not on MMC or its MMC has been purged from the MMC
  1142             // history. Hide the item.
  1071             // history. Hide the item.
  1143             SetObjectFlagsL( EFalse, aItems[i], TMenuItem::ELockDelete );
  1072             SetObjectFlagsL( EFalse, aItems[i], TMenuItem::ELockDelete );
  1144 
  1073 
  1145 			if( iEng.ObjectL( id ).GetNative() )
  1074 			if( iEng.ObjectL( id ).GetAppType() != CMenuEngObject::EWidgetApp )
  1146             	{
  1075             	{
  1147             	SetObjectFlagsL( ETrue, aItems[i], TMenuItem::EHidden,
  1076             	SetObjectFlagsL( ETrue, aItems[i], TMenuItem::EHidden,
  1148 						RMenuNotifier::EItemsAddedRemoved );
  1077 						RMenuNotifier::EItemsAddedRemoved );
  1149             	}
  1078             	}
  1150             else
  1079             else
  1233             }
  1162             }
  1234         }
  1163         }
  1235     return EFalse;
  1164     return EFalse;
  1236     }
  1165     }
  1237 
  1166 
  1238 
       
  1239 // ---------------------------------------------------------
  1167 // ---------------------------------------------------------
  1240 // CMenuSrvAppScanner::IsAppInDrive
  1168 // CMenuSrvAppScanner::IsAppInDrive
  1241 // ---------------------------------------------------------
  1169 // ---------------------------------------------------------
  1242 //
  1170 //
  1243 TBool CMenuSrvAppScanner::IsAppInDrive(
  1171 TBool CMenuSrvAppScanner::IsAppInDrive(
  1244 		const TUid aUid,
  1172         const CMenuSrvAppAttributes& aApaItem,
  1245 		const DriveInfo::TDefaultDrives& aDefaultDrive ) const
  1173 		const DriveInfo::TDefaultDrives& aDefaultDrive ) const
  1246     {
  1174     {
  1247     TBool ret( EFalse );
  1175     TBool ret( EFalse );
  1248     TApaAppInfo info;
  1176     if ( IsFileInDrive( aApaItem.GetFullName(), aDefaultDrive ) )
  1249     TInt err = iApaLsSession.GetAppInfo( info, aUid );
       
  1250     if ( !err && IsFileInDrive( info.iFullName, aDefaultDrive ) )
       
  1251     	{
  1177     	{
  1252     	ret = ETrue;
  1178     	ret = ETrue;
  1253     	}
  1179     	}
  1254     return ret;
  1180     return ret;
  1255     }
  1181     }
  1256 
  1182 
  1257 // ---------------------------------------------------------
  1183 // ---------------------------------------------------------
  1258 // CMenuSrvAppScanner::IsMmcApp
  1184 // CMenuSrvAppScanner::IsInMmc
  1259 // ---------------------------------------------------------
  1185 // ---------------------------------------------------------
  1260 //
  1186 //
  1261 TBool CMenuSrvAppScanner::IsMmcApp( const TUid aUid ) const
  1187 TBool CMenuSrvAppScanner::IsInMmc( const CMenuSrvAppAttributes& aApaItem ) const
  1262     {
  1188     {
  1263     return IsAppInDrive( aUid, DriveInfo::EDefaultRemovableMassStorage );
  1189     return IsAppInDrive( aApaItem, DriveInfo::EDefaultRemovableMassStorage );
  1264     }
  1190     }
  1265 
  1191 
  1266 // ---------------------------------------------------------
  1192 // ---------------------------------------------------------
  1267 // CMenuSrvAppScanner::IsMassStorageApp
  1193 // CMenuSrvAppScanner::IsInMassStorage
  1268 // ---------------------------------------------------------
  1194 // ---------------------------------------------------------
  1269 //
  1195 //
  1270 TBool CMenuSrvAppScanner::IsMassStorageApp( const TUid aUid ) const
  1196 TBool CMenuSrvAppScanner::IsInMassStorage( const CMenuSrvAppAttributes& aApaItem ) const
  1271     {
  1197     {
  1272     return IsAppInDrive( aUid, DriveInfo::EDefaultMassStorage );
  1198     return IsAppInDrive( aApaItem, DriveInfo::EDefaultMassStorage );
       
  1199     }
       
  1200 
       
  1201 // ---------------------------------------------------------
       
  1202 // CMenuSrvAppScanner::IsInRomL
       
  1203 // ---------------------------------------------------------
       
  1204 //
       
  1205 TBool CMenuSrvAppScanner::IsInRomL( const CMenuSrvAppAttributes& aApaItem ) const
       
  1206     {
       
  1207     return IsAppInDrive( aApaItem, DriveInfo::EDefaultRom );
  1273     }
  1208     }
  1274 
  1209 
  1275 // ---------------------------------------------------------
  1210 // ---------------------------------------------------------
  1276 // CMenuSrvAppScanner::IsDriveInUse
  1211 // CMenuSrvAppScanner::IsDriveInUse
  1277 // ---------------------------------------------------------
  1212 // ---------------------------------------------------------
  1295 		}
  1230 		}
  1296 
  1231 
  1297 	return inUse;
  1232 	return inUse;
  1298     }
  1233     }
  1299 
  1234 
  1300 // ==================== MEMBER FUNCTIONS ====================
       
  1301 
       
  1302 // ---------------------------------------------------------
       
  1303 // TAppAtributes::TAppAtributes
       
  1304 // ---------------------------------------------------------
       
  1305 //
       
  1306 TAppAtributes::TAppAtributes ( TUint aUid, TBool aHidden/*, TBool aMissing*/)
       
  1307     {
       
  1308     iUid = aUid;
       
  1309     iHidden = aHidden;
       
  1310     /*iMissing = aMissing;*/
       
  1311     }
       
  1312 
       
  1313 // ---------------------------------------------------------
       
  1314 // TAppAtributes::GetUid
       
  1315 // ---------------------------------------------------------
       
  1316 //
       
  1317 TUint TAppAtributes::GetUid() const
       
  1318     {
       
  1319     return iUid;
       
  1320     }
       
  1321 
       
  1322 // ---------------------------------------------------------
       
  1323 // TAppAtributes::IsHidden
       
  1324 // ---------------------------------------------------------
       
  1325 //
       
  1326 TBool TAppAtributes::IsHidden() const
       
  1327     {
       
  1328     return iHidden;
       
  1329     }
       
  1330 // ---------------------------------------------------------
       
  1331 // TAppAtributes::SetHidden
       
  1332 // ---------------------------------------------------------
       
  1333 //
       
  1334 void TAppAtributes::SetHidden( TBool aHidden )
       
  1335     {
       
  1336     iHidden = aHidden;
       
  1337     }
       
  1338 
       
  1339 // ---------------------------------------------------------
       
  1340 // TAppAtributes::MatchItems
       
  1341 // ---------------------------------------------------------
       
  1342 //
       
  1343 TBool TAppAtributes::MatchItems(const TAppAtributes& item1,
       
  1344                                         const TAppAtributes& item2)
       
  1345     {
       
  1346     TBool result( EFalse );
       
  1347     TUint uid1(item1.GetUid());
       
  1348     TUint uid2(item2.GetUid());
       
  1349     if ( uid1 == uid2 )
       
  1350         {
       
  1351         result = ETrue;
       
  1352         }
       
  1353     return result;
       
  1354     }
       
  1355 
       
  1356 
       
  1357 
       
  1358 //  End of File
  1235 //  End of File