/*

* Copyright (c) 2002 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 helper class for class CPbkContactEngine.

*

*/

// INCLUDE FILES

#include "CPbkContactEngine.h"

#include "CContactDbConnection.h" 

#include <cntdb.h>

#include <cntview.h>

#include <cntitem.h>

#include <sysutil.h>

#include <featmgr.h>

#include <shareddataclient.h>

#include <PbkDebug.h>

#include "PbkProfiling.h"

#include "PbkCompressConfig.h"

#include "CPbkDefaultCompressionStrategy.h"

#include "PbkUID.h"

#include "CPbkFieldsInfo.h"

#include "TPbkMatchPriorityLevel.h"

#include "CPbkEngineExtension.h"

#include "CPbkSortOrderManager.h"

#include "PbkNameFormatterFactory.h"

#include <MPbkContactNameFormat.h>

// Unnamed namespace for local definitions

namespace {

// LOCAL CONSTANTS AND MACROS

/// Name of the shared contacts view

_LIT(KPbkAllContactsViewName, "AllContacts");

/// Default contact database name

_LIT(KDefaultDbName, "C:Contacts.cdb");

/// Default contact view preferences

const TContactViewPreferences KPbkDefaultContactViewPrefs =

    static_cast<TContactViewPreferences>

        ( EContactCardsOnly | EUnSortedAtEnd | ESingleWhiteSpaceIsEmptyField );

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicUninitializedData = 1

    };

// LOCAL FUNCTIONS

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CContactDbConnection");

    User::Panic(KPanicText, aReason);

    }

#endif

// ==================== LOCAL FUNCTIONS ====================

/**

 * Returns true if aLhs and aRhs differ.

 */

inline TBool operator!=

        (const RContactViewSortOrder& aLhs, const RContactViewSortOrder& aRhs)

    {

    return !(aLhs == aRhs);

    }

/**

 * Wrapper class for calling default file name or specified filename versions

 * of CContactDatabase::ReplaceL, OpenL and CreateL.

 */

NONSHARABLE_CLASS(TDbOpen)

    {

    public:

        /**

         * Constructor.

		 * @param aFileName file name

		 * @param aReplace open or replace the database

		 * @param aSharedDataClient shared data client

         */ 

        TDbOpen(const TDesC* aFileName, TBool aReplace, 

            const RSharedDataClient& aSharedDataClient);

        /**

         * Opens or replaces database.

         */ 

        CContactDatabase* OpenOrReplaceL() const;

        /**

         * Creates a new database.

         */

        CContactDatabase* CreateL() const;

        /**

         * Returns the drive the database is stored on.

         * @precond OpenOrReplaceL() or CreateL() has been called.

         */

        TDriveNumber DbDrive(RFs& aFs) const;

    private: // Implementation

        CContactDatabase* ReplaceL() const;

        CContactDatabase* OpenL() const;

    private:

		/// Own: file name

        TFileName iFileName;

		/// Own: open or replace flag

        const TBool iReplace;

		/// Ref: contact database

        mutable CContactDatabase* iDb;

        /// Ref: Shared data client

        const RSharedDataClient& iSharedDataClient;

    };

/**

 * Updates system template to reflect aFieldsInfo.

 */

TBool UpdateSystemTemplateFieldsL

        (CContactItem& aSysTemplate, 

        const CPbkFieldsInfo& aFieldsInfo);

}  // namespace

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

inline CPbkContactEngine::CContactDbConnection::CContactDbConnection()

    {

    }

inline TBool CPbkContactEngine::CContactDbConnection::CheckSystemTemplateL

        (const CPbkFieldsInfo& aFieldsInfo)

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::CheckSystemTemplateL(0x%x)"),this);

    // Open the system template

    TRAPD(err, iSysTemplate = iContactDb->OpenContactL(

        iContactDb->TemplateId()));

    switch (err)

        {

        case KErrNone:

            {

            // All is well

            break;

            }

        case KErrInUse:

            {

            // Assume some other CPbkContactEngine instance is currently 

            // performing this check -> skip the test. The test could be

            // reattempted after a delay but that would slow down the

            // initialisation of this class even more.

            return EFalse;

            }

        default:

            {

            // Propagate other errors to caller

            User::Leave(err);

            return EFalse;

            }

        }

	TBool result = EFalse;

    if (UpdateSystemTemplateFieldsL(*iSysTemplate,aFieldsInfo))

        {

        PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

            "CContactDbConnection::CheckSystemTemplateL(0x%x): updating system template...."),

            this);

        iContactDb->CommitContactL(*iSysTemplate);

		result = ETrue;

        PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

            "CContactDbConnection::CheckSystemTemplateL(0x%x): system template updated."), this);

        }

    CloseSystemTemplate();

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::CheckSystemTemplateL(0x%x) succesful"),this);

	return result;

    }

inline void CPbkContactEngine::CContactDbConnection::CreateAllContactsViewL

        (const RContactViewSortOrder& aSortOrder)

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::CreateAllContactsViewL(0x%x)"),this);

    __PBK_PROFILE_RESET(PbkProfiling::EAllContactsViewOpen);

    __PBK_PROFILE_START(PbkProfiling::EAllContactsViewOpen);

    iAllContactsView = CContactNamedRemoteView::NewL

        (*this, 

        KPbkAllContactsViewName, 

        Database(), 

        aSortOrder, 

        KPbkDefaultContactViewPrefs);

	InitViewL(*iAllContactsView);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::CreateAllContactsViewL(0x%x) succesful"),this);

    }

inline void CPbkContactEngine::CContactDbConnection::ConstructL

        (const TParams& aParams, TBool aSettingsVisible)

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

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

    iFs = aParams.iFs;

    __PBK_PROFILE_START(PbkProfiling::EContactDbOpen);

    // Shared data client is created and connected in CPbkContactEngine

    __ASSERT_DEBUG(aParams.iEngine && aParams.iEngine->iSharedDataClient,

        Panic(EPanicUninitializedData));

    TDbOpen dbOpen(aParams.iDbFileName, aParams.iReplaceExistingDb, 

        *aParams.iEngine->iSharedDataClient);

    TRAPD(error, iContactDb = dbOpen.OpenOrReplaceL());

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::ConstructL(0x%x): CContactDatabase open result=%d."),this, error);

    if (error == KErrNotFound)

        {

	    // Db not found, create it

	    TRAP(error, iContactDb = dbOpen.CreateL());

        PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

            "CContactDbConnection::ConstructL(0x%x): CContactDatabase create result=%d."),this, error);

        }

    __PBK_PROFILE_END(PbkProfiling::EContactDbOpen);

    *aParams.iDbOpenError = error;

    if (error != KErrNone)

        {

        User::Leave(error);

        }

    // Store database drive

    iDbDrive = dbOpen.DbDrive(iFs);

    // Call engine extension plugins

    aParams.iExtension->AddFieldTypesL(*aParams.iFieldsInfo);

    aParams.iExtension->ModifyFieldTypesL(*aParams.iFieldsInfo);

    // Check and update system template if needed

	TBool updated = EFalse;

    TRAP(error, updated = CheckSystemTemplateL(*aParams.iFieldsInfo));

    *aParams.iDbOpenError = error;

    if (error != KErrNone)

        {

        User::Leave(error);

        }

	if (updated)

		{

		// close and reopen contact database if system template has been updated

		delete iContactDb;

		iContactDb = NULL;

		iContactDb = dbOpen.OpenOrReplaceL();

		}

    // Create contact DB change notifier and connect it to aObserver

    iContactChangeNotifier = CContactChangeNotifier::NewL

        (*iContactDb, aParams.iContactDbObserver);

    // Create DB compressor

    iCompressionStrategy = CPbkDefaultCompressionStrategy::NewL

        (*iContactDb, iDbDrive, iFs);

	// Create contact Sort order managing object

    iSortOrderManager = CPbkSortOrderManager::NewL(iFs, aSettingsVisible);

    // Create the shared all contacts view

    CreateAllContactsViewL(iSortOrderManager->SortOrder());

	// Set view to sort order manager

	iSortOrderManager->SetContactView(*iAllContactsView);

    // create name formatting object

    iContactNameFormatter = PbkNameFormatterFactory::CreateL

        (*aParams.iUnnamedTitle, *iSortOrderManager, aSettingsVisible);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::ConstructL(0x%x) succesful."),this);

    }

CPbkContactEngine::CContactDbConnection* CPbkContactEngine::CContactDbConnection::NewL

        (const TParams& aParams, TBool aSettingsVisible)

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CContactDbConnection::NewL()"));

    CContactDbConnection* self = new(ELeave) CContactDbConnection;

    CleanupStack::PushL(self);

    self->ConstructL(aParams, aSettingsVisible);

    CleanupStack::Pop(self);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

        "CContactDbConnection::NewL() succesful, result=0x%x"), self);

    return self;

    }

CPbkContactEngine::CContactDbConnection::~CContactDbConnection()

    {

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

        {

        iFilteredViews[i].iFilteredView->Close(*this);

        }

    iFilteredViews.Close();

    if (iGroupsLocalView)

        {

        iGroupsLocalView->Close(*this);

        }

    if (iAllContactsView)

        {

        iAllContactsView->Close(*this);

        }

    if (iCompressionStrategy)

        {

        iCompressionStrategy->Release();

        }

    delete iContactChangeNotifier;

	delete iContactNameFormatter;

	delete iSortOrderManager;

    CloseSystemTemplate();

    delete iContactDb;

    }

CContactViewBase& CPbkContactEngine::CContactDbConnection::AllGroupsViewL()

    {

    // start loading the all the groups

    if (!iGroupsLocalView)

        {

        // Create a CContactLocalView that contains only groups.

        RContactViewSortOrder groupViewSortOrder;

        CleanupClosePushL(groupViewSortOrder);

        // KUidContactFieldTemplateLabel contains the group label

        groupViewSortOrder.AppendL(KUidContactFieldTemplateLabel);

        iGroupsLocalView = CContactLocalView::NewL(

            *this, *iContactDb, groupViewSortOrder, EGroupsOnly);

		InitViewL(*iGroupsLocalView);

        CleanupStack::PopAndDestroy();  // groupViewSortOrder

        }

    return *iGroupsLocalView;

    }

CContactViewBase& CPbkContactEngine::CContactDbConnection::FilteredContactsViewL

        (TInt aFilter)

    {

    const TInt count = iFilteredViews.Count();

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

        {

        if (iFilteredViews[i].iFilter == aFilter)

            {

            PBK_DEBUG_PRINT(PBK_DEBUG_STRING(

                "Returned filtered view filter=%x from the cache"), aFilter);

            return *iFilteredViews[i].iFilteredView;

            }

        }

    // Ending this profile is in HandleContactViewEvent

    __PBK_PROFILE_RESET(PbkProfiling::EFilteredViewOpen);

    __PBK_PROFILE_START(PbkProfiling::EFilteredViewOpen);

    TFilteredView filter;

    filter.iFilter = aFilter;

    filter.iFilteredView = CContactFilteredView::NewL

        (*this, *iContactDb, *iAllContactsView, aFilter);

	InitViewL(*filter.iFilteredView);

    const TInt err = iFilteredViews.Append(filter);

    if (err != KErrNone)

        {

        filter.iFilteredView->Close(*this);

        User::Leave(err);

        }

    return *filter.iFilteredView;

    }

void CPbkContactEngine::CContactDbConnection::SetCompressUi

        (MPbkCompressUi* aCompressUi)

    {

    iCompressionStrategy->SetCompressUi(aCompressUi);

    }

TBool CPbkContactEngine::CContactDbConnection::IsCompressionEnabled() const

    {

    return iCompressionStrategy->IsCompressionEnabled();

    }

TBool CPbkContactEngine::CContactDbConnection::CheckCompress()

    {

    return iCompressionStrategy->CheckCompress();

    }

void CPbkContactEngine::CContactDbConnection::CompressL()

    {

    iCompressionStrategy->CompressL();

    }

void CPbkContactEngine::CContactDbConnection::CancelCompress() const

    {

    iCompressionStrategy->CancelCompress();

    }

void CPbkContactEngine::CContactDbConnection::CheckFileSystemSpaceAndCompressL()

    {

    PBK_COMPRESS_LOG

        (PBK_COMPRESS_STRING(

        "CContactDbConnection::CheckFileSystemSpaceAndCompressL(0x%x), DB size = %d bytes"), 

        this, Database().FileSize());

    // Cancel any async compress in progress

    CancelCompress();

    // Compress synchronously always if compression is required by the DB 

    // or file system space is below critical level

    if (Database().CompressRequired() || FileSpaceLowOnDbDrive())

        {

        TRAPD(result, Database().CompactL());

        PBK_COMPRESS_LOG(PBK_COMPRESS_STRING("    Compacted database, result=%d"), result);

        }

    // If file system space is still under critical level leave with 

    // error code KErrDiskFull.

    if (FileSpaceLowOnDbDrive())

        {

        PBK_COMPRESS_LOG

            (PBK_COMPRESS_STRING("    FFS space is under critical level -> leaving with KErrDiskFull(%d)"), 

            KErrDiskFull);

        User::Leave(KErrDiskFull);

        }

    }

TBool CPbkContactEngine::CContactDbConnection::FileSpaceLowOnDbDrive() const

    {

    TBool result = EFalse;

    TRAP_IGNORE(result = SysUtil::DiskSpaceBelowCriticalLevelL(&iFs,0,iDbDrive));

    if (result)

        {

        PBK_COMPRESS_LOG(PBK_COMPRESS_STRING("CContactDbConnection::FileSpaceLowOnDbDrive() returning ETrue"));

        }

    return result;

    }

void CPbkContactEngine::CContactDbConnection::HandleContactViewEvent

#ifdef PBK_ENABLE_PROFILE

        (const CContactViewBase& aView, const TContactViewEvent& aEvent)

#else

        (const CContactViewBase& /*aView*/, const TContactViewEvent& /*aEvent*/)

#endif

    {

#ifdef PBK_ENABLE_PROFILE

    if (aEvent.iEventType != TContactViewEvent::EReady)

        {

        return;

        }

    if (&aView == iAllContactsView)

        {

        __PBK_PROFILE_END(PbkProfiling::EAllContactsViewOpen);

        __PBK_PROFILE_DISPLAY(PbkProfiling::EAllContactsViewOpen);

        __PBK_PROFILE_RESET(PbkProfiling::EAllContactsViewOpen);

        }

    else if (iFilteredViews.Count() > 0)

        {

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

            {

            if (iFilteredViews[i].iFilteredView == &aView)

                {

                __PBK_PROFILE_END(PbkProfiling::EFilteredViewOpen);

                __PBK_PROFILE_DISPLAY(PbkProfiling::EFilteredViewOpen);

                __PBK_PROFILE_RESET(PbkProfiling::EFilteredViewOpen);

                }

            }

        }

#endif // PBK_ENABLE_PROFILE

    }

void CPbkContactEngine::CContactDbConnection::CloseSystemTemplate()

    {

    if (iSysTemplate)

        {

        // Contact Model documentation says CloseContactL cannot leave

        iContactDb->CloseContactL(iSysTemplate->Id());

        delete iSysTemplate;

        iSysTemplate = NULL;

        }

    }

void CPbkContactEngine::CContactDbConnection::ChangeSortOrderL

		(const RContactViewSortOrder& aSortOrder) const

	{

	// Compare is the new sort order same than the previous one

	if (iAllContactsView->SortOrderL() != aSortOrder)

		{

		// It wasn't, change the sort order

		iAllContactsView->ChangeSortOrderL(aSortOrder);

		}

	}

MPbkContactNameFormat& CPbkContactEngine::CContactDbConnection::ContactNameFormatter() const

	{