/*

* Copyright (c) 2005-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:  CContactStore implementation

*

*/

// INCLUDE FILES

#include "contactstore.h"

#include "contactstoredomain.h"

#include "contactstoreinfo.h"

#include "contactstoreproperties.h"

#include "contactstoreuri.h"

#include "contact.h"

#include "ldapcontact.h"

#include "contactlink.h"

#include "contactretriever.h"

#include "contactview.h"

#include "supportedfieldtypes.h"

#include "ldapfinderui.h"       // Finder UI

#include "fieldtypemappings.h"  // Field type mapping

#include "ldapfieldtype.h"      // LDAP Field type

#include <barsc.h>              // For resource

#include <barsread.h>           // For resource reader

#include <mvpbkfieldtype.h>     // Field type list

#include <ldapstoreres.rsg>     // Field type mapping resource

#include <cvpbkcontactviewdefinition.h>

#include <mvpbkcontactstoreobserver.h>

#include <mvpbkcontactoperationfactory.h>

// CONSTANTS

_LIT(KLDAPDriveC,"c:");

_LIT(KLDAPDriveZ,"z:");

_LIT(KLDAPResourceFilesDir,"\\resource\\");

_LIT(KLDAPStoreResFile,"LDAPStoreRes.rsc");

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

// LDAPStoreInitializeL

// Store initialized notify callback

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

//

static TInt LDAPStoreInitializeL(TAny* aThis)

    {

    if (aThis)

        {

        return static_cast<LDAPStore::CContactStore*>(aThis)->StoreInitializeL();

        }

    return EFalse;

    }

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

// LDAPStoreReady

// Store ready notify callback

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

//

static TInt LDAPStoreReady(TAny* aThis)

    {

    if (aThis)

        {

        static_cast<LDAPStore::CContactStore*>(aThis)->StoreReady();

        }

    return EFalse;

    }

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

// LDAP Store namespace

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

namespace LDAPStore {

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

// CContactStore::CContactStore

// C++ default constructor can NOT contain any code, that might leave.

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

//

CContactStore::CContactStore(CContactStoreDomain& aStoreDomain)

:   iStoreDomain(aStoreDomain)

    {

    // No implementation required

    }

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

// CContactStore::ConstructL

// CContactStore constructor for performing 2nd stage construction

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

//

void CContactStore::ConstructL(const TVPbkContactStoreUriPtr& aURI)

    {

    // Store properties

    iProperties = CContactStoreProperties::NewL();

    // Store uri - pure nonsense, but required

    iStoreURI = CContactStoreUri::NewL(aURI);

    // Set name, actually whole uri

    iProperties->SetName(iStoreURI->Uri());

    // Store information

    iStoreInfo = CContactStoreInfo::NewL(*this);

    // Settings loaded with store name

    iSettings = CLDAPSettings::NewL(iProperties->Name().UriDes());

    // Initialiaze field mappings of this store

    InitializeFieldMappingL();

    }

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

// CContactStore::NewLC

// CContactStore two-phased constructor.

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

//

CContactStore* CContactStore::NewLC(const TVPbkContactStoreUriPtr& aURI,

                                    CContactStoreDomain& aStoreDomain)

    {

    CContactStore* self = new (ELeave)CContactStore(aStoreDomain);

    CleanupStack::PushL(self);

    self->ConstructL(aURI);

    return self;

    }

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

// CContactStore::NewL

// CContactStore two-phased constructor.

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

//

CContactStore* CContactStore::NewL(const TVPbkContactStoreUriPtr& aURI,

                                   CContactStoreDomain& aStoreDomain)

    {

    CContactStore* self = CContactStore::NewLC(aURI,aStoreDomain);

    CleanupStack::Pop(self);

    return self;

    }

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

// CContactStore::~CContactStore

// CContactStore Destructor

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

//

CContactStore::~CContactStore()

    {

    // Close observers

    iStoreObservers.Close();

    // Callback

    if (iIdle)

        {

        // Cancel all pending operations

        iIdle->Cancel();

        delete iIdle;

        iIdle = NULL;

        }

    // Store directory

    if (iDirectory)

        {

        delete iDirectory;

        iDirectory = NULL;

        }

    // Settings

    if (iSettings)

        {

        delete iSettings;

        iSettings = NULL;

        }

    // Store URI

    if (iStoreURI)

        {

        delete iStoreURI;

        iStoreURI = NULL;

        }

    // Store properties

    if (iProperties)

        {

        delete iProperties;

        iProperties = NULL;

        }

    // Store information

    if (iStoreInfo)

        {

        delete iStoreInfo;

        iStoreInfo = NULL;

        }

    // Supported fields

    if (iSupportedFieldTypes)

        {

        delete iSupportedFieldTypes;

        iSupportedFieldTypes = NULL;

        }

    // Field type list

    iFieldTypes.Close();

    // Clear contacts

    iContacts.ResetAndDestroy();

    iContacts.Close();

    }

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

//                      CContactStore public methods

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

// CContactStore::AddObserverL

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

//

void CContactStore::AddObserverL(MVPbkContactStoreObserver& aObserver)

    {

    // Already in observers

    TInt find = iStoreObservers.Find(&aObserver);

    if (find == KErrNotFound)

        {

        // Add observer

        iStoreObservers.AppendL(&aObserver);

        }

    }

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

// CContactStore::RemoveObserver

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

//

void CContactStore::RemoveObserver(MVPbkContactStoreObserver& aObserver)

    {

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

    if (pos != KErrNotFound)

        {

        iStoreObservers.Remove(pos);

        }

    }

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

// CContactStore::CreateContactL

// Creates new contact from index.

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

//

CContact* CContactStore::CreateContactL(TInt aIndex)

    {

    CContact* cp = NULL;

    // Index in range

    if (aIndex >= 0 && aIndex < iContacts.Count())

        {        

        // New contact

        cp = CContact::NewL(*this,ContactAt(aIndex).Contact(),EFalse);

        }

    return cp;

    }

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

// CContactStore::ContactCount

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

//

TInt CContactStore::ContactCount()

    {

    return iContacts.Count();    

    }

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

// CContactStore::ContactAt

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

//

CContact& CContactStore::ContactAt(TInt aIndex)

    {

    return *iContacts[aIndex];

    }

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

// CContactStore::FieldTypeMappings

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

//

CFieldTypeMappings& CContactStore::FieldTypeMappings()

    {

    return iStoreDomain.FieldTypeMappings();

    }

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

// CContactStore::IsInitialized

// Returns true if store is initialized.

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

//

TBool CContactStore::IsInitialized() {

    return iState == EInitialized;

}

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

// CContactStore::IsOpen

// Returns true if store is open.

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

//

TBool CContactStore::IsOpen()

    {

    return iState == EOpened;

    }

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

// CContactStore::State

// Returns store state.

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

//

CContactStore::TState CContactStore::State()

    {

    return iState;

    }

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

// CContactStore::MatchContactStore

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

//

TBool CContactStore::MatchContactStore(const TDesC& aContactStoreUri) const

    {

    if (iStoreURI->Uri().Compare(TVPbkContactStoreUriPtr(aContactStoreUri), 

        TVPbkContactStoreUriPtr::EContactStoreUriAllComponents) == 0)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CContactStore::MatchContactStoreDomain

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

//

TBool CContactStore::MatchContactStoreDomain(const TDesC& aContactStoreDomain) const

    {

    if (iStoreURI->Uri().Compare(aContactStoreDomain, 

        TVPbkContactStoreUriPtr::EContactStoreUriStoreType) == 0)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CContactStore::Name

// Returns store name

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

//

TPtrC CContactStore::Name()

    {

    return (iSettings) ? iSettings->Name() : TPtrC(KNullDesC);

    }

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

// CContactStore::StoreInitializeL

// Initializes store

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

//

TBool CContactStore::StoreInitializeL()

    {

    TBool status = ETrue;

    // Just change state

    if (iState == EIdle)

        {

        iState = EInitializing;

        }

    else

    // Start initializing

    if (iState == EInitializing)

        {

        // Old directory

        if (iDirectory)

            {

            delete iDirectory;

            iDirectory = NULL;

            }

        // New directory

        iDirectory = LDAPEngine::CDirectory::NewL();

        // Add observer

        iDirectory->AddObserverL(*this);

        // Configure

        iDirectory->Configure(*iSettings);

        // Set field types

        iDirectory->SetSearchAttributesL(iFieldTypes);

        // Supported field types

        InitializeSupportedFieldsL();

        // Stop initializing

        status = EFalse;

        }

    return status;

    }

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

// CContactStore::StoreReady

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

//

void CContactStore::StoreReady()

    {

    // Notify all - notice the reverse order

    for (TInt loop = iStoreObservers.Count() - 1; loop >= 0 ;loop--)

        {

        // Notify

        StoreReady(*iStoreObservers[loop]);

        }

    }

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

//                      CContactStore private methods

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

// CTestEngineAppUi::InitializeFieldMappingL

// Initialiaze store field type mappings

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

void CContactStore::InitializeFieldMappingL()

    {  

    // For resource reading

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    // Default resource file name

    TFileName res_name(KLDAPDriveZ);

    res_name.Append(KLDAPResourceFilesDir);

    res_name.Append(KLDAPStoreResFile);

    // Customized resource file

    TPtrC cus_name = iSettings->ResourceFile();

    if (cus_name.Length() > 0)

        {

        // Custom resource name

        TFileName cus_res;

        // Parse name

        TParse name_parser;

        name_parser.Set(cus_name,NULL,NULL);

        // Has drive

        TPtrC drive = name_parser.Drive();

        if (drive.Length() > 0)

            {

            // Add drive

            cus_res.Append(drive);

            }

        else

            {

            // Add default C drive

            cus_res.Append(KLDAPDriveC);

            }

        // Path present

        if (name_parser.PathPresent())

            {

            // Add path

            cus_res.Append(name_parser.Path());

            }

        else

            {

            // Add default

            cus_res.Append(KLDAPResourceFilesDir);

            }

        // Add name

        cus_res.Append(name_parser.NameAndExt());

        if (fs.IsValidName(cus_res))

            {

            // File attributes

            TUint attr = 0;

            TInt status = fs.Att(cus_res,attr);

            if (status == KErrNone)

                {

                // Replace name

                res_name.Copy(cus_res);

                }

            }

        }

    // Load field type mappings

    RResourceFile res_file;

    // Open resource

    res_file.OpenL(fs,res_name);

    // Check that resource has mapping list

    if (! res_file.OwnsResourceId(R_LDAP_FIELD_MAPPING_LIST))

        {

        // Close resource

        res_file.Close();

        // Custom resource

        if (cus_name.Length() > 0)

            {

            // Default resource

            res_name.Copy(KLDAPDriveZ);

            res_name.Append(KLDAPResourceFilesDir);

            res_name.Append(KLDAPStoreResFile);

            // Open resource

            res_file.OpenL(fs,res_name);

            }

        else

            {

            // File server

            CleanupStack::PopAndDestroy();

            return;

            }

        }

    // Push to close

    CleanupClosePushL(res_file);

    // Resource reader

    TResourceReader reader;

    // Search attribute list

    reader.SetBuffer(res_file.AllocReadLC(R_LDAP_FIELD_MAPPING_LIST));

    // Read field mapping list

    TInt count = reader.ReadInt16();

    while (count-- > 0)

        {

        // Read entries

        iFieldTypes.AppendL(TLDAPFieldType(reader));

        }

    // Cleanup - R_LDAP_FIELD_MAPPING_LIST

    CleanupStack::PopAndDestroy();

    // Close resource

    res_file.Close();

    // Resource file

    CleanupStack::PopAndDestroy();

    // File server

    CleanupStack::PopAndDestroy();

    }

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

// CTestEngineAppUi::InitializeSupportedFieldsL