/*

* Copyright (c) 2002 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:  

 *

*/

//debug

#include "calendarui_debug.h"

// INCLUDE FILES

#include "AIAgendaPluginEngine.h"

#include "AIAgendaPluginEngineImpl.h"

#include "PluginDataChangeObserver.h"

#include "EventExpirationTimer.h"

#include <calsession.h>

#include <calentry.h>

#include <calinstance.h>

#include <calrrule.h>

#include <calnotification.h>

#include <coemain.h>

#include <bacntf.h>

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

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

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

// (CAIAgendaPluginEngineImpl)

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

// CAIAgendaPluginEngineImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAIAgendaPluginEngineImpl::ConstructL(void)

{

    TRACE_ENTRY_POINT;

    iSession.ConnectL();

    if( iObserverType == ECalendarObserver || iObserverType == ECalendarAndTodoObserver )

    {

        TCallBack environmentChangeCallBack( EnvironmentChangeCallBack, this );

        // Create a notifier for system time and locale changes and midnight crossover

        iEnvironmentChangeNotifier = CEnvironmentChangeNotifier::NewL( EActivePriorityLogonA,

                                                                       environmentChangeCallBack );

        iEnvironmentChangeNotifier->Start();

        iEventChangeObserver = CPropertyObserver::NewL( *this, KCalPubSubCategory, ECalPubSubEventNotification, ETrue);

    }

    if( iObserverType == EToDoObserver || iObserverType == ECalendarAndTodoObserver )

    {

        iTodoChangeObserver = CPropertyObserver::NewL( *this, KCalPubSubCategory, ECalPubSubTodoNotification, ETrue );

    }

    TCallBack expirationCallBack( EventExpiredCallBack, this );

    iExpirationTimer = CEventExpirationTimer::NewL( expirationCallBack );

    TCallBack refreshCallBack( RefreshTimerCallBack, this );

    iRefreshTimer = CEventExpirationTimer::NewL( refreshCallBack );

    StateMachine();

    iCalendarSession = CCalSession::NewL();

    iCalendarSession->StartFileChangeNotificationL(*this);

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::NewL

// Two-phased constructor.

// Create instance of concrete ECOM interface implementation

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

//

CAIAgendaPluginEngineImpl* CAIAgendaPluginEngineImpl::NewL(MPluginDataChangeObserver& aDataChangeObserver, TObserverType aObserverType)

{

    TRACE_ENTRY_POINT;

    CAIAgendaPluginEngineImpl* self = new( ELeave )CAIAgendaPluginEngineImpl( aDataChangeObserver, aObserverType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

}

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

// CAIAgendaPluginEngineImpl::CAIAgendaPluginEngineImpl

// ?implementation_description

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

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

//

CAIAgendaPluginEngineImpl::CAIAgendaPluginEngineImpl(MPluginDataChangeObserver& aDataChangeObserver, TObserverType aObserverType)

 : iDataChangeObserver( aDataChangeObserver ),

   iObserverType( aObserverType ),

   iDBState( EDBOffline ),

   iNeedsUpdate( EFalse ),

   iHadEvents( EFalse )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CAIAgendaPluginEngineImpl::~CAIAgendaPluginEngineImpl

// ?implementation_description

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

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

//

CAIAgendaPluginEngineImpl::~CAIAgendaPluginEngineImpl(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOffline;

	if(iCalendarSession)

		{

		iCalendarSession->StopFileChangeNotification();

		delete iCalendarSession;

		iCalendarSession = NULL;

		}

    delete iExpirationTimer;

    delete iRefreshTimer;

    delete iEventChangeObserver;

    delete iTodoChangeObserver;

    if( iEnvironmentChangeNotifier )

    {

        iEnvironmentChangeNotifier->Cancel();

        delete iEnvironmentChangeNotifier;

    }

    delete iCalendarEngine;  // Close() called in destructor

    iInstanceArray.ResetAndDestroy();

    iInstanceArray.Close();

    iSession.Close();

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::StateMachine

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::StateMachine(void)

{

    TRACE_ENTRY_POINT;

    if( iObserverType == ECalendarObserver || iObserverType == ECalendarAndTodoObserver )

    {

        iExpirationTimer->Cancel();

    }

    iNeedsUpdate = EFalse;

    switch( iDBState )

    {

        case EDBOffline:

        {

            iDBState = EDBInitializing;

            iSession.Initialize( *this );

        }

        break;

        case EDBInitialized:

        {

            OpenDataBase();

            iDBState = EDBOpening;  // EDBInitialized -> EDBOpening

        }

        break;

        case EDBInitializing:

        case EDBOpening:

        {

            // needs update 

            // -> set the fetch state to normal and wait...

            iFetchState = EFetchNormal;

        }

        break;

        case EDBOpen:

        {

            if( iFetchState == EFetchNormal )

            {

                GetTodayData();

            }

            else

            {

                GetFutureData();

            }

            iFetchState = EFetchNormal;

            iDBState = EDBReading;  // EDBOpen -> EDBReading

        }

        break;

        case EDBReading:

        {

            // needs update

            // -> set the flag

            iNeedsUpdate = ETrue;  // the only place where we set this to ETrue!!!

            // then set the fetch state to normal and wait...

            iFetchState = EFetchNormal;

        }

        break;

        default:

            // fall through...

            break;

    }

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::OpenDataBase

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::DoOpenDataBaseL(void)

{

    TRACE_ENTRY_POINT;

    iCalendarEngine = CCalenEngine::NewL();  // TRAPPED!

    iCalendarEngine->OpenDatabaseL( *this );  // TRAPPED!

    TRACE_EXIT_POINT;

}

void CAIAgendaPluginEngineImpl::OpenDataBase(void)

    {

    TRACE_ENTRY_POINT;

    TRAPD(err, DoOpenDataBaseL());

    if(err != KErrNone)

        {

        CloseCalendarEngine();

        }

    TRACE_EXIT_POINT;    

    }

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

// CAIAgendaPluginEngineImpl::OpenDatabaseCompleted

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::OpenDatabaseCompleted(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOpen;  // EDBOpening -> EDBOpen

    StateMachine();

    TRACE_EXIT_POINT;

}

void CAIAgendaPluginEngineImpl::GetTodayData(void)

   {

    TRACE_ENTRY_POINT;

    TRAPD(err, DoGetTodayDataL());

    if(err != KErrNone)

        {

        CloseCalendarEngine();

        }

    TRACE_EXIT_POINT;    

    }

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

// CAIAgendaPluginEngineImpl::GetTodayData

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::DoGetTodayDataL(void)

{

    TRACE_ENTRY_POINT;

    TTime today;

    today.HomeTime();

    iInstanceArray.ResetAndDestroy();

    switch( iObserverType )

    {

        case ECalendarObserver:

            iCalendarEngine->GetEntriesForDayL( *this, today, iInstanceArray );  // TRAPPED!

            break;

        case EToDoObserver:

            iCalendarEngine->GetTodosL( *this, iInstanceArray );  // TRAPPED!

            break;

        case ECalendarAndTodoObserver:

            iCalendarEngine->GetCalendarDataL( *this, iInstanceArray, today, 8/* total number of days to search */ );  // TRAPPED

            break;

        default:

            ASSERT( EFalse );

    }

    TRACE_EXIT_POINT;

}

void CAIAgendaPluginEngineImpl::GetEntriesCompleted(void)

    {

    TRACE_ENTRY_POINT;

    TRAPD(err, DoGetEntriesCompletedL());

    if(err != KErrNone)

        {

        CloseCalendarEngine();

        }

    TRACE_EXIT_POINT;    

    }

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

// CAIAgendaPluginEngineImpl::GetEntriesCompleted

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::DoGetEntriesCompletedL(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOpen;  // EDBReading -> EDBOpen

    if( !iNeedsUpdate )

    {

        RemoveExpiredEntries();

        if( HasEventsForTodayL() )

        {

            SetTimerForNextExpiringEventL();

            NotifyObserverAndCloseDB();

        }

        else

        {

            iFetchState = EFetchFuture;

            StateMachine();

        }

    }

    else

    {

        StateMachine();

    }

    TRACE_EXIT_POINT;

}

void CAIAgendaPluginEngineImpl::GetFutureData(void)

    {

    TRACE_ENTRY_POINT;

    TRAPD(err, DoGetFutureDataL());

    if(err != KErrNone)

        {

        CloseCalendarEngine();

        }

    TRACE_EXIT_POINT;    

    }

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

// CAIAgendaPluginEngineImpl::GetFutureData

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::DoGetFutureDataL(void)

{

    TRACE_ENTRY_POINT;

    TTime tomorrow;

    tomorrow.HomeTime();

    tomorrow += TTimeIntervalDays( 1 );

    const TInt daysTosearch( 7 );

    iCalendarEngine->GetEventForNextSevenDaysL( *this, tomorrow, daysTosearch, iInstanceArray );  // TRAPPED!

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::GetEntriesCompleted

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::GetFutureEventCompleted(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOpen;  // EDBReading -> EDBOpen

    if( !iNeedsUpdate )

    {

        NotifyObserverAndCloseDB();

    }

    else

    {

        StateMachine();

    }

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::GetTodosCompleted

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::GetTodosCompleted(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOpen;  // EDBReading -> EDBOpen

    if( !iNeedsUpdate )

    {

        NotifyObserverAndCloseDB();

    }

    else

    {

        StateMachine();

    }

    TRACE_EXIT_POINT;

}

void CAIAgendaPluginEngineImpl::GetCalendarDataCompleted(void)

    {

    TRACE_ENTRY_POINT;

    TRAPD(err, DoGetCalendarDataCompletedL());

    if(err != KErrNone)

        {

        CloseCalendarEngine();

        }

    TRACE_EXIT_POINT;    

    }

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

// CAIAgendaPluginEngineImpl::GetCalendarDataCompleted

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::DoGetCalendarDataCompletedL(void)

{

    TRACE_ENTRY_POINT;

    iDBState = EDBOpen;  // EDBReading -> EDBOpen

    if( !iNeedsUpdate )

    {

        RemoveExpiredEntries();

        SetTimerForNextExpiringEventL();

        NotifyObserverAndCloseDB();

    }

    else

    {

        StateMachine();

    }

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::HandleError

// ?implementation_description

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

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

//

void CAIAgendaPluginEngineImpl::HandleError(TInt aError)

{

    TRACE_ENTRY_POINT;

    // ignore engine cancellation if we're already offline...

    if( aError != KErrCancel && iDBState != EDBOffline )

    {

        // reset the state machine (no notification to the client)

        CloseCalendarEngine();

        // Just to make sure the UI gets updated after an error

        iExpirationTimer->Cancel();

        iRefreshTimer->Cancel();

        iRefreshCounter = 0;

        const TTimeIntervalMicroSeconds32 oneMinute( 60 * 1000000 );

        iRefreshTimer->After( oneMinute );  // refresh after one minute

    }

    TRACE_EXIT_POINT;

}

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

// CAIAgendaPluginEngineImpl::NotifyObserverAndCloseDB

// ?implementation_description

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