/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <mcsdef.h>
#include "mcsmenuitem.h"
#include "mcsrunningappshandler.h"
#include "mcsrunningappswgmonitor.h"
#include "mcsrunningappsfswmonitor.h"
#include "mcsrunningappshiddenattrscanner.h"
#include "mcsrunningappsaddremovehandler.h"
#include "mcsmenunotifier.h"
#include "mcscachehandler.h"


// ---------------------------------------------------------
// CMcsRunningAppsHandler::NewL
// ---------------------------------------------------------
//
CMcsRunningAppsHandler* CMcsRunningAppsHandler::NewL(
    CMenuEng& aEng, CMcsCacheHandler& aCacheHandler )
	{
	CMcsRunningAppsHandler* self;
	self = new ( ELeave ) CMcsRunningAppsHandler( aEng, aCacheHandler );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::~CMcsRunningAppsHandler
// ---------------------------------------------------------
//
CMcsRunningAppsHandler::~CMcsRunningAppsHandler()
    {
    delete iWindowGroupMonitor;
    delete iFswMonitor;
    delete iHiddenAttrScanner;
    delete iAddRemoveHandler;
    iRunningApps.Close();
    iRunningFolderStatus.Close();
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::CMcsRunningAppsHandler
// ---------------------------------------------------------
//
CMcsRunningAppsHandler::CMcsRunningAppsHandler(
	CMenuEng& aEng, CMcsCacheHandler& aCacheHandler ):
	iEng(aEng), 
	iCacheHandler(aCacheHandler)
    {
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::ConstructL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::ConstructL()
	{
	//iFswMonitor and iHiddenAttrScanner must be initialized before
	//iWindowGroupMonitor, because they update lists which are used by
	//iWindowGroupMonitor
	iFswMonitor = CMcsRunningAppsFswMonitor::NewL( iEng, this );
    iHiddenAttrScanner = CMcsRunningAppsHiddenAttrScanner::NewL( iEng, this );
    iWindowGroupMonitor = CMcsRunningAppsWgMonitor::NewL( iEng, this );
    iAddRemoveHandler = CMcsRunningAppsAddRemoveHandler::NewL( iEng, this );
    UpdateFoldersRunningStatusL();
    
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::EngineEventsL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::EngineEventsL( TInt aFolder, TInt aEvents )
	{
    if ( aEvents & RMenuNotifier::EItemsAddedRemoved )
        {
        iAddRemoveHandler->HandleAddRemoveL( aFolder );
        iHiddenAttrScanner->ScanL();
        }    
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::EngineEvents
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::EngineEvents( TInt aFolder, TInt aEvents )
	{
	TRAP_IGNORE( EngineEventsL( aFolder, aEvents ) );      
	}


// ---------------------------------------------------------
// CMcsRunningAppsHandler::EngineEvents
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::GetRunningAppsL( RArray<TUid>& aArray )
	{
	for ( TInt i = 0; i< iRunningApps.Count(); i++ )
		{
		if ( iRunningApps[i].IsRunning() &&
				!iRunningApps[i].IsHidden() &&
				!iRunningApps[i].IsFswHidden() )
			{
			aArray.AppendL( iRunningApps[i].GetUid() );
			}
		}
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleListUpdateL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleListUpdateL(const RArray<TUid>& aArray, 
		TArrayDataType aType )
	{
	switch ( aType )
		{
		case ERunningApps:
			HandleRunningAppsChangedL( aArray );
			break;
		case EFswHiddenApps:
			HandleFswHiddenAppsChangedL( aArray );
			break;
		case EHiddenApps:
			HandleHiddenAppsChangedL( aArray );
			break;
		}
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleRunningAppsChangedL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleRunningAppsChangedL(
		const RArray<TUid>& aArray )
	{
	TInt count = iRunningApps.Count();
	//add new items to iRunningApps
	for ( TInt i = 0; i < aArray.Count(); i++ )
		{
		TRunningAppsAttr item( aArray[i] );
		TInt id = iRunningApps.Find( item, TRunningAppsAttr::MatchByUid );
		if (KErrNotFound == id)
			{
			item.SetRunning( ETrue );
			item.SetFswHidden( iFswMonitor->IsFswHidden( aArray[i] ) );
			item.SetHidden( iHiddenAttrScanner->IsHidden( aArray[i] ) );
			iRunningApps.AppendL( item );
			if ( !item.IsFswHidden() && !item.IsHidden() )
				{
				HandleNotificationL( aArray[i] );
				}
			}
		}
	//set proper running attribute value in iRunningApps 
	//(only for applications that were previously in Array)
	for ( TInt i = 0; i< count; i++ )
		{
		TUid appUid ( iRunningApps[i].GetUid() );
		
		TInt id = aArray.Find( appUid );
		if ( ( KErrNotFound == id ) && ( iRunningApps[i].IsRunning() ) )
			{
			iRunningApps[i].SetRunning( EFalse );
			if ( !iRunningApps[i].IsFswHidden() && 
					!iRunningApps[i].IsHidden() )
				{
				HandleNotificationL( appUid );
				}
			}
		else if ( ( KErrNotFound != id ) && ( !iRunningApps[i].IsRunning() ) )
			{
			iRunningApps[i].SetRunning( ETrue );
			if ( !iRunningApps[i].IsFswHidden() && 
					!iRunningApps[i].IsHidden() )
				{
				HandleNotificationL( appUid );
				}
			}
		}
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleFswHiddenAppsChangedL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleFswHiddenAppsChangedL(
		const RArray<TUid>& aArray )
	{
	//set proper FSW hidden value in iRunningApps 
	for ( TInt i = 0; i< iRunningApps.Count(); i++ )
		{
		TUid appUid ( iRunningApps[i].GetUid() );
		TInt id = aArray.Find( appUid );
		if ( ( KErrNotFound == id ) && ( iRunningApps[i].IsFswHidden() ) )
			{
			iRunningApps[i].SetFswHidden( EFalse );
			if ( iRunningApps[i].IsRunning() && 
					!iRunningApps[i].IsHidden() )
				{
				HandleNotificationL( appUid );
				}
			}
		else if ( ( KErrNotFound != id ) && ( !iRunningApps[i].IsFswHidden() ) )
			{
			iRunningApps[i].SetFswHidden( ETrue );
			if ( iRunningApps[i].IsRunning() && 
					!iRunningApps[i].IsHidden() )
				{
				HandleNotificationL( appUid );
				}
			}
		}	
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleHiddenAppsChangedL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleHiddenAppsChangedL(
		const RArray<TUid>& aArray )
	{
	//set proper hidden value in iRunningApps 
	for ( TInt i = 0; i< iRunningApps.Count(); i++ )
		{
		TUid appUid ( iRunningApps[i].GetUid() );
		TInt id = aArray.Find( appUid );
		if ( ( KErrNotFound == id ) && ( iRunningApps[i].IsHidden() ) )
			{
			iRunningApps[i].SetHidden( EFalse );
			if ( iRunningApps[i].IsRunning() && 
					!iRunningApps[i].IsFswHidden() )
				{
				HandleNotificationL( appUid );
				}
			}
		else if ( ( KErrNotFound != id ) && ( !iRunningApps[i].IsHidden() ) )
			{
			iRunningApps[i].SetHidden( ETrue );
			if ( iRunningApps[i].IsRunning() && 
					!iRunningApps[i].IsFswHidden() )
				{
				HandleNotificationL( appUid );
				}			
			}
		}		
	}



// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleNotificationL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleNotificationL( TInt aId )
	{
    TInt root;
    iEng.RootFolderL( root ); 	
	TInt parentId(0);                
	if ( aId != KErrNotFound )
		{
		//remove running status from cache (for application)
		iCacheHandler.HandleRemoveAttribute( aId, KRunningStatus );
		TBool oldStatus;
		TBool newStatus;
	    while( aId != root )
	    	{
	        iEng.ParentFolderL( aId, parentId );
	        iEng.AppendNotifyL(parentId, 
	        		RMenuNotifier::EItemAttributeChanged);
	        
	        oldStatus = GetFolderPreviousRunningStatusL( parentId );
	        newStatus = GetFolderRunningStatusL( parentId );
	        if( oldStatus != newStatus )
				{
				iCacheHandler.HandleRemoveAttribute( 
						parentId, KRunningStatus );
				UpdateFolderRunningStatusL( parentId, newStatus );
				aId = parentId;
				}
	        else
	        	{
	        	break;
	        	}
	    	}//while
		}//if
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleNotificationL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleNotificationL( TUid aAppUid )
	{
	RArray<TMenuItem> itemArray;
	CleanupClosePushL( itemArray );
	//list of all items representing specified uid 
	TInt error = GetItemsListL( aAppUid, itemArray );
	if( error == KErrNone )
		{
		TInt count = itemArray.Count();
		for( TInt i = 0; i < count; i++ )
			{
			HandleNotificationL( itemArray[i].Id() );
			}
		}
    CleanupStack::PopAndDestroy( &itemArray );
	}


// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetItemsListL
// ---------------------------------------------------------
//

TInt CMcsRunningAppsHandler::GetItemsListL( TUid aAppUid, RArray<TMenuItem>& aItemArray )
    {
    TInt result(KErrNotFound);
    TInt root;
    iEng.RootFolderL( root );
    TMenuSrvTypeAttrFilter appFilter;
    appFilter.SetType( KMenuTypeApp() );
    TBuf<KUidChars> uidString;
    TInt appuid( aAppUid.iUid );
    MenuSrvUtil::UidToStringL( appuid, uidString, EFalse, EHex );
    appFilter.SetAttr( KMenuAttrUid(), uidString );
    iEng.GetItemsL( aItemArray, root, &appFilter, ETrue );
    //if not found in mcs try with UID in decimal format
    if (!aItemArray.Count())
        {
        MenuSrvUtil::UidToStringL( appuid, uidString, EFalse, EDecimal );
        appFilter.SetAttr( KMenuAttrUid(), uidString );
        iEng.GetItemsL( aItemArray, root, &appFilter, ETrue );
        }
   if ( aItemArray.Count() )
        {
        result = KErrNone;
        }
    return result;
    }    


// ---------------------------------------------------------
// CMcsRunningAppsHandler::UpdateFolderRunningStatusL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::UpdateFolderRunningStatusL( TInt aFolderId, 
		TBool aNewRunningStatus )
    {
    TInt id = iRunningFolderStatus.Find( aFolderId );
    if ( aNewRunningStatus && ( id == KErrNotFound ))
    	{
    	iRunningFolderStatus.AppendL( aFolderId );
    	}
    if ( !aNewRunningStatus && ( id != KErrNotFound ))
    	{
    	iRunningFolderStatus.Remove( id );
    	}
    }


// ---------------------------------------------------------
// CMcsRunningAppsHandler::UpdateFoldersRunningStatusL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::UpdateFoldersRunningStatusL(  )
    {
    TMenuSrvTypeFilter filter;
    filter.SetType( KMenuTypeFolder() );
      
    TInt root;
    iEng.RootFolderL( root );
    
    RArray<TMenuItem> aItemArray;
    CleanupClosePushL(aItemArray);
    iEng.GetItemsL( aItemArray , root, &filter, ETrue );
    for ( TInt i = 0; i < aItemArray.Count(); i++ )
    	{
    	if ( GetFolderRunningStatusL( aItemArray[i].Id() ) )
    		{
    		iRunningFolderStatus.AppendL( aItemArray[i].Id() );
    		}
    	}
    CleanupStack::PopAndDestroy( &aItemArray );
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetRunningStatusL
// ---------------------------------------------------------
//
TBool CMcsRunningAppsHandler::GetRunningStatusL( TInt aItemId )
    {
    const CMenuEngObject& obj = iEng.ObjectL( aItemId );
    return GetRunningStatusL( obj );
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetRunningStatusL
// ---------------------------------------------------------
//
TBool CMcsRunningAppsHandler::GetRunningStatusL( 
		const CMenuEngObject& aEngObj )
    {
    TBool runningApp( EFalse );
    if ( aEngObj.Type().CompareF( KMenuTypeApp ) == KErrNone )
        {
        TUid appUid;
        TInt errorUid = CMenuSrvEngUtils::GetAppUid( aEngObj, appUid );
        
        if( !errorUid )
            {
            runningApp = GetAppRunningStatusL( appUid );
            }
        }
    else if( aEngObj.Type().CompareF( KMenuTypeFolder ) == KErrNone )
        {
        runningApp = GetFolderRunningStatusL( aEngObj.Id() );
        }
    return runningApp;
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetFolderPreviousRunningStatusL
// ---------------------------------------------------------
//
TBool CMcsRunningAppsHandler::GetFolderPreviousRunningStatusL( TInt aId )
	{
	if( KErrNotFound == iRunningFolderStatus.Find( aId ) )
		{
		return EFalse;
		}
	else
		{
		return ETrue;
		}
	
	}

// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetFolderRunningStatusL
// ---------------------------------------------------------
//
TBool CMcsRunningAppsHandler::GetFolderRunningStatusL( TInt aId )
    {
    TBool running ( EFalse );
    TMenuSrvTypeFilter filter;
    filter.SetType( KMenuTypeApp() );
    
    RArray<TMenuItem> aItemArray;
    CleanupClosePushL(aItemArray);
    iEng.GetItemsL( aItemArray , aId , &filter, ETrue );
    for( TInt i = 0; i < aItemArray.Count(); i++)
        {
        const CMenuEngObject& obj = iEng.ObjectL( aItemArray[i].Id() );
        TUid appUid;
        TInt errorUid = CMenuSrvEngUtils::GetAppUid( obj, appUid );
        
        if( !errorUid &&  
                !(obj.Flags() & TMenuItem::EHidden) )
            {
            running = GetAppRunningStatusL( appUid  );
            }
        if( running )
            {
            break;
            }
        }
    CleanupStack::PopAndDestroy( &aItemArray );
    return running;
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::GetAppRunningStatusL
// ---------------------------------------------------------
//
TBool CMcsRunningAppsHandler::GetAppRunningStatusL( TUid aUid )
    {
    TBool running ( EFalse );
    
	TRunningAppsAttr item( aUid );
	TInt id = iRunningApps.Find( item, TRunningAppsAttr::MatchByUid );
	
	if( ( id != KErrNotFound ) &&
			( iRunningApps[id].IsRunning() ) && 
			( !iRunningApps[id].IsHidden() ) && 
			( !iRunningApps[id].IsFswHidden() ) )
		{
		running = ETrue;
		}
    return running;
    }

// ---------------------------------------------------------
// CMcsRunningAppsHandler::HandleAddRemoveRunningAppL
// ---------------------------------------------------------
//
void CMcsRunningAppsHandler::HandleAddRemoveRunningAppL( TInt aFolder )
	{
	TBool oldStatus = GetFolderPreviousRunningStatusL( aFolder );
	TBool newStatus = GetFolderRunningStatusL( aFolder );
	if ( oldStatus != newStatus )
		{
		UpdateFolderRunningStatusL( aFolder, newStatus );
		HandleNotificationL( aFolder );
		}
	}

//  End of File