1 /*

     2 * Copyright (c) 2002-2008 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:  System soft notifications.

    15 *

    16 */

    17 

    18 

    19 #include <uikon/eiksrvui.h>

    20 #include <AknNotiferAppServerApplication.h>

    21 #include "AknSystemPopup.h"

    22 #include <AknNotifyStd.h>

    23 #include <AknNotifierControllerPlugin.h>

    24 

    25 #include <avkon.rsg>

    26 #include <avkon.mbg>

    27 #include <eikbtgpc.h>

    28 #include <eikenv.h>

    29 #include <avkon.hrh>

    30 #include <eikimage.h>

    31 #include <barsread.h>

    32 

    33 #include <aknnotpi.rsg>

    34 

    35 #include "AknNotifyPlugin.hrh"

    36 #include <aknnotedialog.h>

    37 #include <aknnotecontrol.h>

    38 #include <aknconsts.h>

    39 

    40 #include <s32mem.h>

    41 #include <viewcli.h>

    42 #include <e32base.h>

    43 

    44 #include <AknNotifySignature.h>

    45 #include <aknnoteattributes.h> // for icon to skin conversion

    46 

    47 #include <AknCapServer.h>

    48 #include "AknCapServerEntry.h"

    49 #include <AknMediatorFacade.h>

    50 #include <aknSDData.h>

    51 

    52 #include <SecondaryDisplay/AknSecondaryDisplayDefs.h>

    53 #include <AknsUtils.h>

    54 #include <aknglobalpopupprioritycontroller.h>

    55 #include "GlobalWindowPriorities.h"

    56 #include "aknmessagereaderlongpressdetector.h" // CAknMessageReaderLongPressDetector    

    57 

    58 #include <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus

    59 

    60 #include "AknDynamicNotificationData.h"

    61 #include "AknPrivateImageLoader.h"

    62 #include <AknUtils.h>

    63 #include <aknlayout.cdl.h>

    64 

    65 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    66 

    67     #include <gfxtranseffect/gfxtranseffect.h>

    68     #include <akntransitionutils.h>

    69 

    70 #endif

    71 

    72 

    73 const TInt KGlobalNoteGranularity = 4; // Initialize with space for 4 notes

    74 

    75 const TInt KMaxSoftNotePriority = 3000;

    76 const TInt KMaxAlarmNotePriority = 4000;

    77 const TInt KMaxNotePriority = 5000;

    78 const TInt KAlarmNotePriority = 3095;

    79 

    80 // class CGlobalNoteInfo

    81 

    82 CGlobalNoteInfo::CGlobalNoteInfo() :

    83     iSoftkeys( 0 ),

    84     iGraphic( -1 ),

    85     iAnimation( 0 ),

    86     iPlural( 0 ),

    87     iAsync( EFalse ),

    88     iTextProcessing( ETrue ),

    89     iSDData(NULL),

    90     iGlobalPopupPriority(0)

    91     {

    92     }

    93 

    94 CGlobalNoteInfo::~CGlobalNoteInfo()

    95     {

    96     delete iSDData;

    97     }

    98     

    99 // class CAknGlobalNoteDialog

   100 

   101 

   102 CAknGlobalNoteDialog::CAknGlobalNoteDialog(MGlobalNoteObserver* aObserver)

   103 :iObserver(aObserver), iPreviousNoteId( KErrNotFound )

   104     {

   105     iCommand = KErrCancel;

   106     }

   107 

   108 void CAknGlobalNoteDialog::ConstructL()

   109     {

   110     ConstructSleepingDialogL(R_GLOBAL_NOTE);

   111     }

   112 

   113 CAknGlobalNoteDialog::~CAknGlobalNoteDialog()

   114     {

   115     delete iImageLoader;

   116     }

   117 

   118 TBool CAknGlobalNoteDialog::OkToExitL(TInt aButtonId)

   119     {

   120     

   121     ((CAknCapAppServerAppUi*) CEikonEnv::Static()->AppUi())->SetIsShortTimeGlobalNoteDisplaying(EFalse);

   122         

   123     if ( (iControlType == R_PERMANENT_CONTROL) ||

   124          (iControlType == R_WAIT_CONTROL && iSoftkeys == R_AVKON_SOFTKEYS_EMPTY) )

   125         {

   126         return EFalse;

   127         }

   128 

   129     else if ( iIsAlarm )

   130         {

   131         // Don't let an empty command through.

   132         if ( aButtonId == EAknSoftkeyEmpty )

   133             {

   134             return EFalse;

   135             }

   136 

   137         CEikButtonGroupContainer& bgc = ButtonGroupContainer();

   138 

   139         if ( aButtonId == EAlertSilence )

   140             {

   141             if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT__OPEN )

   142                 {

   143                 iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE__OPEN;

   144                 }

   145             else // R_ALERT_SOFTKEYS_STOP_SILENT

   146                 {

   147                 iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE;

   148                 }

   149             bgc.SetCommandSetL( iSoftkeys );

   150             bgc.ActivateL();

   151             bgc.MakeVisible( ETrue );            

   152             bgc.DrawNow();

   153             iObserver->GlobalNoteCompleted( EAlertSilence );

   154             return EFalse;

   155             }

   156 

   157         // make sure that rsk will be visible next time

   158         // (this is actually a CBA fault but anyway).

   159         else if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE &&

   160                   !bgc.IsCommandVisible( EAlertSnooze ) )

   161             {

   162             bgc.MakeCommandVisible( EAlertSnooze, ETrue );

   163             }

   164             

   165         if ( aButtonId == EAlertOpen )

   166             {

   167             if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT__OPEN ||

   168                  iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE__OPEN ||

   169                  iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE )

   170                 {

   171                 iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE;

   172                 }

   173             else if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT )

   174                 {

   175                 iSoftkeys = R_ALERT_SOFTKEYS_STOP_SILENT ;

   176                 }

   177             else // R_ALERT_SOFTKEYS_STOP_EMPTY__OPEN

   178                 {

   179                 iSoftkeys = R_ALERT_SOFTKEYS_STOP_EMPTY__EMPTY;

   180                 }

   181 

   182             bgc.SetCommandSetL( iSoftkeys );

   183             bgc.ActivateL();

   184             bgc.MakeVisible( ETrue );            

   185             bgc.DrawNow();

   186             iObserver->GlobalNoteCompleted( EAlertOpen );

   187             return EFalse;

   188             }

   189         }

   190 

   191     iCommand = aButtonId;

   192     NextNoteOrExit();

   193     return ETrue;

   194     }

   195 

   196 

   197 void CAknGlobalNoteDialog::PreLayoutDynInitL()

   198     {

   199     delete iTimer;

   200     iTimer = NULL;

   201     if ( iTimeoutInMicroseconds != ENoTimeout )

   202         {

   203         iTimer = CPeriodic::NewL(0);

   204         iTimer->Start(iTimeoutInMicroseconds, iTimeoutInMicroseconds, 

   205             TCallBack(CallNextNoteOrExit,this));

   206         }

   207 

   208     TransferControlAttributes(); // Ensure that new layout will be done

   209 

   210     if (iIsSoftNotification && iObserver->IsAppsKeyLocked() )

   211         {

   212         iObserver->SetAppsKeyLocked( EFalse );

   213         }

   214     }

   215 

   216 void CAknGlobalNoteDialog::HandleResourceChange(TInt aType)

   217     {

   218     if ( aType == KAknsMessageSkinChange )  

   219         {

   220         iPreviousAnimation = 0; // reload next animation always

   221         }

   222         

   223     CAknStaticNoteDialog::HandleResourceChange(aType);

   224     }

   225 

   226 

   227 void CAknGlobalNoteDialog::PostLayoutDynInitL()

   228     {

   229     CEikButtonGroupContainer& bgc = ButtonGroupContainer();

   230 

   231     if ( iSoftkeys )

   232         {

   233         bgc.SetCommandSetL(iSoftkeys);

   234         MEikButtonGroup* buttonGrp = bgc.ButtonGroup();

   235         if( buttonGrp )

   236             {

   237             if( iSoftkeyLeft.Length() > 0 )

   238                 {

   239                 bgc.SetCommandL( buttonGrp->CommandId( 

   240                     CEikButtonGroupContainer::ELeftSoftkeyPosition ), 

   241                     iSoftkeyLeft );

   242                 }

   243             if( iSoftkeyRight.Length() > 0 )

   244                 {

   245                 bgc.SetCommandL( buttonGrp->CommandId( 

   246                     CEikButtonGroupContainer::ERightSoftkeyPosition ),

   247                     iSoftkeyRight );

   248                 }

   249 

   250             if (AknLayoutUtils::PenEnabled())

   251                 {

   252                 if (iIsSoftNotification && iAutoLock)

   253                     {

   254                     bgc.MakeCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ELeftSoftkeyPosition), EFalse);

   255                     bgc.MakeCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ERightSoftkeyPosition), EFalse);

   256                     }

   257                 else

   258                     {

   259                     if (!bgc.IsCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ELeftSoftkeyPosition)))

   260                         bgc.MakeCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ELeftSoftkeyPosition), ETrue);

   261                     if (!bgc.IsCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ERightSoftkeyPosition)))

   262                         bgc.MakeCommandVisible(buttonGrp->CommandId(CEikButtonGroupContainer::ERightSoftkeyPosition), ETrue);

   263                     }

   264                 }

   265             }

   266         }

   267 

   268     CAknStaticNoteDialog::PostLayoutDynInitL();

   269 

   270     if ( iIsSoftNotification && (iAutoLock > EAutolockOff) )

   271         { // members below exist always when dialog exists,

   272           // LockKeys can be called multiple w/o problems, but as a optimisation, lets not

   273         if (!((CAknGlobalNoteSubject*)iObserver)->iKeyLockController->IsKeyLockEnabled())

   274             {            

   275             ((CAknGlobalNoteSubject*)iObserver)->iKeyLockController->LockKeys(ETrue);

   276             }

   277         }

   278 

   279     // Play the note note here, since RunLD will not be called (which is where tones are normally played from)

   280     PlayTone();

   281     if (!iObserver->IsAppsKeyLocked() && !iIsSoftNotification)

   282         {

   283         if(iTimeoutInMicroseconds != EShortTimeout)

   284            {   

   285            iObserver->SetAppsKeyLocked( ETrue );

   286            }

   287         }

   288     }

   289 

   290 TKeyResponse CAknGlobalNoteDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

   291     {

   292     if (iIsSoftNotification && aType == EEventKey)

   293         {

   294         // Send numbers keys to phone app, and bring it for foreground

   295         if ((aKeyEvent.iCode >= '0' && aKeyEvent.iCode <= '9') 

   296             || aKeyEvent.iCode == '#' 

   297             || aKeyEvent.iCode == '*')

   298             {

   299             if( aKeyEvent.iRepeats == 0 )

   300                 {

   301                 MAknPhoneKeyForwarder* keyf = STATIC_CAST(

   302                     CAknCapAppServerAppUi*, 

   303                     CEikonEnv::Static()->AppUi())->AsKeyForwarder();

   304                 

   305                 keyf->ForwardKeyToPhoneAppL(aKeyEvent);

   306             

   307                 ((CAknGlobalNoteSubject*)iObserver)->SetMaxDisplayPriorityL(KMinimumSoftNotePriority);

   308                 }

   309             return EKeyWasConsumed;

   310             }

   311         else if ( aKeyEvent.iCode == EKeyEnter )

   312             {

   313             TKeyEvent ccpuStart = { EKeyOK, EStdKeyDevice3, 0, 0 };

   314             CCoeEnv::Static()->SimulateKeyEventL( ccpuStart, EEventKey );	

   315             return EKeyWasConsumed;

   316             }    

   317         else if ( aKeyEvent.iCode != EKeyOK ) //Other keys don't remove soft notification.

   318             {

   319             if ( aKeyEvent.iCode == EKeyNo )

   320                 {

   321                 iCommand = EAknSoftkeyExit;

   322                 NextNoteOrExit();

   323                 }

   324 

   325             return EKeyWasConsumed;

   326             }

   327         }

   328 

   329     if (aKeyEvent.iCode == EKeyEscape)

   330         {

   331         return EKeyWasNotConsumed;

   332         }

   333 

   334     // Don't consume send key for displaying the dialer view,

   335     // only for soft notification.

   336     if (aKeyEvent.iScanCode == EStdKeyYes && iIsSoftNotification)

   337         {

   338         return EKeyWasNotConsumed;

   339         }

   340 

   341     if (iControlType == R_PERMANENT_CONTROL || 

   342         iControlType == R_WAIT_CONTROL      || 

   343         iTimeoutInMicroseconds == ENoTimeout)

   344         {

   345         return EKeyWasConsumed;

   346         }

   347 

   348     // Any keypress dismissed other types of notes

   349     if (aType == EEventKey)

   350         {

   351         NextNoteOrExit();

   352         }

   353     return EKeyWasConsumed;

   354     }

   355 

   356 TBool CAknGlobalNoteDialog::CallNextNoteOrExit(TAny* aThis)

   357     {

   358     STATIC_CAST(CAknGlobalNoteDialog*, aThis)->NextNoteOrExit();

   359     return ETrue;

   360     }

   361 

   362 void CAknGlobalNoteDialog::NextNoteOrExit(TBool aDirectExit)

   363     {

   364     // If there is another global note waiting, show the next note,

   365     // otherwise put the global note back to sleep

   366     delete iTimer;

   367     iTimer = NULL;

   368     

   369     // if there are more notes on queue, don't release the apps key

   370     if (iObserver->IsAppsKeyLocked() && !iObserver->NoteWaiting())

   371         {

   372         iObserver->SetAppsKeyLocked( EFalse );

   373         }

   374         

   375     // Set borders back to zero

   376     SetNumberOfBorders(0);

   377 

   378     // to make sure that we don't leave RSK hidden even if OkToExitL is not called

   379     if (aDirectExit)

   380         {

   381         CEikButtonGroupContainer& bgc = ButtonGroupContainer();

   382         if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE &&

   383              !bgc.IsCommandVisible( EAlertSnooze ) )

   384             {

   385             bgc.MakeCommandVisible( EAlertSnooze, ETrue );

   386             }

   387         }

   388 

   389 #ifdef RD_SCALABLE_UI_V2

   390     if ( AknLayoutUtils::PenEnabled() )

   391         {

   392         SetGloballyCapturing( EFalse );

   393         SetPointerCapture( EFalse );

   394         }

   395 #endif // RD_SCALABLE_UI_V2

   396 

   397     ExitSleepingDialog();

   398     iDialogActive = EFalse;

   399     

   400     TRAP_IGNORE( PublishDialogL( 0 ) ); // to reset 

   401     iObserver->GlobalNoteCompleted(iCommand);

   402     }

   403 

   404 void CAknGlobalNoteDialog::RemoveCurrentNote()

   405     {

   406     // Removes the current global note, so that a non-note dialog can be

   407     // shown

   408     delete iTimer;

   409     iTimer = NULL;

   410 #ifdef RD_SCALABLE_UI_V2

   411     if ( AknLayoutUtils::PenEnabled() )

   412         {

   413         SetGloballyCapturing( EFalse );

   414         SetPointerCapture( EFalse );

   415         }

   416 #endif // RD_SCALABLE_UI_V2

   417 

   418     ExitSleepingDialog();

   419     iDialogActive = EFalse;

   420     }

   421 

   422 void CAknGlobalNoteDialog::UpdateNoteAndDisplayL( CGlobalNoteInfo* aInfo )

   423     {

   424     TInt                     notePriority  = aInfo->iPriority;

   425     TInt                     noteResource  = aInfo->iResourceId;

   426     TInt                     noteSoftkeys  = aInfo->iSoftkeys;

   427     TInt                     notePlural    = aInfo->iPlural;

   428     TInt                     noteGraphic   = aInfo->iGraphic;

   429     TInt                     noteGraphicM  = aInfo->iGraphicMask;

   430     TInt                     noteAnimation = aInfo->iAnimation;

   431     CAknNoteDialog::TTimeout noteTimeout   = aInfo->iTimeOut;

   432     CAknNoteDialog::TTone    noteTone      = aInfo->iTone;

   433     CAknSDData*              noteSDData    = aInfo->iSDData;

   434     

   435     iCommand = KErrCancel;

   436     iTimeoutInMicroseconds = noteTimeout;

   437     iControlType = noteResource;

   438     

   439     iIsSoftNotification = (

   440         notePriority >= KMinimumSoftNotePriority && 

   441         notePriority <= KMaxSoftNotePriority );

   442     

   443     //close the blank screen when global note display

   444     if (noteTimeout == EShortTimeout)

   445         {

   446         CAknCapAppServerAppUi* pAppui =

   447                 (CAknCapAppServerAppUi*) CEikonEnv::Static()->AppUi();

   448         pAppui->SetIsShortTimeGlobalNoteDisplaying(ETrue);

   449         }

   450     

   451 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

   452     

   453     // use soft notify context

   454     if( iIsSoftNotification )

   455         {

   456         GfxTransEffect::Register( this, KGfxSystemNotificationControlUid );

   457         }

   458     else // must register other possible contexts (global notes)    

   459         {

   460         class TResIdToContext

   461             {

   462             public:

   463             TInt iResId;

   464             TUid iContextId;

   465             };

   466         

   467         TResIdToContext mapArray[] = 

   468         { 

   469         R_INFORMATION_CONTROL, KGfxInformationNoteControlUid,

   470         R_WARNING_CONTROL, KGfxWarningNoteControlUid,

   471         R_CONFIRMATION_CONTROL, KGfxConfirmationNoteControlUid,

   472         R_ERROR_CONTROL, KGfxErrorNoteControlUid,

   473         R_WAIT_CONTROL, KGfxWaitNoteControlUid, 

   474         R_BATTERY_CHARGING_CONTROL,KGfxSystemNotifBatteryControlUid,

   475         R_BATTERY_NOT_CHARGING_CONTROL,KGfxSystemNotifBatteryControlUid,

   476         R_BATTERY_FULL_CONTROL,KGfxSystemNotifBatteryControlUid,

   477         R_BATTERY_LOW_CONTROL,KGfxSystemNotifBatteryControlUid,

   478         R_RECHARGE_BATTERY_CONTROL,KGfxSystemNotifBatteryControlUid

   479         };

   480         

   481         TUid contextId = TUid::Uid(0);

   482         for( TInt i = 0; i<sizeof(mapArray)/sizeof(TResIdToContext); i++ )

   483             {

   484             if( mapArray[i].iResId == noteResource )

   485                 {

   486                 contextId = mapArray[i].iContextId;

   487                 break;

   488                 }

   489             }

   490         

   491         if( contextId.iUid == 0 )        

   492             {

   493             contextId = KGfxPopupDefaultControlUid;

   494             }

   495             

   496         GfxTransEffect::Register( this, contextId );

   497         }

   498     

   499 #endif // RD_UI_TRANSITION_EFFECTS_POPUPS

   500         

   501     iIsAlarm = ( notePriority == KAlarmNotePriority );

   502     iIsAlarmWakeup = (iIsAlarm && aInfo->iAlmFlag == EAskWakeUp);

   503     iSoftkeys = noteSoftkeys;

   504 

   505 #ifdef RD_SCALABLE_UI_V2

   506     if ( AknLayoutUtils::PenEnabled() )

   507         {

   508         SetGloballyCapturing( ETrue ); 

   509         SetPointerCapture( ETrue ); 

   510         }

   511 #endif

   512 

   513     if ( !iSoftkeys )

   514         {

   515         if (iControlType == R_WAIT_CONTROL)

   516             {

   517             iSoftkeys = R_AVKON_SOFTKEYS_CANCEL;

   518             }

   519         else if ( notePriority != KAlarmNotePriority )

   520             {

   521             iSoftkeys = R_AVKON_SOFTKEYS_EMPTY;

   522             }

   523         }

   524     

   525     iSoftkeyLeft.Set( aInfo->iLeftSK );

   526     iSoftkeyRight.Set( aInfo->iRightSK );

   527 

   528     if (aInfo->iImage.Length() <= 0)

   529         {

   530         // Exit sleeping dialog firstly for preventing from ui flicker.

   531         ExitSleepingDialog();

   532         }

   533 

   534     if( iPreviousNoteId != aInfo->iNoteId && 

   535         aInfo->iImage.Length() > 0 &&

   536         !noteResource )

   537         {

   538         // this is dynamic soft notification with new image.

   539         // Set dialogs layout with resource.

   540         noteResource = R_NEW_DYNAMIC_NOTIFIER_NOTE;

   541         }    

   542     

   543     CAknNoteControl* note = STATIC_CAST( CAknNoteControl*, Control(ENPIGlobalNote) );

   544     if ( noteResource )

   545         {

   546         TResourceReader reader;

   547         iEikonEnv->CreateResourceReaderLC( reader, noteResource );

   548         note->ConstructFromResourceL( reader );

   549         CleanupStack::PopAndDestroy();  // reader

   550         }

   551 

   552     SetTextProcessing( aInfo->iTextProcessing );

   553 

   554     if ( aInfo->iText.Length() )

   555         {

   556         SetTextL( aInfo->iText );

   557         }

   558     if ( notePlural > 0 )

   559         {

   560         SetTextNumberL( notePlural );

   561         }

   562 

   563     // check whether this is the same note we showed last time

   564     TBool noteChanged = ( iPreviousNoteId != aInfo->iNoteId );

   565     iPreviousNoteId = aInfo->iNoteId;

   566     TBool asyncImageLoading = EFalse; // delay dialog until image is loaded

   567     

   568     if( aInfo->iImage.Length() > 0 )

   569         {

   570         // Only load image if the notification has changed

   571         if( noteChanged )

   572             {

   573             // Get icon size from LAF

   574             TRect mainpane;

   575             AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, mainpane );

   576             TAknLayoutRect noterect;

   577             noterect.LayoutRect( mainpane, AknLayout::popup_note_image_window() );

   578             TAknLayoutRect gfxrect;

   579             gfxrect.LayoutRect( noterect.Rect(), 

   580                 AknLayout::Note_with_an_image_pop_up_window_elements_Line_12() );

   581 

   582             // Create image loader

   583             if( !iImageLoader )

   584                 {

   585                 iImageLoader = CAknPrivateImageLoader::NewL( 

   586                     CEikonEnv::Static()->FsSession(), *this );

   587                 }

   588             

   589             // load icon

   590             TRAPD( err, 

   591                 iImageLoader->LoadIconL( aInfo->iImage, gfxrect.Rect().Size() ) );

   592             

   593             if( !err )

   594                 {

   595                 // we're loading image -> delay dialog until loading is done

   596                 asyncImageLoading = ETrue;

   597                 }

   598             else

   599                 {

   600                 // when image loading fails, we reset the dialog's image

   601                 SetImageL( NULL );

   602                 }

   603             }

   604         }

   605     if ( noteGraphic != -1 )

   606         {

   607         MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   608 

   609         CEikImage* image = new (ELeave) CEikImage;

   610         CleanupStack::PushL( image );

   611 

   612         //Check For Skin Icon 

   613         TAknsItemID id = CAknNoteAttributes::GetSkinnedBitmapID( noteGraphic );

   614 

   615         CFbsBitmap* bitmap = NULL;

   616         CFbsBitmap* mask = NULL;

   617        

   618         AknsUtils::CreateIconL(

   619             skin, 

   620             id,

   621             bitmap, 

   622             mask,

   623             KAvkonBitmapFile,

   624             noteGraphic,

   625             noteGraphicM);

   626 

   627         image->SetPicture( bitmap, mask );

   628         SetImageL( image );

   629         CleanupStack::Pop( image );

   630         }

   631 

   632     if ( noteAnimation != 0 )

   633         {

   634         // don't reset animation if it is already loaded            

   635         if ( noteResource || iPreviousAnimation != noteAnimation )

   636             {

   637             note->SetAnimationL( noteAnimation );

   638             iPreviousAnimation = noteAnimation; 

   639             }

   640         }

   641     else

   642         iPreviousAnimation = 0;

   643 

   644     iTone = noteTone;

   645 

   646     // We don't want play tone twice (In case some other note appears on top of this note).    

   647     noteTone = CAknNoteDialog::ENoTone; 

   648     

   649     ReportUserActivity();

   650 

   651     if ( noteSDData )

   652         {

   653         // secondary display data has been published

   654         PublishDialogL( noteSDData->iDialogIdx, noteSDData->iCategory );

   655         }

   656     else 

   657         {

   658         // or the global note is unidentified

   659         PublishDialogL( EAknUnidentifiedNote, KAknSecondaryDisplayCategory );

   660         }

   661         

   662     CAknMediatorFacade* cover_info = AknMediatorFacade(this);

   663     if (cover_info) // cover ui defined

   664         {

   665         if ( noteSDData && noteSDData->iAdditionalData )

   666             {// information from client

   667             cover_info->BufStream() << *(noteSDData->iAdditionalData);        

   668             }

   669         else if (iIsAlarm && iObserver->AlarmData())

   670             { // share detailled alarm info 

   671             TBuf8<sizeof(SAknAlarmPSInfo)> buf;

   672             

   673             // copy constructor should do just fine, but just to make sure               

   674             buf.Append((const TUint8*)iObserver->AlarmData(),sizeof(SAknAlarmPSInfo)); 

   675             

   676             cover_info->BufStream() << buf;

   677             }

   678         else

   679             { // default information about global note

   680             SAknGlobalNoteData params;    

   681             params.iResourceId = noteResource;

   682             params.iTimeOut = noteTimeout;

   683             params.iTone = noteTone;

   684             params.iTextLength = aInfo->iText.Length();

   685             params.iSoftkeys = noteSoftkeys;

   686             params.iImage.iImageId = noteGraphic;

   687             params.iImage.iImageMaskId = noteGraphicM;

   688             params.iAnimation = noteAnimation;

   689             params.iPlural = notePlural;

   690             TPckgBuf<SAknGlobalNoteData> buf(params);

   691             cover_info->BufStream() << buf;

   692             cover_info->BufStream() << aInfo->iText;                

   693             }

   694          cover_info->BufStream().CommitL();    

   695          }

   696         

   697     AknGlobalPopupPriorityController::SetPopupPriorityL(*this, aInfo->iGlobalPopupPriority);

   698     

   699     iDialogActive = ETrue;

   700     

   701     // invalidate whole dialog area

   702     if( !asyncImageLoading )

   703         {

   704      // DrawDeferred();

   705         RouseSleepingDialog();

   706         }

   707     }

   708 

   709 void CAknGlobalNoteDialog::ImageLoadSuccess( CEikImage* aImage )

   710     {

   711     // set image    

   712     TRAP_IGNORE(SetImageL(aImage));

   713 

   714     if( iDialogActive )

   715         {

   716         // Draw dialog

   717         DrawDeferred();

   718         RouseSleepingDialog();

   719         }

   720 

   721     delete iImageLoader;

   722     iImageLoader = NULL;

   723     }

   724 

   725 void CAknGlobalNoteDialog::ImageLoadError( TInt /*aError*/ )

   726     {

   727     // clear previous image

   728     TRAP_IGNORE(SetImageL(NULL));

   729     

   730     if( iDialogActive )

   731         {

   732         // Draw dialog without image

   733         DrawDeferred();

   734         RouseSleepingDialog();

   735         }

   736     

   737     delete iImageLoader;

   738     iImageLoader = NULL;

   739     }

   740 

   741 void CAknGlobalNoteDialog::SetAutoLock(TBool aAutoLock)

   742     {

   743     iAutoLock = aAutoLock;

   744     }

   745 

   746 RWindow& CAknGlobalNoteDialog::GlobalNoteWindow()

   747     {

   748     return Window();

   749     }

   750     

   751 void CAknGlobalNoteDialog::CEikDialog_Reserved_1()

   752     {

   753     }

   754 

   755 void CAknGlobalNoteDialog::CEikDialog_Reserved_2()

   756     {

   757     }

   758 

   759 void CAknGlobalNoteDialog::CAknNoteDialog_Reserved()

   760     {

   761     }

   762 

   763 void CAknGlobalNoteDialog::CAknStaticNoteDialog_Reserved()

   764     {

   765     }

   766 

   767 void CAknGlobalNoteDialog::HandlePointerEventL(const TPointerEvent& aPointerEvent)

   768     {

   769     if (Rect().Contains(aPointerEvent.iPosition) && (aPointerEvent.iType == TPointerEvent::EButton1Up)

   770         && iIsAlarm)

   771         {

   772         if (!iIsAlarmWakeup)

   773             {

   774             CEikDialog::TryExitL(EAlertOpen);

   775             }

   776 		}

   777     else if ((iSoftkeys == R_AVKON_SOFTKEYS_EMPTY) && 

   778             (iTimeoutInMicroseconds != ENoTimeout) && 

   779             (aPointerEvent.iType == TPointerEvent::EButton1Up))

   780         {

   781         CEikDialog::TryExitL(EAknSoftkeyExit);

   782         }

   783     else

   784         {

   785         CAknStaticNoteDialog::HandlePointerEventL(aPointerEvent);

   786         }

   787     }

   788 

   789 // class CAknGlobalNoteSubject

   790 

   791 CAknGlobalNoteSubject* CAknGlobalNoteSubject::NewL(

   792     MAknKeyLockController* aKeyLockController )

   793     {

   794     CAknGlobalNoteSubject* self =

   795         new (ELeave) CAknGlobalNoteSubject(aKeyLockController);

   796     CleanupStack::PushL( self );

   797     self->ConstructL();

   798     CleanupStack::Pop( self );

   799     return self;

   800     }

   801 

   802 CAknGlobalNoteSubject::CAknGlobalNoteSubject(MAknKeyLockController* aKeyLockController)

   803 :iKeyLockController(aKeyLockController),iNoteId(1), iMaxDisplayPriority(KMaxTInt), 

   804     iMaxDisplayPriorityLimit(KMaxSoftNotePriority)

   805     {

   806     }

   807 

   808 void CAknGlobalNoteSubject::ConstructL()

   809     {

   810     iGlobalNoteList = new(ELeave) CArrayFixFlat<CGlobalNoteInfo*>(KGlobalNoteGranularity);

   811     iGlobalNoteList->SetReserveL(KGlobalNoteGranularity);

   812     iDisplayingNoteId = KErrNotFound;

   813     

   814     // Construct the emergency call support here, but it is not activated until a

   815     // permanent note is started

   816     iEcsDetector = CAknEcsDetector::NewL();

   817     iKeyLockController->AddObserverL(this);

   818 

   819     // Setup a async callback for displaying the next note in the queue

   820     // This allows the next note to be displayed from the destructor of

   821     // a previous note, but the callback will execute only when the

   822     // destructor has finished

   823     TCallBack callback(CallDisplayNextNote, this);

   824     iDisplayCallback = new(ELeave)CAsyncCallBack(callback, CActive::EPriorityHigh);

   825 

   826     iGlobalNote = new(ELeave)CAknGlobalNoteDialog(this);

   827     iGlobalNote->ConstructL();

   828 

   829     iDialogController = CNotifierDialogController::NewL(this);

   830     SetNotificationDialogObserver(iDialogController);

   831 

   832     // Make sure that server has a pointer to the dialog stack

   833     STATIC_CAST(CAknCapServer*,CEikonEnv::Static()->AppServer())->

   834         SetGlobalNoteController(iDialogController);

   835         

   836     STATIC_CAST(CAknCapAppServerAppUi*,CEikonEnv::Static()->AppUi())->

   837         iGlobalNotesController = this;

   838     

   839     // Only initialize message reader long press detector 

   840     // if message reader has been installed

   841     if ( CAknMessageReaderLongPressDetector::MessageReaderInstalled() )

   842         {

   843         iMessageReaderLongPressDetector = CAknMessageReaderLongPressDetector::NewL( &iGlobalNote->ButtonGroupContainer(), iGlobalNote->GlobalNoteWindow() );

   844         STATIC_CAST(CAknCapAppServerAppUi*,CEikonEnv::Static()->AppUi())->

   845             iMessageReaderLongPressDetector = iMessageReaderLongPressDetector;

   846         }

   847         

   848     // Set-up autolock status change notification.

   849     User::LeaveIfError(iAutolockStatusProperty.Attach(

   850         KPSUidCoreApplicationUIs, 

   851         KCoreAppUIsAutolockStatus));

   852 

   853     iAutolockStatusSubscriber = new (ELeave) CSubscriber(

   854         TCallBack(AutolockStatusNotificationL, this), 

   855         iAutolockStatusProperty);

   856 

   857     iAutolockStatusSubscriber->Subscribe();       

   858     

   859     // Get the initial value.

   860     iAutolockStatusProperty.Get(iAutoLock);

   861     

   862     iGlobalNote->SetAutoLock(iAutoLock > EAutolockOff);

   863 

   864     iAlarmData = new SAknAlarmPSInfo;

   865     User::LeaveIfNull(iAlarmData);

   866     }

   867 

   868 

   869 TPtrC8 CAknGlobalNoteSubject::StartL(const TDesC8& aBuffer)

   870     {

   871     RDesReadStream readStream(aBuffer);

   872     

   873     // TInt32 takes four chars.

   874     if ( aBuffer.Length() < 4 )

   875         {

   876         User::Leave(KErrArgument);

   877         }

   878     else

   879         {

   880         TInt signature = readStream.ReadInt32L();

   881         

   882         if ( signature == KAKNNOTIFIERSIGNATURE_GETNOTEID )

   883             {

   884             iRetPckg().iNoteId = iNoteId++;

   885             return iRetPckg;            

   886             }

   887 

   888         if ( signature != KAKNNOTIFIERSIGNATURE )

   889             {

   890             User::Leave(KErrArgument);            

   891             }

   892         }        

   893 

   894     TBuf<KGlobalNoteTextLength> text; // We mustn't use heap...

   895 

   896     TInt type = readStream.ReadInt16L();

   897     readStream >> text;

   898 

   899     TInt priority = readStream.ReadInt16L();

   900     TInt softkeys = readStream.ReadInt32L();

   901     TInt graphic = readStream.ReadInt16L();

   902     TInt graphicMask = readStream.ReadInt16L();

   903     TInt animation = readStream.ReadInt32L();

   904     TInt tone = readStream.ReadInt16L();

   905     TChar adapterTypesUsed = readStream.ReadInt8L();

   906     TChar textProcessing = readStream.ReadInt8L();

   907     TInt preallocatedNoteId = readStream.ReadInt32L();

   908     CAknSDData* secondaryDisplayInfo = new (ELeave) CAknSDData();

   909     CleanupStack::PushL(secondaryDisplayInfo);

   910     if (readStream.ReadInt8L())

   911         {

   912         readStream >> *secondaryDisplayInfo;        

   913         }

   914     

   915     TInt noteId = KErrNotFound;

   916 

   917     if ( type == EAknGlobalRechargeBatteryNote ||

   918          type == EAknGlobalBatteryLowNote||

   919          type == EAknGlobalBatteryFullNote||

   920          type == EAknGlobalChargingNote ||

   921          type == EAknGlobalNotChargingNote ||

   922          type == EAknGlobalBatteryFullUnplugNote ||

   923          type == EAknGlobalUnplugChargerNote )

   924         {

   925         if (iNotesDisabled)

   926             {

   927             priority = KMaxAlarmNotePriority;

   928             tone = CAknNoteDialog::ENoTone;

   929             }

   930         secondaryDisplayInfo->iDialogIdx = type;

   931         // fw will set correct category uid automatically    

   932         secondaryDisplayInfo->iCategory = KNullUid;

   933         }

   934 

   935     // make sure that error notes w/o timeout do not get hidden behinds soft notifications

   936     if (type == EAknGlobalErrorNote || type == EAknGlobalWarningNote )

   937         {

   938         // We alter only default priority, and do it only if note does not have timeout.

   939         if (priority == 0 && softkeys != 0 ) 

   940             {

   941             priority = KMaxSoftNotePriority+1;

   942             }

   943         }

   944 

   945     switch ( type )

   946         {

   947         case EAknGlobalInformationNote:

   948             noteId = AddNoteToQueueL( R_INFORMATION_CONTROL,

   949                                       text,

   950                                       priority, 

   951                                       CAknNoteDialog::ELongTimeout,

   952                                       CAknNoteDialog::EConfirmationTone,

   953                                       tone,

   954                                       graphic, 

   955                                       graphicMask,

   956                                       animation,

   957                                       softkeys,

   958                                       preallocatedNoteId );

   959             break;

   960 

   961         case EAknGlobalWarningNote:

   962             noteId = AddNoteToQueueL( R_WARNING_CONTROL,

   963                                       text,

   964                                       priority,

   965                                       CAknNoteDialog::ELongTimeout, 

   966                                       CAknNoteDialog::EWarningTone,

   967                                       tone,

   968                                       graphic,

   969                                       graphicMask,

   970                                       animation,

   971                                       softkeys,

   972                                       preallocatedNoteId );

   973             break;

   974             

   975         case EAknGlobalConfirmationNote:

   976             noteId = AddNoteToQueueL( R_CONFIRMATION_CONTROL,

   977                                       text,

   978                                       priority, 

   979                                       CAknNoteDialog::EShortTimeout,

   980                                       CAknNoteDialog::EConfirmationTone,

   981                                       tone,

   982                                       graphic, 

   983                                       graphicMask,

   984                                       animation,

   985                                       softkeys,

   986                                       preallocatedNoteId );

   987             break;

   988             

   989         case EAknGlobalErrorNote:

   990             noteId = AddNoteToQueueL( R_ERROR_CONTROL,

   991                                       text,

   992                                       priority,

   993                                       CAknNoteDialog::ELongTimeout, 

   994                                       CAknNoteDialog::EErrorTone,

   995                                       tone,

   996                                       graphic,

   997                                       graphicMask,

   998                                       animation,

   999                                       softkeys,

  1000                                       preallocatedNoteId );

  1001             break;

  1002             

  1003         case EAknGlobalWaitNote:

  1004             noteId = AddNoteToQueueL( R_WAIT_CONTROL,

  1005                                       text,

  1006                                       priority,

  1007                                       CAknNoteDialog::ENoTimeout, 

  1008                                       CAknNoteDialog::ENoTone,

  1009                                       tone,

  1010                                       graphic,

  1011                                       graphicMask,

  1012                                       animation,

  1013                                       softkeys,

  1014                                       preallocatedNoteId );

  1015             break;

  1016             

  1017         case EAknGlobalPermanentNote:

  1018             noteId = AddNoteToQueueL( R_PERMANENT_CONTROL,

  1019                                       text,

  1020                                       priority, 

  1021                                       CAknNoteDialog::ENoTimeout,

  1022                                       CAknNoteDialog::ENoTone,

  1023                                       tone,

  1024                                       graphic,

  1025                                       graphicMask, 

  1026                                       animation,

  1027                                       0,                    // softkeys

  1028                                       preallocatedNoteId );

  1029             break;

  1030             

  1031         case EAknGlobalChargingNote:

  1032             noteId = AddNoteToQueueL( R_BATTERY_CHARGING_CONTROL,

  1033                                       priority,

  1034                                       tone,

  1035                                       preallocatedNoteId );

  1036             break;

  1037             

  1038         case EAknGlobalNotChargingNote:

  1039             noteId = AddNoteToQueueL( R_BATTERY_NOT_CHARGING_CONTROL,

  1040                                       priority,

  1041                                       tone,

  1042                                       preallocatedNoteId );

  1043             break;

  1044             

  1045         case EAknGlobalBatteryFullNote:

  1046             noteId = AddNoteToQueueL( R_BATTERY_FULL_CONTROL,

  1047                                       priority,

  1048                                       tone,

  1049                                       preallocatedNoteId );

  1050             break;

  1051             

  1052         case EAknGlobalBatteryLowNote:

  1053             noteId = AddNoteToQueueL( R_BATTERY_LOW_CONTROL,

  1054                                       priority,

  1055                                       tone,

  1056                                       preallocatedNoteId );

  1057             break;

  1058             

  1059         case EAknGlobalRechargeBatteryNote:

  1060             noteId = AddNoteToQueueL( R_RECHARGE_BATTERY_CONTROL,

  1061                                       priority,

  1062                                       tone,

  1063                                       preallocatedNoteId );

  1064             break;

  1065             

  1066         case EAknCancelGlobalNote:

  1067             CancelNote( priority );

  1068             break;

  1069             

  1070         case EAknGlobalTextNote:

  1071             noteId = AddNoteToQueueL( R_NOTE_PLAIN_TEXT_CONTROL,

  1072                                       text,

  1073                                       priority, 

  1074                                       CAknNoteDialog::ELongTimeout,

  1075                                       CAknNoteDialog::EConfirmationTone,

  1076                                       tone,

  1077                                       graphic, 

  1078                                       graphicMask,

  1079                                       animation,

  1080                                       softkeys,

  1081                                       preallocatedNoteId );

  1082             break;

  1083             

  1084         case EAknGlobalBatteryFullUnplugNote:

  1085             noteId = AddNoteToQueueL( R_BATTERY_FULL_UNPLUG_CONTROL,

  1086                                       priority,

  1087                                       tone,

  1088                                       preallocatedNoteId );

  1089             break;

  1090             

  1091         case EAknGlobalUnplugChargerNote:

  1092             noteId = AddNoteToQueueL( R_UNPLUG_CHARGER_CONTROL,

  1093                                       priority,

  1094                                       tone,

  1095                                       preallocatedNoteId );

  1096             break;

  1097             

  1098         default:

  1099             break;

  1100         }

  1101         

  1102     if( type == EAknGlobalChargingNote ||

  1103         type == EAknGlobalNotChargingNote ||

  1104         type == EAknGlobalBatteryFullNote ||

  1105         type == EAknGlobalBatteryLowNote ||

  1106         type == EAknGlobalRechargeBatteryNote ||

  1107         type == EAknGlobalBatteryFullUnplugNote ||

  1108         type == EAknGlobalUnplugChargerNote )

  1109         {

  1110         Note(noteId)->iGlobalPopupPriority = 1;

  1111         }

  1112 

  1113     TBool sdDataSet( EFalse );

  1114 

  1115     if ( noteId != KErrNotFound && iGlobalNoteList ) // we are not in cancel state

  1116         {

  1117         TInt index = NoteIndex(noteId);

  1118         if ( index != KErrNotFound && iGlobalNoteList->Count() > index )

  1119             {

  1120             // Is global note adapter used.                

  1121             (*iGlobalNoteList)[index]->iIsFromAdapter = adapterTypesUsed; 

  1122             (*iGlobalNoteList)[index]->iTextProcessing = textProcessing;

  1123             }

  1124         if ( index != KErrNotFound && secondaryDisplayInfo->iDialogIdx != 0 )

  1125             {

  1126             sdDataSet = SetSDData( noteId, secondaryDisplayInfo );

  1127             }

  1128         }

  1129     

  1130     if ( sdDataSet )

  1131         {

  1132         CleanupStack::Pop( secondaryDisplayInfo );

  1133         }          

  1134     else // secondaryDisplayInfo ownership not transferred