/*

* Copyright (c) 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:  Calendar alarm manager

*

*/

#include <calalarm.h>

#include <calentry.h>

#include <StringLoader.h>

#include <centralrepository.h>

#include <apgtask.h>

#include <aknViewAppUi.h>

#include <aknbutton.h>

#include <akntoolbar.h>

#include <missedalarm.h>

#include <missedalarmstore.h>

#include <missedalarmstorecrkeys.h>

#include <calenagendautils.h>

#include <calencommonui.rsg>

#include <CalendarInternalCRKeys.h>

#include <calendateutils.h>

#include <calencommands.hrh>            // Calendar commands

#include <calencontext.h>

#include <calenservices.h>

#include <calentoolbar.h> 

#include <GlobalWindowPriorities.h>

#include "calendarui_debug.h"

#include "calenalarmmanager.h"

#include "CalenUid.h"

#include "calencontroller.h"

#include "calendar.hrh"

#include "calenviewmanager.h"

#include "calensetting.h"

#include "calencontextfwlistener.h"

#include "CleanupResetAndDestroy.h"

#include "calenattachmentmodel.h"

static const TUint32 KMaxMissedAlarms = 10;

// Order of calendar window(at front) after Stop/Snooze of alarm from event viewer.

static const TInt KCalendarWindowOnFront(0);

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

// CCalenAlarmManager::NewL

// 1st phase of construction

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

//

CCalenAlarmManager* CCalenAlarmManager::NewL(CCalenController& aController)                                          

    {

    TRACE_ENTRY_POINT;

    CCalenAlarmManager* self = new( ELeave ) CCalenAlarmManager( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenAlarmManager::CCalenAlarmManager

// C++ default Constructor.

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

//

CCalenAlarmManager::CCalenAlarmManager( CCalenController& aController )

    : iController( aController ),iViewManager(aController.ViewManager()),

	  iContextFWListener(NULL) 

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::~CCalenAlarmManager

// Destructor.

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

//

CCalenAlarmManager::~CCalenAlarmManager()

    {

    TRACE_ENTRY_POINT;

	if(iContextFWListener)

		{

		delete iContextFWListener;

		iContextFWListener = NULL;

		}

    if(iCenRepChangeNotifier)

        {

        iCenRepChangeNotifier->StopListening();

        delete iCenRepChangeNotifier;

        }

    delete iMissedAlarmStore;

	iMissedAlarmList.Close();

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::ConstructL

// 2nd phase of construction.

// (other items were commented in a header).

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

//

void CCalenAlarmManager::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iMissedAlarmStoreRepository = CRepository::NewL( KCRUidMissedAlarmStore );

    // Create missed alarm store

    iMissedAlarmStore = CMissedAlarmStore::NewL(*iMissedAlarmStoreRepository);

    iCenRepChangeNotifier = CCenRepNotifyHandler::NewL( *this, *iMissedAlarmStoreRepository );

    iCenRepChangeNotifier->StartListeningL();

    iMissedAlarmStore->CountL(iMissedAlarmsCount);

    if(iMissedAlarmsCount)

        {

        CreateMissedAlarmsListL();

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::HandleCommandL

// Handles alarm manager commands.

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

//

TBool CCalenAlarmManager::HandleCommandL( const TCalenCommand& aCommand )

    {

    TRACE_ENTRY_POINT;

    TBool continueCommand(EFalse);    

    switch( aCommand.Command() )

        {

        case ECalenMissedAlarmsView:

            {

            OnCmdMissedAlarmViewL();

            }

            break;

        case ECalenMissedEventView:

            {

            OnCmdMissedEventViewL();

            }

            break;

        case ECalenCmdClear:

            {

            OnCmdClearMissedAlarmL();

            }

            break;

        case ECalenCmdClearAll:

            {

            OnCmdClearAllMissedAlarmsL();

            }

            break;

        case ECalenCmdGotoCalendar:

            {

            // Handling of this command may be moved to viewmanager in future,

            // as it is a general command not specific to missed alarms

            OnCmdGoToCalendarL();

            }

            break;

        case ECalenMissedAlarmsViewFromIdle:

            {

            RemoveAllViewedEventsL();

            iViewManager.StartActiveStepL();

            }

            break;

        case ECalenMissedEventViewFromIdle:

            {

            iLaunchedFromIdle = ETrue;

            OnCmdLaunchFromIdleL();

            }

            break;

        case ECalenEventViewFromAlarm:

            {

            TBool attachmentOpened = iController.Services().GetAttachmentData()->IsAttachmentOpen();

            if(!attachmentOpened)

                {

                LaunchEventViewerL();

                iViewManager.SetRepopulation(EFalse);

                iController.ViewManager().RequestActivationL( KUidCalenEventView, KUidCalenShowAlarmCba );

                }

            }

            break;

        case ECalenEventViewFromAlarmStopOnly:

            {

            LaunchEventViewerL();

            iViewManager.SetRepopulation(EFalse);

            iController.ViewManager().RequestActivationL( KUidCalenEventView, KUidCalenShowAlarmStopOnlyCba );

            }

            break;    

        default:

            break;

        }

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenAlarmManager::CalenCommandHandlerExtensionL

// Dummy implementation.

// (other items were commented in a header).

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

//

TAny* CCalenAlarmManager::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return NULL;

    }

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

// CCalenAlarmManager::HandleNotification

// Calls back when notifications that it has been registered for are broadcast

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

//

void CCalenAlarmManager::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    PIM_TRAPD_HANDLE( HandleNotificationL( aNotification ) );

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::HandleNotificationL

// Called from HandleNotification() when notifications that it has been

//  registered for are broadcast

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

//

void CCalenAlarmManager::HandleNotificationL( TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    switch(aNotification)

        {

        case ECalenNotifyLostAlarms:

            {

            HandleNotifyLostAlarmsL();

            }

            break;

        case ECalenNotifyEntryDeleted:

        case ECalenNotifyInstanceDeleted:

            {

            HandleBackEventL();

            HandleEntryDeleteNotificationL();

            }

            break;

        case ECalenNotifyEntrySaved:

            {

            HandleEntryDeleteNotificationL();

            }

            break;

        case ECalenNotifyMultipleEntriesDeleted:

            {

            // clear all the missed alarms from central repository

            iMissedAlarmStore->RemoveAllL();

            // clear the missed alarms list

            if(iMissedAlarmList.Count())

                {

                iMissedAlarmList.Close();

                }

            }

            break;

        case ECalenNotifyMissedAlarmViewClosed:

            {

            HandleMissedAlarmViewClosedL();

            }

            break;

        case ECalenNotifyClearMissedAlarms:

            {

            TVwsViewId activeView;

            iController.AppUi().GetActiveViewId(activeView);

            if(activeView.iViewUid == KUidCalenMissedAlarmsView)

                {

                OnCmdClearAllMissedAlarmsL();

                }

            }

            break;

        case ECalenNotifyMissedEventViewClosed:

            {

            HandleMissedEventViewClosedL();

            }

            break;

        case ECalenNotifySystemTimeChanged:

            {

            if(iMissedAlarmList.Count())

                {

                HandleSystemTimeChangedL();

                }

            }

            break;

        case ECalenNotifyAlarmStopped:

            {

            // notify alarmui through the context framework          

            iContextFWListener->AlarmStopL();

            }

            break;      

        case ECalenNotifyAlarmSnoozed: 

            {

            // notify alarmui through the context framework           

          	iContextFWListener->AlarmSnoozeL();

            }

            break;        

        case ECalenNotifyEntryClosed:

            {

            HandleBackEventL();

            }

            break;

        case ECalenNotifyAppForegrounded:

            {

            if( iController.IsFasterAppFlagEnabled() )

                {

                iController.SetFasterAppFlag( EFalse );

                }

            }

            break;

        default:

            break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::HandleNotifyGeneric

// From MCenRepNotifyHandlerCallback

// Generic notification that one of our central repository keys has changed

// If any keys change we broadcast a settings changed notification

// (other items were commented in a header).

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

//

void CCalenAlarmManager::HandleNotifyGeneric( TUint32 aCenrepKeyId )

    {

    TRACE_ENTRY_POINT;

    if( aCenrepKeyId <= KMissedAlarmsMaxValue)

        {

        iController.BroadcastNotification(ECalenNotifyLostAlarms);

        }

    TRACE_EXIT_POINT;

    }   

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

// CCalenAlarmManager::CreateMissedAlarmsListL

// Creates missed alarms list

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

void CCalenAlarmManager::CreateMissedAlarmsListL()

    {

    TRACE_ENTRY_POINT;

    if(iMissedAlarmList.Count())

        {

        iMissedAlarmList.Reset();

        }

    RPointerArray<CMissedAlarm> missedAlarmStorelist;      

    CleanupResetAndDestroyPushL( missedAlarmStorelist );   

    iMissedAlarmStore->GetL(missedAlarmStorelist); 

    TCalenInstanceId instanceId;

    TInt entryLocalUid;

    TTime instanceTime;

    for(TInt index=0;index < missedAlarmStorelist.Count();index++)

        {

        CMissedAlarm* missedAlarm = missedAlarmStorelist[index];

        entryLocalUid = missedAlarm->iLuid;

        instanceTime = missedAlarm->iInstanceTime;

        CCalSession *session = NULL; 

        TRAPD(err,session = &iController.Services().SessionL( missedAlarm->iCalFileName ));

        //missed alarm belongs to existing calendar 

        if(err != KErrNotFound)

            {

            // pack instance ids of the missed alarm instances

            TRAP_IGNORE(instanceId = TCalenInstanceId::CreateL( entryLocalUid, instanceTime, 0 ));

            instanceId.iColId = session->CollectionIdL();

            iMissedAlarmList.Append(instanceId);

            }

        else 

            {

            //missed alarm does not belong to any calendar so delete it, since user has deleted the calendar

            iMissedAlarmStore->RemoveL(*missedAlarm);

            }

        }

    CleanupStack::PopAndDestroy(); // missedAlarmStorelist

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::GetMissedAlarmsList

// Get Missed alarms list with viewed inf

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

void CCalenAlarmManager::GetMissedAlarmsList(RArray<TCalenInstanceId>& aMissedAlarmsList)

    {

    TRACE_ENTRY_POINT;

    if(!iMissedAlarmList.Count())

        {

        TRAP_IGNORE(CreateMissedAlarmsListL());

        }

     for(TInt index=0;index<iMissedAlarmList.Count();index++)

        {

        aMissedAlarmsList.Append(iMissedAlarmList[index]); 

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::StartAlarmContextListener

// Creates CCalenContextFWListener object for Alarm

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

void CCalenAlarmManager::StartAlarmContextListenerL()

    {

    TRACE_ENTRY_POINT;

    //if in alarm viewer mode: 

    iContextFWListener = CCalenContextFWListener::NewL(*this);

    // raise calendar priority as the topmost window (alarmui is left at the background)

    RWindowGroup& windowGroup = CCoeEnv::Static()->RootWin();

    iOrigWGPos = windowGroup.OrdinalPosition();

    iOrigWGPrio = windowGroup.OrdinalPriority();

    // move the window on top of the alarm notification window!

    PIM_ASSERT( windowGroup.SetOrdinalPositionErr( 0, ECoeWinPriorityAlwaysAtFront +KGlobalWindowPriority_Alarm +1 ) );    

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::StopAlarmContextListener

// Destroys CCalenContextFWListener object for Alarm

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

void CCalenAlarmManager::StopAlarmContextListener(TBool aCloseEventView)

    {

    TRACE_ENTRY_POINT;

    // restore window group priority

    RWindowGroup& windowGroup = CCoeEnv::Static()->RootWin();

	PIM_ASSERT( windowGroup.SetOrdinalPositionErr( KCalendarWindowOnFront, iOrigWGPrio ) );  

    //Close Event View

    if(aCloseEventView)

    	{

    	MCalenToolbar* toolbarImpl = iController.ViewManager().ToolbarOrNull();

    	if(toolbarImpl) // If toolbar exists

    	    {

    	    CAknToolbar& toolbar = toolbarImpl->Toolbar();

    	    // Remove the viewer toolbar buttons

    	    toolbar.RemoveItem(ECalenDeleteCurrentEntry); // Delete button

    	    toolbar.RemoveItem(ECalenEditCurrentEntry);  // Edit button

    	    toolbar.RemoveItem(ECalenSend);  // Send button

    	    }

    	iController.BroadcastNotification( ECalenNotifyEntryClosed );

    	}

	TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::StopContextListenerForAutoSnooze

// Destroys CCalenContextFWListener object for autosnooze case

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

//

void CCalenAlarmManager::StopContextListenerForAutoSnooze()

    {

    TRACE_ENTRY_POINT;

    // restore window group priority

    RWindowGroup& windowGroup = CCoeEnv::Static()->RootWin();

	PIM_ASSERT( windowGroup.SetOrdinalPositionErr( KCalendarWindowOnFront, iOrigWGPrio ) );  

    // After auto snooze, stop the alarm and open the event viewer in normal mode.

    iController.BroadcastNotification( ECalenNotifyStopAlarm );    

    TRACE_EXIT_POINT;

    }

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

// CCalenAlarmManager::MissedAlarmStore

// Returns a reference to the Missed Alarm Store

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

CMissedAlarmStore* CCalenAlarmManager::MissedAlarmStore()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iMissedAlarmStore;

    }   

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

// CCalenAlarmManager::OnCmdMissedAlarmViewL

// Handles the command ECalenMissedAlarmsView

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

//

void CCalenAlarmManager::OnCmdMissedAlarmViewL()

    {

    TRACE_ENTRY_POINT;