/**
* To return a valid contact item id.
*/
TContactItemId CSyncTestStep::GetValidUIDFromContactsDbL()
{
TContactItemId firstId(KNullContactId);
CContactDatabase *iDb = NULL;
TRAPD(err,iDb = CContactDatabase::OpenL()); // open existing database
CleanupStack::PushL(iDb);
if (err != KErrNone)
{
CleanupStack::PopAndDestroy(); // iDb
return firstId;
}
iDb->SetDbViewContactType(KUidContactICCEntry);
// to get the unique groupId for the phonebook
TContactItemId groupId(KNullContactId);
User::LeaveIfError(iSession.GetPhoneBookId(groupId, RPhoneBookSession::ESyncGroupId));
TESTCHECKCONDITIONL(groupId != KNullContactId);
// based on the groupId, get an item belonging to the phonebook
CContactGroup* group = static_cast<CContactGroup*>(iDb->ReadContactLC(groupId));
const CContactIdArray* array = group->ItemsContained();
TInt count(array->Count());
if (count > 0)
firstId = (*array)[0];
CleanupStack::PopAndDestroy(group);
CleanupStack::PopAndDestroy(); // iDb
return firstId;
}
// 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
}
//------------------------------------------------------------------------------------------------------------
void CPerfDbCreator::AddGroupL(const TDesC & aGroupLabel)
{
CContactGroup * group = static_cast<CContactGroup *>(iContactsDb->CreateContactGroupLC(aGroupLabel));
// Add a number of existing items to the group
TInt itemCount = iContactsDb->CountL();
TInt contactId;
for (TInt i = 0 ; i < KGroupSize; i++)
{
contactId = Math::Rand(iSeed) % itemCount;
iContactsDb->AddContactToGroupL(contactId, group->Id());
}
CleanupStack::PopAndDestroy(group);
}
/**
* Updates the specified group with details like group name, number of contacts in the group
* @param aGroupSection - section in the ini file contains necessary details for group update
* @param aGroup - Group to be updated
*/
void CTestContactViewDatabaseUtilitiesStep::UpdateGroupsL(const TPtrC& aGroupSection, CContactGroup& aGroup)
{
_LIT(KGroupName, "groupname");
TPtrC groupName;
GetStringFromConfig(aGroupSection, KGroupName, groupName);
aGroup.SetGroupLabelL(groupName);
_LIT(KNumOfContacts, "numofcontacts");
TInt numOfContacts;
GetIntFromConfig(aGroupSection, KNumOfContacts, numOfContacts);
CCntFilter* filter = CCntFilter::NewL();
CleanupStack::PushL(filter);
filter->SetContactFilterTypeCard(ETrue);
DatabaseReference().FilterDatabaseL(*filter);
for(TInt i = 0; i < numOfContacts; ++i)
{
CContactIdArray* idArray = filter->iIds;
TContactItemId contactItemId = (*idArray)[i];
CContactItem* contactItem = DatabaseReference().OpenContactL(contactItemId);
CleanupStack::PushL(contactItem);
TRAP_IGNORE(DatabaseReference().RemoveContactFromGroupL(*contactItem, aGroup));
TRAP_IGNORE(DatabaseReference().AddContactToGroupL(*contactItem, aGroup));
CleanupStack::PopAndDestroy(contactItem);
DatabaseReference().CloseContactL(contactItemId);
}
CleanupStack::PopAndDestroy(filter);
}
// -----------------------------------------------------------------------------
// TSnapshotItem::CreateHashL
// Create hash value from group content
// -----------------------------------------------------------------------------
void TSnapshotItem::CreateHashL( CContactGroup& aGroup )
{
CMessageDigest* hash = CMessageDigestFactory::NewDigestLC( CMessageDigest::EMD5 );
if ( aGroup.HasItemLabelField() )
{
TPtrC label = aGroup.GetGroupLabelL();
HBufC8* tempBuf = CnvUtfConverter::ConvertFromUnicodeToUtf8L( label );
CleanupStack::PushL( tempBuf );
hash->Update( tempBuf->Des() );
CleanupStack::PopAndDestroy( tempBuf );
}
// Create text field from items on group
CContactIdArray* contactsIdArray = aGroup.ItemsContainedLC();
const TInt idBufferMaxSize( 400 );
HBufC8* tempIdBuf = HBufC8::NewLC( idBufferMaxSize );
TPtr8 tempId = tempIdBuf->Des();
const TInt KMaxNumLength(5);
if ( contactsIdArray ) // this is NULL if there are no objects
{
tempId.AppendNum( contactsIdArray->Count(), EHex );
for (TInt i=0; i< contactsIdArray->Count(); i++ )
{
if ( tempId.Length()+KMaxNumLength > tempId.MaxLength() )
{
// buffer is almost full, don't add any new items
LOGGER_WRITE("buffer full");
break;
}
// add item id
tempId.AppendNum( (*contactsIdArray)[i] , EHex );
}
}
else
{
tempId.AppendNum( 0 );
}
// update hash
hash->Update( tempId );
iHash.Copy( hash->Final() );
CleanupStack::PopAndDestroy( tempIdBuf );
CleanupStack::PopAndDestroy( contactsIdArray );
CleanupStack::PopAndDestroy( hash );
}
/* In this section, we edit the desired number of groups in the database
* Set label for them and associate them with contacts
@ param aGroupSection - Desired Group Name
@ param aContact - Contact to be updated
*/
void CTestContactViewCRUDOperationsStep::UpdateContactsInGroupL(const TInt aNumberOfContactsToBeUpdated, const TPtrC& aGroupSection)
{
RArray<TPtrC> listOfGroupsSections;
CleanupClosePushL(listOfGroupsSections);
ViewUtilityReference().TokenizeStringL(aGroupSection, listOfGroupsSections);
for ( TInt i = 0; i < listOfGroupsSections.Count(); ++i )
{
CCntFilter* filter = CCntFilter::NewL();
CleanupStack::PushL(filter);
filter->SetContactFilterTypeGroup(ETrue);
DatabaseReference().FilterDatabaseL(*filter);
for ( TInt i = 0; i < filter->iIds->Count(); ++i )
{
TContactItemId groupId = (*filter->iIds)[i];
CContactItem* group = DatabaseReference().OpenContactL(groupId);
CContactGroup* newGroup = static_cast<CContactGroup*>(group);
if(aGroupSection.Compare(newGroup->GetGroupLabelL()) == 0)
{
const CContactIdArray* listOfContacts = newGroup->ItemsContained();
for(TInt i(0); i < aNumberOfContactsToBeUpdated; i++)
{
TContactItemId contactItemId = (*listOfContacts)[i];
CContactItem* contactItem = DatabaseReference().ReadContactL(contactItemId);
CleanupStack::PushL(contactItem);
UpdateFieldsL(*contactItem);
CContactItem* updatedContactItem = DatabaseReference().UpdateContactLC(contactItemId, contactItem);
CleanupStack::PopAndDestroy(updatedContactItem);
CleanupStack::PopAndDestroy(contactItem);
}
delete listOfContacts;
DatabaseReference().CloseContactL(groupId);
break;
}
DatabaseReference().CloseContactL(groupId);
}
CleanupStack::PopAndDestroy(filter);
}
CleanupStack::PopAndDestroy(&listOfGroupsSections);
}
/*
* Private implementation for fetching the members of a group.
*/
QSet<QContactLocalId> CntSymbianDatabase::groupMembersL(QContactLocalId groupId)
{
QSet<QContactLocalId> groupMembers;
CContactItem *contactItem = m_contactDatabase->ReadContactLC(TContactItemId(groupId));
Q_ASSERT(contactItem && contactItem->Type() == KUidContactGroup);
CContactGroup *group = static_cast<CContactGroup*>(contactItem);
const CContactIdArray *idArray = group->ItemsContained();
//loop through all the contacts and add them to the list
for (int i(0); i < idArray->Count(); i++) {
groupMembers.insert((*idArray)[i]);
}
CleanupStack::PopAndDestroy(contactItem);
return groupMembers;
}
/* In this section, we edit the desired number of groups in the database
* Set label for them and associate them with contacts
@ param aGroupSection - Desired Group Name
@ param aContact - Contact to be updated
*/
void CTestContactViewCRUDOperationsStep::IterateThroAllGroupSectionsAndUpdateContactL(const TPtrC& aGroupSection,
CContactCard& aContact)
{
RArray<TPtrC> listOfGroupsSections;
CleanupClosePushL(listOfGroupsSections);
ViewUtilityReference().TokenizeStringL(aGroupSection, listOfGroupsSections);
for ( TInt i = 0; i < listOfGroupsSections.Count(); ++i )
{
CCntFilter* filter = CCntFilter::NewL();
CleanupStack::PushL(filter);
filter->SetContactFilterTypeGroup(ETrue);
DatabaseReference().FilterDatabaseL(*filter);
for ( TInt i = 0; i < filter->iIds->Count(); ++i )
{
TContactItemId groupId = (*filter->iIds)[i];
CContactItem* group = DatabaseReference().OpenContactL(groupId);
CContactGroup* newGroup = static_cast<CContactGroup*>(group);
if(aGroupSection.Compare(newGroup->GetGroupLabelL()) == 0)
{
TRAP_IGNORE(DatabaseReference().RemoveContactFromGroupL(aContact, *newGroup));
TRAP_IGNORE(DatabaseReference().AddContactToGroupL(aContact, *newGroup));
DatabaseReference().CommitContactL(*group);
const CContactIdArray* listOfContacts = newGroup->ItemsContained();
const TInt count = listOfContacts->Count();
delete listOfContacts;
DatabaseReference().CloseContactL(groupId);
break;
}
DatabaseReference().CloseContactL(groupId);
}
CleanupStack::PopAndDestroy(filter);
}
CleanupStack::PopAndDestroy(&listOfGroupsSections);
}
void CTestConductor::CreateGroupTestDataL()
{
CContactGroup* groupOne = static_cast<CContactGroup*>(iDb->CreateContactGroupL(KGroupOneName));
CContactIdArray* idsInGroupViewOne = NULL;
CleanupStack::PushL(groupOne);
iGroupOneId = groupOne->Id();
for (TInt ii=1;ii<=KNumContactsInGroupOne;++ii)
{
test.Printf(_L("Making Group Contact %d \n"),ii);
iDb->AddContactToGroupL(ii,iGroupOneId);
}
CleanupStack::PopAndDestroy(groupOne);
groupOne = static_cast<CContactGroup*>(iDb->ReadContactL(iGroupOneId));
CleanupStack::PushL(groupOne);
idsInGroupViewOne = groupOne->ItemsContainedLC();
CleanupStack::PopAndDestroy(idsInGroupViewOne);
CleanupStack::PopAndDestroy(groupOne);
}
LOCAL_C void TestRemoveContactFromGroupL()
{
test.Next(_L("Remove a contact from the group"));
CTestResources* res = CTestResources::NewLC();
CheckConsistentL(*res);
// Need to open and commit the group to get any events from CContactDatabase!
CContactGroup* group = static_cast<CContactGroup*>(res->iDb->OpenContactLX(res->iGroupId));
CleanupStack::PushL(group);
// Commit the group to get group changed event from Contact Db
res->iDb->CloseContactL(group->Id());
const TContactItemId contactId = (*group->ItemsContained())[0];
res->iDb->RemoveContactFromGroupL(contactId, group->Id());
// Listen to the event from the DB
TContactDbObserverEvent dbEvent;
test(res->iDbEventQueue->ListenForEvent(2,dbEvent));
test(dbEvent.iType == EContactDbObserverEventGroupChanged);
test(dbEvent.iContactId == group->Id());
// Listen to the event from the group view
TContactViewEvent groupViewEvent;
test(res->iGroupViewEventQueue->ListenForEvent(2,groupViewEvent));
CleanupStack::PopAndDestroy(2); // group, lock
// Eat away all events from queue to give iGroupView a chance to update itself
while (res->iGroupViewEventQueue->ListenForEvent(2,groupViewEvent))
{
}
CheckConsistentL(*res);
CleanupStack::PopAndDestroy(res);
}
LOCAL_C void CheckConsistentL
(CContactDatabase& aDb,
const CContactGroupView& aGroupView,
const CContactViewBase& aBaseView,
TContactItemId aGroupId)
{
const TInt groupViewCount = aGroupView.CountL();
test(groupViewCount <= aBaseView.CountL());
CContactGroup* group = static_cast<CContactGroup*>(aDb.ReadContactLC(aGroupId));
const TInt count = aBaseView.CountL();
TInt checked = 0;
for (TInt i=0; i < count; ++i)
{
const TContactItemId id = aBaseView.AtL(i);
if (group->ContainsItem(id))
{
test(aGroupView.FindL(id) != KErrNotFound);
++checked;
}
}
test(checked == groupViewCount);
CleanupStack::PopAndDestroy(group);
}
/**
Add the given contact item to the database. Forward the call to CPplTableBase
based classes representing the tables in the contact database.
@param aItem The contact item to be added to the database.
@param aSessionId The ID of the session that issued the request. Used to
prevent Phonebook Synchroniser deadlock.
@return Contact item ID of the contact added to the database.
*/
TContactItemId CPplContactItemManager::CreateL(CContactItem& aItem, TUint aSessionId)
{
TBool controlTransaction = !(iTransactionManager.IsTransactionActive());
TBool compressedGuid=EFalse;
// If needed generate a gui for the current contact item
if (aItem.Guid() == TPtrC(KNullDesC))
{
iPreferencePersistor->SetGuidL(aItem, compressedGuid);
}
if (compressedGuid)
{
aItem.SetHasCompressedGuid(compressedGuid);
}
if (aItem.Type() == KUidContactICCEntry)
{
const TInt ret = iContactProperties.ContactSynchroniserL(aSessionId).ValidateWriteContact(static_cast<CContactICCEntry&>(aItem));
User::LeaveIfError(ret);
}
if(controlTransaction)
{
StartTransactionL(aSessionId);
}
iContactTable->CreateInDbL(aItem);
iGroupTable->CreateInDbL(aItem);
iCommAddrTable->CreateInDbL(aItem);
TContactItemId groupId = iIccContactStore.CreateInDbL(aItem, aSessionId);
if(groupId != KNullContactId)
{
//Every ICC entry is added to a special group, created by the Phonebook
//Synchroniser server during the initial synchronisation with the Contacts Model.
CContactItemViewDef* itemDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EMaskHiddenFields);
itemDef->AddL(KUidContactFieldMatchAll);
// Add ICC entry to the group.
CContactGroup* grp = static_cast<CContactGroup*>(ReadLC(groupId, *itemDef, EPlAllInfo, aSessionId));
grp->AddContactL(aItem.Id());
UpdateL(*grp, aSessionId);
CleanupStack::PopAndDestroy(2, itemDef); // grp
}
if(controlTransaction)
{
CommitTransactionL();
}
// Assuming success if no leaves at this point, so update
// the metadata search store for this entry
//CCntMetadataOperation* op = CCntMetadataOperation::NewLC(iColSession);
//TRAP_IGNORE(op->SaveContactLD(aItem));
//CleanupStack::Pop(op); // Do not destroy - called LD function
return aItem.Id();
}