Mercurial Mercurial > oss > FCL > sf > app > conversations / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
uiservicetab/vimpstengine/src/cvimpstengineservicetablefetcher.cpp
branchRCL_3
changeset 14 9fdee5e1da30
parent 0 5e5d6b214f4f
equal deleted inserted replaced
13:796276a1bdcc 14:9fdee5e1da30 
    36 #include "tvimpstconsts.h"
 
    36 #include "tvimpstconsts.h"
 
    37 #include "mvimpstenginefactory.h"
 
    37 #include "mvimpstenginefactory.h"
 
    38 #include "cvimpstenginefactory.h"
 
    38 #include "cvimpstenginefactory.h"
 
    39 #include "mvimpststorageserviceview.h"
 
    39 #include "mvimpststorageserviceview.h"
 
    40 #include "cvimpststoragemanagerfactory.h"
 
    40 #include "cvimpststoragemanagerfactory.h"
 
    41 #include "vimpstdebugtrace.h"
 
    41 #include "uiservicetabtracer.h"
 
    42 
    42 
    43 
    43 
    44 
    44 
    45 // ================= MEMBER FUNCTIONS =======================
 
    45 // ================= MEMBER FUNCTIONS =======================
 
    46 
    46 
    56 // CVIMPSTEngineServiceTableFetcher::ConstructL()
 
    56 // CVIMPSTEngineServiceTableFetcher::ConstructL()
 
    57 // ---------------------------------------------------------------------------
 
    57 // ---------------------------------------------------------------------------
 
    58 //
 
    58 //
 
    59 void CVIMPSTEngineServiceTableFetcher::ConstructL()
 
    59 void CVIMPSTEngineServiceTableFetcher::ConstructL()
 
    60     {
 
    60     {
 
    61     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::ConstructL start"));
 
    61 	TRACER_AUTO;
 
    62     iSettings = CSPSettings::NewL();
 
    62     iSettings = CSPSettings::NewL();
 
    63     CompressViewIdsL();
 
    63     CompressViewIdsL();
 
    64     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::ConstructL end"));
 
       
    65     }
 
    64     }
 
    66 
    65 
    67 // ---------------------------------------------------------------------------
 
    66 // ---------------------------------------------------------------------------
 
    68 // CVIMPSTEngineServiceTableFetcher::NewL()
 
    67 // CVIMPSTEngineServiceTableFetcher::NewL()
 
    69 // ---------------------------------------------------------------------------
 
    68 // ---------------------------------------------------------------------------
 
    70 //
 
    69 //
 
    71 CVIMPSTEngineServiceTableFetcher* 
    70 CVIMPSTEngineServiceTableFetcher* 
    72     CVIMPSTEngineServiceTableFetcher::NewL( )
 
    71     CVIMPSTEngineServiceTableFetcher::NewL( )
 
    73     {
 
    72     {
 
    74     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::NewL start"));
 
    73 	TRACER_AUTO;
 
    75     
    74     
    76     CVIMPSTEngineServiceTableFetcher* self = NewLC();
 
    75     CVIMPSTEngineServiceTableFetcher* self = NewLC();
 
    77     CleanupStack::Pop(self);
 
    76     CleanupStack::Pop(self);
 
    78     
    77     
    79     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::NewL end"));
 
       
    80     return self;
 
    78     return self;
 
    81     }
 
    79     }
 
    82 
    80 
    83 // ---------------------------------------------------------------------------
 
    81 // ---------------------------------------------------------------------------
 
    84 // CVIMPSTEngineServiceTableFetcher::NewLC()
 
    82 // CVIMPSTEngineServiceTableFetcher::NewLC()
 
    85 // ---------------------------------------------------------------------------
 
    83 // ---------------------------------------------------------------------------
 
    86 //
 
    84 //
 
    87 CVIMPSTEngineServiceTableFetcher* 
    85 CVIMPSTEngineServiceTableFetcher* 
    88     CVIMPSTEngineServiceTableFetcher::NewLC()
 
    86     CVIMPSTEngineServiceTableFetcher::NewLC()
 
    89     {
 
    87     {
 
    90     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::NewLC start"));
 
    88 	TRACER_AUTO;
 
    91     
    89     
    92     CVIMPSTEngineServiceTableFetcher* self =
 
    90     CVIMPSTEngineServiceTableFetcher* self =
 
    93         new (ELeave) CVIMPSTEngineServiceTableFetcher( );
 
    91         new (ELeave) CVIMPSTEngineServiceTableFetcher( );
 
    94     CleanupStack::PushL(self);
 
    92     CleanupStack::PushL(self);
 
    95     self->ConstructL();
 
    93     self->ConstructL();
 
    96     
    94     
    97     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::NewLC end"));
 
       
    98     return self;
 
    95     return self;
 
    99     }
 
    96     }
 
   100 
    97 
   101 // ---------------------------------------------------------------------------
 
    98 // ---------------------------------------------------------------------------
 
   102 // CVIMPSTEngineServiceTableFetcher::
 
    99 // CVIMPSTEngineServiceTableFetcher::
 
   103 //      ~CVIMPSTEngineServiceTableFetcher()
 
   100 //      ~CVIMPSTEngineServiceTableFetcher()
 
   104 // ---------------------------------------------------------------------------
 
   101 // ---------------------------------------------------------------------------
 
   105 //
 
   102 //
 
   106 CVIMPSTEngineServiceTableFetcher::~CVIMPSTEngineServiceTableFetcher()
 
   103 CVIMPSTEngineServiceTableFetcher::~CVIMPSTEngineServiceTableFetcher()
 
   107     {
 
   104     {
 
   108     
   105 	TRACER_AUTO;
 
   109     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::~CVIMPSTEngineServiceTableFetcher start"));   
   106     
   110     
   107     
   111     delete iSettings;	
   108     delete iSettings;	
   112     iSettings = NULL;
 
   109     iSettings = NULL;
 
   113     
   110     
   114     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::~CVIMPSTEngineServiceTableFetcher end"));    
       
   115     }
 
   111     }
 
   116 
   112 
   117 // ---------------------------------------------------------------------------
 
   113 // ---------------------------------------------------------------------------
 
   118 // CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL()
 
   114 // CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL()
 
   119 // ---------------------------------------------------------------------------
 
   115 // ---------------------------------------------------------------------------
 
   120 //
 
   116 //
 
   121 void CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL( 
   117 void CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL( 
   122     RArray<TUint32>& aServiceIds )
 
   118     RArray<TUint32>& aServiceIds )
 
   123     {
 
   119     {
 
   124     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL start"));
 
   120 	TRACER_AUTO;
 
   125     
   121     
   126     RArray<TServiceId> services;
 
   122     RArray<TServiceId> services;
 
   127     CleanupClosePushL( services );
 
   123     CleanupClosePushL( services );
 
   128     iSettings->FindServiceIdsL( services );
 
   124     iSettings->FindServiceIdsL( services );
 
   129 	
   125 	
   135         if ( TUid::Uid( refContactUid ) == 
   131         if ( TUid::Uid( refContactUid ) == 
   136              TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID ) 
   132              TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID ) 
   137              || TUid::Uid( refContactUid ) == 
   133              || TUid::Uid( refContactUid ) == 
   138              TUid::Uid( 0x20007B6D ) )
 
   134              TUid::Uid( 0x20007B6D ) )
 
   139             {
 
   135             {
 
   140             TRACE( T_LIT("GetMasterServiceIdsL() found serviceid: (%d)"), services[ i ] );
 
   136             TRACE( " found serviceid: (%d)", services[ i ] );
 
   141 
   137 
   142             aServiceIds.Append( services[ i ] );                
   138             aServiceIds.Append( services[ i ] );                
   143 
   139 
   144             TRACE( T_LIT("GetMasterServiceIdsL() - service append ok") );                
   140             TRACE("service append ok" ); 
   145 
   141 
   146             }
 
   142             }
 
   147         }
 
   143         }
 
   148     CleanupStack::PopAndDestroy( &services );
 
   144     CleanupStack::PopAndDestroy( &services );
 
   149     
   145     
   150     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetMasterServiceIdsL end"));  
       
   151     }
 
   146     }
 
   152 
   147 
   153 // ---------------------------------------------------------------------------
 
   148 // ---------------------------------------------------------------------------
 
   154 // CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL()
 
   149 // CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL()
 
   155 // ---------------------------------------------------------------------------
 
   150 // ---------------------------------------------------------------------------
 
   156 //
 
   151 //
 
   157 void CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL( 
   152 void CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL( 
   158     TUint32 aServiceId, TDes& aContactStoreId )
 
   153     TUint32 aServiceId, TDes& aContactStoreId )
 
   159     {
 
   154     {
 
   160     TRACE( T_LIT( 
   155 	TRACER_AUTO;
 
   161        "CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL start")); 
   156     
   162     
   157     TRACE( "ServiceId: %d", aServiceId );
 
   163     TRACE( T_LIT("GetContactStoreIdL() ServiceId: %d"), aServiceId );
 
       
   164         
   158         
   165     CSPProperty* property = CSPProperty::NewLC();
 
   159     CSPProperty* property = CSPProperty::NewLC();
 
   166     TInt err = iSettings->FindPropertyL( aServiceId,
 
   160     TInt err = iSettings->FindPropertyL( aServiceId,
 
   167                                 EPropertyContactStoreId,      
   161                                 EPropertyContactStoreId,      
   168                                 *property );    
   162                                 *property );    
   172 	    
   166 	    
   173 		}
 
   167 		}
 
   174 
   168 
   175     CleanupStack::PopAndDestroy( property );
 
   169     CleanupStack::PopAndDestroy( property );
 
   176     
   170     
   177     TRACE( T_LIT("GetContactStoreIdL() - StoreId: %S"), &aContactStoreId );                
   171     TRACE( "StoreId: %S", &aContactStoreId );     
   178     
   172     
   179     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL end"));  
       
   180  	
   173  	
   181     }   
   174     }   
   182 
   175 
   183     
   176     
   184 
   177 
   187 // ---------------------------------------------------------------------------
 
   180 // ---------------------------------------------------------------------------
 
   188 //
 
   181 //
 
   189 void CVIMPSTEngineServiceTableFetcher::GetBrandIdL( 
   182 void CVIMPSTEngineServiceTableFetcher::GetBrandIdL( 
   190     TUint32 aServiceId, TDes8& aBrandId )
 
   183     TUint32 aServiceId, TDes8& aBrandId )
 
   191     {
 
   184     {
 
   192     TRACE( T_LIT( "CVIMPSTEngineServiceTableFetcher::GetBrandIdL start"));
 
   185 	TRACER_AUTO;
 
   193     
   186     
   194     TRACE( T_LIT("GetBrandIdL() ServiceId: %d"), aServiceId );
 
   187     TRACE( "ServiceId: %d", aServiceId );
 
   195        
   188        
   196     HBufC* ret = HBufC::NewLC( KVIMPSTUISPSMaxPropertyLength );    
   189     HBufC* ret = HBufC::NewLC( KVIMPSTUISPSMaxPropertyLength );    
   197     TPtr retPtr( ret->Des() );
 
   190     TPtr retPtr( ret->Des() );
 
   198     
   191     
   199     CSPProperty* property = CSPProperty::NewLC();
 
   192     CSPProperty* property = CSPProperty::NewLC();
 
   209 	        }
 
   202 	        }
 
   210         }
 
   203         }
 
   211     CleanupStack::PopAndDestroy( property );        
   204     CleanupStack::PopAndDestroy( property );        
   212     CleanupStack::PopAndDestroy( ret );        
   205     CleanupStack::PopAndDestroy( ret );        
   213     
   206     
   214     TRACE( T_LIT("GetBrandIdL() - BrandId: %S"), &aBrandId ); 
   207     TRACE( "BrandId: %S", &aBrandId ); 
   215     
   208     
   216     TRACE( T_LIT( "CVIMPSTEngineServiceTableFetcher::GetBrandIdL end"));
 
       
   217     }    
   209     }    
   218 
   210 
   219 
   211 
   220 // ---------------------------------------------------------------------------
 
   212 // ---------------------------------------------------------------------------
 
   221 // CVIMPSTEngineServiceTableFetcher::FindPropertyL()
 
   213 // CVIMPSTEngineServiceTableFetcher::FindPropertyL()
 
   222 // ---------------------------------------------------------------------------
 
   214 // ---------------------------------------------------------------------------
 
   223 //
 
   215 //
 
   224 TInt CVIMPSTEngineServiceTableFetcher::FindPropertyL( TUint32 aServiceId,
 
   216 TInt CVIMPSTEngineServiceTableFetcher::FindPropertyL( TUint32 aServiceId,
 
   225 	                                TServicePropertyName aPropertyName )
 
   217 	                                TServicePropertyName aPropertyName )
 
   226 	{
 
   218 	{
 
   227 	TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::FindPropertyL start"));
 
   219 	TRACER_AUTO;
 
   228     
   220     
   229     TRACE( T_LIT("FindPropertyL- ServiceId: %d Property: %d"), 
   221 	 TRACE( "ServiceId: %d Property: %d", aServiceId, aPropertyName );
 
   230     								aServiceId, aPropertyName ); 
       
   231        
   222        
   232 	CSPProperty* property = CSPProperty::NewLC();
 
   223 	CSPProperty* property = CSPProperty::NewLC();
 
   233     TInt result = iSettings->FindPropertyL( aServiceId,
 
   224     TInt result = iSettings->FindPropertyL( aServiceId,
 
   234                                 aPropertyName,
 
   225                                 aPropertyName,
 
   235                                 *property );		
   226                                 *property );		
   236 	CleanupStack::PopAndDestroy( property );
 
   227 	CleanupStack::PopAndDestroy( property );
 
   237 	
   228 	
   238 	TRACE( T_LIT("FindPropertyL- Result: %d"), result );
 
   229 	TRACE(" Result: %d", result );
 
   239     								
   230     								
   240 	TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::FindPropertyL end"));
 
       
   241        
   231        
   242 	return result;
 
   232 	return result;
 
   243 	}
 
   233 	}
 
   244 
   234 
   245 
   235 
   250 // ---------------------------------------------------------------------------
 
   240 // ---------------------------------------------------------------------------
 
   251 //
 
   241 //
 
   252 TInt CVIMPSTEngineServiceTableFetcher::PropertyBrandVersionL( 
   242 TInt CVIMPSTEngineServiceTableFetcher::PropertyBrandVersionL( 
   253     TUint32 aServiceId ) 
   243     TUint32 aServiceId ) 
   254     {
 
   244     {
 
   255     TRACE( T_LIT( "CVIMPSTEngineServiceTableFetcher::PropertyBrandVersionL start"));
 
   245 	TRACER_AUTO;
 
   256     
   246     
   257     TRACE( T_LIT("PropertyBrandVersionL() ServiceId: %d"), aServiceId );
 
   247 	TRACE( "ServiceId: %d", aServiceId );
 
   258        
   248        
   259     TInt brandVersion = KErrNotFound; // default value
 
   249     TInt brandVersion = KErrNotFound; // default value
 
   260     CSPProperty* property = CSPProperty::NewLC();
 
   250     CSPProperty* property = CSPProperty::NewLC();
 
   261     TInt err = iSettings->FindPropertyL( aServiceId,
 
   251     TInt err = iSettings->FindPropertyL( aServiceId,
 
   262                                 EPropertyBrandVersion,
 
   252                                 EPropertyBrandVersion,
 
   266         err = property->GetValue( brandVersion );
 
   256         err = property->GetValue( brandVersion );
 
   267         }
 
   257         }
 
   268         
   258         
   269     CleanupStack::PopAndDestroy( property );
 
   259     CleanupStack::PopAndDestroy( property );
 
   270     
   260     
   271     TRACE( T_LIT("PropertyBrandVersionL - version: %d"), brandVersion );  
   261     TRACE( "version: %d", brandVersion );
 
   272     
   262     
   273     TRACE( T_LIT( "CVIMPSTEngineServiceTableFetcher::PropertyBrandVersionL end"));
 
       
   274     return brandVersion;
 
   263     return brandVersion;
 
   275     }
 
   264     }
 
   276 
   265 
   277 // ---------------------------------------------------------------------------
 
   266 // ---------------------------------------------------------------------------
 
   278 // CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL()
 
   267 // CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL()
 
   279 // ---------------------------------------------------------------------------
 
   268 // ---------------------------------------------------------------------------
 
   280 //
 
   269 //
 
   281 TLanguage CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL( 
   270 TLanguage CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL( 
   282     TUint32 aServiceId ) 
   271     TUint32 aServiceId ) 
   283     {
 
   272     {
 
   284     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL start"));
 
   273 	TRACER_AUTO;
 
   285     
   274     
   286     TRACE( T_LIT("PropertyBrandLanguageL() ServiceId: %d"), aServiceId );
 
   275 	 TRACE( " ServiceId: %d", aServiceId );
 
   287     
   276     
   288     // ELangInternationalEnglish is selected as Default Brand Language Id.
 
   277     // ELangInternationalEnglish is selected as Default Brand Language Id.
 
   289     TInt brandLanguage = ELangInternationalEnglish;    
   278     TInt brandLanguage = ELangInternationalEnglish;    
   290     CSPProperty* property = CSPProperty::NewLC();
 
   279     CSPProperty* property = CSPProperty::NewLC();
 
   291     TInt err = iSettings->FindPropertyL( aServiceId,
 
   280     TInt err = iSettings->FindPropertyL( aServiceId,
 
   295         {
 
   284         {
 
   296         err = property->GetValue( brandLanguage );
 
   285         err = property->GetValue( brandLanguage );
 
   297         }
 
   286         }
 
   298     CleanupStack::PopAndDestroy( property );
 
   287     CleanupStack::PopAndDestroy( property );
 
   299 
   288 
   300     TRACE( T_LIT("PropertyBrandVersionL - brandLanguage: (%d) "), brandLanguage );  
   289     TRACE( "brandLanguage: (%d) ", brandLanguage );
 
   301 	
   290 	
   302 	TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::PropertyBrandLanguageL end"));
 
       
   303        
   291        
   304     return ((TLanguage) (brandLanguage) );
 
   292     return ((TLanguage) (brandLanguage) );
 
   305     }
 
   293     }
 
   306 
   294 
   307 
   295 
   310 // ---------------------------------------------------------------------------
 
   298 // ---------------------------------------------------------------------------
 
   311 //
 
   299 //
 
   312 TUint32 CVIMPSTEngineServiceTableFetcher::ContactViewUidL( 
   300 TUint32 CVIMPSTEngineServiceTableFetcher::ContactViewUidL( 
   313     TUint32 aServiceId )
 
   301     TUint32 aServiceId )
 
   314     {
 
   302     {
 
   315     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::ContactViewUidL start"));
 
   303 	TRACER_AUTO;
 
   316     
   304     
   317     TRACE( T_LIT("ContactViewUidL() ServiceId: %d"), aServiceId );
 
   305 	TRACE( "ServiceId: %d", aServiceId );
 
   318         
   306         
   319     TInt contactViewUid = KErrNotFound;
 
   307     TInt contactViewUid = KErrNotFound;
 
   320     CSPProperty* property = CSPProperty::NewLC();
 
   308     CSPProperty* property = CSPProperty::NewLC();
 
   321     TInt err = iSettings->FindPropertyL( aServiceId,
 
   309     TInt err = iSettings->FindPropertyL( aServiceId,
 
   322                                 EPropertyContactViewPluginId,
 
   310                                 EPropertyContactViewPluginId,
 
   325         {
 
   313         {
 
   326         property->GetValue( contactViewUid );
 
   314         property->GetValue( contactViewUid );
 
   327         }
 
   315         }
 
   328     CleanupStack::PopAndDestroy( property );      
   316     CleanupStack::PopAndDestroy( property );      
   329           
   317           
   330     TRACE( T_LIT("ContactViewUid: %d"), contactViewUid );    
   318     TRACE( "ContactViewUid: %d", contactViewUid ); 
   331     
   319     
   332     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetContactStoreIdL end"));
 
       
   333        
   320        
   334     return contactViewUid;
 
   321     return contactViewUid;
 
   335     }    
   322     }    
   336 
   323 
   337 // ---------------------------------------------------------------------------
 
   324 // ---------------------------------------------------------------------------
 
   339 // ---------------------------------------------------------------------------
 
   326 // ---------------------------------------------------------------------------
 
   340 //
 
   327 //
 
   341 void CVIMPSTEngineServiceTableFetcher::GetServiceNameL( 
   328 void CVIMPSTEngineServiceTableFetcher::GetServiceNameL( 
   342     TUint32 aServiceId, TDes& aServiceName )
 
   329     TUint32 aServiceId, TDes& aServiceName )
 
   343     {
 
   330     {
 
   344     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetServiceNameL start"));    
   331 	TRACER_AUTO;
 
   345     
   332     
   346     TRACE( T_LIT("GetServiceNameL() ServiceId: %d"), aServiceId );
 
   333 	TRACE( "ServiceId: %d", aServiceId );
 
   347     
   334     
   348     CSPEntry* entry = CSPEntry::NewLC();
 
   335     CSPEntry* entry = CSPEntry::NewLC();
 
   349     TInt err = iSettings->FindEntryL( aServiceId, *entry ) ;
 
   336     TInt err = iSettings->FindEntryL( aServiceId, *entry ) ;
 
   350     if ( !err )
 
   337     if ( !err )
 
   351         {
 
   338         {
 
   352         aServiceName = entry->GetServiceName();
 
   339         aServiceName = entry->GetServiceName();
 
   353         }
 
   340         }
 
   354     
   341     
   355     CleanupStack::PopAndDestroy( entry );    
   342     CleanupStack::PopAndDestroy( entry );    
   356     
   343     
   357     TRACE( T_LIT("GetServiceNameL() ServiceName: %S"), &aServiceName );
 
   344     TRACE("ServiceName: %S", &aServiceName );
 
   358     
   345     
   359     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::GetServiceNameL end"));
 
       
   360     }
 
   346     }
 
   361 
   347 
   362 // ---------------------------------------------------------------------------
 
   348 // ---------------------------------------------------------------------------
 
   363 // CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL()
 
   349 // CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL()
 
   364 // ---------------------------------------------------------------------------
 
   350 // ---------------------------------------------------------------------------
 
   365 //
 
   351 //
 
   366 void CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL(
 
   352 void CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL(
 
   367     		TServiceId aServiceId, TBool aNewService, MVIMPSTEngine* aEngine )
 
   353     		TServiceId aServiceId, TBool aNewService, MVIMPSTEngine* aEngine )
 
   368     {
 
   354     {
 
   369     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL start"));  
   355 	TRACER_AUTO;
 
   370     TRACE( T_LIT("DoHandleNotifyChange() ServiceId:%d"), aServiceId );
 
   356 	TRACE( "ServiceId:%d", aServiceId );
 
   371     TBool serviceFound( EFalse ); 
   357     TBool serviceFound( EFalse ); 
   372     if(!aNewService)
 
   358     if(!aNewService)
 
   373         {
 
   359         {
 
   374         RArray<TUint32> serviceIdArray;
 
   360         RArray<TUint32> serviceIdArray;
 
   375         CleanupClosePushL( serviceIdArray ); 
   361         CleanupClosePushL( serviceIdArray ); 
   380         const TInt serviceCount = services.Count();
 
   366         const TInt serviceCount = services.Count();
 
   381         for ( TInt index = 0 ; index < serviceCount ; index++ )
 
   367         for ( TInt index = 0 ; index < serviceCount ; index++ )
 
   382             {
 
   368             {
 
   383             if ( services[index] == aServiceId )
 
   369             if ( services[index] == aServiceId )
 
   384                 {
 
   370                 {
 
   385                 TRACE( T_LIT("DoHandleNotifyChange() - Service (%d) found"), aServiceId );
 
   371             TRACE( "Service (%d) found", aServiceId );
 
   386                 serviceFound = ETrue;
 
   372                 serviceFound = ETrue;
 
   387                 }
 
   373                 }
 
   388             }
 
   374             }
 
   389         CleanupStack::PopAndDestroy( &services );
 
   375         CleanupStack::PopAndDestroy( &services );
 
   390         CleanupStack::PopAndDestroy( &serviceIdArray ); 
   376         CleanupStack::PopAndDestroy( &serviceIdArray ); 
   398         // this will the meco UID in case of MECO Service.
 
   384         // this will the meco UID in case of MECO Service.
 
   399         //this is a temperory hack as phonebook doesnot refresh once we delete or add any service
 
   385         //this is a temperory hack as phonebook doesnot refresh once we delete or add any service
 
   400         //once phonebook gives a permanant fix ,remove the below code
 
   386         //once phonebook gives a permanant fix ,remove the below code
 
   401         if(( TUid::Uid(ContactViewUidL( aServiceId )) == TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID )) || aEngine ) 
   387         if(( TUid::Uid(ContactViewUidL( aServiceId )) == TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID )) || aEngine ) 
   402             {                                                               // only MecoServicetabs shutdown phonebook.
 
   388             {                                                               // only MecoServicetabs shutdown phonebook.
 
   403             TRACE( T_LIT("DoHandleNotifyChange() - removing service") );    //or while deleting service from settings
 
   389             TRACE( "removing service" );    //or while deleting service from settings
 
   404             CompressViewIdsL();                                             //check whether engine exists,which is true for only MecoServicetabs.
 
   390             CompressViewIdsL();                                             //check whether engine exists,which is true for only MecoServicetabs.
 
   405             if(aEngine)
 
   391             if(aEngine)
 
   406                 {
 
   392                 {
 
   407                 aEngine->DeleteDataBaseL();
 
   393                 aEngine->DeleteDataBaseL();
 
   408                 }
 
   394                 }
 
   409             ShutDownPhonebookL();
 
   395             ShutDownPhonebookL();
 
   410             }
 
   396             }
 
   411         TRACE( T_LIT("DoHandleNotifyChange() - service removed") );
 
   397         TRACE( "service removed" );
 
   412         }
 
   398         }
 
   413     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::DoHandleNotifyChangeL end"));    
       
   414 
   399 
   415     }
 
   400     }
 
   416 // ---------------------------------------------------------------------------
 
   401 // ---------------------------------------------------------------------------
 
   417 // CVIMPSTEngineServiceTableFetcher::CompressViewIdsL()
 
   402 // CVIMPSTEngineServiceTableFetcher::CompressViewIdsL()
 
   418 // ---------------------------------------------------------------------------
 
   403 // ---------------------------------------------------------------------------
 
   419 //
 
   404 //
 
   420 TBool CVIMPSTEngineServiceTableFetcher::CompressViewIdsL( 
   405 TBool CVIMPSTEngineServiceTableFetcher::CompressViewIdsL( 
   421     TServiceId aServiceId )
 
   406     TServiceId aServiceId )
 
   422     {
 
   407     {
 
   423     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::CompressViewIdsL start"));       
   408 	TRACER_AUTO;
 
   424     TRACE( T_LIT("CompressViewIdsL() ServiceId: %d"), aServiceId );
 
   409 	TRACE(" ServiceId: %d", aServiceId );
 
   425     
   410     
   426     TBool ret = EFalse;
 
   411     TBool ret = EFalse;
 
   427     // Compress view id's in service table
 
   412     // Compress view id's in service table
 
   428     RArray<TServiceId> services;
 
   413     RArray<TServiceId> services;
 
   429     CleanupClosePushL( services );
 
   414     CleanupClosePushL( services );
 
   436         TUint32 refContactUid = ContactViewUidL( serviceId );
 
   421         TUint32 refContactUid = ContactViewUidL( serviceId );
 
   437         if ( TUid::Uid( refContactUid ) == 
   422         if ( TUid::Uid( refContactUid ) == 
   438         TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID ) )
 
   423         TUid::Uid( KIMCONTACTSEXTNIMPLEMENTATIONUID ) )
 
   439             {
 
   424             {
 
   440 
   425 
   441             TRACE( T_LIT("  -> compressing view ids, service: %d"), serviceId );
 
   426         TRACE( "  -> compressing view ids, service: %d", serviceId );
 
   442             TRACE( T_LIT("  -> compressing view ids, view id: (%d)"), ( KVIMPSTTabbedViewIdBase+ serviceId ) );
 
   427         TRACE( "  -> compressing view ids, view id: (%d)", ( KVIMPSTTabbedViewIdBase+ serviceId ) );
 
   443 
   428 
   444             WriteTabViewIdToServiceTableL( services[ i ], ( KVIMPSTTabbedViewIdBase + serviceId ) );
 
   429             WriteTabViewIdToServiceTableL( services[ i ], ( KVIMPSTTabbedViewIdBase + serviceId ) );
 
   445         
   430         
   446             ret = ETrue;
 
   431             ret = ETrue;
 
   447             }
 
   432             }
 
   448         }
 
   433         }
 
   449     CleanupStack::PopAndDestroy( &services );
 
   434     CleanupStack::PopAndDestroy( &services );
 
   450     
   435     
   451     TRACE( T_LIT("CompressViewIdsL returns: (%d)"), ret );     
   436     TRACE( "CompressViewIdsL returns: (%d)", ret );
 
   452     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::CompressViewIdsL end"));    
       
   453     
   437     
   454     return ret;
 
   438     return ret;
 
   455     }
 
   439     }
 
   456 
   440 
   457 
   441 
   460 // ---------------------------------------------------------------------------
 
   444 // ---------------------------------------------------------------------------
 
   461 //
 
   445 //
 
   462 void CVIMPSTEngineServiceTableFetcher::WriteTabViewIdToServiceTableL( 
   446 void CVIMPSTEngineServiceTableFetcher::WriteTabViewIdToServiceTableL( 
   463     TUint32 aServiceId, TUint aViewId ) 
   447     TUint32 aServiceId, TUint aViewId ) 
   464     {
 
   448     {
 
   465     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::WriteTabViewIdToServiceTableL start"));   
   449 	TRACER_AUTO;
 
   466     TRACE( T_LIT("WriteTabViewIdToServiceTableL() aServiceId: %d, aViewId: %d "), 
   450     
   467     										aServiceId, aViewId );
 
   451     TRACE( "aServiceId: %d, aViewId: %d ",aServiceId, aViewId );
 
   468     
   452     
   469     // Write specific view id to service table
 
   453     // Write specific view id to service table
 
   470     // No need to check for error beacuse 
   454     // No need to check for error beacuse 
   471     // we need to add/update the property
 
   455     // we need to add/update the property
 
   472 
   456 
   474     CSPProperty* property = CSPProperty::NewLC();
 
   458     CSPProperty* property = CSPProperty::NewLC();
 
   475     iSettings->FindPropertyL( aServiceId,
 
   459     iSettings->FindPropertyL( aServiceId,
 
   476                                 EPropertyContactViewId,
 
   460                                 EPropertyContactViewId,
 
   477                                 *property );    
   461                                 *property );    
   478     
   462     
   479     TRACE( T_LIT( 
   463     TRACE( " OK");
 
   480        "WriteTabViewIdToServiceTableL() - OK"));
 
       
   481     
   464     
   482     TInt err = property->SetName( EPropertyContactViewId );
 
   465     TInt err = property->SetName( EPropertyContactViewId );
 
   483     
   466     
   484      TRACE( T_LIT( 
   467     TRACE( " ERR1=%d", err );
 
   485        "WriteTabViewIdToServiceTableL ERR1=%d"), err );
 
       
   486     
   468     
   487     TInt err2 = property->SetValue( aViewId );
 
   469     TInt err2 = property->SetValue( aViewId );
 
   488     
   470     
   489     if ( !err && !err2 )
 
   471     if ( !err && !err2 )
 
   490         {
 
   472         {
 
   491         iSettings->AddOrUpdatePropertyL( aServiceId, *property );
 
   473         iSettings->AddOrUpdatePropertyL( aServiceId, *property );
 
   492         }
 
   474         }
 
   493     
   475     
   494     TRACE( T_LIT( 
   476     TRACE(" ERR2=%d", err2 );
 
   495        "WriteTabViewIdToServiceTableL ERR2=%d"), err2 );
 
       
   496         
   477         
   497     
   478     
   498     CleanupStack::PopAndDestroy( property );  
   479     CleanupStack::PopAndDestroy( property );  
   499                    
   480                    
   500     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::WriteTabViewIdToServiceTableL end") );
 
       
   501     }
 
   481     }
 
   502 
   482 
   503 // ---------------------------------------------------------------------------
 
   483 // ---------------------------------------------------------------------------
 
   504 // CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL()
 
   484 // CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL()
 
   505 // ---------------------------------------------------------------------------
 
   485 // ---------------------------------------------------------------------------
 
   506 //
 
   486 //
 
   507 void CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL()
 
   487 void CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL()
 
   508     {
 
   488     {
 
   509     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL start"));   
   489 	TRACER_AUTO;
 
   510     
   490     
   511     // Kills phonebook if running
 
   491     // Kills phonebook if running
 
   512     RWsSession ws;
 
   492     RWsSession ws;
 
   513     User::LeaveIfError( ws.Connect() );
 
   493     User::LeaveIfError( ws.Connect() );
 
   514     CleanupClosePushL( ws );
 
   494     CleanupClosePushL( ws );
 
   519         {
 
   499         {
 
   520         task.EndTask();
 
   500         task.EndTask();
 
   521         }
 
   501         }
 
   522     CleanupStack::PopAndDestroy( &ws ); // ws
 
   502     CleanupStack::PopAndDestroy( &ws ); // ws
 
   523     
   503     
   524     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::ShutDownPhonebookL end"));
 
       
   525     }
 
   504     }
 
   526     
   505     
   527 // ---------------------------------------------------------------------------
 
   506 // ---------------------------------------------------------------------------
 
   528 // CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL()
 
   507 // CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL()
 
   529 // ---------------------------------------------------------------------------
 
   508 // ---------------------------------------------------------------------------
 
   530 //
 
   509 //
 
   531 TInt CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL( 
   510 TInt CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL( 
   532     TUint32 aServiceId )
 
   511     TUint32 aServiceId )
 
   533     {
 
   512     {
 
   534     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL start"));   
   513 	TRACER_AUTO;
 
   535     
   514     
   536     TRACE( T_LIT("XimpAdapterUidL() ServiceId: %d"), aServiceId );
 
   515 	TRACE( "ServiceId: %d", aServiceId );
 
   537     										
   516     										
   538     TInt ret = KErrNotFound;
 
   517     TInt ret = KErrNotFound;
 
   539     CSPProperty* property = CSPProperty::NewLC();
 
   518     CSPProperty* property = CSPProperty::NewLC();
 
   540     
   519     
   541     TInt err = iSettings->FindPropertyL( aServiceId,
 
   520     TInt err = iSettings->FindPropertyL( aServiceId,
 
   546 	    property->GetValue( ret );
 
   525 	    property->GetValue( ret );
 
   547 	    }
 
   526 	    }
 
   548     
   527     
   549     CleanupStack::PopAndDestroy( property );
 
   528     CleanupStack::PopAndDestroy( property );
 
   550     
   529     
   551     TRACE( T_LIT("XimpAdapterUidL() XimpAdapterUid: %d "), 
   530     
   552     										ret );
 
   531     TRACE( "XimpAdapterUid: %d ",ret );
 
   553     										
   532     										
   554     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::XimpAdapterUidL end"));   
       
   555     return ret;
 
   533     return ret;
 
   556     }        
   534     }        
   557     
   535     
   558 // ---------------------------------------------------------------------------
 
   536 // ---------------------------------------------------------------------------
 
   559 // CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL()
 
   537 // CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL()
 
   561 //
 
   539 //
 
   562 TVIMPSTEnums::TVIMPSTPresenceRequestStatus 
   540 TVIMPSTEnums::TVIMPSTPresenceRequestStatus 
   563 CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL( 
   541 CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL( 
   564         TUint32 aServiceId )    
   542         TUint32 aServiceId )    
   565     {
 
   543     {
 
   566     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL  start")); 
   544 	TRACER_AUTO;
 
   567     
   545     
   568     TRACE( T_LIT("PresenceRequestStatusL() ServiceId: %d"), aServiceId );
 
   546 	 TRACE( " ServiceId: %d", aServiceId );
 
   569     
   547     
   570     TVIMPSTEnums::TVIMPSTPresenceRequestStatus ret = 
   548     TVIMPSTEnums::TVIMPSTPresenceRequestStatus ret = 
   571     			TVIMPSTEnums::ESVCEPresenceRequestStatusUnKnown;
 
   549     			TVIMPSTEnums::ESVCEPresenceRequestStatusUnKnown;
 
   572             
   550             
   573     CSPProperty* property = CSPProperty::NewLC();
 
   551     CSPProperty* property = CSPProperty::NewLC();
 
   592             }
 
   570             }
 
   593         }
 
   571         }
 
   594     
   572     
   595     CleanupStack::PopAndDestroy( property );
 
   573     CleanupStack::PopAndDestroy( property );
 
   596     
   574     
   597     TRACE( T_LIT("PresenceRequestStatusL() PresenceRequestStatus: %d "), 
   575     TRACE("PresenceRequestStatus: %d ", ret );
 
   598     										ret );
 
       
   599     										
   576     										
   600     TRACE( T_LIT("CVIMPSTEngineServiceTableFetcher::PresenceRequestStatusL end"));   
       
   601     return ret;        
   577     return ret;        
   602     }
 
   578     }
 
   603   
   579   
   604 // ---------------------------------------------------------------------------
 
   580 // ---------------------------------------------------------------------------
 
   605 // CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL()
 
   581 // CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL()
 
   606 // ---------------------------------------------------------------------------
 
   582 // ---------------------------------------------------------------------------
 
   607 //
 
   583 //
 
   608 void CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL( 
   584 void CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL( 
   609     TUint32 aServiceId, TDes& aDefaultDomainName )
 
   585     TUint32 aServiceId, TDes& aDefaultDomainName )
 
   610     {
 
   586     {
 
   611     TRACE( T_LIT( 
   587 	TRACER_AUTO;
 
   612        "CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL start")); 
   588     
   613     
   589 	
   614     TRACE( T_LIT("GetContactStoreIdL() ServiceId: %d"), aServiceId );
 
   590 	 TRACE( "ServiceId: %d", aServiceId );
 
   615         
   591         
   616     CSPProperty* property = CSPProperty::NewLC();
 
   592     CSPProperty* property = CSPProperty::NewLC();
 
   617     TInt err = iSettings->FindPropertyL( aServiceId,
 
   593     TInt err = iSettings->FindPropertyL( aServiceId,
 
   618                                 ESubPropertyPresenceAddrScheme,      
   594                                 ESubPropertyPresenceAddrScheme,      
   619                                 *property );    
   595                                 *property );    
   622 	    property->GetValue( aDefaultDomainName );	    
   598 	    property->GetValue( aDefaultDomainName );	    
   623 		}
 
   599 		}
 
   624 
   600 
   625     CleanupStack::PopAndDestroy( property );
 
   601     CleanupStack::PopAndDestroy( property );
 
   626     
   602     
   627     TRACE( T_LIT("GetContactStoreIdL() - StoreId: %S"), &aDefaultDomainName );                
   603     TRACE( " StoreId: %S", &aDefaultDomainName );
 
   628     
   604     
   629     TRACE( T_LIT( 
       
   630        "CVIMPSTEngineServiceTableFetcher::GetDefaultDomainNameL end"));  
       
   631  	
   605  	
   632     } 
   606     } 
   633 
   607 
   634    
   608    
   635 // End of file
 
   609 // End of file
FCL/sf/app/conversations