/*
* Copyright (c) 2004 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:  Provides methods for queueing and other funtionalities for alarms. 
 *
*/



//debug
#include "calendarui_debug.h"

#include "CalenSvrAlarmManager.h"
#include <calenglobaldata.h>

#include "CalendarPrivateCRKeys.h"  // includes CalendarInternalCRKeys.h

#include <asshdalarm.h>
#include <bacntf.h>
#include <centralrepository.h>
#include <tz.h>
#include <calenconstants.h>

const TUid KUidAgendaAlarmCategory = { 0x101F4A70 };


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CCalenSvrAlarmManager* CCalenSvrAlarmManager::NewL()
    {
    TRACE_ENTRY_POINT;

    CCalenSvrAlarmManager* self = new( ELeave )CCalenSvrAlarmManager();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;
    return self;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CCalenSvrAlarmManager::CCalenSvrAlarmManager()
    {
    TRACE_ENTRY_POINT;
    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::ConstructL()
    {
    TRACE_ENTRY_POINT;

    // there is no visible need to keep the session open...
    // would it break something if we open it only when needed...?
    User::LeaveIfError( iAlarmServer.Connect() );

    // store the current time zone 
    // so we can check if it was changed after system time change
    iTimeZone = CurrentTimeZoneIdL();

    // register locale change listener. This listens for system time
    // change events. When system time is changed, skipped alarms are checked
    // and alarms are requeued. 
    TCallBack callback( LocaleChangeCallback, this );
    iLocaleChangeNotifier = CEnvironmentChangeNotifier::NewL( CActive::EPriorityStandard, callback );
    iLocaleChangeNotifier->Start();

    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
TUint CCalenSvrAlarmManager::CurrentTimeZoneIdL() const
    {
    TRACE_ENTRY_POINT;

    RTz timeZoneSrv;
    User::LeaveIfError( timeZoneSrv.Connect() );
    CleanupClosePushL( timeZoneSrv );

    CTzId* tzID = timeZoneSrv.GetTimeZoneIdL();
    TUint id = tzID->TimeZoneNumericID();
    delete tzID;

    CleanupStack::PopAndDestroy(); // close timeZoneSrv

    TRACE_EXIT_POINT;
    return id;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CCalenSvrAlarmManager::~CCalenSvrAlarmManager()
    {
    TRACE_ENTRY_POINT;

    delete iLocaleChangeNotifier;

    iAlarmServer.Close();
    
    if ( iGlobalData )
        {
        iGlobalData->Release();
        }

    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
TInt CCalenSvrAlarmManager::LocaleChangeCallback(TAny* aThisPtr)
    {
    TRACE_ENTRY_POINT;
    TInt retVal = static_cast<CCalenSvrAlarmManager*>( aThisPtr )->HandleLocaleChange();
    TRACE_EXIT_POINT;
    return retVal;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
TInt CCalenSvrAlarmManager::HandleLocaleChange()
    {
    TRACE_ENTRY_POINT;
    if( iLocaleChangeNotifier->Change() & EChangesSystemTime )
        {
        PIM_TRAPD_HANDLE( CheckSkippedAlarmsL(); )
        PIM_TRAPD_HANDLE( ReQueueAlarmsL(); )
        }
    TRACE_EXIT_POINT;
    return 0;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::CheckSkippedAlarmsL()
    {
    TRACE_ENTRY_POINT;

    // remove alarms from alarm server
    RArray<TAlarmId> skippedAlarms;
    CleanupClosePushL( skippedAlarms );
    GetSkippedAgendaAlarmsL( skippedAlarms );

    // fetch the current time zone to compare it with the old one
    const TUint newTimeZone = CurrentTimeZoneIdL();
    const TBool tzChanged( newTimeZone != iTimeZone );
    iTimeZone = newTimeZone;

    if( skippedAlarms.Count() )
        {
        for(TInt i(0); i < skippedAlarms.Count(); i++)
            {
            iAlarmServer.AlarmDelete( skippedAlarms[i] );
            }
        SetSystemTimeChangedFlagL( KCalenLostAlarms );
        }
    else
        {
        // there wasn't any skipped alarms, but time zone was changed
        if( tzChanged )
            {
            // value KCalenTimeZoneChanged in KCalendarLostAlarm indicates a time zone change
            SetSystemTimeChangedFlagL( KCalenTimeZoneChanged );
            }
        }

    CleanupStack::PopAndDestroy( &skippedAlarms ); // close skippedAlarms

    TRACE_EXIT_POINT;
    }
    
// ---------------------------------------------------------------------------
// Open an entry view to re-queue calendar alarms.
// ---------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::ReQueueAlarmsL()
    {
    TRACE_ENTRY_POINT;
    if( !iOpeningEntryView )
        {
        // leave only after the iOpeningEntryView has been set back to EFalse!
        iOpeningEntryView = ETrue;
        
        
        // An entry view is created to make sure that the calendar 
        // alarms get queued. The entry view creation within the 
        // global data is done asyncronously. 
        TRAPD( error,
                    // Is the global data already constructed?
                    CCalenGlobalData* existingGD = CCalenGlobalData::Instance();
                    CCalenGlobalData* gData = NULL;
                    if ( !existingGD )
                        {
                        // If not create the global data, but using 
                        // this class as the observer.
                        // Context change notifier is NULL.
                        iGlobalData = CCalenGlobalData::NewL( *this, NULL );
                        gData = iGlobalData;
                        }
                    else 
                        {
                        gData = existingGD;
                        CleanupReleasePushL( *existingGD );
                        }
                          
                    // Create the session
                    gData->CalSessionL();
                        
                    // Get the entryView, if this is null it the entry view
                    // will be created asyncronously.
                    gData->EntryViewL();
                    
                    if ( existingGD )
                        {
                        // If the global data already existed, it can be
                        // released here else it will be released upon the
                        // callback being completed.
                        CleanupStack::PopAndDestroy(); // existingGD
                        }
            );

            iOpeningEntryView = EFalse;
            User::LeaveIfError( error );
        }
        
    TRACE_EXIT_POINT;
    }
    
// -----------------------------------------------------------------------------
// CCalenSvrAlarmManager::Completed
// Called when the construction of the entry view
// has completed.
// -----------------------------------------------------------------------------
//    
void CCalenSvrAlarmManager::Completed(TInt /*aError*/)
    {
    // In this instance, interest is in the
    // entry view being created. Therefore
    // the global data can be released.
    iGlobalData->Release();
    iGlobalData = NULL;
    }

// -----------------------------------------------------------------------------
// CCalenSvrAlarmManager::NotifyProgress()
// Returns if progress notifications are
// required. As there is no interest in
// the progress returns EFalse.
// -----------------------------------------------------------------------------
//
TBool CCalenSvrAlarmManager::NotifyProgress()
    {
    TRACE_ENTRY_POINT;
    
    return EFalse;
     
    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CCalenSvrAlarmManager::Progress
// Intentionally empty as there is no interest in the
// progress of the entry view creation
// -----------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::Progress(TInt /*aPercentageCompleted*/)
    {
    TRACE_ENTRY_POINT;
    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::SetSystemTimeChangedFlagL(TInt aFlag)
    {
    TRACE_ENTRY_POINT;

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

    User::LeaveIfError( repository->Set( KCalendarLostAlarm, aFlag ) );

    CleanupStack::PopAndDestroy(); // repository

    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CCalenSvrAlarmManager::GetSkippedAgendaAlarmsL(RArray<TAlarmId>& aSkippedAlarms) const
    {
    TRACE_ENTRY_POINT;

    RArray<TAlarmId> alarmIds;
    CleanupClosePushL( alarmIds );

    TRAPD( err, 
           iAlarmServer.GetAlarmIdListForCategoryL( KUidAgendaAlarmCategory, alarmIds ); )

    if( err == KErrNone )
        {
        TTime now;
        now.HomeTime();
        // ignoring seconds and microseconds.
        TDateTime tmp( now.DateTime() );
        tmp.SetSecond( 0 );
        tmp.SetMicroSecond( 0 );
        now = tmp;

        for(TInt i(0); i < alarmIds.Count(); i++)
            {
            TASShdAlarm alarm;
            iAlarmServer.GetAlarmDetails( alarmIds[i], alarm );

            if( alarm.IsFloating() && // fixed alarms won't expire due to time or time zone changes
                alarm.State() != EAlarmStateNotified &&
                alarm.NextDueTime() < now )
                {
                aSkippedAlarms.Append( alarmIds[i] );
                }
            }
        }

    CleanupStack::PopAndDestroy( &alarmIds ); // close alarmIds array

    TRACE_EXIT_POINT;
    }


// End of File