--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_contacts_vpbk/tsrc/dev/tcontactprovidertest/src/tcompluginblocks.cpp Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,2410 @@
+/*
+* Copyright (c) 2002 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: ?Description
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+
+#include <LiwServiceHandler.h>
+#include <LiwCommon.h>
+
+#include <VPbkEng.rsg>
+#include <e32def.h>
+
+#include <MVPbkContactFieldTextData.h>
+#include <MVPbkContactStoreList.h>
+#include <MVPbkContactOperationBase.h>
+#include <MVPbkContactLink.h>
+#include <CVPbkContactLinkArray.h>
+#include <MVPbkContactGroup.h>
+#include <CVPbkContactManager.h>
+#include <MVPbkContactStoreList.h>
+#include <MVPbkContactStore.h>
+#include <TVPbkContactStoreUriPtr.h>
+#include <CVPbkFieldTypeRefsList.h>
+#include <MVPbkContactFieldTextData.h>
+#include<f32file.h>
+
+#include "Tcomplugin.h"
+
+_LIT(LogFileName , "C:\\Notifications.txt") ;
+
+_LIT(KError,"Error code is");
+_LIT(KSuccess,"Successful");
+_LIT(KNewLine,"\n");
+_LIT(KServiceOpen,"Service handle created");
+_LIT(KServiceClose,"Service handle deleted");
+_LIT(KPhoneNumber,"9886431364");
+ _LIT(KGroup1,"Test1");
+
+_LIT8( KIDataSource,"IDataSource" );
+_LIT8( KExitCode, "ErrorCode" );
+_LIT8( KService, "Service.Contact" );
+
+//commands that can be performed on the contacts database.
+_LIT8( KCmdImport, "Import" );
+_LIT8( KCmdExport, "Export" );
+_LIT8( KCmdGetList, "GetList");
+_LIT8( KCmdAdd, "Add" );
+_LIT8( KCmdDelete, "Delete" );
+_LIT8( KCmdOrganiseGroups, "Organise" );
+
+_LIT8( KCancel, "Cancel" );
+
+// Constant for the appending Error code
+_LIT8( KErrorCode, "ErrorCode" );
+
+// Constant for the appending TransactionID
+_LIT8( KTransactionID, "TransactionID" );
+
+//Constant for appending Iterator
+_LIT8( KReturnValue, "ReturnValue");
+
+_LIT8(KSourceFileNameParam, "SourceFile");
+_LIT8(KDestFileNameParam, "DestinationFile");
+_LIT8(KGroupId,"id");
+
+
+_LIT8(KFieldLabel, "Label");
+_LIT8(KFieldValue, "Value");
+_LIT8(KFieldNext, "Next");
+_LIT8(KGroupLabel, "GroupLabel");
+_LIT8(KContents, "Contents");
+_LIT8(KContactId, "id");
+
+_LIT8(KList, "IdList");
+_LIT8(KContact, "Contact");
+_LIT8(KGroup, "Group");
+_LIT8(KDatabase, "Database");
+
+_LIT8(KDBUri, "DBUri");
+_LIT8(KSearchVal, "SearchVal");
+
+_LIT8(KType, "Type");
+_LIT8(KFilter, "Filter");
+_LIT8(KSort, "Sort");
+_LIT8(KOrder, "Order");
+_LIT8(KData, "Data");
+_LIT8(KOperationType, "OperationType");
+
+_LIT(KAssociate, "Associate");
+_LIT(KDissociate, "Disassociate");
+_LIT(KAscending, "Ascending");
+_LIT(KDescending, "Descending");
+
+//Field Keys
+_LIT8(KSync, "Sync");
+_LIT8(KLastName, "LastName");
+_LIT8(KLastNameReading, "LastNameReading");
+_LIT8(KFirstName, "FirstName");
+_LIT8(KFirstNameReading, "FirstNameReading");
+_LIT8(KPrefix, "Prefix");
+_LIT8(KSuffix, "Suffix");
+_LIT8(KSecondName, "SecondName");
+_LIT8(KLandPhoneHome, "LandPhoneHome");
+_LIT8(KMobilePhoneHome, "MobilePhoneHome");
+_LIT8(KVideoNumberHome, "VideoNumberHome");
+_LIT8(KFaxNumberHome, "FaxNumberHome");
+_LIT8(KVoipHome, "VoipHome");
+_LIT8(KEmailHome, "EmailHome");
+_LIT8(KURLHome, "URLHome");
+_LIT8(KAddrLabelHome, "AddrLabelHome");
+_LIT8(KAddrPOHome, "AddrPOHome");
+_LIT8(KAddrEXTHome, "AddrEXTHome");
+_LIT8(KAddrStreetHome, "AddrStreetHome");
+_LIT8(KAddrLocalHome, "AddrLocalHome");
+_LIT8(KAddrRegionHome, "AddrRegionHome");
+_LIT8(KAddrPostCodeHome, "AddrPostCodeHome");
+_LIT8(KAddrCountryHome, "AddrCountryHome");
+_LIT8(KJobTitle, "JobTitle");
+_LIT8(KCompanyName,"CompanyName");
+_LIT8(KLandPhoneWork, "LandPhoneWork");
+_LIT8(KMobilePhoneWork, "MobilePhoneWork");
+_LIT8(KVideoNumberWork, "VideoNumberWork");
+_LIT8(KFaxNumberWork, "FaxNumberWork");
+_LIT8(KVoipWork, "VoipWork");
+_LIT8(KEmailWork, "EmailWork");
+_LIT8(KURLWork, "URLWork");
+_LIT8(KAddrLabelWork, "AddrLabelWork");
+_LIT8(KAddrPOWork, "AddrPOWork");
+_LIT8(KAddrEXTWork, "AddrEXTWork");
+_LIT8(KAddrStreetWork, "AddrStreetWork");
+_LIT8(KAddrLocalWork, "AddrLocalWork");
+_LIT8(KAddrRegionWork, "AddrRegionWork");
+_LIT8(KAddrPostCodeWork, "AddrPostCodeWork");
+_LIT8(KAddrCountryWork, "AddrCountryWork");
+_LIT8(KLandPhoneGen, "LandPhoneGen");
+_LIT8(KMobilePhoneGen, "MobilePhoneGen");
+_LIT8(KVideoNumberGen, "VideoNumberGen");
+_LIT8(KFaxNumberGen, "FaxNumberGen");
+_LIT8(KVOIPGen, "VOIPGen");
+_LIT8(KPOC, "POC");
+_LIT8(KSWIS, "SWIS");
+_LIT8(KSIP, "SIP");
+_LIT8(KEmailGen, "EmailGen");
+_LIT8(KURLGen, "URLGen");
+_LIT8(KAddrLabelGen, "AddrLabelGen");
+_LIT8(KAddrPOGen, "AddrPOGen");
+_LIT8(KAddrExtGen, "AddrExtGen");
+_LIT8(KAddrStreetGen, "AddrStreetGen");
+_LIT8(KAddrLocalGen, "AddrLocalGen");
+_LIT8(KAddrRegionGen, "AddrRegionGen");
+_LIT8(KAddrPostCodeGen, "AddrPostCodeGen");
+_LIT8(KAddrCountryGen, "AddrCountryGen");
+_LIT8(KPageNumber, "PageNumber");
+_LIT8(KDTMFString, "DTMFString");
+_LIT8(KWVAddress, "WVAddress");
+_LIT8(KDate, "Date");
+_LIT8(KNote, "Note");
+_LIT8(KThumbNailPic, "ThumbNailPic");
+_LIT8(KRingtone, "Ringtone");
+_LIT8(KCallerObjImg, "CallerObjImg");
+_LIT8(KCallerObjText, "CallerObjText");
+_LIT8(KMiddleName, "MiddleName");
+_LIT8(KDepartment, "Department");
+_LIT8(KAsstName, "AsstName");
+_LIT8(KSpouse, "Spouse");
+_LIT8(KChildren, "Children");
+_LIT8(KAsstPhone, "AsstPhone");
+_LIT8(KCarPhone, "CarPhone");
+_LIT8(KAnniversary, "Anniversary");
+_LIT8(KSyncClass, "SyncClass");
+_LIT8(KLOCPrivacy, "LOCPrivacy");
+_LIT8(KGenLabel, "GenLabel");
+
+
+//----------------------------------------------------------------------------
+// CTestProvider :: Delete()
+//----------------------------------------------------------------------------
+void CTestProvider::Delete()
+ {
+ iIface->Close();
+ iCriteriaArray.Close();
+ delete iServiceHandler;
+ delete iInparams;
+ delete iOutparams;
+ delete iCriteria;
+ delete inList;
+ delete outList;
+ iIdArrayList.ResetAndDestroy();
+ delete iCntID;
+ }
+
+// -----------------------------------------------------------------------------
+// CTestProvider::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CTestProvider::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+
+ ENTRY("GetContactALL" , CTestProvider :: GetContactALL),
+ ENTRY("GetContactSearch" , CTestProvider :: GetContactSearch),
+ ENTRY("GetGroup" , CTestProvider :: GetGroup),
+ ENTRY("GetDatabase" , CTestProvider :: GetDatabase),
+ ENTRY("AddContact" , CTestProvider :: AddContact),
+ ENTRY("DeleteContact" , CTestProvider :: DeleteContact),
+ ENTRY("AddGroup" , CTestProvider :: AddGroup),
+ ENTRY("OrganiseAdd" , CTestProvider :: OrganiseAdd),
+ ENTRY("OrganiseDelete" , CTestProvider:: OrganiseDelete),
+ ENTRY("Export" , CTestProvider:: ExportL),
+ ENTRY("Import" , CTestProvider:: ImportL),
+ ENTRY("ModifyContact" , CTestProvider:: ModifyContact),
+ ENTRY("ModifyGroup" , CTestProvider:: ModifyGroup),
+ ENTRY("GetContactALLPosBased" , CTestProvider:: GetContactALLPosBased),
+ ENTRY("GetContactSearchPosBased" , CTestProvider:: GetContactSearchPosBased),
+ ENTRY("GetGroupPosBased" , CTestProvider:: GetGroupPosBased),
+ ENTRY("GetDatabasePosBased" , CTestProvider:: GetDatabasePosBased),
+ ENTRY("AddContactPosBased" , CTestProvider:: AddContactPosBased),
+ ENTRY("AddGroupPosBased" , CTestProvider:: AddGroupPosBased),
+ ENTRY("DeleteContactPosBased" , CTestProvider:: DeleteContactPosBased),
+ ENTRY("OrganiseAddPosBased" , CTestProvider :: OrganiseAddPosBased ),
+ ENTRY("OrganiseDeletePosbased" , CTestProvider :: OrganiseDeletePosbased),
+ ENTRY("ModifyContactPosBased" , CTestProvider :: ModifyContactPosBased),
+ ENTRY("ModifyGroupPosBased" , CTestProvider :: ModifyGroupPosBased),
+ ENTRY("ExportPosBased" , CTestProvider :: ExportPosBased),
+ ENTRY("ImportPosBased" , CTestProvider :: ImportPosBased),
+ ENTRY("CancelGetList" , CTestProvider :: CancelGetList),
+ ENTRY("CancelAddContact" , CTestProvider :: CancelAddContact),
+ ENTRY("CancelOrganiseAdd" , CTestProvider :: CancelOrganiseAdd),
+ ENTRY("CancelDeleteContact" , CTestProvider :: CancelDeleteContact),
+ ENTRY("CancelExport" , CTestProvider :: CancelExportL),
+ ENTRY("CancelImport" , CTestProvider :: CancelImportL)
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+TInt CTestProvider :: HandleNotifyL(TInt aCmdId,
+ TInt aEventId,
+ CLiwGenericParamList& aEventParamList,
+ const CLiwGenericParamList& aInParamList)
+
+ {
+
+ if (iCancelled != 1)
+ {
+ CActiveScheduler::Stop();
+ iCancelled = 0;
+ }
+
+ TInt pos = 0;
+ const TLiwGenericParam* param;
+
+ param = aEventParamList.FindFirst( pos, KExitCode );
+
+ TLiwVariant err = param->Value();
+
+ TInt code = err.AsTInt32();
+
+ if(iCase == EModifyContactComplete)
+ {
+ //call the get list once again to check whether the contact is modified
+ CStifItemParser* stiff;
+ iCase = EModifyContactVerify;
+ //this time call the getlist with the contact id to get only the modified contact
+ GetContactALL(*stiff);
+ }
+ else if(iCase == EGetAllContacts ||iCase == EDeleteContact
+ || iCase == EOrganizeAddcntid || iCase == EVerifyImport
+ || iCase == EModifyContact || iCase == EModifyContactVerify)
+ {
+
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else
+ {
+ pos = 0;
+ TBool tResult = EFalse;
+ TBool bResult = EFalse;
+ TBool findResult = EFalse;
+ TBuf<255> firstName;
+ TLiwVariant cntId;
+ TLiwVariant mapfield;
+ TLiwVariant firstname;
+ TLiwVariant entry;
+ const CLiwMap* map = NULL;
+ const CLiwMap* mapField = NULL;
+
+ param = aEventParamList.FindFirst(pos, KReturnValue);
+ TLiwVariant iterator = param->Value();
+ CLiwIterable* iter = iterator.AsIterable();
+ while(iter->NextL(entry))
+ {
+ map = entry.AsMap();
+ TInt count1 = map->Count();
+ map->FindL(KContactId, cntId);
+ TPtrC ptr = cntId.AsDes();
+ if(iCase == EDeleteContact)
+ {
+ *iCntID = ptr;
+ break;
+ }
+ if(iCase == EOrganizeAddcntid)
+ {
+ TDesC* ptrtoCntId;
+ TInt count = iIdArrayList.Count();
+ for(TInt i = 0; i<count ; i++)
+ {
+ ptrtoCntId = iIdArrayList[i];
+ if( *ptrtoCntId == ptr )
+ {
+ findResult = ETrue;
+ break;
+ }
+ }
+ if(findResult)
+ {
+ findResult = EFalse;
+ continue;
+ }
+ else
+ {
+ *iCntID = ptr;
+ break;
+ }
+ }
+ if(map->FindL(KFirstName,mapfield))
+ mapField = mapfield.AsMap();
+
+ TInt count = mapField->Count();
+ mapField->FindL(KFieldValue,firstname);
+ firstName = firstname.AsDes();
+ if(iCase == EModifyContact )
+ {
+ if((firstName.CompareF(_L("Arnold")) == 0))
+ {
+ *iCntID=ptr;
+ break;
+ }
+ else
+ {
+ continue;
+ }
+ }
+ if(iCase == EModifyContactVerify )
+ {
+ if((firstName.CompareF(_L("Modified Arnold")) == 0))
+ {
+ iResult = KErrNone;
+ break;
+ }
+ else
+ {
+ continue;
+ }
+ }
+ if(iCase == EVerifyImport )
+ {
+ if((firstName.CompareF(_L("Monica Bellucci")) == 0) || (firstName.CompareF(_L("Kate Winslet")) == 0))
+ {
+ iResult = KErrNone;
+ break;
+ }
+ else
+ {
+ continue;
+ }
+ }
+ if(firstName.CompareF(_L("Johnny")) == 0)
+ {
+ tResult = ETrue;
+ }
+ if(firstName.CompareF(_L("Arnold")) == 0)
+ {
+ bResult = ETrue;
+ }
+ }
+ if(tResult && bResult)
+ {
+ iResult = KErrNone;
+ }
+ if( iCase == EDeleteContact )
+ {
+ iCase = EDeleteVerify;
+ }
+
+ iterator.Reset();
+
+ }
+
+ }
+ else if(iCase == EGetContactSearch)
+ {
+ pos = 0;
+ TBuf<255> firstName;
+ TLiwVariant cntId;
+ TLiwVariant mapfield;
+ TLiwVariant firstname;
+ TLiwVariant entry;
+ const CLiwMap* map = NULL;
+ const CLiwMap* mapField = NULL;
+
+ param = aEventParamList.FindFirst(pos, KReturnValue);
+ TLiwVariant iterator = param->Value();
+ CLiwIterable* iter = iterator.AsIterable();
+ while(1)
+ {
+ if(iter->NextL(entry))
+ {
+ map = entry.AsMap();
+ TInt count1 = map->Count();
+ map->FindL(KContactId, cntId);
+ TPtrC8 ptr = cntId.AsData();
+ if(map->FindL(KFirstName,mapfield))
+ mapField = mapfield.AsMap();
+
+ TInt count = mapField->Count();
+ firstname.Reset();
+ mapField->FindL(KFieldValue,firstname);
+ firstName = firstname.AsDes();
+ if(firstName.CompareF(_L("Johnny")) == 0)
+ {
+ iResult = KErrNone;
+ }
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ }
+ else if(iCase == EDeleteVerify)
+ {
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else if(aEventId == KLiwEventCompleted && code == KErrNone)//KLiwEventCompleted
+ {
+ iResult = KErrNone;
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+ else if(iCase == EGetGroup || iCase == EVerifyGroupAdd || iCase == EVerifyOrganizeDelete)
+ {
+ pos = 0;
+
+ TBuf<255> groupName;
+ TLiwVariant cntId;
+ TLiwVariant groupLabel;
+ TLiwVariant contents;
+ TLiwVariant entry;
+ const CLiwMap* map = NULL;
+ const CLiwList* list =NULL;
+
+ param = aEventParamList.FindFirst(pos, KReturnValue);
+ TLiwVariant iterator = param->Value();
+ CLiwIterable* iter = iterator.AsIterable();
+ while(iter->NextL(entry))
+ {
+ map = entry.AsMap();
+ TInt count1 = map->Count();
+
+ map->FindL(KGroupId, cntId);
+ TPtrC ptr = cntId.AsDes();
+ if(map->FindL(KGroupLabel,groupLabel))
+ {
+ groupName = groupLabel.AsDes();
+ iGrpID.Set(ptr);
+ }
+ if(groupName == _L("Test"))
+ {
+ if(map->FindL(KContents,contents))
+ {
+ iResult = KErrNone;
+ list = contents.AsList();
+ TInt count = list->Count();
+ for(TInt i=0; i<count ; i++)
+ {
+ TLiwVariant cntId;
+ list->AtL(i, cntId) ;
+ TPtrC cntid = cntId.AsDes() ;
+ HBufC* cnt = HBufC::NewL(cntid.Length());
+ *cnt = cntid;
+ iIdArrayList.AppendL(cnt);
+ }
+
+ }
+ if(iCase == EVerifyGroupAdd)
+ {
+ TInt count = iIdArrayList.Count();
+ for(TInt i = 0; i<count; i++)
+ {
+ if(*iCntID == *(iIdArrayList[i]))
+ {
+ iResult = KErrNone;
+ break;
+ }
+ }
+ }
+ if(iCase == EVerifyOrganizeDelete)
+ {
+ iResult = KErrNone;
+ TInt count = iIdArrayList.Count();
+ for(TInt i = 0; i<count; i++)
+ {
+ if(*iCntID == *(iIdArrayList[i]))
+ {
+ iResult = KErrGeneral;
+ break;
+ }
+ }
+ }
+ break;
+ }
+
+ }
+
+
+ }
+ else if(iCase == EAddGroup )
+ {
+ if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iResult = KErrNone;
+ }
+ }
+ else if(iCase == EOrganizeAdd )
+ {
+
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iCase = EVerifyGroupAdd;
+ CStifItemParser* stiff;
+ iIdArrayList.ResetAndDestroy();
+ GetGroup(*stiff);
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+ else if(iCase == EExportVcard )
+ {
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iResult = KErrNone;
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+
+ else if(iCase == EImportVcard)
+ {
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iCase = EVerifyImport;
+ CStifItemParser* stiff;
+ GetContactALL(*stiff);
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+ else if( iCase == EOrganizeDelete )
+ {
+ if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iCase = EVerifyOrganizeDelete;
+ CStifItemParser* stiff;
+ iIdArrayList.ResetAndDestroy();
+ GetGroup(*stiff);
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+ else if( iCase == EAddContact )
+ {
+ if (aEventId == KLiwEventCanceled)
+ {
+ iResult = KErrNone;
+ }
+ else if(aEventId == KLiwEventCompleted && code == KErrNone )
+ {
+ iResult = KErrNone;
+ }
+ else
+ {
+ iResult = code;
+ }
+ }
+ }
+
+void CTestProvider::LoadService()
+ {
+ TInt pos = 0;
+ iCntID = HBufC::NewL(255);
+ inList = CLiwGenericParamList::NewL();
+ outList = CLiwGenericParamList::NewL();
+
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ iInparams = &(iServiceHandler->InParamListL());
+ iOutparams = &(iServiceHandler->OutParamListL());
+
+ iCriteria = CLiwCriteriaItem::NewL( 1, KIDataSource, KService );
+ iCriteria->SetServiceClass(TUid::Uid( KLiwClassBase ));
+
+ iCriteriaArray.AppendL( iCriteria );
+ iServiceHandler->AttachL( iCriteriaArray );
+
+ iServiceHandler->ExecuteServiceCmdL( *iCriteria, *iInparams, *iOutparams );
+
+ iOutparams->FindFirst( pos, KIDataSource );
+ if(pos != KErrNotFound)
+ {
+ //LogMessage(_L8("Service Loaded\n"));
+ iIface = ( *iOutparams )[pos].Value().AsInterface();
+ }
+ else
+ {
+ //LogMessage(_L8("Service Not found\n"));
+ }
+ if( iInparams )
+ {
+ iInparams->Reset();
+ iInparams = NULL;
+ }
+ if( iOutparams )
+ {
+ iOutparams->Reset();
+ iOutparams = NULL; }
+ if( iCriteria )
+ {
+ delete iCriteria;
+ iCriteria = NULL;
+ }
+ }
+
+
+
+void CTestProvider::HandleError( const TInt& aError,TInt /*aTransId*/ )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In Handle Error\n");
+ iLog->Log(KFunc);
+ iErr = aError;
+ TBuf<5> buf;
+ buf.Num(aError);
+ iLog->Log(KError);
+ iLog->Log(buf);
+ iLog->Log(KNewLine);
+ }
+
+void CTestProvider::HandleRetrieveContact( MVPbkStoreContact* /*aStoreContact*/, TInt /*aTransId*/ )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In Handle Retrieve Contact\n");
+ iLog->Log(KFunc);
+ }
+
+void CTestProvider::ContactOperationCompleted(TContactOpResult aResult)
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In ContactOperationCompleted \n");
+ iLog->Log(KFunc);
+ TBuf<5> buf;
+ buf.Num(aResult.iOpCode);
+ iLog->Log(KSuccess);
+ iLog->Log(buf);
+ iLog->Log(KNewLine);
+ }
+
+void CTestProvider::ContactOperationFailed
+ (TContactOp /*aOpCode*/, TInt aErrorCode, TBool /*aErrorNotified*/)
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In ContactOperationFailed \n");
+ iLog->Log(KFunc);
+ TBuf<5> buf;
+ buf.Num(aErrorCode);
+ iLog->Log(KError);
+ iLog->Log(buf);
+ iLog->Log(KNewLine);
+ }
+
+void CTestProvider::FindCompleteL( MVPbkContactLinkArray* aResults )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In FindCompleteL \n");
+ iLog->Log(KFunc);
+// iFindResults = aResults;
+ delete iFindResults;
+ iFindResults = aResults;
+ iLog->Log(KSuccess);
+ }
+void CTestProvider::FindFailed( TInt aError )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In FindFailed \n");
+ iLog->Log(KFunc);
+ iErr = aError;
+ TBuf<5> buf;
+ buf.Num(aError);
+ iLog->Log(KError);
+ iLog->Log(buf);
+ iLog->Log(KNewLine);
+ }
+
+void CTestProvider::VPbkSingleContactOperationComplete(
+ MVPbkContactOperationBase& aOperation,
+ MVPbkStoreContact* aContact )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In VPbkSingleContactOperationComplete \n");
+ iLog->Log(KFunc);
+ iLog->Log(KSuccess);
+ }
+
+
+void CTestProvider::VPbkSingleContactOperationFailed(
+ MVPbkContactOperationBase& aOperation,
+ TInt aError )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In VPbkSingleContactOperationFailed \n");
+ iLog->Log(KFunc);
+ TBuf<5> buf;
+ buf.Num(aError);
+ iLog->Log(KError);
+ iLog->Log(buf);
+ iLog->Log(KNewLine);
+ }
+
+void CTestProvider::StepComplete(
+ MVPbkContactOperationBase& /*aOperation*/,
+ TInt /*aStepSize*/ )
+ {
+ _LIT(KFunc,"In StepComplete \n");
+ iLog->Log(KFunc);
+ iLog->Log(KSuccess);
+ iLog->Log(KNewLine);
+ }
+
+TBool CTestProvider::StepFailed(
+ MVPbkContactOperationBase& /*aOperation*/,
+ TInt /*aStepSize*/, TInt /*aError*/ )
+ {
+ _LIT(KFunc,"In StepFailed \n");
+ iLog->Log(KFunc);
+ return EFalse;
+ }
+
+void CTestProvider::OperationComplete(
+ MVPbkContactOperationBase& /*aOperation*/ )
+ {
+ CActiveScheduler::Stop();
+ _LIT(KFunc,"In OperationComplete \n");
+ iLog->Log(KFunc);
+ iErr = KErrNone;
+ iLog->Log(KSuccess);
+ iLog->Log(KNewLine);
+ }
+
+
+void CTestProvider::AddOneContactL(const TDesC& aName)
+ {
+ // Print to UI
+ _LIT( KContactsTest, "ContactsUT" );
+ _LIT( KExample, "In AddOneContactL" );
+ TestModuleIf().Printf( 0, KContactsTest, KExample );
+ // Print to log file
+ iLog->Log( KExample );
+
+ //__UHEAP_MARK;
+ CVPbkFieldTypeRefsList* fieldTypeRefList = CVPbkFieldTypeRefsList::NewL();
+ CleanupStack::PushL(fieldTypeRefList);
+
+ fieldTypeRefList->AppendL(
+ *iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_FIRSTNAME ) );
+ fieldTypeRefList->AppendL(
+ *iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_MOBILEPHONEGEN ) );
+
+ // Create first contact
+ iStoreContact = iStore->CreateNewContactLC();
+
+ // Create contact field for contact
+ MVPbkStoreContactField* field = iStoreContact->CreateFieldLC( fieldTypeRefList->FieldTypeAt( 0 ) );
+ // Set contact field data
+ (MVPbkContactFieldTextData::Cast(field->FieldData())).SetTextL( aName );
+ // Add the contact field to contact
+ iStoreContact->AddFieldL( field );
+ CleanupStack::Pop(); // field
+
+ // Create contact field for contact
+ field = iStoreContact->CreateFieldLC( fieldTypeRefList->FieldTypeAt( 1 ) );
+ // Set contact field data
+ (MVPbkContactFieldTextData::Cast(field->FieldData())).SetTextL( KPhoneNumber );
+ // Add the contact field to contact
+ iStoreContact->AddFieldL( field );
+ CleanupStack::Pop(); // field
+
+ // Commit the new created contact to contact store
+ iStoreContact->CommitL( *this );
+ CActiveScheduler::Start();
+ CleanupStack::PopAndDestroy(); // iStoreContact
+ CleanupStack::PopAndDestroy(fieldTypeRefList);
+ //__UHEAP_MARKEND;
+
+ }
+
+void CTestProvider::AddOneGroupL(const TDesC& aName)
+ {
+ // Print to UI
+ _LIT( KContactsTest, "ContactsUT" );
+ _LIT( KExample, "In AddOneGroupL" );
+ TestModuleIf().Printf( 0, KContactsTest, KExample );
+ // Print to log file
+ iLog->Log( KExample );
+
+// __UHEAP_MARK;
+ iGroup = iStore->CreateNewContactGroupLC();
+ iGroup->SetGroupLabelL(aName);
+ iGroup->CommitL(*this);
+ CActiveScheduler::Start();
+ CleanupStack::Pop();
+ delete iGroup;
+ iGroup = NULL;
+// __UHEAP_MARKEND;
+ }
+
+TInt CTestProvider :: GetContactALL(CStifItemParser& /*aItem */)
+ {
+ AddOneContactL(_L("Arnold"));
+ AddOneContactL(_L("Johnny"));
+ CLiwDefaultMap* map = CLiwDefaultMap :: NewL();
+ if(inList && inList->Count())
+ inList->Reset();
+
+ //__UHEAP_MARK;
+ iResult = KErrGeneral;
+ if(iCase != EOrganizeAddcntid && iCase != EDeleteContact
+ && iCase != EVerifyImport && iCase != EModifyContact && iCase != EModifyContactVerify)
+ {
+ LoadService();
+ iCase = EGetAllContacts;
+ }
+
+ TInt pos = 0;
+ if(iCase == EModifyContactVerify)
+ {
+ map = CLiwDefaultMap :: NewL();
+ CleanupStack::PushL(map);
+ map->InsertL( KContactId,*iCntID );
+ const TLiwGenericParam paramGetlistData(KFilter, TLiwVariant(map));
+ inList->AppendL( paramGetlistData );
+ }
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ inList->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+
+ inList->Reset();
+ outList->Reset();
+ if(iCase == EModifyContactVerify)
+ {
+ CleanupStack::Pop(map);
+ map->DecRef();
+ }
+ //__UHEAP_MARKEND;
+ return iResult;
+ }
+
+
+TInt CTestProvider :: GetContactSearch(CStifItemParser& /*aItem */)
+ {
+ AddOneContactL(_L("Johnny"));
+ _LIT8(KFilter, "Filter");
+ _LIT8(KSearchVal, "SearchVal");
+ iResult = KErrGeneral;
+ LoadService();
+ TInt pos = 0;
+ iCase = EGetContactSearch;
+
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+
+ CLiwDefaultMap* map = CLiwDefaultMap :: NewL();
+ CleanupStack::PushL(map);
+ map->InsertL(KSearchVal,_L("j"));
+
+ const TLiwGenericParam paramData(KFilter, TLiwVariant(map));
+ inList ->AppendL( paramData );
+
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+
+ CleanupStack::Pop(map);
+ map->DecRef();
+ inList->Reset();
+ outList->Reset();
+ return iResult;
+ }
+
+
+TInt CTestProvider :: AddContact(CStifItemParser& /*aItem */)
+ {
+
+ iResult = KErrGeneral;
+ iCase = EAddContact;
+ LoadService();
+
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ CLiwDefaultMap* fieldMap = CLiwDefaultMap::NewL();
+ TInt pos = 0;
+ fieldMap->InsertL(KFieldLabel,TLiwVariant(_L("firstname")));
+
+ fieldMap->InsertL(KFieldValue,TLiwVariant(_L("Johnny")));
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+
+ pMap->InsertL(KContactId, TLiwVariant( _L("")));
+ pMap->InsertL(KFirstName, TLiwVariant(fieldMap));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ pMap->DecRef();
+ fieldMap->DecRef();
+ fieldMap->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+
+ return iResult;
+ }
+
+
+TInt CTestProvider :: OrganiseAdd(CStifItemParser& /*aItem */)
+ {
+ CStifItemParser* astiff = NULL;
+
+ //LoadService();
+ iResult = KErrGeneral;
+ iCase = EGetGroup;
+
+ GetGroup(*astiff);
+ iCase = EOrganizeAddcntid;
+
+ GetContactALL(*astiff);
+
+ iCase = EOrganizeAdd;
+
+
+ //LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultList* list = CLiwDefaultList::NewL();
+
+ list->AppendL(TLiwVariant(*iCntID));
+
+ TInt pos = 0;
+
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(iGrpID));
+ pMap->InsertL(KList, TLiwVariant(list));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+
+ const TLiwGenericParam paramOperationType(KOperationType, TLiwVariant( _L("Associate")));
+ const TLiwGenericParam paramOrganizeData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramOperationType );
+ inList ->AppendL( paramOrganizeData );
+
+ iIface->ExecuteCmdL(KCmdOrganiseGroups, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+
+ pMap->DecRef();
+ list->DecRef();
+ list->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+ return iResult;
+ }
+
+TInt CTestProvider :: OrganiseDelete(CStifItemParser& /*aItem */)
+ {
+ CStifItemParser* astiff = NULL ;
+
+ //LoadService();
+ iResult = KErrGeneral;
+ iCase = EGetGroup;
+
+ GetGroup(*astiff);
+ iCase = EOrganizeDelete;
+
+
+
+ //LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultList* list = CLiwDefaultList::NewL();
+ if(iIdArrayList.Count()>0)
+ *iCntID = *iIdArrayList[0];
+
+ list->AppendL(TLiwVariant(*iCntID));
+
+ TInt pos = 0;
+
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(iGrpID));
+ pMap->InsertL(KList, TLiwVariant(list));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+
+ const TLiwGenericParam paramOperationType(KOperationType, TLiwVariant(KDissociate));
+ const TLiwGenericParam paramOrganizeData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramOperationType );
+ inList ->AppendL( paramOrganizeData );
+
+ iIface->ExecuteCmdL(KCmdOrganiseGroups, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+ }
+
+
+TInt CTestProvider :: ModifyContact(CStifItemParser& aItem )
+ {
+ /**The testing logic goes this way first load the contact service.
+ *Then,get one contact id by using getlist api, this call GetContactALL(aItem); does that.
+ *change the first name and add it again(do operatoin for edit).
+ *call the getlist api using the same contact id this time.
+ *check for the changed first name.
+ */
+ //load the service
+ LoadService();
+ iCase = EModifyContact;
+ //get the contact to be modified the contact is retrieved in the callback HandleNotifyL
+ GetContactALL(aItem);
+ //get the contact to be modified the contact is retrieved in the callback HandleNotifyL
+ iResult = KErrGeneral;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ CLiwDefaultMap* fieldMap = CLiwDefaultMap::NewL();
+ TInt pos = 0;
+ fieldMap->InsertL(KFieldLabel,TLiwVariant(_L("firstname")));
+
+ fieldMap->InsertL(KFieldValue,TLiwVariant(_L("Modified Arnold")));
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("")));
+
+
+ pMap->InsertL(KContactId, TLiwVariant(iCntID));
+ pMap->InsertL(KFirstName, TLiwVariant(fieldMap));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+ //change the case to verify the operation.
+ iCase = EModifyContactComplete;
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ pMap->DecRef();
+ fieldMap->DecRef();
+ fieldMap->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+
+ return iResult;
+ }
+
+
+
+TInt CTestProvider :: GetGroup(CStifItemParser & /*aItem */)
+ {
+ AddOneGroupL(_L("Test"));
+ iResult = KErrGeneral;
+ iIdArrayList.ResetAndDestroy();
+ if(iCase != EVerifyGroupAdd && iCase != EVerifyOrganizeDelete)
+ {
+ LoadService();
+ iCase = EGetGroup;
+ }
+
+ TInt pos = 0;
+ inList->Reset();
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ return iResult;
+ }
+
+
+TInt CTestProvider :: GetDatabase(CStifItemParser& /*aItem*/)
+ {
+ iResult = KErrGeneral;
+ LoadService();
+ TInt pos = 0;
+ iCase = EGetDatabase;
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Database")));
+ inList ->AppendL( paramContentType );
+
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ pos = 0;
+ TLiwVariant dbname;
+ TLiwVariant entry;
+ const CLiwMap* map = NULL;
+
+ param = outList->FindFirst(pos, KReturnValue);
+ TLiwVariant iterator = param->Value();
+ CLiwIterable* iter = iterator.AsIterable();
+
+ while(iter->NextL(entry))
+ {
+ map = entry.AsMap();
+
+ map->FindL(KDBUri, dbname);
+ TPtrC dbNmae = dbname.AsDes();
+ if(dbNmae == _L("cntdb://c:contacts.cdb"))
+ {
+ iResult = KErrNone;
+ break;
+ }
+
+ }
+
+
+ inList->Reset();
+ outList->Reset();
+
+ return iResult ;
+ }
+
+TInt CTestProvider :: ModifyGroup(CStifItemParser& /*aItem*/)
+ {
+ }
+
+TInt CTestProvider :: ExportL( CStifItemParser& aItem )
+ {
+ iCase = EDeleteContact;
+
+ iResult = KErrGeneral;
+ LoadService();
+ GetContactALL(aItem);
+
+ iCase = EExportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt ferr = iFileHandle.Open(iFSession,_L("c:\\vcardExport.vcf"),EFileRead | EFileWrite );
+
+ if( KErrNone == ferr )
+ {
+ iFileHandle.Close();
+
+ iFSession.Delete(_L("c:\\vcardExport.vcf"));
+ }
+ TInt pos = 0;
+ TBuf<255> cntIdunicode;
+ cntIdunicode.Copy(*iCntID);
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KContactId, TLiwVariant(cntIdunicode));
+
+ pMap->InsertL(KDestFileNameParam, TLiwVariant( _L("c:\\vcardExport.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdExport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+
+
+ }
+TInt CTestProvider :: ImportL(CStifItemParser& /*aItem*/)
+ {
+ iResult = KErrGeneral;
+ LoadService();
+ iCase = EImportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+ pMap->InsertL(KSourceFileNameParam, TLiwVariant( _L("c:\\vcardimport.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdImport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+ }
+
+TInt CTestProvider :: DeleteContact(CStifItemParser& /*aItem*/)
+ {
+ iCase = EDeleteContact;
+ LoadService();
+ TInt pos = 0;
+ CLiwMap* mapContactId = CLiwDefaultMap::NewL();
+ //iCase = EGetAllContacts;
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ const TLiwGenericParam paramContent(KType, TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContent );
+ CLiwDefaultList* list = CLiwDefaultList :: NewL();
+ list->AppendL(TLiwVariant(*iCntID));
+ mapContactId->InsertL(KDBUri, TLiwVariant(_L("cntdb://c:contacts.cdb")));
+ mapContactId->InsertL(KList,TLiwVariant(list));
+ const TLiwGenericParam paramDeleteData(KData, TLiwVariant(mapContactId));
+ inList ->AppendL( paramDeleteData );
+ iIface->ExecuteCmdL(KCmdDelete, *inList, *outList, KLiwOptASyncronous, this);
+
+ pos = 0;
+ param = outList->FindFirst( pos, KExitCode );
+ err = param->Value();
+ code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ mapContactId->DecRef();
+ list->DecRef();
+ return iResult;
+ }
+
+/*
+ * This is a manual test case were the service was available when the
+ * request was made and then Lost the service (Contact to location servier lost
+ */
+
+
+TInt CTestProvider :: AddGroup(CStifItemParser& /*aItem*/)
+ {
+ LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ iCase = EAddGroup;
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(_L8("")));
+ pMap->InsertL(KGroupLabel, TLiwVariant(_L("Test")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ pMap->DecRef();
+ return iResult;
+ }
+
+
+/**
+ *Cancel test, to test cancel functionality
+ */
+TInt CTestProvider :: GetContactALLPosBased(CStifItemParser& /*aItem*/)
+ {
+ AddOneContactL(_L("Arnold"));
+ AddOneContactL(_L("Johnny"));
+ iResult = KErrGeneral;
+ if(iCase != EOrganizeAddcntid && iCase != EDeleteContact && iCase != EVerifyImport)
+ {
+ LoadService();
+ iCase = EGetAllContacts;
+ }
+
+ TInt pos = 0;
+
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+
+ return iResult;
+ }
+
+TInt CTestProvider :: GetContactSearchPosBased(CStifItemParser& /*aItem*/)
+ {
+ AddOneContactL(_L("Johnny"));
+ _LIT8(KFilter, "Filter");
+ _LIT8(KSearchVal, "SearchVal");
+ iResult = KErrGeneral;
+ LoadService();
+ TInt pos = 0;
+ iCase = EGetContactSearch;
+
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+
+ CLiwDefaultMap* map = CLiwDefaultMap :: NewL();
+ CleanupStack::PushL(map);
+ map->InsertL(KSearchVal,_L("j"));
+
+ const TLiwGenericParam paramData(_L8(""), TLiwVariant(map));
+ inList ->AppendL( paramData );
+ TInt count = inList->Count();
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ CleanupStack::Pop(map);
+ map->DecRef();
+ return iResult;
+ }
+/**
+ *Cancel test, to test cancel functionality
+ */
+TInt CTestProvider :: GetGroupPosBased(CStifItemParser& /*aItem*/)
+ {
+ AddOneGroupL(_L("Test"));
+ iResult = KErrGeneral;
+ if(iCase != EVerifyGroupAdd && iCase != EVerifyOrganizeDelete)
+ {
+ LoadService();
+ iCase = EGetGroup;
+ }
+
+ TInt pos = 0;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Group")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ return iResult;
+ }
+
+/**
+ *Cancel test, with wrong notification
+ */
+TInt CTestProvider :: GetDatabasePosBased(CStifItemParser& /*aItem*/)
+ {
+ iResult = KErrGeneral;
+ LoadService();
+ TInt pos = 0;
+ iCase = EGetDatabase;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Database")));
+ inList ->AppendL( paramContentType );
+
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ pos = 0;
+ TLiwVariant dbname;
+ TLiwVariant entry;
+ const CLiwMap* map = NULL;
+
+ param = outList->FindFirst(pos, KReturnValue);
+ TLiwVariant iterator = param->Value();
+ CLiwIterable* iter = iterator.AsIterable();
+
+ while(iter->NextL(entry))
+ {
+ map = entry.AsMap();
+
+ map->FindL(KDBUri, dbname);
+ TPtrC dbNmae = dbname.AsDes();
+ if(dbNmae == _L("cntdb://c:contacts.cdb"))
+ {
+ iResult = KErrNone;
+ break;
+ }
+
+ }
+
+ inList->Reset();
+ outList->Reset();
+
+ return iResult ;
+
+ }
+
+
+
+/**
+ *Cancel test, with wrong notification issues a Trace request and then calls for getlocation
+ * cancellation
+ */
+TInt CTestProvider :: AddContactPosBased(CStifItemParser& /*aItem*/)
+ {
+ iResult = KErrGeneral;
+ iCase = EAddContact;
+ LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultMap* fieldMap = CLiwDefaultMap::NewL();
+ TInt pos = 0;
+ fieldMap->InsertL(KFieldLabel,TLiwVariant(_L("firstname")));
+ fieldMap->InsertL(KFieldValue,TLiwVariant(_L("Arnold")));
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+ pMap->InsertL(KContactId, TLiwVariant( _L("")));
+ pMap->InsertL(KFirstName, TLiwVariant(fieldMap));
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(_L8(""), TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ fieldMap->DecRef();
+ return iResult;
+ }
+
+
+TInt CTestProvider :: AddGroupPosBased(CStifItemParser& /*aItem*/)
+ {
+ LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ iCase = EAddGroup;
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(_L8("")));
+ pMap->InsertL(KGroupLabel, TLiwVariant(_L("Test")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ pMap->DecRef();
+ return iResult;
+ }
+
+/**
+ *Cancel test, Normal cancel test for getlocation
+ */
+TInt CTestProvider :: DeleteContactPosBased(CStifItemParser& /*aItem*/)
+ {
+ iCase = EDeleteContact;
+ LoadService();
+ TInt pos = 0;
+ CLiwMap* mapContactId = CLiwDefaultMap::NewL();
+ //iCase = EGetAllContacts;
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ const TLiwGenericParam paramContent(_L8(""), TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContent );
+ CLiwDefaultList* list = CLiwDefaultList :: NewL();
+ list->AppendL(TLiwVariant(*iCntID));
+ mapContactId->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ mapContactId->InsertL(KList,TLiwVariant(list));
+ const TLiwGenericParam paramDeleteData(_L8(""), TLiwVariant(mapContactId));
+ inList ->AppendL( paramDeleteData );
+
+ iIface->ExecuteCmdL(KCmdDelete, *inList, *outList, KLiwOptASyncronous, this);
+
+ pos = 0;
+ param = outList->FindFirst( pos, KExitCode );
+ err = param->Value();
+ code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ mapContactId->DecRef();
+ inList->Reset();
+ outList->Reset();
+ list->DecRef();
+ return iResult;
+ }
+
+/**
+ * GetLocation Timeout
+ */
+TInt CTestProvider :: OrganiseAddPosBased(CStifItemParser& /*aItem*/)
+ {
+ AddOneContactL(_L("Arnold"));
+ AddOneContactL(_L("Johnny"));
+
+ AddOneGroupL(_L("Test"));
+
+ CStifItemParser* astiff = NULL ;
+
+ //LoadService();
+ iResult = KErrGeneral;
+ iCase = EGetGroup;
+
+ GetGroup(*astiff);
+ iCase = EOrganizeAddcntid;
+
+ GetContactALL(*astiff);
+
+ iCase = EOrganizeAdd;
+
+
+ //LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultList* list = CLiwDefaultList::NewL();
+
+ list->AppendL(TLiwVariant(*iCntID));
+
+ TInt pos = 0;
+
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(iGrpID));
+ pMap->InsertL(KList, TLiwVariant(list));
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Group")));
+
+ const TLiwGenericParam paramOperationType(_L8(""), TLiwVariant( _L("Associate")));
+ const TLiwGenericParam paramOrganizeData(_L8(""), TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramOrganizeData );
+ inList ->AppendL( paramOperationType );
+
+
+ iIface->ExecuteCmdL(KCmdOrganiseGroups, *inList, *outList, KLiwOptASyncronous, this);
+
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ pMap->DecRef();
+ list->DecRef();
+ list->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+ return iResult;
+ }
+
+/**
+ *Normal Trace cancell test.
+ */
+TInt CTestProvider :: OrganiseDeletePosbased(CStifItemParser& /*aItem*/)
+ {
+ AddOneGroupL(_L("Test"));
+ CStifItemParser* astiff = NULL ;
+
+ //LoadService();
+ iResult = KErrGeneral;
+ iCase = EGetGroup;
+
+ GetGroup(*astiff);
+ iCase = EOrganizeDelete;
+
+
+
+ //LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultList* list = CLiwDefaultList::NewL();
+ if(iIdArrayList.Count()>0)
+ *iCntID = *iIdArrayList[0];
+
+ list->AppendL(TLiwVariant(*iCntID));
+
+ TInt pos = 0;
+
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(iGrpID));
+ pMap->InsertL(KList, TLiwVariant(list));
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Group")));
+
+ const TLiwGenericParam paramOperationType(_L8(""), TLiwVariant(KDissociate));
+ const TLiwGenericParam paramOrganizeData(_L8(""), TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramOrganizeData );
+ inList ->AppendL( paramOperationType );
+
+
+ iIface->ExecuteCmdL(KCmdOrganiseGroups, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ list->DecRef();
+ return iResult;
+ }
+
+/**
+ *Math Operation Find distance : Position based parameter
+ */
+ TInt CTestProvider :: ModifyContactPosBased(CStifItemParser& /*aItem*/)
+ {
+
+ }
+/**
+ * Math operation BearingTo Test
+ */
+
+ TInt CTestProvider ::ModifyGroupPosBased(CStifItemParser& /*aItem*/)
+ {
+ }
+
+ TInt CTestProvider :: ExportPosBased(CStifItemParser& aItem)
+ {
+ AddOneContactL(_L("Arnold"));
+ AddOneContactL(_L("Johnny"));
+ iCase = EDeleteContact;
+
+ iResult = KErrGeneral;
+ LoadService();
+ GetContactALL(aItem);
+
+ TInt ferr = iFileHandle.Open(iFSession,_L("c:\\vcardExportposbased.vcf"),EFileRead | EFileWrite );
+
+ if( KErrNone == ferr )
+ {
+ iFileHandle.Close();
+
+ iFSession.Delete(_L("c:\\vcardExportposbased.vcf"));
+ }
+
+ iCase = EExportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KContactId, TLiwVariant(*iCntID));
+
+ pMap->InsertL(KDestFileNameParam, TLiwVariant( _L("c:\\vcardExportposbased.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdExport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+ }
+/**
+ * Math operation BearingTo Test
+ */
+
+ TInt CTestProvider ::ImportPosBased(CStifItemParser& /*aItem*/)
+ {
+ iIdArrayList.ResetAndDestroy();
+ iResult = KErrGeneral;
+ LoadService();
+ iCase = EImportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+ pMap->InsertL(KSourceFileNameParam, TLiwVariant( _L("c:\\vcardimport.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdImport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+
+
+ }
+
+
+
+TInt CTestProvider ::CancelGetList(CStifItemParser& /*aItem*/)
+ {
+ AddOneContactL(_L("Arnold"));
+ AddOneContactL(_L("Johnny"));
+ iResult = KErrGeneral;
+ if(iCase != EOrganizeAddcntid && iCase != EDeleteContact && iCase != EVerifyImport)
+ {
+ LoadService();
+ iCase = EGetAllContacts;
+ }
+
+ TInt pos = 0;
+
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(_L8(""), TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+
+
+ // const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ //TLiwVariant err = param->Value();
+ //TInt code = err.AsTInt32();
+
+ // if(code == SErrNone)
+
+ const TLiwGenericParam* param = outList->FindFirst(pos, KTransactionID);
+
+ inList->Reset();
+ outList->Reset();
+
+ if (param)
+ {
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+
+ // CActiveScheduler::Start();
+
+
+ }
+ inList->Reset();
+ outList->Reset();
+
+ return iResult;
+ }
+
+
+TInt CTestProvider ::CancelAddContact(CStifItemParser& /*aItem*/)
+ {
+// iResult = KErrNone;
+ iCase = EAddContact;
+ LoadService();
+
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ CLiwDefaultMap* fieldMap = CLiwDefaultMap::NewL();
+ TInt pos = 0;
+ fieldMap->InsertL(KFieldLabel,TLiwVariant(_L("firstname")));
+
+ fieldMap->InsertL(KFieldValue,TLiwVariant(_L("Johnny")));
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+
+ pMap->InsertL(KContactId, TLiwVariant( _L("")));
+ pMap->InsertL(KFirstName, TLiwVariant(fieldMap));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap)); ;
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdAdd, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ pos = 0;
+ param = outList->FindFirst(pos, KTransactionID);
+ if (param)
+ {
+ inList->Reset();
+ outList->Reset();
+
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+ }
+ else
+ {
+
+ }
+ }
+ pMap->DecRef();
+ fieldMap->DecRef();
+ fieldMap->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+
+ return iResult;
+ }
+
+
+
+ TInt CTestProvider :: CancelOrganiseAdd(CStifItemParser& /*aItem */)
+ {
+ CStifItemParser* astiff = NULL;
+
+ //LoadService();
+ iResult = KErrGeneral;
+ iCase = EGetGroup;
+
+ GetGroup(*astiff);
+ iCase = EOrganizeAddcntid;
+
+ GetContactALL(*astiff);
+
+ iCase = EOrganizeAdd;
+
+
+ //LoadService();
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+ CLiwDefaultList* list = CLiwDefaultList::NewL();
+
+ list->AppendL(TLiwVariant(*iCntID));
+
+ TInt pos = 0;
+
+ //pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KGroupId, TLiwVariant(iGrpID));
+ pMap->InsertL(KList, TLiwVariant(list));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Group")));
+
+ const TLiwGenericParam paramOperationType(KOperationType, TLiwVariant( _L("Associate")));
+ const TLiwGenericParam paramOrganizeData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramOperationType );
+ inList ->AppendL( paramOrganizeData );
+
+ iIface->ExecuteCmdL(KCmdOrganiseGroups, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ pos = 0;
+ param = outList->FindFirst(pos, KTransactionID);
+ if (param)
+ {
+ inList->Reset();
+ outList->Reset();
+
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+ }
+ else
+ {
+
+ }
+ }
+
+ pMap->DecRef();
+ list->DecRef();
+ list->DecRef();
+
+ inList->Reset();
+ outList->Reset();
+ return iResult;
+ }
+
+TInt CTestProvider :: CancelExportL( CStifItemParser& aItem )
+ {
+ iCase = EDeleteContact;
+
+ iResult = KErrGeneral;
+ LoadService();
+ GetContactALL(aItem);
+
+ iCase = EExportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt ferr = iFileHandle.Open(iFSession,_L("c:\\vcardExport.vcf"),EFileRead | EFileWrite );
+
+ if( KErrNone == ferr )
+ {
+ iFileHandle.Close();
+
+ iFSession.Delete(_L("c:\\vcardExport.vcf"));
+ }
+ TInt pos = 0;
+ TBuf<255> cntIdunicode;
+ cntIdunicode.Copy(*iCntID);
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+ pMap->InsertL(KContactId, TLiwVariant(cntIdunicode));
+
+ pMap->InsertL(KDestFileNameParam, TLiwVariant( _L("c:\\vcardExport.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdExport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ pos = 0;
+ param = outList->FindFirst(pos, KTransactionID);
+ if (param)
+ {
+ inList->Reset();
+ outList->Reset();
+
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+ }
+ else
+ {
+
+ }
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+
+
+ }
+
+TInt CTestProvider :: CancelImportL(CStifItemParser& /*aItem*/)
+ {
+ iResult = KErrGeneral;
+ LoadService();
+ iCase = EImportVcard;
+ CLiwDefaultMap* pMap = CLiwDefaultMap::NewL();
+
+ TInt pos = 0;
+
+ pMap->InsertL(KDBUri, TLiwVariant( _L("cntdb://c:contacts.cdb")));
+
+ pMap->InsertL(KSourceFileNameParam, TLiwVariant( _L("c:\\vcardimport.vcf")));
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ const TLiwGenericParam paramAddData(KData, TLiwVariant(pMap));
+
+ inList ->AppendL( paramContentType );
+ inList ->AppendL( paramAddData );
+
+ iIface->ExecuteCmdL(KCmdImport, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ pos = 0;
+ param = outList->FindFirst(pos, KTransactionID);
+ if (param)
+ {
+ inList->Reset();
+ outList->Reset();
+
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+ }
+ else
+ {
+
+ }
+ }
+ inList->Reset();
+ outList->Reset();
+ pMap->DecRef();
+ return iResult;
+ }
+
+
+
+
+TInt CTestProvider :: CancelDeleteContact(CStifItemParser& /*aItem*/)
+ {
+ iCase = EDeleteContact;
+ LoadService();
+ TInt pos = 0;
+ CLiwMap* mapContactId = CLiwDefaultMap::NewL();
+ //iCase = EGetAllContacts;
+ //const TLiwGenericParam paramGetListSortOrder;
+
+ const TLiwGenericParam paramContentType(KType, TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContentType );
+ iIface->ExecuteCmdL(KCmdGetList, *inList, *outList, KLiwOptASyncronous, this);
+
+ const TLiwGenericParam* param = outList->FindFirst( pos, KExitCode );
+ TLiwVariant err = param->Value();
+ TInt code = err.AsTInt32();
+
+ inList->Reset();
+ outList->Reset();
+
+ if(code == SErrNone)
+ {
+ CActiveScheduler::Start();
+ }
+ const TLiwGenericParam paramContent(KType, TLiwVariant( _L("Contact")));
+ inList ->AppendL( paramContent );
+ CLiwDefaultList* list = CLiwDefaultList :: NewL();
+ list->AppendL(TLiwVariant(*iCntID));
+ mapContactId->InsertL(KDBUri, TLiwVariant(_L("cntdb://c:contacts.cdb")));
+ mapContactId->InsertL(KList,TLiwVariant(list));
+ const TLiwGenericParam paramDeleteData(KData, TLiwVariant(mapContactId));
+ inList ->AppendL( paramDeleteData );
+ iIface->ExecuteCmdL(KCmdDelete, *inList, *outList, KLiwOptASyncronous, this);
+
+
+ pos = 0;
+
+ param = outList->FindFirst( pos, KExitCode );
+ err = param->Value();
+ code = err.AsTInt32();
+
+ if(code == SErrNone)
+ {
+ pos = 0;
+ param = outList->FindFirst(pos, KTransactionID);
+ if (param)
+ {
+ inList->Reset();
+ outList->Reset();
+
+ TInt32 transid = param->Value().AsTInt32();
+
+ TLiwGenericParam paramtransactionId(KTransactionID, TLiwVariant(transid));
+
+
+ inList->AppendL( paramtransactionId );
+
+ iCancelled = 1;
+ iIface->ExecuteCmdL(KCancel, *inList, *outList,KLiwOptCancel, this);
+
+ paramtransactionId.Reset();
+
+
+ inList->Reset();
+ outList->Reset();
+ }
+ else
+ {
+
+ }
+ }
+ inList->Reset();
+ outList->Reset();
+ mapContactId->DecRef();
+ list->DecRef();
+ return iResult;
+ }
+
+
+
+
+
+
+
+
+