61 // --------------------------------------------------------- |
62 // --------------------------------------------------------- |
62 CVIMPSTEngine* CVIMPSTEngine::NewL( |
63 CVIMPSTEngine* CVIMPSTEngine::NewL( |
63 TUint32 aServiceId, |
64 TUint32 aServiceId, |
64 CVIMPSTEngineServiceTableFetcher& aTableFetcher ) |
65 CVIMPSTEngineServiceTableFetcher& aTableFetcher ) |
65 { |
66 { |
66 TRACE( T_LIT("CVIMPSTEngine::NewL start") ); |
67 TRACER_AUTO; |
67 TRACE( T_LIT("NewL() ServiceId: %d"), aServiceId ); |
68 TRACE("ServiceId: %d", aServiceId); |
68 |
69 |
69 |
70 |
70 CVIMPSTEngine* self = CVIMPSTEngine::NewLC( aServiceId, |
71 CVIMPSTEngine* self = CVIMPSTEngine::NewLC( aServiceId, |
71 aTableFetcher ); |
72 aTableFetcher ); |
72 CleanupStack::Pop( self ); |
73 CleanupStack::Pop( self ); |
73 |
74 |
74 TRACE( T_LIT("CVIMPSTEngine::NewL end") ); |
|
75 return self; |
75 return self; |
76 } |
76 } |
77 |
77 |
78 |
78 |
79 // --------------------------------------------------------- |
79 // --------------------------------------------------------- |
82 // --------------------------------------------------------- |
82 // --------------------------------------------------------- |
83 |
83 |
84 CVIMPSTEngine* CVIMPSTEngine::NewLC( |
84 CVIMPSTEngine* CVIMPSTEngine::NewLC( |
85 TUint32 aServiceId, |
85 TUint32 aServiceId, |
86 CVIMPSTEngineServiceTableFetcher& aTableFetcher ) |
86 CVIMPSTEngineServiceTableFetcher& aTableFetcher ) |
87 { |
87 { |
88 TRACE( T_LIT("CVIMPSTEngine::NewLC start") ); |
88 TRACER_AUTO; |
89 TRACE( T_LIT("NewLC() ServiceId: %d"), aServiceId ); |
89 TRACE( "ServiceId: %d", aServiceId ); |
90 |
90 |
91 CVIMPSTEngine* self = new (ELeave) CVIMPSTEngine( |
91 CVIMPSTEngine* self = new (ELeave) CVIMPSTEngine( |
92 aServiceId, |
92 aServiceId, |
93 aTableFetcher ); |
93 aTableFetcher ); |
94 CleanupStack::PushL( self ); |
94 CleanupStack::PushL( self ); |
95 self->ConstructL( aServiceId ); |
95 self->ConstructL( aServiceId ); |
96 |
96 |
97 TRACE( T_LIT("CVIMPSTEngine::NewLC end") ); |
|
98 return self; |
97 return self; |
99 } |
98 } |
100 |
99 |
101 // --------------------------------------------------------- |
100 // --------------------------------------------------------- |
102 // CVIMPSTEngine::~CVIMPSTEngine |
101 // CVIMPSTEngine::~CVIMPSTEngine |
103 // |
102 // |
104 // --------------------------------------------------------- |
103 // --------------------------------------------------------- |
105 |
104 |
106 CVIMPSTEngine::~CVIMPSTEngine() |
105 CVIMPSTEngine::~CVIMPSTEngine() |
107 { |
106 { |
108 TRACE( T_LIT("CVIMPSTEngine::~CVIMPSTEngine start") ); |
107 TRACER_AUTO; |
109 |
108 |
110 iObserverArray.Reset(); |
109 iObserverArray.Reset(); |
111 iObserverArray.Close(); |
110 iObserverArray.Close(); |
112 |
111 |
113 iSubService.ResetAndDestroy(); |
112 iSubService.ResetAndDestroy(); |
120 iExtentionFeatures.Close(); |
119 iExtentionFeatures.Close(); |
121 |
120 |
122 delete iCchHandler; |
121 delete iCchHandler; |
123 iCchHandler = NULL; |
122 iCchHandler = NULL; |
124 |
123 |
125 TRACE( T_LIT("CVIMPSTEngine::~CVIMPSTEngine end") ); |
124 |
126 } |
125 } |
127 |
126 |
128 |
127 |
129 // --------------------------------------------------------- |
128 // --------------------------------------------------------- |
130 // CVIMPSTEngine::ConstructL |
129 // CVIMPSTEngine::ConstructL |
131 // |
130 // |
132 // --------------------------------------------------------- |
131 // --------------------------------------------------------- |
133 |
132 |
134 void CVIMPSTEngine::ConstructL( TUint32 aServiceId ) |
133 void CVIMPSTEngine::ConstructL( TUint32 aServiceId ) |
135 { |
134 { |
136 TRACE( T_LIT("CVIMPSTEngine::ConstructL start") ); |
135 TRACER_AUTO; |
137 TRACE( T_LIT("ConstructL() - ServiceId: %d"), aServiceId ); |
136 TRACE( "ServiceId: %d", aServiceId ); |
138 |
137 |
139 iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength ); |
138 iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength ); |
140 |
139 |
141 // construct the service state by passing the array of subservices. |
140 // construct the service state by passing the array of subservices. |
142 iCchHandler = CVIMPSTEngineCchHandler::NewL(iServiceId,*this); |
141 iCchHandler = CVIMPSTEngineCchHandler::NewL(iServiceId,*this); |
158 //if either of Presence/IM Subservice supported then we need |
157 //if either of Presence/IM Subservice supported then we need |
159 //to bind to XIMP context. |
158 //to bind to XIMP context. |
160 if ( KErrNotFound != ximpAdapterUid && requireXimp ) |
159 if ( KErrNotFound != ximpAdapterUid && requireXimp ) |
161 { |
160 { |
162 TRAPD( err, (iSessionCntxtObserver = CVIMPSTEngineSessionCntxtObserver::NewL(aServiceId))); |
161 TRAPD( err, (iSessionCntxtObserver = CVIMPSTEngineSessionCntxtObserver::NewL(aServiceId))); |
163 TRACE( T_LIT("ConstructL() -1st Creating session context observer: %d"), err ); |
162 TRACE( "1st Creating session context observer: %d", err ); |
164 if (KErrNotFound == err) |
163 if (KErrNotFound == err) |
165 { |
164 { |
166 TRACE( T_LIT("Ximp impl not found. Calling Logout") ); |
165 TRACE( "Ximp impl not found. Calling Logout" ); |
167 iUnInstall = ETrue; |
166 iUnInstall = ETrue; |
168 LogoutL(); |
167 LogoutL(); |
169 TRACE( T_LIT("Logout Called on account of uninstall") ); |
168 TRACE( "Logout Called on account of uninstall" ); |
170 return; |
169 return; |
171 } |
170 } |
172 } |
171 } |
173 |
172 |
174 // iterate the service array |
173 // iterate the service array |
264 iCchHandler->DisableService(); |
262 iCchHandler->DisableService(); |
265 User::LeaveIfError(err); |
263 User::LeaveIfError(err); |
266 } |
264 } |
267 SetExtentionFeaturesSupportedL(); |
265 SetExtentionFeaturesSupportedL(); |
268 } |
266 } |
269 TRACE( T_LIT("CVIMPSTEngine::RetriveContextIfCChEnabledL end")); |
267 |
270 } |
268 } |
271 |
269 |
272 // --------------------------------------------------------- |
270 // --------------------------------------------------------- |
273 // CVIMPSTEngine::LoginL |
271 // CVIMPSTEngine::LoginL |
274 // |
272 // |
275 // --------------------------------------------------------- |
273 // --------------------------------------------------------- |
276 TInt CVIMPSTEngine::Login() |
274 TInt CVIMPSTEngine::Login() |
277 { |
275 { |
278 TRACE( T_LIT("CVIMPSTEngine::ConstructL start") ); |
276 TRACER_AUTO; |
279 TRACE( T_LIT("Login() - ServiceId: %d"), iServiceId ); |
277 TRACE( "ServiceId: %d", iServiceId ); |
280 |
278 |
281 TInt error = KErrNotFound; |
279 TInt error = KErrNotFound; |
282 if(iCchHandler) |
280 if(iCchHandler) |
283 { |
281 { |
284 TRACE( T_LIT("Login() - EnableService Called")); |
282 TRACE( "EnableService Called"); |
285 error = iCchHandler->EnableService(); |
283 error = iCchHandler->EnableService(); |
286 } |
284 } |
287 |
285 |
288 TRACE( T_LIT("Login - error: %d"), error ); |
286 TRACE( "error: %d", error ); |
289 TRACE( T_LIT("CVIMPSTEngine::Login")); |
|
290 |
287 |
291 return error; |
288 return error; |
292 } |
289 } |
293 |
290 |
294 |
291 |
319 } |
316 } |
320 //if either of Presence/IM Subservice supported then we need |
317 //if either of Presence/IM Subservice supported then we need |
321 //to unbind to XIMP context. |
318 //to unbind to XIMP context. |
322 if( iSessionCntxtObserver ) |
319 if( iSessionCntxtObserver ) |
323 { |
320 { |
324 TRACE( T_LIT("Logout() - ServerUnBindL Called")); |
321 TRACE( "ServerUnBindL Called"); |
325 iSessionCntxtObserver->ServerUnBindL(ETrue); |
322 iSessionCntxtObserver->ServerUnBindL(ETrue); |
326 } |
323 } |
327 TRACE( T_LIT("Logout() - DisableService Called")); |
324 TRACE(" DisableService Called"); |
328 iCchHandler->DisableService(); |
325 iCchHandler->DisableService(); |
329 } |
326 } |
330 TRACE( T_LIT("CVIMPSTEngine::Logout")); |
327 |
331 } |
328 } |
332 |
329 |
333 |
330 |
334 // --------------------------------------------------------- |
331 // --------------------------------------------------------- |
335 // CVIMPSTEngine::ServiceId |
332 // CVIMPSTEngine::ServiceId |
336 // |
333 // |
337 // --------------------------------------------------------- |
334 // --------------------------------------------------------- |
338 TUint32 CVIMPSTEngine::ServiceId() const |
335 TUint32 CVIMPSTEngine::ServiceId() const |
339 { |
336 { |
340 TRACE( T_LIT("ServiceId() - ServiceId: %d"), iServiceId ); |
337 TRACER_AUTO; |
|
338 TRACE( "ServiceId: %d", iServiceId ); |
341 return iServiceId; |
339 return iServiceId; |
342 } |
340 } |
343 |
341 |
344 |
342 |
345 // --------------------------------------------------------- |
343 // --------------------------------------------------------- |
346 // CVIMPSTEngine::ServiceName |
344 // CVIMPSTEngine::ServiceName |
347 // |
345 // |
348 // --------------------------------------------------------- |
346 // --------------------------------------------------------- |
349 const TDesC& CVIMPSTEngine::ServiceName() const |
347 const TDesC& CVIMPSTEngine::ServiceName() const |
350 { |
348 { |
|
349 TRACER_AUTO; |
351 TPtr serviceNamePtr = iServiceName->Des(); |
350 TPtr serviceNamePtr = iServiceName->Des(); |
352 TRACE( T_LIT("ServiceName() - ServiceName: '%S'"), &serviceNamePtr ); |
351 TRACE( "ServiceName: '%S'", &serviceNamePtr ); |
353 return *iServiceName; |
352 return *iServiceName; |
354 } |
353 } |
355 |
354 |
356 // --------------------------------------------------------- |
355 // --------------------------------------------------------- |
357 // CVIMPSTEngine::ServiceState |
356 // CVIMPSTEngine::ServiceState |
358 // |
357 // |
359 // --------------------------------------------------------- |
358 // --------------------------------------------------------- |
360 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ServiceState() const |
359 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ServiceState() const |
361 { |
360 { |
362 TRACE( T_LIT("ServiceState() - ServiceState: %d"), iState ); |
361 TRACER_AUTO; |
|
362 TRACE( "ServiceState: %d", iState ); |
363 return iState; |
363 return iState; |
364 } |
364 } |
365 |
365 |
366 |
366 |
367 // --------------------------------------------------------- |
367 // --------------------------------------------------------- |
370 // --------------------------------------------------------- |
370 // --------------------------------------------------------- |
371 TInt CVIMPSTEngine::GetBrandInfoL(TLanguage& aBrandLanguage, |
371 TInt CVIMPSTEngine::GetBrandInfoL(TLanguage& aBrandLanguage, |
372 TInt &aBrandVersion, TDes8& aBrandId) const |
372 TInt &aBrandVersion, TDes8& aBrandId) const |
373 |
373 |
374 { |
374 { |
375 TRACE( T_LIT("CVIMPSTEngine::GetBrandInfoL start")); |
375 TRACER_AUTO; |
376 TRACE( T_LIT("GetBrandInfoL() - ServiceId: %d"), iServiceId ); |
376 TRACE("ServiceId: %d", iServiceId ); |
377 |
377 |
378 iTableFetcher.GetBrandIdL(iServiceId, aBrandId); |
378 iTableFetcher.GetBrandIdL(iServiceId, aBrandId); |
379 aBrandLanguage = iTableFetcher.PropertyBrandLanguageL(iServiceId); |
379 aBrandLanguage = iTableFetcher.PropertyBrandLanguageL(iServiceId); |
380 aBrandVersion = iTableFetcher.PropertyBrandVersionL(iServiceId); |
380 aBrandVersion = iTableFetcher.PropertyBrandVersionL(iServiceId); |
381 TRACE( T_LIT("CVIMPSTEngine::GetBrandInfoL end")); |
|
382 return KErrNone; |
381 return KErrNone; |
383 } |
382 } |
384 |
383 |
385 |
384 |
386 // --------------------------------------------------------- |
385 // --------------------------------------------------------- |
387 // CVIMPSTEngine::IsSubServiceSupportedL |
386 // CVIMPSTEngine::IsSubServiceSupportedL |
388 // |
387 // |
389 // --------------------------------------------------------- |
388 // --------------------------------------------------------- |
390 TBool CVIMPSTEngine::IsSubServiceSupportedL(TVIMPSTEnums::SubServiceType aType) const |
389 TBool CVIMPSTEngine::IsSubServiceSupportedL(TVIMPSTEnums::SubServiceType aType) const |
391 { |
390 { |
392 |
391 TRACER_AUTO; |
393 TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL start")); |
392 TRACE("ServiceId: %d", iServiceId); |
394 TRACE( T_LIT ("IsSubServiceSupportedL() - ServiceId: %d"), iServiceId); |
393 TRACE("SubServiceType: %d", aType); |
395 TRACE( T_LIT ("IsSubServiceSupportedL() - SubServiceType: %d"), aType); |
|
396 |
394 |
397 TBool support = EFalse; |
395 TBool support = EFalse; |
398 |
396 |
399 MVIMPSTEngineSubService* subService = SubService(aType); |
397 MVIMPSTEngineSubService* subService = SubService(aType); |
400 if (subService) |
398 if (subService) |
401 { |
399 { |
402 support = ETrue; |
400 support = ETrue; |
403 } |
401 } |
404 |
402 |
405 TRACE( T_LIT("IsSubServiceSupportedL() - support: %d"), support ); |
403 TRACE( "support: %d", support ); |
406 TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL end")); |
|
407 return support; |
404 return support; |
408 |
405 |
409 } |
406 } |
410 |
407 |
411 |
408 |
428 if ( TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() ) |
426 if ( TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() ) |
429 { |
427 { |
430 enabled = ETrue; |
428 enabled = ETrue; |
431 } |
429 } |
432 } |
430 } |
433 TRACE( T_LIT("IsSubServiceEnabled() - enabled: %d"), enabled ); |
431 TRACE( "enabled: %d", enabled ); |
434 TRACE( T_LIT("CVIMPSTEngine::IsSubServiceEnabled end") ); |
|
435 return enabled; |
432 return enabled; |
436 } |
433 } |
437 |
434 |
438 // --------------------------------------------------------- |
435 // --------------------------------------------------------- |
439 // CVIMPSTEngine::GetContactStoreIdL |
436 // CVIMPSTEngine::GetContactStoreIdL |
440 // |
437 // |
441 // --------------------------------------------------------- |
438 // --------------------------------------------------------- |
442 void CVIMPSTEngine::ContactStoreIdL (TDes& aContactStoreId ) const |
439 void CVIMPSTEngine::ContactStoreIdL (TDes& aContactStoreId ) const |
443 { |
440 { |
444 TRACE( T_LIT("CVIMPSTEngine::ContactStoreIdL start")); |
441 TRACER_AUTO; |
445 TRACE( T_LIT("ContactStoreIdL() - ServiceId: %d"), iServiceId ); |
442 TRACE("ServiceId: %d", iServiceId ); |
446 iTableFetcher.GetContactStoreIdL(iServiceId, aContactStoreId); |
443 iTableFetcher.GetContactStoreIdL(iServiceId, aContactStoreId); |
447 TRACE( T_LIT("CVIMPSTEngine::ContactStoreIdL end")); |
444 |
448 } |
445 } |
449 |
446 |
450 // --------------------------------------------------------------------------- |
447 // --------------------------------------------------------------------------- |
451 // CVIMPSTEngine::RegisterServiceSessionObserver() |
448 // CVIMPSTEngine::RegisterServiceSessionObserver() |
452 // --------------------------------------------------------------------------- |
449 // --------------------------------------------------------------------------- |
453 // |
450 // |
454 void CVIMPSTEngine::RegisterServiceSessionObserverL |
451 void CVIMPSTEngine::RegisterServiceSessionObserverL |
455 (MVIMPSTEngineServiceStateEventObserver* aObserver) |
452 (MVIMPSTEngineServiceStateEventObserver* aObserver) |
456 { |
453 { |
457 __ASSERT_ALWAYS(aObserver,User::Leave(KErrArgument)); |
454 TRACER_AUTO; |
458 TRACE( T_LIT("CVIMPSTEngine::RegisterServiceSessionObserverL start")); |
455 __ASSERT_ALWAYS(aObserver,User::Leave(KErrArgument)); |
459 TInt index = iObserverArray.Find(aObserver); |
456 TInt index = iObserverArray.Find(aObserver); |
460 if( index == KErrNotFound ) |
457 if( index == KErrNotFound ) |
461 { |
458 { |
462 iObserverArray.Append( aObserver ); |
459 iObserverArray.Append( aObserver ); |
463 } |
460 } |
464 TRACE( T_LIT("CVIMPSTEngine::RegisterServiceSessionObserverL end")); |
461 |
465 } |
462 } |
466 |
463 |
467 // --------------------------------------------------------------------------- |
464 // --------------------------------------------------------------------------- |
468 // CVIMPSTEngine::UnRegisterServiceSessionObserver() |
465 // CVIMPSTEngine::UnRegisterServiceSessionObserver() |
469 // --------------------------------------------------------------------------- |
466 // --------------------------------------------------------------------------- |
470 // |
467 // |
471 void CVIMPSTEngine::UnRegisterServiceSessionObserver |
468 void CVIMPSTEngine::UnRegisterServiceSessionObserver |
472 (MVIMPSTEngineServiceStateEventObserver* aObserver) |
469 (MVIMPSTEngineServiceStateEventObserver* aObserver) |
473 { |
470 { |
474 TRACE( T_LIT("CVIMPSTEngine::UnRegisterServiceSessionObserverL start")); |
471 |
|
472 TRACER_AUTO; |
475 if(aObserver) |
473 if(aObserver) |
476 { |
474 { |
477 TInt index = iObserverArray.Find(aObserver); |
475 TInt index = iObserverArray.Find(aObserver); |
478 if( index >=0 ) |
476 if( index >=0 ) |
479 { |
477 { |
480 iObserverArray.Remove( index ); |
478 iObserverArray.Remove( index ); |
481 iObserverArray.Compress(); |
479 iObserverArray.Compress(); |
482 } |
480 } |
483 } |
481 } |
484 TRACE( T_LIT("CVIMPSTEngine::UnRegisterServiceSessionObserverL end")); |
482 |
485 } |
483 } |
486 // --------------------------------------------------------- |
484 // --------------------------------------------------------- |
487 // CVIMPSTEngine::IntializeStorage |
485 // CVIMPSTEngine::IntializeStorage |
488 // |
486 // |
489 // --------------------------------------------------------- |
487 // --------------------------------------------------------- |
490 void CVIMPSTEngine::IntializeStorageL() |
488 void CVIMPSTEngine::IntializeStorageL() |
491 { |
489 { |
492 TRACE( T_LIT("CVIMPSTEngine::IntializeStorageL")); |
490 TRACER_AUTO; |
493 TRACE( T_LIT("IntializeStorageL() - ServiceId: %d"), iServiceId ); |
491 TRACE( "ServiceId: %d", iServiceId ); |
494 iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
492 iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
495 if(iContactInterface) |
493 if(iContactInterface) |
496 { |
494 { |
497 iContactInterface->AddObserverL( this ); |
495 iContactInterface->AddObserverL( this ); |
498 MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); |
496 MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); |
513 iContactInterface->SetOwnUserIdL(lastUserName ); |
511 iContactInterface->SetOwnUserIdL(lastUserName ); |
514 } |
512 } |
515 CleanupStack::PopAndDestroy(&lastUserName); //lastUserName |
513 CleanupStack::PopAndDestroy(&lastUserName); //lastUserName |
516 CleanupStack::PopAndDestroy(); //store |
514 CleanupStack::PopAndDestroy(); //store |
517 } |
515 } |
518 TRACE( T_LIT("CVIMPSTEngine::IntializeStorageL") ); |
516 |
519 } |
517 } |
520 // --------------------------------------------------------- |
518 // --------------------------------------------------------- |
521 // CVIMPSTEngine::UnIntializeStorage |
519 // CVIMPSTEngine::UnIntializeStorage |
522 // |
520 // |
523 // --------------------------------------------------------- |
521 // --------------------------------------------------------- |
524 void CVIMPSTEngine::UnIntializeStorage() |
522 void CVIMPSTEngine::UnIntializeStorage() |
525 { |
523 { |
526 TRACE( T_LIT("CVIMPSTEngine::UnIntializeStorage start")); |
524 TRACER_AUTO; |
527 TRACE( T_LIT("UnIntializeStorage() - ServiceId: %d"), iServiceId ); |
525 TRACE( "ServiceId: %d", iServiceId ); |
528 if(iContactInterface) |
526 if(iContactInterface) |
529 { |
527 { |
530 iContactInterface->RemoveObserver( this ); |
528 iContactInterface->RemoveObserver( this ); |
531 } |
529 } |
532 TRACE( T_LIT("CVIMPSTEngine::UnIntializeStorage end")); |
530 |
533 } |
531 } |
534 |
532 |
535 //----------------------------------------------------------------------------- |
533 //----------------------------------------------------------------------------- |
536 // CVIMPSTEngine::SetOwnUserIdIfChangedL |
534 // CVIMPSTEngine::SetOwnUserIdIfChangedL |
537 // ( Other items commented in header ) |
535 // ( Other items commented in header ) |
538 //----------------------------------------------------------------------------- |
536 //----------------------------------------------------------------------------- |
539 void CVIMPSTEngine::SetOwnUserIdIfChangedL(const TDesC& aUserId) |
537 void CVIMPSTEngine::SetOwnUserIdIfChangedL(const TDesC& aUserId) |
540 { |
538 { |
541 TRACE( T_LIT("CVIMPSTEngine::SetOwnUserIdL")); |
539 |
|
540 TRACER_AUTO; |
542 MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); |
541 MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); |
543 RBuf lastUserName; |
542 RBuf lastUserName; |
544 lastUserName.CreateL( KPropertyMaxLength ); |
543 lastUserName.CreateL( KPropertyMaxLength ); |
545 CleanupClosePushL( lastUserName ); |
544 CleanupClosePushL( lastUserName ); |
546 store->GetL( iServiceId, EServiceLastUserName, lastUserName ); |
545 store->GetL( iServiceId, EServiceLastUserName, lastUserName ); |
550 store->SetL(iServiceId, EServiceLastUserName,aUserId); |
549 store->SetL(iServiceId, EServiceLastUserName,aUserId); |
551 iContactInterface->SetOwnUserIdL(aUserId ); |
550 iContactInterface->SetOwnUserIdL(aUserId ); |
552 } |
551 } |
553 CleanupStack::PopAndDestroy(&lastUserName); //lastUserName |
552 CleanupStack::PopAndDestroy(&lastUserName); //lastUserName |
554 CleanupStack::PopAndDestroy(); //store |
553 CleanupStack::PopAndDestroy(); //store |
555 TRACE( T_LIT("CVIMPSTEngine::SetOwnUserIdL")); |
554 |
556 } |
555 } |
557 |
556 |
558 //----------------------------------------------------------------------------- |
557 //----------------------------------------------------------------------------- |
559 // CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL |
558 // CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL |
560 // ( Other items commented in header ) |
559 // ( Other items commented in header ) |
561 //----------------------------------------------------------------------------- |
560 //----------------------------------------------------------------------------- |
562 HBufC* CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL() const |
561 HBufC* CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL() const |
563 { |
562 { |
564 TRACE( T_LIT("CVIMPSTEngine::GetOwnUserIdFromCChL")); |
563 |
565 TRACE( T_LIT("GetOwnUserIdFromCChL() - ServiceId: %d"), iServiceId ); |
564 TRACER_AUTO; |
|
565 TRACE( "ServiceId: %d", iServiceId ); |
566 HBufC* buffer = NULL; |
566 HBufC* buffer = NULL; |
567 if(iCchHandler) |
567 if(iCchHandler) |
568 { |
568 { |
569 // Set userid |
569 // Set userid |
570 buffer = iCchHandler->GetConParametersL(ECchUsername); |
570 buffer = iCchHandler->GetConParametersL(ECchUsername); |
582 // CVIMPSTEngine::SubService |
582 // CVIMPSTEngine::SubService |
583 // ( Other items commented in header ) |
583 // ( Other items commented in header ) |
584 //----------------------------------------------------------------------------- |
584 //----------------------------------------------------------------------------- |
585 MVIMPSTEngineSubService* CVIMPSTEngine::SubService(TVIMPSTEnums::SubServiceType aType) const |
585 MVIMPSTEngineSubService* CVIMPSTEngine::SubService(TVIMPSTEnums::SubServiceType aType) const |
586 { |
586 { |
587 TRACE( T_LIT("CVIMPSTEngine::SubService start")); |
587 TRACER_AUTO; |
588 TRACE( T_LIT("SubService() - ServiceId: %d"), iServiceId ); |
588 TRACE("ServiceId: %d", iServiceId ); |
589 TRACE( T_LIT("SubService() - SubServiceType: %d"), aType ); |
589 TRACE( "SubServiceType: %d", aType ); |
590 |
|
591 TInt subServiceCount = iSubService.Count(); |
590 TInt subServiceCount = iSubService.Count(); |
592 MVIMPSTEngineSubService* subService = NULL; |
591 MVIMPSTEngineSubService* subService = NULL; |
593 |
592 |
594 // iterate the service array |
593 // iterate the service array |
595 for ( TInt index = 0; index < subServiceCount ; index++ ) |
594 for ( TInt index = 0; index < subServiceCount ; index++ ) |
596 { |
595 { |
597 |
596 |
598 if (aType == iSubService[index]->Type()) |
597 if (aType == iSubService[index]->Type()) |
599 { |
598 { |
600 subService = iSubService[index]; |
599 subService = iSubService[index]; |
601 TRACE( T_LIT("SubService() - SubService Found") ); |
600 TRACE("SubService Found"); |
602 break; |
601 break; |
603 } |
602 } |
604 } |
603 } |
605 |
604 |
606 TRACE( T_LIT("CVIMPSTEngine::SubService end")); |
605 |
|
606 |
607 return subService; |
607 return subService; |
608 } |
608 } |
609 |
609 |
610 |
610 |
611 //----------------------------------------------------------------------------- |
611 //----------------------------------------------------------------------------- |
612 // CVIMPSTEngine::ExtentionFeatures |
612 // CVIMPSTEngine::ExtentionFeatures |
613 // ( Other items commented in header ) |
613 // ( Other items commented in header ) |
614 //----------------------------------------------------------------------------- |
614 //----------------------------------------------------------------------------- |
615 MVIMPSTEngineExtentionFeatures* CVIMPSTEngine::ExtentionFeatures(TVIMPSTEnums::ExtentionType aType) const |
615 MVIMPSTEngineExtentionFeatures* CVIMPSTEngine::ExtentionFeatures(TVIMPSTEnums::ExtentionType aType) const |
616 { |
616 { |
617 TRACE( T_LIT("CVIMPSTEngine::ExtentionFeatures start")); |
617 TRACER_AUTO; |
618 TRACE( T_LIT("ExtentionFeatures() - ServiceId: %d"), iServiceId ); |
618 TRACE("ServiceId: %d", iServiceId); |
619 TRACE( T_LIT("ExtentionFeatures() - ExtentionType: %d"), aType ); |
619 TRACE("ExtentionType: %d", aType); |
620 |
|
621 TInt fetaureCount = iExtentionFeatures.Count(); |
620 TInt fetaureCount = iExtentionFeatures.Count(); |
622 MVIMPSTEngineExtentionFeatures* feature = NULL; |
621 MVIMPSTEngineExtentionFeatures* feature = NULL; |
623 |
622 |
624 // iterate the service array |
623 // iterate the service array |
625 for ( TInt index = 0; index < fetaureCount ; index++ ) |
624 for ( TInt index = 0; index < fetaureCount ; index++ ) |
626 { |
625 { |
627 |
626 |
628 if (aType == iExtentionFeatures[index]->Type()) |
627 if (aType == iExtentionFeatures[index]->Type()) |
629 { |
628 { |
630 feature = iExtentionFeatures[index]; |
629 feature = iExtentionFeatures[index]; |
631 TRACE( T_LIT("SubService() - ExtentionFeatures Found") ); |
630 TRACE("ExtentionFeatures Found"); |
632 break; |
631 break; |
633 } |
632 } |
634 } |
633 } |
635 |
634 |
636 TRACE( T_LIT("CVIMPSTEngine::ExtentionFeatures")); |
635 |
637 return feature; |
636 return feature; |
638 } |
637 } |
639 |
638 |
640 |
639 |
641 |
640 |
643 // CVIMPSTEngine::AddExtentionFeaturesL |
642 // CVIMPSTEngine::AddExtentionFeaturesL |
644 // ( Other items commented in header ) |
643 // ( Other items commented in header ) |
645 //----------------------------------------------------------------------------- |
644 //----------------------------------------------------------------------------- |
646 void CVIMPSTEngine::AddExtentionFeaturesL(MVIMPSTEngineExtentionFeatures* aFeature) |
645 void CVIMPSTEngine::AddExtentionFeaturesL(MVIMPSTEngineExtentionFeatures* aFeature) |
647 { |
646 { |
648 __ASSERT_ALWAYS(aFeature,User::Leave(KErrArgument)); |
647 __ASSERT_ALWAYS(aFeature,User::Leave(KErrArgument)); |
649 |
648 |
650 TRACE( T_LIT("CVIMPSTEngine::AddExtentionFeaturesL")); |
649 TRACER_AUTO; |
651 TRACE( T_LIT("AddExtentionFeaturesL() - ServiceId: %d"), iServiceId ); |
650 TRACE( "ServiceId: %d", iServiceId ); |
652 |
|
653 if (aFeature) |
651 if (aFeature) |
654 { |
652 { |
655 TRACE( T_LIT("AddExtentionFeaturesL() - ExtentionType: %d"), aFeature->Type() ); |
653 TRACE( "ExtentionType: %d", aFeature->Type() ); |
656 iExtentionFeatures.Append(aFeature); |
654 iExtentionFeatures.Append(aFeature); |
657 TRACE( T_LIT("AddExtentionFeaturesL() - Append Done") ); |
655 TRACE( "Append Done" ); |
658 } |
656 } |
659 |
657 |
660 TRACE( T_LIT("CVIMPSTEngine::AddExtentionFeaturesL")); |
658 |
661 |
659 |
662 } |
660 } |
663 |
661 |
664 |
662 |
665 //----------------------------------------------------------------------------- |
663 //----------------------------------------------------------------------------- |
666 // CVIMPSTEngine::RemoveExtentionFeatures |
664 // CVIMPSTEngine::RemoveExtentionFeatures |
667 // ( Other items commented in header ) |
665 // ( Other items commented in header ) |
668 //----------------------------------------------------------------------------- |
666 //----------------------------------------------------------------------------- |
669 void CVIMPSTEngine::RemoveExtentionFeatures(TVIMPSTEnums::ExtentionType aType) |
667 void CVIMPSTEngine::RemoveExtentionFeatures(TVIMPSTEnums::ExtentionType aType) |
670 { |
668 { |
671 |
669 TRACER_AUTO; |
672 TRACE( T_LIT("CVIMPSTEngine::RemoveExtentionFeatures")); |
670 |
673 TRACE( T_LIT("RemoveExtentionFeatures() - ServiceId: %d"), iServiceId ); |
671 TRACE( "ServiceId: %d", iServiceId ); |
674 |
|
675 TInt fetaureCount = iExtentionFeatures.Count(); |
672 TInt fetaureCount = iExtentionFeatures.Count(); |
676 |
673 |
677 // iterate the service array |
674 // iterate the service array |
678 for ( TInt index = 0; index < fetaureCount ; index++ ) |
675 for ( TInt index = 0; index < fetaureCount ; index++ ) |
679 { |
676 { |
680 |
677 |
681 if (aType == iExtentionFeatures[index]->Type()) |
678 if (aType == iExtentionFeatures[index]->Type()) |
682 { |
679 { |
683 TRACE( T_LIT("RemoveExtentionFeatures() Found - ExtentionType: %d"), aType ); |
680 TRACE( "ExtentionType: %d", aType ); |
684 iExtentionFeatures.Remove(index); |
681 iExtentionFeatures.Remove(index); |
685 iExtentionFeatures.Compress(); |
682 iExtentionFeatures.Compress(); |
686 TRACE( T_LIT("RemoveExtentionFeatures() - Remove Done") ); |
683 TRACE( "Remove Done" ); |
687 break; |
684 break; |
688 } |
685 } |
689 } |
686 } |
690 |
687 |
691 TRACE( T_LIT("CVIMPSTEngine::RemoveExtentionFeatures end")); |
688 |
692 |
689 |
693 } |
690 } |
694 |
691 |
695 |
692 |
696 |
693 |
698 // CVIMPSTEngine::HandleServceConnectionEventL |
695 // CVIMPSTEngine::HandleServceConnectionEventL |
699 // ( Other items commented in header ) |
696 // ( Other items commented in header ) |
700 //----------------------------------------------------------------------------- |
697 //----------------------------------------------------------------------------- |
701 void CVIMPSTEngine::HandleServceConnectionEventL() |
698 void CVIMPSTEngine::HandleServceConnectionEventL() |
702 { |
699 { |
703 TRACE( T_LIT("CVIMPSTEngine::HandleServceConnectionEventL")); |
700 TRACER_AUTO; |
704 TRACE( T_LIT("HandleServceConnectionEventL() - ServiceId: %d"), iServiceId ); |
701 TRACE( "ServiceId: %d", iServiceId ); |
705 |
702 |
706 TVIMPSTEnums::TVIMPSTRegistrationState previousState = iState; |
703 TVIMPSTEnums::TVIMPSTRegistrationState previousState = iState; |
707 iState = ParseGetServiceState(); |
704 iState = ParseGetServiceState(); |
708 |
705 |
709 if(TVIMPSTEnums::ESVCENotRegistered == iState) |
706 if(TVIMPSTEnums::ESVCENotRegistered == iState) |
729 // in case of roaming(moving from one network to another) |
726 // in case of roaming(moving from one network to another) |
730 // servicetab goes from registered to connecting state, hence the unbind is done here. |
727 // servicetab goes from registered to connecting state, hence the unbind is done here. |
731 if ( presSubService && TVIMPSTEnums::ESVCERegistered == previousState && |
728 if ( presSubService && TVIMPSTEnums::ESVCERegistered == previousState && |
732 TVIMPSTEnums::ESVCENetworkConnecting == iState ) |
729 TVIMPSTEnums::ESVCENetworkConnecting == iState ) |
733 { |
730 { |
734 TRACE( T_LIT( "HandleServceConnectionEventL()-UnsubscribeLists" ) ); |
731 TRACE( "UnsubscribeLists" ); |
735 |
732 |
736 TRAPD( err, presSubService->UnsubscribeListsL() ); |
733 TRAPD( err, presSubService->UnsubscribeListsL() ); |
737 |
734 |
738 TRACE( T_LIT( "HandleServceConnectionEventL()-UnsubscribeLists -err: %d" ), err ); |
735 TRACE( "UnsubscribeLists -err: %d" , err ); |
739 |
736 |
740 if ( iSessionCntxtObserver ) |
737 if ( iSessionCntxtObserver ) |
741 { |
738 { |
742 iSessionCntxtObserver->ServerUnBindL( ETrue ); |
739 iSessionCntxtObserver->ServerUnBindL( ETrue ); |
743 } |
740 } |
744 } |
741 } |
745 TInt count = iObserverArray.Count(); |
742 TInt count = iObserverArray.Count(); |
746 for (TInt index=0; index<count; index++) |
743 for (TInt index=0; index<count; index++) |
747 { |
744 { |
748 TRACE( T_LIT("HandleServceConnectionEventL()calling HandleServiceEventL") ); |
745 TRACE( "calling HandleServiceEventL" ); |
749 iObserverArray[index]->HandleServiceEventL(iState, KErrNone); |
746 iObserverArray[index]->HandleServiceEventL(iState, KErrNone); |
750 } |
747 } |
751 TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(iServiceId); |
748 TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(iServiceId); |
752 if ( (iSessionCntxtObserver) && (KErrNotFound != ximpAdapterUid ) ) |
749 if ( (iSessionCntxtObserver) && (KErrNotFound != ximpAdapterUid ) ) |
753 { |
750 { |
807 } |
804 } |
808 ReSetExtentionFeaturesSupportedL(); |
805 ReSetExtentionFeaturesSupportedL(); |
809 } //end of else if |
806 } //end of else if |
810 }// end of isessioncontextobserver and ximpadapteruid. |
807 }// end of isessioncontextobserver and ximpadapteruid. |
811 }// end of if(previousstate != iState) |
808 }// end of if(previousstate != iState) |
812 TRACE( T_LIT("CVIMPSTEngine::HandleServceConnectionEventL end") ); |
809 |
813 } |
810 } |
814 |
811 |
815 //----------------------------------------------------------------------------- |
812 //----------------------------------------------------------------------------- |
816 // CVIMPSTEngine::ParseGetServiceState |
813 // CVIMPSTEngine::ParseGetServiceState |
817 // ( Other items commented in header ) |
814 // ( Other items commented in header ) |
818 //----------------------------------------------------------------------------- |
815 //----------------------------------------------------------------------------- |
819 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ParseGetServiceState() |
816 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ParseGetServiceState() |
820 { |
817 { |
821 |
818 TRACER_AUTO; |
822 TInt subServiceCount = iSubService.Count(); |
819 TInt subServiceCount = iSubService.Count(); |
823 TInt serviceState = 0; |
820 TInt serviceState = 0; |
824 |
821 |
825 //Find the cumulative of the ServiceStates of all subservices |
822 //Find the cumulative of the ServiceStates of all subservices |
826 // iterate the service array |
823 // iterate the service array |
923 void CVIMPSTEngine::HandleStorageChangeL( TVIMPSTEnums::TVIMPSTStorgaeEventType aEventType, |
921 void CVIMPSTEngine::HandleStorageChangeL( TVIMPSTEnums::TVIMPSTStorgaeEventType aEventType, |
924 MVIMPSTStorageContactList* /*aList*/, |
922 MVIMPSTStorageContactList* /*aList*/, |
925 MVIMPSTStorageContact* aContact, |
923 MVIMPSTStorageContact* aContact, |
926 TInt /*aContactIndex*/ ) |
924 TInt /*aContactIndex*/ ) |
927 { |
925 { |
928 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL begin")); |
926 |
929 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL iState = %d"), iState); |
927 TRACER_AUTO; |
|
928 TRACE(" iState = %d", iState); |
930 if (TVIMPSTEnums::ESVCERegistered == iState || TVIMPSTEnums::ESVCEUpdatingContacts == iState ) |
929 if (TVIMPSTEnums::ESVCERegistered == iState || TVIMPSTEnums::ESVCEUpdatingContacts == iState ) |
931 { |
930 { |
932 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL Inside IF")); |
931 TRACE( "Inside IF"); |
933 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL aEventType : %d"), aEventType); |
932 TRACE( "aEventType : %d", aEventType); |
934 switch( aEventType ) |
933 switch( aEventType ) |
935 { |
934 { |
936 case TVIMPSTEnums::EStorageContactReadComplete: |
935 case TVIMPSTEnums::EStorageContactReadComplete: |
937 case TVIMPSTEnums::EStorageContactFetchComplete: |
936 case TVIMPSTEnums::EStorageContactFetchComplete: |
938 { |
937 { |
939 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL aEventType EStorageContactFetchComplete")); |
938 TRACE( "aEventType EStorageContactFetchComplete"); |
940 MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); |
939 MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); |
941 if( subService ) |
940 if( subService ) |
942 { |
941 { |
943 TRACE( T_LIT("HandleStorageChangeL::EStorageContactFetchComplete Inside IF subService")); |
942 |
|
943 TRACE( "Inside IF subService"); |
944 MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); |
944 MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); |
945 |
945 |
946 MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
946 MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
947 if( storage ) |
947 if( storage ) |
948 { |
948 { |
950 TPtrC ownUserId = ownContact.UserId(); |
950 TPtrC ownUserId = ownContact.UserId(); |
951 if( ownUserId.Length() ) |
951 if( ownUserId.Length() ) |
952 { |
952 { |
953 presenceSubService.SubscribePresenceOfSingleContactL( ownUserId ); |
953 presenceSubService.SubscribePresenceOfSingleContactL( ownUserId ); |
954 } |
954 } |
955 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL inside if storage")); |
955 |
|
956 TRACE( "inside if storage"); |
956 MVIMPSTStorageContactList* list = storage->FindContactList(KIMContactListId) ; |
957 MVIMPSTStorageContactList* list = storage->FindContactList(KIMContactListId) ; |
957 if ( list ) |
958 if ( list ) |
958 { |
959 { |
959 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL inside if list")); |
960 |
960 TInt count = list->Count(); |
961 TRACE( "inside if list"); |
961 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL inside count = %d"), count); |
962 TInt count = list->Count(); |
|
963 TRACE( "inside count = %d", count); |
962 for(TInt i = 0;i < count; i++) |
964 for(TInt i = 0;i < count; i++) |
963 { |
965 { |
964 MVIMPSTStorageContact* contact = &(list->operator[](i)); |
966 MVIMPSTStorageContact* contact = &(list->operator[](i)); |
965 if(contact) |
967 if(contact) |
966 { |
968 { |
967 if( contact->UserId().Length() ) |
969 if( contact->UserId().Length() ) |
968 { |
970 { |
969 TPtrC userId = contact->UserId(); |
971 TPtrC userId = contact->UserId(); |
970 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL inside userId = %S"), &userId); |
972 TRACE("inside userId = %S", &userId); |
971 presenceSubService.SubscribePresenceOfSingleContactL( contact->UserId() ); |
973 presenceSubService.SubscribePresenceOfSingleContactL( contact->UserId() ); |
972 } |
974 } |
973 } // end of if(contact) |
975 } // end of if(contact) |
974 }// end of for |
976 }// end of for |
975 } |
977 } |
983 case TVIMPSTEnums::EStorageEventOwnUserChanged: |
985 case TVIMPSTEnums::EStorageEventOwnUserChanged: |
984 case TVIMPSTEnums::EStorageEventContactAddition: |
986 case TVIMPSTEnums::EStorageEventContactAddition: |
985 case TVIMPSTEnums::EStorageContactSynchronizing: |
987 case TVIMPSTEnums::EStorageContactSynchronizing: |
986 case TVIMPSTEnums::EStorageContactReading: |
988 case TVIMPSTEnums::EStorageContactReading: |
987 case TVIMPSTEnums::EStorageContactFetchExistInStore: |
989 case TVIMPSTEnums::EStorageContactFetchExistInStore: |
988 { |
990 { |
989 TRACE( T_LIT("CVIMPSTEngine::HandleStorageChangeL aEventType : %d"), aEventType); |
991 TRACE( "aEventType : %d", aEventType); |
990 MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); |
992 MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); |
991 if( subService && aContact && |
993 if( subService && aContact && |
992 aContact->UserId().Length() && |
994 aContact->UserId().Length() && |
993 TVIMPSTEnums::ESVCERegistered == iState ) |
995 TVIMPSTEnums::ESVCERegistered == iState ) |
994 { |
996 { |
1111 |
1114 |
1112 //Unregister is done by session context when the presence context gets |
1115 //Unregister is done by session context when the presence context gets |
1113 //unbinded |
1116 //unbinded |
1114 iSessionCntxtObserver->RegisterObserver(searchitem); |
1117 iSessionCntxtObserver->RegisterObserver(searchitem); |
1115 } |
1118 } |
1116 TRACE( T_LIT("CVIMPSTEngine::CreateExtentionFeaturesL end")); |
1119 |
1117 } |
1120 } |
1118 |
1121 |
1119 //----------------------------------------------------------------------------- |
1122 //----------------------------------------------------------------------------- |
1120 // CVIMPSTEngine::SetExtentionFeaturesSupportedL |
1123 // CVIMPSTEngine::SetExtentionFeaturesSupportedL |
1121 // ( Other items commented in header ) |
1124 // ( Other items commented in header ) |
1122 //----------------------------------------------------------------------------- |
1125 //----------------------------------------------------------------------------- |
1123 void CVIMPSTEngine::SetExtentionFeaturesSupportedL() |
1126 void CVIMPSTEngine::SetExtentionFeaturesSupportedL() |
1124 { |
1127 { |
1125 TRACE( T_LIT("CVIMPSTEngine::SetExtentionFeaturesSupportedL start")); |
1128 TRACER_AUTO; |
1126 if (!iSessionCntxtObserver) |
1129 if (!iSessionCntxtObserver) |
1127 { |
1130 { |
1128 return; |
1131 return; |
1129 } |
1132 } |
1130 |
1133 |
1175 MVIMPSTEnginePresenceSubService& avatarFeature = |
1178 MVIMPSTEnginePresenceSubService& avatarFeature = |
1176 CVIMPSTEnginePresenceSubService::Cast(*subService); |
1179 CVIMPSTEnginePresenceSubService::Cast(*subService); |
1177 avatarFeature.SetAvatarSupported(ETrue); |
1180 avatarFeature.SetAvatarSupported(ETrue); |
1178 } |
1181 } |
1179 } |
1182 } |
1180 TRACE( T_LIT("CVIMPSTEngine::SetExtentionFeaturesSupportedL end")); |
|
1181 } |
1183 } |
1182 |
1184 |
1183 |
1185 |
1184 //----------------------------------------------------------------------------- |
1186 //----------------------------------------------------------------------------- |
1185 // CVIMPSTEngine::ReSetExtentionFeaturesSupportedL |
1187 // CVIMPSTEngine::ReSetExtentionFeaturesSupportedL |
1186 // ( Other items commented in header ) |
1188 // ( Other items commented in header ) |
1187 //----------------------------------------------------------------------------- |
1189 //----------------------------------------------------------------------------- |
1188 void CVIMPSTEngine::ReSetExtentionFeaturesSupportedL() |
1190 void CVIMPSTEngine::ReSetExtentionFeaturesSupportedL() |
1189 { |
1191 { |
|
1192 TRACER_AUTO; |
1190 //first find whether we have the extention already created |
1193 //first find whether we have the extention already created |
1191 //in the extention manager list |
1194 //in the extention manager list |
1192 MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( |
1195 MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( |
1193 TVIMPSTEnums::ESearch); |
1196 TVIMPSTEnums::ESearch); |
1194 if (feature) |
1197 if (feature) |
1227 // CVIMPSTEngine::DefaultDomainNameL |
1230 // CVIMPSTEngine::DefaultDomainNameL |
1228 // |
1231 // |
1229 // --------------------------------------------------------- |
1232 // --------------------------------------------------------- |
1230 void CVIMPSTEngine::DefaultDomainNameL( TDes& aDefaultDomainName ) const |
1233 void CVIMPSTEngine::DefaultDomainNameL( TDes& aDefaultDomainName ) const |
1231 { |
1234 { |
1232 TRACE( T_LIT("CVIMPSTEngine::DefaultDomainName start")); |
1235 TRACER_AUTO; |
1233 TRACE( T_LIT("DefaultDomainNameL() - ServiceId: %d"), iServiceId ); |
1236 TRACE( "ServiceId: %d", iServiceId ); |
1234 iTableFetcher.GetDefaultDomainNameL(iServiceId, aDefaultDomainName); |
1237 iTableFetcher.GetDefaultDomainNameL(iServiceId, aDefaultDomainName); |
1235 TRACE( T_LIT("CVIMPSTEngine::DefaultDomainNameL end")); |
1238 |
1236 } |
1239 } |
1237 |
1240 |
1238 |
1241 |
1239 // --------------------------------------------------------- |
1242 // --------------------------------------------------------- |
1240 // CVIMPSTEngine::IsSubServiceSupportedInternal |
1243 // CVIMPSTEngine::IsSubServiceSupportedInternal |
1241 // |
1244 // |
1242 // --------------------------------------------------------- |
1245 // --------------------------------------------------------- |
1243 TBool CVIMPSTEngine::IsSubServiceSupportedInternal(TVIMPSTEnums::SubServiceType aType) const |
1246 TBool CVIMPSTEngine::IsSubServiceSupportedInternal(TVIMPSTEnums::SubServiceType aType) const |
1244 { |
1247 { |
1245 |
1248 TRACER_AUTO; |
1246 TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL")); |
1249 TRACE( "ServiceId: %d", iServiceId ); |
1247 TRACE( T_LIT("IsSubServiceSupportedL() - ServiceId: %d"), iServiceId ); |
1250 TRACE( "SubServiceType: %d", aType ); |
1248 TRACE( T_LIT("IsSubServiceSupportedL() - SubServiceType: %d"), aType ); |
|
1249 |
|
1250 TInt err = KErrNotFound; |
1251 TInt err = KErrNotFound; |
1251 TBool support = EFalse; |
1252 TBool support = EFalse; |
1252 TCCHSubserviceState aCCHState(ECCHUninitialized); |
1253 TCCHSubserviceState aCCHState(ECCHUninitialized); |
1253 |
1254 |
1254 switch(aType) |
1255 switch(aType) |
1278 if (KErrNone == err) |
1279 if (KErrNone == err) |
1279 { |
1280 { |
1280 support = ETrue; |
1281 support = ETrue; |
1281 } |
1282 } |
1282 |
1283 |
1283 TRACE( T_LIT("IsSubServiceSupportedL() - support: %d"), support ); |
1284 |
1284 TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL end")); |
1285 TRACE("support: %d", support ); |
1285 return support; |
1286 return support; |
1286 } |
1287 } |
1287 |
1288 |
1288 |
1289 |
1289 // --------------------------------------------------------- |
1290 // --------------------------------------------------------- |
1290 // CVIMPSTEngine::ChangeConnectionL |
1291 // CVIMPSTEngine::ChangeConnectionL |
1291 // |
1292 // |
1292 // --------------------------------------------------------- |
1293 // --------------------------------------------------------- |
1293 TInt CVIMPSTEngine::ChangeConnectionL() |
1294 TInt CVIMPSTEngine::ChangeConnectionL() |
1294 { |
1295 { |
1295 TRACE( T_LIT("CVIMPSTEngine::ChangeConnectionL")); |
1296 TRACER_AUTO; |
1296 TRACE( T_LIT("ChangeConnectionL() - ServiceId: %d"), iServiceId ); |
1297 TRACE( "ServiceId: %d", iServiceId ); |
1297 |
|
1298 TInt error = KErrNotFound; |
1298 TInt error = KErrNotFound; |
1299 if(iCchHandler) |
1299 if(iCchHandler) |
1300 { |
1300 { |
1301 TRACE( T_LIT("ChangeConnectionL() Called") ); |
1301 |
|
1302 TRACE( "ChangeConnectionL() Called" ); |
1302 error = iCchHandler->ChangeConnectionL(); |
1303 error = iCchHandler->ChangeConnectionL(); |
1303 } |
1304 } |
1304 |
1305 |
1305 TRACE( T_LIT("ChangeConnectionL - error: %d"), error ); |
1306 |
1306 TRACE( T_LIT("CVIMPSTEngine::ChangeConnectionL end") ); |
1307 TRACE("error: %d", error ); |
1307 |
1308 |
1308 return error; |
1309 return error; |
1309 } |
1310 } |
1310 |
1311 |
1311 // --------------------------------------------------------- |
1312 // --------------------------------------------------------- |
1312 // CVIMPSTEngine::IsBlockSupportedL |
1313 // CVIMPSTEngine::IsBlockSupportedL |
1313 // |
1314 // |
1314 // --------------------------------------------------------- |
1315 // --------------------------------------------------------- |
1315 |
1316 |
1316 TBool CVIMPSTEngine::IsBlockSupportedL() |
1317 TBool CVIMPSTEngine::IsBlockSupportedL() |
1317 { |
1318 { |
|
1319 TRACER_AUTO; |
1318 TBool isBlockSupported = EFalse; |
1320 TBool isBlockSupported = EFalse; |
1319 //We would have got the supported features |
1321 //We would have got the supported features |
1320 if(iSessionCntxtObserver && (TVIMPSTEnums::ESVCERegistered == ParseGetServiceState())) |
1322 if(iSessionCntxtObserver && (TVIMPSTEnums::ESVCERegistered == ParseGetServiceState())) |
1321 { |
1323 { |
1322 TInt supportedFeatures = iSessionCntxtObserver->GetSupportedFeatures(); |
1324 TInt supportedFeatures = iSessionCntxtObserver->GetSupportedFeatures(); |
1332 // CVIMPSTEngine::IsPasswordAvailable |
1334 // CVIMPSTEngine::IsPasswordAvailable |
1333 // returns True if password is present in the settings else returns false |
1335 // returns True if password is present in the settings else returns false |
1334 // --------------------------------------------------------- |
1336 // --------------------------------------------------------- |
1335 TBool CVIMPSTEngine::IsPasswordAvailableL() |
1337 TBool CVIMPSTEngine::IsPasswordAvailableL() |
1336 { |
1338 { |
1337 TRACE( T_LIT("CVIMPSTEngine::IsPasswordAvailable start - End")); |
1339 TRACER_AUTO; |
|
1340 |
1338 return(iCchHandler->IsPasswordAvailable(ECchPasswordSet)); |
1341 return(iCchHandler->IsPasswordAvailable(ECchPasswordSet)); |
1339 } |
1342 } |
1340 |
1343 |
1341 // --------------------------------------------------------- |
1344 // --------------------------------------------------------- |
1342 // CVIMPSTEngine::DeleteDataBase |
1345 // CVIMPSTEngine::DeleteDataBase |
1343 // --------------------------------------------------------- |
1346 // --------------------------------------------------------- |
1344 void CVIMPSTEngine::DeleteDataBaseL() |
1347 void CVIMPSTEngine::DeleteDataBaseL() |
1345 { |
1348 { |
|
1349 TRACER_AUTO; |
1346 MVIMPSTStorageServiceView* storage = |
1350 MVIMPSTStorageServiceView* storage = |
1347 CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
1351 CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); |
1348 if( storage ) |
1352 if( storage ) |
1349 { |
1353 { |
1350 //delete cdb file. |
1354 //delete cdb file. |