/*

* 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: casrvappscanner.cpp

*

*/

#include <e32property.h>

#include <bautils.h>

#include <usif/scr/screntries.h>

#include "cadef.h"

#include "casrvappscanner.h"

#include "cautils.h"

#include "casrvmmchistory.h"

#include "pathinfo.h"

#include "casrvengutils.h"

#include "cainnerquery.h"

#include "cainnerentry.h"

#include "caarraycleanup.inl"

#include "castorageproxy.h"

#include "caarraycleanup.inl"

using namespace Usif;

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

/**

 * Identity function to search in an array of CCaInnerEntry.

 * Identity is the ID.

 * @param aLeft Search term.

 * @param aRight Array item.

 * @return ETrue if ID-s match.

 */

LOCAL_C TBool IdMatch( const CCaInnerEntry& aLeft,

        const CCaInnerEntry& aRight )

    {

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

    }

/**

 * Identity function to search in an array of CCaInnerEntry.

 * Identity is the ID.

 * @param aLeft Search term.

 * @param aRight Array item.

 * @return ETrue if ID-s match.

 */

LOCAL_C TBool UidMatch( const CCaInnerEntry& aLeft,

        const CCaInnerEntry& aRight )

    {

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

    }

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

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

//

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

//

CCaSrvAppScanner* CCaSrvAppScanner::NewL( CCaStorageProxy& aCaStorageProxy,

        Usif::RSoftwareComponentRegistry& aSoftwareRegistry,

        CCaSrvEngUtils& aUtils )

    {

    CCaSrvAppScanner* scanner = new ( ELeave ) CCaSrvAppScanner(

            aCaStorageProxy, aSoftwareRegistry, aUtils );

    CleanupStack::PushL( scanner );

    scanner->ConstructL();

    CleanupStack::Pop( scanner );

    return scanner;

    }

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

//

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

//

CCaSrvAppScanner::~CCaSrvAppScanner()

    {

    Cancel();

    iApaLsSession.Close();

    delete iMmcHistory;

    iFs.Close();

    }

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

//

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

//

CCaSrvAppScanner::CCaSrvAppScanner( CCaStorageProxy& aCaStorageProxy,

        Usif::RSoftwareComponentRegistry& aSoftwareRegistry,

        CCaSrvEngUtils& aUtils ) :

    CActive( CActive::EPriorityStandard ),

    iCaStorageProxy( aCaStorageProxy ),

    iSoftwareRegistry(aSoftwareRegistry), iSrvEngUtils( aUtils )

    {

    CActiveScheduler::Add( this );

    }

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

//

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

//

void CCaSrvAppScanner::ConstructL()

    {

    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 = CCaSrvMmcHistory::NewL();

    iMmcHistory->LoadL( iFs, KCaMmcHistoryFname() );

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

    iApaLsSession.SetNotify( EFalse, iStatus );

    iCollectionDownloadId = 0;

    iAllCollectionId = 0;

    UpdateApplicationEntriesL();

    MakeNotEmptyCollectionsVisibleL();

    SetActive();

    }

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

//

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

//

void CCaSrvAppScanner::RunL()

    {

    User::LeaveIfError( iStatus.Int() );

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

    RArray<TApaAppUpdateInfo> updatedAppsInfo;

    CleanupClosePushL( updatedAppsInfo );

    iApaLsSession.UpdatedAppsInfoL( updatedAppsInfo );

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

    	{

		TApaAppUpdateInfo::TApaAppAction action = updatedAppsInfo[i].iAction;

        RPointerArray<CCaInnerEntry> resultArray;

        CleanupResetAndDestroyPushL( resultArray );

        GetCaAppEntriesL( updatedAppsInfo[i].iAppUid.iUid, resultArray );

		if( action == TApaAppUpdateInfo::EAppPresent

				|| action == TApaAppUpdateInfo::EAppInfoChanged )

			{

			TInt id;

			if( !resultArray.Count() )

				{

                id = AddAppEntryL(

                        updatedAppsInfo[i].iAppUid.iUid, UpdateMmcHistoryL() );

                AddEntryToDownloadedCollectionL( id );

				}

			else

			    {

                ASSERT( resultArray.Count() == 1 );

                id = resultArray[0]->GetId();

                UpdateAppEntryL( resultArray[0], UpdateMmcHistoryL(), ETrue );

                }

            MakeNotEmptyCollectionsVisibleL();

			}

		else if( action == TApaAppUpdateInfo::EAppNotPresent )

			{

			HandleMissingItemsL( resultArray );

			}

		else

			{

			User::Leave( KErrNotSupported );

			}

        CleanupStack::PopAndDestroy( &resultArray );

    	}

    CleanupStack::PopAndDestroy( &updatedAppsInfo );

    iApaLsSession.SetNotify( EFalse, iStatus );

    SetActive();

    }

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

//

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

//

void CCaSrvAppScanner::DoCancel()

    {

    iApaLsSession.CancelNotify();

    }

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

//

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

//

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

    {

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

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

    return KErrNone;

    }

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

//

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

//

void CCaSrvAppScanner::UpdateApplicationEntryL(

        RPointerArray<CCaInnerEntry>& aCaEntries,

        TUint aAppUid, TUint aMmcId )

    {

    RPointerArray<CCaInnerEntry> resultArray;

    CleanupResetAndDestroyPushL( resultArray );

    GetCaAppEntriesL( aAppUid, resultArray );

    // This app is not in the storage, add it now.

    // We don't add hidden items, there are too many of them!

    // do not display Menu app

    if( !resultArray.Count() )

        {

        AddAppEntryL( aAppUid, aMmcId );

        }//if

    // "removable", "missing" and "visible"  flags update

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

        {

        //We need to handle first run of appscanner,

        //there might be some incorrect data. If this will have impact

        //on performance we may run this methods only at start up.

        UpdateAppEntryL( resultArray[j], aMmcId );

        TInt index = aCaEntries.Find( resultArray[j],

                TIdentityRelation<CCaInnerEntry>( IdMatch ) );

        if( index != KErrNotFound )

            {

            delete aCaEntries[index];

            aCaEntries.Remove( index );

            }

        }//for

    CleanupStack::PopAndDestroy( &resultArray );

    }

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

//

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

//

void CCaSrvAppScanner::UpdateAppEntryL(

        CCaInnerEntry* aEntry, TUint aMmcId, TBool aAlwaysUpdate )

    {

    TBool missingFlagChanged = HandleMissingFlagsUpdate( aEntry );

    TBool visibleFlagChanged = HandleVisibleFlagUpdate( aEntry );

    // To handle case with mmc card. When mmc attritube is updated then

    // used flag should be change. When aplication is update but

    // it is not appear then this flag should be change too.

    if( aAlwaysUpdate && !missingFlagChanged )

        {

        HandleUsedFlagUpdate( aEntry );

        }

    TBool toUpdate = missingFlagChanged || visibleFlagChanged;

    toUpdate = SetApaAppInfoL( aEntry ) || toUpdate;

    toUpdate = HandleRemovableFlagAndMmcAttrUpdateL( aEntry, aMmcId ) || toUpdate;

    toUpdate = RemoveUninstallFlagL( aEntry ) || toUpdate;

    if( toUpdate || aAlwaysUpdate )

        {

        //update app in storage

        TItemAppearance itemAppearanceChange = EItemAppearanceNotChanged;

        if( missingFlagChanged || visibleFlagChanged )

            {

            itemAppearanceChange = EItemAppeared;

            }

        if( !missingFlagChanged )

            {

            AddEntryToPredefinedCollectionL( aEntry, ETrue );

            if ( aEntry->GetFlags() & ERemovable )

                {

                AddEntryToDownloadedCollectionL( aEntry->GetId() );

                }

            }

        iCaStorageProxy.AddL( aEntry, EFalse, itemAppearanceChange );

        }

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleMmcAttrUpdateL(

        const Usif::CComponentEntry* aEntry,

        CCaInnerEntry* aItem, TUint aMmcId )

    {

    TBool toChange( EFalse );

    if( aEntry && aEntry->IsRemovable() )

        {

        TChar currentDriveLetter;

        if ( aEntry->SoftwareType().Compare(KCaAttrAppTypeValueNative()) != 0 )

            {

            TDriveList driveList = aEntry->InstalledDrives();

            for ( TInt driveNr=EDriveY; driveNr >= EDriveA; driveNr-- )

                {

                if ( driveList[driveNr] )

                    {

                    User::LeaveIfError( iFs.DriveToChar( driveNr,

                            currentDriveLetter ) );

                    }

                }

            }

        else

            {

            TApaAppInfo* appInfo = new ( ELeave ) TApaAppInfo();

            if( !iApaLsSession.GetAppInfo( *appInfo,

                    TUid::Uid( aItem->GetUid() ) ) )

                {

                currentDriveLetter = appInfo->iFullName[0];

                }

            }

        if( IsCharInDrive( currentDriveLetter,

                DriveInfo::EDefaultRemovableMassStorage ) )

            {

            //app is instaled on mmc - KCaAttrMmcId attribute update

            RBuf uidString;

            uidString.CleanupClosePushL();

            uidString.CreateL( KUidChars );

            uidString.Format( KHexFormat, aMmcId );

            toChange = AddAttributeL( aItem, KCaAttrMmcId, uidString );

            CleanupStack::PopAndDestroy( &uidString );

            }

        else if ( IsCharInDrive( currentDriveLetter, DriveInfo::EDefaultMassStorage ) )

            {

            //its app installed on mass storage, we need to leave it

            //in case of connecting usb in mass storage mode

            toChange = AddAttributeL( aItem, KCaAttrMmcId, KCaMassStorage );

            }

        else

            {

            toChange = RemoveAttributeL( aItem, KCaAttrMmcId );

            }

        }

    else

        {

        toChange = RemoveAttributeL( aItem, KCaAttrMmcId );

        //its installed on c: drive - remove attribute

        }

    return toChange;

    }

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

//

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

//

void CCaSrvAppScanner::UpdateApplicationEntriesL()

    {

    TUint currentMmcId = UpdateMmcHistoryL();

    // get all Content arsenal enties with type application

    RPointerArray<CCaInnerEntry> resultArray;

    CleanupResetAndDestroyPushL( resultArray );

    GetCaAppEntriesL( resultArray );

    HandleHsAppEntryL( resultArray );

    RemoveSatAppL( resultArray );

    RArray<TUint> appUids;

    CleanupClosePushL( appUids );

    GetApaItemsL( appUids );

    RemoveApp( appUids, KSatUid.iUid );

    RemoveApp( appUids, KHsAppUid.iUid );

    //for every item in apaAndCrItems array

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

        {

        // if there was leave for any item we ignore it

        // and proceed to the next one

        TRAP_IGNORE(UpdateApplicationEntryL(

                resultArray, appUids[i], currentMmcId));

        }

    // Here the big list with items that refer to missing apps.

    HandleMissingItemsL( resultArray );

    CleanupStack::PopAndDestroy( &appUids );

    CleanupStack::PopAndDestroy( &resultArray );

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleRemovableFlagAndMmcAttrUpdateL(

        CCaInnerEntry* aItem, TUint aMmcId )

    {

    TBool toChange( EFalse );

    TComponentId compId = GetComponentIdFromEntryL( aItem );

    TBool isRemovable( EFalse );

    if( compId )

        {

        CComponentEntry* entry = CComponentEntry::NewLC();

        iSoftwareRegistry.GetComponentL( compId , *entry );

        isRemovable = entry->IsRemovable();

        toChange = HandleMmcAttrUpdateL( entry, aItem, aMmcId );

        CleanupStack::PopAndDestroy( entry );

        }

    if( ( aItem->GetFlags() & EVisible ) && !isRemovable )

        {

        if( ( aItem->GetFlags() & ERemovable ) != 0 )

            {

            aItem->SetFlags( aItem->GetFlags() & ~ERemovable );

            toChange = ETrue;

            }

        }

    else

        {

        if( ( aItem->GetFlags() & ERemovable ) == 0 && isRemovable )

            {

            aItem->SetFlags( aItem->GetFlags() | ERemovable );

            toChange = ETrue;

            }

        }

    return toChange;

    }

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

//

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

//

TBool CCaSrvAppScanner::RemoveUninstallFlagL( CCaInnerEntry* aItem )

    {

    TBool toChange( EFalse );

    if( aItem->GetFlags() & EUninstall )

        {

		aItem->SetFlags( aItem->GetFlags() & ~EUninstall );

		toChange = ETrue;

        }

    return toChange;

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleMissingFlagsUpdate(

        CCaInnerEntry* aItem )

    {

    TBool ret( EFalse );

    if( aItem->GetFlags() & EMissing )

        {

        //application found so we unset "missing" flag

        aItem->SetFlags( aItem->GetFlags() & ~EMissing );

        ret = ETrue;

        }

    return ret;

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleVisibleFlagUpdate( CCaInnerEntry* aItem )

    {

    TBool toChange( EFalse );

    if( !( aItem->GetFlags() & EVisible ) )

        {

        aItem->SetFlags( aItem->GetFlags() | EVisible );

        toChange = ETrue;

        }

    return toChange;

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleUsedFlagUpdate( CCaInnerEntry* aItem )

    {

    TBool changed( EFalse );

    if( aItem->GetFlags() & EUsed )

        {

        aItem->SetFlags( aItem->GetFlags() & ~EUsed );

        changed = ETrue;

        }

    return changed;

    }

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

//

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

//

void CCaSrvAppScanner::RemoveApp( RArray<TUint>& aArray, TInt32 aUid )

    {

    TInt id = aArray.Find( aUid );

    if( id != KErrNotFound )

        {

        aArray.Remove( id );

        }

    }

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

//

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

//

void CCaSrvAppScanner::RemoveSatAppL( RPointerArray<CCaInnerEntry>& aArray )

    {

    CCaInnerEntry* sat = CCaInnerEntry::NewL();

    sat->SetUid( KSatUid.iUid );

    TInt index = aArray.Find(

            sat, TIdentityRelation<CCaInnerEntry>( UidMatch ) );

    if ( index != KErrNotFound )

        {

        delete aArray[index];

        aArray.Remove( index );

        }

    delete sat;

    }

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

//