/*

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

*

*/

#include "AspDbNotifier.h"

#include "AspDebug.h"

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

/******************************************************************************

 * class TAspDbEvent

 ******************************************************************************/

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

// TAspDbEvent::TAspDbEvent

//

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

//

TAspDbEvent::TAspDbEvent(TInt aType)

 : iType(aType), iProfileId(KErrNotFound), iError(KErrNone)

	 {

	 }

/******************************************************************************

 * class CAspDbNotifier

 ******************************************************************************/

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

// CAspDbNotifier::CAspDbNotifier

//

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

//

CAspDbNotifier::CAspDbNotifier(const TAspParam& aParam, MAspDbEventHandler* aHandler)

 : iSyncSession(aParam.iSyncSession), iHandler(aHandler)

 	{

 	iSessionEventRequested = EFalse;

 	}

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

// CAspDbNotifier::NewL

//

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

//

CAspDbNotifier* CAspDbNotifier::NewL(const TAspParam& aParam, MAspDbEventHandler* aHandler)

	{

	CAspDbNotifier* self = new (ELeave) CAspDbNotifier(aParam, aHandler);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CAspDbNotifier::ConstructL

//

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

//

void CAspDbNotifier::ConstructL()

	{

    FLOG( _L("CAspDbNotifier::ConstructL START") );

	iActiveCaller = CAspActiveCaller::NewL(this);

    FLOG( _L("CAspDbNotifier::ConstructL END") );

	}

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

// Destructor

//

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

//

CAspDbNotifier::~CAspDbNotifier()

	{		

    FLOG( _L("CAspDbNotifier::~CAspDbNotifier START") );

	delete iActiveCaller;

	iList.Close();

    if (iSessionEventRequested)

    	{

    	Session().CancelEvent();

    	}

    if (iDestroyedPtr)

        {

        *iDestroyedPtr = ETrue;

        iDestroyedPtr = NULL;

        }

    FLOG( _L("CAspDbNotifier::~CAspDbNotifier END") );

	}

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

// CAspDbNotifier::RequestL

//

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

//

void CAspDbNotifier::RequestL()

	{

	if (!iSessionEventRequested)

		{

		Session().RequestEventL(*this);  // request MSyncMLEventObserver events

		iSessionEventRequested = ETrue;

		}

	}

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

// CAspDbNotifier::OnSyncMLSessionEvent (from MSyncMLEventObserver)

//

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

//

void CAspDbNotifier::OnSyncMLSessionEvent(TEvent aEvent, TInt aIdentifier, TInt aError, TInt aAdditionalData)

	{

    FLOG( _L("CAspDbNotifier::OnSyncMLSessionEvent START") );

#ifdef _DEBUG

    LogSessionEvent(aEvent, aIdentifier, aError);

#endif

    TRAP_IGNORE(HandleSessionEventL(aEvent, aIdentifier, aError, aAdditionalData));

    FLOG( _L("CAspDbNotifier::OnSyncMLSessionEvent END") );

    }

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

// CAspDbNotifier::HandleSessionEventL

//

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

//

void CAspDbNotifier::HandleSessionEventL(TEvent aEvent, TInt aIdentifier, TInt aError, TInt /*aAdditionalData*/)

	{

	if (aEvent != MSyncMLEventObserver::EProfileCreated &&

	    aEvent != MSyncMLEventObserver::EProfileChanged &&

	    aEvent != MSyncMLEventObserver::EProfileDeleted &&

	    aEvent != MSyncMLEventObserver::EServerTerminated)

		{

		return; // setting dialog does not need this event

		}

	TAspDbEvent event(aEvent);

    event.iError = aError;

	if (aEvent == MSyncMLEventObserver::EProfileCreated || 

	    aEvent == MSyncMLEventObserver::EProfileChanged ||

	    aEvent == MSyncMLEventObserver::EProfileDeleted )

		{

		event.iProfileId = aIdentifier;

		}

	else

		{

		event.iProfileId = KErrNotFound;

		}

	iList.AppendL (event);

	CallObserverWithDelay();

	RequestL();

    }

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

// CAspDbNotifier::CreateUpdateEventL

//

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

//

void CAspDbNotifier::CreateUpdateEventL(TInt aIdentifier, TInt aError)

	{

	TAspDbEvent event(MSyncMLEventObserver::EProfileChanged);

	event.iProfileId = aIdentifier;

    event.iError = aError;

	iList.Reset();

	iList.AppendL (event);

	CallObserverWithDelay();

	RequestL();

    }

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

// CAspDbNotifier::CheckUpdateEventL

//

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

//

void CAspDbNotifier::CheckUpdateEventL()

	{

	if (iList.Count() == 0)

		{

		return; // no database events - no need to update UI

		}

	CallObserverWithDelay();

	RequestL();

    }

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

// CAspDbNotifier::SetDisabled

//

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

//

void CAspDbNotifier::SetDisabled(TBool aDisable)

	{

    iDisabled = aDisable;

	}

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

// CAspDbNotifier::Reset

//

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

//

void CAspDbNotifier::Reset()

	{

    iDisabled = EFalse;

	iList.Reset();

	}

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

// CAspDbNotifier::EventCount

//

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

//

TInt CAspDbNotifier::EventCount()

	{

	return iList.Count();

	}

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

// CAspDbNotifier::Event

//

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

//

TAspDbEvent CAspDbNotifier::Event(TInt aIndex)

	{

	__ASSERT_DEBUG(aIndex>=0 && aIndex<iList.Count(), TUtil::Panic(KErrGeneral));

	return iList[aIndex];

	}

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

// CAspDbNotifier::Session

// 

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

//

RSyncMLSession& CAspDbNotifier::Session()

	{

	__ASSERT_DEBUG(iSyncSession, TUtil::Panic(KErrGeneral));

	return *iSyncSession;

	}

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

// CAspDbNotifier::CallObserverWithDelay

//

// This is needed to avoid unnecessary observer calls (eg. in case 10 events are

// reported in short time only last is reported to observer). 

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

//

void CAspDbNotifier::CallObserverWithDelay(void)

	{

    FLOG( _L("CAspDbNotifier::CallObserverWithDelay START") );

    iActiveCaller->Cancel();

	iActiveCaller->Start(KErrNone, KListBoxUpdateDelay);

    FLOG( _L("CAspDbNotifier::CallObserverWithDelay END") );

	}

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

// CAspDbNotifier::CallObserver

//

// this function investigates received events from last observer call

// and calls observer to inform UI what to do. 

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

//

void CAspDbNotifier::CallObserver()

	{

    FLOG( _L("CAspDbNotifier::CallObserver START") );

	TAspDbEvent event(EUpdateAll);

	//

	// check for critical error

	//

	if (FindCloseEvent() != KErrNotFound)

		{

		event.iType = EClose;

		TRAP_IGNORE(iHandler->HandleDbEventL(event));

		FLOG( _L("CAspDbNotifier::CallObserver END") );

		return; // some database problem - UI should close

		}

	//

	// check if only one profile has changed

	//

	TInt index = FindSingleProfileEvent();

	if (index != KErrNotFound)

		{

		TAspDbEvent& e = iList[index];

        event.iProfileId = e.iProfileId; 

        event.iType = EUpdate;

        if (ProfileDeleted())

			{

			event.iType = EDelete;

			}

		TRAP_IGNORE(iHandler->HandleDbEventL(event));

        FLOG( _L("CAspDbNotifier::CallObserver END") );

        return;

		}

	//

	// check if 2 or more profiles have changed

	//

	if (FindProfileEvent() != KErrNotFound)

		{

	    event.iType = EUpdateAll;

    	TRAP_IGNORE(iHandler->HandleDbEventL(event));

        FLOG( _L("CAspDbNotifier::CallObserver END") );

        return;

    	}

    FLOG( _L("CAspDbNotifier::CallObserver END") );

	}

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

// CAspDbNotifier::FindCloseEvent

//

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

//

TInt CAspDbNotifier::FindCloseEvent()

	{

	TInt count = iList.Count();

	for (TInt i=0; i<count; i++)

		{

		TAspDbEvent& event = iList[i];

		if (event.iType == MSyncMLEventObserver::EServerTerminated)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CAspDbNotifier::FindProfileEvent

//

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

//

TInt CAspDbNotifier::FindProfileEvent()

	{

	TInt count = iList.Count();

    for (TInt i=0; i<count; i++)

		{

		TAspDbEvent& event = iList[i];

		if (event.iProfileId != KErrNotFound)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CAspDbNotifier::FindSingleProfileEvent

//

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

//

TInt CAspDbNotifier::FindSingleProfileEvent()

	{

	TInt count = iList.Count();

	// find out whether list contains update events for one profile only

	for (TInt i=0; i<count; i++)

		{

		TAspDbEvent& event = iList[i];

		if (event.iProfileId != KErrNotFound && IsUniqueProfileId(event.iProfileId))

			{

			return i;

        	}

		}

	return KErrNotFound;

	}

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

// CAspDbNotifier::ProfileDeleted

//

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

//

TBool CAspDbNotifier::ProfileDeleted()

	{

	TInt count = iList.Count();

	for (TInt i=0; i<count; i++)

		{

		TAspDbEvent& event = iList[i];

		if (event.iType == MSyncMLEventObserver::EProfileDeleted)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

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

// CAspDbNotifier::IsUniqueProfileId

//

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

//

TBool CAspDbNotifier::IsUniqueProfileId(TInt aId)

	{

	TInt count = iList.Count();

    for (TInt i=0; i<count; i++)

		{

		TAspDbEvent& event = iList[i];

		if (event.iProfileId != KErrNotFound && event.iProfileId != aId)

			{

			return EFalse;

			}

		}

	return ETrue;

	}

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

// CAspDbNotifier::HandleActiveCallL (from MAspActiveCallerObserver)

//

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

//

void CAspDbNotifier::HandleActiveCallL(TInt /*aCallId*/)

	{

    FLOG( _L("CAspDbNotifier::HandleActiveCallL START") );

	if (iDisabled)

		{

		FLOG( _L("CAspDbNotifier::HandleActiveCallL: event observing disabled") );

		FLOG( _L("CAspDbNotifier::HandleActiveCallL END") );

		return;  // UI has disabled notifications

		}

    TBool destroyed(EFalse);

    iDestroyedPtr = &destroyed;

	CallObserver();

    if (!destroyed)   // destructor sets this to ETrue

        {

    	Reset();

    	iDestroyedPtr = NULL;

        }

    FLOG( _L("CAspDbNotifier::HandleActiveCallL END") );

	}

#ifdef _DEBUG

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

// LogSessionEvent

//

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

//

void CAspDbNotifier::LogSessionEvent(TEvent& aEvent, TInt aIdentifier, TInt aError)

	{

    TBuf<KBufSize> eventStr;

    GetSyncEventText(eventStr, aEvent);

	if (aError == KErrNone)

		{

		FTRACE( RDebug::Print(_L("event='%S' id=%d"), &eventStr, aIdentifier) );

		}

	else

		{

		FTRACE( RDebug::Print(_L("### event='%S' id=%d err=%d ###"), &eventStr, aIdentifier, aError) );

		}