/*

* Copyright (c) 2005-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 server application contact store manager.

*

*/

#include "CPbk2ServerAppStoreManager.h"

// Phonebook 2

#include "mpbk2serverappstartupobserver.h"

#include "CPbk2ServerAppMonitor.h"

#include "CPbk2ServerAppAppUi.h"

#include <CPbk2StoreProperty.h>

#include <CPbk2StorePropertyArray.h>

#include <CPbk2StoreManager.h>

#include <CPbk2ContactViewBuilder.h>

#include <CPbk2StoreConfiguration.h>

#include <CPbk2SortOrderManager.h>

#include <Pbk2StoreProperty.hrh>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactStore.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkContactStoreUris.h>

#include <MVPbkContactViewBase.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactLinkArray.h>

#include <CVPbkSortOrderAcquirer.h>

#include <VPbkSortOrderAcquirerUid.h>

#include <MVPbkBaseContact.h>

#include <MVPbkContactSelector.h>

// Debugging headers

#include <Pbk2Debug.h>

#include <featmgr.h>

/// Unnamed namespace for local definitions

namespace {

_LIT( KGroupSortOrderDisplayName, "AllGroups" );

/**

 * Custom cleanup function.

 *

 * @param aObj  Object to clean.

 */

void CleanupResetAndDestroy( TAny* aObj )

    {

    if ( aObj )

        {

        static_cast<RImplInfoPtrArray*>( aObj )->ResetAndDestroy();

        }

    }

} /// namespace

/**

 * Helper class to filter mycard from phonebooks views

 */

class CPbk2MyCardFilter : public CBase, 

                          public MVPbkContactSelector

    {

public:

    CPbk2MyCardFilter();

    ~CPbk2MyCardFilter();

protected:  // From MVPbkContactSelector

    TBool IsContactIncluded(

                const MVPbkBaseContact& aContact );

    };

CPbk2MyCardFilter::CPbk2MyCardFilter()

    {

    }

CPbk2MyCardFilter::~CPbk2MyCardFilter()

    {

    }

TBool CPbk2MyCardFilter::IsContactIncluded(

                const MVPbkBaseContact& aContact )

    {

    TBool isContactIncluded( ETrue );

    // this is temporary solution to hide own contact from phonebook contacts list,

    // TODO remove this code when we can hide own contact with contact model

    MVPbkBaseContact& contact = const_cast<MVPbkBaseContact&>( aContact );

    TAny* extension = contact.BaseContactExtension( 

                KVPbkBaseContactExtension2Uid );

    if( extension )

        {

        MVPbkBaseContact2* baseContactExtension =

                static_cast<MVPbkBaseContact2*>( extension );

        TInt error( KErrNone );

        isContactIncluded =

                ( !baseContactExtension->IsOwnContact( error ) );

        }

    return isContactIncluded;

    }

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

// CPbk2ServerAppStoreManager::CPbk2ServerAppStoreManager

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

//

CPbk2ServerAppStoreManager::CPbk2ServerAppStoreManager

        ( CPbk2StoreManager& aStoreManager,

          CVPbkContactManager& aContactManager ) :

            iStoreManager( aStoreManager ),

            iContactManager( aContactManager )

    {

    }

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

// CPbk2ServerAppStoreManager::~CPbk2ServerAppStoreManager

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

//

CPbk2ServerAppStoreManager::~CPbk2ServerAppStoreManager()

    {

    iStoreManager.DeregisterStoreEvents( *this );

    iOpenedStores.Reset();

    iOpenedStores.Close();

    delete iSortOrderAcquirer;

    delete iMonitor;

    delete iFetchView;

    }

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

// CPbk2ServerAppStoreManager::ConstructL

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

//

void CPbk2ServerAppStoreManager::ConstructL()

    {

    iStoreManager.RegisterStoreEventsL( *this );

    }

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

// CPbk2ServerAppStoreManager::NewL

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

//

CPbk2ServerAppStoreManager* CPbk2ServerAppStoreManager::NewL

        ( CPbk2StoreManager& aStoreManager,

          CVPbkContactManager& aContactManager )

    {

    CPbk2ServerAppStoreManager* self =

        new ( ELeave ) CPbk2ServerAppStoreManager

            ( aStoreManager, aContactManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ServerAppStoreManager::LoadAndOpenContactStoresL

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

//

void CPbk2ServerAppStoreManager::LoadAndOpenContactStoresL

        ( CVPbkContactStoreUriArray& aStoreUris,

          MPbk2ServerAppStartupObserver& aObserver,

          TBool aLoadSavingMemoriesAlways )

    {

    if ( aLoadSavingMemoriesAlways )

        {

        TVPbkContactStoreUriPtr ptr

            ( VPbkContactStoreUris::DefaultCntDbUri() );

        if ( !aStoreUris.IsIncluded( ptr ) )

            {

            iContactManager.LoadContactStoreL( ptr );

            }

        iStoreManager.EnsureDefaultSavingStoreIncludedL();

        }

    const TInt count( aStoreUris.Count() );

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

        {

        iContactManager.LoadContactStoreL( aStoreUris[i] );

        }

    iMonitor = CPbk2ServerAppMonitor::NewL

        ( iContactManager.ContactStoresL(), aObserver );

    iMonitor->RegisterEventsL( aObserver );

    iMonitor->StartupBeginsL();

    iStoreManager.OpenStoresL();

    }

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

// CPbk2ServerAppStoreManager::BuildFetchViewL

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

//

MVPbkContactViewBase* CPbk2ServerAppStoreManager::BuildFetchViewL

        ( TVPbkContactViewType aViewType,

          const CVPbkContactStoreUriArray& aStoreUris,

          CVPbkFieldTypeSelector* aViewFilter,

          CPbk2StorePropertyArray& aStoreProperties,

          const CPbk2SortOrderManager& aSortOrderManager,

          const TUint32 aFlags )

    {

    MVPbkContactViewBase* result = NULL;

    CPbk2ContactViewBuilder* viewBuilder = CPbk2ContactViewBuilder::NewLC

        ( iContactManager, aStoreProperties );

    if( !iMyCardFilter )

        {

        FeatureManager::InitializeLibL();

        if( FeatureManager::FeatureSupported( KFeatureIdffContactsMycard ) )

            {

            iMyCardFilter = new (ELeave) CPbk2MyCardFilter();

            }

        FeatureManager::UnInitializeLib();    

        }

    if ( aViewType == EVPbkContactsView )

        {

        result = viewBuilder->CreateContactViewForStoresLC

            ( aStoreUris, *this, aSortOrderManager.SortOrder(),

              aViewFilter, aFlags, iMyCardFilter );

        CleanupStack::Pop(); // result

        }

    else if ( aViewType == EVPbkGroupsView )

        {

        const MVPbkFieldTypeList* sortOrder = NULL;

        // Acquire group sort order

        RImplInfoPtrArray implementations;

        REComSession::ListImplementationsL

            ( TUid::Uid( KVPbkSortOrderAcquirerInterfaceUID ), implementations );

        CleanupStack::PushL( TCleanupItem

                ( CleanupResetAndDestroy, &implementations ) );

        TBool found = EFalse;

        const TInt count = implementations.Count();

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

            {

            CImplementationInformation* implInfo = implementations[i];

            if ( implInfo->DisplayName().

                    CompareC( KGroupSortOrderDisplayName ) == 0 )

                {

                TUid implUid = implInfo->ImplementationUid();

                CVPbkSortOrderAcquirer::TSortOrderAcquirerParam param

                    ( iContactManager.FieldTypes() );

                delete iSortOrderAcquirer;

                iSortOrderAcquirer = NULL;

                iSortOrderAcquirer = CVPbkSortOrderAcquirer::NewL

                    ( implUid, param );

                sortOrder = &iSortOrderAcquirer->SortOrder();

                found = ETrue;

                }

            }

        CleanupStack::PopAndDestroy(); // implementations

        result = viewBuilder->CreateGroupViewForStoresLC

            ( aStoreUris, *this, *sortOrder,

              aViewFilter, aFlags );

        CleanupStack::Pop(); // result

        }

    CleanupStack::PopAndDestroy(); // viewBuilder

    return result;

    }

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

// CPbk2ServerAppStoreManager::RemoveReadOnlyStoreUris

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

//

void CPbk2ServerAppStoreManager::RemoveReadOnlyStoreUris

        ( CVPbkContactStoreUriArray& aStoreUriArray,

          CPbk2StorePropertyArray& aStoreProperties ) const

    {

    // Browse the list backwards

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

        {

        const CPbk2StoreProperty* storeProperty =

            aStoreProperties.FindProperty( aStoreUriArray[i] );

        if ( storeProperty && !( storeProperty->Flags() & KPbk2DefaultSavingStorageItem ) )

            {

            // Remove read only URI from the array

            aStoreUriArray.Remove( aStoreUriArray[i] );

            }

        }

    }

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

// CPbk2ServerAppStoreManager::IsContactIncludedInCurrentConfigurationL

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

//

TBool CPbk2ServerAppStoreManager::IsContactIncludedInCurrentConfigurationL

        ( const MVPbkStoreContact& aContact,

          const CPbk2StoreConfiguration& aStoreConfiguration ) const

    {

    TBool result = EFalse;

    TVPbkContactStoreUriPtr contactUri =

        aContact.ParentStore().StoreProperties().Uri();

    CVPbkContactStoreUriArray* currentConfig =

        aStoreConfiguration.CurrentConfigurationL();

    CleanupStack::PushL( currentConfig );

    if ( currentConfig->IsIncluded( contactUri ) )

        {

        result = ETrue;

        }

    CleanupStack::PopAndDestroy( currentConfig );

    return result;

    }

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

// CPbk2ServerAppStoreManager::ContactsAvailableL

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

//

TBool CPbk2ServerAppStoreManager::ContactsAvailableL

        ( const MVPbkContactLinkArray& aContactLinks ) const

    {

    TBool ret = ETrue;

    CVPbkContactStoreUriArray* validStores = CurrentlyValidStoresL();

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

        {

        const MVPbkContactLink& link = aContactLinks.At( i );

        if ( !validStores->IsIncluded

                ( link.ContactStore().StoreProperties().Uri() ) )

            {

            ret = EFalse;

            break;

            }

        }

    delete validStores;

    return ret;

    }

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

// CPbk2ServerAppStoreManager::CurrentlyValidStoresL

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

//

CVPbkContactStoreUriArray*

        CPbk2ServerAppStoreManager::CurrentlyValidStoresL() const

    {

    CVPbkContactStoreUriArray* uris = CVPbkContactStoreUriArray::NewLC();

    const TInt count = iOpenedStores.Count();

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

        {

        uris->AppendL( iOpenedStores[i]->StoreProperties().Uri() );

        }

    CleanupStack::Pop( uris );

    return uris;

    }

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

// CPbk2ServerAppStoreManager::ContactViewReady

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

//

void CPbk2ServerAppStoreManager::ContactViewReady

        ( MVPbkContactViewBase& /*aView*/ )

    {

    // Do nothing

    }

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

// CPbk2ServerAppStoreManager::ContactViewUnavailable

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

//

void CPbk2ServerAppStoreManager::ContactViewUnavailable

        ( MVPbkContactViewBase& /*aView*/ )

    {

    // Do nothing

    }

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

// CPbk2ServerAppStoreManager::ContactAddedToView

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

//

void CPbk2ServerAppStoreManager::ContactAddedToView

        ( MVPbkContactViewBase& /*aView*/, TInt /*aIndex*/,

          const MVPbkContactLink& /*aContactLink*/ )

    {

    // Do nothing

    }

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

// CPbk2ServerAppStoreManager::ContactRemovedFromView

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

//

void CPbk2ServerAppStoreManager::ContactRemovedFromView

        ( MVPbkContactViewBase& /*aView*/, TInt /*aIndex*/,

          const MVPbkContactLink& /*aContactLink*/ )

    {

    // Do nothing

    }

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

// CPbk2ServerAppStoreManager::ContactViewError

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

//

void CPbk2ServerAppStoreManager::ContactViewError

        ( MVPbkContactViewBase& /*aView*/, TInt /*aError*/,

          TBool /*aErrorNotified*/ )

    {

    // Do nothing

    }

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

// CPbk2ServerAppStoreManager::StoreReady

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

//

void CPbk2ServerAppStoreManager::StoreReady

        ( MVPbkContactStore& aContactStore )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

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

        &aContactStore);

    // Add the store to the open stores list

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

        {

        iOpenedStores.Append( &aContactStore );

        }

    }

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

// CPbk2ServerAppStoreManager::StoreUnavailable

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

//

void CPbk2ServerAppStoreManager::StoreUnavailable

        ( MVPbkContactStore& aContactStore, TInt aReason )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

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

        &aContactStore, aReason);

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

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

    if ( index != KErrNotFound )

        {

        iOpenedStores.Remove( index );

        }

    }

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

// CPbk2ServerAppStoreManager::HandleStoreEventL

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

//

void CPbk2ServerAppStoreManager::HandleStoreEventL

        ( MVPbkContactStore& /*aContactStore*/,

          TVPbkContactStoreEvent /*aEvent*/ )

    {

    // Do nothing

    }

// End of File