/*

* Copyright (c) 2008 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:   Implementation of CNcdProviderManager

*

*/

#include "ncdprovidermanager.h"

#include <bautils.h>

#include "ncdproviderimpl.h"

#include "catalogsconstants.h"

#include "catalogstransportimpl.h"

#include "ncdproviderutils.h"

#include "ncdstoragemanagerimpl.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

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

CNcdProviderManager* CNcdProviderManager::NewL()

    {

    CNcdProviderManager* self = new (ELeave) CNcdProviderManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

// 

CNcdProviderManager::CNcdProviderManager()        

    {

    }

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

// 

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

// 

CNcdProviderManager::~CNcdProviderManager()

    {

    // Providers are not owned by the array

    iProviders.Close();

    delete iEngineRootPath;

    delete iTransport;

    delete iStorageManager;    

    delete iProviderUtils;

    }

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

// 

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

// 

void CNcdProviderManager::ConstructL()

    {

    DLTRACEIN((""));

    // create provider utils, fs is used as the global fs returned by 

    // CNcdProviderUtils::FileSession so it must not be closed here

    iProviderUtils = CNcdProviderUtils::NewL(

        KCatalogsConfigFile );        

    iEngineRootPath = WritableEnginePathL( CNcdProviderUtils::FileSession() );                        

    // Create transport

    iTransport = CCatalogsTransport::NewL( 

        CNcdProviderUtils::InstallationServiceL().DocumentHandler() );

    iStorageManager = CNcdStorageManager::NewL( 

        CNcdProviderUtils::FileSession(), *iEngineRootPath );

    DLTRACE(("iStorageManager ok"));

    }

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

// 

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

// 

CNcdProvider& CNcdProviderManager::ProviderL( 

    const MCatalogsContext& aContext,

    TBool& aCreated )

    {

    DLTRACEIN((""));

    TInt index = FindFamily( aContext );

    aCreated = EFalse;

    if ( index == KErrNotFound ) 

        {

        DLTRACE(("Creating new provider"));

        CNcdProvider* provider = CNcdProvider::NewLC( 

            aContext.FamilyId(), 

            *this,

            *iEngineRootPath,

            *iTransport,

            *iStorageManager );

        iProviders.AppendL( provider );

        CleanupStack::Pop( provider );        

        index = iProviders.Count() - 1;

        aCreated = ETrue;

        }

    return *iProviders[ index ];

    }

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

// 

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

// 

CNcdProvider* CNcdProviderManager::Provider( 

    const MCatalogsContext& aContext ) const

    {

    TInt index = FindFamily( aContext );

    CNcdProvider* provider = NULL;

    if ( index != KErrNotFound )

        {

        provider = iProviders[ index ];

        }

    return provider;

    }

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

// 

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

// 

void CNcdProviderManager::ProviderClosed( CNcdProvider& aProvider )

    {

    DLTRACEIN((""));

    TInt index = iProviders.Find( &aProvider );

    if ( index != KErrNotFound )

        {

        DLTRACE(("Removing provider: %x", &aProvider));

        iProviders.Remove( index );

        }

    }

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

// 

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

// 

TInt CNcdProviderManager::FindFamily( const MCatalogsContext& aContext ) const

    {

    TInt count = iProviders.Count();

    TInt index = KErrNotFound;

    while( count-- ) 

        {

        if ( aContext.FamilyId() == iProviders[ count ]->FamilyId() ) 

            {

            index = count;

            break;

            }

        }

    return index;

    }

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

// 

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

// 

HBufC* CNcdProviderManager::WritableEnginePathL( RFs& aFs )

    {

    DLTRACEIN( ( "" ) );    

    // Determine the installation path from the location of the 

    // engine's config file

    HBufC* fullPath = FindEngineFileL( aFs, KCatalogsConfigFile );    

    TParsePtrC parse( *fullPath );

    TPath path( parse.DriveAndPath() );

    delete fullPath;

    if ( path.Length() < 1 )

        {    

        DLERROR(("No path"));

        User::Leave( KErrArgument );

        }

    // If it is in ROM, default to C.        

    if ( IsRomDriveL( aFs, path[0] ) )

        {

        DLTRACE(("Config on ROM, use C:"));

        path[0] = DriveToCharL( EDriveC );        

        }

    TDriveName drive;

    drive.Append( path[0] );

    drive.Append( KDriveDelimiter );

    CreatePrivatePathL( aFs, drive, path );

    BaflUtils::EnsurePathExistsL( aFs, path );

    DLTRACEOUT( ( _L("Path: %S"), &path ) );

    return path.AllocL();

    }