FCL/sf/mw/serviceapi: comparison serviceproviders/sapi_contacts

equal deleted inserted replaced

-:989d2f495d90
+:fc9cf246af83
 #include <CVPbkContactStoreUriArray.h>
 #include <CVPbkContactManager.h>
 #include <MVPbkContactStoreList.h>
 #include <TVPbkContactStoreUriPtr.h>
 #include <MVPbkContactLink.h>
+#include <f32file.h>
+#include <e32des16.h>
+#include <e32base.h>
+#include <e32svr.h>
 // User Includes
 #include "contactservice.h"
 #include "contactinterface.h"
 #include "contactinterfacecallback.h"
 break;
 }
 case R_VPBK_FIELD_TYPE_EMAILGEN :
 case R_VPBK_FIELD_TYPE_EMAILWORK:
 case R_VPBK_FIELD_TYPE_EMAILHOME:
+		  case R_VPBK_FIELD_TYPE_IMPP:
 {
 fieldmaxlength =  KMaxLengthOneHundredAndFifty;
 break;
 }
 case R_VPBK_FIELD_TYPE_ADDRLABELHOME:
 fieldmaxlength =  KMaxLengthTwoHundredAndFifty;
 break;
 }
 case R_VPBK_FIELD_TYPE_LOCPRIVACY:
 case R_VPBK_FIELD_TYPE_RINGTONE:
+		  case R_VPBK_FIELD_TYPE_CALLEROBJIMG:
 {
 fieldmaxlength = KMaxLengthTwoHundredAndFiftySix;
 break;
 }
 case R_VPBK_FIELD_TYPE_URLWORK:
 void CContactInterface::ProcessAddDataL(const CLiwMap* aMap,
 										CSingleContact* aContact,
 										CLiwGenericParamList& aOutParamList)
 {
+TBool xspid = EFalse;
+TBool xspidIsDes = EFalse;
 TBool atleastOneField = EFalse;
 iDburi = HBufC::NewL(VPbkContactStoreUris::DefaultCntDbUri().Length());
 //set the DBUri to the default value.
 iDburi->Des().Copy(VPbkContactStoreUris::DefaultCntDbUri());
 //get the number of entries in the map
 }
 else
 {
 //if the key is not uri and is not a contact id
 //search for the field
-if(CSearchFields::GetIdFromFieldKey(fieldKey) == -1)
+if(CSearchFields::GetIdFromFieldKey(fieldKey) != -1)
-{
+/*   {
 TBuf<25> buff;
 buff.Copy(fieldKey);
 TBuf<KMaxName> errmsg(KAddInvalidFieldKey);
 errmsg.Append(buff);
 	aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
 	                      TLiwVariant(errmsg)));
 				User::Leave(KErrArgument);
 }
+else*/
+{
 			aMap->FindL(fieldKey,fieldVal);
 	 	if(EVariantTypeMap == fieldVal.TypeId())
 {
 const CLiwMap* pMap = fieldVal.AsMap();
 if(pMap)
 						}
 					TBool date = EFalse;
 						//Set contact item field value
 					if(pMap->FindL(KFieldValue, valueVar))
 						{
-if((fieldKey.Compare(KDate) == 0 || (fieldKey.Compare(KAnniversary) == 0)))
+						if(fieldKey.Compare(KXspid) == 0)
+						    {
+						    xspid = ETrue;
+						    if(EVariantTypeList != valueVar.TypeId())
+						        {
+						        	if(EVariantTypeDesC ==  valueVar.TypeId())
+						        	{
+						        	//xspidIsDes = ETrue;
+						        	CLiwList* xspidList = NULL;
+						        	xspidList = CLiwDefaultList::NewL();
+						      /*  	TPtrC val = valueVar.AsDes();
+						        	TBuf<1000> bufVal;
+						        	bufVal.Copy(val);
+						        	HBufC* xspidVal = bufVal.AllocLC();*/
+						        	xspidList->AppendL(valueVar);
+						        	valueVar.Reset();
+						        	valueVar.Set(xspidList);
+						        	}
+						            else
+						                {
+						        TPtr16  err(iErrorMess->Des());
+TBuf<KMaxName> buf;
+buf.Copy(valueVar.AsData());
+err.Append(KAddCnt);
+err.Append(buf);
+err.Append(KAddInvalidTime);
+aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(*iErrorMess) ) );
+CleanupStack::Pop(&nextVar);
+nextVar.Reset();
+CleanupStack::Pop(&valueVar);
+valueVar.Reset();
+CleanupStack::Pop(&labelVar);
+labelVar.Reset();
+CleanupStack::Pop(&fieldVal);
+fieldVal.Reset();
+err.Delete(0,iErrorMess->Length());
+User::Leave(KErrArgument);
+						                }
+						        }
+						    }
+if((fieldKey.Compare(KDate) == 0 || (fieldKey.Compare(KAnniversary) == 0))) // || (fieldKey.Compare(KBirthDay) == 0))
 	                        {
 	                        if(EVariantTypeTTime != valueVar.TypeId())
 	                        {
 							TPtr16  err(iErrorMess->Des());
 							TBuf<KMaxName> buf;
 						err.Delete(0,iErrorMess->Length());
 							User::Leave(KErrArgument);
 	                        }
 date = ETrue;
 }
+						if((EVariantTypeDesC !=  valueVar.TypeId())	&& (date == EFalse) && (xspid == EFalse))
-						if((EVariantTypeDesC !=  valueVar.TypeId())	&& (date == EFalse))
 							{
 							TPtr16  err(iErrorMess->Des());
 							TBuf<KMaxName> buf;
 							buf.Copy(valueVar.AsData());
 							err.Append(KAddCnt);
 {
 field->SetFieldParamsL(fieldKey,
 						                       labelVar.AsDes(),
 					    	                   KNullDesC);
 					    field->SetDateTime(valueVar.AsTTime());
+	                    }
+else if(xspid && !xspidIsDes)
+{
+RPointerArray<HBufC> xspidArray;
+const CLiwList* xspidList = valueVar.AsList();
+TInt count = xspidList->Count();
+for(int i =0; i< count; i++)
+{
+TLiwVariant xspidVal;
+if(xspidList->AtL(i,xspidVal))
+{
+TPtrC ptrVal = xspidVal.AsDes();
+HBufC *pHeap1 = ptrVal.AllocLC();
+xspidArray.Append(pHeap1);
+TInt len = pHeap1->Find(_L(":"));
+if(len == -1)
+{
+aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
+TLiwVariant(KAddXspidInvalidFormat)));
+User::Leave(KErrArgument);
+}
+CleanupStack::Pop(pHeap1);
+}
+}
+field->SetXspidDataL(fieldKey,
+labelVar.AsDes(),
+xspidArray);
+xspid = EFalse;
 	                    }
 else
 {
 						field->SetFieldParamsL(fieldKey,
 labelVar.AsDes(),
 				                       TLiwVariant(*iErrorMess) ) );
 				err.Delete(0,iErrorMess->Length());
 				User::Leave(KErrArgument);
 				}
+}
 }
 		CleanupStack::Pop(&fieldVal);
 		fieldVal.Reset();
 } //end of for
 //checking for the maximum length (this is a temporary check since there is no support from vpbk)
 for( TInt i=0;i<fieldCount;i++ )
 {
 contactfield = aContact->FieldAt(i);
 if(contactfield)
 {
 contactfield->GetFieldDataL(fieldKey, fieldLabel, fieldValue);
-			 if(!(fieldKey.Compare(KDate) == 0 || fieldKey.Compare(KAnniversary) == 0))
+if(fieldKey.Compare(KXspid) == 0)
+{
+RPointerArray<HBufC> xspidArr;
+contactfield->GetXspidDataL(xspidArr);
+for(TInt j=0;j<xspidArr.Count(); j++)
+{
+HBufC* xspidVal = xspidArr[j];
+//HBufC* xspidBufVal = xspidVal.AllocL();
+if(xspidVal->Length() > GetFieldMaxLength(CSearchFields::GetIdFromFieldKey(fieldKey), *iDburi))
+{
+TPtr16  err(iErrorMess->Des());
+TBuf<KMaxName> fld;
+fld.Copy(fieldKey);
+err.Append(_L("Contacts : Add : Field Value too long for key : "));
+err.Append(fld);
+aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
+TLiwVariant(*iErrorMess)));
+err.Delete(0,iErrorMess->Length());
+User::Leave(KErrArgument);
+}
+}
+}
+else if(!(fieldKey.Compare(KDate) == 0 || fieldKey.Compare(KAnniversary) == 0))
 			 {
 	            if(fieldValue.Length() > GetFieldMaxLength(CSearchFields::GetIdFromFieldKey(fieldKey), *iDburi))
 	        		{
 	        		TPtr16  err(iErrorMess->Des());
 	        		TBuf<KMaxName> fld;
 {
 GetListCommandL(aInParamList,
 aOutParamList,
 aCallback,
 aCmdOptions,
-transId);
+transId,
+EGetList);
 }
+//Passing arguments for GetIds command
+else if( aCmdName.CompareF( KCmdGetIds ) == 0 )
+{
+GetListCommandL(aInParamList,
+aOutParamList,
+aCallback,
+aCmdOptions,
+transId,
+EGetIds);
+}
 else
 		{
 //Leave with the error code
 aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
 TLiwVariant(KCommandNotSupported)));
 void CContactInterface::
 GetListCommandL(const CLiwGenericParamList& aInParamList,
 CLiwGenericParamList& aOutParamList,
 MLiwNotifyCallback* aCallback,
 TUint aCmdOptions,
-TInt aTransId)
+TInt aTransId, TCmdType aVal)
 {
 const TLiwGenericParam* paramContentType = NULL;
 	const TLiwGenericParam* paramGetListData = NULL;
 const TLiwGenericParam* paramGetListSortOrder = NULL;
 	TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri());
 	//Switch based on the Ttype var value
 	switch(listType)
 	    {
 		case EDatabase:
+		    if(aVal == EGetIds)
+		        {
+		        aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
+		                                      TLiwVariant(KGetIdsInvalidContentType)));
+		        User::Leave(KErrArgument);
+		        }
 		    //In case it is GetList of dabases, the call is synchronous
 			iter = CContactIter::NewL();
 			CleanupStack::PushL(iter);
 			iContactService->GetListL(*iter);
 		    CleanupStack::Pop(iter);
 										  listType,
 										  *cntid,
 										  KNullDesC,
 										  NULL,
 										  EAsc,
-										  dbUri);
+										  dbUri,aVal);
 CleanupStack :: Pop(contactCallback);
 CleanupStack::PopAndDestroy(cntid);
 }
 else
 {
-//it is assumed that the call is synchronous
+if(aVal == EGetList)
+{
+					//it is assumed that the call is synchronous
 CContactIter* iter =
 iContactService->GetListL(listType,
 *cntid,
 KNullDesC,
 NULL,
 EAsc,
-dbUri);
+dbUri,
+aVal);
 aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
 TLiwVariant((TInt32)SErrNone)));
 //Setting the output param
 CContactIterator* iterator=CContactIterator::NewL(iter);
 CleanupStack::PushL(iterator);
 aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
 TLiwVariant(iterator)));
 CleanupStack::Pop(iterator);
 iterator->DecRef();
+}
+else
+{
+aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
+TLiwVariant((TInt32)SErrBadArgumentType)));
+aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetIdsBadArgGrpId) ) );
+}
 CleanupStack::PopAndDestroy(cntid);
 CleanupStack::Pop(&groupId);
 groupId.Reset();
 CleanupStack::Pop(&uriofDb);
 uriofDb.Reset();
 listType,
 ptrToCntId,
 KNullDesC,
 NULL,
 EAsc,
-dbUri);
+dbUri,
+aVal);
 CleanupStack :: Pop(contactCallback);
 }
 else
 {
-//it is assumed that the call is synchronous
+if(aVal == EGetList)
+{
+				//it is assumed that the call is synchronous
 CContactIter* iter =
 iContactService->GetListL(listType,
 ptrToCntId,
 KNullDesC,
 										  NULL,
 										  EAsc,
-dbUri);
+dbUri,
+aVal);
 //Setting the output param
 CContactIterator* iterator=CContactIterator::NewL(iter);
 CleanupStack::PushL(iterator);
 aOutParamList.AppendL(TLiwGenericParam( KReturnValue,
 TLiwVariant(iterator) ));
 CleanupStack::Pop(iterator);
 iterator->DecRef();
+}
+else
+{
+//call the GetIds() service api
+RPointerArray<HBufC8>& arrayid =
+iContactService->GetIdsL(listType,
+KNullDesC,
+NULL,
+EAsc,
+dbUri,
+aVal);
+aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
+TLiwVariant((TInt32)SErrNone)));
+//Setting the output param
+if(arrayid.Count() > 0)
+{
+CLiwList* iList = NULL;
+iList = CLiwDefaultList::NewL();
+TLiwVariant outputVal;
+TInt count = arrayid.Count();
+TInt i;
+for(i=0; i<count; i++)
+{
+TDesC8* idVal = arrayid[i];
+							HBufC* cntIdUnicode = HBufC::NewL(idVal->Length());
+CleanupStack :: PushL(cntIdUnicode);
+cntIdUnicode->Des().Copy(*idVal);
+CContactInterfaceCallback::ContactIDToUTF(cntIdUnicode);
+outputVal.Set(*cntIdUnicode);
+iList->AppendL(outputVal);
+CleanupStack :: Pop(cntIdUnicode);
+}
+CLiwMap* pFieldLinkedMap = CLiwDefaultMap::NewL();
+CleanupClosePushL(*pFieldLinkedMap);
+pFieldLinkedMap->InsertL(KIdsLabel,TLiwVariant(iList));
+aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
+TLiwVariant(pFieldLinkedMap)));
+CleanupStack::PopAndDestroy(pFieldLinkedMap);
+arrayid.ResetAndDestroy();
+}
+}
 	CleanupStack::Pop(&groupId);
 	groupId.Reset();
 CleanupStack::Pop(&uriofDb);
 uriofDb.Reset();
 return;
 	 contactCallback->SetParams(aCallback,
 	                            aTransId,
 	                            &aInParamList);
 	 //Call GetList in case of retrieval of a
 	 //single contact whose id is known
-iContactService->GetListL(contactCallback,
+					 iContactService->GetListL(contactCallback,
 										  aTransId,
 										  listType,
 										  *cntid,
 										  KNullDesC,
 										  NULL,
 										  EAsc,
-										  dbUri);
+										  dbUri,
+										  aVal);
 CleanupStack :: Pop(contactCallback);
 CleanupStack::PopAndDestroy(cntid);
 }
 else
 {
 //it is assumed that the call is synchronous
-CContactIter* iter =
+if(aVal == EGetList)
+{
+				CContactIter* iter =
 iContactService->GetListL(listType,
 *cntid,
 KNullDesC,
 NULL,
 EAsc,
-dbUri);
+dbUri,
+aVal);
 aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
 TLiwVariant((TInt32)SErrNone)));
 //Setting the output param
 CContactIterator* iterator=CContactIterator::NewL(iter);
 CleanupStack::PushL(iterator);
 aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
 TLiwVariant(iterator)));
 CleanupStack::Pop(iterator);
 iterator->DecRef();
+}
+else
+{
+aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
+TLiwVariant((TInt32)SErrBadArgumentType)));
+aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,
+TLiwVariant(KGetIdsBadArgCntId) ) );
+}
 CleanupStack::PopAndDestroy(cntid);
 CleanupStack::Pop(&contactId);
 contactId.Reset();
 CleanupStack::Pop(&groupId);
 	    groupId.Reset();
 									  listType,
 									  ptrToCntId,
 									  srchVal,
 									  searchFields,
 									  srtOrder,
-									  dbUri);
+									  dbUri,
+									  aVal);
 CleanupStack :: Pop(contactCallback);
 }
 else
 {
 //it is assumed that the call is synchronous
+if(aVal == EGetList)
+{
 CContactIter* iter =
 iContactService->GetListL(listType,
 											  ptrToCntId,
 											  srchVal,
 											  searchFields,
 											  srtOrder,
-											  dbUri);
+											  dbUri,
+											  aVal);
 aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
 TLiwVariant((TInt32)SErrNone)));
 //Setting the output param
 CContactIterator* iterator=CContactIterator::NewL(iter);
 CleanupStack::PushL(iterator);
 aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
 TLiwVariant(iterator)));
 CleanupStack::Pop(iterator);
 iterator->DecRef();
+}
+else
+{
+RPointerArray<HBufC8>& arrayid =
+iContactService->GetIdsL(listType,
+srchVal,
+searchFields,
+srtOrder,
+dbUri,
+aVal);
+aOutParamList.AppendL(TLiwGenericParam( KErrorCode,
+TLiwVariant((TInt32)SErrNone)));
+//Setting the output param
+if(arrayid.Count() > 0)
+{
+CLiwList* iList = NULL;
+iList = CLiwDefaultList::NewL();
+TLiwVariant outputVal;
+TInt count = arrayid.Count();
+TInt i;
+for(i=0; i<count; i++)
+{
+TDesC8* idVal = arrayid[i];
+HBufC* cntIdUnicode = HBufC::NewL(idVal->Length());
+CleanupStack :: PushL(cntIdUnicode);
+cntIdUnicode->Des().Copy(*idVal);
+CContactInterfaceCallback::ContactIDToUTF(cntIdUnicode);
+outputVal.Set(*cntIdUnicode);
+iList->AppendL(outputVal);
+CleanupStack :: Pop(cntIdUnicode);
+}
+CLiwMap* pFieldLinkedMap = CLiwDefaultMap::NewL();
+CleanupClosePushL(*pFieldLinkedMap);
+pFieldLinkedMap->InsertL(KIdsLabel,TLiwVariant(iList));
+aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
+TLiwVariant(pFieldLinkedMap)));
+CleanupStack::PopAndDestroy(pFieldLinkedMap);
+arrayid.ResetAndDestroy();
+}
+}
 CleanupStack::Pop(&order);
 order.Reset();
 CleanupStack::Pop(&searchFieldKeys);
 searchFieldKeys.Reset();
 CleanupStack::Pop(&searchVal);
 CleanupStack :: Pop(contactCallback);
 }
 else
 {
 //it is assumed that the call is synchronous
-TRAPD(err,iContactService->AddL(contact,
-KNullDesC8, //group id
+HBufC8* cntIdVal = NULL;
-KNullDesC, //group label
+TRAPD(err, cntIdVal = iContactService->AddL(contact,
-*iDburi));
+KNullDesC8, //group id
+KNullDesC, //group label
+*iDburi));
 if(err == KErrNotSupported)
 {
 TInt errkey  = iContactService->GetErrKey();
 TPtrC8 ptr = CSearchFields::GetFieldKeyFromId(errkey);
 		TBuf<25> buff;
 TBuf<KMaxName> errmsg(KAddFieldKeyNotSupported);
 		errmsg.Append(buff);
 aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
 TLiwVariant(errmsg)));
 User::Leave(err);
+}
+if(err == KErrNone)
+{
+HBufC* cntIdUnicode = HBufC::NewL(cntIdVal->Length());
+CleanupStack :: PushL(cntIdUnicode);
+cntIdUnicode->Des().Copy(*cntIdVal);
+delete cntIdVal;
+cntIdVal = NULL;
+CContactInterfaceCallback::ContactIDToUTF(cntIdUnicode);
+aOutParamList.AppendL(TLiwGenericParam(KReturnValue,TLiwVariant(*cntIdUnicode)));
+CleanupStack :: Pop(cntIdUnicode);
 }
-}
+else
+{
+User::Leave(err);
+}
+}
 CleanupStack::Pop(contact);
 } //end of if pMap
 else
 {
 aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
 dbUri.Set(valueUri.AsDes());
 }
 }
 if(EFalse != pMap->FindL(KGroupId,valueGrpid))
 {
+TInt typeofgrpId = valueGrpid.TypeId();
 TPtrC grpIdUnicode = valueGrpid.AsDes();
 			if(grpIdUnicode == NULL)
 				{
 				CleanupStack::Pop(&valueGrpid);
 				valueGrpid.Reset();
 //get the values for dburi, group id and group label
 if(EFalse != pMap->FindL(KGroupLabel,valueGrplabel))
 {
 			if(EVariantTypeDesC != valueGrplabel.TypeId())
 				{
+				CleanupStack::Pop(&valueUri);
+valueUri.Reset();
 				CleanupStack::Pop(&valueGrplabel);
 				valueGrplabel.Reset();
 				CleanupStack::Pop(&valueGrpid);
 				valueGrpid.Reset();
 CleanupStack :: Pop(contactCallback);
 }
 else
 {
 //it is assumed that the call is synchronous
-TRAPD(err,iContactService->AddL(NULL,
+HBufC8* grpId = NULL;
+TRAPD(err,grpId = iContactService->AddL(NULL,
 *groupId,
 grpLabel,
 dbUri));
 if(err == KErrNotSupported)
 {
 TBuf<KMaxName> errmsg(KAddFieldKeyNotSupported);
 		errmsg.Append(buff);
 aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,
 TLiwVariant(errmsg)));
 User::Leave(err);
 }
+if(err == KErrNone)
+{
+if(grpId)
+{
+HBufC* grpIdUnicode = HBufC::NewL(grpId->Length());
+CleanupStack :: PushL(grpIdUnicode);
+grpIdUnicode->Des().Copy(*grpId);
+delete grpId;
+grpId = NULL;
+CContactInterfaceCallback::ContactIDToUTF(grpIdUnicode);
+aOutParamList.AppendL(TLiwGenericParam(KReturnValue,TLiwVariant(*grpIdUnicode)));
+CleanupStack :: Pop(grpIdUnicode);
+}
+}
+else
+{
+User::Leave(err);
+}
 }
 	        CleanupStack :: PopAndDestroy(groupId);
 	        CleanupStack::Pop(&valueUri);
 	        valueUri.Reset();

changeset 22	fc9cf246af83
parent 19	989d2f495d90
child 33	50974a8b132e