1 /*

     2 * Copyright (c) 2006-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:  Provides interface between the AIW FrameWork and Service Provider.

    15 *

    16 */

    17 

    18 #include <LiwVariant.h>

    19 #include <LiwGenericParam.h>

    20 #include <LiwCommon.h>

    21 

    22 #include <CVPbkContactLinkArray.h>

    23 #include <CVPbkContactStoreUriArray.h>

    24 #include <CVPbkContactManager.h>

    25 #include <MVPbkContactStoreList.h>

    26 #include <TVPbkContactStoreUriPtr.h>

    27 #include <MVPbkContactLink.h>

    28 

    29 // User Includes

    30 #include "contactservice.h"

    31 #include "contactinterface.h"

    32 #include "contactinterfacecallback.h"

    33 #include "searchfields.h"

    34 #include "contactservice.hrh"

    35 #include "contacterrormessage.hrh"

    36 #include "../../inc/serviceerrno.h"

    37 #include "contactsmaxlength.h"

    38 

    39 using namespace LIW;

    40 

    41 #define KMissingArg -100

    42 

    43 /*

    44 -----------------------------------------------------------------------------

    45     CContactInterface::CContactInterface()

    46     Description    : Constructor

    47     Return values  : N/A

    48 -----------------------------------------------------------------------------

    49 */

    50 CContactInterface::CContactInterface()

    51                 : iContactService( NULL ),

    52                   iErrorMess(NULL),

    53                   iDburi(NULL)

    54     {

    55     }

    56 

    57 /*

    58 -----------------------------------------------------------------------------

    59     void CContactInterface::ConstructL()

    60     Description         : Symbian 2nd phase constructor can leave.

    61     Return values       : N/A

    62 -----------------------------------------------------------------------------

    63 */

    64 void CContactInterface::ConstructL()

    65     {

    66     iContactService = CContactService::NewL();    

    67 	iErrorMess = HBufC::NewL(250);    

    68     }

    69 /*

    70 -----------------------------------------------------------------------------

    71     CContactInterface* CContactInterface::NewL()

    72     Description                       : Two-phased constructor.

    73     Return values                     : CContactInterface object pointer

    74 

    75 -----------------------------------------------------------------------------

    76 */

    77 EXPORT_C CContactInterface* CContactInterface::NewL()

    78     {

    79     CContactInterface* self = new ( ELeave ) CContactInterface();

    80     CleanupStack::PushL( self );

    81     self->ConstructL();

    82     CleanupStack::Pop( self );

    83     return self;

    84     }

    85 /*

    86 -----------------------------------------------------------------------------

    87     CContactInterface::~CContactInterface()

    88     Description     : Destructor, free allocated resources

    89     Return values   : N/A

    90 -----------------------------------------------------------------------------

    91 */

    92 CContactInterface::~CContactInterface()

    93     {

    94     delete iContactService;

    95     delete iErrorMess;

    96     delete iDburi;

    97     iCallbackMap.ResetAndDestroy();

    98     iCallbackMap.Close();		

    99     }

   100     

   101 /*

   102 -----------------------------------------------------------------------------

   103     CContactInterface::GetFieldMaxLength()

   104     Description     : Gets the max length of the field.

   105     Return values   : MaxLength

   106 -----------------------------------------------------------------------------

   107 */    

   108     

   109 TInt CContactInterface :: GetFieldMaxLength(TInt aFieldKeyID, TDesC& aDbUri)

   110     {

   111     TInt fieldmaxlength = -1;

   112     switch(aFieldKeyID)

   113         {

   114             case R_VPBK_FIELD_TYPE_LASTNAME     :

   115             case R_VPBK_FIELD_TYPE_FIRSTNAME    :

   116             case R_VPBK_FIELD_TYPE_SECONDNAME   :

   117             case R_VPBK_FIELD_TYPE_DEPARTMENT   :

   118             case R_VPBK_FIELD_TYPE_JOBTITLE	    : 

   119         	case R_VPBK_FIELD_TYPE_ASSTNAME    	:

   120             case R_VPBK_FIELD_TYPE_ASSTPHONE    :

   121         	case R_VPBK_FIELD_TYPE_SPOUSE		:

   122             case R_VPBK_FIELD_TYPE_CHILDREN	    :

   123             case R_VPBK_FIELD_TYPE_COMPANYNAME  :

   124             case R_VPBK_FIELD_TYPE_MIDDLENAME   :           

   125             case R_VPBK_FIELD_TYPE_ADDRSTREETGEN:

   126             case R_VPBK_FIELD_TYPE_ADDRSTREETHOME:

   127             case R_VPBK_FIELD_TYPE_ADDRSTREETWORK:

   128             case R_VPBK_FIELD_TYPE_ADDRLOCALGEN	:

   129             case R_VPBK_FIELD_TYPE_ADDRLOCALHOME:

   130             case R_VPBK_FIELD_TYPE_ADDRLOCALWORK:

   131             case R_VPBK_FIELD_TYPE_ADDRREGIONGEN:

   132             case R_VPBK_FIELD_TYPE_ADDRREGIONHOME:

   133             case R_VPBK_FIELD_TYPE_ADDRREGIONWORK:            

   134             case R_VPBK_FIELD_TYPE_ADDRCOUNTRYGEN:

   135             case R_VPBK_FIELD_TYPE_ADDRCOUNTRYHOME:

   136             case R_VPBK_FIELD_TYPE_ADDRCOUNTRYWORK:

   137         	case R_VPBK_FIELD_TYPE_ADDREXTGEN:

   138         	case R_VPBK_FIELD_TYPE_ADDREXTHOME:

   139         	case R_VPBK_FIELD_TYPE_ADDREXTWORK:            

   140                 {

   141                 // a very bad fix for sim case 

   142                 if(aFieldKeyID == R_VPBK_FIELD_TYPE_LASTNAME && (aDbUri.CompareF(KSimDataBaseOne) == 0))

   143                     {

   144                     //comparing the database uri for sim and setting the length

   145                     fieldmaxlength = KMaLengthFourteen;                        

   146                     }

   147                 else

   148                     {

   149                     fieldmaxlength = KMaxLengthFifty;     

   150                     }                                                    

   151                 break;

   152                 }

   153                 

   154            case R_VPBK_FIELD_TYPE_MOBILEPHONEGEN  :

   155            case R_VPBK_FIELD_TYPE_MOBILEPHONEHOME :

   156            case R_VPBK_FIELD_TYPE_MOBILEPHONEWORK :

   157            case R_VPBK_FIELD_TYPE_LANDPHONEGEN	  :

   158            case R_VPBK_FIELD_TYPE_LANDPHONEHOME	  :

   159            case R_VPBK_FIELD_TYPE_LANDPHONEWORK   :

   160            case R_VPBK_FIELD_TYPE_VIDEONUMBERHOME :

   161            case R_VPBK_FIELD_TYPE_VIDEONUMBERWORK :

   162            case R_VPBK_FIELD_TYPE_VIDEONUMBERGEN  :

   163            case R_VPBK_FIELD_TYPE_CARPHONE		  :

   164            case R_VPBK_FIELD_TYPE_PAGERNUMBER	  :

   165            case R_VPBK_FIELD_TYPE_FAXNUMBERHOME   :

   166            case R_VPBK_FIELD_TYPE_FAXNUMBERWORK   :

   167            case R_VPBK_FIELD_TYPE_FAXNUMBERGEN	  :

   168                {

   169                fieldmaxlength = KMaxLengthFourtyEight;

   170                break;

   171                }

   172           case R_VPBK_FIELD_TYPE_ADDRPOGEN		  :

   173           case R_VPBK_FIELD_TYPE_ADDRPOHOME		  :

   174           case R_VPBK_FIELD_TYPE_ADDRPOWORK		  :

   175           case R_VPBK_FIELD_TYPE_ADDRPOSTCODEGEN  :

   176           case R_VPBK_FIELD_TYPE_ADDRPOSTCODEHOME :

   177           case R_VPBK_FIELD_TYPE_ADDRPOSTCODEWORK : 

   178               {

   179               fieldmaxlength = KMaxLengthTwenty; 

   180               break; 

   181               }

   182           case R_VPBK_FIELD_TYPE_PREFIX:

   183           case R_VPBK_FIELD_TYPE_SUFFIX:

   184               {

   185               fieldmaxlength = KMaxLengthTen;

   186               break;

   187               }

   188           

   189           case R_VPBK_FIELD_TYPE_DTMFSTRING:

   190               {

   191               fieldmaxlength =  KMaxLengthSixty;

   192               break;

   193               }

   194           

   195           case R_VPBK_FIELD_TYPE_SIP:

   196           case R_VPBK_FIELD_TYPE_POC:

   197           case R_VPBK_FIELD_TYPE_VOIPHOME:

   198           case R_VPBK_FIELD_TYPE_VOIPWORK:

   199           case R_VPBK_FIELD_TYPE_VOIPGEN:

   200           case R_VPBK_FIELD_TYPE_SWIS:

   201               {

   202               fieldmaxlength =  KMaxLengthHundred;

   203               break;

   204               }

   205           case R_VPBK_FIELD_TYPE_EMAILGEN :

   206           case R_VPBK_FIELD_TYPE_EMAILWORK:

   207           case R_VPBK_FIELD_TYPE_EMAILHOME:

   208               {

   209               fieldmaxlength =  KMaxLengthOneHundredAndFifty;

   210               break;

   211               }

   212           case R_VPBK_FIELD_TYPE_ADDRLABELHOME:

   213           case R_VPBK_FIELD_TYPE_ADDRLABELGEN:

   214           case R_VPBK_FIELD_TYPE_ADDRLABELWORK :

   215               {

   216               fieldmaxlength =  KMaxLengthTwoHundredAndFifty;

   217               break;

   218               }

   219           case R_VPBK_FIELD_TYPE_LOCPRIVACY:

   220           case R_VPBK_FIELD_TYPE_RINGTONE:

   221               {

   222               fieldmaxlength = KMaxLengthTwoHundredAndFiftySix;

   223               break;

   224               }

   225            case R_VPBK_FIELD_TYPE_URLWORK:

   226            case R_VPBK_FIELD_TYPE_URLHOME:

   227            case R_VPBK_FIELD_TYPE_URLGEN:

   228            case R_VPBK_FIELD_TYPE_NOTE:

   229            case R_VPBK_FIELD_TYPE_SYNCCLASS:

   230               {

   231               fieldmaxlength = KMaxLengthThousand;

   232               break;

   233               }

   234         }

   235     return fieldmaxlength;    

   236     }

   237 

   238 /*

   239 -----------------------------------------------------------------------------

   240     CContactInterface::ExecuteCmdL()

   241     Description     : This is called by the consumer with command to execute.

   242     Return values   : N/A

   243 -----------------------------------------------------------------------------

   244 */

   245 EXPORT_C void CContactInterface::

   246     ExecuteCmdL(const TDesC8& aCmdName,

   247                 const CLiwGenericParamList& aInParamList,

   248                 CLiwGenericParamList& aOutParamList,

   249                 TUint aCmdOptions,

   250                 MLiwNotifyCallback* aCallback)

   251     {    

   252     //Top level TRAP for all the api's

   253     TRAPD(returnCode,

   254           ProcessCmdL(aCmdName,

   255                       aInParamList,

   256                       aOutParamList,

   257                       aCmdOptions,

   258                       aCallback));      

   259     //append the appropriate error code.

   260     TInt32 SapiErr = SapiError(returnCode);

   261     aOutParamList.AppendL(TLiwGenericParam(KErrorCode,

   262                           TLiwVariant((TInt32)SapiErr)));

   263     }

   264 

   265 /*

   266 ---------------------------------------------------------------------------

   267  CContactInterface::SapiError(err)

   268  Description      :This function is called by the user to get mapped SAPI

   269                    generic error code from symbian error codes.

   270   Return values   :Integer Value TInt.

   271 ---------------------------------------------------------------------------

   272 */

   273 TInt CContactInterface::SapiError( TInt aSymbianErr )

   274     {

   275     TInt sapiErr(SErrGeneralError);

   276 

   277    	switch (aSymbianErr)

   278     	{

   279    		case KErrBadName:

   280    		case KErrArgument:

   281    		    {

   282    		    sapiErr = SErrBadArgumentType;

   283    		    break;

   284    		    }

   285    		case KErrNotSupported:

   286    		    {

   287    		    sapiErr = SErrServiceNotSupported;

   288    		    break;

   289    		    }

   290    		case KErrInUse:

   291    		    {

   292    		    sapiErr = SErrServiceInUse;

   293    		    break;

   294    		    }

   295    		case KErrAccessDenied:

   296    		    {

   297    		    sapiErr = SErrAccessDenied;

   298    		    break;

   299    		    }

   300     	case KErrNoMemory:

   301 	    	{

   302     		sapiErr = SErrNoMemory;

   303     		break;

   304     		}

   305    		case KErrAlreadyExists:

   306    		    {

   307    		    sapiErr = SErrEntryExists;

   308    		    break;

   309    		    }

   310    		case KErrNotReady:

   311    		    {

   312    		    sapiErr = SErrServiceNotReady;

   313    		    break;

   314    		    }

   315    		case KErrNotFound:

   316    		    {

   317    		    sapiErr = SErrNotFound;

   318    		    break;

   319    		    }

   320     	case KErrNone:

   321     		{

   322     		sapiErr = SErrNone;

   323     		break;

   324     		}

   325     	case KErrPathNotFound:

   326     		{

   327     		sapiErr = SErrPathNotFound;

   328     		break;

   329     		}

   330     	case KMissingArg:

   331     		{

   332     		sapiErr = SErrMissingArgument;

   333     		break;

   334     		}

   335     	default:

   336     		{

   337     		sapiErr = SErrGeneralError;

   338 	    	}

   339    	}

   340     return sapiErr;

   341     }

   342 

   343 /*

   344 -----------------------------------------------------------------------------

   345     CContactInterface::Close()

   346     Description     : This is called by the consumer to delete the handle.

   347     Return values   : N/A

   348 -----------------------------------------------------------------------------

   349 */

   350 void CContactInterface::Close()

   351     {

   352     delete this;

   353     }

   354 

   355 /*

   356 -----------------------------------------------------------------------------

   357     CContactInterface::ContactIDUTFToStreamL()

   358     Description     : This method is used to convert the UTF to stream.

   359     Return values   : N/A

   360 -----------------------------------------------------------------------------

   361 */

   362 HBufC8* CContactInterface::ContactIDUTFToStreamL(TDesC&  aContactIDUTF)

   363     {

   364     TInt len = aContactIDUTF.Length();    

   365     HBufC8* buf = HBufC8 :: NewL(len);    

   366     buf->Des().SetLength(len);

   367     TUint16* ptr =  const_cast<TUint16*>(aContactIDUTF.Ptr());

   368     TUint8* ptr8 = const_cast<TUint8*>(buf->Des().Ptr());

   369     

   370     for(TInt i=0; i<len; i++)

   371         {

   372         TUint c = ptr[i];

   373         if(c>=0x100)

   374          c = c & 0x00ff;        

   375         ptr8[i] = (TUint8)c;    

   376         }       

   377     return buf;         

   378     }

   379     

   380 /*

   381 -----------------------------------------------------------------------------

   382     CContactInterface::ProcessAddDataL(const CLiwMap* aMap,

   383  									   TPtrC& aDbUri,

   384  									   CSingleContact* aContact)

   385     Description     : Constructs a contact from the fields that exist in the map..

   386     Return values   : N/A

   387 -----------------------------------------------------------------------------

   388 */

   389 

   390 void CContactInterface::ProcessAddDataL(const CLiwMap* aMap, 										

   391  										CSingleContact* aContact,

   392  										CLiwGenericParamList& aOutParamList)

   393     {

   394     TBool atleastOneField = EFalse;

   395     iDburi = HBufC::NewL(VPbkContactStoreUris::DefaultCntDbUri().Length());    

   396     //set the DBUri to the default value.    

   397     iDburi->Des().Copy(VPbkContactStoreUris::DefaultCntDbUri());

   398     //get the number of entries in the map

   399     TInt keyCount = aMap->Count();

   400 

   401     for(TInt index=0;index<keyCount;index++)

   402         {

   403         //iterate through each entry in the map

   404         //starting from the first element

   405 

   406         //this variable should be reemoved

   407         //when the AtL signature is changed in LIW.

   408         TBuf8<KMaxName> fieldKey;

   409         TLiwVariant fieldVal;

   410         CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup ,&fieldVal) );

   411 

   412         //AtL gives us the key stored at a particular index

   413         aMap->AtL(index, fieldKey);

   414         //check whether the key is DBUri

   415         //if it is extract it and mark it.

   416         if( fieldKey.Compare(KDBUri) == 0 )

   417             {

   418             //get the DBUri from the map

   419             if(aMap->FindL(fieldKey, fieldVal))

   420                 {

   421                 if(fieldVal.AsDes().CompareF(KNullDesC)!=0)

   422                     { 

   423                     delete iDburi;

   424                     iDburi = NULL;                                  

   425                     iDburi = HBufC::NewL(fieldVal.AsDes().Length());

   426                     iDburi->Des().Copy(fieldVal.AsDes());                    

   427                     }

   428                 }

   429             }

   430         else if( fieldKey.Compare(KContactId) == 0 )

   431             {

   432             //get the contact ID  from the map

   433             if(aMap->FindL(fieldKey, fieldVal))

   434                 {

   435                 TPtrC cntIdUnicode = fieldVal.AsDes();      

   436 				if(cntIdUnicode == NULL)

   437 					{

   438 					aOutParamList.AppendL(TLiwGenericParam (KErrorMessage,

   439 					                      TLiwVariant(KAddWrongContactId)));  	

   440 					User::Leave(KErrArgument); 

   441 					}

   442           

   443                 HBufC8* cntid = ContactIDUTFToStreamL(cntIdUnicode);                

   444                 aContact->SetContactIdL(*cntid);

   445                 delete cntid;

   446                 }

   447             }

   448         else

   449             {            

   450             //if the key is not uri and is not a contact id

   451             //search for the field

   452             if(CSearchFields::GetIdFromFieldKey(fieldKey) == -1)

   453                 {

   454                 TBuf<25> buff;

   455                 buff.Copy(fieldKey);

   456                 TBuf<KMaxName> errmsg(KAddInvalidFieldKey);

   457                 errmsg.Append(buff);                                

   458             	aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   459             	                      TLiwVariant(errmsg)));  	

   460 				User::Leave(KErrArgument);     

   461                 }                                        

   462 			aMap->FindL(fieldKey,fieldVal);

   463        	 	if(EVariantTypeMap == fieldVal.TypeId())

   464                 {

   465                 const CLiwMap* pMap = fieldVal.AsMap();

   466                 if(pMap)

   467                     {

   468                     TLiwVariant labelVar;

   469 				    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &labelVar) );

   470                     

   471                     TLiwVariant valueVar;

   472 				    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueVar) );

   473 

   474                     TLiwVariant nextVar;

   475                     CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &nextVar) );

   476                     while(1)

   477                         {

   478 						//Get field label and value from map

   479 					if(pMap->FindL(KFieldLabel, labelVar))				

   480 						{

   481 						if(EVariantTypeDesC !=  labelVar.TypeId())	

   482 					 		{

   483 							TPtr16  err(iErrorMess->Des());

   484 							TBuf<KMaxName> buf;

   485 							buf.Copy(labelVar.AsData());							

   486 							err.Append(KAddCnt);

   487 							err.Append(buf);

   488 							err.Append(KAddInvalidStr);

   489 							aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(*iErrorMess) ) );  

   490 							CleanupStack::Pop(&nextVar);

   491 							nextVar.Reset();

   492 							CleanupStack::Pop(&valueVar);

   493 							valueVar.Reset();

   494 							CleanupStack::Pop(&labelVar);

   495 							labelVar.Reset();

   496     						CleanupStack::Pop(&fieldVal);

   497     						fieldVal.Reset();

   498     						err.Delete(0,iErrorMess->Length());

   499 							User::Leave(KErrArgument); 														

   500 							}							

   501 						}

   502 					TBool date = EFalse;                        

   503 						//Set contact item field value

   504 					if(pMap->FindL(KFieldValue, valueVar))	

   505 						{

   506                         if((fieldKey.Compare(KDate) == 0 || (fieldKey.Compare(KAnniversary) == 0)))

   507 	                        {

   508 	                        if(EVariantTypeTTime != valueVar.TypeId())

   509 	                        {

   510 							TPtr16  err(iErrorMess->Des());

   511 							TBuf<KMaxName> buf;

   512 							buf.Copy(valueVar.AsData());

   513 							err.Append(KAddCnt);

   514 							err.Append(buf);

   515 							err.Append(KAddInvalidTime);

   516 

   517 							aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(*iErrorMess) ) );  

   518 							CleanupStack::Pop(&nextVar);

   519 							nextVar.Reset();

   520 							CleanupStack::Pop(&valueVar);

   521 							valueVar.Reset();

   522 							CleanupStack::Pop(&labelVar);

   523 							labelVar.Reset();

   524     						CleanupStack::Pop(&fieldVal);

   525     						fieldVal.Reset();

   526     						err.Delete(0,iErrorMess->Length());

   527 							User::Leave(KErrArgument); 														

   528 	                        }

   529                         date = ETrue;

   530                         }

   531 

   532 						if((EVariantTypeDesC !=  valueVar.TypeId())	&& (date == EFalse))

   533 							{

   534 							TPtr16  err(iErrorMess->Des());

   535 							TBuf<KMaxName> buf;

   536 							buf.Copy(valueVar.AsData());

   537 							err.Append(KAddCnt);

   538 							err.Append(buf);

   539 							err.Append(KAddInvalidStr);

   540 

   541 							aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(*iErrorMess) ) );  

   542 							CleanupStack::Pop(&nextVar);

   543 							nextVar.Reset();

   544 							CleanupStack::Pop(&valueVar);

   545 							valueVar.Reset();

   546 							CleanupStack::Pop(&labelVar);

   547 							labelVar.Reset();

   548     						CleanupStack::Pop(&fieldVal);

   549     						fieldVal.Reset();

   550     						err.Delete(0,iErrorMess->Length());

   551 							User::Leave(KErrArgument); 														

   552 							}					

   553 						}

   554                         CSingleContactField* field =

   555                             CSingleContactField::NewL();

   556                         CleanupStack::PushL(field);

   557                         if(date)

   558                             {

   559                             field->SetFieldParamsL(fieldKey,

   560     						                       labelVar.AsDes(),

   561     					    	                   KNullDesC);

   562     					    field->SetDateTime(valueVar.AsTTime());	                   

   563     	                    }

   564                         else 

   565                             {

   566     						field->SetFieldParamsL(fieldKey,

   567                                                    labelVar.AsDes(),

   568                                                    valueVar.AsDes());

   569                             	

   570                             }

   571                         aContact->AddFieldToContactL(field);

   572                         atleastOneField = ETrue;

   573                         CleanupStack::Pop(field);

   574                         if(pMap->FindL(KFieldNext,nextVar))

   575                             {

   576                             if(EVariantTypeMap == nextVar.TypeId())

   577                                 {

   578                                 pMap = nextVar.AsMap();

   579                                 }

   580                             else

   581                             	{

   582 				                //if the map is not found

   583 				                //Leave with the error code

   584 				                aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   585 				                                      TLiwVariant(KAddNextFieldType)));

   586 				                User::Leave(KErrArgument);

   587                             	}

   588                             }

   589                         else //EVariantTypeNull

   590                             {

   591                             break;

   592                             }

   593                         }  //end of while

   594                     CleanupStack::Pop(&nextVar);    

   595                     nextVar.Reset();

   596 					CleanupStack::Pop(&valueVar);

   597 					valueVar.Reset();

   598 					CleanupStack::Pop(&labelVar);

   599 					labelVar.Reset();

   600                     }

   601                 else

   602                     {

   603                     //if the map is not found

   604                     //Leave with the error code

   605                     aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   606                                           TLiwVariant(KAddInvalidFieldType)));

   607                     User::Leave(KErrArgument);

   608                     }

   609                 }

   610             else

   611                 {

   612 				CleanupStack::Pop(&fieldVal);

   613 				fieldVal.Reset();

   614 				TPtr16  err(iErrorMess->Des());

   615 				TBuf<KMaxName> fld;

   616 				fld.Copy(fieldKey);

   617 				err.Append(fld);

   618 				err.Append(_L(",Invalid Type,Map is Required"));

   619 				aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,

   620 				                       TLiwVariant(*iErrorMess) ) );  

   621 				err.Delete(0,iErrorMess->Length()); 

   622 				User::Leave(KErrArgument); 

   623 

   624 				}	

   625             }            

   626 		CleanupStack::Pop(&fieldVal);

   627 		fieldVal.Reset();    

   628         } //end of for

   629     //checking for the maximum length (this is a temporary check since there is no support from vpbk)

   630     CSingleContactField* contactfield = NULL;

   631     TPtrC8 fieldKey(KNullDesC8);

   632     TPtrC fieldLabel(KNullDesC);

   633     TPtrC fieldValue(KNullDesC);

   634     TInt fieldCount = aContact->FieldCount(); 

   635     for( TInt i=0;i<fieldCount;i++ ) 

   636         {                

   637         contactfield = aContact->FieldAt(i);

   638         if(contactfield) 

   639             {

   640             contactfield->GetFieldDataL(fieldKey, fieldLabel, fieldValue);            

   641 			 if(!(fieldKey.Compare(KDate) == 0 || fieldKey.Compare(KAnniversary) == 0))

   642 			 {

   643 	            if(fieldValue.Length() > GetFieldMaxLength(CSearchFields::GetIdFromFieldKey(fieldKey), *iDburi))

   644 	        		{

   645 	        		TPtr16  err(iErrorMess->Des());

   646 	        		TBuf<KMaxName> fld;

   647 					fld.Copy(fieldKey);				

   648 					err.Append(_L("Contacts : Add : Field Value too long for key : "));

   649 					err.Append(fld);

   650 					

   651 	        		aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   652 	                                      TLiwVariant(*iErrorMess)));

   653 	                

   654 	                err.Delete(0,iErrorMess->Length());

   655 	        		User::Leave(KErrArgument);    

   656 	        		}     

   657 			 	

   658 			 }

   659             }

   660             

   661         }

   662        

   663 	if(atleastOneField == EFalse)

   664 		{

   665         aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   666                               TLiwVariant(KAddKeyNotSpecified)));

   667 		User::Leave(KErrArgument);

   668 		}				

   669     } //End of function : ProcessAddDataL()

   670 

   671 

   672 /*

   673 -----------------------------------------------------------------------------

   674     CContactInterface::ProcessCmdL(const TDesC8& aCmdName,

   675                                     const CLiwGenericParamList& aInParamList,

   676                                     CLiwGenericParamList& aOutParamList,

   677                                     TUint aCmdOptions,

   678                                     MLiwNotifyCallback* aCallback )

   679     Description     : This function processes the commands like add, delete, organise,

   680                      getlist.....etc.

   681     Return values   : N/A

   682 -----------------------------------------------------------------------------

   683 */

   684 void CContactInterface::ProcessCmdL(const TDesC8& aCmdName,

   685                                     const CLiwGenericParamList& aInParamList,

   686                                     CLiwGenericParamList& aOutParamList,

   687                                     TUint aCmdOptions,

   688                                     MLiwNotifyCallback* aCallback )

   689     {

   690     TInt returnCode = KErrNone;

   691     TInt transId = 0;

   692 	//if callback parameter is not null then retrieve the transaction id.

   693     if(aCallback && aCmdOptions == KLiwOptASyncronous)

   694         {

   695         transId = aCallback->GetTransactionID();

   696 

   697         CContactCallbackMap* map =

   698             new (ELeave) CContactCallbackMap(transId,

   699                                              aCallback);

   700         CleanupStack::PushL(map);

   701         iCallbackMap.AppendL(map);

   702         CleanupStack::Pop(map);

   703 

   704         //In case of async calls, also set the transaction id

   705         aOutParamList.AppendL(TLiwGenericParam(KTransactionID,

   706                               TLiwVariant((TInt32)transId)));

   707 

   708         }

   709     else if((aCmdOptions == KLiwOptASyncronous) && (!aCallback))

   710     	{

   711     	//Leave with the error code

   712         aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   713                           TLiwVariant(KCallbackNotFound)));

   714         User::Leave(KErrArgument);

   715     	}

   716     else if(aCallback && (aCmdOptions == 0))

   717 	    {

   718         aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   719                           TLiwVariant(KCallbackNotFound)));

   720         User::Leave(KErrArgument);

   721 	    	

   722 	    }	

   723     

   724     if( aCmdName.CompareF(KCmdCancel) == 0) // for cancel asynchronous request

   725 	    {

   726 		if(aCmdOptions != KLiwOptCancel)

   727 			{

   728 	    	//Leave with the error code

   729 	        aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   730 	                          TLiwVariant(KCancleCommandoptionWrong)));

   731 	        User::Leave(KErrArgument);

   732 				

   733 			}

   734  		returnCode = CancelCommandL(aInParamList,

   735  									aOutParamList);

   736 		if(returnCode != KErrNone)

   737 			{

   738 			//Leave with the error code

   739 			aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   740 									TLiwVariant(KCancelUnsuccessful)));

   741 			User::Leave(returnCode);

   742 			}

   743     	}

   744     //check for the command name,...if Import proceed further.

   745     else if ( (aCmdName.CompareF( KCmdImport ) == 0))

   746         {

   747         ImportCommandL(aInParamList,

   748                        aOutParamList,

   749                        aCallback,

   750                        aCmdOptions,

   751                        transId);

   752         }

   753     //check for the command name,...if Export, proceed further.

   754     else if ( (aCmdName.CompareF( KCmdExport ) == 0))

   755         {

   756         ExportCommandL(aInParamList,

   757                        aOutParamList,

   758                        aCallback,

   759                        aCmdOptions,

   760                        transId);

   761         }

   762     //check for the command name,...if Add, proceed further.

   763 	else if ( (aCmdName.CompareF( KCmdAdd ) == 0))

   764         {

   765         AddCommandL(aInParamList,

   766                     aOutParamList,

   767                     aCallback,

   768                     aCmdOptions,

   769                     transId);

   770         }

   771    //check for the command name,...if Delete, proceed further.

   772    else if ( (aCmdName.CompareF( KCmdDelete ) == 0))

   773         {

   774         DeleteCommandL(aInParamList,

   775                        aOutParamList,

   776                        aCallback,

   777                        aCmdOptions,

   778                        transId);

   779 	    }

   780 

   781 	   //check for the command name,...if OrganiseGroups, proceed further.

   782     else if ( (aCmdName.CompareF( KCmdOrganiseGroups ) == 0))

   783         {

   784         OrganiseGroupCommandL(aInParamList,

   785                                            aOutParamList,

   786             	                           aCallback,

   787             	                           aCmdOptions,

   788             	                           transId);

   789         }

   790    //Passing arguments for GetList command

   791    else if( aCmdName.CompareF( KCmdGetList ) == 0 )

   792         {

   793         GetListCommandL(aInParamList,

   794                         aOutParamList,

   795                         aCallback,

   796                         aCmdOptions,

   797                         transId);

   798         }

   799    else 

   800    		{

   801         //Leave with the error code

   802         aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   803                           TLiwVariant(KCommandNotSupported)));

   804         User::Leave(KErrNotSupported);

   805    		}

   806 

   807     } //end of ProcessCmdL

   808 

   809 /*

   810 -----------------------------------------------------------------------------

   811     CContactInterface::GetListCommandL(const CLiwGenericParamList& aInParamList,

   812                                        CLiwGenericParamList& aOutParamList,

   813                                        MLiwNotifyCallback* aCallback,

   814                                        TUint aCmdOptions,

   815                                        TInt aTransId)

   816     Description     : This function parses the input param list

   817                     : and calls the Getlist API

   818     Return values   : N/A

   819 -----------------------------------------------------------------------------

   820 */

   821 void CContactInterface::

   822      GetListCommandL(const CLiwGenericParamList& aInParamList,

   823                      CLiwGenericParamList& aOutParamList,

   824                      MLiwNotifyCallback* aCallback,

   825                      TUint aCmdOptions,

   826                      TInt aTransId)

   827     {    

   828     const TLiwGenericParam* paramContentType = NULL;

   829 	const TLiwGenericParam* paramGetListData = NULL;

   830     const TLiwGenericParam* paramGetListSortOrder = NULL;

   831 

   832     TInt pos = 0;

   833 	//Get the content type: it can be "contact" or "group" 

   834 	paramContentType = aInParamList.FindFirst( pos, KType );

   835 	if(!paramContentType)

   836 		{

   837 			if(aInParamList.Count()>0)

   838 				paramContentType = &aInParamList[0] ;

   839 			

   840 			if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0)

   841 				{

   842 				aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListContentTypeMissing) ) );  

   843 				User::Leave(KMissingArg); 

   844 				}		

   845         	if(aInParamList.Count()>1)    	

   846         		paramGetListData = &aInParamList[1]; 

   847         	

   848     		if(aInParamList.Count()>2)

   849 	            paramGetListSortOrder = &aInParamList[2] ;

   850 		}	

   851 	pos = 0;

   852     //Get the filter criteria, the value of which is a Map

   853     paramGetListData = aInParamList.FindFirst( pos, KFilter );    

   854     

   855     pos = 0;

   856     paramGetListSortOrder = aInParamList.FindFirst( pos, KSort );    	

   857 	

   858 	TLiwVariant cnttyp = paramContentType->Value();

   859 	if(EVariantTypeDesC !=  cnttyp.TypeId())

   860 		{

   861 		cnttyp.Reset();

   862 

   863 		aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListWrongContentType) ) );  

   864 		User::Leave(KErrArgument);			

   865 		}

   866 			 

   867     //Retrieve the map

   868     const CLiwMap* pMap = NULL;

   869     if(paramGetListData)

   870         {

   871         TLiwVariant getlistdata = paramGetListData->Value();

   872         if(EVariantTypeMap != getlistdata.TypeId() )

   873 	        {

   874 	        getlistdata.Reset();

   875 			aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListInvalidFilterType) ) );  

   876 			User::Leave(KErrArgument);			

   877 	        }

   878         pMap = getlistdata.AsMap();

   879 	    getlistdata.Reset();

   880         }

   881 		

   882  	const CLiwMap* sortMap = NULL;

   883 

   884  	if(paramGetListSortOrder)

   885  	{

   886  	TLiwVariant map =  paramGetListSortOrder->Value();

   887  	

   888  	if(EVariantTypeMap == map.TypeId())

   889 	 	{

   890 	 	sortMap= paramGetListSortOrder->Value().AsMap();	

   891 	 	}

   892  	else

   893 	 	{

   894 		map.Reset();

   895 		aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListInvalidSortType) ) );  

   896 		User::Leave(KErrArgument);			

   897 	

   898 	 	}

   899  	map.Reset();	

   900  	}

   901         

   902     //Get the type of the list requested

   903     Ttype listType = EContacts;

   904     TPtrC contentType;

   905 

   906     contentType.Set(paramContentType->Value().AsDes());

   907 

   908 	 //Based on content type set the value of the enum Ttype

   909 	if(contentType.Compare(KDatabase) == 0)

   910 		{

   911 		listType = EDatabase;

   912 		}

   913 	else if(contentType.Compare(KGroup) == 0)

   914 		{

   915 		listType = EGroups;

   916 		}

   917 	else if(contentType.Compare(KContact) == 0)

   918 		{

   919 		listType = EContacts;

   920 		}

   921 	else

   922     	{ 

   923     	aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

   924                               TLiwVariant(KGetListInvalidContentType)));   

   925     	User::Leave(KErrArgument);

   926     	}

   927 

   928 	TLiwVariant uriofDb;

   929     CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &uriofDb) );

   930 

   931 	TLiwVariant groupId;

   932     CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &groupId) );

   933 

   934     TPtrC8 ptrToCntId(KNullDesC8);

   935 	HBufC8* cntid = NULL;

   936 	CContactIter* iter;

   937 	CContactIterator* iterator;

   938 	TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri());	

   939 	//Switch based on the Ttype var value

   940 	switch(listType)

   941 	    {	    

   942 		case EDatabase:

   943 		    //In case it is GetList of dabases, the call is synchronous

   944 			iter = CContactIter::NewL();			

   945 			CleanupStack::PushL(iter);

   946 			iContactService->GetListL(*iter);

   947 		    CleanupStack::Pop(iter);

   948 		    //Setting the output param

   949 			if(iter)

   950 				{

   951 			    iterator = CContactIterator::NewL(iter);

   952 			    CleanupStack::PushL(iterator);

   953 		        aOutParamList.AppendL(TLiwGenericParam(KReturnValue,

   954 		                              TLiwVariant(iterator)));

   955 		        

   956 		        CleanupStack::Pop(iterator);

   957 		        iterator->DecRef();

   958                 CleanupStack::Pop(&groupId);

   959                 groupId.Reset();

   960                 CleanupStack::Pop(&uriofDb);

   961                 uriofDb.Reset();

   962 				return;

   963 				}

   964 			break;

   965 		case EGroups:

   966             //In case it is GetList of groups, its asynchronous

   967             //All that is required to get the list of groups is the database name

   968             //(in case its null default database is used) and callback function

   969             if(pMap && (EFalse != pMap->FindL(KDBUri, uriofDb)))

   970                  {

   971                  if(uriofDb.AsDes().Compare(KNullDesC)!= 0)

   972                      {

   973                      dbUri.Set(uriofDb.AsDes());

   974                      }

   975                  }

   976             // Get the contact id, in case it is specified single contact is retrived

   977             // If content is NULL, search is performed using search criteria

   978             // If the ID is mentioned then the search value and fields are ignored.

   979             if(pMap && (EFalse != pMap->FindL(KGroupId, groupId)))

   980                  {

   981                  TPtrC ptr = groupId.AsDes();

   982                  cntid = ContactIDUTFToStreamL(ptr);                 

   983                  CleanupStack::PushL(cntid);

   984                  if(aCmdOptions == KLiwOptASyncronous)

   985                     {

   986                 	CContactInterfaceCallback* contactCallback =

   987                 	    CContactInterfaceCallback::NewL();

   988                     CleanupStack :: PushL(contactCallback);

   989                    	 contactCallback->SetParams(aCallback,

   990                    	                            aTransId,

   991                    	                            &aInParamList);

   992                    	 //Call GetList in case of retrieval of a

   993                    	 //single contact whose id is known

   994                         iContactService->GetListL(contactCallback,

   995         										  aTransId,

   996         										  listType,

   997         										  *cntid,

   998         										  KNullDesC,

   999         										  NULL,

  1000         										  EAsc,

  1001         										  dbUri);

  1002 

  1003                     CleanupStack :: Pop(contactCallback);

  1004                     CleanupStack::PopAndDestroy(cntid);  

  1005                     }

  1006              else

  1007                     {

  1008                     //it is assumed that the call is synchronous

  1009                     CContactIter* iter =

  1010                     iContactService->GetListL(listType,

  1011                                               *cntid,

  1012                                               KNullDesC,

  1013                                               NULL,

  1014                                               EAsc,

  1015                                               dbUri);

  1016                     aOutParamList.AppendL(TLiwGenericParam( KErrorCode,

  1017                                           TLiwVariant((TInt32)SErrNone)));

  1018                     //Setting the output param

  1019                     CContactIterator* iterator=CContactIterator::NewL(iter);

  1020                     CleanupStack::PushL(iterator);

  1021                     aOutParamList.AppendL(TLiwGenericParam(KReturnValue,

  1022                                           TLiwVariant(iterator)));                                                             

  1023                     CleanupStack::Pop(iterator);

  1024                     iterator->DecRef();

  1025                     CleanupStack::PopAndDestroy(cntid);

  1026                     CleanupStack::Pop(&groupId);

  1027                     groupId.Reset();

  1028                     CleanupStack::Pop(&uriofDb);

  1029                     uriofDb.Reset();

  1030                     return;

  1031                     }

  1032              break;

  1033              }                 

  1034             if(aCmdOptions == KLiwOptASyncronous)

  1035                 {

  1036                 CContactInterfaceCallback* contactCallback =

  1037                     CContactInterfaceCallback::NewL();

  1038                 CleanupStack :: PushL(contactCallback);

  1039                 contactCallback->SetParams(aCallback,

  1040                                            aTransId,

  1041                                            &aInParamList);

  1042                 //Call the contactservice api

  1043                     iContactService->GetListL(contactCallback,

  1044                                               aTransId,

  1045                                               listType,

  1046                                               ptrToCntId,

  1047                                               KNullDesC,

  1048                                               NULL,

  1049                                               EAsc,

  1050                                               dbUri);

  1051 

  1052                 CleanupStack :: Pop(contactCallback);

  1053                 }

  1054             else

  1055                 {

  1056                 //it is assumed that the call is synchronous

  1057                 CContactIter* iter =

  1058                     iContactService->GetListL(listType,

  1059                                               ptrToCntId,

  1060                                               KNullDesC,

  1061     										  NULL,

  1062     										  EAsc,

  1063                                               dbUri);

  1064                 //Setting the output param

  1065                 CContactIterator* iterator=CContactIterator::NewL(iter);

  1066                 CleanupStack::PushL(iterator);

  1067                 aOutParamList.AppendL(TLiwGenericParam( KReturnValue,

  1068                                       TLiwVariant(iterator) ));                                                      

  1069                 CleanupStack::Pop(iterator);

  1070                 iterator->DecRef(); 

  1071                	CleanupStack::Pop(&groupId);

  1072                	groupId.Reset();

  1073                 CleanupStack::Pop(&uriofDb);

  1074                 uriofDb.Reset();

  1075                 return;

  1076                 }

  1077             break;

  1078 		case EContacts:

  1079 		    //In case it is GetList of contacts, its asynchronous

  1080             //Get the database uri, if not specified default database is used

  1081             if(pMap && (EFalse != pMap->FindL(KDBUri,uriofDb)))

  1082                  {

  1083                  if(uriofDb.AsDes().Compare(KNullDesC)!= 0)

  1084                      {

  1085                      dbUri.Set(uriofDb.AsDes());

  1086                      }

  1087                  }

  1088             TLiwVariant contactId;

  1089             CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &contactId) );

  1090 

  1091             // Get the contact id, in case it is specified single contact is retrived

  1092             // If content is NULL, search is performed using search criteria

  1093             // If the ID is mentioned then the search value and fields are ignored.

  1094             if(pMap && (EFalse != pMap->FindL(KContactId, contactId)))

  1095                  {

  1096                  TPtrC ptr = contactId.AsDes();

  1097                  cntid = ContactIDUTFToStreamL(ptr);                 

  1098                  CleanupStack::PushL(cntid);

  1099                  if(aCmdOptions == KLiwOptASyncronous)

  1100                     {

  1101                 	CContactInterfaceCallback* contactCallback =

  1102                 	    CContactInterfaceCallback::NewL();

  1103                     CleanupStack :: PushL(contactCallback);

  1104                    	 contactCallback->SetParams(aCallback,

  1105                    	                            aTransId,

  1106                    	                            &aInParamList);

  1107                    	 //Call GetList in case of retrieval of a

  1108                    	 //single contact whose id is known

  1109                         iContactService->GetListL(contactCallback,

  1110         										  aTransId,

  1111         										  listType,

  1112         										  *cntid,

  1113         										  KNullDesC,

  1114         										  NULL,

  1115         										  EAsc,

  1116         										  dbUri);

  1117 

  1118                     CleanupStack :: Pop(contactCallback);

  1119                     CleanupStack::PopAndDestroy(cntid);  

  1120                     }

  1121              else

  1122                     {

  1123                     //it is assumed that the call is synchronous

  1124                     CContactIter* iter =

  1125                     iContactService->GetListL(listType,

  1126                                               *cntid,

  1127                                               KNullDesC,

  1128                                               NULL,

  1129                                               EAsc,

  1130                                               dbUri);

  1131                     aOutParamList.AppendL(TLiwGenericParam( KErrorCode,

  1132                                           TLiwVariant((TInt32)SErrNone)));

  1133                     //Setting the output param

  1134                     CContactIterator* iterator=CContactIterator::NewL(iter);

  1135                     CleanupStack::PushL(iterator);