|
1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <e32test.h> |
|
17 #include <versit.h> |
|
18 #include <s32file.h> |
|
19 #include "T_UTILS.H" |
|
20 |
|
21 // |
|
22 // CCntTest |
|
23 // |
|
24 EXPORT_C CCntTest::~CCntTest() |
|
25 { |
|
26 delete iDb; |
|
27 delete iCleanup; |
|
28 iFs.Close(); |
|
29 // RTest object is created in each test harness and does a __UHEAP_MARK |
|
30 // the Close() method does a __UHEAP_MARKEND and so must now be the last action |
|
31 iTest->Close(); |
|
32 } |
|
33 |
|
34 EXPORT_C void CCntTest::ConstructL(RTest &aTest, const TDesC &aDatabaseName) |
|
35 { |
|
36 iDatabaseName.Copy(aDatabaseName); |
|
37 CActiveScheduler::Install(new(ELeave) CActiveScheduler); |
|
38 iTest=&aTest; |
|
39 iTest->Title(); |
|
40 iCleanup=CTrapCleanup::New(); |
|
41 User::LeaveIfError(iFs.Connect()); |
|
42 } |
|
43 |
|
44 EXPORT_C void CCntTest::SelectDriveL() |
|
45 { |
|
46 TDriveList driveList; |
|
47 iFs.DriveList(driveList); |
|
48 driveList[25]=0; // Get rid of Z: |
|
49 TBuf<2> drive; |
|
50 drive.Copy(_L("C:")); |
|
51 TInt driveCount=0; |
|
52 for(TInt loop0=0;loop0<driveList.Size();loop0++) |
|
53 if (driveList[loop0]) |
|
54 driveCount++; |
|
55 if (driveCount>1) |
|
56 { |
|
57 iTest->Printf(_L("Select drive for multi access test:\n")); |
|
58 for(TInt loop=0;loop<driveList.Size();loop++) |
|
59 if (driveList[loop]) |
|
60 iTest->Printf(_L("%c:\n"),loop+'A'); |
|
61 FOREVER |
|
62 { |
|
63 TChar key=iTest->Getch(); |
|
64 TInt index=key.GetLowerCase()-'a'; |
|
65 if (index>=0 && index<driveList.Size() && driveList[index]) |
|
66 { |
|
67 drive[0]=(TText)(index+'A'); |
|
68 break; |
|
69 } |
|
70 } |
|
71 } |
|
72 TParse parse; |
|
73 parse.Set(drive,&iDatabaseName,NULL); |
|
74 iDatabaseName.Copy(parse.FullName()); |
|
75 } |
|
76 |
|
77 EXPORT_C void CCntTest::EndTestLib(TInt aErr) |
|
78 { |
|
79 (*iTest)(aErr==KErrNone); |
|
80 |
|
81 iTest->End(); |
|
82 (*iTest)(iFs.ResourceCount()==0); |
|
83 delete CActiveScheduler::Current(); |
|
84 delete this; |
|
85 } |
|
86 |
|
87 EXPORT_C CContactDatabase *CCntTest::CreateDatabaseL() |
|
88 { |
|
89 CloseDatabase(); |
|
90 iDb=CContactDatabase::ReplaceL(iDatabaseName); |
|
91 return(iDb); |
|
92 } |
|
93 |
|
94 EXPORT_C CContactDatabase* CCntTest::OpenDatabaseL() |
|
95 { |
|
96 CloseDatabase(); |
|
97 iDb=CContactDatabase::OpenL(iDatabaseName); |
|
98 return(iDb); |
|
99 } |
|
100 |
|
101 EXPORT_C void CCntTest::CloseDatabase() |
|
102 { |
|
103 delete iDb; |
|
104 iDb=NULL; |
|
105 } |
|
106 |
|
107 EXPORT_C void CCntTest::DeleteDatabaseL() |
|
108 { |
|
109 CContactDatabase::DeleteDatabaseL(iDatabaseName); |
|
110 } |
|
111 |
|
112 EXPORT_C void CCntTest::DeleteAllTemplateFieldsL() |
|
113 { |
|
114 CContactItemViewDef *viewDef=CContactItemViewDef::NewL(CContactItemViewDef::EMaskFields,CContactItemViewDef::EIncludeHiddenFields); |
|
115 CContactItem *item=iDb->OpenContactLX(iDb->TemplateId(),*viewDef); |
|
116 delete viewDef; |
|
117 CleanupStack::PushL(item); |
|
118 CContactItemFieldSet& fieldSet=item->CardFields(); |
|
119 while(fieldSet.Count()) |
|
120 fieldSet.Remove(0); |
|
121 iDb->CommitContactL(*item); |
|
122 CleanupStack::PopAndDestroy(2); // item,close |
|
123 } |
|
124 |
|
125 EXPORT_C void CCntTest::TestField(CContactItemField &aField,TStorageType aType,TFieldType aFieldType,TUid aMapping) |
|
126 { |
|
127 (*iTest)(aField.StorageType()==aType); |
|
128 (*iTest)(aField.ContentType().ContainsFieldType(aFieldType)); |
|
129 (*iTest)(aField.ContentType().Mapping()==aMapping); |
|
130 } |
|
131 |
|
132 EXPORT_C void CCntTest::AdjustContactAccessCountL(TContactItemId aItemId, TInt aCount) |
|
133 { |
|
134 CContactItem *incItem=iDb->OpenContactLX(aItemId); |
|
135 CleanupStack::PushL(incItem); |
|
136 while(aCount>0) |
|
137 { |
|
138 incItem->IncAccessCount(); |
|
139 aCount--; |
|
140 } |
|
141 while(aCount<0) |
|
142 { |
|
143 incItem->DecAccessCount(); |
|
144 aCount++; |
|
145 } |
|
146 iDb->CommitContactL(*incItem); |
|
147 CleanupStack::PopAndDestroy(2); // incItem, Close(incItem) |
|
148 } |
|
149 |
|
150 EXPORT_C void CCntTest::TestAccessCount(TContactItemId aItemId, TInt aCount) |
|
151 { |
|
152 CContactItem *item=iDb->ReadContactLC(aItemId); |
|
153 (*iTest)(item->AccessCount()==aCount); |
|
154 CleanupStack::PopAndDestroy(); // item |
|
155 } |
|
156 |
|
157 EXPORT_C TBool CCntTest::CompareFields(CContactItemField &aField1, CContactItemField &aField2) |
|
158 { |
|
159 return(aField1.Label()==aField2.Label() && |
|
160 aField1.StorageType()==aField2.StorageType() && |
|
161 aField1.ContentType()==aField2.ContentType()); |
|
162 } |
|
163 |
|
164 EXPORT_C void CCntTest::CheckDeletedContact(TContactItemId aDeleteId) |
|
165 { |
|
166 CContactItem *deletedContact=iDb->ReadContactLC(aDeleteId); |
|
167 (*iTest)(deletedContact->IsDeleted()); |
|
168 (*iTest)(deletedContact->CardFields().Count()==0); |
|
169 TBuf<10> textDef; |
|
170 iDb->ReadContactTextDefL(aDeleteId,textDef); |
|
171 (*iTest)(textDef.Length()==0); |
|
172 CleanupStack::PopAndDestroy(); // deletedContact |
|
173 } |
|
174 |
|
175 EXPORT_C void CCntTest::CheckContactDoesNotExist(TContactItemId aNotExistId) |
|
176 { |
|
177 TRAPD(notExist,iDb->ReadContactLC(aNotExistId)); |
|
178 (*iTest)(notExist==KErrNotFound); |
|
179 } |
|
180 |
|
181 EXPORT_C void CCntTest::DeleteContact(TContactItemId aDeleteMe) |
|
182 { |
|
183 TRAP_IGNORE(iDb->DeleteContactL(aDeleteMe)); |
|
184 } |
|
185 |
|
186 EXPORT_C HBufC *CCntTest::ContactUidLC(TContactItemId aId, TInt64 aMachineId) |
|
187 { |
|
188 CContactItem *contact=iDb->ReadContactLC(aId); |
|
189 HBufC *uid=contact->UidStringL(aMachineId).AllocL(); |
|
190 CleanupStack::PopAndDestroy(); // deletedContact |
|
191 CleanupStack::PushL(uid); |
|
192 return(uid); |
|
193 } |
|
194 |
|
195 EXPORT_C CVCardTestStore* CCntTest::ExportContactsLC(const CContactIdArray *aIds, TUint aFormatFlags, TVCardStoreType aType, TInt aFileNum) |
|
196 { |
|
197 CVCardTestStore* store=ExportContactsL(iDb,aIds,aFormatFlags, aType, &iFs, aFileNum); |
|
198 CleanupStack::PushL(store); // outstream |
|
199 return(store); |
|
200 } |
|
201 |
|
202 EXPORT_C CVCardTestStore* CCntTest::ExportContactLC(TContactItemId aId, TUint aFormatFlags, TVCardStoreType aType, TInt aFileNum) |
|
203 { |
|
204 CContactIdArray *ids=CContactIdArray::NewLC(); |
|
205 ids->AddL(aId); |
|
206 CVCardTestStore* store=ExportContactsLC(ids,aFormatFlags, aType, aFileNum); |
|
207 CleanupStack::Pop(); // store |
|
208 CleanupStack::PopAndDestroy(); // ids |
|
209 CleanupStack::PushL(store); |
|
210 return(store); |
|
211 } |
|
212 |
|
213 EXPORT_C void CCntTest::ImportContacts1by1L(CVCardTestStore* aStore, TUint aFormatFlags) |
|
214 { |
|
215 RStoreReadStream instream; |
|
216 instream.OpenLC(*aStore->Store(),aStore->StreamId()); |
|
217 TBool success=EFalse; |
|
218 do |
|
219 { |
|
220 CArrayPtr<CContactItem>* items=iDb->ImportContactsL(TUid::Uid(KUidVCardConvDefaultImpl),instream,success,aFormatFlags); |
|
221 items->ResetAndDestroy(); |
|
222 delete items; |
|
223 } while(success); |
|
224 CleanupStack::PopAndDestroy(); // instream |
|
225 } |
|
226 |
|
227 EXPORT_C CArrayPtr<CContactItem>* CCntTest::ImportContactsL(CVCardTestStore* aStore, TUint aFormatFlags) |
|
228 { |
|
229 return(::ImportContactsL(iDb,aStore,aFormatFlags)); |
|
230 } |
|
231 |
|
232 EXPORT_C CArrayPtr<CContactItem>* CCntTest::ImportContactsLC(CVCardTestStore* aStore, TUint aFormatFlags) |
|
233 { |
|
234 CArrayPtr<CContactItem>* items=ImportContactsL(aStore, aFormatFlags); |
|
235 CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,items)); |
|
236 return(items); |
|
237 } |
|
238 |
|
239 class RTestSession : public RSessionBase |
|
240 { |
|
241 public: |
|
242 TInt CreateSession(); |
|
243 }; |
|
244 |
|
245 TInt RTestSession::CreateSession() |
|
246 { |
|
247 TVersion version; |
|
248 return(RSessionBase::CreateSession(_L("CntLockServer"),version,1)); |
|
249 } |
|
250 |
|
251 EXPORT_C TBool CCntTest::LockServerSessionExists(TBool aPause) const |
|
252 { |
|
253 if (aPause) |
|
254 User::After(200000); |
|
255 RTestSession session; |
|
256 TInt sessionErr=session.CreateSession(); |
|
257 session.Close(); |
|
258 return(sessionErr==KErrNone); |
|
259 } |
|
260 |
|
261 EXPORT_C void CCntTest::PrintfNewline() const |
|
262 { |
|
263 (*iTest).Printf(_L("\n")); |
|
264 } |
|
265 |
|
266 EXPORT_C TInt CCntTest::LockServerProcessCount(TBool aPause, TBool aDisplayCount, TBool aDisplayList) const |
|
267 { |
|
268 if (aPause) |
|
269 User::After(200000); |
|
270 TInt count=0; |
|
271 TFullName fullName; |
|
272 TFindProcess find(_L("cntsrv*")); |
|
273 if (aDisplayList) |
|
274 iTest->Printf(_L("Lock server process list\n")); |
|
275 while(find.Next(fullName)==KErrNone) |
|
276 { |
|
277 count++; |
|
278 if (aDisplayList) |
|
279 { |
|
280 iTest->Printf(fullName); |
|
281 PrintfNewline(); |
|
282 } |
|
283 } |
|
284 if (aDisplayCount) |
|
285 { |
|
286 iTest->Printf(_L("Process count=%d"),count); |
|
287 PrintfNewline(); |
|
288 } |
|
289 return(count); |
|
290 } |
|
291 |
|
292 EXPORT_C void CCntTest::TestLockServerExists() const |
|
293 { |
|
294 (*iTest)(LockServerProcessCount(EFalse,EFalse,ETrue)==1); |
|
295 } |
|
296 |
|
297 EXPORT_C void CCntTest::TestNoLockServer() const |
|
298 { |
|
299 TInt retries=0; |
|
300 FOREVER |
|
301 { |
|
302 TInt count=LockServerProcessCount(EFalse,EFalse,ETrue); |
|
303 if (count==0) |
|
304 break; |
|
305 if (retries==5) |
|
306 { |
|
307 iTest->Printf(_L("Error lock server count=%d\nPress 't' to try again\n"),count); |
|
308 TChar key=iTest->Getch(); |
|
309 if (key=='t') |
|
310 retries--; |
|
311 else |
|
312 (*iTest)(EFalse); |
|
313 } |
|
314 User::After(100000); |
|
315 retries++; |
|
316 } |
|
317 } |
|
318 |
|
319 |
|
320 EXPORT_C void CCntTest::TestLockServerCloses() const |
|
321 { |
|
322 // Contacts Lock Server waits 5sec from last client until shutdown |
|
323 TInt time = 0; |
|
324 TInt count = LockServerProcessCount(); |
|
325 |
|
326 while (count) |
|
327 { |
|
328 if (time > 55) |
|
329 { // 5.5 sec - too slow |
|
330 (*iTest)(EFalse); |
|
331 } |
|
332 // wait a 1/10th second, then count again |
|
333 User::After(100000); |
|
334 time++; |
|
335 count = LockServerProcessCount(); |
|
336 } |
|
337 } |
|
338 |
|
339 |
|
340 /* |
|
341 The RDebug::Profile APIs are removed from secure builds using |
|
342 the __SECURE_API__ macro. |
|
343 |
|
344 Although the APIs are present in EKA2, the EKA2 macro has been |
|
345 used because the implementation of the RDebug::Profile APIs |
|
346 does not do anything in EKA2. |
|
347 |
|
348 In EKA2 |
|
349 TCntProfileTls is stored in 'Thread Local Storage' and contains |
|
350 a TTime, used to store the time when ProfileStart() is called |
|
351 and a TCntProfile, used to store the time elapsed and to count |
|
352 the pairs of calls to ProfileStart() and ProfileEnd(). |
|
353 Only 1 'Profile Bin' can be used in EKA2 with this approach. |
|
354 |
|
355 The 'Thread Local Storage' is stored on the heap so therfore |
|
356 if a call to ProfileStart() is made then it must be followed |
|
357 by a call to either ProfileReset() or ProfileResult() to ensure |
|
358 the memory is freed |
|
359 */ |
|
360 |
|
361 EXPORT_C TInt CCntTest::ProfileResult(TCntProfile* aProfile,TInt,TInt) |
|
362 { |
|
363 TCntProfileTls* tls = (TCntProfileTls*)Dll::Tls(); |
|
364 if(!tls) |
|
365 { |
|
366 // The tls has not been created |
|
367 // do nothing |
|
368 } |
|
369 else |
|
370 { |
|
371 *aProfile = tls->iProfile; |
|
372 delete tls; |
|
373 Dll::FreeTls(); |
|
374 } |
|
375 return KErrNone; |
|
376 } |
|
377 |
|
378 EXPORT_C TInt CCntTest::ProfileReset(TInt,TInt) |
|
379 { |
|
380 // Always exit with no tls allocated |
|
381 TCntProfileTls* tls = (TCntProfileTls*)Dll::Tls(); |
|
382 if(!tls) |
|
383 { |
|
384 // The tls has not been created |
|
385 // do nothing |
|
386 } |
|
387 else |
|
388 { |
|
389 delete tls; |
|
390 Dll::FreeTls(); |
|
391 } |
|
392 return KErrNone; |
|
393 } |
|
394 |
|
395 EXPORT_C TInt CCntTest::ProfileStart(TInt) |
|
396 { |
|
397 TCntProfileTls* tls = (TCntProfileTls*)Dll::Tls(); |
|
398 if(!tls) |
|
399 { |
|
400 tls = new (ELeave) TCntProfileTls(); |
|
401 Dll::SetTls(tls); |
|
402 tls->iProfile.iTime = 0; |
|
403 tls->iProfile.iCount = 0; |
|
404 } |
|
405 ++tls->iProfile.iCount; |
|
406 tls->iTime.UniversalTime(); |
|
407 return KErrNone; |
|
408 } |
|
409 |
|
410 EXPORT_C TInt CCntTest::ProfileEnd(TInt) |
|
411 { |
|
412 TCntProfileTls* tls = (TCntProfileTls*)Dll::Tls(); |
|
413 if(!tls) |
|
414 { |
|
415 // The tls has not been created |
|
416 // do nothing |
|
417 } |
|
418 else |
|
419 { |
|
420 TTime myTime; |
|
421 myTime.UniversalTime(); |
|
422 tls->iProfile.iTime += ((myTime).MicroSecondsFrom(tls->iTime)).Int64(); |
|
423 } |
|
424 return KErrNone; |
|
425 } |
|
426 |
|
427 /* |
|
428 The RDebug::Profile APIs are present and working on EKA1 (keep these for when |
|
429 this functionality is reinstated for EKA2. |
|
430 |
|
431 |
|
432 |
|
433 EXPORT_C TInt CCntTest::ProfileResult(TCntProfile* aProfile,TInt aStart,TInt aCount) |
|
434 { |
|
435 TProfile* p = reinterpret_cast<TProfile*>(&aProfile[0]); |
|
436 const TInt result = RDebug::ProfileResult(p,aStart,aCount); |
|
437 return result; |
|
438 } |
|
439 |
|
440 EXPORT_C TInt CCntTest::ProfileReset(TInt aStart,TInt aCount) |
|
441 { |
|
442 return RDebug::ProfileReset(aStart, aCount); |
|
443 } |
|
444 |
|
445 EXPORT_C TInt CCntTest::ProfileStart(TInt aProfile) |
|
446 { |
|
447 return RDebug::ProfileStart(aProfile); |
|
448 } |
|
449 |
|
450 EXPORT_C TInt CCntTest::ProfileEnd(TInt aProfile) |
|
451 { |
|
452 return RDebug::ProfileEnd(aProfile); |
|
453 } |
|
454 */ |
|
455 |
|
456 |
|
457 EXPORT_C TBool TestGroupStateL(CContactDatabase* aDb, TInt aGroupCount, TInt aGroupEntryCount) |
|
458 { |
|
459 CContactIdArray* groupIdList=aDb->GetGroupIdListL(); |
|
460 CleanupStack::PushL(groupIdList); |
|
461 TInt groupCount=groupIdList->Count(); |
|
462 if (aGroupCount>=0 && groupCount!=aGroupCount) |
|
463 return(EFalse); |
|
464 TInt groupEntryCount=0; |
|
465 // Cross check that all contacts think they are in all the groups that think they contain the contact |
|
466 for(TInt groupIndex=0;groupIndex<groupCount;groupIndex++) |
|
467 { |
|
468 TContactItemId groupId=(*groupIdList)[groupIndex]; |
|
469 CContactGroup *group=(CContactGroup *)aDb->ReadContactLC(groupId); |
|
470 const CContactIdArray* itemsContained=group->ItemsContained(); |
|
471 TInt itemCount=itemsContained->Count(); |
|
472 groupEntryCount+=itemCount; |
|
473 for (TInt itemLoop=0;itemLoop<itemCount;itemLoop++) |
|
474 { |
|
475 CContactItemPlusGroup *contact=(CContactItemPlusGroup*)aDb->ReadContactLC((*itemsContained)[itemLoop]); |
|
476 CContactIdArray* groupsJoined=contact->GroupsJoinedLC(); |
|
477 TInt groupsJoinedLoop=0; |
|
478 for (;groupsJoinedLoop<groupsJoined->Count();groupsJoinedLoop++) |
|
479 { |
|
480 if ((*groupsJoined)[groupsJoinedLoop]==groupId) |
|
481 break; |
|
482 } |
|
483 if (groupsJoinedLoop==groupsJoined->Count()) |
|
484 return(EFalse); |
|
485 CleanupStack::PopAndDestroy(2,contact); |
|
486 } |
|
487 CleanupStack::PopAndDestroy(group); |
|
488 } |
|
489 if (aGroupEntryCount>=0 && groupEntryCount!=aGroupEntryCount) |
|
490 return(EFalse); |
|
491 CleanupStack::PopAndDestroy(groupIdList); |
|
492 // Now cross check the other way, |
|
493 const CContactIdArray* contacts=aDb->SortedItemsL(); |
|
494 for(TInt contactIndex=0;contactIndex<contacts->Count();contactIndex++) |
|
495 { |
|
496 TContactItemId contactId=(*contacts)[contactIndex]; |
|
497 CContactItemPlusGroup *item=(CContactItemPlusGroup*)aDb->ReadContactLC(contactId); |
|
498 CContactIdArray* groupsJoined=item->GroupsJoinedLC(); |
|
499 for (TInt groupsJoinedLoop=0;groupsJoinedLoop<groupsJoined->Count();groupsJoinedLoop++) |
|
500 { |
|
501 CContactGroup *group=(CContactGroup *)aDb->ReadContactLC((*groupsJoined)[groupsJoinedLoop]); |
|
502 const CContactIdArray* itemsContained=group->ItemsContained(); |
|
503 TInt itemsCount=itemsContained->Count(); |
|
504 TInt itemLoop=0; |
|
505 for (;itemLoop<itemsCount;itemLoop++) |
|
506 { |
|
507 if ((*itemsContained)[itemLoop]==contactId) |
|
508 break; |
|
509 } |
|
510 if (itemLoop==itemsCount) |
|
511 return(EFalse); |
|
512 CleanupStack::PopAndDestroy(group); |
|
513 } |
|
514 CleanupStack::PopAndDestroy(2,item); |
|
515 } |
|
516 return(ETrue); |
|
517 } |
|
518 |
|
519 // |
|
520 // Misc Util functions |
|
521 // |
|
522 |
|
523 EXPORT_C void CleanUpResetAndDestroy(TAny *aArray) |
|
524 { |
|
525 if (aArray) |
|
526 { |
|
527 CArrayPtr<CContactItem>* array=(CArrayPtr<CContactItem>*)aArray; |
|
528 array->ResetAndDestroy(); |
|
529 delete array; |
|
530 } |
|
531 } |
|
532 |
|
533 EXPORT_C TPtrC FieldText(CContactItem& aItem,TUid aType) |
|
534 { |
|
535 CContactItemFieldSet& fieldSet=aItem.CardFields(); |
|
536 const TInt pos=fieldSet.Find(aType); |
|
537 if (pos==KErrNotFound || fieldSet[pos].StorageType()!=KStorageTypeText) |
|
538 return _L(""); |
|
539 return fieldSet[pos].TextStorage()->Text(); |
|
540 } |
|
541 |
|
542 EXPORT_C void SetNameL(CContactItem& aItem,TUid aFieldType,TUid aMapping, const TDesC& aName, TBool aAddEntry) |
|
543 // |
|
544 // Set the contents of a text field, creating the field if required |
|
545 // |
|
546 { |
|
547 TInt pos=KErrNotFound; |
|
548 if (!aAddEntry) |
|
549 { |
|
550 CContactItemFieldSet& fieldSet=aItem.CardFields(); |
|
551 pos=fieldSet.Find(aFieldType); |
|
552 if (pos!=KErrNotFound) |
|
553 fieldSet[pos].TextStorage()->SetTextL(aName); |
|
554 } |
|
555 if (pos==KErrNotFound) |
|
556 { |
|
557 CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aFieldType); |
|
558 field->SetMapping(aMapping); |
|
559 field->TextStorage()->SetTextL(aName); |
|
560 aItem.AddFieldL(*field); |
|
561 CleanupStack::Pop(); // item |
|
562 } |
|
563 } |
|
564 |
|
565 EXPORT_C void SetUserFlags(CContactItemFieldSet& aFieldSet, TUint aFlags, TInt aIndex) |
|
566 { |
|
567 aFieldSet[aIndex].SetUserFlags(aFlags); |
|
568 } |
|
569 |
|
570 EXPORT_C void SetUserFlags(CContactItemFieldSet& aFieldSet, TUint aFlags) |
|
571 { |
|
572 SetUserFlags(aFieldSet,aFlags,aFieldSet.Count()-1); |
|
573 } |
|
574 |
|
575 EXPORT_C void SetUserFlags(CContactItem* aItem, TUint aFlags, TInt aIndex) |
|
576 { |
|
577 SetUserFlags(aItem->CardFields(),aFlags,aIndex); |
|
578 } |
|
579 |
|
580 EXPORT_C void SetUserFlags(CContactItem* aItem, TUint aFlags) |
|
581 { |
|
582 SetUserFlags(aItem->CardFields(),aFlags); |
|
583 } |
|
584 |
|
585 EXPORT_C void AddFieldL(CContactItemFieldSet* aFieldSet, TStorageType aType,TFieldType aFieldType,TUid aMapping) |
|
586 { |
|
587 CContactItemField* field=CContactItemField::NewLC(aType,aFieldType); |
|
588 field->SetMapping(aMapping); |
|
589 aFieldSet->AddL(*field); |
|
590 CleanupStack::Pop(); // field |
|
591 } |
|
592 |
|
593 EXPORT_C void AddFieldL(CContactItem* aItem, TStorageType aType,TFieldType aFieldType,TUid aMapping) |
|
594 { |
|
595 CContactItemField* field=CContactItemField::NewLC(aType,aFieldType); |
|
596 field->SetMapping(aMapping); |
|
597 aItem->AddFieldL(*field); |
|
598 CleanupStack::Pop(); // field |
|
599 } |
|
600 |
|
601 EXPORT_C void InsertFieldL(CContactItem& aItem, TInt aPos, TStorageType aType,TFieldType aFieldType,TUid aMapping) |
|
602 { |
|
603 CContactItemField* field=CContactItemField::NewLC(aType,aFieldType); |
|
604 field->SetMapping(aMapping); |
|
605 aItem.InsertFieldL(*field,aPos); |
|
606 CleanupStack::Pop(); // field |
|
607 } |
|
608 |
|
609 EXPORT_C void InsertFieldL(CContactItem& aItem, TInt aPos, TStorageType aType,TFieldType aFieldType,TUid aMapping, const TDesC& aText) |
|
610 { |
|
611 CContactItemField* field=CContactItemField::NewLC(aType,aFieldType); |
|
612 field->SetMapping(aMapping); |
|
613 aItem.InsertFieldL(*field,aPos); |
|
614 field->TextStorage()->SetTextL(aText); |
|
615 CleanupStack::Pop(); // field |
|
616 } |
|
617 |
|
618 EXPORT_C TContactItemId AddContactL(CContactDatabase* aDb, TFieldType aFieldType,TUid aMapping, const TDesC &aText) |
|
619 { |
|
620 CContactCard *item=CContactCard::NewLC(); |
|
621 SetNameL(*item,aFieldType,aMapping,aText,ETrue); |
|
622 TContactItemId id=aDb->AddNewContactL(*item); |
|
623 CleanupStack::PopAndDestroy(); // item |
|
624 return(id); |
|
625 } |
|
626 |
|
627 EXPORT_C CVCardTestStore* ExportContactsL(CContactDatabase* aDb, const CContactIdArray *aIds, TUint aFormatFlags, TVCardStoreType aType, RFs *aFs, TInt aFileNum) |
|
628 { |
|
629 CVCardTestStore* store=CVCardTestStore::NewLC(aType,aFs,aFileNum); |
|
630 RStoreWriteStream outstream; |
|
631 TStreamId streamId=outstream.CreateLC(*store->Store()); |
|
632 TUid uid; |
|
633 uid.iUid=KUidVCardConvDefaultImpl; |
|
634 aDb->ExportSelectedContactsL(uid,*aIds,outstream,aFormatFlags); |
|
635 outstream.CommitL(); |
|
636 store->SetStreamId(streamId); |
|
637 store->Store()->CommitL(); |
|
638 CleanupStack::PopAndDestroy(); // outstream |
|
639 CleanupStack::Pop(); // store |
|
640 return(store); |
|
641 } |
|
642 |
|
643 EXPORT_C CArrayPtr<CContactItem>* ImportContactsL(CContactDatabase* aDb, CVCardTestStore* aStore, TUint aFormatFlags) |
|
644 { |
|
645 RStoreReadStream instream; |
|
646 instream.OpenLC(*aStore->Store(),aStore->StreamId()); |
|
647 TBool success=EFalse; |
|
648 CArrayPtr<CContactItem>* items=aDb->ImportContactsL(TUid::Uid(KUidVCardConvDefaultImpl),instream,success,aFormatFlags); |
|
649 CleanupStack::PopAndDestroy(); // instream |
|
650 return(items); |
|
651 } |
|
652 |
|
653 EXPORT_C TBool CompareItemField(const CContactItemField &aItemField1, const CContactItemField &aItemField2, TBool aCheckStorage) |
|
654 { |
|
655 if (aItemField1.StorageType()!=aItemField2.StorageType()) |
|
656 return(EFalse); |
|
657 TInt count=aItemField1.ContentType().FieldTypeCount(); |
|
658 if (count!=aItemField2.ContentType().FieldTypeCount()) |
|
659 return(EFalse); |
|
660 for(TInt loop=0;loop<count;loop++) |
|
661 if (!aItemField2.ContentType().ContainsFieldType(aItemField1.ContentType().FieldType(loop))) |
|
662 return(EFalse); |
|
663 if (aItemField1.StorageType()!=aItemField2.StorageType()) |
|
664 return(EFalse); |
|
665 if (aItemField1.Label()!=aItemField2.Label()) |
|
666 return(EFalse); |
|
667 if (aItemField1.IsHidden()!=aItemField2.IsHidden()) |
|
668 return(EFalse); |
|
669 if (aItemField1.IsReadOnly()!=aItemField2.IsReadOnly()) |
|
670 return(EFalse); |
|
671 if (aItemField1.IsDisabled()!=aItemField2.IsDisabled()) |
|
672 return(EFalse); |
|
673 if (aItemField1.UserFlags()!=aItemField2.UserFlags()) |
|
674 return(EFalse); |
|
675 if (aCheckStorage) |
|
676 { |
|
677 switch(aItemField1.StorageType()) |
|
678 { |
|
679 case KStorageTypeText: |
|
680 { |
|
681 TPtrC f1=aItemField1.TextStorage()->Text(); |
|
682 TPtrC f2=aItemField2.TextStorage()->Text(); |
|
683 TInt len=f1.Length(); |
|
684 if (len==f2.Length()+1 && f1[0]==' ') |
|
685 f1.Set(&f1[1],len-1); |
|
686 //if (aItemField1.TextStorage()->Text()!=aItemField2.TextStorage()->Text()) |
|
687 if (f1!=f2) |
|
688 return(EFalse); |
|
689 break; |
|
690 } |
|
691 case KStorageTypeStore: |
|
692 break; |
|
693 case KStorageTypeContactItemId: |
|
694 break; |
|
695 case KStorageTypeDateTime: |
|
696 if (aItemField1.DateTimeStorage()->Time()!=aItemField2.DateTimeStorage()->Time()) |
|
697 return(EFalse); |
|
698 break; |
|
699 } |
|
700 } |
|
701 return(ETrue); |
|
702 } |
|
703 |
|
704 EXPORT_C TBool CompareItemFields(CContactItem *aItem1, CContactItem *aItem2, TBool aCheckStorage, TBool aTemplateLabelRemoved) |
|
705 { |
|
706 CContactItemFieldSet& fieldSet1 = aItem1->CardFields(); |
|
707 CContactItemFieldSet& fieldSet2 = aItem2->CardFields(); |
|
708 TInt count = fieldSet1.Count(); |
|
709 TInt check = aTemplateLabelRemoved?count-1:count; |
|
710 if (check != fieldSet2.Count()) |
|
711 { |
|
712 return(EFalse); |
|
713 } |
|
714 |
|
715 for(TInt loop=0;loop<count;loop++) |
|
716 { |
|
717 const CContactItemField &field1 = fieldSet1[loop]; |
|
718 if (aTemplateLabelRemoved && field1.ContentType().ContainsFieldType(KUidContactFieldTemplateLabel)) |
|
719 { |
|
720 continue; |
|
721 } |
|
722 |
|
723 TBool found(EFalse); |
|
724 for(TInt loop2 = 0; loop2 < count; loop2++) |
|
725 { |
|
726 found = CompareItemField(field1, fieldSet2[loop2], aCheckStorage); |
|
727 if(found) |
|
728 { |
|
729 break; |
|
730 } |
|
731 } |
|
732 |
|
733 if(!found) |
|
734 { |
|
735 return EFalse; |
|
736 } |
|
737 } |
|
738 return(ETrue); |
|
739 } |
|
740 |
|
741 // This was originally created as the database files were going to reside in |
|
742 // the SQLite private directory. However, the file is now to be stored in the |
|
743 // contacts model private directory like the old DBMS file. So this is now a |
|
744 // bit redundant and perhaps could be removed at some point. |
|
745 _LIT(KSqlServerPrivateDir, "\\private\\10003A73\\"); |
|
746 |
|
747 EXPORT_C HBufC* GetFullDbName(const TDesC& aDbName) |
|
748 { |
|
749 TParse parse; |
|
750 parse.Set(aDbName, &KSqlServerPrivateDir(), 0); |
|
751 return parse.FullName().Alloc(); |
|
752 } |
|
753 |
|
754 // |
|
755 // CVCardTestStore |
|
756 // |
|
757 |
|
758 EXPORT_C CVCardTestStore* CVCardTestStore::NewLC(TVCardStoreType aType, RFs *aFs, TInt aFileNum) |
|
759 { |
|
760 CVCardTestStore* store=CVCardTestStore::NewL(aType,aFs,aFileNum); |
|
761 CleanupStack::PushL(store); |
|
762 return(store); |
|
763 } |
|
764 |
|
765 EXPORT_C CVCardTestStore* CVCardTestStore::NewL(TVCardStoreType aType, RFs *aFs, TInt aFileNum) |
|
766 { |
|
767 CVCardTestStore* store=new(ELeave) CVCardTestStore(); |
|
768 store->ConstructL(aType,aFs, aFileNum); |
|
769 return(store); |
|
770 } |
|
771 |
|
772 EXPORT_C CVCardTestStore::~CVCardTestStore() |
|
773 { |
|
774 delete iBufStore; |
|
775 delete iFileStore; |
|
776 } |
|
777 |
|
778 EXPORT_C void CVCardTestStore::ConstructL(TVCardStoreType aType, RFs *aFs, TInt aFileNum) |
|
779 { |
|
780 iType=aType; |
|
781 switch(iType) |
|
782 { |
|
783 case KVCardStoreTypeBuf: |
|
784 iBufStore=CBufStore::NewL(256); |
|
785 break; |
|
786 case KVCardStoreTypeFile: |
|
787 { |
|
788 aFs->MkDirAll(_L("c:\\vcards\\")); |
|
789 TFileName fileName; |
|
790 fileName.Format(_L("c:\\vcards\\VCard%04d"),aFileNum); |
|
791 iFileStore=CDirectFileStore::ReplaceL(*aFs,fileName,EFileWrite); |
|
792 iFileStore->SetTypeL(KDirectFileStoreLayoutUid); |
|
793 } |
|
794 break; |
|
795 } |
|
796 } |
|
797 |
|
798 EXPORT_C CStreamStore *CVCardTestStore::Store() const |
|
799 { |
|
800 CStreamStore *store=NULL; |
|
801 switch(iType) |
|
802 { |
|
803 case KVCardStoreTypeBuf: |
|
804 store=iBufStore; |
|
805 break; |
|
806 case KVCardStoreTypeFile: |
|
807 store=iFileStore; |
|
808 break; |
|
809 } |
|
810 return(store); |
|
811 } |
|
812 |
|
813 // |
|
814 |
|
815 // |
|
816 // TCntPerfTimer |
|
817 // |
|
818 |
|
819 EXPORT_C TCntPerfTimer::TCntPerfTimer() |
|
820 : iTickCount1(0), iTickCount2(0) |
|
821 { |
|
822 } |
|
823 |
|
824 EXPORT_C void TCntPerfTimer::StartTimer() |
|
825 { |
|
826 iTickCount1 = User::NTickCount(); |
|
827 } |
|
828 |
|
829 EXPORT_C void TCntPerfTimer::StopTimer() |
|
830 { |
|
831 iTickCount2 = User::NTickCount(); |
|
832 } |
|
833 |
|
834 EXPORT_C void TCntPerfTimer::ResetTimer() |
|
835 { |
|
836 iTickCount1 = 0; |
|
837 iTickCount2 = 0; |
|
838 } |
|
839 |
|
840 EXPORT_C TUint TCntPerfTimer::Result() |
|
841 { |
|
842 TInt tickPeriodMicroSeconds; |
|
843 HAL::Get(HAL::ENanoTickPeriod, tickPeriodMicroSeconds); |
|
844 TUint result(0); |
|
845 if (iTickCount1 > 0 && iTickCount2 > iTickCount1) |
|
846 { |
|
847 result = (iTickCount2 - iTickCount1) * tickPeriodMicroSeconds; |
|
848 } |
|
849 return result; |
|
850 } |
|
851 |
|
852 |
|
853 EXPORT_C TBool DbShouldBeInDamagedState(CContactDatabase* aDb) |
|
854 { |
|
855 TBool isDamaged(aDb->IsDamaged()); |
|
856 #ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ |
|
857 return isDamaged; |
|
858 #else |
|
859 return ETrue; |
|
860 #endif |
|
861 } |
|
862 |
|
863 EXPORT_C CContactItem* ReadContactFromDamagedDbLC(CContactDatabase* aDb, TContactItemId aContactId) |
|
864 { |
|
865 CContactItem* item(aDb->ReadContactLC(aContactId) ); |
|
866 #ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ |
|
867 return item; |
|
868 #else |
|
869 User::Leave(KErrNotReady); |
|
870 return NULL; |
|
871 #endif |
|
872 } |