/*

* Copyright (c) 2002-2007 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:  Phonebook 2 store manager.

*

*/

// INCLUDE FILES

#include <CPbk2StoreManager.h>

// Phonebook 2

#include "CPbk2CompressPolicyManager.h"

#include <CPbk2StoreConfiguration.h>

#include <RPbk2LocalizedResourceFile.h>

#include <Pbk2DataCaging.hrh>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <CVPbkContactStoreUriArray.h>

#include <TVPbkContactStoreUriPtr.h>

// System includes

#include <barsread.h>

#include <coemain.h>

#include <aknnotewrappers.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

/**

 * Checks is the error received from the database at the open

 * fatal or not.

 *

 * @param aError    Error code.

 * @return  ETrue if the error is a fatal one.

 */

TBool IsFatalDbOpenError( TInt aError )

    {

    TBool ret = ETrue;

    switch ( aError )

        {

        case KErrNone:              // FALLTHROUGH

        case KErrCancel:            // FALLTHROUGH

        case KErrNoMemory:          // FALLTHROUGH

        case KErrNotSupported:      // FALLTHROUGH

        case KErrArgument:          // FALLTHROUGH

        case KErrDied:              // FALLTHROUGH

        case KErrInUse:             // FALLTHROUGH

        case KErrServerTerminated:  // FALLTHROUGH

        case KErrServerBusy:        // FALLTHROUGH

        case KErrNotReady:          // FALLTHROUGH

        case KErrAccessDenied:      // FALLTHROUGH

        case KErrLocked:            // FALLTHROUGH

        case KErrWrite:             // FALLTHROUGH

        case KErrDisMounted:        // FALLTHROUGH

        case KErrDiskFull:          // FALLTHROUGH

        case KErrAbort:             // FALLTHROUGH

        case KErrBadPower:          // FALLTHROUGH

        case KErrDirFull:           // FALLTHROUGH

        case KErrHardwareNotAvailable:

            {

            ret = EFalse;

            break;

            }

        default:

            {

            // All error codes not handled above end up here,

            // especially KErrCorrupt

            break;

            }

        }

    return ret;

    }

} /// namespace

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

// CPbk2StoreManager::CPbk2StoreManager

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

//

inline CPbk2StoreManager::CPbk2StoreManager

        ( CVPbkContactManager& aContactManager,

          CPbk2StoreConfiguration& aStoreConfiguration,

          TBool aActOnConfigurationEvents ) :

            iContactManager( aContactManager ),

            iStoreConfiguration( aStoreConfiguration ),

            iActOnConfigurationEvents( aActOnConfigurationEvents )

    {

    }

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

// CPbk2StoreManager::~CPbk2StoreManager

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

//

CPbk2StoreManager::~CPbk2StoreManager()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::~CPbk2StoreManager(0x%x)"), this);

    if ( iContactStores )

        {

        iContactStores->CloseAll(*this);

        }

    iFailedStores.Reset();

    iFailedStores.Close();

    iOpenedStores.Reset();

    iOpenedStores.Close();

    iStoreObservers.Reset();

    iStoreObservers.Close();

    delete iCompressPolicy;

    }

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

// CPbk2StoreManager::ConstructL

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

//

inline void CPbk2StoreManager::ConstructL()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::ConstructL(0x%x)"), this);

    iStoreConfiguration.AddObserverL( *this );

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::ConstructL(0x%x) Store configuration created"),

        this);

    iCompressPolicy =

        CPbk2CompressPolicyManager::NewL( *this, iContactManager );

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::ConstructL(0x%x) end"), this);

    }

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

// CPbk2StoreManager::NewL

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

//

EXPORT_C CPbk2StoreManager* CPbk2StoreManager::NewL

        ( CVPbkContactManager& aContactManager,

          CPbk2StoreConfiguration& aStoreConfiguration,

          TBool aActOnConfigurationEvents )

    {

    CPbk2StoreManager* self = new (ELeave) CPbk2StoreManager

        ( aContactManager, aStoreConfiguration, aActOnConfigurationEvents );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2StoreManager::OpenStoresL

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

//

EXPORT_C void CPbk2StoreManager::OpenStoresL()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::OpenStoresL"));

    if (iContactStores)

        {

        iContactStores->CloseAll(*this);

        }

    iContactStores = &iContactManager.ContactStoresL();

    if (iContactStores)

        {

        iContactStores->OpenAllL(*this);

        }

    }

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

// CPbk2StoreManager::EnableCompression

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

//

EXPORT_C void CPbk2StoreManager::EnableCompression(TBool aEnable)

    {

    if (aEnable)

        {

        iCompressPolicy->StartAllPolicies();

        }

    else

        {

        iCompressPolicy->StopAllPolicies();

        }

    }

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

// CPbk2StoreManager::EnsureDefaultSavingStoreIncludedL

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

//

EXPORT_C void CPbk2StoreManager::EnsureDefaultSavingStoreIncludedL()

    {

    iStoreConfiguration.AddDefaultSavingStoreObserverL( *this );

    iContactManager.LoadContactStoreL

        ( iStoreConfiguration.DefaultSavingStoreL() );

    }

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

// CPbk2StoreManager::EnsureDefaultSavingStoreIncludedL

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

//

EXPORT_C void CPbk2StoreManager::EnsureCurrentConfigurationStoresIncludedL()

    {

    CVPbkContactStoreUriArray* uriArray =

        iStoreConfiguration.CurrentConfigurationL();

    CleanupStack::PushL( uriArray );

    TInt count( uriArray->Count() );

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

        {

        iContactManager.LoadContactStoreL( (*uriArray)[i] );

        }

    CleanupStack::PopAndDestroy( uriArray );

    }

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

// CPbk2StoreManager::RegisterStoreEventsL

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

//

void CPbk2StoreManager::RegisterStoreEventsL

        (const MVPbkContactStoreObserver& aObserver)

    {

    User::LeaveIfError( iStoreObservers.Append( &aObserver ) );

    }

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

// CPbk2StoreManager::DeregisterStoreEvents

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

//

void CPbk2StoreManager::DeregisterStoreEvents

        (const MVPbkContactStoreObserver& aObserver)

    {

    const TInt index = iStoreObservers.Find( &aObserver );

    if ( index > KErrNotFound )

        {

        iStoreObservers.Remove( index );

        }

    }

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

// CPbk2StoreManager::CurrentlyValidStoresL

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

//

CVPbkContactStoreUriArray* CPbk2StoreManager::CurrentlyValidStoresL() const

    {

    CVPbkContactStoreUriArray* uris = CurrentlyValidShownStoresL();

    CleanupStack::PushL( uris );

    // If default saving store is not part of current config,

    // check if it still valid store

    TVPbkContactStoreUriPtr defaultSavingStoreUri =

        iStoreConfiguration.DefaultSavingStoreL();

    if ( !uris->IsIncluded( defaultSavingStoreUri ))

        {

        // Default store is not in the uris array

        MVPbkContactStore* defaultStore =

            iContactStores->Find( defaultSavingStoreUri );

        // Add the default saving store to the list

        // if it is loaded, opened and not failed

        if ( defaultStore && IsStoreOpen(*defaultStore)

            && iFailedStores.Find( defaultStore ) == KErrNotFound )

            {

            // Default saving store is valid store and successfully opened

            uris->AppendL( defaultSavingStoreUri );

            }

        }

    CleanupStack::Pop( uris );

    return uris;

    }

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

// CPbk2StoreManager::CurrentlyValidShownStoresL

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

//

CVPbkContactStoreUriArray*

        CPbk2StoreManager::CurrentlyValidShownStoresL() const

    {

    // Gets the list of URI's that compose the current configuration

    CVPbkContactStoreUriArray* uris =

        iStoreConfiguration.CurrentConfigurationL();

    // Remove stores that are not open or are unavailable from the list

    const TInt count = uris->Count();

    for (TInt i = count - 1; i >= 0; --i)

        {

        TVPbkContactStoreUriPtr uri = (*uris)[i];

        MVPbkContactStore* store = iContactStores->Find(uri);

        if ( !(store && IsStoreOpen( *store ) &&

             ( iFailedStores.Find( store ) == KErrNotFound ) ) )

            {

            // When the store is loaded, opened and not failed

            // it is not removed from the URI list

            uris->Remove(uri);

            }

        }

    return uris;

    }

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

// CPbk2StoreManager::OpenComplete

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

//

void CPbk2StoreManager::OpenComplete()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::OpenComplete"));

    }

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

// CPbk2StoreManager::StoreReady

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

//

void CPbk2StoreManager::StoreReady(

        MVPbkContactStore& aContactStore)

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::StoreReady(0x%x)"),

        &aContactStore);

    // If the store was on the failed list, remove it

    // from there

    const TInt index = iFailedStores.Find(&aContactStore);

    if (index != KErrNotFound)

        {

        iFailedStores.Remove(index);

        }

    // Add it to the open stores list

    if (iOpenedStores.Find(&aContactStore) == KErrNotFound)

        {

        iOpenedStores.Append(&aContactStore);

        }

    // Notify observers

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

        {

        iStoreObservers[i]->StoreReady(aContactStore);

        }

    }

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

// CPbk2StoreManager::StoreUnavailable

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

//

void CPbk2StoreManager::StoreUnavailable

        ( MVPbkContactStore& aContactStore, TInt aReason )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::StoreUnavailable(0x%x,%d)"),

        &aContactStore, aReason);

    // If the store is not found from the failed list,

    // add it there and try to replace it.

    // If the replace fails, the store will be found from the

    // failed list, and the replace is not called again.

    TBool informObservers = ETrue;

    if ( iFailedStores.Find( &aContactStore ) == KErrNotFound )

        {

        iFailedStores.Append( &aContactStore );

        if ( IsFatalDbOpenError( aReason ) )

            {

            informObservers = EFalse; // inform only if the replace fails too

            TRAPD( err, ReplaceStoreL( aContactStore ) );

            if ( err != KErrNone )

                {

                informObservers = ETrue;

                CCoeEnv::Static()->HandleError( err );

                }

            }

        }

    // Remove the store from the open store list if it is there

    const TInt index = iOpenedStores.Find( &aContactStore );

    if ( index != KErrNotFound )

        {

        iOpenedStores.Remove( index );

        }

    // Notify observers

    if ( informObservers )

        {

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

            {

            iStoreObservers[i]->StoreUnavailable( aContactStore, aReason );

            }

        }

    }

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

// CPbk2StoreManager::HandleStoreEventL

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

//

void CPbk2StoreManager::HandleStoreEventL

        ( MVPbkContactStore& aContactStore,

          TVPbkContactStoreEvent aEvent )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::HandleStoreEventL(0x%x,%d)"),

        &aContactStore, aEvent.iEventType);

    // Notify observers

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

        {

        iStoreObservers[i]->HandleStoreEventL(aContactStore, aEvent);

        }

    }

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

// CPbk2StoreManager::ConfigurationChanged

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

//

void CPbk2StoreManager::ConfigurationChanged()

    {

    if ( iActOnConfigurationEvents )

        {

        TRAPD( err, HandleConfigurationChangedL() );

        if ( err != KErrNone )

            {

            CCoeEnv::Static()->HandleError( err );

            }

        }

    }

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

// CPbk2StoreManager::ConfigurationChangedComplete

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

//

void CPbk2StoreManager::ConfigurationChangedComplete()

    {

    if ( iActOnConfigurationEvents )

        {

        TRAPD( err,CloseUnnecessaryStoresL() );

        if ( err != KErrNone )

            {

            CCoeEnv::Static()->HandleError( err );

            }

        }

    }

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

// CPbk2StoreManager::SavingStoreChanged

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

//

void CPbk2StoreManager::SavingStoreChanged()

    {

    TRAPD(err,HandleSavingStoreChangedL());

    if (err != KErrNone)

        {

        CCoeEnv::Static()->HandleError(err);

        }

    }

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

// CPbk2StoreManager::HandleConfigurationChangedL

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

//

void CPbk2StoreManager::HandleConfigurationChangedL()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StoreManager::HandleConfigurationChangedL(0x%x)"),

        this);

    EnsureCurrentConfigurationLoadedAndOpenL();

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ( "CPbk2StoreManager::HandleConfigurationChangedL(0x%x) end" ),

            this );

    }

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

// CPbk2StoreManager::EnsureCurrentConfigurationLoadedAndOpenL

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

//

void CPbk2StoreManager::EnsureCurrentConfigurationLoadedAndOpenL()

    {

    CVPbkContactStoreUriArray* supportedConfiguration =

            iStoreConfiguration.SupportedStoreConfigurationL();

    CleanupStack::PushL(supportedConfiguration);

    CVPbkContactStoreUriArray* currentConfiguration =

            iStoreConfiguration.CurrentConfigurationL();

    CleanupStack::PushL(currentConfiguration);

    MVPbkContactStoreList& storeList = iContactManager.ContactStoresL();

    const TInt supportedCount = supportedConfiguration->Count();

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

        {

        // loop through the supported configurations and load and open

        // all stores that are not part of the current configuration

        TVPbkContactStoreUriPtr supportedStore = (*supportedConfiguration)[i];

        if (currentConfiguration->IsIncluded(supportedStore))

            {

            // if the supported store is not loaded, then load it

            if ( !storeList.Find(supportedStore) )

                {

                iContactManager.LoadContactStoreL(supportedStore);

                }

            // if the supported store is not open, then open it

            MVPbkContactStore* store = storeList.Find(supportedStore);