LOCAL_C void CheckBasicPopulatedGroup()
{
test.Next(_L("Populate Basic Group"));
CntTest->CloseDatabase();
CntTest->DeleteDatabaseL();
CntTest->CreateDatabaseL();
TRAP_IGNORE(PopulateDatabaseL(KFamilySizeRecords,ETrue));
CContactItem* newGroup = CntTest->Db()->CreateContactGroupLC(_L("Family Group"));
TContactItemId groupId = newGroup->Id();
for(TInt ii=2;ii<12;ii++)
{
CntTest->Db()->AddContactToGroupL(ii,groupId);
}
CntTest->CloseDatabase();
CntTest->OpenDatabaseL();
//
CContactItem* familyGroup = CntTest->Db()->ReadContactLC(groupId);
CContactIdArray* memberArray = STATIC_CAST(CContactGroup*,familyGroup)->ItemsContainedLC();
test(memberArray->Count()==10);
//
CContactItem* familyMember = CntTest->Db()->ReadContactLC(2);
CContactIdArray* groups = STATIC_CAST(CContactCard*, familyMember)->GroupsJoinedLC();
test(groups->Count()==1);
TContactItemId memberShip = (*groups)[0];
test(memberShip==groupId);
CleanupStack::PopAndDestroy(5);
// newGroup familyGroup memberArray familyMember groups
}
void TestPhoneMatchingL(CContactDatabase& aDb)
{
test.Next(_L("Test phone match"));
CContactIdArray* array = aDb.MatchPhoneNumberL(KTelephoneNum,KMaxPhoneMatchLength);
test(array->Count() == 4);
delete array;
syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);
syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);
syncChecker->SetValidateWriteResponseL(KErrNone);
aDb.SetDbViewContactType(KUidContactICCEntry);
TContactItemId id = (*aDb.SortedItemsL())[0];
CContactItem* item = aDb.OpenContactLX(id);
CleanupStack::PushL(item);
CContactItemFieldSet& fieldset = item->CardFields();
const TInt pos = fieldset.Find(KUidContactFieldPhoneNumber);
CContactItemField& field = fieldset[pos];
CContactTextField* textfield = field.TextStorage();
textfield->SetTextL(KTelephoneNumModified);
aDb.CommitContactL(*item);
CleanupStack::PopAndDestroy(2); //item, lock record
CContactIdArray* array2 = aDb.MatchPhoneNumberL(KTelephoneNumModified,KMaxPhoneMatchLength);
test(array2->Count() == 1);
delete array2;
}
// Regression testcode for MAT-5B7JD4 "AddContactToGroupL()/RemoveContactFromGroupL() does not update
// object passed as argument"
//
LOCAL_C void GroupAddRemoveTestL()
{
test.Next(_L("Group addition/removal defect"));
CntTest->CloseDatabase();
CntTest->DeleteDatabaseL();
CContactDatabase* db=CntTest->CreateDatabaseL();
_LIT(KCntmodelGroup,"MyGroup");
CContactItem* group = db->CreateContactGroupLC(KCntmodelGroup);
TContactItemId groupId = group->Id();
TContactItemId itemId=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("C"));
CContactItem* item = CntTest->Db()->ReadContactLC(itemId);
CntTest->Db()->AddContactToGroupL(*item,*group);
// write change to database
const CContactIdArray* groupsJoined = STATIC_CAST(CContactItemPlusGroup*,item)->GroupsJoined();
test(groupsJoined->Find(groupId)==0);
const CContactIdArray* itemsContained = STATIC_CAST(CContactGroup*,group)->ItemsContained();
test(itemsContained->Find(itemId)==0);
CntTest->Db()->RemoveContactFromGroupL(*item,*group);
test(STATIC_CAST(CContactItemPlusGroup*,item)->GroupsJoined()->Find(groupId)!=0);
test(STATIC_CAST(CContactGroup*,group)->ItemsContained()->Find(itemId)!=0);
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(group);
}
/**
Test: opens contact item, and adds a custom uid to each field,
then checks if uid was stored correctly
*/
void CCustomLabelUid::TestCustomUidsL( const TContactItemId aCid )
{
//open contact
CContactItem *contactItem = NULL;
contactItem = iContactsDatabase->OpenContactLX(aCid,*iViewAll);
CleanupStack::PushL(contactItem);
CContactItemFieldSet *ContactFields = &(contactItem->CardFields());
//add an extra (custom) uid to each fieldtype of this contact
AddUIDsL(*ContactFields,TestConstants::KInitialUID);
//populate contact fields
SetContactFieldsL(*contactItem);
//update contact
iContactsDatabase->CommitContactL(*contactItem);
CleanupStack::PopAndDestroy(contactItem);
CleanupStack::Pop();//lock
contactItem = NULL;
//read contact item
contactItem = iContactsDatabase->ReadContactLC(aCid,*iViewAll);
ContactFields = &(contactItem->CardFields());
//check that contact field uids updated correctly
SINGLECOMPARE( CheckUIDsL(*ContactFields,TestConstants::KInitialUID), 0 ,0 );
//check that contact fields updated correctly
SINGLECOMPARE( CheckContactFieldsL(*contactItem), 0, 0 );
CleanupStack::PopAndDestroy(contactItem);
}
/**
Merging pure (minimal) contact with the template should be out of scope of the
Persistence Layer. The only reason to have this functions in the test interface
is that CContactItem::RestoreTemplateFieldsL() is not exported.
*/
void CLplTester::MergeContactWithTemplateL(CContactItem& aContact, const CContactItem& aTempl, const CContactItemViewDef& aView) const
{
if (aContact.TemplateRefId()!=KNullContactId && aContact.Type() != KUidContactCardTemplate)
{
aContact.RestoreTemplateFieldsL(iProps.SystemTemplateL().CardFields(), aTempl.CardFields(), aView);
}
}
/**
Deletes all the communication addresses for a particular contact item. Should be used when
deleting a contact item from the database altogether.
@param aItem The contact item whose communcation addresses are to be deleted.
*/
void CPplCommAddrTable::DeleteL(const CContactItem& aItem, TBool& aLowDiskErrorOccurred)
{
const TUid KType = aItem.Type();
if (KType != KUidContactCard && KType != KUidContactOwnCard && KType != KUidContactICCEntry && KType != KUidContactGroup)
{
return;
}
RSqlStatement stmnt;
CleanupClosePushL(stmnt);
stmnt.PrepareL(iDatabase, iAllForItemDeleteStmnt->SqlStringL() );
const TInt KContactIdParamIndex(KFirstIndex); // first and only parameter in query
User::LeaveIfError(stmnt.BindInt(KContactIdParamIndex, aItem.Id() ) );
TInt err = stmnt.Exec();
CleanupStack::PopAndDestroy(&stmnt);
if (err == KErrDiskFull)
{
aLowDiskErrorOccurred = ETrue;
}
else
{
User::LeaveIfError(err);
}
}
void CntThumbnailCreator::initializeThumbnailFieldL()
{
// Assume the golden template is not changed run-time and fetch it only
// when initializeThumbnailFieldL is called for the first time during the
// life-time of the CntThumbnailCreator object (requires the instance to
// live longer than one thumbnail create operation to be effective,
// otherwise we would end up opening contact database and reading the
// system template every time a thumbnail is stored for a contact).
if(!m_thumbnailFieldFromTemplate) {
CContactDatabase *contactDatabase = CContactDatabase::OpenL();
CleanupStack::PushL(contactDatabase);
CContactItem *goldenTemplate = contactDatabase->ReadContactLC(KGoldenTemplateId);
const CContactItemFieldSet& cardFields = goldenTemplate->CardFields();
// Check if thumbnail field type is KUidContactFieldPictureValue
TInt pictureFieldIndex = cardFields.Find(KUidContactFieldPicture, KUidContactFieldVCardMapPHOTO);
// Check if thumbnail field type is KUidContactFieldVCardMapJPEG
if(pictureFieldIndex == KErrNotFound) {
pictureFieldIndex = cardFields.Find(KUidContactFieldVCardMapJPEG, KUidContactFieldVCardMapPHOTO);
}
if(pictureFieldIndex == KErrNotFound) {
// Either KUidContactFieldPictureValue or KUidContactFieldVCardMapJPEG
// thumbnail field types should be in the template
User::Leave(KErrNotFound);
}
m_thumbnailFieldFromTemplate = CContactItemField::NewL(cardFields[pictureFieldIndex]);
CleanupStack::PopAndDestroy(goldenTemplate);
CleanupStack::PopAndDestroy(contactDatabase);
}
}
/**
* Deleting the 1000 contact item
* with all new fields
* @return - void
*/
void CTestContactPerformanceStep::DeletePerformanceL()
{
// delete multiple contact item field
CContactItem *readItem = NULL;
//Get the number of contact item from ini file
GetIntFromConfig(ConfigSection(), KNoOfContactItem, iNoOfCI);
for(TInt readContact=0; readContact<iNoOfCI; readContact++)
{
readItem = dBase->ReadContactLC(idArray[readContact]);
CContactItemFieldSet& ContactFieldSet = readItem->CardFields();
for(TInt del=0; del<7; del++)
{
TInt pos = ContactFieldSet.Find(iFieldUid[del], iVcardUid[del]);
if(pos != KErrNotFound)
{
ContactFieldSet.Remove(pos);
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF1(_L("field not deleted"));
SetTestStepResult(EFail);
}
}
CleanupStack::PopAndDestroy(readItem);
}
INFO_PRINTF1(_L("Fields deleted successfully"));
}
/** Add UID and REV properties to the input vCard files
* This helps in importing the vCards in Merge Mode
* @param aContactItem - existing contact item
* @param fsSession - File Session
* @param aSource - new file
* @param aDestination - File contains Uid of existing Contact item and field value from new file
* @return - void
*/
void CTestImportContactMergeModeStep::AddUidRevPropertyL(const CContactItem& aContactItem, RFs& fsSession, const TDesC& aSource, const TDesC& aDestination)
{
CParserVCard* vCardParser=CParserVCard::NewL();
CleanupStack::PushL(vCardParser);
InternalizeFileL(*vCardParser,aSource,fsSession);
CParserPropertyValueDateTime* valueDateTime = CreateDateTimePropertyL(aContactItem.LastModified(),TVersitDateTime::EIsMachineLocal);
CleanupStack::PushL(valueDateTime);
CParserProperty* property=CParserGroupedProperty::NewL(*valueDateTime,KVersitTokenREV,NULL,NULL);
CleanupStack::Pop(valueDateTime);
CleanupStack::PushL(property);
vCardParser->AddPropertyL(property); //takes ownership
CleanupStack::Pop(property);
TInt64 machineUniqueId = dBase->MachineId();
TPtrC guid=aContactItem.UidStringL(machineUniqueId);
CParserPropertyValueHBufC* uidValue=CParserPropertyValueHBufC::NewL(guid);
CleanupStack::PushL(uidValue);
CParserProperty* uidproperty=CParserGroupedProperty::NewL(*uidValue,KVersitTokenUID,NULL,NULL);
CleanupStack::Pop(uidValue);
CleanupStack::PushL(uidproperty);
vCardParser->AddPropertyL(uidproperty); //takes ownership
CleanupStack::Pop(uidproperty);
ExternaliseFileL(*vCardParser,aDestination, fsSession);
CleanupStack::PopAndDestroy(vCardParser);
}
/**
Utility method used to read text blob fields from contacts database. Provides a mechanism to
fill a contact item with informations stored in text blobs within contact database.
A reference to the contact item to be fill has to be provided. A template has to be provided
if the contact item is based on a template. Template can be NULL. Also a view definition can
be provided to filter which fields are read from blob fields.
@param aTextHeader reference to a read stream from which header values will be read
@param aTextValues reference to a descriptor from which text values will be read
@param aItem Contact item to be filled with information from text blob field.
@param aView View definition specifying what item fields should be read from text blob field
@param aTemplate Contact item representing a template based on which aItem should be read. Can be NULL
@leave KErrNotFound if the specified contact item does not exist any more in contact database
*/
void TCntPersistenceUtility::ReadTextBlobL(CEmbeddedStore& aTextHeaderStore, TPtrC& aTextValues, CContactItem& aItem, const CContactItemViewDef& aView, const CContactItem* aTemplate)
{
HBufC* textFieldsBuf = aTextValues.AllocLC();
if (aTemplate)
{
// If a system template is provided, we create a new CContactItemFieldSet object
// and restore it based on provided template (CContactItemField objects composing
// template). CContactItem object will be set with the newly created CContactItemFieldSet.
CContactItemFieldSet* original = CContactItemFieldSet::NewLC();
RestoreTextL(*original, aTextHeaderStore, aTextHeaderStore.Root(), textFieldsBuf, aView, aTemplate);
for(TInt loop = 0;loop < original->Count();loop++)
{
CContactItemField* additionalField = CContactItemField::NewLC((*original)[loop]);
aItem.CardFields().AddL(*additionalField);
CleanupStack::Pop(additionalField);
}
CleanupStack::PopAndDestroy(original);
}
else
{
// If there is no template provided, we will fill the CContactItemField set provided
// in the curent CContactItem object
RestoreTextL(aItem.CardFields(), aTextHeaderStore, aTextHeaderStore.Root(), textFieldsBuf, aView, NULL);
}
CleanupStack::PopAndDestroy(textFieldsBuf);
}
/**
Utility method used to write text and binary blob fields into write streams. The write
streams will be used to persist the blob informations in contact database.
Provides a mechanism to get information from a contact item and store them in the
right blob fields within contact database. Template can be NULL.
@param aTextHeader reference to a write stream in which text header will be written
@param aTextValues reference to a write stream in which text values will be written.
From the caller point of view this reference should be a reference to a RSqlParamWriteStream instance
@param aBinaryHeader reference to a write stream in which binary header will be written
@param aBinaryValues reference to a write stream in which binary values will be written.
@param aItem Contact item to be filled with information from text blob field.
@param aSysTemplate System template item.
*/
void TCntPersistenceUtility::WriteBlobL(CEmbeddedStore& aTextEmbeddedStore, RWriteStream& aTextValues, CEmbeddedStore& aBinaryEmbeddedStore, CEmbeddedStore& aBinaryEmbeddedBlobStore, const CContactItem& aItem, const CContactTemplate* aSysTemplate)
{
CContactItemFieldSet& fieldSet = aItem.CardFields();
CContactItemFieldSet* textFieldSet = CContactItemFieldSet::NewLC();
CContactItemFieldSet* binaryFieldSet = CContactItemFieldSet::NewLC();
for(TInt i = 0; i < fieldSet.Count(); ++i)
{
CContactItemField* item = CContactItemField::NewL((aItem.CardFields())[i]);
CleanupStack::PushL(item);
if(item->StorageType() == KStorageTypeText)
{
textFieldSet->AddL(*item);
}
else
{
binaryFieldSet->AddL(*item);
}
CleanupStack::Pop(item);
}
TStreamId rootId = textFieldSet->StoreL(aTextEmbeddedStore, aSysTemplate, aTextValues, aBinaryEmbeddedBlobStore, NULL);// *textEmbeddedBlobStore);
aTextEmbeddedStore.SetRootL(rootId);
aTextEmbeddedStore.CommitL();
rootId = binaryFieldSet->StoreL(aBinaryEmbeddedStore, aSysTemplate, aTextValues, aBinaryEmbeddedBlobStore, NULL);
aBinaryEmbeddedStore.SetRootL(rootId);
aBinaryEmbeddedStore.CommitL();
aBinaryEmbeddedBlobStore.CommitL();
CleanupStack::PopAndDestroy(2, textFieldSet); //binaryFieldSet, textFieldSet
}
/**
* Set the phone number field of the contact with id aId to contain the number aNumber
* @param aDb Contact database
* @param aId Contact item id
* @param aNumber A telephone number
*/
void SetPhoneNumberField(CContactDatabase& aDb,TContactItemId aId,const TDesC& aNumber)
{
syncChecker->ResetMethodCallCountsL();
CContactItem* item = aDb.OpenContactLX(aId);
CleanupStack::PushL(item);
if (item->Type() == KUidContactICCEntry)
{
test(syncChecker->ValidateMethodCallCountL() == 2);
}
else
{
test(syncChecker->ValidateMethodCallCountL() == 0);
}
CContactItemFieldSet& fieldset = item->CardFields();
TInt pos = fieldset.Find(KUidContactFieldPhoneNumber);
test(pos!=KErrNotFound);
CContactItemField& field = fieldset[pos];
CContactTextField* textfield = field.TextStorage();
textfield->SetTextL(aNumber);
syncChecker->ResetMethodCallCountsL();
aDb.CommitContactL(*item);
if (item->Type() == KUidContactICCEntry)
{
test(syncChecker->ValidateMethodCallCountL() == 2);
}
else
{
test(syncChecker->ValidateMethodCallCountL() == 0);
}
CleanupStack::PopAndDestroy(2); // item, lock record
}
void TestOneL()
{
g_test.Start(_L("@SYMTestCaseID:PIM-T-SPEEDDIALTEST-0001 Create Database with Speed Dials then Delete and Create database"));
TestDatabaseWithSpeedDialsL();
g_test.Next(_L("Delete database"));
CContactDatabase::DeleteDatabaseL(KDbFileName);
g_test.Next( _L("open database should fail"));
CContactDatabase* database = NULL;
TRAPD(openError, database = CContactDatabase::OpenL(KDbFileName));
g_test(openError == KErrNotFound && database == NULL);
g_test.Next( _L("create replacement database"));
database = CContactDatabase::CreateL(KDbFileName);
CleanupStack::PushL(database);
CreateContactsL(*database);
CContactItem* item = database->ReadContactL(KSpeedDialContact);
CleanupStack::PushL(item);
g_test.Next( _L("Check that Speed dial is forgotten"));
g_test(item->Id() == KSpeedDialContact);
// retored item should not be a SpeedDial
g_test(!ContactIsASpeedDial( *item ));
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(database);
g_test.End();
}
void AssignSpeedDialL( TInt aContact, TInt aSpeedDialID, CContactDatabase& database )
{
CContactItem* item = NULL;
item = database.OpenContactL( aContact );
CleanupStack::PushL( item );
if ( ContactIsASpeedDial( *item ) )
{
g_test.Printf( _L("Contact is a speed dial !!! \n") );
}
else
{
g_test.Printf( _L("Contact is NOT A SPEED DIAL \n") );
}
CContactItemFieldSet &fieldSet = item->CardFields();
for(TInt index = fieldSet.Count() - 1; index > 0; --index)
{
if(fieldSet[index].StorageType() == KStorageTypeText)
{
//set the last text field from the fieldset as speeddial field.
database.SetFieldAsSpeedDialL(*item, index, aSpeedDialID );
break;
}
}
g_test.Next( _L("Contact changed to speed dial") );
g_test(ContactIsASpeedDial( *item ));
CleanupStack::PopAndDestroy( item );
}
// This tests tries to reproduce defect
// EDNRTRN-4J5C5E "Groups in Cntmodel cannot be renamed.."
//
// This defect was caused because groups weren't included in the view and
// MoveInSortArrayL doesn't check that the contact item will be in the
// iSortedItems list (this list depends on the view chosen).
//
LOCAL_C void RenameDefectL()
{
test.Next(_L("Rename a group"));
CntTest->CloseDatabase();
CntTest->DeleteDatabaseL();
CContactDatabase* db=CntTest->CreateDatabaseL();
_LIT(KCntmodelOriginalName,"Original");
_LIT(KCntmodelRevisedName,"Revised");
CContactItem* newGroup = CntTest->Db()->CreateContactGroupLC(KCntmodelOriginalName);
TContactItemId groupId = newGroup->Id();
CleanupStack::PopAndDestroy(); //newGroup
TContactItemId contactA=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("a"));
TContactItemId contactB=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("b"));
CntTest->Db()->AddContactToGroupL(contactA,groupId);
CntTest->Db()->AddContactToGroupL(contactB,groupId);
CntTest->Db()->SetDbViewContactType(KUidContactCard);
CntTest->Db()->SortedItemsL(); // ensures theres a iSortedItems
SetSortOrderL(*db,TUid::Uid(KUidContactFieldDefinedTextValue)); // required so that the comparision
CContactGroup* group = static_cast<CContactGroup*>(CntTest->Db()->OpenContactL(groupId));
CleanupStack::PushL(group);
group->SetGroupLabelL(KCntmodelRevisedName);
CntTest->Db()->CommitContactL(*group);
CntTest->Db()->CloseContactL(groupId);
CleanupStack::PopAndDestroy(); //group
CContactItem* revisedGroup = CntTest->Db()->ReadContactLC(groupId,*CntTest->Db()->AllFieldsView());
TPtrC testLabel = static_cast<CContactGroup*>(revisedGroup)->GetGroupLabelL();
test(testLabel==KCntmodelRevisedName);
CleanupStack::PopAndDestroy(); //revisedGroup
}
/**
* Create a new template and add it to the database
* @param aDb Contact database
* @param aTemplateName Name for the template
* @param aFieldSet Array of fields which should are added to the template
* @return TContactItemId Id of the newly created template
*/
TContactItemId CreatePhonebookTemplateL(CContactDatabase& aDb, const TDesC& aTemplateName, RArray<TFieldEntry>& aFieldSet)
{
CContactItem* temp = aDb.CreateContactCardTemplateLC(aTemplateName);
TContactItemId templateId = temp->Id();
CleanupStack::PopAndDestroy(temp);
temp=NULL;
//Remove all the unnecessary fields
temp = aDb.OpenContactLX(templateId);
CleanupStack::PushL(temp);
const TInt fieldCount = temp->CardFields().Count();
for(TInt i=fieldCount-1;i>=0;i--)
temp->RemoveField(i);
// Add each of the required fields to the template
for (TInt j=0; j<aFieldSet.Count(); ++j)
{
TFieldEntry fieldEntry=aFieldSet[j];
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText,fieldEntry.iField);
if (fieldEntry.iFieldType!=KNullUid)
field->AddFieldTypeL(fieldEntry.iFieldType);
temp->AddFieldL(*field);
CleanupStack::Pop(field);
}
aDb.CommitContactL(*temp);
CleanupStack::PopAndDestroy(2); // temp, close template
return templateId;
}
/** Create Contact Item and add field to it and
* verify the field is being added
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestAddFieldsStep::AddFieldsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value;
TInt year, month, day;
// Create contact Item and add field to it
CContactItem* item = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(aValue);
}
item->AddFieldL(*field);
// verify the field is being added
CContactItemFieldSet& ContactFieldSet = item->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
//compair the results
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
//compair the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(item);
}
TBool CPredictiveSearchSynchronizer::ReadMailAddressesL(CContactItem& aContact)
{
PRINT(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL"));
// SELECT value FROM comm_addr
// WHERE contact_id = [contact id value] AND type = [type value];
_LIT(KSelectMailAddrFormat, "SELECT %S FROM %S WHERE %S = %d AND %S = %d;");
const TInt KContactIdLength = 10;
const TInt KCommAddrTypeLength = 2; // CPplCommAddrTable::EEmailAddress is enum
TInt bufSize = KSelectMailAddrFormat().Length() +
KCommAddrValue().Length() +
KSqlContactCommAddrTableName().Length() +
KCommAddrContactId().Length() +
KContactIdLength +
KCommAddrType().Length() +
KCommAddrTypeLength;
HBufC* sqlStatement = HBufC::NewLC(bufSize);
sqlStatement->Des().AppendFormat(KSelectMailAddrFormat,
&KCommAddrValue,
&KSqlContactCommAddrTableName,
&KCommAddrContactId,
aContact.Id(),
&KCommAddrType,
CPplCommAddrTable::EEmailAddress);
RSqlStatement stmnt;
CleanupClosePushL(stmnt);
PRINT1(_L("prepare SQL statement:%S"), sqlStatement);
stmnt.PrepareL(iDatabase, *sqlStatement);
const TInt KValueIndex = 0;
TBool foundMailAddress(EFalse);
TInt err(KErrNone);
while ((err = stmnt.Next()) == KSqlAtRow)
{
TPtrC value;
if (stmnt.ColumnText(KValueIndex, value) == KErrNone)
{
PRINT2(_L(" id=%d, found mail address=%S"), aContact.Id(), &value);
CContactItemField* field =
CContactItemField::NewLC(KStorageTypeText, KUidContactFieldEMail);
CContactTextField* textfield = field->TextStorage();
textfield->SetTextL(value);
aContact.AddFieldL(*field); // Takes ownership
CleanupStack::Pop(field);
foundMailAddress = ETrue;
}
}
if (err != KSqlAtEnd)
{
PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL SQL err=%d"), err);
User::Leave(err);
}
CleanupStack::PopAndDestroy(&stmnt);
CleanupStack::PopAndDestroy(sqlStatement);
PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL return %d"), foundMailAddress);
return foundMailAddress;
}
/**
* Create phonebook group
* @param aDb Contact database
*/
TContactItemId CreatePhonebookGroupL(CContactDatabase& aDb)
{
_LIT(KPhbkGroup,"ADN Phonebook");
CContactItem* group = aDb.CreateContactGroupLC(KPhbkGroup);
TContactItemId groupId = group->Id();
CleanupStack::PopAndDestroy(group);
return groupId;
}
LOCAL_C void TestFilteringL()
{
_LIT(KProgressIndicator,".");
test.Printf(KProgressIndicator);
CCntFilter* filter = CCntFilter::NewL();
CleanupStack::PushL(filter);
filter->SetContactFilterTypeCard(ETrue);
TTime time;
time.UniversalTime();
time-=TTimeIntervalMinutes(20); // changes in the last 20 mins
filter->SetFilterDateTime(time);
filter->SetIncludeNewContacts(ETrue);
CntTest->Db()->FilterDatabaseL(*filter);
test(filter->iIds->Count()==KTotalNumRecords);
// modified contact
User::After(4000000); // Let time pass to distinguish between mod / new
// this may still fail if the device is running too slow (e.g. under a heavy load)
filter->Reset();
time.UniversalTime();
filter->SetFilterDateTime(time);
filter->SetIncludeModifiedContacts(ETrue);
CntTest->Db()->FilterDatabaseL(*filter);
test(filter->iIds->Count()==0);
CContactItem* contact = CntTest->Db()->OpenContactLX(5);
CleanupStack::PushL(contact);
contact->IncAccessCount();
CntTest->Db()->CommitContactL(*contact);
CleanupStack::PopAndDestroy(contact);
CleanupStack::Pop(); // contact.Close()
CntTest->Db()->FilterDatabaseL(*filter);
test(filter->iIds->Count()==1);
// deleted contact
filter->Reset();
filter->SetFilterDateTime(time); // same time as for modified
filter->SetIncludeDeletedContacts(ETrue);
CntTest->Db()->FilterDatabaseL(*filter);
test(filter->iIds->Count()==0);
CntTest->Db()->DeleteContactL(5);
CntTest->Db()->FilterDatabaseL(*filter);
TInt deletedContactCount = filter->iIds->Count();
test(deletedContactCount ==1);
#ifdef _DEBUG
CContactIdArray* deletedCntArray = CntTest->Db()->DeletedContactsLC();
test(deletedCntArray->Count()==deletedContactCount);
CleanupStack::PopAndDestroy(deletedCntArray );
#endif
CleanupStack::PopAndDestroy(filter);
}
/**
Try to match the phone number given with existing numbers in the database.
*/
void CCrudOperations::MatchContactsByPhoneNumL()
{
_LIT(KPass, "Pass");
_LIT(KFail, "Fail");
_LIT(KMatchOutputFormat1, "Number of phone numbers matched: %d -- %s\n");
_LIT(KMatchOutputFormat2, "Phone number lookup took: %d s %03d\n");
_LIT(KMatchOutputFormat3, "The contact's first name: %S\n");
_LIT(KPhoneNumberToFind, "241867306233253164487125"); // this number belongs to the 1000th
// contact item in the database, which
// has a photo.
const TInt KMatchLengthFromRight(7); // match on the number without the dialling code prefix
// to avoid differences like +447876... and 07876...
_LIT(KPhoneNumberTestTitle, "\nBeginning Phone Number Match testing...\n");
iTest->Printf(KPhoneNumberTestTitle);
TCntPerfTimer timer;
timer.StartTimer();
// Search the database...
CContactIdArray* idArray = iDb->MatchPhoneNumberL(KPhoneNumberToFind, KMatchLengthFromRight);
CleanupStack::PushL(idArray);
TInt numMatches = idArray->Count();
iTest->Printf(KMatchOutputFormat1, numMatches, numMatches ? KPass().Ptr() : KFail().Ptr());
if (numMatches)
{
//fetch first contact item in array
CContactItem* item = iDb->ReadContactLC((*idArray)[0]);
timer.StopTimer();
CContactItemFieldSet& fieldSet = item->CardFields();
TInt firstNameFieldId = fieldSet.Find(KUidContactFieldGivenName);
if (firstNameFieldId == KErrNotFound)
{
User::Leave(KErrNotFound);
}
CContactItemField& firstNameField = fieldSet[firstNameFieldId];
CContactTextField* firstNameText = firstNameField.TextStorage();
TPtrC firstName(firstNameText->Text());
iTest->Printf(KMatchOutputFormat3, &firstName);
CleanupStack::PopAndDestroy(item);
}
else
{
timer.StopTimer();
}
CleanupStack::PopAndDestroy(idArray);
TInt result = timer.Result();
TBuf<64> formattable;
formattable.Format(KMatchOutputFormat2, result / 1000000, (result / 1000) % 1000);
iTest->Printf(formattable);
}
LOCAL_C void DoTestsL()
{
CleanupClosePushL(test);
test.Start(_L("@SYMTESTCaseID:PIM-T-TEMPLATECACHE-0001 ----------- State Tests ----------"));
__UHEAP_MARK;
RCntModel cntClient;
cntClient.ConnectL();
cntClient.OpenDatabase();
CCntTemplateCache* templateCache = CCntTemplateCache::NewL(cntClient);
CleanupStack::PushL(templateCache);
CContactIdArray* cardTemplateIds = CContactIdArray::NewLC();
// Add 15 templates
CContactTemplate* contactTemplate = NULL;
TInt ii = 0;
for (; ii < 15; ++ii)
{
contactTemplate = CContactTemplate::NewLC();
cardTemplateIds->AddL(cntClient.CreateContactL(*contactTemplate));
CleanupStack::PopAndDestroy(); // contactTemplate
}
// Create a contactItem
CCntItemBuilder* cntItemBldr = CCntItemBuilder::NewLC(static_cast<CContactTemplate&>(templateCache->SystemTemplateL()));
CContactItem* cntItem = cntItemBldr->GetCntItemLC();
/*TContactItemId cntId = */cntClient.CreateContactL(*cntItem);
ii = 0;
for (; ii < 15; ++ii)
{
cntItem->SetTemplateRefId((*cardTemplateIds)[ii]);
templateCache->MergeWithTemplateL(*cntItem);
// Merge a second time... the template should now be cached
templateCache->MergeWithTemplateL(*cntItem);
}
CleanupStack::PopAndDestroy(cntItem);
CleanupStack::PopAndDestroy(cntItemBldr);
CleanupStack::PopAndDestroy(cardTemplateIds);
CleanupStack::PopAndDestroy(templateCache);
cntClient.Close();
__UHEAP_MARKEND;
test.Next(_L("---- All Tests Completed OK ----"));
test.End();
CleanupStack::PopAndDestroy(1); // test.Close
}
void TestFourL()
{
g_test.Start(_L("Check that Settings are saved - killing ContactLockSrv"));
g_test.Next(_L("Setting up..."));
CLockServerTester* lockSrvTester = CLockServerTester::NewL();
CleanupStack::PushL(lockSrvTester);
CContactDatabase* database = SetupLC();
g_test.Next( _L("Assign Speed Dial"));
TInt error = KErrNone;
TRAP(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );
g_test(error == KErrNone);
g_test.Next( _L("Update Speed Dial"));
error = KErrNone;
TRAP(error, UpdateSpeedDialL( KSpeedDialContact, KSpeedDialPositionTwo, *database ) );
g_test(error == KErrNone);
g_test.Next( _L("Change Database Drive"));
CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveD),EFalse);
CleanupStack::PopAndDestroy(database);
// Kill ContactLockServer process
g_test.Next( _L("Kill CntServer"));
lockSrvTester->FindServerAndKillItL();
CleanupStack::PopAndDestroy( lockSrvTester );
g_test.Next( _L("Open Database"));
database = CContactDatabase::OpenL(KDbFileName);
CleanupStack::PushL(database);
TDriveUnit driveUnit;
CContactDatabase::DatabaseDrive(driveUnit);
g_test.Next( _L("Check that Database Drive is changed"));
g_test(driveUnit==TDriveUnit(EDriveD));
CContactItem* item = database->ReadContactL(KSpeedDialContact);
CleanupStack::PushL(item);
g_test.Next( _L("Check that Speed Dial is remembered"));
g_test(item->Id() == KSpeedDialContact);
// retored item should be a SpeedDial
g_test(ContactIsASpeedDial( *item ));
// reset Database Drive
g_test.Next( _L("Reset Database Drive setting"));
CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(database);
g_test.End();
}
LOCAL_C void AddGroupToCard()
{
//
test.Next(_L("Group to Card"));
CContactItem* newGroup = CntTest->Db()->CreateContactGroupL(_L("New Group"));
TContactItemId tempId = newGroup->Id();
delete newGroup;
// assumes Prior Knowldege of contact 3 (is a card)
CntTest->Db()->AddContactToGroupL(tempId,3);
//
}
void TestThreeL()
{
g_test.Start(_L("Check that Settings are saved - normal shutdown"));
g_test.Next(_L("Setting up..."));
CContactDatabase* database = SetupLC();
g_test.Next( _L("Assign Speed Dial"));
TInt error = KErrNone;
TRAP(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );
g_test(error == KErrNone);
g_test.Next( _L("Update Speed Dial"));
error = KErrNone;
TRAP(error, UpdateSpeedDialL( KSpeedDialContact, KSpeedDialPositionTwo, *database ) );
g_test(error == KErrNone);
g_test.Next( _L("Change Database Drive"));
CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveD),EFalse);
CleanupStack::PopAndDestroy( database );
g_test.Next(_L("Wait for Contact Server to shutdown"));
// wait until Contacts Lock Server shuts down
// applicabale only in the case of transient server.
User::After(6000000);
g_test.Next( _L("Try to open Database again"));
database = CContactDatabase::OpenL(KDbFileName);
CleanupStack::PushL(database);
TDriveUnit driveUnit;
CContactDatabase::DatabaseDrive(driveUnit);
g_test.Next( _L("Check that Database Drive is changed"));
g_test(driveUnit==TDriveUnit(EDriveD));
CContactItem* item = database->ReadContactL(KSpeedDialContact);
CleanupStack::PushL(item);
g_test.Next( _L("Check that Speed Dial is remembered"));
g_test(item->Id() == KSpeedDialContact);
// retored item should be a SpeedDial
g_test(ContactIsASpeedDial( *item ));
// reset Database Drive
g_test.Next( _L("Reset Database Drive setting"));
CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(database);
g_test.End();
}
CContentType* CPackagerCntFactory::doCreateDefaultCContentTypeL() const
/** Implementation method for constructing a new default CContentType object.
@return a Pointer to the CContentType object. */
{
CContactItem* theItem = doCreateDefaultCContactItemL();
CleanupStack::PushL(theItem);
CContentType* theContent = CContentType::NewL(theItem->CardFields()[0].ContentType());
CleanupStack::PopAndDestroy(theItem);
return theContent;
}
/**
* Verify that the template was correctly added
* @param aTemplate CContactCardTemplate template item
*/
void CheckTemplateL(CContactItem& aTemplate)
{
test(aTemplate.Type() == KUidContactCardTemplate);
test(aTemplate.TemplateRefId() == KNullContactId);
test(static_cast<CContactCardTemplate&>(aTemplate).GetTemplateLabelL() == KTemplateName);
CContactItemFieldSet& fieldset = aTemplate.CardFields();
TInt pos = fieldset.Find(KUidContactFieldTemplateLabel);
test(pos!=KErrNotFound);
TInt count = fieldset.Count();
test(count==5); //label, name, number, ICC slot, phonebook
}
LOCAL_C void TestUpdateContactL()
{
test.Next(_L("TestUpdateContactL"));
SETUP;
CContactItem* contact = CContactItem::NewLC(KUidContactCard);
TContactItemId id = cntClient.CreateContactL(*contact);
CleanupStack::PopAndDestroy(contact);
// View definition to read image field
CContactItemViewDef* imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldMatchAll);
contact = cntClient.OpenContactLX(imageViewDef ,id);
CleanupStack::PushL(contact);
CContactItemField* newField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCodImage);
newField->SetMapping(KUidContactFieldVCardMapUnknown);
newField->TextStorage()->SetTextL(KSrcImage());
contact->AddFieldL(*newField); // Takes ownership
CleanupStack::Pop(newField);
cntClient.CommitContactL(*contact, EFalse);
CleanupStack::PopAndDestroy(2); // contact, imageViewDef
// View definition to read image field
imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldCodImage);
contact = cntClient.ReadContactL(imageViewDef ,id);
TInt index = contact->CardFields().Find(KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown);
// Test image field found
test(index != KErrNotFound);
CContactItemField& field = contact->CardFields()[index];
TPtrC imagePtr = field.TextStorage()->Text();
// Image should exist
test(BaflUtils::FileExists(fs, imagePtr));
// Test for GUID
TPtrC guid = contact->Guid();
test(imagePtr.Find(guid));
cntClient.CloseContact(id);
CleanupStack::PopAndDestroy(2); // contact, imageViewDef
TEAR_DOWN;
}
// Check that the speed dial at position aSpeedDialPosition matches the aExpectedId
// and the contents of the field with aFieldId is the same in the speed dial.
//
LOCAL_C void CheckSpeedDialL(TInt aSpeedDialPosition, CContactItem& aContact, TInt aFieldId)
{
HBufC* buf=HBufC::NewLC(100);
TPtr fieldContents=buf->Des();
TContactItemId id = CntTest->Db()->GetSpeedDialFieldL(aSpeedDialPosition, fieldContents);
TPtrC actualContents =(aContact.CardFields()[aFieldId].TextStorage()->Text());
test(id==aContact.Id());
test(actualContents==fieldContents);
CleanupStack::PopAndDestroy(); //buf
}
EXPORT_C void CCntItemModifier::SetTextFieldL(TFieldType aFieldType, const TDesC& aText, CContactItem& aContactItem)
{
CContactItemFieldSet& fields = aContactItem.CardFields();
TInt fieldIndex = aContactItem.CardFields().Find(aFieldType);
if (fieldIndex > KErrNotFound)
{
CContactItemField& field = fields[ fieldIndex ];
ASSERT(field.StorageType() == KStorageTypeText);
STATIC_CAST(CContactTextField*, field.Storage())->SetText(aText.AllocL());
}
