/*

* 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 <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <swi/sisregistrypackage.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,

        CCaSrvEngUtils& aUtils )

    {

    CCaSrvAppScanner* scanner = new ( ELeave ) CCaSrvAppScanner(

            aCaStorageProxy, aUtils );

    CleanupStack::PushL( scanner );

    scanner->ConstructL();

    CleanupStack::Pop( scanner );

    return scanner;

    }

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

//

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

//

CCaSrvAppScanner::~CCaSrvAppScanner()

    {

    Cancel();

    iSoftwareRegistry.Close();

    iApaLsSession.Close();

    iInstalledPackages.Close();

    delete iInstallNotifier;

    delete iNotifier;

    delete iMmcHistory;

    iFs.Close();

    }

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

//

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

//

CCaSrvAppScanner::CCaSrvAppScanner( CCaStorageProxy& aCaStorageProxy,

        CCaSrvEngUtils& aUtils ) :

    CActive( CActive::EPriorityStandard ),

    iCaStorageProxy( aCaStorageProxy ), 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() );

    iNotifier = CApaAppListNotifier::NewL(

            this, CActive::EPriorityStandard );

    iInstallNotifier = CCaInstallNotifier::NewL(

            *this, CCaInstallNotifier::ESisInstallNotification );

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

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

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

    iApaLsSession.RegisterListPopulationCompleteObserver( iStatus );

    iCollectionDownloadId = 0;

    iAllCollectionId = 0;

    SetActive();

    }

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

//

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

//

void CCaSrvAppScanner::RunL()

    {

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

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

    UpdateApplicationEntriesL();

    InstallationNotifyL();

    MakeNotEmptyCollectionsVisibleL();

    }

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

//

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

//

void CCaSrvAppScanner::DoCancel()

    {

    iApaLsSession.CancelListPopulationCompleteObserver();

    }

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

//

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

//

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 toUpdate = HandleMmcAttrUpdateL( aEntry, aMmcId );

    TBool missingVisibleFlagChanged =

        HandleMissingVisibleFlagsUpdate( aEntry );

    toUpdate = missingVisibleFlagChanged || toUpdate;

    toUpdate = HandleRemovableVisibleFlagsUpdateL( aEntry ) || toUpdate;

    toUpdate = SetApaAppInfoL( aEntry ) || toUpdate;

    if( iInstalledPackages.Find( aEntry->GetUid() ) != KErrNotFound )

        {

        AddEntryToDownloadedCollectionL( aEntry->GetId() );

        toUpdate = HandleUsedFlagUpdate( aEntry ) || toUpdate;

        AddEntryToPredefinedCollectionL( aEntry, ETrue );

        }

    if( toUpdate )

        {

        //update app in storage

        TItemAppearance itemAppearanceChange = EItemAppearanceNotChanged;

        if( missingVisibleFlagChanged )

            {

            itemAppearanceChange = EItemAppeared;

            }

        iCaStorageProxy.AddL( aEntry, EFalse, itemAppearanceChange );

        RemoveFromInstalledPackages( aEntry->GetUid() );

        }

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleMmcAttrUpdateL(

        CCaInnerEntry* aItem, TUint aMmcId )

    {

    TBool toUpdate( ETrue );

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

        {

        //app is instaled on mmc - KCaAttrMmcId attribute update

        RBuf uidString;

        uidString.CleanupClosePushL();

        uidString.CreateL(KUidChars);

        uidString.Format( KHexFormat, aMmcId );

        aItem->AddAttributeL( KCaAttrMmcId, uidString );

        CleanupStack::PopAndDestroy( &uidString );

        }

    else if ( IsInMassStorageL( TUid::Uid( aItem->GetUid() ) ) )

        {

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

        //in case of connecting usb in mass storage mode

        aItem->AddAttributeL( KCaAttrMmcId, KCaMassStorage );

        }

    else

        {

        RBuf attrVal;

        attrVal.CleanupClosePushL();

        attrVal.CreateL( KCaMaxAttrValueLen );

        if( aItem->FindAttribute( KCaAttrMmcId, attrVal ) )

            {

            aItem->RemoveAttributeL( KCaAttrMmcId );

            }

        else

            {

            toUpdate = EFalse;

            }

        CleanupStack::PopAndDestroy( &attrVal );

        //its installed on c: drive - remove attribute

        }

    return toUpdate;

    }

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

//

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

//

void CCaSrvAppScanner::InstallationNotifyL()

    {

    for( TInt i = iInstalledPackages.Count() - 1; i >= 0; i-- )

        {

        NotifyL( iInstalledPackages[i] );

        iInstalledPackages.Remove( i );

        }

    }

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

//

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

//

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::HandleRemovableVisibleFlagsUpdateL(

        CCaInnerEntry* aItem )

    {

    TBool toChange( EFalse );

    if( ( aItem->GetFlags() & EVisible ) && IsInRomL( aItem->GetUid() ) )

        {

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

            {

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

            toChange = ETrue;

            }

        }

    else

        {

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

            {

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

            toChange = ETrue;

            }

        }

    return toChange;

    }

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

//

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

//

TBool CCaSrvAppScanner::HandleMissingVisibleFlagsUpdate(

        CCaInnerEntry* aItem )

    {

    TBool ret( EFalse );

    if( aItem->GetFlags() & EMissing ||

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

        {

        //application found so we unset "missing" and set "visible" flags

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

        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;

    }

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

//

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

//

void CCaSrvAppScanner::HandleHsAppEntryL(

        RPointerArray<CCaInnerEntry>& aArray )

    {

    CCaInnerEntry* appEntry = CCaInnerEntry::NewLC();

    appEntry->SetUid( KHsAppUid.iUid );

    TInt index = aArray.Find(

            appEntry, TIdentityRelation<CCaInnerEntry>( UidMatch ) );

    if ( index != KErrNotFound )

        {

        // hs app already in storage - ensure it is hidden

        // and remove from resultArray

        if ( aArray[index]->GetFlags() & EVisible )

            {

            aArray[index]->SetFlags( aArray[index]->GetFlags() & ~EVisible);

            iCaStorageProxy.AddL( aArray[index], EFalse, EItemDisappeared );

            }

        delete aArray[index];

        aArray.Remove( index );

        }

    else

        {

        // if not found add as not visible to the storage

        appEntry->SetEntryTypeNameL( KCaTypeApp );

        appEntry->SetFlags( 0 );

        appEntry->SetRole( EItemEntryRole );

        SetApaAppInfoL( appEntry );

        iCaStorageProxy.AddL( appEntry );

        }

    CleanupStack::PopAndDestroy( appEntry );

    }

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

//

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

//

void CCaSrvAppScanner::GetApaItemsL( RArray<TUint>& aArray )

    {

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

    CleanupStack::PushL(appInfo);

    TApaAppCapabilityBuf appCap;

    User::LeaveIfError( iApaLsSession.GetAllApps( 0 ) );

    // for every application get uid, hidden and missing attribute

    // and add to aArray.

    while( KErrNone == iApaLsSession.GetNextApp( *appInfo ) )

        {

        User::LeaveIfError( iApaLsSession.GetAppCapability(

                appCap, appInfo->iUid ) );

        // "Hidden" status according to AppArc.

        if( !appCap().iAppIsHidden )

            {

            aArray.AppendL( appInfo->iUid.iUid );

            }

        }

    CleanupStack::PopAndDestroy(appInfo);