/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  System soft notifications.

*

*/

#include <uikon/eiksrvui.h>

#include <AknNotiferAppServerApplication.h>

#include "AknSystemPopup.h"

#include <AknNotifyStd.h>

#include <AknNotifierControllerPlugin.h>

#include <avkon.rsg>

#include <avkon.mbg>

#include <eikbtgpc.h>

#include <eikenv.h>

#include <avkon.hrh>

#include <eikimage.h>

#include <barsread.h>

#include <aknnotpi.rsg>

#include "AknNotifyPlugin.hrh"

#include <aknnotedialog.h>

#include <aknnotecontrol.h>

#include <aknconsts.h>

#include <s32mem.h>

#include <viewcli.h>

#include <e32base.h>

#include <AknNotifySignature.h>

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

#include <AknCapServer.h>

#include "AknCapServerEntry.h"

#include <AknMediatorFacade.h>

#include <aknSDData.h>

#include <AknsUtils.h>

#include <aknglobalpopupprioritycontroller.h>

#include "GlobalWindowPriorities.h"

#include "aknmessagereaderlongpressdetector.h" // CAknMessageReaderLongPressDetector    

#include <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus

#include "AknDynamicNotificationData.h"

#include "AknPrivateImageLoader.h"

#include <AknUtils.h>

#include <aknlayout.cdl.h>

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    #include <gfxtranseffect/gfxtranseffect.h>

    #include <akntransitionutils.h>

#endif

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

const TInt KMaxSoftNotePriority = 3000;

const TInt KMaxAlarmNotePriority = 4000;

const TInt KMaxNotePriority = 5000;

const TInt KAlarmNotePriority = 3095;

// class CGlobalNoteInfo

CGlobalNoteInfo::CGlobalNoteInfo() :

    iSoftkeys( 0 ),

    iGraphic( -1 ),

    iAnimation( 0 ),

    iPlural( 0 ),

    iAsync( EFalse ),

    iTextProcessing( ETrue ),

    iSDData(NULL),

    iGlobalPopupPriority(0)

    {

    }

CGlobalNoteInfo::~CGlobalNoteInfo()

    {

    delete iSDData;

    }

// class CAknGlobalNoteDialog

CAknGlobalNoteDialog::CAknGlobalNoteDialog(MGlobalNoteObserver* aObserver)

:iObserver(aObserver), iPreviousNoteId( KErrNotFound )

    {

    iCommand = KErrCancel;

    }

void CAknGlobalNoteDialog::ConstructL()

    {

    ConstructSleepingDialogL(R_GLOBAL_NOTE);

    }

CAknGlobalNoteDialog::~CAknGlobalNoteDialog()

    {

    delete iImageLoader;

    }

TBool CAknGlobalNoteDialog::OkToExitL(TInt aButtonId)

    {

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

    if ( (iControlType == R_PERMANENT_CONTROL) ||

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

        {

        return EFalse;

        }

    else if ( iIsAlarm )

        {

        // Don't let an empty command through.

        if ( aButtonId == EAknSoftkeyEmpty )

            {

            return EFalse;

            }

        CEikButtonGroupContainer& bgc = ButtonGroupContainer();

        if ( aButtonId == EAlertSilence )

            {

            if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT__OPEN )

                {

                iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE__OPEN;

                }

            else // R_ALERT_SOFTKEYS_STOP_SILENT

                {

                iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE;

                }

            bgc.SetCommandSetL( iSoftkeys );

            bgc.ActivateL();

            bgc.MakeVisible( ETrue );            

            bgc.DrawNow();

            iObserver->GlobalNoteCompleted( EAlertSilence );

            return EFalse;

            }

        // make sure that rsk will be visible next time

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

        else if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE &&

                  !bgc.IsCommandVisible( EAlertSnooze ) )

            {

            bgc.MakeCommandVisible( EAlertSnooze, ETrue );

            }

        if ( aButtonId == EAlertOpen )

            {

            if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT__OPEN ||

                 iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE__OPEN ||

                 iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE )

                {

                iSoftkeys = R_ALERT_SOFTKEYS_STOP_SNOOZE;

                }

            else if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SILENT )

                {

                iSoftkeys = R_ALERT_SOFTKEYS_STOP_SILENT ;

                }

            else // R_ALERT_SOFTKEYS_STOP_EMPTY__OPEN

                {

                iSoftkeys = R_ALERT_SOFTKEYS_STOP_EMPTY__EMPTY;

                }

            bgc.SetCommandSetL( iSoftkeys );

            bgc.ActivateL();

            bgc.MakeVisible( ETrue );            

            bgc.DrawNow();

            iObserver->GlobalNoteCompleted( EAlertOpen );

            return EFalse;

            }

        }

    iCommand = aButtonId;

    NextNoteOrExit();

    return ETrue;

    }

void CAknGlobalNoteDialog::PreLayoutDynInitL()

    {

    delete iTimer;

    iTimer = NULL;

    if ( iTimeoutInMicroseconds != ENoTimeout )

        {

        iTimer = CPeriodic::NewL(0);

        iTimer->Start(iTimeoutInMicroseconds, iTimeoutInMicroseconds, 

            TCallBack(CallNextNoteOrExit,this));

        }

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

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

        {

        iObserver->SetAppsKeyLocked( EFalse );

        }

    }

void CAknGlobalNoteDialog::HandleResourceChange(TInt aType)

    {

    if ( aType == KAknsMessageSkinChange )  

        {

        iPreviousAnimation = 0; // reload next animation always

        }

    CAknStaticNoteDialog::HandleResourceChange(aType);

    }

void CAknGlobalNoteDialog::PostLayoutDynInitL()

    {

    CEikButtonGroupContainer& bgc = ButtonGroupContainer();

    if ( iSoftkeys )

        {

        bgc.SetCommandSetL(iSoftkeys);

        MEikButtonGroup* buttonGrp = bgc.ButtonGroup();

        if( buttonGrp )

            {

            if( iSoftkeyLeft.Length() > 0 )

                {

                bgc.SetCommandL( buttonGrp->CommandId( 

                    CEikButtonGroupContainer::ELeftSoftkeyPosition ), 

                    iSoftkeyLeft );

                }

            if( iSoftkeyRight.Length() > 0 )

                {

                bgc.SetCommandL( buttonGrp->CommandId( 

                    CEikButtonGroupContainer::ERightSoftkeyPosition ),

                    iSoftkeyRight );

                }

            if (AknLayoutUtils::PenEnabled())

                {

                if (iIsSoftNotification && iAutoLock)

                    {

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

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

                    }

                else

                    {

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

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

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

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

                    }

                }

            }

        }

    CAknStaticNoteDialog::PostLayoutDynInitL();

    if ( iIsSoftNotification && (iAutoLock > EAutolockOff) )

        { // members below exist always when dialog exists,

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

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

            {            

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

            }

        }

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

    PlayTone();

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

        {

        if(iTimeoutInMicroseconds != EShortTimeout)

           {   

           iObserver->SetAppsKeyLocked( ETrue );

           }

        }

    }

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

    {

    if (iIsSoftNotification && aType == EEventKey)

        {

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

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

            || aKeyEvent.iCode == '#' 

            || aKeyEvent.iCode == '*')

            {

            if( aKeyEvent.iRepeats == 0 )

                {

                MAknPhoneKeyForwarder* keyf = STATIC_CAST(

                    CAknCapAppServerAppUi*, 

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

                keyf->ForwardKeyToPhoneAppL(aKeyEvent);

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

                }

            return EKeyWasConsumed;

            }

        else if ( aKeyEvent.iCode == EKeyEnter )

            {

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

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

            return EKeyWasConsumed;

            }    

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

            {

            if ( aKeyEvent.iCode == EKeyNo )

                {

                iCommand = EAknSoftkeyExit;

                NextNoteOrExit();

                }

            return EKeyWasConsumed;

            }

        }

    if (aKeyEvent.iCode == EKeyEscape)

        {

        return EKeyWasNotConsumed;

        }

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

    // only for soft notification.

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

        {

        return EKeyWasNotConsumed;

        }

    if (iControlType == R_PERMANENT_CONTROL || 

        iControlType == R_WAIT_CONTROL      || 

        iTimeoutInMicroseconds == ENoTimeout)

        {

        return EKeyWasConsumed;

        }

    // Any keypress dismissed other types of notes

    if (aType == EEventKey)

        {

        NextNoteOrExit();

        }

    return EKeyWasConsumed;

    }

TBool CAknGlobalNoteDialog::CallNextNoteOrExit(TAny* aThis)

    {

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

    return ETrue;

    }

void CAknGlobalNoteDialog::NextNoteOrExit(TBool aDirectExit)

    {

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

    // otherwise put the global note back to sleep

    delete iTimer;

    iTimer = NULL;

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

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

        {

        iObserver->SetAppsKeyLocked( EFalse );

        }

    // Set borders back to zero

    SetNumberOfBorders(0);

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

    if (aDirectExit)

        {

        CEikButtonGroupContainer& bgc = ButtonGroupContainer();

        if ( iSoftkeys == R_ALERT_SOFTKEYS_STOP_SNOOZE &&

             !bgc.IsCommandVisible( EAlertSnooze ) )

            {

            bgc.MakeCommandVisible( EAlertSnooze, ETrue );

            }

        }

#ifdef RD_SCALABLE_UI_V2

    if ( AknLayoutUtils::PenEnabled() )

        {

        SetGloballyCapturing( EFalse );

        SetPointerCapture( EFalse );

        }

#endif // RD_SCALABLE_UI_V2

    ExitSleepingDialog();

    iDialogActive = EFalse;

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

    iObserver->GlobalNoteCompleted(iCommand);

    }

void CAknGlobalNoteDialog::RemoveCurrentNote()

    {

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

    // shown

    delete iTimer;

    iTimer = NULL;

#ifdef RD_SCALABLE_UI_V2

    if ( AknLayoutUtils::PenEnabled() )

        {

        SetGloballyCapturing( EFalse );

        SetPointerCapture( EFalse );

        }

#endif // RD_SCALABLE_UI_V2

    ExitSleepingDialog();

    iDialogActive = EFalse;

    }

void CAknGlobalNoteDialog::UpdateNoteAndDisplayL( CGlobalNoteInfo* aInfo )

    {

    TInt                     notePriority  = aInfo->iPriority;

    TInt                     noteResource  = aInfo->iResourceId;

    TInt                     noteSoftkeys  = aInfo->iSoftkeys;

    TInt                     notePlural    = aInfo->iPlural;

    TInt                     noteGraphic   = aInfo->iGraphic;

    TInt                     noteGraphicM  = aInfo->iGraphicMask;

    TInt                     noteAnimation = aInfo->iAnimation;

    CAknNoteDialog::TTimeout noteTimeout   = aInfo->iTimeOut;

    CAknNoteDialog::TTone    noteTone      = aInfo->iTone;

    CAknSDData*              noteSDData    = aInfo->iSDData;

    iCommand = KErrCancel;

    iTimeoutInMicroseconds = noteTimeout;

    iControlType = noteResource;

    iIsSoftNotification = (

        notePriority >= KMinimumSoftNotePriority && 

        notePriority <= KMaxSoftNotePriority );

    //close the blank screen when global note display

    if (noteTimeout == EShortTimeout)

        {

        CAknCapAppServerAppUi* pAppui =

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

        pAppui->SetIsShortTimeGlobalNoteDisplaying(ETrue);

        }

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    // use soft notify context

    if( iIsSoftNotification )

        {

        GfxTransEffect::Register( this, KGfxSystemNotificationControlUid );

        }

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

        {

        class TResIdToContext

            {

            public:

            TInt iResId;

            TUid iContextId;

            };

        TResIdToContext mapArray[] = 

        { 

        R_INFORMATION_CONTROL, KGfxInformationNoteControlUid,

        R_WARNING_CONTROL, KGfxWarningNoteControlUid,

        R_CONFIRMATION_CONTROL, KGfxConfirmationNoteControlUid,

        R_ERROR_CONTROL, KGfxErrorNoteControlUid,

        R_WAIT_CONTROL, KGfxWaitNoteControlUid, 

        R_BATTERY_CHARGING_CONTROL,KGfxSystemNotifBatteryControlUid,

        R_BATTERY_NOT_CHARGING_CONTROL,KGfxSystemNotifBatteryControlUid,

        R_BATTERY_FULL_CONTROL,KGfxSystemNotifBatteryControlUid,

        R_BATTERY_LOW_CONTROL,KGfxSystemNotifBatteryControlUid,

        R_RECHARGE_BATTERY_CONTROL,KGfxSystemNotifBatteryControlUid

        };

        TUid contextId = TUid::Uid(0);

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

            {

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

                {

                contextId = mapArray[i].iContextId;

                break;

                }

            }

        if( contextId.iUid == 0 )        

            {

            contextId = KGfxPopupDefaultControlUid;

            }

        GfxTransEffect::Register( this, contextId );

        }

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS

    iIsAlarm = ( notePriority == KAlarmNotePriority );

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

    iSoftkeys = noteSoftkeys;

#ifdef RD_SCALABLE_UI_V2

    if ( AknLayoutUtils::PenEnabled() )

        {

        SetGloballyCapturing( ETrue ); 

        SetPointerCapture( ETrue ); 

        }

#endif

    if ( !iSoftkeys )

        {

        if (iControlType == R_WAIT_CONTROL)

            {

            iSoftkeys = R_AVKON_SOFTKEYS_CANCEL;

            }

        else if ( notePriority != KAlarmNotePriority )

            {

            iSoftkeys = R_AVKON_SOFTKEYS_EMPTY;

            }

        }

    iSoftkeyLeft.Set( aInfo->iLeftSK );

    iSoftkeyRight.Set( aInfo->iRightSK );

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