/*

* 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:   An missed alarm handler class, CCalenSvrMissedAlarmManager.

 *                This class takes care of handling the UI and cenrep updation

 *                for missed alarms.

 *

*/

#include <avkon.rsg> 

#include <AknSmallIndicator.h>

#include <centralrepository.h>

#include <missedalarmstorecrkeys.h>

#include <CalendarInternalCRKeys.h>

#include <calensvrmissedalarmmanagerresource.rsg>

#include "calendarui_debug.h"

#include "calensvrmissedalarmmanager.h"

#include "calenmissedalarmconstants.h"

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

// CCalenSvrMissedAlarmManager::NewL

// First phase construction

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

//

CCalenSvrMissedAlarmManager* CCalenSvrMissedAlarmManager::NewL()

    {

    TRACE_ENTRY_POINT;

    CCalenSvrMissedAlarmManager* self = new( ELeave )CCalenSvrMissedAlarmManager();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenSvrMissedAlarmManager::CCalenSvrMissedAlarmManager

// Default constructor

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

//

CCalenSvrMissedAlarmManager::CCalenSvrMissedAlarmManager() :

		CActive(CActive::EPriorityLow),

    iNumOfMissedAlarms( KNoMissedAlarms ),

    iShowSoftNotification( EFalse )

    {

    TRACE_ENTRY_POINT;

    CActiveScheduler::Add(this);

    TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::CCalenSvrMissedAlarmManager

// Second phase construction

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

//

void CCalenSvrMissedAlarmManager::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iSoftNotifier = CAknSoftNotifier::NewL();

    iMissedAlarmStoreRepository = CRepository::NewL( KCRUidMissedAlarmStore );

    // Create missed alarm store

    iMissedAlarmStore = CMissedAlarmStore::NewL(*iMissedAlarmStoreRepository);

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

    iCenRepChangeNotifier->StartListeningL();

    Start();

    TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::~CCalenSvrMissedAlarmManager

// Destructor

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

//

CCalenSvrMissedAlarmManager::~CCalenSvrMissedAlarmManager()

    {

	TRACE_ENTRY_POINT;

	Cancel();

	delete iSoftNotifier;

    iSoftNotifier = NULL;

    if(iCenRepChangeNotifier)

        {

        iCenRepChangeNotifier->StopListening();

        delete iCenRepChangeNotifier;

        }

    delete iMissedAlarmStore;

    iMissedAlarmStore = NULL;

	TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::Start

// Start the scheduler

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

//

void CCalenSvrMissedAlarmManager::Start()

	{

	TRACE_ENTRY_POINT;

	__ASSERT_ALWAYS(!IsActive(), User::Invariant());

	TRequestStatus* pStat = &iStatus;

    User::RequestComplete(pStat, KErrNone);

    SetActive();	

    TRACE_EXIT_POINT;

	}

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

// CCalenSvrMissedAlarmManager::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 CCalenSvrMissedAlarmManager::HandleNotifyGeneric( TUint32 aCenrepKeyId )

    {

    TRACE_ENTRY_POINT;

    if(aCenrepKeyId <= KMissedAlarmsMaxValue)

        {

        TRAP_IGNORE(HandleMissedAlarmL());

        }

    TRACE_EXIT_POINT;

    } 

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

// CCalenSvrMissedAlarmManager::HandleMissedAlarmL

// Handles the change in missed alarm store.

// updates soft notification and indicator plugins

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

//

void CCalenSvrMissedAlarmManager::HandleMissedAlarmL()

    {

	TRACE_ENTRY_POINT;

	//If the value of supressnotification is 1 then supress the missed alarm soft notification

	//If the value of supressnotification is 0 then show the missed alarm soft notification

	CRepository* repository = CRepository::NewL( KCRUidCalendar );

    TBool supressnotification = EFalse;

    repository->Get( KCalendarSupressMissedAlarmSoftNotification, supressnotification );

    if( supressnotification )

        {

        TRACE_EXIT_POINT;

        return;

        }

	//Update with the count from the metadata

	GetCountOfMissedAlarmsL();

	// Update Soft Notifications 

	HandleMissedAlarmSoftNotificationL();

    TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::DoCancel

// For cancel

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

//

void CCalenSvrMissedAlarmManager::DoCancel()

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

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

// CCalenSvrMissedAlarmManager::RunError

// ?implementation_description

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

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

//	

TInt CCalenSvrMissedAlarmManager::RunError(TInt /*aError*/)

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	return 0;	

	}

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

// CCalenSvrMissedAlarmManager::RunL

// Handle missed alarms on RunL

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

//	

void CCalenSvrMissedAlarmManager::RunL()

	{

	TRACE_ENTRY_POINT;

	HandleMissedAlarmL();

	TRACE_EXIT_POINT;	

	}

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

// CCalenSvrMissedAlarmManager::GetCountOfMissedAlarms

// Get count of missed alarms from cenrep

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

//

void CCalenSvrMissedAlarmManager::GetCountOfMissedAlarmsL()

    {

	TRACE_ENTRY_POINT;

	TUint32 newCount = 0;

	iMissedAlarmStore->CountL(newCount);

	if(TInt(newCount) <= KNoMissedAlarms)

	    {

		iNumOfMissedAlarms = KNoMissedAlarms;

		iShowSoftNotification = EFalse;	

	    }

	else

	    {

		/*if(iNumOfMissedAlarms > TInt(newCount))

		    {

		    iShowSoftNotification = EFalse;

		    }

		else

		    {

		    iShowSoftNotification = ETrue;

		    }*/

	// changes done for missing popup in idle screen when alarm expires in editor mode

		iNumOfMissedAlarms = TInt(newCount);

		iShowSoftNotification = ETrue;

	    }

	TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::HandleMissedAlarmSoftNotificationL

// Update soft notification/status pane indicator

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

//

void CCalenSvrMissedAlarmManager::HandleMissedAlarmSoftNotificationL()

    {

	TRACE_ENTRY_POINT;	

	//Update indicator 

	HandleMissedAlarmSmallIndicatorL(

	        (iNumOfMissedAlarms > KNoMissedAlarms ? ETrue : EFalse));

	CAknSoftNotificationParameters* softNotificationParameters = 

	                        CreateNotificationParametersLC( aNotificationType );

	if(!iShowSoftNotification )

	    {

	    iSoftNotifier->CancelCustomSoftNotificationL( *softNotificationParameters );

	    }

	else

	    { 

	    if(iNumOfMissedAlarms > KNoMissedAlarms) //check for -ve

	        {

	        iSoftNotifier->SetCustomNotificationCountL(

	                                *softNotificationParameters, iNumOfMissedAlarms );	

	        }

	    }

	CleanupStack::PopAndDestroy( softNotificationParameters );		

	TRACE_EXIT_POINT;	

    }

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

// CCalenSvrMissedAlarmManager::HandleMissedAlarmCoverUISoftNotificationL

// ?implementation_description

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

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

//

void CCalenSvrMissedAlarmManager::HandleMissedAlarmCoverUISoftNotificationL()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenSvrMissedAlarmManager::CreateNotificationParametersLC

// Initialise soft notification parameters. 

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

//

CAknSoftNotificationParameters* CCalenSvrMissedAlarmManager::

                                CreateNotificationParametersLC(

                       			const TAknSoftNotificationType aNotificationType  )

    {

	TRACE_ENTRY_POINT;

	// instantiate parameters

	CAknSoftNotificationParameters* softNotificationParameters = NULL;

	switch( aNotificationType )

	    {

        case ECustomSoftNotification: //Notification for missed alarm message

			{

            TUint32 newCount = 0;

            iMissedAlarmStore->CountL(newCount);

            if(newCount>1)

                {

                // if count is more than one,launch missed alarms view

                const TDesC8& viewActivationMsg = _L8("MAV");

                softNotificationParameters = CAknSoftNotificationParameters::NewL(

                        KMissedAlarmResourceFile,

                        R_MISSED_ALARM_SOFT_NOTIFICATION ,

                        KMissedAlarmNotificationPriority,

                        R_AVKON_SOFTKEYS_SHOW_EXIT,                             

                        CAknNoteDialog::ENoTone,

                        KMissedAlarmsViewId,

                        KCommandUid,

                        EAknSoftkeyShow,

                        viewActivationMsg);

                softNotificationParameters->SetGroupedTexts( R_MISSED_ALARM_UI_GROUPED );

                }

            else

                {

                // if count is one,launch missed event view

                const TDesC8& viewActivationMsg = _L8("MEV");

                softNotificationParameters = CAknSoftNotificationParameters::NewL(

                        KMissedAlarmResourceFile,

                        R_MISSED_ALARM_SOFT_NOTIFICATION ,

                        KMissedAlarmNotificationPriority,

                        R_AVKON_SOFTKEYS_SHOW_EXIT,                             

                        CAknNoteDialog::ENoTone,

                        KMissedEventViewId,

                        KCommandUid,

                        EAknSoftkeyShow,

                        viewActivationMsg);

                softNotificationParameters->SetGroupedTexts( R_MISSED_ALARM_UI_GROUPED );

                }

			break;

			}

         default:

			{

			// No other notification type is supported for now.

			User::Leave( KErrNotFound );

			break;

			}

	  }

  CleanupStack::PushL( softNotificationParameters );

  TRACE_EXIT_POINT;

  return softNotificationParameters;

}

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

// CCalenSvrMissedAlarmManager::HandleMissedAlarmSmallIndicatorL

// For Handling calendar's status pane indicator

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

//

void CCalenSvrMissedAlarmManager::HandleMissedAlarmSmallIndicatorL(TBool aArg)

    {

    TRACE_ENTRY_POINT;

	CAknSmallIndicator* indicator = CAknSmallIndicator::NewL(

	                            TUid::Uid( EAknIndicatorMissedCalendarAlarm ) );

	CleanupStack::PushL(indicator);

	indicator->SetIndicatorStateL( aArg );	

	CleanupStack::PopAndDestroy(); // indicator

    TRACE_EXIT_POINT;

    }   

// End of file