FCL/sf/mw/homescreensrv: comparison menucontentsrv/srvsrc/menusrvappscanner.cpp

equal deleted inserted replaced

-:8baec10861af
+:6cadd6867c17
 if( iCenRepNotifyHandlerCPHiddenFolders )
 {
 iCenRepNotifyHandlerCPHiddenFolders->StopListening();
 }
 delete iCenRepNotifyHandlerCPHiddenFolders;
-	delete iCenRepSession;
+delete iCenRepSession;
-	delete iFreeSpaceObserver;
+delete iFreeSpaceObserver;
 iInstalledPackages.Close();
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::CMenuSrvAppScanner
 User::LeaveIfError( iFs.Connect() );
 TFileName path;
 User::LeaveIfError( iFs.PrivatePath( path ) );
 TUint attribute;
 if( iFs.Att( path, attribute) == KErrNotFound )
-	{
+{
 TInt mdRes = iFs.MkDirAll( path );
 if ( mdRes != KErrNone )
-	{
+{
-	User::Leave( mdRes );
+User::Leave( mdRes );
-	}
+}
-	}
+}
 iMmcHistory = new (ELeave) CMenuSrvMmcHistory();
 iMmcHistory->LoadL( iFs, KMenuMmcHistoryFname() );
 // The notifier has its own session to apparc, instead of taking
 // it as argument... :(
 iNotifier = CApaAppListNotifier::NewL( this, CActive::EPriorityStandard );
-	iCenRepSession = CRepository::NewL( KCRUidMenu );
+iCenRepSession = CRepository::NewL( KCRUidMenu );
-	iCenRepNotifyHandlerHiddenApps = CCenRepNotifyHandler::NewL(
+iCenRepNotifyHandlerHiddenApps = CCenRepNotifyHandler::NewL(
-	    *this, *iCenRepSession,
+*this, *iCenRepSession,
-		CCenRepNotifyHandler::EStringKey, KMenuHideApplication );
+CCenRepNotifyHandler::EStringKey, KMenuHideApplication );
-	iCenRepNotifyHandlerCPHiddenApps = CCenRepNotifyHandler::NewL(
+iCenRepNotifyHandlerCPHiddenApps = CCenRepNotifyHandler::NewL(
-	    *this, *iCenRepSession,
+*this, *iCenRepSession,
-		CCenRepNotifyHandler::EStringKey, KMenuHideCPApplication );
+CCenRepNotifyHandler::EStringKey, KMenuHideCPApplication );
-	iCenRepNotifyHandlerCPHiddenFolders = CCenRepNotifyHandler::NewL(
+iCenRepNotifyHandlerCPHiddenFolders = CCenRepNotifyHandler::NewL(
-	    *this, *iCenRepSession,
+*this, *iCenRepSession,
-		CCenRepNotifyHandler::EStringKey, KMenuHideCPFolder );
+CCenRepNotifyHandler::EStringKey, KMenuHideCPFolder );
-	iCenRepNotifyHandlerHiddenApps->StartListeningL();
+iCenRepNotifyHandlerHiddenApps->StartListeningL();
-	iCenRepNotifyHandlerCPHiddenApps->StartListeningL();
+iCenRepNotifyHandlerCPHiddenApps->StartListeningL();
-	iCenRepNotifyHandlerCPHiddenFolders->StartListeningL();
+iCenRepNotifyHandlerCPHiddenFolders->StartListeningL();
-	iMcsSatNotifier = CMcsSatNotifier::NewL(
+iMcsSatNotifier = CMcsSatNotifier::NewL(
-	                this, KCRUidMenu, KMenuShowSatUI );
+this, KCRUidMenu, KMenuShowSatUI );
-	iFreeSpaceObserver = CMcsFreeSpaceObserver::NewL( *this );
+iFreeSpaceObserver = CMcsFreeSpaceObserver::NewL( *this );
-	iSisInstallNotifier = CMcsInstallNotifier::NewL(
+iSisInstallNotifier = CMcsInstallNotifier::NewL(
 *this, CMcsInstallNotifier::ESisInstallNotification );
-	iJavaInstallNotifier = CMcsInstallNotifier::NewL(
+iJavaInstallNotifier = CMcsInstallNotifier::NewL(
 *this, CMcsInstallNotifier::EJavaInstallNotification );
-	ScheduleScan();
+ScheduleScan();
 //iOpStatus = ETrue;
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::RunL
 iEng.GetItemsL( appItems, aFolder, &uidAppFilter, ETrue );
 for( TInt i=0; i < appItems.Count(); i++ )
 {
 if( appItems[i].Type() != KMenuTypeLink() )
-	{
+{
 const TMenuItem& item = appItems[i];
 TBool itemHidden = (0 != ( item.Flags() & TMenuItem::EHidden ) );
 TBool itemMissing = ( 0 != ( item.Flags() & TMenuItem::EMissing ) );
 if ( !itemHidden && !itemMissing )
 {
 hideItem = ETrue;
 }
-	}
+}
 }
 SetHiddenFlagL( aId, aWasHidden, hideItem );
 CleanupStack::PopAndDestroy( &appItems );
 }
 TBool exists = EFalse;
 TBool itemMissing = EFalse;
 for (TInt i=0; i < appItems.Count(); i++)
 {
 if(appItems[i].Id() != aId)
-	{
+{
 exists = ETrue;
 const TMenuItem& item = appItems[i];
 TBool itemHidden = (0 != (item.Flags() & TMenuItem::EHidden));
 itemMissing = (0 != (item.Flags() & TMenuItem::EMissing));
 if ( !itemHidden && !itemMissing )
 {
 showItem = ETrue;
 }
-	}
+}
 }
 UpdateLinkL( aId, exists, showItem, itemMissing );
 CleanupStack::PopAndDestroy( &appItems );
 // ---------------------------------------------------------
 //
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleInstallNotifyL( TUid aUid,
-		CMcsInstallNotifier::TNotificationType aNotificationType )
+CMcsInstallNotifier::TNotificationType aNotificationType )
 {
 iInstalledPackages.AppendL( aUid );
 // when installing java, appscanner first gets notification from appArc,
 // and then it is notified with instal notifier(RProperty)
 // so we need another scan for java apps
 if( aNotificationType == CMcsInstallNotifier::EJavaInstallNotification )
-	{
+{
-		ScheduleScan();
+ScheduleScan();
-	}
+}
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::RunMenuEngOperationL
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::UpdateApplicationItemL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::UpdateApplicationItemL(
-		RArray<TMenuItem>& aMcsItems, const CMenuSrvAppAttributes& aApaItem,
+RArray<TMenuItem>& aMcsItems, const CMenuSrvAppAttributes& aApaItem,
-		TUint aMmcId, TBool isLegacy)
+TUint aMmcId, TBool isLegacy)
 {
 RArray<TMenuItem> mcsUidItems;
 CleanupClosePushL( mcsUidItems );
 TUid appUid = aApaItem.GetUid();
 GetMcsAppItemsL( isLegacy, appUid.iUid, mcsUidItems );
 // This app is not in the menu, add it now.
 // We don't add hidden items, there are too many of them!
 // do not display Menu app
 if ( !mcsUidItems.Count()
-		&& !isApaItemHidden
+&& !isApaItemHidden
-		&& appUid !=  KMmUid3  )
+&& appUid !=  KMmUid3  )
 {
 if( appUid == KSatUid )
 {
 if( CMcsSatHandler::CheckVisibility() )
-	{
+{
-	AddAppItemL( aApaItem, aMmcId );
+AddAppItemL( aApaItem, aMmcId );
-	}
+}
 }
 else
-	{
+{
-	AddAppItemL( aApaItem, aMmcId );
+AddAppItemL( aApaItem, aMmcId );
 GetMcsAppItemsL( isLegacy, appUid.iUid, mcsUidItems );
 RemoveFromInstalledPackages( appUid );
-	}
+}
 }//if
 // if there are any items with legacy UID format
 // update them to new uid format
 else if ( mcsUidItems.Count() && isLegacy )
 {
 //for every item with matching UID
 for (TInt j=0; j < mcsUidItems.Count(); j++)
-		{
+{
 TBuf<KUidChars> uidString;
 MenuSrvUtil::UidToStringL( appUid.iUid, uidString, EFalse, EHex );
 ModifiableObjectL( appUid, mcsUidItems[j].Id() ).SetAttributeL(
 KMenuAttrUid(), uidString, EFalse );
-		}//for
+}//for
 }//else if
 // "hidden", "missing" and "lock_delete"  flags update
 for ( TInt j = 0; j < mcsUidItems.Count(); j++ )
 {
 const TMenuItem& item = mcsUidItems[j];
 //we need to handle first run of appscanner,
 //there might be some incorrect data in content xml file
 //if this will have impact on performance we may run this methods only at start up
-	HandleMmcAttrUpdateL( item, aApaItem, aMmcId );
+HandleMmcAttrUpdateL( item, aApaItem, aMmcId );
-		HandleNativeAttrUpdateL( item, aApaItem );
+HandleNativeAttrUpdateL( item, aApaItem );
 // "hidden" flag handling.
 HandleHiddenFlagUpdateL( item, aApaItem );
 // "missing" flag handling
 HandleLockDeleteFlagUpdateL( item, aApaItem );
 // if item was just added to MCS  it is not present in aMcsItems
 // so we cannot remove it
 TInt index = aMcsItems.Find( item, TIdentityRelation<TMenuItem>( IdMatch ) );
 if ( index != KErrNotFound )
-	{
+{
-	aMcsItems.Remove( index );
+aMcsItems.Remove( index );
-	}
+}
 }//for
 CleanupStack::PopAndDestroy( &mcsUidItems );
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::HandleHiddenFlagUpdateL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleHiddenFlagUpdateL( const TMenuItem & aItem,
 const CMenuSrvAppAttributes& aApaItem )
-	{
+{
-	TBool itemHidden = ( 0 != ( aItem.Flags() & TMenuItem::EHidden ) );
+TBool itemHidden = ( 0 != ( aItem.Flags() & TMenuItem::EHidden ) );
-	if( aApaItem.GetUid() == KSatUid )
+if( aApaItem.GetUid() == KSatUid )
-		{
+{
-		if( itemHidden == CMcsSatHandler::CheckVisibility() )
+if( itemHidden == CMcsSatHandler::CheckVisibility() )
-			{
+{
-			ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
+ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
-			        RMenuNotifier::EItemsAddedRemoved ).SetFlags(
+RMenuNotifier::EItemsAddedRemoved ).SetFlags(
-			                TMenuItem::EHidden,
+TMenuItem::EHidden,
-			                !CMcsSatHandler::CheckVisibility() );
+!CMcsSatHandler::CheckVisibility() );
-			}
+}
-		}
+}
-	else if( itemHidden != aApaItem.IsHidden() )
+else if( itemHidden != aApaItem.IsHidden() )
-		{
+{
-		ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
+ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
-		        RMenuNotifier::EItemsAddedRemoved ).SetFlags(
+RMenuNotifier::EItemsAddedRemoved ).SetFlags(
-		                TMenuItem::EHidden, aApaItem.IsHidden() );
+TMenuItem::EHidden, aApaItem.IsHidden() );
-		}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::HandleNativeAttrUpdateL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleNativeAttrUpdateL(
-		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
+const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
-	{
+{
 //we need this to delete uninstalled java app item
 if( aApaItem.GetAppType() != iEng.ObjectL( aItem.Id() ).GetAppType() )
-	{
+{
-	ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
+ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
-			RMenuNotifier::EItemsNone ).SetAppType( aApaItem.GetAppType() );
+RMenuNotifier::EItemsNone ).SetAppType( aApaItem.GetAppType() );
-	}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::HandleMmcAttrUpdateL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleMmcAttrUpdateL(
-		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem, TUint aMmcId )
+const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem, TUint aMmcId )
-	{
+{
 TPtrC val;
 TBool dummy;
 TBool attributeExists = iEng.ObjectL( aItem.Id() ).FindAttribute(
 KMenuAttrMmcId(), val, dummy );
 if( IsInMmc( aApaItem ) )
-	{
+{
-	//app is instaled on mmc - KMenuAttrMmcId attribute update
+//app is instaled on mmc - KMenuAttrMmcId attribute update
-	TBuf<KUidChars> uidString;
+TBuf<KUidChars> uidString;
 uidString.Format( KHexFormat, aMmcId );
 if( uidString.Compare( val ) )
 {
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id() ).SetAttributeL(
 KMenuAttrMmcId, uidString, EFalse );
 }
-	}
+}
 else if( IsInMassStorage( aApaItem )
-		&& aApaItem.GetAppType() == CMenuEngObject::EWidgetApp )
+&& aApaItem.GetAppType() == CMenuEngObject::EWidgetApp )
-	{
+{
-	//its java app installed on mass storage, we need to leave it in xml
+//its java app installed on mass storage, we need to leave it in xml
-	//in case of connecting usb in mass storage mode
+//in case of connecting usb in mass storage mode
 if( KMenuMassStorage().Compare( val ) )
 {
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id() ).SetAttributeL(
 KMenuAttrMmcId, KMenuMassStorage, EFalse );
 }
-	}
+}
 else if( attributeExists )
-	{
+{
-	//its installed on c: drive - remove attribute
+//its installed on c: drive - remove attribute
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id() ).RemoveAttribute(
 KMenuAttrMmcId );
-	}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::UpdateApplicationItemsL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::UpdateApplicationItemsL()
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleLockDeleteFlagUpdateL(
-		const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
+const TMenuItem& aItem, const CMenuSrvAppAttributes& aApaItem )
-	{
+{
-	TBool isHidden = ( ( iEng.ObjectL( aItem.Id() )
+TBool isHidden = ( ( iEng.ObjectL( aItem.Id() )
-							.Flags() & TMenuItem::EHidden ) != 0 );
+.Flags() & TMenuItem::EHidden ) != 0 );
-	if ( !isHidden && IsInRomL( aApaItem ) )
+if ( !isHidden && IsInRomL( aApaItem ) )
-		{
+{
-		if ( ( aItem.Flags() & TMenuItem::ELockDelete ) == 0 )
+if ( ( aItem.Flags() & TMenuItem::ELockDelete ) == 0 )
-			{
+{
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id()).SetFlags(
 TMenuItem::ELockDelete, ETrue );
-			}
+}
-		}
+}
-	else
+else
-		{
+{
-		if ( ( aItem.Flags() & TMenuItem::ELockDelete ) != 0 )
+if ( ( aItem.Flags() & TMenuItem::ELockDelete ) != 0 )
-			{
+{
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id() ).SetFlags(
 TMenuItem::ELockDelete, EFalse );
-			}
+}
-		}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::HandleMissingFlagUpdateL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::HandleMissingFlagUpdateL(
 const TMenuItem& aItem,  const CMenuSrvAppAttributes& aApaItem  )
-	{
+{
-	if ( aItem.Flags() & TMenuItem::EMissing )
+if ( aItem.Flags() & TMenuItem::EMissing )
 {
 CLOG_WRITE_FORMAT8( "Unsetting flag EMissing on %d", item.Id() );
 //application found so we unset "missing" flag
 ModifiableObjectL( aApaItem.GetUid(), aItem.Id(),
 RMenuNotifier::EItemsAddedRemoved ).SetFlags(
 TMenuItem::EMissing, EFalse );
 }
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::GetCrItemsL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::GetCrItemsL( RPointerArray<CMenuSrvAppAttributes>& aArray )
 {
-	TBuf<KCenRepBufferSize> buf;
+TBuf<KCenRepBufferSize> buf;
-	iCenRepSession->Get( KMenuHideCPApplication, buf );
+iCenRepSession->Get( KMenuHideCPApplication, buf );
-	ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
+ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
-	iCenRepSession->Get( KMenuHideApplication, buf );
+iCenRepSession->Get( KMenuHideApplication, buf );
-	ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
+ParseUidsL( buf, aArray );// parses UIDs from buf and appends them to array
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::ParseUidsL
 // ---------------------------------------------------------
 TBool notEmpty = EFalse;
 while ( !input.Eos() )
 {
 if( input.Peek() == ',')
 {
-SetHidden(input.MarkedToken( startMark ), aArray);
+SetHiddenL(input.MarkedToken( startMark ), aArray);
 input.Inc();
 input.Mark( startMark );
 }
 input.Inc();
 notEmpty = ETrue;
 }
-	if ( notEmpty )
+if ( notEmpty )
-		{
+{
-		SetHidden(input.MarkedToken( startMark ), aArray);
+SetHiddenL( input.MarkedToken( startMark ), aArray );
-		}
+}
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::SetHidden
 // ---------------------------------------------------------
 //
-void CMenuSrvAppScanner::SetHidden(
+void CMenuSrvAppScanner::SetHiddenL(
 const TDesC& aHiddenAppUid, RPointerArray<CMenuSrvAppAttributes>& aArray )
 {
 TLex appUidDescriptor(aHiddenAppUid);
 TUint hiddenAppUid( 0 );
 appUidDescriptor.Val( hiddenAppUid, EHex );
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::ScheduleScan
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::ScheduleScan()
-	{
+{
-	if ( !IsActive() && !iOpStatus )
+if ( !IsActive() && !iOpStatus )
-		{
+{
-		iOpStatus = ETrue;
+iOpStatus = ETrue;
-		TRequestStatus* ownStatus = &iStatus;
+TRequestStatus* ownStatus = &iStatus;
-		*ownStatus = KRequestPending;
+*ownStatus = KRequestPending;
-		SetActive();
+SetActive();
-		User::RequestComplete( ownStatus, KErrNone );
+User::RequestComplete( ownStatus, KErrNone );
-		}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::CreateInstallFolderL
 // ---------------------------------------------------------
 //
 TInt CMenuSrvAppScanner::CreateInstallFolderL( const CMenuSrvAppAttributes& aApaItem )
-	{
+{
 // Find a folder for this app.
 TInt folder(0);
 if ( aApaItem.GetGroupName().Length() )
 {
 // appgroup_name is defined for this app. Find or create folder.
 {
 // Last resort: it goes to the root.
 iEng.RootFolderL( folder );
 }
 return folder;
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::AddAppItemL
 // ---------------------------------------------------------
 //
 // This app is on the MMC, set the "mmc_id" attribute.
 uidString.Format( KHexFormat, aCurrentMmcId );
 object->SetAttributeL( KMenuAttrMmcId, uidString, EFalse );
 }
 if( aApaItem.GetAppType() == CMenuEngObject::EWidgetApp )
-	{
+{
-	//we need this to delete uninstalled java or wrt widget app item
+//we need this to delete uninstalled java or wrt widget app item
-	if ( !IsInMmc( aApaItem )
+if ( !IsInMmc( aApaItem )
-			&& IsInMassStorage( aApaItem ) )
+&& IsInMassStorage( aApaItem ) )
-		{
+{
-		object->SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
+object->SetAttributeL( KMenuAttrMmcId, KMenuMassStorage, EFalse );
-		}
+}
-	}
+}
 object->SetAppType( aApaItem.GetAppType() );
 EnsureFolderWritableL( folder );
 iEng.AddL( *object, folder, 0 );
 CleanupStack::Pop( object );
 }
 const CMenuEngObject& rootObject = iEng.ObjectL( defaultFolderId );
 TPtrC groupName;
 TBool localized;
 if ( rootObject.FindAttribute( KMenuAttrAppGroupName, groupName, localized ) &&
-	groupName.Compare( aAppGroupName )==0 )
+groupName.Compare( aAppGroupName )==0 )
 {
 folder = defaultFolderId;
 }
 else
-	{
+{
 TMenuSrvTypeAttrFilter filter;
 filter.SetType( KMenuTypeFolder() );
 filter.SetAttr( KMenuAttrAppGroupName(), aAppGroupName );
 RArray<TMenuItem> items;
 CleanupClosePushL( items );
 if ( items.Count() )
 {
 folder = items[0].Id();
 }
 CleanupStack::PopAndDestroy( &items );
-	}
+}
 if ( !folder )
 {
 // No such folder, create it now.
 CMenuEngObject* object = iEng.NewObjectL( KMenuTypeFolder() );
 CleanupStack::PushL( object );
 }
 }
 else if( iEng.ObjectL( aItem.Id() ).GetAppType()
 != CMenuEngObject::EWidgetApp
 || iEng.ObjectL( aItem.Id() ).FindAttribute(
-		KMenuAttrPredefined(), val, dummy ) )
+KMenuAttrPredefined(), val, dummy ) )
 {
 flags = TMenuItem::EHidden;
 }
 return flags;
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::SetObjectFlagsL
 // ---------------------------------------------------------
 //
 void CMenuSrvAppScanner::SetObjectFlagsL( TBool aFlagValue, const TMenuItem& aItem,
-		const TMenuItem::TFlags& aFlag, const RMenuNotifier::TEvent& aEvent  )
+const TMenuItem::TFlags& aFlag, const RMenuNotifier::TEvent& aEvent  )
-	{
+{
-	TBool itemFlagPresent = (0 != (aItem.Flags() & aFlag));
+TBool itemFlagPresent = (0 != (aItem.Flags() & aFlag));
-	if( aFlagValue != itemFlagPresent )
+if( aFlagValue != itemFlagPresent )
-		{
+{
 iEng.ModifiableObjectL( aItem.Id(), aEvent ).
 SetFlags( aFlag, aFlagValue );
-		}
+}
-	}
+}
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::UpdateMmcHistoryL
 // ---------------------------------------------------------
 //
 TUint CMenuSrvAppScanner::UpdateMmcHistoryL()
 {
 TUint mmcId = CurrentMmcId();
 if( mmcId )
-	{
+{
-	iMmcHistory->InsertL( mmcId );
+iMmcHistory->InsertL( mmcId );
-	iMmcHistory->SaveL( iFs, KMenuMmcHistoryFname() );
+iMmcHistory->SaveL( iFs, KMenuMmcHistoryFname() );
-	}
+}
 return mmcId;
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::CurrentMmcId
 // Get mmc id. Errors are ignored.
 TUint mmcId = 0;
 TInt mmcDrive;
 TInt err;
 err = DriveInfo::GetDefaultDrive(
-	    DriveInfo::EDefaultRemovableMassStorage, mmcDrive );
+DriveInfo::EDefaultRemovableMassStorage, mmcDrive );
 if ( !err )
 {
 TVolumeInfo volumeInfo;
 err = iFs.Volume( volumeInfo, mmcDrive );
 if( !err )
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::IsFileInDrive
 // ---------------------------------------------------------
 //
 TBool CMenuSrvAppScanner::IsFileInDrive(
-			const TDesC& aFileName,
+const TDesC& aFileName,
-			const DriveInfo::TDefaultDrives& aDefaultDrive ) const
+const DriveInfo::TDefaultDrives& aDefaultDrive ) const
 {
 if ( aFileName.Length() )
 {
 TInt mmcDrive;
 TInt err = DriveInfo::GetDefaultDrive(
-						aDefaultDrive, mmcDrive );
+aDefaultDrive, mmcDrive );
 if ( !err )
 {
 TInt fileDrive;
 err = RFs::CharToDrive( aFileName[0], fileDrive );
 if ( !err && fileDrive == mmcDrive )
 // CMenuSrvAppScanner::IsAppInDrive
 // ---------------------------------------------------------
 //
 TBool CMenuSrvAppScanner::IsAppInDrive(
 const CMenuSrvAppAttributes& aApaItem,
-		const DriveInfo::TDefaultDrives& aDefaultDrive ) const
+const DriveInfo::TDefaultDrives& aDefaultDrive ) const
 {
 TBool ret( EFalse );
 if ( IsFileInDrive( aApaItem.GetFullName(), aDefaultDrive ) )
-	{
+{
-	ret = ETrue;
+ret = ETrue;
-	}
+}
 return ret;
 }
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::IsInMmc
 // ---------------------------------------------------------
 // CMenuSrvAppScanner::IsDriveInUse
 // ---------------------------------------------------------
 //
 TBool CMenuSrvAppScanner::IsDriveInUse(
-		const DriveInfo::TDefaultDrives& aDefaultDrive )
+const DriveInfo::TDefaultDrives& aDefaultDrive )
 {
 TBool inUse( EFalse );
 TInt drive;
 TInt err = DriveInfo::GetDefaultDrive( aDefaultDrive, drive );
 if( err == KErrNone )
-		{
+{
-		TUint status;
+TUint status;
-		err =  DriveInfo::GetDriveStatus(  iFs, drive, status );
+err =  DriveInfo::GetDriveStatus(  iFs, drive, status );
-		if( err == KErrNone
+if( err == KErrNone
-				&& ( status & DriveInfo::EDriveInUse ) )
+&& ( status & DriveInfo::EDriveInUse ) )
-			{
+{
-			inUse = ETrue;
+inUse = ETrue;
-			}
+}
-		}
+}
-	return inUse;
+return inUse;
 }
 //  End of File

branch	RCL_3
changeset 122	6cadd6867c17
parent 118	8baec10861af
child 130	67f2ed48ad91