/*

* Copyright (c) 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:   Notifies observers of external changes to the calendar database

*

*/

//debug

#include "calendarui_debug.h"

// INCLUDE FILES

#include "CleanupResetAndDestroy.h"

#include "calendbchangenotifier.h"    // CCalenDbChangeNotifier

#include "calenglobaldata.h"            // Calendar global data

#include <calsession.h>                 // CalSession

#include <missedalarm.h>

#include <missedalarmstore.h>

#include <missedalarmstorecrkeys.h>

#include <calcalendarinfo.h>

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

// KTimerResolution limits the number of notifications sent to registered

// MCalenDBChangeObserver instances.  Notifications may come from 

// MCalChangeCallBack2 at a very high rate which could impact performance, 

// for example by causing constant view refreshes.

// CCalenDbChangeNotifier notifies observers when KTimerResolution has elapsed

// since the last notification was received from MCalChangeCallBack2

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

const TInt KTimerResolution = 1000000;  // 1 Second

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

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

// CCalenDbChangeNotifier::CCalenDbChangeNotifier

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

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

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

CCalenDbChangeNotifier::CCalenDbChangeNotifier( CCalSession& aSession ) 

    : CActive( EPriorityNormal ),

      iSession( aSession )

    {

    TRACE_ENTRY_POINT;

    iRestartTimer = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenDbChangeNotifier::NewL

// Two-phased constructor.

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

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

CCalenDbChangeNotifier* CCalenDbChangeNotifier::NewL( CCalSession& aSession )

    {

    TRACE_ENTRY_POINT;

    CCalenDbChangeNotifier* self = new( ELeave ) CCalenDbChangeNotifier( aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenDbChangeNotifier::ConstructL

// Symbian 2nd phase constructor can leave.

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

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

void CCalenDbChangeNotifier::ConstructL()

    {

    TRACE_ENTRY_POINT;

    // We want to receive notifications for the full agenda date range

    TCalTime start, end;

    start.SetTimeUtcL( TCalTime::MinTime() );

    end.SetTimeUtcL( TCalTime::MaxTime() );

    CalCommon::TCalTimeRange range( start, end ); 

    // Create a notification filter

    iCalChangeFilter = CCalChangeNotificationFilter::NewL(

                                                        MCalChangeCallBack2::EChangeEntryAll, 

                                                        ETrue, 

                                                        range );

    // Enable database change notifications on current global data session

    iSession.StartChangeNotification( *this, *iCalChangeFilter );

    // Create a timer to limit the number of notifications broadcast

    iNotificationTimer.CreateLocal();

    // Active object, add to active scheduler

    CActiveScheduler::Add( this );

    TRACE_EXIT_POINT;

    }

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

// CCalenDbChangeNotifier::~CCalenDbChangeNotifier

// Destructor

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

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

CCalenDbChangeNotifier::~CCalenDbChangeNotifier()

    {

    TRACE_ENTRY_POINT;

    Cancel();

    // Reset the observer array.  Array contents are NOT owned by this class

    iDBObservers.Reset();

    iNotificationTimer.Close();

    // Disable database change notifications on current global data session   

    PIM_TRAPD_HANDLE( iSession.StopChangeNotification() );

    // Destroy the notification filter

    delete iCalChangeFilter;

    TRACE_EXIT_POINT;    

    }

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

// CCalenDbChangeNotifier::LastDBModificationTime

// Returns the time of the last database change notification.  This may not be

// the time of the last notification sent to MCalenDBChangeObservers.

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

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

TTime CCalenDbChangeNotifier::LastDBModificationTime() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iLastDbChangeNotification;

    }

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

// CCalenDbChangeNotifier::CalChangeNotification

// Called when a change to the agenda database occurs from a different session

// to the one we are currently using.

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

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

void CCalenDbChangeNotifier::CalChangeNotification( RArray<TCalChangeEntry>& aChangeItems )

    {

    TRACE_ENTRY_POINT;

    TRAP_IGNORE(HandleMissedAlarmsL(aChangeItems));

    // Always update the last notification time, even if we don't notify 

    // our observers

    iLastDbChangeNotification.UniversalTime();

    if( !IsActive() )

        {

        iNotificationTimer.After( iStatus, KTimerResolution );

        SetActive();

        }

    else

        {

        iRestartTimer = ETrue;

        iNotificationTimer.Cancel();

        }

    TRACE_EXIT_POINT;

    }

void CCalenDbChangeNotifier::HandleMissedAlarmsL(const RArray<TCalChangeEntry>& aChangeItems)

    {

    TRACE_ENTRY_POINT

    CRepository* missedAlarmStoreRepository = CRepository::NewL(

            KCRUidMissedAlarmStore);

    // Create missed alarm store

    CMissedAlarmStore* missedAlarmStore = CMissedAlarmStore::NewL(

            *missedAlarmStoreRepository);

    CleanupStack::PushL(missedAlarmStore);

    RPointerArray<CMissedAlarm> missedAlarmStorelist;

    CleanupResetAndDestroyPushL(missedAlarmStorelist);

    missedAlarmStore->GetL(missedAlarmStorelist);

    CCalCalendarInfo* calendarInfo = iSession.CalendarInfoL();

    CleanupStack::PushL(calendarInfo);

    CCalenDbChangeNotifier::TCalLuidFilename calLuidFilename;

    calLuidFilename.iFilename = calendarInfo->FileNameL();

    if (missedAlarmStorelist.Count())

        {

        for (TInt idx = 0; idx < aChangeItems.Count(); idx++)

            {

            if (aChangeItems[idx].iChangeType == EChangeDelete)

                {

                calLuidFilename.iLuid = aChangeItems[idx].iEntryId;

                    {

                    CMissedAlarm* missedAlarm = missedAlarmStorelist[index];

                    missedAlarmStore->RemoveL(*missedAlarm);

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy(calendarInfo);

    CleanupStack::PopAndDestroy(&missedAlarmStorelist);

    CleanupStack::PopAndDestroy(missedAlarmStore);

    TRACE_EXIT_POINT    

    }

TBool CCalenDbChangeNotifier::DoFindEntryByLuid(

                const TCalLuidFilename* aLuidFilename,const CMissedAlarm& aMissedAlarm)

    {

    TRACE_ENTRY_POINT

    TRACE_EXIT_POINT

    return (aLuidFilename->iLuid == aMissedAlarm.iLuid 

            && !aLuidFilename->iFilename.CompareF(aMissedAlarm.iCalFileName));

    }

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

// CCalenDbChangeNotifier::RegisterObserverL

// Adds the passed observer to the observer array.  All observers in the array 

// will be notified of changes to the agenda database.

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

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

 void CCalenDbChangeNotifier::RegisterObserverL( MCalenDBChangeObserver& aDBObserver )

    {

    TRACE_ENTRY_POINT;

    iDBObservers.Append( &aDBObserver );

    TRACE_EXIT_POINT;

    }

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

// CCalenDbChangeNotifier::DeRegisterObserverL

// Removes the passed observer to the observer array.  All observers in the array 

// will be notified of changes to the agenda database.

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

void CCalenDbChangeNotifier::DeRegisterObserverL( MCalenDBChangeObserver& aDBObserver )

    {

    TRACE_ENTRY_POINT;

    for( TInt x = 0; x < iDBObservers.Count(); ++x )

        {

        if( iDBObservers[x] == &aDBObserver )

            {

            iDBObservers.Remove( x );

            return;

            }

        }

    User::Leave( KErrNotFound );

    TRACE_EXIT_POINT;

    }

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

// CCalenDbChangeNotifier::RunL

// From CActive::RunL

// Called when notification timer expires

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

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

void CCalenDbChangeNotifier::RunL()

    {

    TRACE_ENTRY_POINT;

    switch( iStatus.Int() )

        {

        case KErrCancel:

            {

            // The normal reason for the timer being cancelled is another

            // database change.  Restart the timer.

            if( iRestartTimer )

                {

                iRestartTimer = EFalse;

                iNotificationTimer.After( iStatus, KTimerResolution );

                SetActive();

                }        

            }

        break;

        case KErrNone:

            {

            //Timer completion, notify observers

            for( TInt x = 0; x < iDBObservers.Count(); ++x )

                {

                iDBObservers[x]->HandleDBChangeL();

                }

            }

        break;

        default:

            {

            User::Leave( KErrArgument );

            }

        break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenDbChangeNotifier::RunError

// From CActive::RunError

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

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

TInt CCalenDbChangeNotifier::RunError( TInt aError )

    {

    TRACE_ENTRY_POINT;

    //RunL leaving means that the view could not be refreshed.

    //Theres not much we can do except be ready for the next database event.

    iRestartTimer = EFalse;

    TRACE_EXIT_POINT;

    return aError;

    }

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

// CCalenDbChangeNotifier::DoCancel

// From CActive::DoCancel

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

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

void CCalenDbChangeNotifier::DoCancel()

    {

    TRACE_ENTRY_POINT;

    // Stop the notification timer

    iRestartTimer = EFalse;

    iNotificationTimer.Cancel();

    TRACE_EXIT_POINT;

    }

// End of File