|
1 /* |
|
2 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Operator logo publisher. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <RPhCltServer.h> |
|
20 |
|
21 #include <CPhCltImageHandler.h> |
|
22 #include <CPhCltBaseImageParams.h> |
|
23 |
|
24 #include <PhoneClientServerDomainPStypes.h> |
|
25 #include <fbs.h> |
|
26 #include <e32cmn.h> |
|
27 #include <gulicon.h> |
|
28 #include <centralrepository.h> |
|
29 #include <cenrepnotifyhandler.h> |
|
30 #include <settingsinternalcrkeys.h> |
|
31 #include <PhoneClientServerDomainPSkeys.h> |
|
32 #include <aknlayoutscalable_avkon.cdl.h> |
|
33 #include <AknLayout2ScalableDef.h> |
|
34 #include <bitdev.h> |
|
35 #include <AknStatuspaneUtils.h> |
|
36 #include <AknUtils.h> |
|
37 #include <aipspropertyobserver.h> |
|
38 #include "aioperatorlogopublisher.h" |
|
39 #include "ainetworkinfolistener.h" |
|
40 #include "aidevicestatuscontentmodel.h" |
|
41 #include "aiprioritizer.h" |
|
42 #include "ainwidpriorities.h" |
|
43 #include "debug.h" |
|
44 |
|
45 // Operator Logo showing state is OFF. |
|
46 const TInt KAIDisplayOperatorLogoOff = 0; |
|
47 |
|
48 // Operator Logo showing state is ON. |
|
49 const TInt KAIDisplayOperatorLogoOn = 1; |
|
50 |
|
51 const TInt KAddTwoPixels = 2; |
|
52 const TInt KMaskBlitStartOffset = -1; |
|
53 const TInt KMaskBlitEndOffset = 2; |
|
54 |
|
55 |
|
56 // ======== MEMBER FUNCTIONS ======== |
|
57 |
|
58 CAiOperatorLogoPublisher::CAiOperatorLogoPublisher() |
|
59 : iPriority( EAiInvalidPriority ) |
|
60 { |
|
61 |
|
62 } |
|
63 |
|
64 |
|
65 void CAiOperatorLogoPublisher::ConstructL() |
|
66 { |
|
67 __PRINTS("CAiOperatorLogoPublisher:: ConstructL >>"); |
|
68 iListener = CAiNetworkInfoListener::InstanceL(); |
|
69 |
|
70 iOperatorLogoObserver = AiUtility::CreatePSPropertyObserverL( |
|
71 TCallBack( HandleOperatorLogoUpdateL, this ), |
|
72 KPSUidPhoneClientServerInformation, KTelOperatorLogoUpdated ); |
|
73 |
|
74 iCenRep = CRepository::NewL( KCRUidPersonalizationSettings ); |
|
75 |
|
76 iCenRepNotify = CCenRepNotifyHandler::NewL( *this, |
|
77 *iCenRep, |
|
78 CCenRepNotifyHandler::EIntKey, |
|
79 KSettingsDisplayOperatorLogo ); |
|
80 |
|
81 iCenRepNotify->StartListeningL(); |
|
82 __PRINTS("CAiOperatorLogoPublisher:: ConstructL <<"); |
|
83 } |
|
84 |
|
85 |
|
86 CAiOperatorLogoPublisher* CAiOperatorLogoPublisher::NewL() |
|
87 { |
|
88 CAiOperatorLogoPublisher* self = new( ELeave ) CAiOperatorLogoPublisher; |
|
89 CleanupStack::PushL( self ); |
|
90 self->ConstructL(); |
|
91 CleanupStack::Pop( self ); |
|
92 return self; |
|
93 } |
|
94 |
|
95 |
|
96 CAiOperatorLogoPublisher::~CAiOperatorLogoPublisher() |
|
97 { |
|
98 __PRINTS("CAiOperatorLogoPublisher:: ~CAiOperatorLogoPublisher >>"); |
|
99 if( iCenRepNotify ) |
|
100 { |
|
101 iCenRepNotify->StopListening(); |
|
102 } |
|
103 delete iCenRepNotify; |
|
104 delete iCenRep; |
|
105 if( iListener ) |
|
106 { |
|
107 iListener->RemoveObserver( *this ); |
|
108 iListener->Release(); |
|
109 } |
|
110 delete iIcon; |
|
111 Release( iOperatorLogoObserver ); |
|
112 __PRINTS("CAiOperatorLogoPublisher:: ~CAiOperatorLogoPublisher <<"); |
|
113 } |
|
114 |
|
115 |
|
116 void CAiOperatorLogoPublisher::ResumeL() |
|
117 { |
|
118 __PRINTS("CAiOperatorLogoPublisher:: ResumeL >>"); |
|
119 iListener->AddObserverL( *this ); |
|
120 __PRINTS("CAiOperatorLogoPublisher:: ResumeL <<"); |
|
121 } |
|
122 |
|
123 |
|
124 void CAiOperatorLogoPublisher::HandleNetworkInfoChange( |
|
125 const MNWMessageObserver::TNWMessages& /*aMessage*/, |
|
126 const TNWInfo& /*aInfo*/, |
|
127 const TBool aShowOpInd ) |
|
128 { |
|
129 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: HandleNetworkInfoChange >> aShowOpInd %d "), aShowOpInd); |
|
130 if( aShowOpInd ) |
|
131 { |
|
132 TRAP_IGNORE(UpdateOperatorLogoL( ETrue )); |
|
133 } |
|
134 else |
|
135 { |
|
136 TRAP_IGNORE (iPrioritizer->TryToCleanL( *iBroadcaster, |
|
137 EAiDeviceStatusContentNetworkIdentity, |
|
138 iPriority )); |
|
139 } |
|
140 |
|
141 __PRINTS("CAiOperatorLogoPublisher:: HandleNetworkInfoChange <<"); |
|
142 } |
|
143 |
|
144 |
|
145 void CAiOperatorLogoPublisher::HandleNotifyInt( TUint32 aId, TInt /*aNewValue*/ ) |
|
146 { |
|
147 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: HandleNotifyInt >> aId %d "), aId); |
|
148 if( aId == KSettingsDisplayOperatorLogo ) |
|
149 { |
|
150 TRAP_IGNORE( UpdateOperatorLogoL( ETrue ) ); |
|
151 } |
|
152 __PRINTS("CAiOperatorLogoPublisher:: HandleNotifyInt <<"); |
|
153 } |
|
154 |
|
155 |
|
156 void CAiOperatorLogoPublisher::Subscribe( MAiContentObserver& aObserver, |
|
157 MAiPropertyExtension& aExtension, |
|
158 MAiPublishPrioritizer& aPrioritizer, |
|
159 MAiPublisherBroadcaster& aBroadcaster ) |
|
160 { |
|
161 iContentObserver = &aObserver; |
|
162 iExtension = &aExtension; |
|
163 iPrioritizer = &aPrioritizer; |
|
164 iBroadcaster = &aBroadcaster; |
|
165 } |
|
166 |
|
167 |
|
168 void CAiOperatorLogoPublisher::RefreshL( TBool aClean ) |
|
169 { |
|
170 __PRINTS("CAiOperatorLogoPublisher:: RefresL >> "); |
|
171 TRAP_IGNORE( UpdateOperatorLogoL( aClean ) ); |
|
172 __PRINTS("CAiOperatorLogoPublisher:: RefresL << "); |
|
173 } |
|
174 |
|
175 |
|
176 CFbsBitmap* CAiOperatorLogoPublisher::LoadLogoL( TInt aMCC, |
|
177 TInt aMNC ) |
|
178 { |
|
179 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: LoadLogo >> aMCC %d, aMNC %d"), aMCC, aMNC); |
|
180 CPhCltImageHandler* imageHandler = CPhCltImageHandler::NewL(); |
|
181 User::LeaveIfNull( imageHandler ); |
|
182 |
|
183 CleanupStack::PushL( imageHandler ); |
|
184 |
|
185 // Create image parameter class |
|
186 CPhCltImageParams* params = |
|
187 imageHandler->CPhCltBaseImageParamsL( EPhCltTypeOperatorLogo ); |
|
188 CleanupStack::PushL( params ); |
|
189 |
|
190 TInt err = KErrNotFound; |
|
191 iPriority = EAiOTAOperatorLogo; |
|
192 |
|
193 CPhCltExtOperatorLogoParams* opLogoParams = |
|
194 static_cast<CPhCltExtOperatorLogoParams*>(params); |
|
195 |
|
196 if( opLogoParams ) |
|
197 { |
|
198 opLogoParams->SetCodesL( aMCC, aMNC, EPhCltLogoTypeOTA ); |
|
199 err = imageHandler->LoadImages( params ); |
|
200 |
|
201 if( err == KErrNotFound ) |
|
202 { |
|
203 // OTA logo wasn't found, try programmable logo |
|
204 opLogoParams->SetCodesL( aMCC, aMNC, EPhCltLogoTypeProgrammable ); |
|
205 err = imageHandler->LoadImages( params ); |
|
206 iPriority = EAiProgOperatorLogo; |
|
207 } |
|
208 } |
|
209 else |
|
210 { |
|
211 err = KErrNotFound; |
|
212 } |
|
213 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: LoadLogo >> err %d"), err); |
|
214 User::LeaveIfError( err ); |
|
215 |
|
216 //take always first image, we can show only one logo |
|
217 TInt bitmapHandle = params->GetImageL( 0 ); |
|
218 |
|
219 CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap; |
|
220 CleanupStack::PushL( bitmap ); |
|
221 User::LeaveIfError( bitmap->Duplicate( bitmapHandle ) ); |
|
222 |
|
223 CleanupStack::Pop( bitmap ); |
|
224 |
|
225 CleanupStack::PopAndDestroy( params ); |
|
226 CleanupStack::PopAndDestroy( imageHandler ); |
|
227 __PRINTS("CAiOperatorLogoPublisher:: LoadLogo << "); |
|
228 return bitmap; |
|
229 } |
|
230 |
|
231 |
|
232 void CAiOperatorLogoPublisher::UpdateOperatorLogoL( TBool aClean ) |
|
233 { |
|
234 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: UpdateOperatorLogoL >> aClean %d"), aClean); |
|
235 iSuccess = EFalse; |
|
236 if( aClean ) |
|
237 { |
|
238 iPrioritizer->TryToCleanL( *iBroadcaster, |
|
239 EAiDeviceStatusContentNetworkIdentity, |
|
240 iPriority ); |
|
241 } |
|
242 |
|
243 if( !AllowToShowLogoL() ) |
|
244 { |
|
245 iPrioritizer->TryToCleanL( *iBroadcaster, |
|
246 EAiDeviceStatusContentNetworkIdentity, |
|
247 iPriority ); |
|
248 |
|
249 delete iIcon; |
|
250 iIcon = NULL; |
|
251 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL : not allowed to show logo"); |
|
252 return; |
|
253 } |
|
254 |
|
255 const TNWInfo& info = iListener->NetworkInfo(); |
|
256 |
|
257 if ( info.iRegistrationStatus == ENWNotRegisteredNoService || |
|
258 info.iRegistrationStatus ==ENWRegistrationUnknown ) |
|
259 { |
|
260 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL : registrationstatus unknown"); |
|
261 return; |
|
262 } |
|
263 |
|
264 TInt mcc; |
|
265 |
|
266 TLex lex( info.iCountryCode ); |
|
267 User::LeaveIfError( lex.Val( mcc ) ); |
|
268 |
|
269 TInt mnc; |
|
270 lex.Assign( info.iNetworkId ); |
|
271 User::LeaveIfError( lex.Val( mnc ) ); |
|
272 |
|
273 CFbsBitmap* opLogo = NULL; |
|
274 CFbsBitmap* opLogoMask = NULL; |
|
275 |
|
276 TRAPD( err, opLogo = LoadLogoL( mcc, |
|
277 mnc ) ); |
|
278 |
|
279 if( err ) |
|
280 { |
|
281 opLogo = NULL; |
|
282 } |
|
283 |
|
284 if ( opLogo && opLogo->IsMonochrome() ) |
|
285 { |
|
286 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL : monochrome icon"); |
|
287 CFbsBitmap* bitmap = opLogo; |
|
288 opLogo = NULL; |
|
289 |
|
290 CleanupStack::PushL( bitmap ); |
|
291 CreateMonochromeBitmapsL( *bitmap, opLogo, opLogoMask ); |
|
292 |
|
293 CleanupStack::PopAndDestroy( bitmap ); |
|
294 } |
|
295 |
|
296 //clean always, might be that there is old logo published |
|
297 //and now the logo isn't valid anymore. So publish clean |
|
298 //even if we didn't get new logo |
|
299 if( opLogo ) |
|
300 { |
|
301 delete iIcon; |
|
302 iIcon = NULL; |
|
303 |
|
304 if( opLogoMask ) |
|
305 { |
|
306 iIcon = CGulIcon::NewL( opLogo, opLogoMask ); |
|
307 } |
|
308 else |
|
309 { |
|
310 iIcon = CGulIcon::NewL( opLogo, NULL ); |
|
311 } |
|
312 |
|
313 opLogo = NULL; |
|
314 opLogoMask = NULL; |
|
315 |
|
316 TPckg<CGulIcon*> pckg( iIcon ); |
|
317 |
|
318 iPrioritizer->TryToPublishL( *iBroadcaster, |
|
319 EAiDeviceStatusContentNetworkIdentity, |
|
320 pckg, |
|
321 iPriority ); |
|
322 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL : logo published "); |
|
323 iSuccess = ETrue; |
|
324 } |
|
325 else |
|
326 { |
|
327 iPrioritizer->TryToCleanL( *iBroadcaster, |
|
328 EAiDeviceStatusContentNetworkIdentity, |
|
329 iPriority ); |
|
330 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL : logo cleaned "); |
|
331 } |
|
332 __PRINTS("CAiOperatorLogoPublisher:: UpdateOperatorLogoL << "); |
|
333 } |
|
334 |
|
335 |
|
336 TBool CAiOperatorLogoPublisher::AllowToShowLogoL() const |
|
337 { |
|
338 TInt val; |
|
339 iCenRep->Get( KSettingsDisplayOperatorLogo, val ); |
|
340 return val && iListener->IsOperatorIndicatorAllowed(); |
|
341 } |
|
342 |
|
343 |
|
344 void CAiOperatorLogoPublisher::CreateMonochromeBitmapsL( |
|
345 const CFbsBitmap& aBitmap, |
|
346 CFbsBitmap*& aNewLogoMain, |
|
347 CFbsBitmap*& aNewLogoMask ) |
|
348 { |
|
349 |
|
350 __PRINTS("CAiOperatorLogoPublisher:: CreateMonochromeBitmapsL >> "); |
|
351 TSize size = aBitmap.SizeInPixels(); |
|
352 const TRgb white = TRgb::Gray2( 1 ); |
|
353 |
|
354 // New size 2 pixels larger in every dimension. |
|
355 TSize newSize( size.iWidth + KAddTwoPixels, size.iHeight + KAddTwoPixels ); |
|
356 TPoint delta( 1, 1 ); // adjust image position. |
|
357 |
|
358 TSize opLogoSize; |
|
359 TInt err = GetTitlePaneSize( opLogoSize ); |
|
360 if ( err != KErrNone ) |
|
361 { |
|
362 return; |
|
363 } |
|
364 |
|
365 if ( newSize.iWidth > opLogoSize.iWidth && |
|
366 size.iWidth <= opLogoSize.iWidth ) |
|
367 { |
|
368 newSize.iWidth = size.iWidth; |
|
369 delta.iX = 0; |
|
370 } |
|
371 if ( newSize.iHeight > opLogoSize.iHeight && |
|
372 size.iHeight <= opLogoSize.iHeight ) |
|
373 { |
|
374 newSize.iHeight = size.iHeight; |
|
375 delta.iY = 0; |
|
376 } |
|
377 |
|
378 // Create mask image |
|
379 CFbsBitmap* bitmapLargeMain = |
|
380 new (ELeave) CFbsBitmap; |
|
381 CleanupStack::PushL( bitmapLargeMain ); |
|
382 User::LeaveIfError( |
|
383 bitmapLargeMain->Create( newSize, EGray2 ) ); |
|
384 |
|
385 CFbsBitmapDevice* device = |
|
386 CFbsBitmapDevice::NewL( bitmapLargeMain ); |
|
387 CleanupStack::PushL( device ); |
|
388 |
|
389 CFbsBitGc* gc = NULL; |
|
390 User::LeaveIfError( device->CreateContext( gc ) ); |
|
391 |
|
392 gc->SetPenStyle(CGraphicsContext::ENullPen); |
|
393 gc->SetBrushColor( white ); |
|
394 gc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
395 gc->Clear(); |
|
396 |
|
397 gc->BitBlt( TPoint() + delta, &aBitmap ); |
|
398 |
|
399 delete gc; |
|
400 gc = NULL; |
|
401 |
|
402 CleanupStack::PopAndDestroy( device ); |
|
403 |
|
404 // Create main image |
|
405 CFbsBitmap* bitmapLargeMask = |
|
406 new (ELeave) CFbsBitmap; |
|
407 CleanupStack::PushL( bitmapLargeMask ); |
|
408 User::LeaveIfError( |
|
409 bitmapLargeMask->Create( newSize, EGray2 ) ); |
|
410 |
|
411 CFbsBitmapDevice* deviceMask = |
|
412 CFbsBitmapDevice::NewL( bitmapLargeMask ); |
|
413 CleanupStack::PushL( deviceMask ); |
|
414 |
|
415 User::LeaveIfError( deviceMask->CreateContext( gc ) ); |
|
416 |
|
417 gc->SetPenStyle(CGraphicsContext::ENullPen); |
|
418 gc->SetBrushColor( white ); |
|
419 gc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
420 gc->Clear(); |
|
421 gc->SetBrushStyle(CGraphicsContext::ENullBrush); |
|
422 |
|
423 TPoint point; |
|
424 TRect rect( point, size ); |
|
425 |
|
426 // Blit with mask 3 points from top left to down right. |
|
427 for ( TInt j = KMaskBlitStartOffset; |
|
428 j < KMaskBlitEndOffset; |
|
429 j++ ) |
|
430 { |
|
431 for ( TInt i = KMaskBlitStartOffset; |
|
432 i < KMaskBlitEndOffset; |
|
433 i++ ) |
|
434 { |
|
435 point = TPoint( i, j ); |
|
436 point += delta; |
|
437 gc->BitBltMasked( |
|
438 point, &aBitmap, rect, &aBitmap, ETrue ); |
|
439 } |
|
440 } |
|
441 |
|
442 delete gc; |
|
443 gc = NULL; |
|
444 |
|
445 CleanupStack::PopAndDestroy( deviceMask ); |
|
446 |
|
447 CleanupStack::Pop( bitmapLargeMask ); |
|
448 CleanupStack::Pop( bitmapLargeMain ); |
|
449 |
|
450 aNewLogoMain = bitmapLargeMain; |
|
451 aNewLogoMask = bitmapLargeMask; |
|
452 __PRINTS("CAiOperatorLogoPublisher:: CreateMonochromeBitmapsL << "); |
|
453 } |
|
454 |
|
455 |
|
456 TInt CAiOperatorLogoPublisher::GetTitlePaneSize( TSize& aSize ) |
|
457 { |
|
458 TRect titlePaneRect; |
|
459 TBool hasTitlePane = AknLayoutUtils::LayoutMetricsRect( |
|
460 AknLayoutUtils::ETitlePane, titlePaneRect ); |
|
461 |
|
462 if ( !hasTitlePane ) |
|
463 { |
|
464 return KErrNotFound; |
|
465 } |
|
466 |
|
467 TAknLayoutRect oplogoLayout; |
|
468 |
|
469 if ( AknStatuspaneUtils::StaconPaneActive() ) |
|
470 { |
|
471 // stacon |
|
472 oplogoLayout.LayoutRect( titlePaneRect, |
|
473 AknLayoutScalable_Avkon::title_pane_stacon_g2(0).LayoutLine() ); |
|
474 } |
|
475 else if ( AknStatuspaneUtils::FlatLayoutActive() ) |
|
476 { |
|
477 // flat |
|
478 oplogoLayout.LayoutRect( titlePaneRect, |
|
479 AknLayoutScalable_Avkon::title_pane_stacon_g2(0).LayoutLine() ); |
|
480 } |
|
481 else |
|
482 { |
|
483 // usual idle |
|
484 oplogoLayout.LayoutRect( titlePaneRect, |
|
485 AknLayout::Title_pane_elements_Line_1() ); |
|
486 } |
|
487 |
|
488 aSize = oplogoLayout.Rect().Size(); |
|
489 |
|
490 |
|
491 return KErrNone; |
|
492 } |
|
493 |
|
494 |
|
495 TBool CAiOperatorLogoPublisher::RefreshL( TInt aContentId, TBool aClean ) |
|
496 { |
|
497 |
|
498 if(aContentId == EAiDeviceStatusContentNetworkIdentity ) |
|
499 { |
|
500 __PRINTS("CAiOperatorLogoPublisher:: RefreshL >> "); |
|
501 RefreshL( aClean ); |
|
502 if( iSuccess ) |
|
503 { |
|
504 __PRINTS("CAiOperatorLogoPublisher:: RefreshL << success "); |
|
505 return ETrue; |
|
506 } |
|
507 __PRINTS("CAiOperatorLogoPublisher:: RefreshL << failed "); |
|
508 } |
|
509 return EFalse; |
|
510 } |
|
511 |
|
512 |
|
513 TInt CAiOperatorLogoPublisher::HandleOperatorLogoUpdateL( TAny *aPtr ) |
|
514 { |
|
515 __PRINTS("CAiOperatorLogoPublisher:: HandleOperatorLogoUpdateL >> "); |
|
516 CAiOperatorLogoPublisher* self = static_cast<CAiOperatorLogoPublisher*>( aPtr ); |
|
517 |
|
518 TTelOTALogoUpdate logoUpd; |
|
519 TTelOTALogoUpdate::TOTALogoUpdatePckg logoUpdPckg( logoUpd ); |
|
520 |
|
521 if ( RProperty::Get( |
|
522 KPSUidPhoneClientServerInformation, |
|
523 KTelOperatorLogoUpdated, |
|
524 logoUpdPckg ) == KErrNone ) |
|
525 { |
|
526 __PRINT(__DBG_FORMAT("CAiOperatorLogoPublisher:: HandleOperatorLogoUpdateL >> logoUpd.iEvent %d"), logoUpd.iEvent); |
|
527 if ( logoUpd.iEvent == TTelOTALogoUpdate::EPSTelephonyLogoChanged ) |
|
528 { |
|
529 if(self) |
|
530 { |
|
531 __PRINTS("CAiOperatorLogoPublisher:: HandleOperatorLogoUpdateL: logo changed "); |
|
532 self->iCenRep->Set( KSettingsDisplayOperatorLogo, KAIDisplayOperatorLogoOn ); |
|
533 self->UpdateOperatorLogoL( ETrue ); |
|
534 } |
|
535 } |
|
536 else if ( logoUpd.iEvent == TTelOTALogoUpdate::EPSTelephonyLogoDeleted || |
|
537 logoUpd.iEvent == TTelOTALogoUpdate::EPSTelephonyAllLogosDeleted ) |
|
538 { |
|
539 if(self) |
|
540 { |
|
541 __PRINTS("CAiOperatorLogoPublisher:: HandleOperatorLogoUpdateL: logo deleted "); |
|
542 self->iCenRep->Set( KSettingsDisplayOperatorLogo, KAIDisplayOperatorLogoOff ); |
|
543 self->UpdateOperatorLogoL( ETrue ); |
|
544 } |
|
545 } |
|
546 |
|
547 } |
|
548 __PRINTS("CAiOperatorLogoPublisher:: HandleOperatorLogoUpdateL << "); |
|
549 return KErrNone; |
|
550 } |
|
551 |
|
552 |
|
553 TBool CAiOperatorLogoPublisher::RefreshContentWithPriorityL( TInt aContentId, |
|
554 TInt aPriority ) |
|
555 { |
|
556 if( aContentId == EAiDeviceStatusContentNetworkIdentity && |
|
557 ( aPriority == EAiOTAOperatorLogo || |
|
558 aPriority == EAiProgOperatorLogo ) ) |
|
559 { |
|
560 __PRINTS("CAiOperatorLogoPublisher:: RefreshContentWithPriorityL >> "); |
|
561 RefreshL( EFalse ); |
|
562 if( iSuccess ) |
|
563 { |
|
564 __PRINTS("CAiOperatorLogoPublisher:: RefreshContentWithPriorityL << success"); |
|
565 return ETrue; |
|
566 } |
|
567 __PRINTS("CAiOperatorLogoPublisher:: RefreshContentWithPriorityL << failed"); |
|
568 } |
|
569 return EFalse; |
|
570 } |
|
571 |