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

#include <e32property.h>
#include <f32file.h>
#include <badesca.h>
#include <usif/sif/sif.h>
#include <usif/scr/scr.h>
#include <usif/sif/sifcommon.h>

#include "causifscanner.h"
#include "cainnerentry.h"
#include "cainnerquery.h"
#include "cadef.h"
#include "castorageproxy.h"
#include "caarraycleanup.inl"

using namespace Usif;

_LIT( KUsifPluginCollection, "Usif collection");
_LIT( KCaAttrComponentId, "component_id" );

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCaUsifScanner* CCaUsifScanner::NewL( TPluginParams* aPluginParams )
    {
    CCaUsifScanner* self = new ( ELeave )
            CCaUsifScanner( *aPluginParams->storageProxy );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCaUsifScanner::CCaUsifScanner( CCaStorageProxy& aStorageProxy ) :
    iStorageProxy( aStorageProxy )
    {

    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::ConstructL()
    {
    AddCollectionUsifL();
    AddNativeAppsL();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCaUsifScanner::~CCaUsifScanner()
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::InstallL( const TDesC& aFileName )
    {
    RSoftwareInstall sif;
    CleanupClosePushL( sif );
    User::LeaveIfError( sif.Connect());

    // Install the component
    TRequestStatus status;
    sif.Install( aFileName, status, EFalse );
    User::WaitForRequest( status );
    User::LeaveIfError(status.Int());

    // Disconnect from the SIF server
    CleanupStack::PopAndDestroy( &sif );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::AddCollectionUsifL()
    {
    if( GetCollectionUsifIdL() == 0 )
        {
        CCaInnerEntry *entry = CCaInnerEntry::NewLC();
        entry->SetRole( EGroupEntryRole );
        entry->SetEntryTypeNameL( KCaTypeCollection );
        entry->SetFlags( ERemovable | EVisible );
        entry->SetTextL( KUsifPluginCollection );
        iStorageProxy.AddL( entry );
        iCollectionUsifId = entry->GetId();
        CleanupStack::PopAndDestroy( entry );

        TCaOperationParams params =
            {
            TCaOperationParams::EPrepend, 2, 0
            };
        RArray<TInt> ids;
        CleanupClosePushL( ids );
        ids.AppendL( iCollectionUsifId );
        iStorageProxy.OrganizeL( ids, params );
        CleanupStack::PopAndDestroy( &ids );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CCaUsifScanner::GetCollectionUsifIdL()
    {
    if( iCollectionUsifId == 0 )
        {
        RPointerArray<CCaInnerEntry> resultArray;
        CleanupResetAndDestroyPushL( resultArray );
        CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();
        CDesC16ArrayFlat* appType = new ( ELeave ) CDesC16ArrayFlat( 1 );
        CleanupStack::PushL( appType );
        appType->AppendL( KCaTypeCollection );
        allAppQuery->SetEntryTypeNames( appType );
        allAppQuery->SetRole(CCaInnerQuery::Group);
        CleanupStack::Pop( appType );
        iStorageProxy.GetEntriesL( allAppQuery, resultArray );
        CleanupStack::PopAndDestroy( allAppQuery );
        for(TInt i(0); i< resultArray.Count(); i++ )
            {
            if(!resultArray[i]->GetText().Compare(KUsifPluginCollection))
                iCollectionUsifId = resultArray[i]->GetId();
            }
        CleanupStack::PopAndDestroy( &resultArray );
        }
    return iCollectionUsifId;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::CreateCaEntryFromEntryL(
        const CComponentEntry* aEntry, CCaInnerEntry* aCaEntry )
    {
    aCaEntry->SetRole( EItemEntryRole );
    aCaEntry->SetEntryTypeNameL(KCaTypeApp);
    if( aEntry->Name().Compare(KNullDesC))
        {
        aCaEntry->SetTextL(aEntry->Name());
        }
    if( !aEntry->IsHidden() )
        {
        aCaEntry->SetFlags( EVisible );
        }
    if( aEntry->IsRemovable() )
        {
        aCaEntry->SetFlags( aCaEntry->GetFlags() | ERemovable );
        }
    if( aEntry->GlobalId().Compare( KNullDesC ) )
        {
        TLex lex( aEntry->GlobalId() );
        TUint uint( 0 );
        User::LeaveIfError( lex.Val( uint, EHex ) );
        aCaEntry->SetUid( uint );
        }
    RBuf compIdDesc;
    CleanupClosePushL(compIdDesc);
    compIdDesc.CreateL(KCaMaxAttrValueLen);
    compIdDesc.Num(aEntry->ComponentId());
    aCaEntry->AddAttributeL( KCaAttrComponentId, compIdDesc );
    CleanupStack::PopAndDestroy( &compIdDesc );

    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::AddNativeAppsL()
    {
    TLanguage locale = TLanguage(-1);

    CComponentFilter *filter = CComponentFilter::NewL();
    CleanupStack::PushL(filter);
    filter->SetSoftwareTypeL( KSoftwareTypeNative );
    filter->SetRemovable(ETrue);

    // Connect to the SCR server
    RSoftwareComponentRegistry *scr = new RSoftwareComponentRegistry();
    CleanupClosePushL(*scr);
    User::LeaveIfError( scr->Connect() );

    // Create an SCR view
    RSoftwareComponentRegistryView *scrView =
            new RSoftwareComponentRegistryView();
    CleanupClosePushL(*scrView);
    scrView->OpenViewL( *scr, filter );

    // Iterate over the matching components
    CComponentEntry* entry = CComponentEntry::NewLC();

    RPointerArray<CCaInnerEntry> entries;
    CleanupResetAndDestroyPushL( entries );
    GetCaAppEntriesL(entries);

    RArray<TInt> entryIds;
    CleanupClosePushL(entryIds);
    while( scrView->NextComponentL( *entry, locale ) )
        {
        CCaInnerEntry *caEntry = CCaInnerEntry::NewLC();
        CreateCaEntryFromEntryL( entry, caEntry );

        if( !AppExist(entries, caEntry))
            {
            iStorageProxy.AddL( caEntry );
            entryIds.Append( caEntry->GetId() );
            }
        CleanupStack::PopAndDestroy( caEntry );
        }
    TCaOperationParams params =
        {
        TCaOperationParams::EAppend, iCollectionUsifId, 0
        };
    iStorageProxy.OrganizeL( entryIds, params );

    CleanupStack::PopAndDestroy( &entryIds );
    CleanupStack::PopAndDestroy( &entries );
    CleanupStack::PopAndDestroy( entry );
    CleanupStack::PopAndDestroy(scrView);
    CleanupStack::PopAndDestroy(scr);
    CleanupStack::PopAndDestroy(filter);
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaUsifScanner::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 );
    iStorageProxy.GetEntriesL( allAppQuery, aArray );
    CleanupStack::PopAndDestroy( allAppQuery );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CCaUsifScanner::AppExist( RPointerArray<CCaInnerEntry>& aArray,
            CCaInnerEntry* aEntry )
    {
    for (TInt i(0); i < aArray.Count(); i++)
        {
        if( aArray[i]->GetUid() == aEntry->GetUid())
            return KErrAlreadyExists;
        }
    return KErrNone;
    }