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 "cntservices.h"

    19 #include "cntglobal.h"

    20 #include "cntdebug.h"

    21 #include <cntabstractviewmanager.h>

    22 #include "cntserviceviewmanager.h"

    23 #include "cntimageutility.h"

    24 #include "cntserviceviewparams.h"

    25 #include <cntservicescontact.h>

    26 

    27 #include <hbview.h>

    28 #include <hblistview.h>

    29 #include <qversitreader.h>

    30 #include <qversitcontactimporter.h>

    31 #include <qversitdocument.h>

    32 #include <xqserviceprovider.h>

    33 

    34 #include <QApplication>

    35 #include <QPixmap>

    36 #include <QFile>

    37 #include <QUrl>

    38 

    39 CntServices::CntServices() :

    40 mViewManager(NULL),

    41 mCurrentProvider(NULL),

    42 mIsQuittable(true)

    43 {

    44     CNT_ENTRY

    45 

    46     // Definition names supported in symbian back-end

    47     m_definitionNames << QContactName::DefinitionName;

    48     m_definitionNames << QContactNickname::DefinitionName;

    49     m_definitionNames << QContactPhoneNumber::DefinitionName;

    50     m_definitionNames << QContactEmailAddress::DefinitionName;

    51     m_definitionNames << QContactAddress::DefinitionName;

    52     m_definitionNames << QContactUrl::DefinitionName;

    53     m_definitionNames << QContactBirthday::DefinitionName;

    54     m_definitionNames << QContactOrganization::DefinitionName;

    55     m_definitionNames << QContactSyncTarget::DefinitionName;

    56     m_definitionNames << QContactNote::DefinitionName;

    57     m_definitionNames << QContactFamily::DefinitionName;

    58     m_definitionNames << QContactAvatar::DefinitionName;

    59     m_definitionNames << QContactAnniversary::DefinitionName;

    60     m_definitionNames << QContactGeoLocation::DefinitionName;

    61     m_definitionNames << QContactGender::DefinitionName;

    62     m_definitionNames << QContactOnlineAccount::DefinitionName;

    63     

    64     CNT_EXIT

    65 }

    66 

    67 

    68 CntServices::~CntServices()

    69 {

    70     CNT_LOG

    71 }

    72 

    73 

    74 void CntServices::setViewManager( CntAbstractViewManager& aViewManager )

    75 {

    76     CNT_LOG

    77     mViewManager = &aViewManager;

    78     CntServiceViewManager* srvMng = static_cast<CntServiceViewManager*>(mViewManager);

    79     connect(srvMng, SIGNAL(applicationClosed()), this, SLOT(terminateService()));

    80 }

    81 

    82 

    83 void CntServices::singleFetch(

    84     const QString &title, const QString &action,

    85     CntAbstractServiceProvider& aServiceProvider )

    86 {

    87     CNT_ENTRY

    88     mCurrentProvider = &aServiceProvider;

    89 

    90     CntViewParameters params;

    91     params.insert(EViewId, serviceContactFetchView);

    92     params.insert(ESelectedAction, action);

    93     params.insert(KCntServiceViewParamTitle, title);

    94     // SINGLE fetch

    95     params.insert(ESelectionMode, HbAbstractItemView::SingleSelection);

    96 

    97     mViewManager->changeView(params);

    98     CNT_EXIT

    99 }

   100 

   101 

   102 void CntServices::multiFetch(

   103     const QString &title, const QString &action,

   104     CntAbstractServiceProvider& aServiceProvider )

   105 {

   106     CNT_ENTRY

   107     mCurrentProvider = &aServiceProvider;

   108 

   109     CntViewParameters params;

   110     params.insert(EViewId, serviceContactFetchView);

   111     params.insert(ESelectedAction, action);

   112     params.insert(KCntServiceViewParamTitle, title);

   113     // MULTI fetch

   114     params.insert(ESelectionMode, HbAbstractItemView::MultiSelection);

   115     mViewManager->changeView(params);

   116     CNT_EXIT

   117 }

   118 

   119 void CntServices::editCreateNew(const QString &definitionName, const QString &value,

   120     CntAbstractServiceProvider& aServiceProvider, bool defaultForOnlineAccountIsImpp )

   121 {

   122     CNT_ENTRY

   123     editCreateNew( definitionName, value, QString(), aServiceProvider, defaultForOnlineAccountIsImpp);

   124     CNT_EXIT

   125 }

   126 

   127 void CntServices::editCreateNew(const QString &definitionName, const QString &value, const QString& subType,

   128     CntAbstractServiceProvider& aServiceProvider, bool defaultForOnlineAccountIsImpp )

   129 {

   130     CNT_ENTRY

   131     mCurrentProvider = &aServiceProvider;

   132 

   133     QContact contact;

   134     

   135     if (definitionName == QContactPhoneNumber::DefinitionName)

   136     {

   137         QContactPhoneNumber phoneNumber;

   138         phoneNumber.setNumber(value);

   139         if (!subType.isEmpty())

   140         {

   141             phoneNumber.setSubTypes(subType);

   142         }

   143         else

   144         {

   145             phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile); // Mobile is the default if subtype is not given.

   146         }

   147          contact.saveDetail(&phoneNumber);

   148     }

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

   150     {

   151         QContactEmailAddress email;

   152         email.setEmailAddress(value);

   153         // Email addresses can't have subtypes.

   154         contact.saveDetail(&email);

   155     }

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

   157     {

   158         QContactOnlineAccount account;

   159         fillOnlineAccount( account, value, subType, defaultForOnlineAccountIsImpp);

   160         contact.saveDetail(&account);

   161     }    

   162 

   163     // Launch editor now

   164     CntViewParameters params;

   165     params.insert(EViewId, serviceEditView);

   166     QVariant var;

   167     var.setValue(contact);

   168     params.insert(ESelectedContact, var);

   169     mViewManager->changeView(params);

   170     CNT_EXIT

   171 }

   172 

   173 

   174 void CntServices::editCreateNewFromVCard(const QString &vCardFile,

   175     CntAbstractServiceProvider& aServiceProvider )

   176 {

   177     CNT_ENTRY

   178     mCurrentProvider = &aServiceProvider;

   179 

   180     CntImageUtility imageUtility;

   181     QContact contact;

   182     QVersitReader reader;

   183     QFile file(vCardFile);

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

   185         return;

   186     reader.setDevice(&file);

   187     

   188     reader.startReading();

   189     reader.waitForFinished();

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

   191     QVersitContactImporter importer;

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

   193     if(versitDocuments.count() > 0 

   194        && importer.importDocuments(versitDocuments))

   195         {

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

   197         if(contacts.count() > 0)

   198             contact = contacts.first();

   199         }

   200     file.close();

   201     

   202     // Save thumbnail images

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

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

   205         {

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

   207             {

   208             QString imagepath;

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

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

   211                 {

   212                 // Update contact detail

   213                 QContactAvatar detail=details.at(i);

   214                 detail.setImageUrl(imagepath);

   215                 contact.saveDetail(&detail);

   216                 }

   217             }

   218         }

   219     

   220     removeNotSupportedDetails(contact);

   221     removeNotSupportedFields(contact);

   222 

   223     // Launch editor now

   224     CntViewParameters params;

   225     params.insert(EViewId, serviceEditView);

   226     QVariant var;

   227     var.setValue(contact);

   228     params.insert(ESelectedContact, var);

   229     mViewManager->changeView(params);

   230     CNT_EXIT

   231 }

   232 

   233 void CntServices::editUpdateExisting(const QString &definitionName, const QString &value,

   234     CntAbstractServiceProvider& aServiceProvider, bool defaultForOnlineAccountIsImpp )

   235 {

   236     CNT_ENTRY

   237     editUpdateExisting( definitionName, value, QString(), aServiceProvider, defaultForOnlineAccountIsImpp );

   238     CNT_EXIT

   239 }

   240 

   241 void CntServices::editUpdateExisting(const QString &definitionName, const QString &value, const QString& subType,

   242     CntAbstractServiceProvider& aServiceProvider, bool defaultForOnlineAccountIsImpp )

   243 {

   244     CNT_ENTRY

   245     mCurrentProvider = &aServiceProvider;

   246 

   247     QContactDetail detail;

   248     

   249     if (definitionName == QContactPhoneNumber::DefinitionName)

   250     {

   251         QContactPhoneNumber phoneNumber;

   252         phoneNumber.setNumber(value);

   253         if (!subType.isEmpty())

   254         {        

   255             phoneNumber.setSubTypes(subType);

   256         }

   257         else

   258         {

   259             phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile);    

   260         }

   261         detail = phoneNumber;

   262     }

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

   264     {

   265         QContactEmailAddress email;

   266         email.setEmailAddress(value);

   267         // Email addresses can't have subtypes.

   268         detail = email;

   269     }

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

   271     {

   272         QContactOnlineAccount account;

   273         fillOnlineAccount( account, value, subType, defaultForOnlineAccountIsImpp);

   274         detail = account;

   275     }

   276 

   277     CntViewParameters params;

   278     params.insert(EViewId, serviceContactSelectionView);

   279     QVariant var;

   280     var.setValue(detail);

   281     params.insert(ESelectedDetail, var);

   282     mViewManager->changeView(params);

   283     CNT_EXIT

   284 }

   285 

   286 void CntServices::editExisting(int contactId,

   287 CntAbstractServiceProvider& aServiceProvider)

   288 {

   289     CNT_ENTRY

   290     mCurrentProvider = &aServiceProvider;

   291 

   292     // Give parameters for launching editor.

   293     CntViewParameters params;

   294     params.insert(EViewId, serviceEditView);

   295 

   296     QContact contact = contactManager()->contact(contactId);

   297     QVariant varContact;

   298     varContact.setValue(contact);

   299     params.insert(ESelectedContact, varContact);

   300     mViewManager->changeView(params);

   301     CNT_EXIT

   302 }

   303 

   304 

   305 void CntServices::launchContactCard(int aContactId,

   306     CntAbstractServiceProvider& aServiceProvider )

   307 {

   308     CNT_ENTRY

   309     mCurrentProvider = &aServiceProvider;

   310 

   311     QContact contact = contactManager()->contact(aContactId);

   312 

   313     // Launch Contact Card view

   314     CntViewParameters params;

   315     params.insert(EViewId, serviceContactCardView);

   316     QVariant var;

   317     var.setValue(contact);

   318     params.insert(ESelectedContact, var);

   319     mViewManager->changeView( params );

   320     CNT_EXIT

   321 }

   322 

   323 

   324 void CntServices::launchTemporaryContactCard(const QString &definitionName, const QString &value,

   325     CntAbstractServiceProvider& aServiceProvider )

   326 {

   327     CNT_ENTRY

   328     mCurrentProvider = &aServiceProvider;

   329 

   330     QContact contact;

   331     QContactDetail detail;

   332     

   333     QContactName name;

   334     name.setFirstName(hbTrId("txt_phob_list_unknown"));

   335     contact.saveDetail(&name);

   336     

   337     if (definitionName == QContactPhoneNumber::DefinitionName)

   338     {

   339         QContactPhoneNumber phoneNumber;

   340         phoneNumber.setNumber(value);

   341         phoneNumber.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   342         contact.saveDetail(&phoneNumber);

   343         detail = phoneNumber;

   344     }

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

   346     {

   347         QContactEmailAddress email;

   348         email.setEmailAddress(value);

   349         contact.saveDetail(&email);

   350         detail = email;

   351     }

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

   353     {

   354         QContactOnlineAccount account;

   355         account.setAccountUri(value);

   356         account.setSubTypes(QContactOnlineAccount::SubTypeSipVoip);

   357         contact.saveDetail(&account);

   358         detail = account;

   359     }

   360 

   361     // Launch the view

   362     CntViewParameters params;

   363     params.insert(EViewId, serviceAssignContactCardView);

   364     QVariant var;

   365     var.setValue(contact);

   366     params.insert(ESelectedContact, var);

   367     QVariant varDetail;

   368     varDetail.setValue(detail);

   369     params.insert(ESelectedDetail, varDetail);

   370     mViewManager->changeView(params);

   371     CNT_EXIT

   372 }

   373 

   374 void CntServices::launchGroupMemberView(int aContactId,

   375     CntAbstractServiceProvider& aServiceProvider )

   376 {

   377     CNT_ENTRY

   378     mCurrentProvider = &aServiceProvider;

   379 

   380     QContact contact = contactManager()->contact(aContactId);

   381 

   382     // Launch Group member view

   383     CntViewParameters params;

   384     params.insert(EViewId, serviceGroupMemberView);

   385     QVariant var;

   386     var.setValue(contact);

   387     params.insert(ESelectedGroupContact, var);

   388     mViewManager->changeView( params );

   389     CNT_EXIT

   390 }

   391 

   392 void CntServices::setQuittable(bool quittable)

   393 {

   394     mIsQuittable = quittable;

   395 }

   396 

   397 void CntServices::quitApp()

   398 {

   399     CNT_ENTRY

   400    

   401     // Only embedded applications should be exited once a client

   402     // disconnects. At the moments QtHighWay has unresolved issues

   403     // when closing non-embedded applications. Error ou1cimx1#472852

   404     // has more info

   405     if ( mIsQuittable ) 

   406     {

   407        qApp->quit();

   408     }   

   409     CNT_EXIT

   410 }

   411 

   412 void CntServices::removeNotSupportedDetails(QContact& contact)

   413 {

   414     CNT_ENTRY

   415     // Check definition map, remove details not supported

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

   417     {

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

   419         {

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

   421             contact.removeDetail(&detail);

   422         }

   423     }

   424     CNT_EXIT

   425 }

   426 

   427 void CntServices::removeNotSupportedFields(QContact& contact)

   428 {

   429     CNT_ENTRY

   430     QList<QContactDetail>   removeList;

   431     

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

   433     // Remove not supported fields

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

   435     {

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

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

   438         {

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

   440             

   441             // Sub-types not supported

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

   443                 contact.saveDetail(&detail);

   444         }

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

   446         {

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

   448             

   449             // Sub-types not supported

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

   451                 contact.saveDetail(&detail);

   452             

   453             // Context not supported

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

   455                 contact.saveDetail(&detail);

   456         }

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

   458         {

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

   460             

   461             if(phoneDetail.subTypes().size() > 0 )

   462             {

   463                 // Sub-types not supported

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

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

   466                 {

   467                     // Default to subtype mobile

   468                     QStringList l;

   469                     l << QLatin1String(QContactPhoneNumber::SubTypeMobile);

   470                     detail.setValue(QContactPhoneNumber::FieldSubTypes, l);

   471                     contact.saveDetail(&detail);

   472                 }

   473             }

   474         }

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

   476         {

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

   478             

   479             QString stype=QContactUrl::SubTypeHomePage;

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

   481             {

   482                 detail.removeValue(QContactUrl::FieldSubType);

   483                 contact.saveDetail(&detail);

   484             }

   485         }

   486     }

   487     CNT_EXIT

   488 }

   489 

   490 void CntServices::fillOnlineAccount( QContactOnlineAccount& account, const QString& value,

   491     const QString& subType, bool defaultForOnlineAccountIsImpp )

   492     {

   493         // The value should normally consist of two parts:

   494         //    <service provider>:<user ID>

   495         // for eg. "serviceprovider:jack@serviceprovider.com"

   496         QStringList accountDetails = value.split(":");

   497         if (accountDetails.count() == 1)

   498         {

   499             // For some reason it only had one part, so we're assuming it's the user ID.

   500             account.setAccountUri(accountDetails.at(0));

   501         }

   502         else if (accountDetails.count() >= 2)

   503         {

   504             account.setServiceProvider(accountDetails.at(0));        

   505             account.setAccountUri(accountDetails.at(1)); // the user ID

   506         }

   507 

   508         if (!subType.isEmpty())

   509         {        

   510             account.setSubTypes(subType);

   511         }

   512         else

   513         {

   514             if (defaultForOnlineAccountIsImpp)

   515             {

   516                 account.setSubTypes( QContactOnlineAccount::SubTypeImpp );

   517             }

   518             else

   519             {

   520                 account.setSubTypes( QContactOnlineAccount::SubTypeSipVoip );

   521             }

   522         }

   523     }

   524 

   525 // This method is inherited from CntAbstractServiceProvider

   526 void CntServices::CompleteServiceAndCloseApp(const QVariant& retValue)

   527 {

   528     CNT_ENTRY

   529     if (  mCurrentProvider )

   530     {

   531         mCurrentProvider->CompleteServiceAndCloseApp( retValue );

   532     }

   533     CNT_EXIT

   534 }

   535 

   536 void CntServices::terminateService()

   537 {

   538     CNT_ENTRY

   539     if (  mCurrentProvider )

   540     {

   541         // Complete the service with KCntServicesTerminated return value

   542         QVariant var(KCntServicesTerminated);

   543         mCurrentProvider->CompleteServiceAndCloseApp( var );

   544     }

   545     CNT_EXIT

   546 }

   547 

   548 QContactManager* CntServices::contactManager()

   549 {

   550     if ( mViewManager )

   551         return mViewManager->contactManager(SYMBIAN_BACKEND);

   552     return NULL;

   553 }

   554 

   555 Q_IMPLEMENT_USER_METATYPE(CntServicesContact)

   556 Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(CntServicesContactList)

   557