/*

* 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 <mcsmenuutils.h>

#include <e32property.h>

#include <WidgetRegistryClient.h>

#include "menusrvappscanner.h"

#include "menusrvmmchistory.h"

#include "menueng.h"

#include "menuengobject.h"

#include "pathinfo.h"

#include "menulogger.h"

#include "centralrepository.h"

#include "mcssathandler.h"

#include "menusrvengutils.h"

#include "bautils.h"

_LIT( KMenuOne, "1" );

_LIT( KMenuAttrMmcId, "mmc_id" );

_LIT( KMenuMassStorage, "mass_storage" );

_LIT( KMenuMmcHistoryFname, "mmchistory" );

_LIT( KZDrive, "Z" );

// ==================== LOCAL FUNCTIONS ====================

/**

* Identity function to search in an array of TMenuItems.

* Identity is the ID.

* @param aLeft Search term.

* @param aRight Array item.

* @return ETrue if ID-s match.

*/

LOCAL_C TBool IdMatch( const TMenuItem& aLeft, const TMenuItem& aRight )

    {

    return aLeft.Id() == aRight.Id();

    }

// ==================== MEMBER FUNCTIONS ====================

// ---------------------------------------------------------

// CMenuSrvAppScanner::NewL

// ---------------------------------------------------------

//

CMenuSrvAppScanner* CMenuSrvAppScanner::NewL( CMenuEng& aEng )

    {

    CMenuSrvAppScanner* scanner = new (ELeave) CMenuSrvAppScanner( aEng );

    CleanupStack::PushL( scanner );

    scanner->ConstructL();

    CleanupStack::Pop( scanner );

    return scanner;

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::~CMenuSrvAppScanner

// ---------------------------------------------------------

//

CMenuSrvAppScanner::~CMenuSrvAppScanner()

    {

    Cancel();

    iApaLsSession.Close();

    delete iMcsSatNotifier;

    delete iNotifier;

    iEng.DequeueOperation( *this );

    delete iMmcHistory;

    iFs.Close();

	iWidgetSession.Close();

    if( iCenRepNotifyHandlerHiddenApps )

        {

        iCenRepNotifyHandlerHiddenApps->StopListening();

        }

    delete iCenRepNotifyHandlerHiddenApps;

    if( iCenRepNotifyHandlerCPHiddenApps )

        {

        iCenRepNotifyHandlerCPHiddenApps->StopListening();

        }

    delete iCenRepNotifyHandlerCPHiddenApps;

    if( iCenRepNotifyHandlerCPHiddenFolders )

        {

        iCenRepNotifyHandlerCPHiddenFolders->StopListening();

        }

    delete iCenRepNotifyHandlerCPHiddenFolders;

  	delete iCenRepSession;

  	delete iFreeSpaceObserver;

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::CMenuSrvAppScanner

// ---------------------------------------------------------

//

CMenuSrvAppScanner::CMenuSrvAppScanner( CMenuEng& aEng )

: CActive( CActive::EPriorityStandard ), iEng( aEng )

    {

    CActiveScheduler::Add( this );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::ConstructL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::ConstructL()

    {

    iOpStatus = EFalse;

    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 );

        	}

    	}

    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 );

    User::LeaveIfError( iApaLsSession.Connect() );

    User::LeaveIfError( iApaLsSession.GetAllApps() ); // This is async.

	User::LeaveIfError( iWidgetSession.Connect() );

   	iCenRepSession = CRepository::NewL( KCRUidMenu );

	iCenRepNotifyHandlerHiddenApps = CCenRepNotifyHandler::NewL(

	    *this, *iCenRepSession,

		CCenRepNotifyHandler::EStringKey, KMenuHideApplication );

	iCenRepNotifyHandlerCPHiddenApps = CCenRepNotifyHandler::NewL(

	    *this, *iCenRepSession,

		CCenRepNotifyHandler::EStringKey, KMenuHideCPApplication );

	iCenRepNotifyHandlerCPHiddenFolders = CCenRepNotifyHandler::NewL(

	    *this, *iCenRepSession,

		CCenRepNotifyHandler::EStringKey, KMenuHideCPFolder );

	iCenRepNotifyHandlerHiddenApps->StartListeningL();

	iCenRepNotifyHandlerCPHiddenApps->StartListeningL();

	iCenRepNotifyHandlerCPHiddenFolders->StartListeningL();

	iMcsSatNotifier = CMcsSatNotifier::NewL(

	                this, KCRUidMenu, KMenuShowSatUI );

	iFreeSpaceObserver = CMcsFreeSpaceObserver::NewL( *this );

    iApaLsSession.RegisterListPopulationCompleteObserver( iStatus );

    SetActive();

    iOpStatus = ETrue;

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::RunL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::RunL()

    {

    User::LeaveIfError( iStatus.Int() ); // Handle errors in RunL.

    // AppArc app scan complete, we have the app list.

    // Now queue this operation to be executed by the Engine.

    iEng.QueueOperationL( *this );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::DoCancel

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::DoCancel()

    {

    iApaLsSession.CancelListPopulationCompleteObserver();

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::RunError

// ---------------------------------------------------------

//

TInt CMenuSrvAppScanner::RunError( TInt /*aError*/ )

    {

    // Ignore the error (what else could we do?).

    // When next AppArc update occurs, we will run again.

    return KErrNone;

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::UpdateApplicationWithHideIfInstalledItemsL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::UpdateApplicationWithHideIfInstalledItemsL()

    {

    TInt root;

    iEng.RootFolderL( root );

    TMenuSrvAttrExistsFilter appFilter;

    appFilter.SetAttr( KMenuAttrHideIfInstalledUid() );

    RArray<TMenuItem> items;

    CleanupClosePushL( items );

    iEng.GetItemsL( items, root, &appFilter, ETrue );

    for (TInt i=0; i < items.Count(); i++)

        {

        TBool wasHidden;

        TPtrC uidTmp;

        GetHiddenFlagAndUidL( items[i].Id(), wasHidden, uidTmp );

        HideItemIfPresentL( root, items[i].Id(), uidTmp, wasHidden );

        }

    CleanupStack::PopAndDestroy( &items );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::GetHiddenFlagAndUidL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::GetHiddenFlagAndUidL( TInt aId, TBool& aHidden, TPtrC& aUidStr )

    {

    const CMenuEngObject& object = iEng.ObjectL( aId );

    aHidden = (0 != (object.Flags() & TMenuItem::EHidden));

    TBool tmp;

    object.FindAttribute( KMenuAttrHideIfInstalledUid(), aUidStr, tmp);

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::HideAppIfExists

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::HideItemIfPresentL( TInt aFolder, TInt aId, const TDesC& aUid, TBool aWasHidden )

    {

    TBool hideItem = EFalse;

    TMenuSrvAttrFilter uidAppFilter;

    uidAppFilter.SetAttr( KMenuAttrUid(), aUid );

    RArray<TMenuItem> appItems;

    CleanupClosePushL( appItems );

    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 );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::SetHiddenFlagL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::SetHiddenFlagL( TInt aId, TBool aWasHidden, TBool aHide )

    {

    if ( aWasHidden ^ aHide )

        {

        iEng.ModifiableObjectL( aId, RMenuNotifier::EItemsAddedRemoved ).

            SetFlags( TMenuItem::EHidden, aHide );

        }

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::ValidateLinkUidL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::ValidateLinkUidL( TInt aFolder, TInt aId, const TDesC& aUidStr )

    {

    TMenuSrvAttrFilter uidAppFilter;

    uidAppFilter.SetAttr( KMenuAttrUid(), aUidStr );

    RArray<TMenuItem> appItems;

    CleanupClosePushL( appItems );

    iEng.GetItemsL( appItems, aFolder, &uidAppFilter, ETrue );

    TBool showItem = EFalse;

    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 );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::UpdateLinkL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::UpdateLinkL(

    TInt aId,

    TBool aExists,

    TBool aShowItem,

    TBool aMissingItem )

    {

    if (!aExists)

        {

        iEng.ModifiableObjectL( aId ).SetFlags( TMenuItem::ELockDelete, EFalse );

        iEng.RemoveL( aId );

        }

    else if ( !aMissingItem )

        {

        const CMenuEngObject& object = iEng.ObjectL( aId );

        TBool itemHidden = (0 != (object.Flags() & TMenuItem::EHidden));

        TBool itemMissing = (0 != (object.Flags() & TMenuItem::EMissing));

        if ( itemHidden == aShowItem )

            {

            iEng.ModifiableObjectL( aId, RMenuNotifier::EItemsAddedRemoved  ).

            SetFlags( TMenuItem::EHidden, !aShowItem );

            }

        if ( itemMissing != aMissingItem )

            {

            iEng.ModifiableObjectL( aId, RMenuNotifier::EItemsAddedRemoved  ).

            SetFlags( TMenuItem::EMissing, aMissingItem );

            }

        }

    else

        {

        const CMenuEngObject& object = iEng.ObjectL( aId );

        TBool itemMissing = (0 != (object.Flags() & TMenuItem::EMissing));

        if ( itemMissing != aMissingItem )

            {

            iEng.ModifiableObjectL( aId, RMenuNotifier::EItemsAddedRemoved  ).

            SetFlags( TMenuItem::EMissing, aMissingItem );

            }

        }

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::ValidateLinkRefIdL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::ValidateLinkRefIdL( TInt aId, const TDesC& refIdStr )

    {

    TUint refItemId;

    MenuUtils::GetTUint( refIdStr, refItemId );

    TMenuItem refItem;

    TBool showItem = EFalse;

    TBool exists = EFalse;

    TRAPD( err, iEng.GetItemL( refItemId, refItem ) );

    if (err == KErrNone)

        {

        exists = ETrue;

        }

    TBool itemHidden = (0 != (refItem.Flags() & TMenuItem::EHidden));

    TBool itemMissing = (0 != (refItem.Flags() & TMenuItem::EMissing));

    if ( !itemHidden  && !itemMissing )

        {

        showItem = ETrue;

        }

    UpdateLinkL( aId, exists, showItem, itemMissing );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::ValidateLinkL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::ValidateLinkL( TInt aFolder, TInt aId )

    {

    const CMenuEngObject& object = iEng.ObjectL( aId );

    TBool tmp;

    TPtrC refIdStr;

    TPtrC uidStr;

    if ( object.FindAttribute( KMenuAttrRefId(), refIdStr, tmp) )

        {

        ValidateLinkRefIdL( aId, refIdStr );

        }

    else if ( object.FindAttribute( KMenuAttrUid(), uidStr, tmp) )

        {

        ValidateLinkUidL( aFolder, aId, uidStr );

        }

    else

        {

        UpdateLinkL( aId, EFalse, EFalse, EFalse );

        }

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::UpdateLinkItemsL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::UpdateLinkItemsL()

    {

    TInt root;

    iEng.RootFolderL( root );

    TMenuSrvTypeFilter linkFilter;

    linkFilter.SetType( KMenuTypeLink() );

    RArray<TMenuItem> items;

    CleanupClosePushL( items );

    iEng.GetItemsL( items, root, &linkFilter, ETrue );

    for (TInt i=0; i < items.Count(); i++)

        {

        ValidateLinkL( root, items[i].Id() );

        }

    CleanupStack::PopAndDestroy( &items );

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::HandleFreeSpaceEventL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::HandleFreeSpaceEventL()

    {

    if ( !IsActive() && !iOpStatus )

        {

        iOpStatus = ETrue;

        TRequestStatus* ownStatus = &iStatus;

        *ownStatus = KRequestPending;

        SetActive();

        User::RequestComplete( ownStatus, KErrNone );

        }

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::RunMenuEngOperationL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::RunMenuEngOperationL()

    {

    UpdateApplicationItemsL();

    UpdateApplicationWithHideIfInstalledItemsL();

    UpdateLinkItemsL();

    iOpStatus = EFalse;

    }

// ---------------------------------------------------------

// CMenuSrvAppScanner::UpdateApplicationItemL

// ---------------------------------------------------------

//

void CMenuSrvAppScanner::UpdateApplicationItemL(

		RArray<TMenuItem>& aMcsItems, const TAppAtributes& aApaItem,

		TUint aMmcId, TBool isLegacy)

    {

    RArray<TMenuItem> mcsUidItems;

    CleanupClosePushL( mcsUidItems );

    TInt appuid = aApaItem.GetUid();

    GetMcsAppItemsL( isLegacy, appuid, mcsUidItems );

    TBool isApaItemHidden( aApaItem.IsHidden() );

    // 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

    		&& appuid !=  KMmUid3.iUid  )

        {

        if( appuid == KSatUid.iUid )

            {

            if( CMcsSatHandler::CheckVisibility() )

             	{

              	AddAppItemL( appuid, aMmcId );

               	}

            }

        else

          	{

          	AddAppItemL( appuid, aMmcId );

            GetMcsAppItemsL( isLegacy, appuid, mcsUidItems );

           	}

        }//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++)

     		{

       		CMenuEngObject& object =

      		                iEng.ModifiableObjectL( mcsUidItems[j].Id() );

            TBuf<KUidChars> uidString;

            MenuSrvUtil::UidToStringL( appuid, uidString, EFalse, EHex );

       	    object.SetAttributeL( KMenuAttrUid(), uidString, EFalse );

       		}//for

        }//else if

    // "hidden", "missing" and "lock_delete"  flags update

    for ( TInt j = 0; j < mcsUidItems.Count(); j++ )

        {

        const TMenuItem& item = mcsUidItems[j];