1 /*

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

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 #include "cntservicehandler.h"

    19 #include "cntimageutility.h"

    20 

    21 #include <qversitreader.h>

    22 #include <qversitcontactimporter.h>

    23 #include <qversitdocument.h>

    24 

    25 #include <QPixmap>

    26 #include <QFile>

    27 #include <QUrl>

    28 

    29 /* NOTE! THIS SERVICE WILL BE RENAMED TO com.nokia.services.phonebook.Services */

    30 CntServiceHandler::CntServiceHandler(QObject *parent):

    31     XQServiceProvider(QLatin1String("com.nokia.services.phonebookservices.Fetch"), parent),

    32     mCurrentRequestIndex(0)

    33 {

    34     publishAll();

    35     

    36     // Definition names supported in symbian back-end

    37     m_definitionNames << QContactName::DefinitionName;

    38     m_definitionNames << QContactNickname::DefinitionName;

    39     m_definitionNames << QContactPhoneNumber::DefinitionName;

    40     m_definitionNames << QContactEmailAddress::DefinitionName;

    41     m_definitionNames << QContactAddress::DefinitionName;

    42     m_definitionNames << QContactUrl::DefinitionName;

    43     m_definitionNames << QContactBirthday::DefinitionName;

    44     m_definitionNames << QContactOrganization::DefinitionName;

    45     m_definitionNames << QContactSyncTarget::DefinitionName;

    46     m_definitionNames << QContactNote::DefinitionName;

    47     m_definitionNames << QContactFamily::DefinitionName;

    48     m_definitionNames << QContactAvatar::DefinitionName;

    49     m_definitionNames << QContactAnniversary::DefinitionName;

    50     m_definitionNames << QContactGeoLocation::DefinitionName;

    51     m_definitionNames << QContactGender::DefinitionName;

    52     m_definitionNames << QContactOnlineAccount::DefinitionName;

    53 }

    54 

    55 CntServiceHandler::~CntServiceHandler()

    56 {

    57 }

    58 

    59 /*

    60 Complete the fetch and return the list selected contacts

    61 */

    62 void CntServiceHandler::completeFetch( const CntServicesContactList &contactList )

    63 {

    64     QVariant retValue;

    65     retValue.setValue(contactList);

    66     completeRequest(mCurrentRequestIndex, retValue);

    67     mCurrentRequestIndex = 0;

    68 }

    69 

    70 /*

    71 Complete edit and return if contact wasn't modified (-2), was deleted (-1), saved (1) or if saving failed (0)

    72 */

    73 void CntServiceHandler::completeEdit(int result)

    74 {

    75     QVariant retValue(result);

    76     completeRequest(mCurrentRequestIndex, retValue);

    77     mCurrentRequestIndex = 0;

    78 }

    79 

    80 /*

    81 Launch fetch service with given parameters

    82 */

    83 void CntServiceHandler::fetch(const QString &title, const QString &action, const QString &filter)

    84 {

    85     emit launchFetch(title, action, filter);

    86     mCurrentRequestIndex = setCurrentRequestAsync();

    87 }

    88 

    89 /*

    90 Launch fetch service with given parameters. Fetching mode is No-select by default.

    91 */

    92 void CntServiceHandler::Dofetch(const QString &title, const QString &action, const QString &filter, const QString &mode)

    93 {

    94     emit launchFetchVerified(title, action, filter, mode);

    95     mCurrentRequestIndex = setCurrentRequestAsync();

    96 }

    97 

    98 /*

    99 Launch new contact editor with a given detail

   100 */

   101 void CntServiceHandler::editCreateNew(const QString &definitionName, const QString &value)

   102 {

   103     QContact contact;

   104     

   105     if (definitionName == QContactPhoneNumber::DefinitionName)

   106     {

   107         QContactPhoneNumber phoneNumber;

   108         phoneNumber.setNumber(value);

   109         phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   110         contact.saveDetail(&phoneNumber);

   111     }

   112     else if (definitionName == QContactEmailAddress::DefinitionName)

   113     {

   114         QContactEmailAddress email;

   115         email.setEmailAddress(value);

   116         contact.saveDetail(&email);

   117     }

   118     else if (definitionName == QContactOnlineAccount::DefinitionName)

   119     {

   120         QContactOnlineAccount account;

   121         account.setAccountUri(value);

   122         account.setSubTypes(QContactOnlineAccount::SubTypeSipVoip);

   123         contact.saveDetail(&account);

   124     }    

   125     

   126     emit launchEditor(contact);

   127 

   128     mCurrentRequestIndex = setCurrentRequestAsync();

   129 }

   130 

   131 /*

   132 Launch new contact editor with a given vCard filename

   133 */

   134 void CntServiceHandler::editCreateNew(const QString &vCardFile)

   135 {

   136     CntImageUtility imageUtility;

   137     QContact contact;

   138     QVersitReader reader;

   139     QFile file(vCardFile);

   140 

   141     if (!file.open(QIODevice::ReadOnly))

   142         return;

   143     reader.setDevice(&file);

   144     reader.startReading();

   145     reader.waitForFinished();

   146 

   147     // Use the resulting document(s)...

   148     QVersitContactImporter importer;

   149     QList<QVersitDocument> versitDocuments = reader.results();

   150     if (versitDocuments.count() > 0 

   151         && importer.importDocuments(versitDocuments))

   152     {

   153         QList<QContact> contacts = importer.contacts();

   154         if (contacts.count() > 0)

   155             contact = contacts.first();

   156     }

   157     file.close();

   158     

   159     // Save thumbnail images

   160     QList<QContactThumbnail> details = contact.details<QContactThumbnail>();

   161     for (int i = 0;i < details.count();i++)

   162     {

   163         if (!details.at(i).thumbnail().isNull())

   164         {

   165             QString imagepath;

   166             QPixmap pixmap = QPixmap::fromImage(details.at(i).thumbnail());

   167             if (imageUtility.createImage(pixmap,imagepath))

   168             {

   169                 // Update contact detail

   170                 QContactAvatar detail=details.at(i);

   171                 detail.setImageUrl(imagepath);

   172                 contact.saveDetail(&detail);

   173             }

   174         }

   175     }

   176     

   177     removeNotSupportedDetails(contact);

   178     removeNotSupportedFields(contact);

   179     emit launchEditor(contact);

   180 

   181     mCurrentRequestIndex = setCurrentRequestAsync();

   182 }

   183 

   184 /*

   185 * Remove details not supported in symbian back-end.

   186 */

   187 void CntServiceHandler::removeNotSupportedDetails(QContact& contact)

   188 {

   189     // Check definition map, remove details not supported

   190     for (int i=0; i < contact.details().count(); i++)

   191     {

   192         if (!m_definitionNames.contains(contact.details().at(i).definitionName()))

   193         {

   194             QContactDetail detail= contact.details().at(i);

   195             contact.removeDetail(&detail);

   196         }

   197     }

   198 }

   199 /*

   200 * Remove fields not supported in symbian back-end.

   201 */

   202 void CntServiceHandler::removeNotSupportedFields(QContact& contact)

   203 {

   204     QContactManager cm("symbian");

   205     

   206     // Not all fields are supported in symbian back-end

   207     // Remove not supported fields

   208     for (int i=0; i < contact.details().count(); i++)

   209     {

   210         QContactDetail detail = contact.details().at(i);

   211         if (detail.definitionName() == QContactAddress::DefinitionName)

   212         {

   213             QContactAddress addrDetail = static_cast<QContactAddress>(detail);

   214             

   215             // Sub-types not supported

   216             if (detail.removeValue(QContactAddress::FieldSubTypes))

   217                 contact.saveDetail(&detail);

   218         }

   219         else if (detail.definitionName() == QContactAnniversary::DefinitionName)

   220         {

   221             QContactAnniversary annivDetail = static_cast<QContactAnniversary>(detail);

   222             

   223             // Sub-types not supported

   224             if (detail.removeValue(QContactAnniversary::FieldSubType))

   225                 contact.saveDetail(&detail);

   226             

   227             // Context not supported

   228             if (detail.removeValue(QContactDetail::FieldContext))

   229                 contact.saveDetail(&detail);

   230         }

   231         else if (detail.definitionName() == QContactPhoneNumber::DefinitionName)

   232         {

   233             QContactPhoneNumber phoneDetail = static_cast<QContactPhoneNumber>(detail);

   234             

   235             if (phoneDetail.subTypes().size() == 0)

   236             {

   237                 // No Sub-type found, set as SubTypeMobile

   238                 phoneDetail.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   239                 contact.saveDetail(&phoneDetail);

   240             }

   241             else if (phoneDetail.subTypes().size() > 0 )

   242             {

   243                 // Sub-types not supported

   244                 if (phoneDetail.subTypes().contains(QContactPhoneNumber::SubTypeVoice)

   245                     || phoneDetail.subTypes().contains(QContactPhoneNumber::SubTypeMessagingCapable)

   246                     || phoneDetail.subTypes().contains(QContactPhoneNumber::SubTypeVideo))

   247                 {

   248                     // Replace as SubTypeMobile

   249                     phoneDetail.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   250                     contact.saveDetail(&phoneDetail);

   251                 }

   252             }

   253         }

   254         else if (detail.definitionName() == QContactUrl::DefinitionName)

   255         {

   256             QContactUrl urlDetail = static_cast<QContactUrl>(detail);

   257             

   258             QString stype=QContactUrl::SubTypeHomePage;

   259             if (urlDetail.subType().compare(stype) != 0)

   260             {

   261                 detail.removeValue(QContactUrl::FieldSubType);

   262                 contact.saveDetail(&detail);

   263             }

   264         }

   265     }

   266 }

   267 /*

   268 Launch contact selection view with a given detail (selecting detail there opens the editor and adds the new detail)

   269 */

   270 void CntServiceHandler::editUpdateExisting(const QString &definitionName, const QString &value)

   271 {

   272     QContactDetail detail;

   273     

   274     if (definitionName == QContactPhoneNumber::DefinitionName)

   275     {

   276         QContactPhoneNumber phoneNumber;

   277         phoneNumber.setNumber(value);

   278         phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   279         detail = phoneNumber;

   280     }

   281     else if (definitionName == QContactEmailAddress::DefinitionName)

   282     {

   283         QContactEmailAddress email;

   284         email.setEmailAddress(value);

   285         detail = email;

   286     }

   287     else if (definitionName == QContactOnlineAccount::DefinitionName)

   288     {

   289         QContactOnlineAccount account;

   290         account.setAccountUri(value);

   291         account.setSubTypes(QContactOnlineAccount::SubTypeSipVoip);

   292         detail = account;

   293     }

   294     

   295     emit launchContactSelection(detail);

   296 

   297     mCurrentRequestIndex = setCurrentRequestAsync();

   298 }

   299 

   300 /*

   301 Launch communication launcher view for the contact with the given ID (QContactLocalId -> int)

   302 */

   303 void CntServiceHandler::open(int contactId)

   304 {

   305     QContactManager manager("symbian");

   306     QContact contact = manager.contact(contactId);

   307 

   308     emit launchContactCard(contact);

   309 

   310     mCurrentRequestIndex = setCurrentRequestAsync();

   311 }

   312 

   313 /*

   314 Launch temporary communication launcher view with the given detail

   315 */

   316 void CntServiceHandler::open(const QString &definitionName, const QString &value)

   317 {

   318     QContact contact;

   319     QContactDetail detail;

   320     

   321     if (definitionName == QContactPhoneNumber::DefinitionName)

   322     {

   323         QContactPhoneNumber phoneNumber;

   324         phoneNumber.setNumber(value);

   325         phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   326         contact.saveDetail(&phoneNumber);

   327         detail = phoneNumber;

   328     }

   329     else if (definitionName == QContactEmailAddress::DefinitionName)

   330     {

   331         QContactEmailAddress email;

   332         email.setEmailAddress(value);

   333         contact.saveDetail(&email);

   334         detail = email;

   335     }

   336     else if (definitionName == QContactOnlineAccount::DefinitionName)

   337     {

   338         QContactOnlineAccount account;

   339         account.setAccountUri(value);

   340         account.setSubTypes(QContactOnlineAccount::SubTypeSipVoip);

   341         contact.saveDetail(&account);

   342         detail = account;

   343     }

   344     

   345     emit launchAssignContactCard(contact, detail);

   346 

   347     mCurrentRequestIndex = setCurrentRequestAsync();

   348 }

   349 

   350 Q_IMPLEMENT_USER_METATYPE(CntServicesContact)

   351 Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(CntServicesContactList)