/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QFileSystemWatcher>

#include <QFile>

#include <QUuid>

#include <QTimer>

#include <QDebug>

#include <qtcontacts.h>

#include "cntsymbianengine.h"

#include "qcontactchangeset.h"

#include "cntsymbiandatabase.h"

#include "cnttransformcontact.h"

#include "cntsymbiantransformerror.h"

#include "cntsymbianfilterdbms.h"

#include "cntsymbianfiltersql.h"

#include "cntsymbiansorterdbms.h"

#include "cntrelationship.h"

#include "cntdisplaylabel.h"

typedef QList<QContactLocalId> QContactLocalIdList;

typedef QPair<QContactLocalId, QContactLocalId> QOwnCardPair;

// NOTE: There is a bug with RVCT compiler which causes the local stack

// variable to corrupt if the called function leaves. As a workaround we are

// reserving the objects from heap so it will not get corrupted.

// This of course applies only to those stack variables which are passed to

// the called function or the return value of the function is placed to the

// variable

/* ... The macros changed names */

#if QT_VERSION < QT_VERSION_CHECK(4, 6, 0)

#define QT_TRAP_THROWING QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION

#define QT_TRYCATCH_LEAVING QT_TRANSLATE_EXCEPTION_TO_SYMBIAN_LEAVE

#endif

{

    m_dataBase = new CntSymbianDatabase(this, error);

    //Database opened successfully

        m_managerUri = QContactManager::buildUri(CNT_SYMBIAN_MANAGER_NAME, parameters);

        m_transformContact = new CntTransformContact;

#ifdef SYMBIAN_BACKEND_USE_SQLITE

        m_contactFilter    = new CntSymbianFilter(*this, *m_dataBase->contactDatabase(), *m_transformContact);

#else

        m_contactFilter    = new CntSymbianFilter(*m_dataBase->contactDatabase());

#endif

        m_contactSorter    = new CntSymbianSorterDbms(*m_dataBase->contactDatabase(), *m_transformContact);

        m_relationship     = new CntRelationship(m_dataBase->contactDatabase(), m_managerUri);

        m_displayLabel     = new CntDisplayLabel();

    }

}

CntSymbianEngine::CntSymbianEngine(const CntSymbianEngine& other)

    : QContactManagerEngine(),

      m_dataBase(other.m_dataBase),

      m_managerUri(other.m_managerUri),

      m_transformContact(other.m_transformContact),

      m_contactFilter(other.m_contactFilter),

      m_contactSorter(other.m_contactSorter),

      m_relationship(other.m_relationship),

      m_displayLabel(other.m_displayLabel)

{

}

CntSymbianEngine::~CntSymbianEngine()

{

    delete m_contactFilter; // needs to be deleted before database

    delete m_dataBase;

    delete m_transformContact;

    delete m_contactSorter;

    delete m_relationship;

    delete m_displayLabel;

}

/*!

 * Returns a list of the ids of contacts that match the supplied \a filter, sorted according to the given \a sortOrders.

 * Any error that occurs will be stored in \a error. Uses either the Symbian backend native filtering or in case of an

 * unsupported filter, the generic (slow) filtering of QContactManagerEngine.

 */

QList<QContactLocalId> CntSymbianEngine::contactIds(

        const QContactFilter& filter,

        const QList<QContactSortOrder>& sortOrders,

{

    QList<QContactLocalId> result;

    if (filter.type() == QContactFilter::RelationshipFilter)

    {

        QContactRelationshipFilter rf = static_cast<QContactRelationshipFilter>(filter);

        QList<QContactRelationship> relationshipsList = relationships(

            rf.relationshipType(), rf.relatedContactId(), rf.relatedContactRole(), error);

                    result += r.second().localId();

                    result += r.first().localId();

                    result += r.first().localId();

                    result += r.second().localId();

                }

            }

        }

    }

    else

    {

        bool filterSupported(true);

        result = m_contactFilter->contacts(filter, sortOrders, filterSupported, error);

#ifdef SYMBIAN_BACKEND_USE_SQLITE

        // Remove possible false positives

            result = slowFilter(filter, result, error);

#else

        // Remove possible false positives

            result = slowFilter(filter, result, error);

        // Sort the matching contacts

            if(m_contactSorter->sortOrderSupported(sortOrders)) {

                result = m_contactSorter->sort(result, sortOrders, error);

            } else {

                result = slowSort(result, sortOrders, error);

            }

        }

#endif

    }

    return result;

}

{

    // Check if sorting is supported by backend

    if(m_contactSorter->sortOrderSupported(sortOrders))

        return m_contactSorter->contacts(sortOrders,error);

    // Backend does not support this sorting.

    // Fall back to slow QContact-level sorting method.

    // Get unsorted contact ids

    QList<QContactSortOrder> noSortOrders;

    QList<QContactLocalId> unsortedIds = m_contactSorter->contacts(noSortOrders, error);

        return QList<QContactLocalId>();

    // Sort contacts

    return slowSort(unsortedIds, sortOrders, error);

}

{

    QList<QContact> contacts;

    QList<QContactLocalId> contactIds = this->contactIds(sortOrders, error);

        foreach (QContactLocalId id, contactIds) {

            QContact contact = this->contact(id, definitionRestrictions, error);

                return QList<QContact>(); // return empty list if error occurred

            }

            contacts.append(contact);

        }

    }

    return contacts;

}

{

    QList<QContact> contacts;

    QList<QContactLocalId> contactIds = this->contactIds(filter, sortOrders, error);

        foreach (QContactLocalId id, contactIds) {

                return QList<QContact>(); // return empty list if error occurred

            }

            contacts.append(contact);

        }

    }

    return contacts;

}

/*!

 * Read a contact from the contact database.

 *

 * \param contactId The Id of the contact to be retrieved.

 * \param error Qt error code.

 * \return A QContact for the requested QContactLocalId value or 0 if the read

 *  operation was unsuccessful (e.g. contact not found).

 */

{

    QContact* contact = new QContact();

    CntSymbianTransformError::transformError(err, error);

        updateDisplayLabel(*contact);

        //check relationship only if there are no definition restrictions, otherwise

        //skip this time expensive operation.       

            QContactManager::Error relationshipError;

            if (relationshipError != QContactManager::NoError &&

                relationshipError != QContactManager::DoesNotExistError) { // means that no relationships found

            }

            QContactManagerEngine::setContactRelationships(contact, relationships);

        }

    }

    return *QScopedPointer<QContact>(contact);

}

{

    QContactChangeSet changeSet;

    TBool ret = doSaveContact(contact, changeSet, error);

    changeSet.emitSignals(this);

    return ret;

}

/*! \reimp */

{

    if (errorMap) {

        // if the errormap argument is null, we just don't do fine-grained reporting.            

        errorMap->clear();

    }    

    if (!contacts) {

        return false;

    }

    QContactChangeSet changeSet;

    for (int i = 0; i < contacts->count(); i++) {

        QContact current = contacts->at(i);

        QContactManager::Error functionError = QContactManager::NoError;

            if (errorMap) {

                errorMap->insert(i, functionError);

            }

        } else {

            (*contacts)[i] = current;

        }

    }

    changeSet.emitSignals(this);

}

/*!

 * Uses the generic filtering implementation of QContactManagerEngine to filter

 * contacts one-by-one. Really slow when filtering a lot of contacts because

 * every contact needs to be loaded from the database before filtering.

 */

QList<QContactLocalId> CntSymbianEngine::slowFilter(

        const QContactFilter& filter,

        const QList<QContactLocalId>& contacts,

        ) const

{

    QList<QContactLocalId> result;

    for (int i(0); i < contacts.count(); i++) {

        QContactLocalId id = contacts.at(i);

        // Check if this is a false positive. If not, add to the result set.

            result << id;

    }

    return result;

}

QList<QContactLocalId> CntSymbianEngine::slowSort(

        const QList<QContactLocalId>& contactIds,

        const QList<QContactSortOrder>& sortOrders,

{

    // Get unsorted contacts

    QList<QContact> unsortedContacts;

    foreach (QContactLocalId id, contactIds) {

            return QList<QContactLocalId>();

        unsortedContacts << c;

    }

    return QContactManagerEngine::sortContacts(unsortedContacts, sortOrders);

}

{

    bool ret = false;

    if(contact && !validateContact(*contact, error))

        return false;

    // If contact has GUid and no local Id, try to find it in database

    if (contact && !contact->localId() &&

        contact->details(QContactGuid::DefinitionName).count() > 0) {

        QContactDetailFilter guidFilter;

        guidFilter.setDetailDefinitionName(QContactGuid::DefinitionName, QContactGuid::FieldGuid);

        QContactGuid guidDetail = static_cast<QContactGuid>(contact->details(QContactGuid::DefinitionName).at(0));

        guidFilter.setValue(guidDetail.guid());

        QContactManager::Error err;

        QList<QContactLocalId> localIdList = contactIds(guidFilter,

        if (err == QContactManager::NoError && localIdList.count() > 0) {

            QScopedPointer<QContactId> contactId(new QContactId());

            contactId->setLocalId(localIdList.at(0));

            contactId->setManagerUri(m_managerUri);

            contact->setId(*contactId);

        }

    }

    // Check parameters

    if(!contact) {

        ret = false;

    // Update an existing contact

    } else if(contact->localId()) {

        if(contact->id().managerUri() == m_managerUri) {

            ret = updateContact(*contact, changeSet, error);

        } else {

            ret = false;

        }

    // Create new contact

    } else {

        ret = addContact(*contact, changeSet, error);

    }

    if (ret)

        updateDisplayLabel(*contact);

    return ret;

}

/*!

 * Private leaving implementation for contact()

 */

QContact CntSymbianEngine::fetchContactL(const QContactLocalId &localId, const QStringList& definitionRestrictions) const

{

    // A contact with a zero id is not expected to exist.

    // Symbian contact database uses id 0 internally as the id of the

    // system template.

    if(localId == 0)

        User::Leave(KErrNotFound);

    // Read the contact from the CContactDatabase

    CContactItem* contactItem = m_dataBase->contactDatabase()->ReadContactL(localId);

    CleanupStack::PushL(contactItem);

    // Convert to a QContact

    QContact contact = m_transformContact->transformContactL(*contactItem, definitionRestrictions);

    // Transform details that are not available until the contact has been saved

    m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

    CleanupStack::PopAndDestroy(contactItem);

    return contact;

}

/*!

 * Add the specified contact item to the persistent contacts store.

 *

 * \param contact The QContact to be saved.

 * \param id The Id of new contact

 * \param qtError Qt error code.

 * \return Error status

 */

{

    // Attempt to persist contact, trapping errors

    int err(0);

    QContactLocalId id(0);

    TRAP(err, id = addContactL(contact));

    if(err == KErrNone)

    {

        m_dataBase->appendContactEmitted(id);

    }

    CntSymbianTransformError::transformError(err, qtError);

    return (err==KErrNone);

}

/*!

 * Private leaving implementation for addContact()

 *

 * \param contact The contact item to save in the database.

 * \return The new contact ID.

 */

int CntSymbianEngine::addContactL(QContact &contact)

{

    int id(0);

    //handle normal contact

    if(contact.type() == QContactType::TypeContact)

    {

        // Create a new contact card.

        CContactItem* contactItem = CContactCard::NewLC();

        m_transformContact->transformContactL(contact, *contactItem);

        // Add to the database

        id = m_dataBase->contactDatabase()->AddNewContactL(*contactItem);

        // Reload contact item

        CleanupStack::PopAndDestroy(contactItem);

        contactItem = 0;

        contactItem = m_dataBase->contactDatabase()->ReadContactLC(id);

        // Transform details that are not available until the contact has been saved

        m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

        CleanupStack::PopAndDestroy(contactItem);

    }

    //group contact

    else if(contact.type() == QContactType::TypeGroup)

    {

        // Create a new group, which is added to the database

        CContactItem* contactItem = m_dataBase->contactDatabase()->CreateContactGroupLC();

        //set the id for the contact, needed by update

        id = contactItem->Id();

        QScopedPointer<QContactId> contactId(new QContactId());

        contactId->setLocalId(QContactLocalId(id));

        contactId->setManagerUri(m_managerUri);

        contact.setId(*contactId);

        //update contact, will add the fields to the already saved group

        updateContactL(contact);

        // Transform details that are not available until the contact has been saved

        m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

        CleanupStack::PopAndDestroy(contactItem);

    }

    // Leave with an error

    else

    {

        User::Leave(KErrInvalidContactDetail);

    }

    // Return the new ID.

    return id;

}

/*!

 * Update an existing contact entry in the database.

 *

 * \param contact The contact to update in the database.

 * \param qtError Qt error code.

 * \return Error status.

 */

{