1 /*

     2 * Copyright (c) 2002 - 2007 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 the License "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:   ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <Stiftestinterface.h>

    25 #include <VPbkEng.rsg>

    26 

    27 #include <MVPbkContactFieldTextData.h>

    28 #include <MVPbkContactStoreList.h>

    29 #include <MVPbkContactOperationBase.h>

    30 #include <MVPbkContactLink.h>

    31 #include <CVPbkContactLinkArray.h>

    32 #include <MVPbkContactGroup.h>

    33 #include <utf.h>

    34 #include <CVPbkPhoneNumberMatchStrategy.h>

    35 #include <CVPbkContactStoreUriArray.h>

    36 #include <TVPbkContactStoreUriPtr.h>

    37 #include "tcontacts_async.h"

    38 #include "singlecontact.h"

    39 

    40 // CONSTANTS

    41 _LIT(KError,"Error code is");

    42 _LIT(KSuccess,"Successful");

    43 _LIT(KNewLine,"\n");

    44 _LIT(KServiceOpen,"Service handle created");

    45 _LIT(KServiceClose,"Service handle deleted");

    46 _LIT(KPhoneNumber,"9886431364");

    47  _LIT(KGroup1,"Test1");

    48  TInt KInvalidKey = -1;

    49 // ============================ MEMBER FUNCTIONS ===============================

    50 

    51 // -----------------------------------------------------------------------------

    52 // CContactsUT::Delete

    53 // Delete here all resources allocated and opened from test methods. 

    54 // Called from destructor. 

    55 // -----------------------------------------------------------------------------

    56 //

    57 void CContactsUT::Delete() 

    58     {

    59 

    60     }

    61 

    62 // -----------------------------------------------------------------------------

    63 // CContactsUT::RunMethodL

    64 // Run specified method. Contains also table of test mothods and their names.

    65 // -----------------------------------------------------------------------------

    66 //

    67 TInt CContactsUT::RunMethodL( 

    68     CStifItemParser& aItem ) 

    69     {

    70 

    71     static TStifFunctionInfo const KFunctions[] =

    72         { 

    73         ENTRY( "Add_contact_sapi", CContactsUT::AddContactSAPIL ),

    74         ENTRY( "Delete_contact_sapi", CContactsUT::DeleteContactSAPIL ),

    75         ENTRY( "Modify_contact_sapi", CContactsUT::ModifyContactSAPIL ),

    76         ENTRY( "Getlist_delete_contact", CContactsUT::GetListDeleteContactL ),

    77         ENTRY( "Add_getlist_contact", CContactsUT::AddContactGetListL ), 

    78         ENTRY( "Get_group", CContactsUT::GetGroupsL ),

    79         ENTRY( "Get_contact", CContactsUT::GetContactsL ),

    80         ENTRY( "Get_database", CContactsUT::GetDatabaseL ),

    81         ENTRY( "Add_contact", CContactsUT::AddL ),

    82         ENTRY( "Add_group", CContactsUT::AddGroupL ),

    83         ENTRY( "Modify_contact", CContactsUT::ModifyL ),

    84         ENTRY( "Modify_group", CContactsUT::ModifyGroupL ),

    85         ENTRY( "Delete_contact", CContactsUT::DeleteContactL ),

    86         ENTRY( "Delete_group", CContactsUT::DeleteGroupL ),

    87         ENTRY( "Organise_add", CContactsUT::OrganiseAddL ),

    88         ENTRY( "Organise_delete", CContactsUT::OrganiseDeleteL ),

    89         ENTRY( "Import", CContactsUT::ImportL ),

    90         ENTRY( "Export", CContactsUT::ExportL ),

    91         ENTRY( "Get_SearchContact", CContactsUT::GetSearchContactL ),

    92         ENTRY( "Get_ContactAsc", CContactsUT::GetContactsAscOrderL ),

    93         ENTRY( "Get_ContactDsc", CContactsUT::GetContactsDscOrderL ),

    94         ENTRY( "Get_ContactbyId", CContactsUT::GetListConactIdL ),

    95         ENTRY( "AddInvalidField", CContactsUT::AddInvalidFieldL ),

    96         ENTRY( "AddMultiplePhoneNumbersContact", CContactsUT::AddMultiplePhoneNumbersContactL ),

    97         ENTRY( "DeleteSingleContact", CContactsUT::DeleteSingleContactL ),

    98         ENTRY( "GetListCancelTest", CContactsUT::GetListCancelL ),

    99         ENTRY( "GetListSrchCancelTest", CContactsUT::GetListSrchCancelL ),

   100         ENTRY( "ExportCancelTest",  CContactsUT::ExportCancelL ),

   101         ENTRY( "AddCancelTest", CContactsUT::AddCancelL ),

   102         ENTRY( "ImportCancelTest", CContactsUT::ImportCancelL ),

   103         ENTRY( "DeleteCancelTest", CContactsUT::DeleteCancelL ),

   104         ENTRY( "OrganiseCancelTest", CContactsUT::OrganiseCancelL),

   105         };

   106 

   107     const TInt count = sizeof( KFunctions ) / 

   108                         sizeof( TStifFunctionInfo );

   109 

   110     return RunInternalL( KFunctions, count, aItem );

   111 

   112     }

   113 

   114 

   115 void CContactsUT::HandleReturnValue(TOperationEvent /*aEvent*/,  const TInt& aError, TInt /*aTransId*/ )

   116     {

   117     CActiveScheduler::Stop();

   118     _LIT(KFunc,"In Handle Return Value\n");

   119     iLog->Log(KFunc);

   120     if(aError == KErrArgument)

   121     iErr = KErrNone;

   122     else

   123     iErr = aError;

   124     TBuf<5> buf;

   125     buf.Num(aError);

   126     iLog->Log(KError);

   127     iLog->Log(buf);

   128     iLog->Log(KNewLine);

   129     }

   130     

   131 void CContactsUT::HandleReturnIter(const TInt& aError, CContactIter* aIter, TInt /*aTransId*/ )

   132     {

   133     CActiveScheduler::Stop();

   134     _LIT(KFunc,"In Handle Return Iter\n");

   135     iLog->Log(KFunc);

   136     iErr = aError;

   137     TBuf<5> buf;

   138     buf.Num(aError);

   139     iLog->Log(KError);

   140     iLog->Log(buf);

   141     iLog->Log(KNewLine);       

   142     

   143     if(EGetContactDelete == iOperation )

   144         {

   145         iOperation = ENone;        

   146         CSingleContact* singleContact = NULL;  

   147         HBufC8* buf = NULL;

   148         TInt count = 0; 

   149         while(ETrue)

   150             {

   151             aIter->NextL(singleContact,buf);

   152             if(!singleContact)

   153                 {

   154                 break;

   155                 }

   156             iBuffer = buf;

   157            // delete buf;

   158             delete singleContact;

   159             break;

   160             }

   161         }

   162     if(iOperation == EContact)

   163         {

   164         iOperation = ENone;

   165         iErr = KErrGeneral;

   166         CSingleContact* singleContact = NULL;        

   167         HBufC8* buf = NULL; 

   168         

   169         _LIT(KPhone,"Birbal");       

   170         _LIT8(KField,"FirstName");

   171         

   172         while(ETrue)

   173             {

   174             __UHEAP_MARK;

   175             aIter->NextL(singleContact,buf);           

   176             if(!singleContact)

   177                 {

   178                 break;

   179                 }            

   180             CleanupStack::PushL(singleContact);

   181             //CleanupStack::PushL(buf);            

   182             if(!buf->Compare(*iBuffer))

   183                 {     

   184                 TInt count(singleContact->FieldCount());       

   185                 CSingleContactField* field = NULL;                 

   186                 while(count)

   187                     {            

   188                     TPtrC8 fieldKey;

   189                     TPtrC label;

   190                     TPtrC value;

   191                     field = singleContact->FieldAt(--count);

   192                     field->GetFieldDataL(fieldKey,label,value);

   193                     if(!fieldKey.Compare(KField))

   194                         {

   195                         field->SetFieldParamsL(KField,KNullDesC,KPhone);

   196                         iLog->Log(_L("Phone Contact Field modified \n"));

   197                         __UHEAP_MARK;

   198                         iServiceHandle->AddL(this,0,singleContact);

   199                         iLog->Log(_L("AddL called\n"));

   200                         iLog->Log(_L("Start Active Scheduler\n"));

   201                         CActiveScheduler::Start(); 

   202                         __UHEAP_MARKEND;

   203                         break;                        

   204                         }

   205                     }

   206                 }            

   207               

   208             //CleanupStack::PopAndDestroy(buf);

   209             delete buf;

   210             CleanupStack::PopAndDestroy(singleContact);  

   211             __UHEAP_MARKEND;

   212             }

   213          } 

   214     if(EGetContact == iOperation )

   215         {

   216         iOperation = ENone;

   217         //iErr = KErrGeneral;

   218         _LIT8(KFirstName,"FirstName");

   219         _LIT(KName,"Kats"); 

   220         CSingleContact* singleContact = NULL;  

   221         HBufC8* buf = NULL;

   222         TInt count = 0; 

   223         while(ETrue)

   224             {

   225             aIter->NextL(singleContact,buf);

   226             if(!singleContact)

   227                 {

   228                 break;

   229                 }

   230             ++count;

   231             TInt count(singleContact->FieldCount());            

   232             while(count)

   233                 {

   234                 CSingleContactField* field = singleContact->FieldAt(--count);

   235                 TPtrC8 fieldKey;

   236                 TPtrC label;

   237                 TPtrC value;

   238                 field->GetFieldDataL(fieldKey,label,value);

   239                 if (fieldKey == KFirstName && value == KName)

   240                     {

   241                     iErr = KErrNone;

   242                     }

   243               //  delete field;

   244                 }

   245             delete buf;

   246             delete singleContact;

   247             }

   248 		delete buf;            

   249         }

   250     if(EContactVerify == iOperation )

   251         {       

   252         iOperation = ENone;

   253         iErr = KErrGeneral;

   254         _LIT8(KFirstName,"FirstName");

   255         _LIT(KName,"Tenali"); 

   256         CSingleContact* singleContact = NULL;  

   257         HBufC8* buf = NULL;

   258         aIter->NextL(singleContact,buf);

   259         if(buf->Compare(*iBuf)==0)

   260             {

   261             iErr = KErrNone;    

   262             }

   263         }    

   264     if(EContactId == iOperation )

   265         {

   266         iOperation = ENone;

   267         //iErr = KErrGeneral;

   268         _LIT8(KFirstName,"FirstName");

   269         _LIT(KName,"Tenali"); 

   270         CSingleContact* singleContact = NULL;  

   271         HBufC8* buf = NULL;

   272         TInt count = 0; 

   273         

   274         aIter->NextL(singleContact,buf);

   275         iOperation = EContactVerify;

   276         iBuf = buf;

   277         iServiceHandle->GetListL(this,0,EContacts,*buf);

   278         CActiveScheduler::Start();

   279         delete singleContact;                       

   280         } 

   281     if(ESearchContact == iOperation )

   282         {

   283         iOperation = ENone;

   284         iErr = KErrGeneral;

   285         _LIT8(KFirstName,"FirstName");

   286         _LIT(KName,"Tenali"); 

   287         CSingleContact* singleContact = NULL;  

   288         HBufC8* buf = NULL;

   289         TInt count = 0; 

   290         while(ETrue)

   291             {

   292             aIter->NextL(singleContact,buf);

   293             if(!singleContact)

   294                 {

   295                 break;

   296                 }

   297             ++count;

   298             TInt count(singleContact->FieldCount());

   299             while(count)

   300                 {

   301                 CSingleContactField* field = singleContact->FieldAt(--count);

   302                 TPtrC8 fieldKey;

   303                 TPtrC label;

   304                 TPtrC value;

   305                 field->GetFieldDataL(fieldKey,label,value);

   306                 if (fieldKey == KFirstName && value == KName)

   307                     {

   308                     iErr = KErrNone;

   309                     }

   310             else if (fieldKey == KFirstName)

   311                 {

   312                 break;    

   313                 }

   314             }

   315         delete singleContact;            

   316         }

   317         }

   318      if(EAscContact == iOperation )

   319         {

   320         iOperation = ENone;

   321         iErr = KErrGeneral;

   322         _LIT8(KFirstName,"FirstName");

   323         _LIT(KNameT,"Tenali");

   324         _LIT(KNameB,"Birbal"); 

   325         TInt count1 = 0;

   326         TInt tCount = 0;

   327         TInt bCount = 0;

   328         CSingleContact* singleContact = NULL;  

   329         HBufC8* buf = NULL;

   330         TInt count = 0; 

   331         

   332         while(ETrue)

   333             {

   334             aIter->NextL(singleContact,buf);

   335             if(!singleContact)

   336                 {

   337                 break;

   338                 }

   339             ++count;

   340             TInt count(singleContact->FieldCount());

   341             while(count)

   342                 {

   343                 CSingleContactField* field = singleContact->FieldAt(--count);

   344                 TPtrC8 fieldKey;

   345                 TPtrC label;

   346                 TPtrC value;

   347                 field->GetFieldDataL(fieldKey,label,value);

   348                 if (fieldKey == KFirstName && value == KNameT)

   349                     {

   350                     ++count1;

   351                     tCount = count1;

   352                     }

   353                 if (fieldKey == KFirstName && value == KNameB)

   354                     {

   355                     ++count1;

   356                     bCount = count1;

   357                     }    

   358               

   359                 }               

   360             delete singleContact;

   361             }

   362             

   363         if(bCount>0 && tCount>0 && bCount<tCount)

   364                   {

   365                   iErr = KErrNone;  

   366                   }     

   367         }

   368         

   369     if(EDscContact == iOperation )

   370         {

   371         iOperation = ENone;

   372         iErr = KErrGeneral;

   373         _LIT8(KFirstName,"FirstName");

   374         _LIT(KNameT,"Tenali");

   375         _LIT(KNameB,"Birbal"); 

   376         TInt count1 = 0;

   377         TInt tCount = 0;

   378         TInt bCount = 0;

   379         CSingleContact* singleContact = NULL;  

   380         HBufC8* buf = NULL;

   381         TInt count = 0; 

   382         while(ETrue)

   383             {

   384             aIter->NextL(singleContact,buf);

   385             if(!singleContact)

   386                 {

   387                 break;

   388                 }

   389             ++count;

   390             TInt count(singleContact->FieldCount());

   391             while(count)

   392                 {

   393                 CSingleContactField* field = singleContact->FieldAt(--count);

   394                 TPtrC8 fieldKey;

   395                 TPtrC label;

   396                 TPtrC value;

   397                 field->GetFieldDataL(fieldKey,label,value);

   398                 if (fieldKey == KFirstName && value == KNameT)

   399                     {

   400                     ++count1;

   401                     tCount = count1;

   402                     }

   403                 if (fieldKey == KFirstName && value == KNameB)

   404                     {

   405                     ++count1;

   406                     bCount = count1;

   407                     }                  

   408                 }

   409             delete singleContact;

   410             }

   411         if(bCount>tCount)

   412                   {

   413                   iErr = KErrNone;  

   414                   }    

   415         }            

   416     if(EGetGroup == iOperation )

   417         {

   418         iOperation = ENone;

   419         iErr = KErrGeneral;

   420         CSingleContact* singleContact = NULL;  

   421         HBufC8* buf = NULL;

   422         TInt count = 0; 

   423         while(ETrue)

   424             {

   425             aIter->NextL(singleContact,buf);

   426             iBuffer = buf;

   427             if(!singleContact)

   428                 {

   429                 break;

   430                 }

   431             ++count; 

   432             TInt fields(singleContact->FieldCount());

   433             while(fields)

   434                 {

   435                 CSingleContactField* field = singleContact->FieldAt(--fields);

   436                 TPtrC groupId;

   437                 RPointerArray<TDesC8> array;

   438                 field->GetFieldDataL(groupId,array);

   439               

   440                 

   441                 if(groupId.Compare(KGroup1)==0)

   442                     {

   443                     iErr = KErrNone; 

   444                     break;   

   445                     }

   446                    

   447                 }

   448                           

   449             }

   450         }

   451     delete aIter;  

   452     }

   453 

   454 void CContactsUT::HandleRetrieveContact( MVPbkStoreContact* /*aStoreContact*/, TInt /*aTransId*/ )

   455     {

   456     CActiveScheduler::Stop();

   457     _LIT(KFunc,"In Handle Retrieve Contact\n");

   458     iLog->Log(KFunc);

   459     }

   460 

   461 void CContactsUT::ContactOperationCompleted(TContactOpResult aResult)

   462     {

   463     CActiveScheduler::Stop();

   464     _LIT(KFunc,"In ContactOperationCompleted \n");

   465     iLog->Log(KFunc);

   466     iErr = KErrNone;

   467     TBuf<5> buf;

   468     buf.Num(aResult.iOpCode);

   469     iLog->Log(KSuccess);

   470     iLog->Log(buf);

   471     iLog->Log(KNewLine);

   472     switch(iOperation)

   473         {/*

   474         case EContact: delete iStoreContact;

   475                        iStoreContact = NULL;

   476                        break;*/

   477         case EGroup: delete iGroup;

   478                      iGroup = NULL;

   479                      break;

   480         }          

   481     iOperation = ENone;

   482     }

   483 void CContactsUT::ContactOperationFailed

   484             (TContactOp /*aOpCode*/, TInt aErrorCode, TBool /*aErrorNotified*/)

   485     {

   486     CActiveScheduler::Stop();

   487     _LIT(KFunc,"In ContactOperationFailed \n");

   488     iLog->Log(KFunc);

   489     iErr = aErrorCode;

   490     TBuf<5> buf;

   491     buf.Num(aErrorCode);

   492     iLog->Log(KError);

   493     iLog->Log(buf);

   494     iLog->Log(KNewLine);

   495     switch(iOperation)

   496         {

   497         case EContact:/* delete iStoreContact;

   498                        iStoreContact = NULL;

   499                        break;*/

   500         case EGroup: delete iGroup;

   501                      iGroup = NULL;

   502                      break;

   503         }          

   504     iOperation = ENone;

   505     }  

   506             

   507 void CContactsUT::FindCompleteL( MVPbkContactLinkArray* aResults )

   508     {

   509     CActiveScheduler::Stop();

   510     _LIT(KFunc,"In FindCompleteL \n");

   511     iLog->Log(KFunc);

   512     iErr = KErrNone;

   513     TInt count = aResults->Count();

   514     iFindResults = aResults;

   515     iLog->Log(KSuccess);

   516     }

   517 void CContactsUT::FindFailed( TInt aError )

   518     {

   519     CActiveScheduler::Stop();

   520     _LIT(KFunc,"In FindFailed \n");

   521     iLog->Log(KFunc);

   522     iErr = aError;

   523     TBuf<5> buf;

   524     buf.Num(aError);

   525     iLog->Log(KError);

   526     iLog->Log(buf);

   527     iLog->Log(KNewLine);

   528     }

   529     

   530 void CContactsUT::VPbkSingleContactOperationComplete(

   531                 MVPbkContactOperationBase& aOperation,

   532                 MVPbkStoreContact* aContact )

   533     {

   534     CActiveScheduler::Stop();

   535     _LIT(KFunc,"In VPbkSingleContactOperationComplete \n");

   536     iLog->Log(KFunc);

   537     iErr = KErrNone;

   538     

   539     if(iOperation == EVCard)

   540         {

   541         iDestStream.CommitL();

   542         delete iOp;

   543         iOp = NULL;

   544         iDestStream.Close();

   545         delete iResult;

   546         iResult = NULL;

   547         }

   548     else if(iOperation == EVCardEx)

   549         {        

   550         delete iOp;

   551         iOp = NULL;

   552         }

   553     else

   554         {

   555         delete iStoreContact;

   556         iStoreContact = NULL;

   557         iStoreContact = aContact;

   558         if( iOp == &aOperation )

   559             {

   560                 delete iOp;

   561                 iOp = NULL;

   562             }

   563         }

   564     iOperation = ENone;

   565     iLog->Log(KSuccess);

   566     }

   567 

   568 

   569 void CContactsUT::VPbkSingleContactOperationFailed(

   570                 MVPbkContactOperationBase& aOperation, 

   571                 TInt aError )

   572     {

   573     CActiveScheduler::Stop();

   574     _LIT(KFunc,"In VPbkSingleContactOperationFailed \n");

   575     iLog->Log(KFunc);

   576     iErr = aError;

   577     ;

   578     if(iOperation == EVCard)

   579         {

   580         iDestStream.CommitL();

   581         delete iOp;

   582         iOp = NULL;

   583         iDestStream.Close();

   584         delete iBuffer;

   585         iBuffer = NULL;

   586         delete iResult;

   587         iResult = NULL;

   588         }

   589     else if(iOperation == EVCardEx)

   590         {        

   591         delete iOp;

   592         iOp = NULL;

   593         }

   594     else

   595         {

   596         delete iStoreContact;

   597         iStoreContact = NULL;

   598         if( iOp == &aOperation )

   599             {

   600                 delete iOp;

   601                 iOp = NULL;

   602             }

   603         }

   604     TBuf<5> buf;

   605     buf.Num(aError);

   606     iLog->Log(KError);

   607     iLog->Log(buf);

   608     iLog->Log(KNewLine);

   609     

   610     iOperation = ENone;

   611     }

   612 

   613 void CContactsUT::StepComplete( 

   614                 MVPbkContactOperationBase& /*aOperation*/,

   615                 TInt /*aStepSize*/ )

   616     {

   617     _LIT(KFunc,"In StepComplete \n");

   618     iLog->Log(KFunc);

   619     iLog->Log(KSuccess);

   620     iLog->Log(KNewLine);

   621     }

   622 

   623 TBool CContactsUT::StepFailed(

   624                 MVPbkContactOperationBase& /*aOperation*/,

   625                 TInt /*aStepSize*/, TInt /*aError*/ )

   626     {

   627     _LIT(KFunc,"In StepFailed \n");

   628     iLog->Log(KFunc);

   629     return EFalse;

   630     }

   631 

   632 void CContactsUT::OperationComplete( 

   633                 MVPbkContactOperationBase& /*aOperation*/ )

   634     {

   635     CActiveScheduler::Stop();

   636     _LIT(KFunc,"In OperationComplete \n");

   637     iLog->Log(KFunc);

   638     iErr = KErrNone;

   639     iLog->Log(KSuccess);

   640     iLog->Log(KNewLine);

   641     }

   642 

   643 

   644 //Delete all contacts

   645 void CContactsUT::DeleteAllL()

   646     {

   647     // Print to UI

   648     _LIT( KContactsTest, "ContactsUT" );

   649     _LIT( KExample, "In DeleteAllL" );

   650     TestModuleIf().Printf( 0, KContactsTest, KExample );

   651     // Print to log file

   652     iLog->Log( KExample );

   653 

   654     iErr = KErrNone;

   655        

   656     __UHEAP_MARK;    

   657     iOp = iContactManager->MatchPhoneNumberL(

   658         KPhoneNumber, KPhoneNumber().Length(), *this );    

   659     CActiveScheduler::Start();

   660     delete iOp;

   661     iOp = NULL;

   662     

   663     TInt count(iFindResults->Count());

   664     iContactToDelete = CVPbkContactLinkArray::NewLC();

   665     while(count)

   666         {  

   667         MVPbkContactLink* link = iFindResults->At(--count).CloneLC();

   668         iContactToDelete->AppendL(link);

   669         CleanupStack::Pop();

   670         }

   671     delete iFindResults;

   672     iFindResults = NULL;

   673         

   674     iOp = iContactManager->DeleteContactsL( *iContactToDelete, *this );

   675     CActiveScheduler::Start();

   676     delete iOp;

   677     iOp = NULL;

   678     CleanupStack::PopAndDestroy(iContactToDelete);

   679     iContactToDelete = NULL;

   680          

   681     

   682     __UHEAP_MARKEND;          

   683     }

   684     

   685 //Add 1 contact

   686 void CContactsUT::AddOneContactL(TDesC& aName)

   687     {

   688     // Print to UI

   689     _LIT( KContactsTest, "ContactsUT" );

   690     _LIT( KExample, "In AddOneContactL" );

   691     TestModuleIf().Printf( 0, KContactsTest, KExample );

   692     // Print to log file

   693     iLog->Log( KExample );

   694 

   695     iErr = KErrNone;

   696     

   697     __UHEAP_MARK;

   698     CVPbkFieldTypeRefsList* fieldTypeRefList = CVPbkFieldTypeRefsList::NewL();

   699     CleanupStack::PushL(fieldTypeRefList);

   700     

   701     fieldTypeRefList->AppendL( 

   702         *iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_FIRSTNAME ) );

   703     fieldTypeRefList->AppendL( 

   704         *iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_MOBILEPHONEGEN ) );

   705     

   706     // Create first contact

   707     iStoreContact = iStore->CreateNewContactLC();

   708     

   709     // Create contact field for contact

   710     MVPbkStoreContactField* field = iStoreContact->CreateFieldLC( fieldTypeRefList->FieldTypeAt( 0 ) );

   711     // Set contact field data

   712     (MVPbkContactFieldTextData::Cast(field->FieldData())).SetTextL( aName );

   713     // Add the contact field to contact

   714     iStoreContact->AddFieldL( field );

   715     CleanupStack::Pop(); // field

   716     

   717     // Create contact field for contact

   718     field = iStoreContact->CreateFieldLC( fieldTypeRefList->FieldTypeAt( 1 ) );

   719     // Set contact field data

   720     (MVPbkContactFieldTextData::Cast(field->FieldData())).SetTextL( KPhoneNumber );

   721     // Add the contact field to contact

   722     iStoreContact->AddFieldL( field );

   723     CleanupStack::Pop(); // field

   724     

   725     // Commit the new created contact to contact store

   726     iStoreContact->CommitL( *this );

   727     CActiveScheduler::Start();	

   728     CleanupStack::PopAndDestroy(); // iStoreContact

   729     iStoreContact = NULL;

   730     CleanupStack::PopAndDestroy(fieldTypeRefList);

   731     __UHEAP_MARKEND;    

   732     }

   733     

   734 //Check for contact

   735 void CContactsUT::CheckContactsL(TInt& aCount,RPointerArray<TDesC8>& aIdArray)

   736     {    

   737     // Print to UI

   738     _LIT( KContactsTest, "ContactsUT" );

   739     _LIT( KExample, "In CheckContactsL" );

   740     TestModuleIf().Printf( 0, KContactsTest, KExample );

   741     // Print to log file

   742     iLog->Log( KExample );

   743 

   744     iErr = KErrNone;

   745         

   746     //__UHEAP_MARK;

   747     iOp = iContactManager->MatchPhoneNumberL(

   748         KPhoneNumber, KPhoneNumber().Length(), *this );    

   749     CActiveScheduler::Start();

   750     delete iOp;

   751     iOp = NULL;

   752     

   753     aCount = iFindResults->Count();

   754     TInt count(aCount);

   755     while(count)

   756         {

   757         aIdArray.AppendL((const_cast<MVPbkContactLink&>(iFindResults->At(--count))).PackLC());

   758         CleanupStack::Pop();

   759         }

   760     delete iFindResults;

   761     iFindResults = NULL;

   762    // __UHEAP_MARKENDC(aCount);          

   763     }

   764     

   765 // -----------------------------------------------------------------------------

   766 // CContactsUT::?member_function

   767 // ?implementation_description

   768 // (other items were commented in a header).

   769 // -----------------------------------------------------------------------------

   770 //

   771 TInt CContactsUT::AddContactSAPIL( CStifItemParser& aItem )

   772     {

   773     // Print to UI

   774     _LIT( KContactsTest, "ContactsUT" );

   775     _LIT( KExample, "In AddContactSAPIL" );

   776     TestModuleIf().Printf( 0, KContactsTest, KExample );

   777     // Print to log file

   778     iLog->Log( KExample );

   779 

   780     TInt i = 0;

   781     TPtrC string;

   782     _LIT( KParam, "Param[%i]: %S" );

   783     while ( aItem.GetNextString ( string ) == KErrNone )

   784         {

   785         TestModuleIf().Printf( i, KContactsTest, 

   786                                 KParam, i, &string );

   787         i++;

   788         }

   789     

   790     iErr = KErrNone;  

   791     

   792     DeleteAllL();

   793     

   794      /**Add contact using SAPI Core class*/

   795     

   796     _LIT8(KFirstName,"FirstName");

   797     _LIT(KName,"Sikandar"); 

   798     _LIT8(KNumber,"MobilePhoneGen");

   799         

   800     __UHEAP_MARK;

   801     //instantiate service class 

   802     CContactService* serviceHandle = CContactService::NewL();

   803     CleanupStack::PushL(serviceHandle);

   804     iLog->Log( KServiceOpen );

   805     

   806     CSingleContact* singleContact = CSingleContact::NewL();

   807     CleanupStack::PushL(singleContact);

   808     iLog->Log(_L("single Contact created\n"));

   809     

   810     CSingleContactField* nameContactField = CSingleContactField::NewL();

   811     CleanupStack::PushL(nameContactField);

   812     iLog->Log(_L("Name Contact Field created \n"));

   813     

   814     CSingleContactField* phoneContactField = CSingleContactField::NewL();

   815     CleanupStack::PushL(phoneContactField);

   816     iLog->Log(_L("Phone Contact Field created \n"));

   817     

   818     nameContactField->SetFieldParamsL(KFirstName,KNullDesC,KName);

   819     singleContact->AddFieldToContactL(nameContactField);

   820     iLog->Log(_L("Name Contact Field added \n"));

   821     

   822     phoneContactField->SetFieldParamsL(KNumber,KNullDesC,KPhoneNumber);

   823     singleContact->AddFieldToContactL(phoneContactField);

   824     iLog->Log(_L("Phone Contact Field added \n"));

   825     

   826     serviceHandle->AddL(this,0,singleContact);

   827     iLog->Log(_L("AddL called\n"));

   828     iLog->Log(_L("Start Active Scheduler\n"));

   829     CActiveScheduler::Start();    

   830     

   831     CleanupStack::Pop(phoneContactField);//singleContactField	

   832     CleanupStack::Pop(nameContactField);//singleContactField	

   833     CleanupStack::PopAndDestroy(singleContact);//singleContact

   834     CleanupStack::PopAndDestroy(serviceHandle);//serviceHandle   

   835     iLog->Log( KServiceClose );

   836     __UHEAP_MARKEND; 

   837     /**end */

   838     

   839     TInt count;

   840     RPointerArray<TDesC8> idArray;

   841     CheckContactsL(count,idArray);

   842     if(count != 1)

   843         {

   844         iErr = KErrGeneral;

   845         }

   846     idArray.ResetAndDestroy();

   847     

   848     DeleteAllL();

   849     return iErr;    

   850     }

   851 

   852 // -----------------------------------------------------------------------------

   853 // CContactsUT::?member_function

   854 // ?implementation_description

   855 // (other items were commented in a header).

   856 // -----------------------------------------------------------------------------

   857 //

   858 TInt CContactsUT::DeleteContactSAPIL( CStifItemParser& aItem )

   859     {

   860     // Print to UI

   861     _LIT( KContactsTest, "ContactsUT" );

   862     _LIT( KExample, "In DeleteContactSAPIL" );

   863     TestModuleIf().Printf( 0, KContactsTest, KExample );

   864     // Print to log file

   865     iLog->Log( KExample );

   866 

   867     TInt i = 0;

   868     TPtrC string;

   869     _LIT( KParam, "Param[%i]: %S" );

   870     while ( aItem.GetNextString ( string ) == KErrNone )

   871         {

   872         TestModuleIf().Printf( i, KContactsTest, 

   873                                 KParam, i, &string );

   874         i++;

   875         }

   876     

   877     iErr = KErrNone;  

   878     

   879     DeleteAllL();

   880     _LIT(KName,"SpiderMan");

   881     TPtrC name(KName);

   882     AddOneContactL(name);

   883     

   884     TInt count(0);

   885     RPointerArray<TDesC8> idArray;

   886     CleanupClosePushL(idArray);

   887     CheckContactsL(count,idArray);

   888     if(count != 1)

   889         {

   890         return KErrGeneral;

   891         }

   892         

   893     /**Delete using SAPI core class*/

   894     

   895     __UHEAP_MARK;         

   896     CContactService* serviceHandle = CContactService::NewL();

   897     CleanupStack::PushL(serviceHandle);

   898     iLog->Log( KServiceOpen );

   899    

   900     serviceHandle->DeleteL(this,0,idArray);

   901     iLog->Log(_L("DeleteL called\n"));

   902     iLog->Log(_L("Start Active Scheduler\n"));

   903     CActiveScheduler::Start(); 

   904    

   905     CleanupStack::PopAndDestroy(serviceHandle);//serviceHandle      	          

   906     iLog->Log( KServiceClose ); 

   907     __UHEAP_MARKEND;  

   908     /**end*/

   909     CleanupStack::Pop(&idArray);

   910     idArray.ResetAndDestroy();

   911         

   912     RPointerArray<TDesC8> idArray1;

   913     CleanupClosePushL(idArray1);

   914     CheckContactsL(count,idArray1);

   915     if(count)

   916         {

   917         iErr = KErrGeneral;

   918         }

   919     CleanupStack::Pop(&idArray1);

   920     idArray.ResetAndDestroy();

   921     return iErr;

   922         

   923     }

   924     

   925 // -----------------------------------------------------------------------------

   926 // CContactsUT::?member_function

   927 // ?implementation_description

   928 // (other items were commented in a header).

   929 // -----------------------------------------------------------------------------

   930 //

   931 TInt CContactsUT::ModifyContactSAPIL( CStifItemParser& aItem )

   932     {

   933     // Print to UI

   934     _LIT( KContactsTest, "ContactsUT" );

   935     _LIT( KExample, "In ModifyContactSAPIL" );

   936     TestModuleIf().Printf( 0, KContactsTest, KExample );

   937     // Print to log file

   938     iLog->Log( KExample );

   939 

   940     TInt i = 0;

   941     TPtrC string;

   942     _LIT( KParam, "Param[%i]: %S" );

   943     while ( aItem.GetNextString ( string ) == KErrNone )

   944         {

   945         TestModuleIf().Printf( i, KContactsTest, 

   946                                 KParam, i, &string );

   947         i++;

   948         }

   949     

   950     iErr = KErrNone;  

   951     

   952     DeleteAllL();

   953     _LIT(KName,"SuperMan");

   954     TPtrC name(KName);

   955     AddOneContactL(name);

   956     

   957     TInt count(0);

   958     RPointerArray<TDesC8> idArray;

   959     CleanupClosePushL(idArray);

   960     CheckContactsL(count,idArray);

   961     if(count != 1)

   962         {

   963         return KErrGeneral;

   964         }

   965       

   966     /**Get using SAPI core class*/    

   967     __UHEAP_MARK;         

   968     CContactService* serviceHandle = CContactService::NewL();

   969     CleanupStack::PushL(serviceHandle);

   970     iLog->Log( KServiceOpen );

   971     

   972     serviceHandle->GetListL(this,0,EContacts,*idArray[0]);

   973     iLog->Log(_L("GetListL called\n"));

   974     iLog->Log(_L("Start Active Scheduler\n"));

   975     CActiveScheduler::Start();

   976     

   977     if(!iSingleContact)

   978         {

   979         return KErrGeneral;

   980         }

   981     

   982     _LIT(KName1,"SpiderMan");

   983     _LIT8(KFirstName,"FirstName");

   984     CSingleContactField* field = NULL; 

   985     TInt fieldCount(iSingleContact->FieldCount());                    

   986     while(fieldCount)

   987         {            

   988         TPtrC8 fieldKey;

   989         TPtrC label;

   990         TPtrC value;

   991         field = iSingleContact->FieldAt(--fieldCount);

   992         field->GetFieldDataL(fieldKey,label,value);

   993         if(!fieldKey.Compare(KFirstName) && !value.Compare(KName))

   994             {

   995             field->SetFieldParamsL(KFirstName,KNullDesC,KName1);

   996             iLog->Log(_L("Phone Contact Field modified \n"));            

   997             break;                        

   998             }

   999         }

  1000    

  1001     __UHEAP_MARK;

  1002     serviceHandle->AddL(this,0,iSingleContact);

  1003     iLog->Log(_L("AddL called\n"));

  1004     iLog->Log(_L("Start Active Scheduler\n"));

  1005     CActiveScheduler::Start();        

  1006     __UHEAP_MARKEND;

  1007     

  1008     delete iSingleContact;

  1009     iSingleContact = NULL;

  1010     

  1011     CleanupStack::PopAndDestroy(serviceHandle);//serviceHandle      	          

  1012     iLog->Log( KServiceClose ); 

  1013     __UHEAP_MARKEND;  

  1014     /**end*/

  1015     

  1016     

  1017     CleanupStack::Pop(&idArray);

  1018     idArray.ResetAndDestroy();

  1019         

  1020     RPointerArray<TDesC8> idArray1;

  1021     CleanupClosePushL(idArray1);

  1022     CheckContactsL(count,idArray1);

  1023     if(count != 1)

  1024         {

  1025         iErr = KErrGeneral;

  1026         }

  1027     CleanupStack::Pop();

  1028     idArray1.ResetAndDestroy();

  1029     //to implement ..checking name

  1030     return iErr;

  1031         

  1032     }

  1033 

  1034 // -----------------------------------------------------------------------------

  1035 // CContactsUT::?member_function

  1036 // ?implementation_description

  1037 // (other items were commented in a header).

  1038 // -----------------------------------------------------------------------------

  1039 //

  1040 TInt CContactsUT::ImportContactSAPIL( CStifItemParser& aItem )

  1041     {

  1042     // Print to UI

  1043     _LIT( KContactsTest, "ContactsUT" );

  1044     _LIT( KExample, "In ImportContactSAPIL" );

  1045     TestModuleIf().Printf( 0, KContactsTest, KExample );

  1046     // Print to log file

  1047     iLog->Log( KExample );

  1048 

  1049     TInt i = 0;

  1050     TPtrC string;

  1051     _LIT( KParam, "Param[%i]: %S" );

  1052     while ( aItem.GetNextString ( string ) == KErrNone )

  1053         {

  1054         TestModuleIf().Printf( i, KContactsTest, 

  1055                                 KParam, i, &string );

  1056         i++;

  1057         }

  1058     

  1059     iErr = KErrNone; 

  1060     _LIT(KFileName,"c:\\vcardim.vcf");

  1061     

  1062   /*  DeleteAllL();

  1063     

  1064     _LIT(KName,"SuperMan");

  1065     TPtrC name(KName);

  1066     AddOneContactL(name);

  1067     

  1068     TInt count(0);

  1069     RPointerArray<TDesC8> idArray;

  1070     CleanupClosePushL(idArray);

  1071     CheckContactsL(count,idArray);

  1072     if(count != 1)

  1073         {

  1074         return KErrGeneral;

  1075         }

  1076         

  1077     //__UHEAP_MARK;

  1078     MVPbkContactLinkArray* linkArray = iContactManager->CreateLinksLC(*idArray[0]);

  1079     iVCardEngine = CVPbkVCardEng::NewL( *iContactManager );

  1080      // Create the buffer to store the contact

  1081     iBuffer = HBufC8::NewL( 1024 );

  1082     TPtr8 bufferPtr( iBuffer->Des() );

  1083     iDestStream.Open( bufferPtr );

  1084     //export the contact from MVPbkContactLink

  1085    // __UHEAP_MARK;

  1086     iOp = iVCardEngine->ExportVCardL( iDestStream, linkArray->At(0), *this );

  1087     CActiveScheduler::Start();    

  1088     

  1089     // __UHEAP_MARKEND;

  1090     if( !iErr )

  1091         {

  1092         iDestStream.CommitL();

  1093         }

  1094     

  1095     iDestStream.Close();

  1096     if(iBuffer)

  1097         {

  1098         RFile file;

  1099         CleanupClosePushL(file);            

  1100         file.Replace(iRfs,KFileName,EFileWrite);

  1101         file.Write(0,*iBuffer);

  1102         CleanupStack::PopAndDestroy(&file);        

  1103         }    

  1104     delete iBuffer;

  1105     iBuffer = NULL;

  1106     delete iVCardEngine;

  1107     iVCardEngine = NULL;   

  1108     CleanupStack::PopAndDestroy();//linkArray      

  1109     //__UHEAP_MARKEND;

  1110     

  1111     CleanupStack::Pop(&idArray);

  1112     idArray.ResetAndDestroy();

  1113     DeleteAllL();

  1114     */

  1115     DeleteAllL();

  1116     __UHEAP_MARK;

  1117     CContactService* serviceHandle = CContactService::NewL();

  1118     CleanupStack::PushL(serviceHandle);

  1119     iLog->Log( KServiceOpen );

  1120     

  1121     TFileName importFile(KFileName);

  1122     

  1123     serviceHandle->ImportVCardToStoreL(this,0,importFile);

  1124     iLog->Log(_L("ImportVCardToStoreL called\n"));

  1125     iLog->Log(_L("Start Active Scheduler\n"));

  1126     CActiveScheduler::Start();  

  1127     

  1128     CleanupStack::PopAndDestroy(serviceHandle);//serviceHandle        

  1129     iLog->Log( KServiceClose );   

  1130     __UHEAP_MARKEND;

  1131     

  1132     TInt count = 0;

  1133     RPointerArray<TDesC8> idArray;

  1134     CleanupClosePushL(idArray);