idlefw/plugins/devicestatus/src/aioperatorlogopublisher.cpp
branchRCL_3
changeset 8 d0529222e3f0
parent 0 79c6a41cd166
child 16 b276298d5729
equal deleted inserted replaced
4:1a2a00e78665 8:d0529222e3f0
   125 							const MNWMessageObserver::TNWMessages& /*aMessage*/,
   125 							const MNWMessageObserver::TNWMessages& /*aMessage*/,
   126 							const TNWInfo& /*aInfo*/,
   126 							const TNWInfo& /*aInfo*/,
   127 							const TBool aShowOpInd )
   127 							const TBool aShowOpInd )
   128     {
   128     {
   129     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: HandleNetworkInfoChange >> aShowOpInd %d "), aShowOpInd);
   129     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: HandleNetworkInfoChange >> aShowOpInd %d "), aShowOpInd);
   130         if( aShowOpInd )
   130 
   131         	{
   131     if ( iSuspended )
   132         	TRAP_IGNORE(UpdateOperatorLogoL( ETrue ));
   132         {
   133         	}
   133         __PRINTS("CAiOperatorLogoPublisher:: HandleNetworkInfoChange - suspended <<");
   134         else
   134         return;
   135         	{
   135         }
   136         	TRAP_IGNORE (iPrioritizer->TryToCleanL( *iBroadcaster,
   136     
   137             							EAiDeviceStatusContentNetworkIdentity,
   137     if( aShowOpInd )
   138             							iPriority ));
   138         {
   139         	}
   139         TRAP_IGNORE( UpdateOperatorLogoL( ETrue ) );
       
   140         }
       
   141     else
       
   142         {
       
   143         TRAP_IGNORE (iPrioritizer->TryToCleanL( *iBroadcaster,
       
   144                                     EAiDeviceStatusContentNetworkIdentity,
       
   145                                     iPriority ));
       
   146         }
   140         
   147         
   141     __PRINTS("CAiOperatorLogoPublisher:: HandleNetworkInfoChange <<");
   148     __PRINTS("CAiOperatorLogoPublisher:: HandleNetworkInfoChange <<");
   142     }
   149     }
   143 
   150 
   144 
   151 
   152     __PRINTS("CAiOperatorLogoPublisher:: HandleNotifyInt <<");
   159     __PRINTS("CAiOperatorLogoPublisher:: HandleNotifyInt <<");
   153 	}
   160 	}
   154 	
   161 	
   155 	
   162 	
   156 void CAiOperatorLogoPublisher::Subscribe( MAiContentObserver& aObserver, 
   163 void CAiOperatorLogoPublisher::Subscribe( MAiContentObserver& aObserver, 
   157 									        MAiPropertyExtension& aExtension,
   164 									        CHsContentPublisher& aExtension,
   158                                             MAiPublishPrioritizer& aPrioritizer,
   165                                             MAiPublishPrioritizer& aPrioritizer,
   159                                             MAiPublisherBroadcaster& aBroadcaster )
   166                                             MAiPublisherBroadcaster& aBroadcaster )
   160     {
   167     {
   161     iContentObserver = &aObserver;
   168     iContentObserver = &aObserver;
   162     iExtension = &aExtension;
   169     iExtension = &aExtension;
   169     {
   176     {
   170     __PRINTS("CAiOperatorLogoPublisher:: RefresL >> ");
   177     __PRINTS("CAiOperatorLogoPublisher:: RefresL >> ");
   171     TRAP_IGNORE( UpdateOperatorLogoL( aClean ) );
   178     TRAP_IGNORE( UpdateOperatorLogoL( aClean ) );
   172     __PRINTS("CAiOperatorLogoPublisher:: RefresL << ");
   179     __PRINTS("CAiOperatorLogoPublisher:: RefresL << ");
   173     }
   180     }
   174 
       
   175 
   181 
   176 CFbsBitmap* CAiOperatorLogoPublisher::LoadLogoL( TInt aMCC, 
   182 CFbsBitmap* CAiOperatorLogoPublisher::LoadLogoL( TInt aMCC, 
   177                                                  TInt aMNC )
   183                                                  TInt aMNC )
   178     {
   184     {
   179     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: LoadLogo >> aMCC %d, aMNC %d"), aMCC, aMNC);
   185     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: LoadLogo >> aMCC %d, aMNC %d"), aMCC, aMNC);
   231 
   237 
   232 void CAiOperatorLogoPublisher::UpdateOperatorLogoL( TBool aClean )
   238 void CAiOperatorLogoPublisher::UpdateOperatorLogoL( TBool aClean )
   233     {
   239     {
   234     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: UpdateOperatorLogoL >> aClean %d"), aClean);
   240     __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: UpdateOperatorLogoL >> aClean %d"), aClean);
   235     iSuccess = EFalse;
   241     iSuccess = EFalse;
       
   242     
       
   243     if ( iSuspended )
       
   244         {
       
   245         // EAiDeviceStatusContentNetworkIdentity is suspended
       
   246         
       
   247         __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL - suspended <<");
       
   248         return;
       
   249         }
       
   250     
   236     if( aClean )
   251     if( aClean )
   237         {
   252         {
   238         iPrioritizer->TryToCleanL( *iBroadcaster,
   253         iPrioritizer->TryToCleanL( *iBroadcaster,
   239         							EAiDeviceStatusContentNetworkIdentity,
   254         							EAiDeviceStatusContentNetworkIdentity,
   240         							iPriority );
   255         							iPriority );
   491     return KErrNone;  
   506     return KErrNone;  
   492     }
   507     }
   493 
   508 
   494 
   509 
   495 TBool CAiOperatorLogoPublisher::RefreshL( TInt aContentId, TBool aClean )
   510 TBool CAiOperatorLogoPublisher::RefreshL( TInt aContentId, TBool aClean )
   496 	{
   511 	{	
   497 	
   512     if ( aContentId == EAiDeviceStatusContentNetworkIdentity )
   498     if(aContentId == EAiDeviceStatusContentNetworkIdentity )
   513         {
   499         {
   514         iSuspended = EFalse;
       
   515         
   500         __PRINTS("CAiOperatorLogoPublisher:: RefreshL >> ");
   516         __PRINTS("CAiOperatorLogoPublisher:: RefreshL >> ");
   501    	    RefreshL( aClean );
   517    	    RefreshL( aClean );
   502    	    if( iSuccess )
   518    	    if( iSuccess )
   503    	        {
   519    	        {
   504    	        __PRINTS("CAiOperatorLogoPublisher:: RefreshL << success ");
   520    	        __PRINTS("CAiOperatorLogoPublisher:: RefreshL << success ");
   505    	        return ETrue;
   521    	        return ETrue;
   506    	        }   
   522    	        }   
   507    	    __PRINTS("CAiOperatorLogoPublisher:: RefreshL << failed ");	    
   523    	    __PRINTS("CAiOperatorLogoPublisher:: RefreshL << failed ");	    
   508     	}    	
   524     	}    	
       
   525     
   509     return EFalse;
   526     return EFalse;
   510 	}
   527 	}
   511 
   528 
       
   529 TBool CAiOperatorLogoPublisher::SuspendL( TInt aContentId, TBool /*aClean*/ )
       
   530     {
       
   531     if ( aContentId == EAiDeviceStatusContentNetworkIdentity )
       
   532         {
       
   533         iSuspended = ETrue;
       
   534         
       
   535         return ETrue;
       
   536         }
       
   537     
       
   538     return EFalse;
       
   539     }
   512 
   540 
   513 TInt CAiOperatorLogoPublisher::HandleOperatorLogoUpdateL( TAny *aPtr )
   541 TInt CAiOperatorLogoPublisher::HandleOperatorLogoUpdateL( TAny *aPtr )
   514 	{
   542 	{
   515 	__PRINTS("CAiOperatorLogoPublisher::  HandleOperatorLogoUpdateL >> ");
   543 	__PRINTS("CAiOperatorLogoPublisher::  HandleOperatorLogoUpdateL >> ");
   516 	CAiOperatorLogoPublisher* self = static_cast<CAiOperatorLogoPublisher*>( aPtr );
   544 	CAiOperatorLogoPublisher* self = static_cast<CAiOperatorLogoPublisher*>( aPtr );