1 /*

     2 * Copyright (c) 2005 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:  Private implementation file for extended contacts adapter

    15 *

    16 */

    17 

    18 #include <s32strm.h>

    19 #include <s32mem.h>

    20 #include <e32base.h> 

    21 #include <badesca.h>

    22 #include <utf.h>

    23 #include <e32hashtab.h>

    24 #include <qcontactmanager.h>

    25 #include <qcontact.h>

    26 #include <qcontactname.h>

    27 #include <qcontactphonenumber.h>

    28 #include <qcontactsynctarget.h>

    29 #include <qcontacttimestamp.h>

    30 #include <qcontactguid.h>

    31 #include <qcontacttype.h>

    32 #include <qversitwriter.h>

    33 #include <qversitreader.h>

    34 #include <qversitcontactexporter.h>

    35 #include <qversitcontactimporter.h>

    36 #include <xqconversions.h> 

    37 #include <QBuffer>

    38 #include <QMap>

    39 #include <nsmlcontactsdatastoreextension.h>

    40 #include "nsmlcontactsdatastoreextension_p.h"

    41 #include "nsmldebug.h"

    42 

    43 

    44 #ifndef __WINS__

    45 // This lowers the unnecessary compiler warning (armv5) to remark.

    46 // "Warning:  #174-D: expression has no effect..." is caused by 

    47 // DBG_ARGS8 macro in no-debug builds.

    48 #pragma diag_remark 174

    49 #endif

    50 

    51 

    52 /*!

    53   \class CNsmlContactsDataStoreExtensionPrivate

    54   \brief The CNsmlContactsDataStoreExtensionPrivate class provides interface

    55   to access the qtmobility Contacts APIs'

    56 

    57   \sa CNsmlContactsDataStoreExtensionPrivate

    58  */

    59 

    60 

    61 /*!

    62  * Constructor

    63  */

    64 CNsmlContactsDataStoreExtensionPrivate::CNsmlContactsDataStoreExtensionPrivate(const TDesC &manager )

    65 {

    66     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::CNsmlContactsDataStoreExtensionPrivate: BEGIN");

    67     

    68     // Get the QString manager

    69     mManagerName = QString::fromUtf16(manager.Ptr(),manager.Length());

    70     

    71     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Manager: %S"), &manager );

    72     

    73     mWriter = new QVersitWriter;

    74     mReader = new QVersitReader;

    75     mExporter = new QVersitContactExporter;

    76     mImporter = new QVersitContactImporter;

    77     

    78     // Instantiate the Contact Manager

    79     mContactManager = NULL;

    80     QStringList availableManagers = QContactManager::availableManagers();  

    81     

    82     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Manager Count: %d"), availableManagers.count());

    83     

    84     foreach (const QString manager, availableManagers)

    85     {

    86         if( mManagerName == manager )

    87         {

    88             _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::Got a Match");

    89             mContactManager = QContactManager::fromUri(QContactManager::buildUri(manager, QMap<QString, QString>()));

    90         }

    91     }

    92     if( mContactManager == NULL )

    93     {

    94     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::Did Not Find a Match");

    95         mContactManager = new QContactManager( mManagerName );

    96     }

    97    

    98    _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::CNsmlContactsDataStoreExtensionPrivate: END");

    99 }

   100 

   101 /*!

   102  * Destructor

   103  */

   104 CNsmlContactsDataStoreExtensionPrivate::~CNsmlContactsDataStoreExtensionPrivate()

   105 {

   106     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::~CNsmlContactsDataStoreExtensionPrivate: BEGIN");

   107    

   108     

   109     if( mContactManager )

   110         {

   111         delete mContactManager;

   112         mContactManager = NULL;

   113         }

   114     

   115     if( mWriter )

   116         {

   117         delete mWriter;

   118         mWriter = NULL;

   119         }

   120     if( mReader )

   121         {

   122         delete mReader;

   123         mReader = NULL;

   124         }

   125     if( mExporter )

   126         {

   127         delete mExporter;

   128         mExporter = NULL;

   129         }

   130     if( mImporter )

   131         {

   132         delete mImporter;

   133         mImporter = NULL;

   134         }

   135     

   136     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::~CNsmlContactsDataStoreExtensionPrivate: END");

   137 }

   138 

   139 /*!

   140  * Fetch contact

   141  */

   142 TInt CNsmlContactsDataStoreExtensionPrivate::ExportContactsL( const TUid &uid, CBufBase &contactbufbase )

   143 {

   144     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: BEGIN: UID: %d"), uid);

   145    

   146     TInt error(KErrNone);

   147     QList<QContact> contacts;

   148     QBuffer contactsbuf;

   149     contactsbuf.open(QBuffer::ReadWrite);    

   150     mWriter->setDevice( &contactsbuf );  

   151     QContact contact = mContactManager->contact( uid.iUid );

   152     error = mContactManager->error();

   153     if( error != QContactManager::NoError )

   154         {

   155         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:Error %d"), error );

   156         return error; 

   157         }

   158 	contacts.append( contact );    

   159     

   160     if( mExporter->exportContacts( contacts, QVersitDocument::VCard21Type ) )

   161         {

   162         QList<QVersitDocument> documents = mExporter->documents();        

   163         mWriter->startWriting( documents );

   164         bool status = mWriter->waitForFinished();  

   165         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:status %d"), status);  

   166         HBufC8* buf = XQConversions::qStringToS60Desc8( contactsbuf.data() );

   167         contactbufbase.InsertL( contactbufbase.Size(), *buf );

   168         delete buf;

   169         }

   170     else

   171         {

   172         error = KErrGeneral;

   173         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:Error in exporting %d"), error );

   174         }

   175     

   176     TPtr8 ptrbuf(contactbufbase.Ptr(0));

   177     DBG_DUMP( (void*)ptrbuf.Ptr(), ptrbuf.Length(),

   178            _S8("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: From DB:"));  

   179     

   180     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: END");

   181     

   182     return error;

   183 }

   184 

   185 /*!

   186  * Store contact

   187  */

   188 CArrayFixFlat<TUid>* CNsmlContactsDataStoreExtensionPrivate::ImportContactsL( const TDesC8 &contactbufbase )

   189 {

   190     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: BEGIN");    

   191 

   192     DBG_DUMP((void*)contactbufbase.Ptr(), contactbufbase.Length(),

   193         _S8("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: To DB :"));      

   194     

   195     TBool ret( ETrue );

   196     CArrayFixFlat<TUid>* contactItems = new(ELeave) CArrayFixFlat<TUid>(4);

   197     QBuffer contactsbuf;

   198     contactsbuf.open(QBuffer::ReadWrite);

   199     QByteArray bytearray((char*)contactbufbase.Ptr());

   200     

   201     contactsbuf.write(bytearray);

   202     contactsbuf.seek(0);

   203     

   204     mReader->setDevice(&contactsbuf);

   205     if (mReader->startReading() && mReader->waitForFinished()) 

   206         {

   207         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Buffer Count: %d"), mReader->results().count() );

   208         

   209         QList<QContact> contacts;

   210         if ( mImporter->importDocuments( mReader->results() ) )

   211             {

   212             contacts = mImporter->contacts();

   213             QMap<int, QContactManager::Error> errorMap;

   214             ret = mContactManager->saveContacts( &contacts, &errorMap );           

   215             DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Import Status: %d"), ret );

   216             }

   217         if( ret )

   218             {

   219             foreach (QContact contact, contacts ) 

   220                 {

   221                 TUint contactid = contact.id().localId();

   222                 

   223                 DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Contact ID: %d"), contactid );

   224                 

   225                 contactItems->AppendL( TUid::Uid( contactid ) );

   226                 }

   227             }

   228             

   229         if( contactItems->Count() <= 0 )

   230             {

   231             delete contactItems;

   232             contactItems = NULL;

   233             }

   234         }

   235     

   236     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: END");

   237     

   238     return contactItems;

   239 }

   240 

   241 /*!

   242  * Reads a Contact Details

   243  */

   244 TInt CNsmlContactsDataStoreExtensionPrivate::ReadContactL( const TUid &uid, CNsmlContactItem *contactitem )

   245     {

   246     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ReadContactL: BEGIN ID: %d"), uid);

   247     

   248     TInt error(KErrNone);

   249     

   250     QContact contact = mContactManager->contact( uid.iUid );

   251     error = mContactManager->error();

   252     if( error != QContactManager::NoError )

   253         {

   254         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ReadContactL:Error %d"), error );

   255         return error;

   256         }

   257         

   258     // Fetch the contact details

   259     QContactTimestamp timestamp = contact.detail( QContactTimestamp::DefinitionName );

   260     // Created Time

   261     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::created: %d"), timestamp.created().toTime_t () );

   262     

   263     // Last Modified Time

   264     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::modified: %d"), timestamp.lastModified().toTime_t () );

   265     contactitem->iLastModified = qTimeToS60TTime( timestamp.lastModified() );

   266        

   267     // Contact Type

   268     QContactType contacttype = contact.detail( QContactType::DefinitionName );

   269     contacttype.type();

   270     

   271     // GUID

   272     QContactGuid contactguid = contact.detail( QContactGuid::DefinitionName );

   273     contactitem->iGuid = XQConversions::qStringToS60Desc8( contactguid.guid() );

   274     

   275     // UID

   276     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ReadContactL:LUID %d"), contact.localId() );

   277     contactitem->iUid = TUid::Uid(contact.localId());

   278     

   279     // SyncTarget

   280     QContactSyncTarget contactsynctarget = contact.detail( QContactSyncTarget::DefinitionName );

   281     contactsynctarget.syncTarget();

   282     

   283     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ReadContactL: END");

   284     

   285     return error;

   286     }

   287 

   288 /*!

   289  * Delete a contact

   290  */

   291 TBool CNsmlContactsDataStoreExtensionPrivate::DeleteContactL( const TUid &uid )

   292     {

   293     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::DeleteContactL: BEGIN");

   294     

   295     TBool ret = mContactManager->removeContact( uid.iUid );

   296     

   297     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::DeleteContactL: END %d"), ret );

   298     

   299     return ret;

   300     }

   301 

   302 /*!

   303  * Delete array of contacts

   304  */

   305 TBool CNsmlContactsDataStoreExtensionPrivate::DeleteContactsL( CArrayFixFlat<TUid> *arrDelete )

   306     {

   307     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::DeleteContactsL: BEGIN");

   308     

   309     QList<QContactLocalId> contacts;

   310     for( TInt count = 0; count < arrDelete->Count(); count++ )

   311         {

   312         contacts.append( arrDelete->At( count ).iUid );

   313         }

   314     

   315     QMap<int, QContactManager::Error> errorMap;

   316     TBool ret = mContactManager->removeContacts( contacts, &errorMap );

   317     

   318     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::DeleteContactsL: END");

   319     

   320     return ret;

   321     }

   322 

   323 /*!

   324  * Delete all contacts except selfcontact

   325  */

   326 TBool CNsmlContactsDataStoreExtensionPrivate::DeleteAllContactsL()

   327     {

   328     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::DeleteAllContactsL: BEGIN");

   329     

   330     QContactLocalId selfcontactid = mContactManager->selfContactId();

   331     QList<QContactLocalId> contactIds = mContactManager->contactIds();

   332     int index = contactIds.indexOf( selfcontactid );   

   333     contactIds.removeAt( index );

   334     

   335     QMap<int, QContactManager::Error> errorMap;

   336     TBool ret = mContactManager->removeContacts( contactIds, &errorMap );

   337     

   338     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::DeleteAllContactsL: END");

   339     

   340     return ret;

   341     }

   342 

   343 /*!

   344  * List the available managers

   345  */

   346 void CNsmlContactsDataStoreExtensionPrivate::ListStoresL( CDesCArray *cntstores )

   347     {

   348     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ListStoresL: BEGIN");

   349     

   350     QStringList availableManagers = QContactManager::availableManagers();    

   351     foreach (const QString manager, availableManagers)

   352     {

   353         HBufC* buf = XQConversions::qStringToS60Desc( manager );

   354         cntstores->AppendL( buf->Des() );

   355         delete buf;

   356     }

   357     

   358     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ListStoresL: END");

   359     }

   360 

   361 

   362 /*!

   363  * Fetch Manager URI

   364  */

   365 TInt64 CNsmlContactsDataStoreExtensionPrivate::MachineIdL()

   366     {

   367     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::MachineIdL: BEGIN");

   368    

   369     HBufC* buf = XQConversions::qStringToS60Desc( mContactManager->managerUri() );

   370     TInt64 machineid = DefaultHash::Des16( buf->Des() );

   371     delete buf;

   372     

   373     DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::MachineIdL: %ld"), machineid );

   374     

   375     return machineid;

   376     }

   377 

   378 /*!

   379  * List all contacts

   380  */

   381 void CNsmlContactsDataStoreExtensionPrivate::ListContactsL( CArrayFixFlat<TUid> *contactuidlist )

   382     {

   383     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ListContactsL: BEGIN");

   384     

   385     QList<QContactLocalId> contactIds = mContactManager->contactIds();    

   386      

   387     foreach (QContactLocalId id, contactIds )

   388         {

   389         DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ListContactsL: %d"), id );

   390         contactuidlist->AppendL( TUid::Uid(id) );

   391         }    

   392     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ListContactsL: END");

   393     }

   394 

   395 /*!

   396  * Convert QTime to S60 TTime

   397  */

   398 TTime CNsmlContactsDataStoreExtensionPrivate::qTimeToS60TTime(const QDateTime &datetime)

   399     {

   400     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::qTimeToS60TTime: BEGIN");

   401     

   402     //Symbian month & day are zero based, so -1 from Qt's

   403     TDateTime dt(datetime.date().year(), 

   404     TMonth(datetime.date().month() - 1),

   405     datetime.date().day() - 1,

   406     datetime.time().hour(),

   407     datetime.time().minute(),

   408     datetime.time().second(),

   409     datetime.time().msec() * 1000);

   410     

   411     _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::qTimeToS60TTime: END");

   412     return TTime(dt);

   413     }

   414 

   415 // End of File