/*

* 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 "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"

// ==================== 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::NewL

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

//

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

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

//

CCaSrvAppScanner::~CCaSrvAppScanner()

    {

    Cancel();

    iApaLsSession.Close();

    iInstalledPackages.Close();

    delete iInstallNotifier;

    delete iNotifier;

    delete iMmcHistory;

    iFs.Close();

    }

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

// CCaSrvAppScanner::CCaSrvAppScanner

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

//

CCaSrvAppScanner::CCaSrvAppScanner( CCaStorageProxy& aCaStorageProxy,

        CCaSrvEngUtils& aUtils ) :

    CActive( CActive::EPriorityStandard ),

    iCaStorageProxy( aCaStorageProxy ), iSrvEngUtils( aUtils )

    {

    CActiveScheduler::Add( this );

    }

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

// CCaSrvAppScanner::ConstructL

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

//

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 = new (ELeave) CCaSrvMmcHistory();

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

    // The notifier has its own session to apparc, instead of taking

    // it as argument... :(

    iNotifier = CApaAppListNotifier::NewL(

            this, CActive::EPriorityStandard );

    iInstallNotifier = CCaInstallNotifier::NewL(

            *this, CCaInstallNotifier::ESisInstallNotification );

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

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

    iApaLsSession.RegisterListPopulationCompleteObserver( iStatus );

    iCollectionDownloadId = 0;

    SetActive();

    }

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

// CCaSrvAppScanner::RunL

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

//

void CCaSrvAppScanner::RunL()

    {

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

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

    UpdateApplicationEntriesL();

    InstallationNotifyL();

    }

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

// CCaSrvAppScanner::DoCancel

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

//

void CCaSrvAppScanner::DoCancel()

    {

    iApaLsSession.CancelListPopulationCompleteObserver();

    }

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

// CCaSrvAppScanner::RunError

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

//

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

    {

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

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

    return KErrNone;

    }

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

// CCaSrvAppScanner::UpdateApplicationItemL

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

//

void CCaSrvAppScanner::UpdateApplicationEntryL(

        RPointerArray<CCaInnerEntry>& aCaEntries,

        const TCaAppAtributes& aApaItem, TUint aMmcId )

    {

    TInt appuid = aApaItem.GetUid();

    RPointerArray<CCaInnerEntry> resultArray;

    CleanupResetAndDestroyPushL( resultArray );

    GetCaAppEntriesL( appuid, 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( appuid, 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 in content xml file

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

    }

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

// CCaSrvAppScanner::UpdateAppEntryL

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

//

void CCaSrvAppScanner::UpdateAppEntryL( CCaInnerEntry* aEntry, TUint aMmcId )

    {

    TBool toUpdate = HandleMmcAttrUpdateL( aEntry, aMmcId );

    toUpdate = HandleHiddenFlagUpdateL( aEntry ) || toUpdate;

    toUpdate = HandleMissingFlagUpdate( aEntry ) || toUpdate;

    toUpdate = HandleLockDeleteFlagUpdateL( aEntry ) || toUpdate;

    toUpdate = SetApaAppInfoL( aEntry ) || toUpdate;

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

        {

        AddEntryToDownloadedCollectionL( aEntry->GetId() );

        toUpdate = HandleUsedFlagUpdateL( aEntry ) || toUpdate;

        }

    if( toUpdate )

        {

        //update app in storage

        iCaStorageProxy.AddL( aEntry );

        RemoveFromInstalledPackages( aEntry->GetUid() );

        }

    }

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

// CCaSrvAppScanner::HandleHiddenFlagUpdateL

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

//

TBool CCaSrvAppScanner::HandleHiddenFlagUpdateL( CCaInnerEntry* aItem )

    {

    TBool toChange( EFalse );

    TBool itemHidden = ( 0 == ( aItem->GetFlags() & EVisible ) );

    if( itemHidden )

        {

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

        toChange = ETrue;

        }

    return toChange;

    }

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

// CCaSrvAppScanner::HandleUsedFlagUpdateL

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

//

TBool CCaSrvAppScanner::HandleUsedFlagUpdateL( CCaInnerEntry* aItem )

    {

    if( aItem->GetFlags() & EUsed )

        {

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

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CCaSrvAppScanner::HandleMmcAttrUpdateL

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

//

TBool CCaSrvAppScanner::HandleMmcAttrUpdateL(

        CCaInnerEntry* aItem, TUint aMmcId )

    {

    TBool toUpdate( ETrue );

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

        {

        //app is instaled on mmc - KCaAttrMmcId attribute update

        TBuf<KUidChars> uidString;

        uidString.Format( KHexFormat, aMmcId );

        aItem->AddAttributeL( KCaAttrMmcId, uidString );

        }

    else if ( IsInMassStorage( 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;

    }

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

// CCaSrvAppScanner::UpdateApplicationItemsL

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

//

void CCaSrvAppScanner::InstallationNotifyL()

    {

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

        {

        NotifyL( iInstalledPackages[i] );

        iInstalledPackages.Remove( i );

        }

    }

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

// CCaSrvAppScanner::UpdateApplicationItemsL

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

//

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<TCaAppAtributes> apaItems;

    CleanupClosePushL( apaItems );

    GetApaItemsL( apaItems );

    RemoveApp( apaItems, KSatUid.iUid );

    RemoveApp( apaItems, KHsAppUid.iUid );

    //for every item in apaAndCrItems array

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

        {

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

            // and proceed to the next one

            TRAP_IGNORE(UpdateApplicationEntryL(

                            resultArray, apaItems[i], currentMmcId));

        }

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

    HandleMissingItemsL( resultArray );

    CleanupStack::PopAndDestroy( &apaItems );

    CleanupStack::PopAndDestroy( &resultArray );

    }

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

// CCaSrvAppScanner::HandleLockDeleteFlagUpdateL

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

//

TBool CCaSrvAppScanner::HandleLockDeleteFlagUpdateL( CCaInnerEntry* aItem )

    {

    TBool toChange( EFalse );

    TBool isVisible = ( ( aItem->GetFlags() & EVisible ) != 0 );

    if( isVisible && IsInRom( 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;

    }

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

// CCaSrvAppScanner::HandleMissingFlagUpdateL

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

//

TBool CCaSrvAppScanner::HandleMissingFlagUpdate( CCaInnerEntry* aItem )

    {

    if( aItem->GetFlags() & EMissing )

        {

        //application found so we unset "missing" flag

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

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CCaSrvAppScanner::RemoveApp

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

//

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

    {

    TCaAppAtributes app( aUid );

    TInt id = aArray.Find( app, TCaAppAtributes::MatchItems );

    if( id != KErrNotFound )

        {

        aArray.Remove( id );

        }

    }

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

// CCaSrvAppScanner::RemoveSatApp

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

//

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;

    }

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

// CCaSrvAppScanner::HandleHsAppEntryL

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

//

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 ) != 0 )

            {

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

            iCaStorageProxy.AddL( aArray[index] );

            }        

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

    }

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

// CCaSrvAppScanner::GetApaItemsL

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

//

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

    {

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

            {

            TCaAppAtributes appAtributes( appInfo.iUid.iUid );

            aArray.AppendL( appAtributes );

            }

        }

    }

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

// CCaSrvAppScanner::GetMcsItemsL

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

//

void CCaSrvAppScanner::GetCaAppEntriesL(

        RPointerArray<CCaInnerEntry>& aArray )

    {

    CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();

    CDesC16ArrayFlat* appType = new ( ELeave ) CDesC16ArrayFlat( 1 );

    CleanupStack::PushL( appType );

    appType->AppendL( KCaTypeApp );

    allAppQuery->SetEntryTypeNames( appType );

    CleanupStack::Pop( appType );

    iCaStorageProxy.GetEntriesL( allAppQuery, aArray );

    CleanupStack::PopAndDestroy( allAppQuery );

    }

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

// CCaSrvAppScanner::GetMcsItemsL

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

//

TInt CCaSrvAppScanner::GetCollectionDownloadIdL()

    {

    if( iCollectionDownloadId == 0 )

        {

        RPointerArray<CCaInnerEntry> resultArray;

        CleanupResetAndDestroyPushL( resultArray );

        CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();

        CDesC16ArrayFlat* appType = new ( ELeave ) CDesC16ArrayFlat( 1 );

        CleanupStack::PushL( appType );

        appType->AppendL( KCaTypeCollectionDownload );

        allAppQuery->SetEntryTypeNames( appType );

        CleanupStack::Pop( appType );

        iCaStorageProxy.GetEntriesL( allAppQuery, resultArray );

        CleanupStack::PopAndDestroy( allAppQuery );

        if( resultArray.Count() )

            {