/*

* Copyright (c) 2010 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:  Easy dialing contact data manager.

*

*/

#include <e32std.h>

#include <fbs.h>

#include <CPbk2ImageManager.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactLink.h>

#include <CPbk2StoreConfiguration.h>

#include <CVPbkContactStoreUriArray.h>

#include <VPbkContactStoreUris.h>

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkTopContactManager.h>

#include <MVPbkContactOperationBase.h>

#include <TVPbkStoreContactAnalyzer.h>

#include <MVPbkFieldType.h>

#include <VPbkEng.rsg>

#include <MVPbkContactViewBase.h>

#include <MVPbkBaseContactFieldCollection.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldData.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkOperationObserver.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkStoreContact.h>

#include <PbkGlobalSettingFactory.h>

#include <centralrepository.h>

#include "easydialingcontactdata.h"

#include "easydialingcontactdatamanager.h"

#include "easydialingutils.h"

#include "mcontactdatamanagerobserver.h"

#include "easydialingcrkeys.h"

#include "easydialinglogger.h"

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

// CEasyDialingContactDataManager::NewL

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

//

CEasyDialingContactDataManager* CEasyDialingContactDataManager::NewL()

    {

    CEasyDialingContactDataManager* self = 

            new ( ELeave ) CEasyDialingContactDataManager();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CEasyDialingContactDataManager::CEasyDialingContactDataManager

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

//

CEasyDialingContactDataManager::CEasyDialingContactDataManager()

        : iPbkStoreConfiguration(NULL), 

          iImageOperation(NULL), 

          iContactManager(NULL), 

          iContactOperation(NULL),

          iContactThumbnailSetting(ETrue), 

          iStoreReady(EFalse)

    {

    }

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

// CEasyDialingContactDataManager::~CEasyDialingContactDataManager

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

//

CEasyDialingContactDataManager::~CEasyDialingContactDataManager()

    {

    Reset();

    iWaitingContacts.Close();

    iContactDataArray.Close();

    delete iImageManager;

    delete iVPbkTopContactManager;

    delete iImageOperation;

    delete iContactOperation;

    delete iFavsView;

    if ( iContactManager )

        {

        TRAP_IGNORE( iContactManager->ContactStoresL().CloseAll( *this ) );

        }

    delete iContactManager;

    if ( iPbkStoreConfiguration )

        {

        iPbkStoreConfiguration->RemoveObserver( *this );

        }

    delete iPbkStoreConfiguration;

    if ( iPbkSettings )

        {

        iPbkSettings->Close();

        }

    delete iPbkSettings;

    }

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

// CEasyDialingContactDataManager::ConstructL

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

//

void CEasyDialingContactDataManager::ConstructL()

    {

    // Create contact store configuration handler

    iPbkStoreConfiguration = CPbk2StoreConfiguration::NewL();

    iPbkStoreConfiguration->AddObserverL( *this );

    // Create manager for all the supported contact stores

    CVPbkContactStoreUriArray* supportedStores = 

            iPbkStoreConfiguration->SupportedStoreConfigurationL();

    CleanupStack::PushL( supportedStores );

    iContactManager = CVPbkContactManager::NewL( *supportedStores );

    CleanupStack::PopAndDestroy( supportedStores );

    // Open the stores and start observing them

    iContactManager->ContactStoresL().OpenAllL( *this );

    iImageManager = CPbk2ImageManager::NewL(*iContactManager);

    iVPbkTopContactManager = CVPbkTopContactManager::NewL( *iContactManager );

    iImageManagerParams.iFlags = TPbk2ImageManagerParams::EScaleImage | TPbk2ImageManagerParams::EKeepAspectRatio;

    iThumbnailFieldType = iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_THUMBNAILPIC );

    // Read easydialing setting from cenrep.

    CRepository* cenrep = CRepository::NewL( KCRUidEasyDialSettings );

    CleanupStack::PushL( cenrep );

    User::LeaveIfError( cenrep->Get( KEasyDialingContactThumbnails, iContactThumbnailSetting ) );

    CleanupStack::PopAndDestroy( cenrep );

    // Start observing Phoenbook setting for the name order

    iPbkSettings = PbkGlobalSettingFactory::CreatePersistentSettingL();

    iPbkSettings->ConnectL( MPbkGlobalSetting::EGeneralSettingCategory );

    iPbkSettings->RegisterObserverL( this );

    // Get name order from Phonebook settings

    UpdateNameOrderL();

    // Check if store with favourites is configured to be searched.

    SetupFavStoreSearchedL();

    }

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

// CEasyDialingContactDataManager::SetObserver

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

//

void CEasyDialingContactDataManager::SetObserver(MContactDataManagerObserver* aObserver)

    {

    iObserver = aObserver;

    }

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

// CEasyDialingContactDataManager::ContactManager

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

//

CVPbkContactManager& CEasyDialingContactDataManager::ContactManager()

    {

    return *iContactManager;

    }

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

// CEasyDialingContactDataManager::SetThumbnailSize

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

//

void CEasyDialingContactDataManager::SetThumbnailSize(const TSize& aSize)

    {

    if (iImageManagerParams.iSize != aSize)

        {

        iImageManagerParams.iSize = aSize;

        Reload();

        }

    }

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

// CEasyDialingContactDataManager::GetThumbnailIdL

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

//

HBufC* CEasyDialingContactDataManager::GetThumbnailIdL(

        MVPbkContactLink* aContact, TBool aMatchThumbnails, TBool aFav )

    {

    LOGSTRING("CEasyDialingContactDataManager: GetThumbnailIdL");

    TInt newIndex(KErrNotFound);

    if (aMatchThumbnails)

        {

        newIndex = FindContactIndex( aContact );

        }

    LOGSTRING1("newIndex = %d", newIndex);

    if (newIndex == KErrNotFound)

        {

        MVPbkContactLink* newLink = aContact->CloneLC();

        CEasyDialingContactData* newData = new (ELeave) CEasyDialingContactData(newLink);

        CleanupStack::Pop(); // newLink

        newIndex = iContactDataArray.Count();

        CleanupStack::PushL(newData);

        iContactDataArray.AppendL(newData);

        CleanupStack::Pop(newData);

        SetStoreFlagsForContact(newData);

        }

    iContactDataArray[ newIndex ]->SetFav( aFav );

    HBufC* id = HBufC::NewL( sizeof(TInt) * 2 ); // space for hex representation of TInt

    TPtr ptr = id->Des();

    ptr.Num(newIndex, EHex);

    LOGSTRING1("CEasyDialingContactDataManager: GetThumbnailIdL returns %S", id);

    return id;

    }

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

// CEasyDialingContactDataManager::IndexForId 

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

//

TInt CEasyDialingContactDataManager::IndexForId( const TDesC& aId ) const

    {

    TUint idVal(0);

    TLex lex(aId);

    lex.Val(idVal, EHex);

    return idVal;

    }

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

// CEasyDialingContactDataManager::GetThumbnail 

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

//

TBool CEasyDialingContactDataManager::GetThumbnail( TInt aIndex, CFbsBitmap*& aThumbnail )

    {

    LOGSTRING("CEasyDialingContactDataManager: GetThumbnail");

    TBool retVal;

    CEasyDialingContactData* contactData = iContactDataArray[aIndex];

    if ( contactData->IsLoaded() )

        {

        aThumbnail = contactData->Thumbnail();

        retVal = ETrue;

        }

    else

        {

        aThumbnail = NULL;

        retVal = EFalse;

        if (iWaitingContacts.Find(aIndex) == KErrNotFound)

            {

            LOGSTRING1("iWaitingContacts.Append %d", aIndex);

            iWaitingContacts.Append(aIndex);

            TRAPD(err, LoadNextContactDataL());

            if (err)

                {

                HandleError(err);

                }

            }

        }    

    LOGSTRING("CEasyDialingContactDataManager: GetThumbnail Exit");

    return retVal;

    }

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

// CEasyDialingContactDataManager::IsFav

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

//

TBool CEasyDialingContactDataManager::IsFav( TInt aIndex ) const

    {

    CEasyDialingContactData* contactData = iContactDataArray[aIndex];

    return contactData->Fav();

    }

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

// CEasyDialingContactDataManager::IsSimContact

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

//

TBool CEasyDialingContactDataManager::IsSimContact( TInt aIndex ) const

    {

    CEasyDialingContactData* contactData = iContactDataArray[aIndex];

    return contactData->IsSimContact();

    }

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

// CEasyDialingContactDataManager::IsSdnContact

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

//

TBool CEasyDialingContactDataManager::IsSdnContact( TInt aIndex ) const

    {

    CEasyDialingContactData* contactData = iContactDataArray[aIndex];

    return contactData->IsSdnContact();

    }

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

// CEasyDialingContactDataManager::IsFavL

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

//

TBool CEasyDialingContactDataManager::IsFavL( MVPbkContactLink* aLink )

    {

    if ( iFavsView && iFavsViewReady && iFavsView->IndexOfLinkL( *aLink ) > KErrNotFound )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CEasyDialingContactDataManager::NumberOfFavsL

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

//

TInt CEasyDialingContactDataManager::NumberOfFavsL()

    {

    if ( iFavsView && iFavsViewReady && iFavStoreSearched )

        {

        return iFavsView->ContactCountL();

        }

    else

        {

        return 0;

        }

    }

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

// CEasyDialingContactDataManager::FavLinkLC

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

//

MVPbkContactLink* CEasyDialingContactDataManager::FavLinkLC( TInt aIndex )

    {

    if ( !iFavsView || !iFavsViewReady || !iFavStoreSearched )

        {

        // LC function should not return normally unless it has actually

        // put something to cleanup stack

        User::Leave( KErrNotFound );

        }

    return iFavsView->ContactAtL( aIndex ).CreateLinkLC();

    }

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

// CEasyDialingContactDataManager::FavContactStringLC

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

//

HBufC* CEasyDialingContactDataManager::FavContactStringLC( TInt aIndex, TNameOrder aNameOrder )

    {

    const MVPbkBaseContactFieldCollection& fields = iFavsView->ContactAtL( aIndex ).Fields();

    TPtrC firstName;

    TPtrC lastName;

    TPtrC companyName;

    for ( TInt i = 0; i < fields.FieldCount(); i++ )

        {

        const MVPbkFieldType* fieldType = fields.FieldAt( i ).MatchFieldType( 0 );

        switch ( fieldType->FieldTypeResId() )

            {

            case R_VPBK_FIELD_TYPE_LASTNAME:

                {

                const MVPbkContactFieldTextData& data = 

                        MVPbkContactFieldTextData::Cast( fields.FieldAt( i ).FieldData() );

                lastName.Set( data.Text() );

                }

                break;

            case R_VPBK_FIELD_TYPE_FIRSTNAME:

                {

                const MVPbkContactFieldTextData& data = 

                        MVPbkContactFieldTextData::Cast( fields.FieldAt( i ).FieldData() );

                firstName.Set( data.Text() );

                }

                break;

            case R_VPBK_FIELD_TYPE_COMPANYNAME:

                {

                const MVPbkContactFieldTextData& data = 

                        MVPbkContactFieldTextData::Cast( fields.FieldAt( i ).FieldData() );

                companyName.Set( data.Text() );

                }

                break;

            default:

                break;

            }

        }

    return EasyDialingUtils::CreateContactStringLC( firstName, lastName, companyName, aNameOrder );

    }

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

// CEasyDialingContactDataManager::NameOrder

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

//

CEasyDialingContactDataManager::TNameOrder CEasyDialingContactDataManager::NameOrder()

    {

    return iNameOrder;

    }

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

// CEasyDialingContactDataManager::GetCurrentStoreUrisL

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

//

void CEasyDialingContactDataManager::GetCurrentStoreUrisL( RPointerArray<TDesC>& aUris )

    {

    CVPbkContactStoreUriArray* storeUris = iPbkStoreConfiguration->CurrentConfigurationL();

    CleanupStack::PushL( storeUris );

    for ( TInt i = 0 ; i < storeUris->Count() ; ++i )

        {

        HBufC* dbUri = (*storeUris)[i].UriDes().AllocLC();

        aUris.AppendL( dbUri );

        CleanupStack::Pop( dbUri );

        }

    CleanupStack::PopAndDestroy( storeUris );

    }

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

// CEasyDialingContactDataManager::Pause

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

//

void CEasyDialingContactDataManager::Pause( TBool aPause )

    {

    if ( iPause != aPause )

        {

        iPause = aPause;

        if ( !iPause && iWaitingContacts.Count() )

            {

            TRAPD( err, LoadNextContactDataL());

            if ( err )

                {

                HandleError(err);

                }

            }

        }

    }

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

// CEasyDialingContactDataManager::InitReady

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

//

void CEasyDialingContactDataManager::InitReady()

    {

    // Initialization is ready. we can start loading contact data, if needed.

    // (It is unlikely that there is any data to load at this point)

    iStoreReady = ETrue;

    if ( iWaitingContacts.Count() )

        {

        TRAPD( err, LoadNextContactDataL() )

        if ( err )

            {

            HandleError( err );

            }

        }

    }

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

// CEasyDialingContactDataManager::FindContactIndex

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

//

TInt CEasyDialingContactDataManager::FindContactIndex( MVPbkContactLink* aContact )

    {

    TInt index( KErrNotFound );

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

        {

        if ( iContactDataArray[i]->ContactLink()->IsSame( *aContact ) )

            {

            index = i;

            break;

            }

        }

    return index;

    }

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

// CEasyDialingContactDataManager::LoadNextContactDataL

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

//

void CEasyDialingContactDataManager::LoadNextContactDataL()

    {

    LOGSTRING("CEasyDialingContactDataManager: LoadNextContactDataL");

    if ( !iImageOperation && !iContactOperation && iWaitingContacts.Count() && iStoreReady && !iPause )

        {

        // first we need to load the contact item

        const TInt index( iWaitingContacts[0] );

        if ( index >= 0 && index < iContactDataArray.Count() )

            {

            CEasyDialingContactData* data = iContactDataArray[index];

            iContactOperation = iContactManager->RetrieveContactL( *(data->ContactLink()), *this);

            if (!iContactOperation)

                {

                data->LoadingComplete();

                RDebug::Print(_L("iWaitingContacts.Remove %d"), iWaitingContacts[0]);

                iWaitingContacts.Remove(0);

                LoadNextContactDataL();

                }

            }

        }

    LOGSTRING("CEasyDialingContactDataManager: LoadNextContactDataL Exit");

    }

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

// CEasyDialingContactDataManager::PbkImageGetComplete

// From MPbkImageGetObserver

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

//

void CEasyDialingContactDataManager::Pbk2ImageGetComplete(MPbk2ImageOperation& aOperation, CFbsBitmap* aBitmap)

    {

    LOGSTRING("CEasyDialingContactDataManager: Pbk2ImageGetComplete");

    TInt index( KErrNotFound );

    if ( iWaitingContacts.Count() > 0 )

        {

        index = iWaitingContacts[0];

        LOGSTRING1("iWaitingContacts.Remove %d", iWaitingContacts[0]);

        iWaitingContacts.Remove(0);

        }

    delete &aOperation;

    iImageOperation = NULL;