/*

* Copyright (c) 2006 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:  

*

*/

#include <f32file.h>

#include "ncdstoragemanagerimpl.h"

#include "ncdstorageimpl.h"

#include "ncdstorageclientimpl.h"

#include "ncdproviderdefines.h"

#include "catalogsconstants.h"

#include "catalogsdebug.h"

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

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

// ConstructL

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

//

void CNcdStorageManager::ConstructL( const TDesC& aRootDirectory )

    {

    DLTRACEIN( ("") );    

    iRootDir.CreateL( aRootDirectory );    

    iFileMan = CFileMan::NewL( iFs );    

    DLTRACEOUT( ("" ) );

    }

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

// NewL

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

//

CNcdStorageManager* CNcdStorageManager::NewL( 

    RFs& aFs,

    const TDesC& aRootDirectory )

    {

    CNcdStorageManager* self = new (ELeave ) CNcdStorageManager( aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aRootDirectory );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CNcdStorageManager::~CNcdStorageManager()

    {

    DLTRACEIN( ( "" ) );

    iClients.ResetAndDestroy();    

    delete iFileMan;   

    iRootDir.Close();

    }

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

// CreateOrGetStorageL

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

//

MNcdStorage& CNcdStorageManager::CreateOrGetStorageL( const TDesC& aClientUid, 

    const TDesC& aNamespace )

    {

    DLTRACEIN((""));

    MNcdStorage* storage = NULL;

    TRAPD( err,        

           storage =

           &StorageL( aClientUid, aNamespace ) );

    if ( err == KErrNotFound ) 

        {

        DLINFO(("Creating storage for the client"));

        storage = 

            &CreateStorageL( aClientUid, 

                             aNamespace );

        }

    else if ( err != KErrNone )

        {

        DLERROR(("Leaving: %i", err));

        User::Leave( err );   

        }

    DLTRACEOUT((""));

    return *storage;    

    }

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

// CreateStorageL

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

//

MNcdStorage& CNcdStorageManager::CreateStorageL( const TDesC& aClientUid, 

    const TDesC& aNamespace )

    {

    DLTRACEIN( ("") );

    TInt index = FindClientByUid( aClientUid );

    CNcdStorageClient* client = NULL;

    if ( index == KErrNotFound ) 

        {

        DLTRACE( ("Create a new client") );

        // Create a new client

        client = CNcdStorageClient::NewLC( *this, aClientUid );

        iClients.AppendL( client );

        CleanupStack::Pop( client );

        }

    else 

        {

        DLTRACE( ("Use an existing client") );

        // Use existing client

        client = iClients[ index ];

        DASSERT( client );

        }

    // Create the storage

    MNcdStorage& storage = client->CreateStorageL( aNamespace );

    DLTRACEOUT( ("") );

    return storage;                

    }

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

// Provider storage getter

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

//

MNcdStorage& CNcdStorageManager::ProviderStorageL( const TDesC& aClientUid )

    {

    return CreateOrGetStorageL( 

        aClientUid, 

        NcdProviderDefines::KProviderStorageNamespace );

    }

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

// Storage getter

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

//

MNcdStorage& CNcdStorageManager::StorageL( const TDesC& aClientUid, 

    const TDesC& aNamespace )

    {

    DLTRACEIN( ("") );

    TInt index = FindClientByUidL( aClientUid );

    return iClients[index]->StorageL( aNamespace );

    }

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

// Storage client namespace list getter

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

//

MDesCArray* CNcdStorageManager::StorageNamespacesLC( 

    const TDesC& aClientUid ) const

    {

    TInt index = FindClientByUidL( aClientUid );

    return iClients[index]->NamespacesLC();

    }

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

// Storage client getter

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

//

MNcdStorageClient& CNcdStorageManager::StorageClientL( 

    const TDesC& aClientUid )

    {

    TInt index = FindClientByUid( aClientUid );

    if ( index == KErrNotFound ) 

        {

        // Create a new client

        CNcdStorageClient* client = CNcdStorageClient::NewLC( *this, aClientUid );

        iClients.AppendL( client );

        CleanupStack::Pop( client );

        return *client;

        }

    return *iClients[ index ];

    }

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

// Client remover

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

//

/*

void CNcdStorageManager::RemoveClientL( const TDesC& aClientUid )

    {    

    DLTRACEIN( ("") );

    TInt index = KErrNone;

    TRAPD( err, index = FindClientByUidL( aClientUid ) );

    if ( err == KErrNotFound ) 

        {

        // Create storage client temporarily.

        CNcdStorageClient* client = CNcdStorageClient::NewLC( *this, aClientUid );

        iClients.AppendL( client );

        CleanupStack::Pop( client );

        index = iClients.Count() - 1;

        }

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL( KMaxPath );

    iClients[index]->AppendRoot( path );

    DLINFO( ( _L("Removing client: %S"), &path ) );

    delete iClients[index];

    iClients.Remove( index );

    // Remove client's directory

    RemoveDirectoryL( iFs, path );

    CleanupStack::PopAndDestroy( &path );

    DLTRACEOUT((""));

    }

*/    

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

// Storage remover

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

//

void CNcdStorageManager::RemoveStorageL( const TDesC& aClientUid, 

    const TDesC& aNamespace)

    {

    DLTRACEIN( ("") );

    TInt index = KErrNone;

    TRAPD( err, index = FindClientByUidL( aClientUid ) );

    if ( err == KErrNotFound ) 

        {

        // Create storage client.

        CNcdStorageClient* client = CNcdStorageClient::NewLC( *this, aClientUid );

        iClients.AppendL( client );

        CleanupStack::Pop( client );

        index = iClients.Count() - 1;

        }

    // Removes the actual storage directory

    TRAP( err, iClients[ index ]->RemoveStorageL( aNamespace ) );

    if ( err != KErrNotFound ) 

        {

        User::LeaveIfError( err );

        }

    DLTRACEOUT( ( "" ) );

    }

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

// Close

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

//

void CNcdStorageManager::CloseClient( const TDesC& aClientUid )

    {

    DLTRACEIN((""));

    TInt index = FindClientByUid( aClientUid );

    if ( index != KErrNotFound )

        {

        delete iClients[ index ];

        iClients.Remove( index );

        }

    }

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

// File session getter

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

//

RFs& CNcdStorageManager::FileSession()

    {

    DLTRACEIN((""));

    return iFs;

    }

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

// Prepends root dir to the des

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

//

void CNcdStorageManager::AppendRoot( TDes& aPath ) const

    {

    DLTRACEIN((""));

    aPath.Append( iRootDir );

    DLTRACEOUT((""));

    }

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

// File manager getter

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

//

CFileMan& CNcdStorageManager::FileManager()

    {

    DASSERT( iFileMan );

    return *iFileMan;

    }

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

// Utility function for removing a directory

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

//

void CNcdStorageManager::RemoveDirectoryL( RFs& aFileSession, 

    const TDesC& aDirectory )

    {

    CFileMan* fileman = CFileMan::NewL( aFileSession );

    CleanupStack::PushL( fileman );

    User::LeaveIfError( fileman->RmDir( aDirectory ) );    

    CleanupStack::PopAndDestroy( fileman );    

    }

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

// Constructor

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

//

CNcdStorageManager::CNcdStorageManager( RFs& aFs ) : iFs( aFs )

    {

    }

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

//  Searches for the storage client by uid

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

//

TInt CNcdStorageManager::FindClientByUidL( const TDesC& aUid ) const

    {

    DLTRACEIN(( _L("Uid: %S"), &aUid ));

    TInt index = FindClientByUid( aUid );    

    User::LeaveIfError( index );

    return index;

    }

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

//  Searches for the storage client by uid

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

//

TInt CNcdStorageManager::FindClientByUid( const TDesC& aUid ) const

    {

    DLTRACEIN(( _L("Uid: %S"), &aUid ));

    TInt count = iClients.Count();

    for ( TInt i = 0; i < count; ++i ) 

        {

        if ( iClients[ i ]->ClientUid().Compare( aUid ) == 0 ) 

            {

            DLTRACEOUT(("index: %d", i));

            return i;

            }

        }

    DLTRACEOUT(("Err: -1"));    

    return KErrNotFound;

    }