diff -r 000000000000 -r 14df0fbfcc4e sapi_contacts_vpbk/src/contactinterface.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sapi_contacts_vpbk/src/contactinterface.cpp Mon Mar 30 12:51:10 2009 +0300 @@ -0,0 +1,2471 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Provides interface between the AIW FrameWork and Service Provider. +* +*/ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +// User Includes +#include "contactservice.h" +#include "contactinterface.h" +#include "contactinterfacecallback.h" +#include "searchfields.h" +#include "contactservice.hrh" +#include "contacterrormessage.hrh" +#include "../../inc/serviceerrno.h" +#include "contactsmaxlength.h" + +using namespace LIW; + +#define KMissingArg -100 + +/* +----------------------------------------------------------------------------- + CContactInterface::CContactInterface() + Description : Constructor + Return values : N/A +----------------------------------------------------------------------------- +*/ +CContactInterface::CContactInterface() + : iContactService( NULL ), + iErrorMess(NULL), + iDburi(NULL) + { + } + +/* +----------------------------------------------------------------------------- + void CContactInterface::ConstructL() + Description : Symbian 2nd phase constructor can leave. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CContactInterface::ConstructL() + { + iContactService = CContactService::NewL(); + iErrorMess = HBufC::NewL(250); + } +/* +----------------------------------------------------------------------------- + CContactInterface* CContactInterface::NewL() + Description : Two-phased constructor. + Return values : CContactInterface object pointer + +----------------------------------------------------------------------------- +*/ +EXPORT_C CContactInterface* CContactInterface::NewL() + { + CContactInterface* self = new ( ELeave ) CContactInterface(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } +/* +----------------------------------------------------------------------------- + CContactInterface::~CContactInterface() + Description : Destructor, free allocated resources + Return values : N/A +----------------------------------------------------------------------------- +*/ +CContactInterface::~CContactInterface() + { + delete iContactService; + delete iErrorMess; + delete iDburi; + iCallbackMap.ResetAndDestroy(); + iCallbackMap.Close(); + } + +/* +----------------------------------------------------------------------------- + CContactInterface::GetFieldMaxLength() + Description : Gets the max length of the field. + Return values : MaxLength +----------------------------------------------------------------------------- +*/ + +TInt CContactInterface :: GetFieldMaxLength(TInt aFieldKeyID, TDesC& aDbUri) + { + TInt fieldmaxlength = -1; + switch(aFieldKeyID) + { + case R_VPBK_FIELD_TYPE_LASTNAME : + case R_VPBK_FIELD_TYPE_FIRSTNAME : + case R_VPBK_FIELD_TYPE_SECONDNAME : + case R_VPBK_FIELD_TYPE_DEPARTMENT : + case R_VPBK_FIELD_TYPE_JOBTITLE : + case R_VPBK_FIELD_TYPE_ASSTNAME : + case R_VPBK_FIELD_TYPE_ASSTPHONE : + case R_VPBK_FIELD_TYPE_SPOUSE : + case R_VPBK_FIELD_TYPE_CHILDREN : + case R_VPBK_FIELD_TYPE_COMPANYNAME : + case R_VPBK_FIELD_TYPE_MIDDLENAME : + case R_VPBK_FIELD_TYPE_ADDRSTREETGEN: + case R_VPBK_FIELD_TYPE_ADDRSTREETHOME: + case R_VPBK_FIELD_TYPE_ADDRSTREETWORK: + case R_VPBK_FIELD_TYPE_ADDRLOCALGEN : + case R_VPBK_FIELD_TYPE_ADDRLOCALHOME: + case R_VPBK_FIELD_TYPE_ADDRLOCALWORK: + case R_VPBK_FIELD_TYPE_ADDRREGIONGEN: + case R_VPBK_FIELD_TYPE_ADDRREGIONHOME: + case R_VPBK_FIELD_TYPE_ADDRREGIONWORK: + case R_VPBK_FIELD_TYPE_ADDRCOUNTRYGEN: + case R_VPBK_FIELD_TYPE_ADDRCOUNTRYHOME: + case R_VPBK_FIELD_TYPE_ADDRCOUNTRYWORK: + case R_VPBK_FIELD_TYPE_ADDREXTGEN: + case R_VPBK_FIELD_TYPE_ADDREXTHOME: + case R_VPBK_FIELD_TYPE_ADDREXTWORK: + { + // a very bad fix for sim case + if(aFieldKeyID == R_VPBK_FIELD_TYPE_LASTNAME && (aDbUri.CompareF(KSimDataBaseOne) == 0)) + { + //comparing the database uri for sim and setting the length + fieldmaxlength = KMaLengthFourteen; + } + else + { + fieldmaxlength = KMaxLengthFifty; + } + break; + } + + case R_VPBK_FIELD_TYPE_MOBILEPHONEGEN : + case R_VPBK_FIELD_TYPE_MOBILEPHONEHOME : + case R_VPBK_FIELD_TYPE_MOBILEPHONEWORK : + case R_VPBK_FIELD_TYPE_LANDPHONEGEN : + case R_VPBK_FIELD_TYPE_LANDPHONEHOME : + case R_VPBK_FIELD_TYPE_LANDPHONEWORK : + case R_VPBK_FIELD_TYPE_VIDEONUMBERHOME : + case R_VPBK_FIELD_TYPE_VIDEONUMBERWORK : + case R_VPBK_FIELD_TYPE_VIDEONUMBERGEN : + case R_VPBK_FIELD_TYPE_CARPHONE : + case R_VPBK_FIELD_TYPE_PAGERNUMBER : + case R_VPBK_FIELD_TYPE_FAXNUMBERHOME : + case R_VPBK_FIELD_TYPE_FAXNUMBERWORK : + case R_VPBK_FIELD_TYPE_FAXNUMBERGEN : + { + fieldmaxlength = KMaxLengthFourtyEight; + break; + } + case R_VPBK_FIELD_TYPE_ADDRPOGEN : + case R_VPBK_FIELD_TYPE_ADDRPOHOME : + case R_VPBK_FIELD_TYPE_ADDRPOWORK : + case R_VPBK_FIELD_TYPE_ADDRPOSTCODEGEN : + case R_VPBK_FIELD_TYPE_ADDRPOSTCODEHOME : + case R_VPBK_FIELD_TYPE_ADDRPOSTCODEWORK : + { + fieldmaxlength = KMaxLengthTwenty; + break; + } + case R_VPBK_FIELD_TYPE_PREFIX: + case R_VPBK_FIELD_TYPE_SUFFIX: + { + fieldmaxlength = KMaxLengthTen; + break; + } + + case R_VPBK_FIELD_TYPE_DTMFSTRING: + { + fieldmaxlength = KMaxLengthSixty; + break; + } + + case R_VPBK_FIELD_TYPE_SIP: + case R_VPBK_FIELD_TYPE_POC: + case R_VPBK_FIELD_TYPE_VOIPHOME: + case R_VPBK_FIELD_TYPE_VOIPWORK: + case R_VPBK_FIELD_TYPE_VOIPGEN: + case R_VPBK_FIELD_TYPE_SWIS: + { + fieldmaxlength = KMaxLengthHundred; + break; + } + case R_VPBK_FIELD_TYPE_EMAILGEN : + case R_VPBK_FIELD_TYPE_EMAILWORK: + case R_VPBK_FIELD_TYPE_EMAILHOME: + { + fieldmaxlength = KMaxLengthOneHundredAndFifty; + break; + } + case R_VPBK_FIELD_TYPE_ADDRLABELHOME: + case R_VPBK_FIELD_TYPE_ADDRLABELGEN: + case R_VPBK_FIELD_TYPE_ADDRLABELWORK : + { + fieldmaxlength = KMaxLengthTwoHundredAndFifty; + break; + } + case R_VPBK_FIELD_TYPE_LOCPRIVACY: + case R_VPBK_FIELD_TYPE_RINGTONE: + { + fieldmaxlength = KMaxLengthTwoHundredAndFiftySix; + break; + } + case R_VPBK_FIELD_TYPE_URLWORK: + case R_VPBK_FIELD_TYPE_URLHOME: + case R_VPBK_FIELD_TYPE_URLGEN: + case R_VPBK_FIELD_TYPE_NOTE: + case R_VPBK_FIELD_TYPE_SYNCCLASS: + { + fieldmaxlength = KMaxLengthThousand; + break; + } + } + return fieldmaxlength; + } + +/* +----------------------------------------------------------------------------- + CContactInterface::ExecuteCmdL() + Description : This is called by the consumer with command to execute. + Return values : N/A +----------------------------------------------------------------------------- +*/ +EXPORT_C void CContactInterface:: + ExecuteCmdL(const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback) + { + //Top level TRAP for all the api's + TRAPD(returnCode, + ProcessCmdL(aCmdName, + aInParamList, + aOutParamList, + aCmdOptions, + aCallback)); + //append the appropriate error code. + TInt32 SapiErr = SapiError(returnCode); + aOutParamList.AppendL(TLiwGenericParam(KErrorCode, + TLiwVariant((TInt32)SapiErr))); + } + +/* +--------------------------------------------------------------------------- + CContactInterface::SapiError(err) + Description :This function is called by the user to get mapped SAPI + generic error code from symbian error codes. + Return values :Integer Value TInt. +--------------------------------------------------------------------------- +*/ +TInt CContactInterface::SapiError( TInt aSymbianErr ) + { + TInt sapiErr(SErrGeneralError); + + switch (aSymbianErr) + { + case KErrBadName: + case KErrArgument: + { + sapiErr = SErrBadArgumentType; + break; + } + case KErrNotSupported: + { + sapiErr = SErrServiceNotSupported; + break; + } + case KErrInUse: + { + sapiErr = SErrServiceInUse; + break; + } + case KErrAccessDenied: + { + sapiErr = SErrAccessDenied; + break; + } + case KErrNoMemory: + { + sapiErr = SErrNoMemory; + break; + } + case KErrAlreadyExists: + { + sapiErr = SErrEntryExists; + break; + } + case KErrNotReady: + { + sapiErr = SErrServiceNotReady; + break; + } + case KErrNotFound: + { + sapiErr = SErrNotFound; + break; + } + case KErrNone: + { + sapiErr = SErrNone; + break; + } + case KErrPathNotFound: + { + sapiErr = SErrPathNotFound; + break; + } + case KMissingArg: + { + sapiErr = SErrMissingArgument; + break; + } + default: + { + sapiErr = SErrGeneralError; + } + } + return sapiErr; + } + +/* +----------------------------------------------------------------------------- + CContactInterface::Close() + Description : This is called by the consumer to delete the handle. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CContactInterface::Close() + { + delete this; + } + +/* +----------------------------------------------------------------------------- + CContactInterface::ContactIDUTFToStreamL() + Description : This method is used to convert the UTF to stream. + Return values : N/A +----------------------------------------------------------------------------- +*/ +HBufC8* CContactInterface::ContactIDUTFToStreamL(TDesC& aContactIDUTF) + { + TInt len = aContactIDUTF.Length(); + HBufC8* buf = HBufC8 :: NewL(len); + buf->Des().SetLength(len); + TUint16* ptr = const_cast(aContactIDUTF.Ptr()); + TUint8* ptr8 = const_cast(buf->Des().Ptr()); + + for(TInt i=0; i=0x100) + c = c & 0x00ff; + ptr8[i] = (TUint8)c; + } + return buf; + } + +/* +----------------------------------------------------------------------------- + CContactInterface::ProcessAddDataL(const CLiwMap* aMap, + TPtrC& aDbUri, + CSingleContact* aContact) + Description : Constructs a contact from the fields that exist in the map.. + Return values : N/A +----------------------------------------------------------------------------- +*/ + +void CContactInterface::ProcessAddDataL(const CLiwMap* aMap, + CSingleContact* aContact, + CLiwGenericParamList& aOutParamList) + { + 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 + TInt keyCount = aMap->Count(); + + for(TInt index=0;index fieldKey; + TLiwVariant fieldVal; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup ,&fieldVal) ); + + //AtL gives us the key stored at a particular index + aMap->AtL(index, fieldKey); + //check whether the key is DBUri + //if it is extract it and mark it. + if( fieldKey.Compare(KDBUri) == 0 ) + { + //get the DBUri from the map + if(aMap->FindL(fieldKey, fieldVal)) + { + if(fieldVal.AsDes().CompareF(KNullDesC)!=0) + { + delete iDburi; + iDburi = NULL; + iDburi = HBufC::NewL(fieldVal.AsDes().Length()); + iDburi->Des().Copy(fieldVal.AsDes()); + } + } + } + else if( fieldKey.Compare(KContactId) == 0 ) + { + //get the contact ID from the map + if(aMap->FindL(fieldKey, fieldVal)) + { + TPtrC cntIdUnicode = fieldVal.AsDes(); + if(cntIdUnicode == NULL) + { + aOutParamList.AppendL(TLiwGenericParam (KErrorMessage, + TLiwVariant(KAddWrongContactId))); + User::Leave(KErrArgument); + } + + HBufC8* cntid = ContactIDUTFToStreamL(cntIdUnicode); + aContact->SetContactIdL(*cntid); + delete cntid; + } + } + else + { + //if the key is not uri and is not a contact id + //search for the field + if(CSearchFields::GetIdFromFieldKey(fieldKey) == -1) + { + TBuf<25> buff; + buff.Copy(fieldKey); + TBuf errmsg(KAddInvalidFieldKey); + errmsg.Append(buff); + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(errmsg))); + User::Leave(KErrArgument); + } + aMap->FindL(fieldKey,fieldVal); + if(EVariantTypeMap == fieldVal.TypeId()) + { + const CLiwMap* pMap = fieldVal.AsMap(); + if(pMap) + { + TLiwVariant labelVar; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &labelVar) ); + + TLiwVariant valueVar; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueVar) ); + + TLiwVariant nextVar; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &nextVar) ); + while(1) + { + //Get field label and value from map + if(pMap->FindL(KFieldLabel, labelVar)) + { + if(EVariantTypeDesC != labelVar.TypeId()) + { + TPtr16 err(iErrorMess->Des()); + TBuf buf; + buf.Copy(labelVar.AsData()); + err.Append(KAddCnt); + err.Append(buf); + err.Append(KAddInvalidStr); + 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); + } + } + TBool date = EFalse; + //Set contact item field value + if(pMap->FindL(KFieldValue, valueVar)) + { + if((fieldKey.Compare(KDate) == 0 || (fieldKey.Compare(KAnniversary) == 0))) + { + if(EVariantTypeTTime != valueVar.TypeId()) + { + TPtr16 err(iErrorMess->Des()); + TBuf 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); + } + date = ETrue; + } + + if((EVariantTypeDesC != valueVar.TypeId()) && (date == EFalse)) + { + TPtr16 err(iErrorMess->Des()); + TBuf buf; + buf.Copy(valueVar.AsData()); + err.Append(KAddCnt); + err.Append(buf); + err.Append(KAddInvalidStr); + + 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); + } + } + CSingleContactField* field = + CSingleContactField::NewL(); + CleanupStack::PushL(field); + if(date) + { + field->SetFieldParamsL(fieldKey, + labelVar.AsDes(), + KNullDesC); + field->SetDateTime(valueVar.AsTTime()); + } + else + { + field->SetFieldParamsL(fieldKey, + labelVar.AsDes(), + valueVar.AsDes()); + + } + aContact->AddFieldToContactL(field); + atleastOneField = ETrue; + CleanupStack::Pop(field); + if(pMap->FindL(KFieldNext,nextVar)) + { + if(EVariantTypeMap == nextVar.TypeId()) + { + pMap = nextVar.AsMap(); + } + else + { + //if the map is not found + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddNextFieldType))); + User::Leave(KErrArgument); + } + } + else //EVariantTypeNull + { + break; + } + } //end of while + CleanupStack::Pop(&nextVar); + nextVar.Reset(); + CleanupStack::Pop(&valueVar); + valueVar.Reset(); + CleanupStack::Pop(&labelVar); + labelVar.Reset(); + } + else + { + //if the map is not found + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddInvalidFieldType))); + User::Leave(KErrArgument); + } + } + else + { + CleanupStack::Pop(&fieldVal); + fieldVal.Reset(); + TPtr16 err(iErrorMess->Des()); + TBuf fld; + fld.Copy(fieldKey); + err.Append(fld); + err.Append(_L(",Invalid Type,Map is Required")); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage, + 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) + CSingleContactField* contactfield = NULL; + TPtrC8 fieldKey(KNullDesC8); + TPtrC fieldLabel(KNullDesC); + TPtrC fieldValue(KNullDesC); + TInt fieldCount = aContact->FieldCount(); + for( TInt i=0;iFieldAt(i); + if(contactfield) + { + contactfield->GetFieldDataL(fieldKey, fieldLabel, fieldValue); + if(!(fieldKey.Compare(KDate) == 0 || fieldKey.Compare(KAnniversary) == 0)) + { + if(fieldValue.Length() > GetFieldMaxLength(CSearchFields::GetIdFromFieldKey(fieldKey), *iDburi)) + { + TPtr16 err(iErrorMess->Des()); + TBuf 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); + } + + } + } + + } + + if(atleastOneField == EFalse) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddKeyNotSpecified))); + User::Leave(KErrArgument); + } + } //End of function : ProcessAddDataL() + + +/* +----------------------------------------------------------------------------- + CContactInterface::ProcessCmdL(const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback ) + Description : This function processes the commands like add, delete, organise, + getlist.....etc. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CContactInterface::ProcessCmdL(const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback ) + { + TInt returnCode = KErrNone; + TInt transId = 0; + //if callback parameter is not null then retrieve the transaction id. + if(aCallback && aCmdOptions == KLiwOptASyncronous) + { + transId = aCallback->GetTransactionID(); + + CContactCallbackMap* map = + new (ELeave) CContactCallbackMap(transId, + aCallback); + CleanupStack::PushL(map); + iCallbackMap.AppendL(map); + CleanupStack::Pop(map); + + //In case of async calls, also set the transaction id + aOutParamList.AppendL(TLiwGenericParam(KTransactionID, + TLiwVariant((TInt32)transId))); + + } + else if((aCmdOptions == KLiwOptASyncronous) && (!aCallback)) + { + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCallbackNotFound))); + User::Leave(KErrArgument); + } + else if(aCallback && (aCmdOptions == 0)) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCallbackNotFound))); + User::Leave(KErrArgument); + + } + + if( aCmdName.CompareF(KCmdCancel) == 0) // for cancel asynchronous request + { + if(aCmdOptions != KLiwOptCancel) + { + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCancleCommandoptionWrong))); + User::Leave(KErrArgument); + + } + returnCode = CancelCommandL(aInParamList, + aOutParamList); + if(returnCode != KErrNone) + { + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCancelUnsuccessful))); + User::Leave(returnCode); + } + } + //check for the command name,...if Import proceed further. + else if ( (aCmdName.CompareF( KCmdImport ) == 0)) + { + ImportCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + //check for the command name,...if Export, proceed further. + else if ( (aCmdName.CompareF( KCmdExport ) == 0)) + { + ExportCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + //check for the command name,...if Add, proceed further. + else if ( (aCmdName.CompareF( KCmdAdd ) == 0)) + { + AddCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + //check for the command name,...if Delete, proceed further. + else if ( (aCmdName.CompareF( KCmdDelete ) == 0)) + { + DeleteCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + + //check for the command name,...if OrganiseGroups, proceed further. + else if ( (aCmdName.CompareF( KCmdOrganiseGroups ) == 0)) + { + OrganiseGroupCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + //Passing arguments for GetList command + else if( aCmdName.CompareF( KCmdGetList ) == 0 ) + { + GetListCommandL(aInParamList, + aOutParamList, + aCallback, + aCmdOptions, + transId); + } + else + { + //Leave with the error code + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCommandNotSupported))); + User::Leave(KErrNotSupported); + } + + } //end of ProcessCmdL + +/* +----------------------------------------------------------------------------- + CContactInterface::GetListCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Getlist API + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CContactInterface:: + GetListCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + const TLiwGenericParam* paramContentType = NULL; + const TLiwGenericParam* paramGetListData = NULL; + const TLiwGenericParam* paramGetListSortOrder = NULL; + + TInt pos = 0; + //Get the content type: it can be "contact" or "group" + paramContentType = aInParamList.FindFirst( pos, KType ); + if(!paramContentType) + { + if(aInParamList.Count()>0) + paramContentType = &aInParamList[0] ; + + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListContentTypeMissing) ) ); + User::Leave(KMissingArg); + } + if(aInParamList.Count()>1) + paramGetListData = &aInParamList[1]; + + if(aInParamList.Count()>2) + paramGetListSortOrder = &aInParamList[2] ; + } + pos = 0; + //Get the filter criteria, the value of which is a Map + paramGetListData = aInParamList.FindFirst( pos, KFilter ); + + pos = 0; + paramGetListSortOrder = aInParamList.FindFirst( pos, KSort ); + + TLiwVariant cnttyp = paramContentType->Value(); + if(EVariantTypeDesC != cnttyp.TypeId()) + { + cnttyp.Reset(); + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListWrongContentType) ) ); + User::Leave(KErrArgument); + } + + //Retrieve the map + const CLiwMap* pMap = NULL; + if(paramGetListData) + { + TLiwVariant getlistdata = paramGetListData->Value(); + if(EVariantTypeMap != getlistdata.TypeId() ) + { + getlistdata.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListInvalidFilterType) ) ); + User::Leave(KErrArgument); + } + pMap = getlistdata.AsMap(); + getlistdata.Reset(); + } + + const CLiwMap* sortMap = NULL; + + if(paramGetListSortOrder) + { + TLiwVariant map = paramGetListSortOrder->Value(); + + if(EVariantTypeMap == map.TypeId()) + { + sortMap= paramGetListSortOrder->Value().AsMap(); + } + else + { + map.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListInvalidSortType) ) ); + User::Leave(KErrArgument); + + } + map.Reset(); + } + + //Get the type of the list requested + Ttype listType = EContacts; + TPtrC contentType; + + contentType.Set(paramContentType->Value().AsDes()); + + //Based on content type set the value of the enum Ttype + if(contentType.Compare(KDatabase) == 0) + { + listType = EDatabase; + } + else if(contentType.Compare(KGroup) == 0) + { + listType = EGroups; + } + else if(contentType.Compare(KContact) == 0) + { + listType = EContacts; + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KGetListInvalidContentType))); + User::Leave(KErrArgument); + } + + TLiwVariant uriofDb; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &uriofDb) ); + + TLiwVariant groupId; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &groupId) ); + + TPtrC8 ptrToCntId(KNullDesC8); + HBufC8* cntid = NULL; + CContactIter* iter; + CContactIterator* iterator; + TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri()); + //Switch based on the Ttype var value + switch(listType) + { + case EDatabase: + //In case it is GetList of dabases, the call is synchronous + iter = CContactIter::NewL(); + CleanupStack::PushL(iter); + iContactService->GetListL(*iter); + CleanupStack::Pop(iter); + //Setting the output param + if(iter) + { + iterator = CContactIterator::NewL(iter); + CleanupStack::PushL(iterator); + aOutParamList.AppendL(TLiwGenericParam(KReturnValue, + TLiwVariant(iterator))); + + CleanupStack::Pop(iterator); + iterator->DecRef(); + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + return; + } + break; + case EGroups: + //In case it is GetList of groups, its asynchronous + //All that is required to get the list of groups is the database name + //(in case its null default database is used) and callback function + if(pMap && (EFalse != pMap->FindL(KDBUri, uriofDb))) + { + if(uriofDb.AsDes().Compare(KNullDesC)!= 0) + { + dbUri.Set(uriofDb.AsDes()); + } + } + // Get the contact id, in case it is specified single contact is retrived + // If content is NULL, search is performed using search criteria + // If the ID is mentioned then the search value and fields are ignored. + if(pMap && (EFalse != pMap->FindL(KGroupId, groupId))) + { + TPtrC ptr = groupId.AsDes(); + cntid = ContactIDUTFToStreamL(ptr); + CleanupStack::PushL(cntid); + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + CleanupStack :: PushL(contactCallback); + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //Call GetList in case of retrieval of a + //single contact whose id is known + iContactService->GetListL(contactCallback, + aTransId, + listType, + *cntid, + KNullDesC, + NULL, + EAsc, + dbUri); + + CleanupStack :: Pop(contactCallback); + CleanupStack::PopAndDestroy(cntid); + } + else + { + //it is assumed that the call is synchronous + CContactIter* iter = + iContactService->GetListL(listType, + *cntid, + KNullDesC, + NULL, + EAsc, + dbUri); + 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(); + CleanupStack::PopAndDestroy(cntid); + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + return; + } + break; + } + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + CleanupStack :: PushL(contactCallback); + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //Call the contactservice api + iContactService->GetListL(contactCallback, + aTransId, + listType, + ptrToCntId, + KNullDesC, + NULL, + EAsc, + dbUri); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + CContactIter* iter = + iContactService->GetListL(listType, + ptrToCntId, + KNullDesC, + NULL, + EAsc, + dbUri); + //Setting the output param + CContactIterator* iterator=CContactIterator::NewL(iter); + CleanupStack::PushL(iterator); + aOutParamList.AppendL(TLiwGenericParam( KReturnValue, + TLiwVariant(iterator) )); + CleanupStack::Pop(iterator); + iterator->DecRef(); + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + return; + } + break; + case EContacts: + //In case it is GetList of contacts, its asynchronous + //Get the database uri, if not specified default database is used + if(pMap && (EFalse != pMap->FindL(KDBUri,uriofDb))) + { + if(uriofDb.AsDes().Compare(KNullDesC)!= 0) + { + dbUri.Set(uriofDb.AsDes()); + } + } + TLiwVariant contactId; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &contactId) ); + + // Get the contact id, in case it is specified single contact is retrived + // If content is NULL, search is performed using search criteria + // If the ID is mentioned then the search value and fields are ignored. + if(pMap && (EFalse != pMap->FindL(KContactId, contactId))) + { + TPtrC ptr = contactId.AsDes(); + cntid = ContactIDUTFToStreamL(ptr); + CleanupStack::PushL(cntid); + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + CleanupStack :: PushL(contactCallback); + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //Call GetList in case of retrieval of a + //single contact whose id is known + iContactService->GetListL(contactCallback, + aTransId, + listType, + *cntid, + KNullDesC, + NULL, + EAsc, + dbUri); + + CleanupStack :: Pop(contactCallback); + CleanupStack::PopAndDestroy(cntid); + } + else + { + //it is assumed that the call is synchronous + CContactIter* iter = + iContactService->GetListL(listType, + *cntid, + KNullDesC, + NULL, + EAsc, + dbUri); + 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(); + CleanupStack::PopAndDestroy(cntid); + CleanupStack::Pop(&contactId); + contactId.Reset(); + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + return; + } + CleanupStack::Pop(&contactId); + contactId.Reset(); + break; + } + CleanupStack::Pop(&contactId); + contactId.Reset(); + TLiwVariant searchVal; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &searchVal) ); + + TPtrC srchVal(KNullDesC); + TLiwVariant searchFieldKeys; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &searchFieldKeys) ); + + //Get the searchval, the value to be searched in the fields specified. + //If the value is NULL, the whole database is listed as an output + if(pMap && (EFalse != pMap->FindL(KSearchVal,searchVal))) + { + if(EVariantTypeDesC != searchVal.TypeId()) + { + CleanupStack::Pop(&searchVal); + searchVal.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListInvalidSearchVal) ) ); + User::Leave(KErrArgument); + } + if(searchVal.AsDes().Compare(KNullDesC)) + srchVal.Set(searchVal.AsDes()); + } + + CSearchFields* searchFields = NULL; + // Get the search fields, fields in which + //the given searchval is to looked for + // in all the contacts of the database. + //If not specified, fields are first and last name + // by default + + TLiwVariant order; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &order) ); + + TPtrC sortOrder; + TOrder srtOrder = EAsc; + + if(NULL != paramGetListSortOrder) + { + if(EFalse != sortMap->FindL(KOrder, order)) + { + if(EVariantTypeDesC != order.TypeId()) + { + CleanupStack::Pop(&order); + order.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KGetListSortOrderValue) ) ); + User::Leave(KErrArgument); + + } + sortOrder.Set(order.AsDes()); + + // Set the TOrder variable to the sort order preference + if( sortOrder.CompareF( KAscending ) == 0) + { + srtOrder = EAsc; + } + else if(sortOrder.CompareF( KDescending ) == 0) + { + srtOrder = EDesc; + } + else + { + CleanupStack::Pop(&order); + order.Reset(); + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KGetListInvalidSortordVal))); + User::Leave(KErrArgument); + } + } + } + + + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + CleanupStack :: PushL(contactCallback); + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + + + //Call to GetList in case of searching + iContactService->GetListL(contactCallback, + aTransId, + listType, + ptrToCntId, + srchVal, + searchFields, + srtOrder, + dbUri); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + CContactIter* iter = + iContactService->GetListL(listType, + ptrToCntId, + srchVal, + searchFields, + srtOrder, + dbUri); + + 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(); + CleanupStack::Pop(&order); + order.Reset(); + CleanupStack::Pop(&searchFieldKeys); + searchFieldKeys.Reset(); + CleanupStack::Pop(&searchVal); + searchVal.Reset(); + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + return; + } + + CleanupStack::Pop(&order); + order.Reset(); + CleanupStack::Pop(&searchFieldKeys); + searchFieldKeys.Reset(); + CleanupStack::Pop(&searchVal); + searchVal.Reset(); + + break; + } + CleanupStack::Pop(&groupId); + groupId.Reset(); + CleanupStack::Pop(&uriofDb); + uriofDb.Reset(); + + if( aCallback && aCmdOptions == KLiwOptASyncronous ) + { + //In case of async calls, also set the transaction id + aOutParamList.AppendL(TLiwGenericParam(KTransactionID, + TLiwVariant((TInt32)aTransId ))); + } + } + +/* +----------------------------------------------------------------------------- + CContactInterface::CancelCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Cancel on the given transaction id + Return values : TInt +----------------------------------------------------------------------------- +*/ + +TInt CContactInterface::CancelCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList) + { + + TInt32 transactionID = 0; + TInt errCode = KErrArgument; + TInt pos = 0; + const TLiwGenericParam* param = NULL; + TLiwGenericParam posbasedparam; + + param = aInParamList.FindFirst( pos, KTransactionID ); + if((!param) && (aInParamList.Count()<=0)) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KCancelTransIdMissing))); + User::Leave(KMissingArg); + } + else + { + pos = 0; + aInParamList.AtL( pos, posbasedparam ); + + if (posbasedparam.Value().IsEmpty() ) + { + param = NULL; + } + else + { + param = &posbasedparam; + } + } + if( param ) + { + param->Value().Get( transactionID ); + errCode = iContactService->Cancel( transactionID ); + } + return errCode; + } + + +/* +----------------------------------------------------------------------------- + CContactInterface::AddCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Add API + Return values : TInt +----------------------------------------------------------------------------- +*/ + +void CContactInterface::AddCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + TInt pos = 0; + const TLiwGenericParam* paramAddData = NULL; + const TLiwGenericParam* paramContentType = NULL; + + if(aInParamList.Count()<2) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage, + TLiwVariant(KAddLessArguments) ) ); + + User::Leave(KMissingArg); + + } + //get the content type and add data. + paramContentType = aInParamList.FindFirst( pos, KType ); + if(!paramContentType) + { + paramContentType = &aInParamList[0]; + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL(TLiwGenericParam (KErrorMessage, + TLiwVariant(KAddContentTypeMissing))); + + User::Leave(KMissingArg); + } + } + + pos = 0; + //Get the add data, the value of which is a Map + paramAddData = aInParamList.FindFirst( pos, KData ); + if(!paramAddData) + { + paramAddData = &aInParamList[1]; + + if(!paramAddData || paramAddData->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL(TLiwGenericParam ( KErrorMessage, + TLiwVariant(KAddDataMissing) ) ); + User::Leave(KMissingArg); + } + } + + //get the content type. + TLiwVariant contentTypeVar = paramContentType->Value(); + + if(EVariantTypeDesC != contentTypeVar.TypeId()) + { + contentTypeVar.Reset(); + aOutParamList.AppendL(TLiwGenericParam ( KErrorMessage, + TLiwVariant(KAddWrongContentType) ) ); + User::Leave(KErrArgument); + + } + + //if content type is "Contacts" then.... + if(contentTypeVar.AsDes().CompareF(KContact) == 0 ) + { + contentTypeVar.Reset(); + //get the liw map from the add data generic parameter. + //if map is not null then call the function ProcesAddDataL(), + //which will parse the map and gets dburi and creates a new contact. + const CLiwMap* pMap = paramAddData->Value().AsMap(); + if( pMap ) + { + //create a new contact. + CSingleContact* contact = CSingleContact::NewL(); + CleanupStack::PushL(contact); + //call to ProcessAddDataL to parse the + //map and create a new contact. + ProcessAddDataL(pMap, contact, aOutParamList); + + if( aCmdOptions == KLiwOptASyncronous ) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(contact); + + CleanupStack :: PushL(contactCallback); + //set the callback parameter values. + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + + //invoke the main method of contactService + //to add/edit a contact/group + //into the database. + iContactService->AddL(contactCallback, + aTransId, + contact, + KNullDesC8, //group id + KNullDesC, //group label + *iDburi); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + TRAPD(err,iContactService->AddL(contact, + KNullDesC8, //group id + KNullDesC, //group label + *iDburi)); + if(err == KErrNotSupported) + { + TInt errkey = iContactService->GetErrKey(); + TPtrC8 ptr = CSearchFields::GetFieldKeyFromId(errkey); + TBuf<25> buff; + buff.Copy(ptr); + TBuf errmsg(KAddFieldKeyNotSupported); + errmsg.Append(buff); + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(errmsg))); + User::Leave(err); + } + } + CleanupStack::Pop(contact); + } //end of if pMap + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddInvalidDataType))); + User::Leave(KErrArgument); + } + } //end of if contentType == KContact + //if content type is "Groups", then.... + else if(contentTypeVar.AsDes().CompareF(KGroup)==0) + { + contentTypeVar.Reset(); + //get the map from the addgroup data. + const CLiwMap* pMap = paramAddData->Value().AsMap(); + if(pMap) + { + TLiwVariant valueGrpid; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueGrpid) ); + + TLiwVariant valueGrplabel; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueGrplabel)); + + TLiwVariant valueUri; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueUri) ); + + //set the Db Uri to default database. + TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri()); + + TPtrC grpIdUnicode(KNullDesC); + TPtrC grpLabel(KNullDesC); + + HBufC8* groupId = NULL; + if( EFalse != pMap->FindL(KDBUri,valueUri)) + { + if( valueUri.AsDes().CompareF(KNullDesC) != 0 ) + { + dbUri.Set(valueUri.AsDes()); + } + } + if(EFalse != pMap->FindL(KGroupId,valueGrpid)) + { + TPtrC grpIdUnicode = valueGrpid.AsDes(); + if(grpIdUnicode == NULL) + { + CleanupStack::Pop(&valueGrpid); + valueGrpid.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KAddInvalGrpId) ) ); + User::Leave(KErrArgument); + //Leave + } + //Convert the values back to the 8 bit descriptor. + groupId = ContactIDUTFToStreamL(grpIdUnicode); + } + else + { + groupId = KNullDesC8().AllocL(); + } + //get the values for dburi, group id and group label + if(EFalse != pMap->FindL(KGroupLabel,valueGrplabel)) + { + if(EVariantTypeDesC != valueGrplabel.TypeId()) + { + CleanupStack::Pop(&valueGrplabel); + valueGrplabel.Reset(); + CleanupStack::Pop(&valueGrpid); + valueGrpid.Reset(); + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KAddInvalGrpLabel) ) ); + User::Leave(KErrArgument); + //Leave + } + if( valueGrplabel.AsDes().CompareF(KNullDesC) != 0) + { + grpLabel.Set(valueGrplabel.AsDes()); + } + else + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KAddGroupLabelEmpty) ) ); + User::Leave(KErrArgument); + } + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddLabelMissing))); + + User::Leave(KErrArgument); + } + CleanupStack :: PushL(groupId); + //All the params are retrieved now call the main api. + if( aCmdOptions == KLiwOptASyncronous ) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + + CleanupStack :: PushL(contactCallback); + //set the parameters for callback + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + + //invoke the main method of the contactService to Add/Edit Group. + iContactService->AddL(contactCallback, + aTransId, + NULL, + *groupId, + grpLabel, + dbUri); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + TRAPD(err,iContactService->AddL(NULL, + *groupId, + grpLabel, + dbUri)); + if(err == KErrNotSupported) + { + TInt errkey = iContactService->GetErrKey(); + TPtrC8 ptr = CSearchFields::GetFieldKeyFromId(errkey); + TBuf<25> buff; + buff.Copy(ptr); + TBuf errmsg(KAddFieldKeyNotSupported); + errmsg.Append(buff); + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(errmsg))); + User::Leave(err); + } + + } + CleanupStack :: PopAndDestroy(groupId); + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueGrplabel); + valueGrplabel.Reset(); + CleanupStack::Pop(&valueGrpid); + valueGrpid.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddInvalidDataType))); + User::Leave(KMissingArg); + } + + } + else + { + contentTypeVar.Reset(); + + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KAddInvalidContentType))); + User::Leave(KErrArgument); + } + + } + +/* +----------------------------------------------------------------------------- + CContactInterface::ImportCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Import API + Return values : TInt +----------------------------------------------------------------------------- +*/ +void CContactInterface::ImportCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + TInt pos = 0; + const TLiwGenericParam* paramImportData = NULL; + const TLiwGenericParam* paramContentType = NULL; + + //get the content type and import data. + paramContentType = aInParamList.FindFirst( pos, KType ); + + if(!paramContentType) + { + + if(aInParamList.Count()<2) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KImportLessArguments) ) ); + User::Leave(KMissingArg); + } + paramContentType = &aInParamList[0] ; + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KImportContentTypeMissing) ) ); + User::Leave(KMissingArg); + } + } + pos = 0; + //Get the delete data, the value of which is a Map + paramImportData = aInParamList.FindFirst( pos, KData ); + if(!paramImportData) + { + if(aInParamList.Count()>1) + paramImportData = &aInParamList[1] ; + if(!paramImportData || paramImportData->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KImportDataMissing) ) ); + User::Leave(KMissingArg); + } + } + + TLiwVariant cnttent = paramContentType->Value(); + + if(EVariantTypeDesC !=cnttent.TypeId()) + { + cnttent.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KImportWrongContentType) ) ); + User::Leave(KErrArgument); + + } + cnttent.Reset(); + + TPtrC contentType; + contentType.Set(paramContentType->Value().AsDes()); + + // Check for content type + + if(contentType !=KContact) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KImportInvalidContentType) ) ); + User::Leave(KErrArgument); + } + + //get the liw map from the import data generic parameter. + //if map is not null then get db name, source file from the + //contact has to be imported. + const CLiwMap* pMap = paramImportData->Value().AsMap(); + if(NULL != pMap) + { + TPtrC dburi(VPbkContactStoreUris::DefaultCntDbUri()); + TLiwVariant valueFname; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueFname) ); + + TLiwVariant valueUri; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueUri) ); + + if( EFalse != pMap->FindL(KDBUri,valueUri)) + { + if(EVariantTypeDesC != valueUri.TypeId()) + { + + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KImportDbUriNotString))); + User::Leave(KErrArgument); + + } + + if(valueUri.AsDes().CompareF(KNullDesC)!=0) + { + dburi.Set(valueUri.AsDes()); + } + } + if(EFalse != pMap->FindL(KSourceFileNameParam,valueFname)) + { + //get the uri and filename. + if(EVariantTypeDesC != valueFname.TypeId()) + { + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueFname); + valueFname.Reset(); + + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KImportSrcFileNotString))); + User::Leave(KErrArgument); + + } + TPtrC filename = valueFname.AsDes(); + TInt length = filename.Length(); + + if(length > KMaxFileName) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KImportFileNameTooLong))); + User::Leave(KErrBadName); + } + + if( aCmdOptions == KLiwOptASyncronous ) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + + CleanupStack::PushL(contactCallback); + //if callback is not null, set the params like + //callback, transid..etc + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //invoke the main method of contact service + //to import the contact. + iContactService->ImportVCardToStoreL(contactCallback, + aTransId, + filename, + dburi); + CleanupStack::Pop(contactCallback); + + } + else + { + //it is assumed that the call is synchronous + iContactService->ImportVCardToStoreL(filename, + dburi); + } + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KImportSrcFileNameMissing))); + User::Leave(KMissingArg); + } + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueFname); + valueFname.Reset(); + } + + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KImportDataMapMissing))); + User::Leave(KMissingArg); + } + } + +/* +----------------------------------------------------------------------------- + CContactInterface::ExportCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Export API + Return values : TInt +----------------------------------------------------------------------------- +*/ +void CContactInterface::ExportCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + TInt pos = 0; + const TLiwGenericParam* paramExportData = NULL; + const TLiwGenericParam* paramContentType = NULL; + //get the content type and export data. + paramContentType = aInParamList.FindFirst( pos, KType ); + + //get the content type and export data. + if(!paramContentType) + { + + if(aInParamList.Count()<2) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KExportLessArguments) ) ); + User::Leave(KMissingArg); + } + + paramContentType = &aInParamList[0] ; + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KExportContentTypeMissing) ) ); + User::Leave(KMissingArg); + } + } + + pos = 0; + //Get the export data, the value of which is a Map + paramExportData = aInParamList.FindFirst( pos, KData ); + if(!paramExportData) + { + if(aInParamList.Count()>1) + paramExportData = &aInParamList[1] ; + if(!paramExportData || paramExportData->Name().Compare(KNullDesC8) != 0) + { + // Append error message + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KExportDataMissing) ) ); + User::Leave(KMissingArg); + } + } + + TLiwVariant cnttent = paramContentType->Value(); + + if(EVariantTypeDesC !=cnttent.TypeId()) + { + cnttent.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KExportWrongContentType) ) ); + User::Leave(KErrArgument); + + } + cnttent.Reset(); + + + + TPtrC contentType; + contentType.Set(paramContentType->Value().AsDes()); + + // Check for content type + if(contentType.Compare(KContact) != 0) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KExportInvalidContentType) ) ); + User::Leave(KErrArgument); + } + + //get the liw map from the export data generic parameter. + //if map is not null then get db name, contact id and dest file + //to whi the contact has to be exported. + const CLiwMap* pMap = paramExportData->Value().AsMap(); + if(NULL != pMap) + { + TLiwVariant valueFname; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueFname) ); + + TLiwVariant valueUri; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueUri) ); + + TPtrC dburi(VPbkContactStoreUris::DefaultCntDbUri()); + if( EFalse != pMap->FindL(KDBUri,valueUri)) + { + if(EVariantTypeDesC != valueUri.TypeId()) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportDbUriNotString))); + User::Leave(KErrArgument); + + } + if(valueUri.AsDes().CompareF(KNullDesC)!=0) + { + dburi.Set(valueUri.AsDes()); + } + } + if(EFalse != pMap->FindL(KDestFileNameParam,valueFname)) + { + + if(EVariantTypeDesC !=valueFname.TypeId() ) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportDestnFlNmWrongType))); + User::Leave(KErrArgument); + } + TLiwVariant valueCntid; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueCntid) ); + + if(EFalse != pMap->FindL(KContactId,valueCntid)) + { + //get dburi, filename and contact id parameters from the map. + if(EVariantTypeDesC != valueCntid.TypeId()) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportContactIdWrongType))); + User::Leave(KErrArgument); + + } + TPtrC filename = valueFname.AsDes(); + TInt length = filename.Length(); + + if(length > KMaxFileName) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportFileNameTooLong))); + User::Leave(KErrBadName); + } + + TPtrC cntIdUnicode = valueCntid.AsDes(); + + HBufC8* cntid = ContactIDUTFToStreamL(cntIdUnicode); + CleanupStack::PushL(cntid); + + if( aCmdOptions == KLiwOptASyncronous ) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + CleanupStack :: PushL(contactCallback); + //if callback is not null, set the params like callback, transid..etc + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //invoke the main method of contact service to export the contact. + iContactService->ExportVCardL(contactCallback, + aTransId, + filename, + *cntid , + dburi); + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + iContactService->ExportVCardL(filename, + *cntid, + dburi); + + + } + CleanupStack :: PopAndDestroy(cntid); + } //end of if Find of cntid + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportContactIdMissing))); + User::Leave(KMissingArg); + + } + CleanupStack::Pop(&valueCntid); + valueCntid.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportDstFileNameMissing))); + User::Leave(KMissingArg); + + } + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueFname); + valueFname.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KExportDataMapMissing))); + User::Leave(KMissingArg); + + } + } + +/* +----------------------------------------------------------------------------- + CContactInterface::DeleteCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Delete API + Return values : TInt +----------------------------------------------------------------------------- +*/ +void CContactInterface::DeleteCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + TInt pos = 0; + const TLiwGenericParam* paramDeleteData = NULL; + const TLiwGenericParam* paramContentType = NULL; + + //get the content type and delete data. + paramContentType = aInParamList.FindFirst(pos, KType); + if(!paramContentType) + { + + if(aInParamList.Count()<1) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteLessArguments) ) ); + User::Leave(KMissingArg); + } + if(aInParamList.Count()>0) + paramContentType = &aInParamList[0] ; + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteContentTypeMissing) ) ); + User::Leave(KMissingArg); + } + } + + pos = 0; + //Get the delete data, the value of which is a Map + paramDeleteData = aInParamList.FindFirst( pos, KData ); + if(!paramDeleteData) + { + if(aInParamList.Count()>1) + paramDeleteData = &aInParamList[1] ; + if(!paramDeleteData || paramDeleteData->Name().Compare(KNullDesC8) != 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteDataMissing) ) ); + User::Leave(KMissingArg); + } + } + + //Get the content type + TLiwVariant contentTypeVar = paramContentType->Value(); + + if(EVariantTypeDesC !=contentTypeVar.TypeId()) + { + contentTypeVar.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteWrongContentType) ) ); + User::Leave(KErrArgument); + + + } + + //either gorups or contacts + if(contentTypeVar.AsDes() == KContact || contentTypeVar.AsDes() == KGroup) + { + //get the map from the delete data generic parameter. + const CLiwMap* pMap = paramDeleteData->Value().AsMap(); + if( pMap ) + { + TLiwVariant valueList; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueList) ); + + TLiwVariant valueUri; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueUri) ); + + TLiwVariant valueId; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueId) ); + + TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri()); + const CLiwList* contactIdList = NULL; + + if( EFalse != pMap->FindL(KDBUri,valueUri)) + { + if(valueUri.AsDes().CompareF(KNullDesC)!=0) + { + dbUri.Set(valueUri.AsDes()); + } + } + //get the dbUri and contact id list from the map. + if(EFalse != pMap->FindL(KList,valueList) ) + { + if(EVariantTypeList != valueList.TypeId()) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteInvalidTypeIdList) ) ); + User::Leave(KErrArgument); + } + contactIdList = valueList.AsList(); + + //get the contact id count in the list. + TInt idCount = contactIdList->Count(); + //create the array of contact ids from the liw list. + RPointerArray contactIdArray; + for(TInt index = 0; index < idCount; index++) + { + contactIdList->AtL(index, valueId); + if(EVariantTypeDesC !=valueId.TypeId()) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KDeleteInvalidIdType) ) ); + User::Leave(KErrArgument); + } + + TPtrC cntidptr = valueId.AsDes(); + HBufC8* cntid = ContactIDUTFToStreamL(cntidptr); + CleanupStack :: PushL(cntid); + contactIdArray.AppendL(cntid); + CleanupStack :: Pop(cntid); + + } + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + + CleanupStack :: PushL(contactCallback); + //set the basic params of callback object. + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //invoke the main method of contactservice + //to delete the list + //contacts/groups. + iContactService->DeleteL(contactCallback, + aTransId, + contactIdArray, + dbUri); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + iContactService->DeleteL(contactIdArray, + dbUri); + } + + }//if pMap + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KDeleteDataListMissing))); + User::Leave(KMissingArg); + } + CleanupStack::Pop(&valueId); + valueId.Reset(); + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueList); + valueList.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KDeleteDataMapMissing))); + User::Leave(KMissingArg); + } + contentTypeVar.Reset(); + }//if ContentType == KContact or KGroup + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KDeleteInvalidContentType))); + User::Leave(KErrArgument); + } + } + +/* +----------------------------------------------------------------------------- + CContactInterface::OrganiseGroupCommandL(const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + Description : This function parses the input param list + : and calls the Organise API + Return values : TInt +----------------------------------------------------------------------------- +*/ +void CContactInterface::OrganiseGroupCommandL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + MLiwNotifyCallback* aCallback, + TUint aCmdOptions, + TInt aTransId) + { + TInt position = 0; + const TLiwGenericParam* paramOrganiseData = NULL; + const TLiwGenericParam* paramOperationType = NULL; + const TLiwGenericParam* paramContentType = NULL; + + //get the content type and Organise data. + paramContentType = aInParamList.FindFirst( position, KType ); + if(!paramContentType) + { + if(aInParamList.Count()<3) + { + + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseLessArguments) ) ); + User::Leave(KMissingArg); + } + + + paramContentType = &aInParamList[0] ; + if(!paramContentType || paramContentType->Name().Compare(KNullDesC8) != 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseContentTypeMissing) ) ); + User::Leave(KMissingArg); + } + } + + position = 0; + //Get the orgainse data, the value of which is a Map + paramOrganiseData = aInParamList.FindFirst( position, KData ); + if(!paramOrganiseData) + { + if(aInParamList.Count()>2) + paramOrganiseData = &aInParamList[1] ; + if(!paramOrganiseData || paramOrganiseData->Name().Compare(KNullDesC8) != 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseDataMissing) ) ); + User::Leave(KMissingArg); + } + } + + position = 0; + //Get the operation type, the value of which is a Map + paramOperationType = aInParamList.FindFirst( position, KOperationType ); + if(!paramOperationType) + { + if(aInParamList.Count() == 3) + paramOperationType = &aInParamList[2] ; + if(!paramOperationType || paramOperationType->Name().Compare(KNullDesC8) != 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseOperationTypeMissing) ) ); + User::Leave(KMissingArg); + } + } + + //get the content type.. + TLiwVariant contentTypeVar = paramContentType->Value(); + + if(EVariantTypeDesC !=contentTypeVar.TypeId()) + { + contentTypeVar.Reset(); + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseWrongContentType) ) ); + + User::Leave(KErrArgument); + } + + //if content type is " Groups", then.... + if( contentTypeVar.AsDes() == KGroup) + { + //get the pointer to map in the organise data. + const CLiwMap* pMap = paramOrganiseData->Value().AsMap(); + if( pMap ) + { + TLiwVariant valueGroupid; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueGroupid) ); + + TLiwVariant valueList; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueList) ); + + TLiwVariant valueUri; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueUri) ); + + TPtrC dbUri(VPbkContactStoreUris::DefaultCntDbUri()); + TBool associateType = EFalse; + HBufC8* groupId = NULL; + + if(EVariantTypeDesC != paramOperationType->Value().TypeId() ) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseOperationTypeWrong) ) ); + User::Leave(KErrArgument); + } + + if(paramOperationType->Value().AsDes().Compare(KAssociate)==0) + { + associateType = ETrue; + } + else if(paramOperationType->Value().AsDes().Compare(KDissociate)==0) + { + associateType = EFalse; + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseDataInvalidOpType))); + User::Leave(KErrArgument); + } + + const CLiwList* contactIdList = NULL; + //get the values for dburi, groupid, associatetype and id list. + if( EFalse != pMap->FindL(KDBUri,valueUri)) + { + if(valueUri.AsDes().CompareF(KNullDesC)!=0) + { + dbUri.Set(valueUri.AsDes()); + } + } + + if(EFalse != pMap->FindL(KGroupId,valueGroupid)) + { + if(EVariantTypeDesC != valueGroupid.TypeId()) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseWrongGrpIdType) ) ); + + User::Leave(KErrArgument); + } + TPtrC grpid = valueGroupid.AsDes(); + groupId = ContactIDUTFToStreamL(grpid); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseGrpIdMissing))); + User::Leave(KMissingArg); + } + + if(EFalse != pMap->FindL(KList,valueList)) + { + if(EVariantTypeList != valueList.TypeId()) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseWrongIdListType) ) ); + User::Leave(KErrArgument); + } + contactIdList = valueList.AsList(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseDataListMissing))); + User::Leave(KMissingArg); + } + + CleanupStack :: PushL(groupId); + //get the number of contact ids in the list. + TInt idCount = contactIdList->Count(); + if(idCount == 0) + { + aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant(KOrganiseEmptyIdList) ) ); + User::Leave(KErrArgument); + } + TLiwVariant valueId; + CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &valueId) ); + + //create the contact id array and append the ids from the list to this + //contactIdArray + RPointerArray contactIdArray; + CleanupClosePushL(contactIdArray); + + for(TInt index = 0; index < idCount; index++) + { + contactIdList->AtL(index, valueId); + if(EVariantTypeDesC != valueId.TypeId()) + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseWrongIdType))); + User::Leave(KErrArgument); + } + + TPtrC cntIdUnicode = valueId.AsDes(); + HBufC8* cntid = ContactIDUTFToStreamL(cntIdUnicode); + CleanupStack :: PushL(cntid); + contactIdArray.AppendL(cntid); + } + if(aCmdOptions == KLiwOptASyncronous) + { + CContactInterfaceCallback* contactCallback = + CContactInterfaceCallback::NewL(); + + CleanupStack :: PushL(contactCallback); + //Set the params of the contact callback + contactCallback->SetParams(aCallback, + aTransId, + &aInParamList); + //invoke the main method of the contactService + //to Associate/Disassocite + //list of contacts to/from the group. + iContactService->OrganiseGroupsL(contactCallback, + aTransId, + *groupId, + contactIdArray, + associateType, + dbUri); + + CleanupStack :: Pop(contactCallback); + } + else + { + //it is assumed that the call is synchronous + iContactService->OrganiseGroupsL(*groupId, + contactIdArray, + associateType, + dbUri); + } + //cleanup + CleanupStack::PopAndDestroy(contactIdArray.Count()); + CleanupStack::PopAndDestroy(); + CleanupStack::Pop(&valueId); + valueId.Reset(); + CleanupStack::PopAndDestroy(groupId); + CleanupStack::Pop(&valueUri); + valueUri.Reset(); + CleanupStack::Pop(&valueList); + valueList.Reset(); + CleanupStack::Pop(&valueGroupid); + valueGroupid.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseDataMapMissing))); + User::Leave(KMissingArg); + + } + contentTypeVar.Reset(); + } + else + { + aOutParamList.AppendL(TLiwGenericParam(KErrorMessage, + TLiwVariant(KOrganiseInvalidContentType))); + User::Leave(KMissingArg); + } + }