/*

* Copyright (c) 2006-2006 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:   An alarm UI class, CAlmAlarmControl.

*                This class takes care of displaying the alarm note and

*                handling user input.

*

*/

// INCLUDE FILES

#include "AlmAlarmControl.h"

#include "pim_trace.h"

#include "alarmutils.h"

#include <secondarydisplay/alarmuiSecondaryDisplay.h>

#include <bautils.h>

#include <StringLoader.h>

#include <pathinfo.h>

#include <featmgr.h>

#include <aknnotewrappers.h>

#include <coreapplicationuisdomainpskeys.h>

#include <alarmuidomainpskeys.h>

#include <data_caging_path_literals.hrh>

#include <AlmAlert.rsg>

#include "AlmAlert.hrh"

#include "AlmAlert.pan"

#include <aknnotewrappers.h>

#include <AknMediatorFacade.h>

#include <missedalarm.h>

_LIT( KResourceFile, "AlmAlert.rsc" );

const TInt KAlarmPriority( 3095 );  // Priority for global note queue

const TUint KAlarmAutoShutdown( 60000000 );  // 60 s

const TUint KShutdownTime( 1500000 ); // 1.5 s

// ==========================================================

// ================= MEMBER FUNCTIONS =======================

// -----------------------------------------------------------------------------

//

// -----------------------------------------------------------------------------

//

void CAlmAlarmControl::Panic(const TUint aReason) const

{

    TRACE_ENTRY_POINT;

    _LIT( KPanicCategory, "AlarmUI-AlmAlert.pan" );

    User::Panic( KPanicCategory, aReason );

    TRACE_EXIT_POINT;

}

// -----------------------------------------------------------------------------

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CAlmAlarmControl::CAlmAlarmControl() :

    iGlobalNoteId( KErrNotFound ),

    iState( EStateIdle )

{

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

}

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CAlmAlarmControl::~CAlmAlarmControl()

{

    TRACE_ENTRY_POINT;

    this->HideAlarm();

    delete iAlarmUtils;

    iAlarmUtils = NULL;

    iEikonEnv->EikAppUi()->RemoveFromStack( this );

    iEikonEnv->DeleteResourceFile( iResOffset );

    delete iPropertyHideAlarm;

    iPropertyHideAlarm = NULL;

    delete iPropertySWStateValue;

    iPropertySWStateValue = NULL;

    delete iPropertyStopAlarm;

    iPropertyStopAlarm = NULL;

    delete iPropertySnoozeAlarm;

    iPropertySnoozeAlarm = NULL;

    TRACE_EXIT_POINT;

}

// --------------------------------------------------------

//

// ---------------------------------------------------------

//

void CAlmAlarmControl::SetState(TInt aState)

{

    TRACE_ENTRY_POINT;

    const TInt oldState( iState );

    iState = aState;

    // handle state transitions

    HandleStateChange( oldState );

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// handle custom state transitions

// ---------------------------------------------------------

//

void CAlmAlarmControl::HandleStateChange(TInt aOldState)

{

    TRACE_ENTRY_POINT;

    // stop observers when exiting from EStateWaitingInput state

    if( aOldState == EStateWaitingInput

        && iState != EStateWaitingInput )

    {

        // stop the context/sensor observer.

        PIM_TRAPD_ASSERT( iAlarmUtils->StopCFObserverL(); )

        // stop waiting for "end call" command from accessories

        iAlarmUtils->StopAccessoryObserver();

    }

    switch( iState )

    {

        case EStateIdle:

        {

            iAlarmUtils->StopInactivityResetTimer();

            // was the device started for alarm?

            if( iAlarmUtils->IsDeviceInAlarmState() )

            {

                /**

                * Show the wakeup query if any of the alarms was stopped (by user

                * pressing the stop key) and there is no more alarms in the queue.

                */

                if( iAskWakeup && !iAlarmUtils->HasExpiredAlarmsWaiting() )

                {

                    SetState( EStateBeforeAskingWakeup );

                    iAlarmUtils->AsyncShowWakeupQuery();

                }

                else

                {

                    /**

                    * Prepare to shutdown if wakeup query is not needed.

                    * (also works as a fallback if we are waiting for more

                    * alarms to be notified (iAlarmUtils->HasExpiredAlarmsWaiting()==ETrue),

                    * but alarm server queue changes suddenly)

                    */

                    iAlarmUtils->StartShutdownTimer( KShutdownTime );

                }

            }

            else

            {

                /**

                * block all input for 0.5 seconds

                * (try to prevent accidental key presses from going through the key or security lock)

                */

                iAlarmUtils->StartKeyBlocker();

                // reset the key guard

                iAlarmUtils->SetKeyGuard( ETrue );

            }

            break;

        }

        case EStateWaitingInput:

        {

            // make sure the screen saver, key or security lock, etc. won't active during the alarm

            iAlarmUtils->StartInactivityResetTimer();

            // start waiting for "end call" command from accessories

            iAlarmUtils->StartAccessoryObserver();

            // publish new alarm context value and wait for any actions

            PIM_TRAPD_ASSERT( iAlarmUtils->StartCFObserverL(); )

            break;

        }

        default:

            // fall through

            break;

    }

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

TBool CAlmAlarmControl::IsState(const TInt aState) const

{

    TRACE_ENTRY_POINT;

    TBool retVal(iState == aState);

    TRACE_EXIT_POINT;

    return retVal;

}

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CAlmAlarmControl::DoAutoSnooze()

    {

    TRACE_ENTRY_POINT;

    iAlarmUtils->CancelAutoSnooze();

    // Allow auto-snooze only while waiting user input

    if( IsState( EStateWaitingInput ) )

        {

        SetState( EStateAfterInput );

	 StopOrSnoozeAlarm();

	 DoCancelDialog();

        }

    TRACE_EXIT_POINT;

    }

// ---------------------------------------------------------

// Dismiss the alarm notification.

// ---------------------------------------------------------

//

void CAlmAlarmControl::DoCancelDialog()

{

    TRACE_ENTRY_POINT;

    if( iGlobalNoteId != KErrNotFound )

    {

        iAlarmUtils->NotifierDialogController()->SetNoteObserver( this );

        iAlarmUtils->NotifierDialogController()->CancelNote( iGlobalNoteId );

    }

    iAlarmUtils->StopAlarmSound();

    iAlarmUtils->CancelAutoSnooze();

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// Show the wake-up query

// ---------------------------------------------------------

//

void CAlmAlarmControl::AskWakeupPhoneL()

{

    TRACE_ENTRY_POINT;

    iAskWakeup = EFalse;

    ASSERT( IsState( EStateBeforeAskingWakeup ) );

    if( IsState( EStateBeforeAskingWakeup ) )

    {

        HBufC* label = NULL;

        TBuf<1> time;

        iAlarmUtils->GetWakeupLabelL( label );

        CleanupStack::PushL( label );

		if(!IsVisible())

		{

			MakeVisible(ETrue);

		}

        iAlarmUtils->NotifierDialogController()->SetNoteObserver( this );

        iGlobalNoteId = iAlarmUtils->NotifierDialogController()->DisplayAlarmL( EAskWakeUp, *label, time/*not used*/ );

        CleanupStack::PopAndDestroy( label );

        // shutdown automatically if user doesn't react within one minute

        iAlarmUtils->StartShutdownTimer( KAlarmAutoShutdown );

    }

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// Handle alarm interrupt commands (power key)

// ---------------------------------------------------------

//

void CAlmAlarmControl::HandleInterruptAlarm(TInt aReason)

{

    TRACE_ENTRY_POINT;

    switch( aReason )

    {

        case EReasonKSysApHideAlarm:  // stop

        {

            switch( iState )

            {

                case EStateIdle:

                {

                    // ignore

                }

                break;

                case EStateWaitingShowRequest:  // stop -> EStateIdle

                case EStateWaitingDisplayRequest:  // stop -> hide -> EStateIdle

                case EStateWaitingInput:  // stop -> hide -> EStateIdle

                {

                    iAskWakeup = EFalse; // don't show the wakeup query!

                    SetState( EStateIdle );

                    // Stop alarm -> HideAlarm() -> CancelNote()

                    iAlarmUtils->DoStopAlarm();  // stop

                    DoCancelDialog();

                }

                break;

                case EStateBeforeAskingWakeup:  // hide and shutdown

                case EStateAskingWakeup:  // hide and shutdown

                {

                    iAskWakeup = EFalse;

                    iAlarmUtils->CancelAsynchRequest();

                    SetState( EStateIdle );

                    DoCancelDialog();

                }

                break;

                case EStateAfterInput:

                case EStateShowingSnoozeInfo:

                {

                    SetState( EStateIdle );

                }

                break;

                default:

                {

                    // panic - unknown state!

                    Panic( EAlarmUIUnknownState | EAlarmUIHandleInterrupt );

                }

                break;

            }

            break;

        }

        default:

        {

            // Unknown reason

            Panic( EAlarmUIUnknownReason | EAlarmUIHandleInterrupt );

        }

        break;

    }

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// Stores the missed alarm data in the repository  

// ---------------------------------------------------------

//

void CAlmAlarmControl::StoreMissedAlarmDataL()

    {

	//Get the Calendar instance values and         	  

	//Store it in the missed alarm repository

	RPointerArray<CMissedAlarm> missedAlarmList;

	TCalLocalUid localUid = iAlarmUtils->AlarmData().iLocalUid;

	TCalTime instanceTime = iAlarmUtils->AlarmData().iInstanceTime;

	TTime startTime = instanceTime.TimeLocalL();

	CMissedAlarm* missedAlarm = CMissedAlarm::NewL( localUid, startTime,

	                                                     iAlarmUtils->AlarmData().iCalFileName );

	CleanupStack::PushL( missedAlarm );

	missedAlarmList.AppendL(missedAlarm);

	CMissedAlarmStore* missedAlarmStore = CMissedAlarmStore::NewLC();

	missedAlarmStore->AddL(missedAlarmList);

	CleanupStack::PopAndDestroy( missedAlarmStore );

	CleanupStack::Pop( missedAlarm );

	missedAlarmList.ResetAndDestroy();

    }

// ---------------------------------------------------------

// Checks for calendar type alarm needed to be stored as missed alarm   

// Stops the alarm and enters to missed alarm table. If the calendar type

// is clock, then snoozes the alarm.

// ---------------------------------------------------------

//

void CAlmAlarmControl::StopOrSnoozeAlarm()

	{

	TRACE_ENTRY_POINT;

	if( iAlarmUtils->IsCalendarAlarm() )

		{	 

		if( iAlarmUtils->IsCalendarAlarmViewer() )

			{				 

			iAlarmUtils->SetCalendarAlarmViewer(EFalse);		   

			}

		else

			{

			TRAP_IGNORE( StoreMissedAlarmDataL() );

			}

		iAlarmUtils->DoStopAlarm(); 										 

		}

	else

		{		 

		iAlarmUtils->TryToSnoozeActiveAlarm();

		}

    	TRACE_EXIT_POINT;

	}

// ===========================================================

// ================ INHERITED FUNCTIONS ======================

// ---------------------------------------------------------

// Symbian 2nd phase constructor

// ---------------------------------------------------------

//

void CAlmAlarmControl::ConstructL(CAknAlarmService* aSupervisor)

{

    TRACE_ENTRY_POINT;

  TFileName fileName;

	// Get the complate path of the DLL from where it is currently loaded

	Dll::FileName( fileName );

	TFileName resFile;

	// Append the Drive letters ex., Z: or C:

	resFile.Append(fileName.Mid(0,2));

	resFile.Append(KDC_RESOURCE_FILES_DIR);

    resFile.Append(KResourceFile);

    BaflUtils::NearestLanguageFile( iEikonEnv->FsSession(), resFile );

    iResOffset = iEikonEnv->AddResourceFileL( resFile );

    iEikonEnv->EikAppUi()->AddToStackL(

        this,

        ECoeStackPriorityAlert,

        ECoeStackFlagRefusesFocus );

	MakeVisible(EFalse);

	SetStopFromContext(EFalse);

    iAlarmUtils = CAlarmUtils::NewL( this, aSupervisor );

    // observe "hide alarm" commands (i.e. powerkey presses)

    iPropertyHideAlarm = CPropertyObserver::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm );

    // observe system state changes

    iPropertySWStateValue = CPropertyObserver::NewL( *this, KPSUidStartup, KPSGlobalSystemState );

    //For Plasma accessory handling

    _LIT_SECURITY_POLICY_PASS( KGeneralReadPolicy );

	_LIT_SECURITY_POLICY_C1( KProtectedWritePolicy, ECapabilityWriteDeviceData );

	RProperty::Define( KPSUidAlarmExtCntl, KAlarmStopKey, RProperty::EInt, KGeneralReadPolicy, KProtectedWritePolicy );

    RProperty::Define( KPSUidAlarmExtCntl, KAlarmSnoozeKey, RProperty::EInt, KGeneralReadPolicy, KProtectedWritePolicy );

    //observe Plasma accessory stop key changes

    iPropertyStopAlarm = CPropertyObserver::NewL(*this, KPSUidAlarmExtCntl, KAlarmStopKey);

    //observe Plasma accessory snooze key changes

    iPropertySnoozeAlarm = CPropertyObserver::NewL(*this, KPSUidAlarmExtCntl, KAlarmSnoozeKey);

    //observe SysAp backlight setting PS Key

	iPropertyBacklight = CPropertyObserver::NewL(*this, KPSUidCoreApplicationUIs, KLightsAlarmLightActive);

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// From MEikServAlarm (MAlarmObserver)

// ---------------------------------------------------------

//

void CAlmAlarmControl::Release()

{

    TRACE_ENTRY_POINT;

    delete this;

    TRACE_EXIT_POINT;

}

// ---------------------------------------------------------

// From MEikServAlarm

// NOTE!!! This function is also called from HandlePropertyChange()

// ---------------------------------------------------------

//

void CAlmAlarmControl::ShowAlarm()

{

    TRACE_ENTRY_POINT;

    switch( iState )

    {

        case EStateWaitingShowRequest:

        {

            /**

            * wait until device startup is ready,

            * snooze info note is not being displayed and

            * delay timer has finished.

            */

            if( iAlarmUtils->IsPhoneStartupReady() &&

                !iSnoozeInfoNoteActive &&

                !iAlarmUtils->AlarmDelayTimerActive() )

            {

                // State MUST be set before requesting the note from avkon!

                // DisplayAlarmL() will call DisplayDialogL() directly!

                SetState( EStateWaitingDisplayRequest );

                // Only call this within ShowAlarm to prevent updating data too early/late.

                // (e.g. updating snooze time before showing the snooze info note)

                TRAPD( err, iAlarmUtils->InitialiseAlarmDataL(); )

                HBufC* text = NULL;

                if( !err )

                {

                    TRAP( err, iAlarmUtils->GetAlarmLabelL( text ); )

                }

            	// cleanup (release global data)

            	iAlarmUtils->UninitialiseAlarmData();

                if( !err )

                {

                	if(!IsVisible())

                	{

                		MakeVisible(ETrue);

                	}

                    iAlarmUtils->NotifierDialogController()->SetNoteObserver( this );

                    // setup CBA for the global note

                    TUint cba(0);  // See AknDialogController.h

                    // alarm type - no silence key for clock alarms, unknown alarms are handled as calendar alarms

                    cba |= iAlarmUtils->IsClockAlarm() ? EClockAlarm | ENoSilence : ECalendarAlarm;

                    // disable silence key when ringing type is set to "silent" or if alarm sounds is set off

                    cba |= iAlarmUtils->IsRingingTypeSilent() || iAlarmUtils->IsOffTone() ? ENoSilence : 0;

                    // disable silence and snooze key if alarm can't be snoozed anymore