/*
* 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: class to handle event notification to subscribers.
*
*
*/


// INCLUDE FILES
#include "EPos_CPosLmDbManEventHandler.h"
#include "EPos_LandmarksServerPanics.h"
#include "EPos_PosLmServerCommon.h"
#include "EPos_LmServerGlobal.h"

// CONSTANTS
const TInt KEventQueueMaxSize = 5;
const TInt KArrayGranularity = 6;

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

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::CPosLmDbManEventHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPosLmDbManEventHandler::CPosLmDbManEventHandler()
    {
    }

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::ConstructL()
    {
    iUriArray = new (ELeave) CDesCArrayFlat(KArrayGranularity);
    }

// Two-phased constructor.
CPosLmDbManEventHandler* CPosLmDbManEventHandler::NewL()
    {
    CPosLmDbManEventHandler* self = new (ELeave) CPosLmDbManEventHandler();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
CPosLmDbManEventHandler::~CPosLmDbManEventHandler()
    {
    CompleteAnyOutStandingRequest(KErrCancel);
    iEventQueue.Close();
    delete iUriArray;
    delete iLastUri;
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::ServerUriFromLastEvent
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::ServerUriFromLastEvent(
    const RMessagePtr2& aMessage)
    {
    if (!iLastUri || iLastUri->Length() == 0)
        {
        LmServerGlobal::Complete(aMessage, KErrNotFound);
        }
    else
        {
        LmServerGlobal::Write(aMessage, KPosLmServerUriArg, *iLastUri);
        LmServerGlobal::Complete(aMessage, KErrNone);
        }
    delete iLastUri;
    iLastUri = NULL;
    }

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::HandleRequestForEventL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::HandleRequestForEventL(
    const RMessagePtr2& aMessage)
    {
    // check that descriptor parameters are OK so that server
    // won't panic when trying to write.
    TPckgBuf<TPosLmDatabaseEvent> event;
    TPckgBuf<TInt> length;
    TInt eventMaxLength = aMessage.GetDesMaxLength(KPosLmServerDbManEventArg);
    TInt lengthMaxLength = aMessage.GetDesMaxLength(KPosLmServerUriLengthArg);
    if (eventMaxLength  != event.Length() ||
        lengthMaxLength != length.Length())
        {
        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);
        return;
        }

    if (iEventQueue.Count() > 0)
        {
        // Send the first event in the queue to the client.
        WriteEventAndComplete(aMessage);
        }
    else
         {
        // No events in queue. Put the message on hold.
        if (!iHoldingMessage.IsNull())
            {
            PanicClient(aMessage,
                EPosEventNotifierAlreadyHasOutstandingRequest);
            }
        else
            {
            iHoldingMessage = aMessage;
            }
        }
    }

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::HandleIncomingEventL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::HandleIncomingEventL(
    TPosLmDatabaseEvent aEvent,
    const TDesC& aUri)
    {
    if (iEventQueue.Count() == KEventQueueMaxSize)
        {
        iEventQueue.Reset();
        iUriArray->Reset();
        aEvent.iEventType = EPosLmDbUnknownEvent;
        AddToEventQueueL(aEvent, KNullDesC);
        }
    else
        {
        AddToEventQueueL(aEvent, aUri);
        }

    if (!iHoldingMessage.IsNull())
        {
        // There is a message on hold. Send response immediately.
        WriteEventAndComplete(iHoldingMessage);
        }
    }

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::CompleteAnyOutStandingRequest
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::CompleteAnyOutStandingRequest(
    TInt aError)
    {
    LmServerGlobal::Complete(iHoldingMessage, aError);
    }

// -----------------------------------------------------------------------------
// CPosLmDbManEventHandler::WriteEventAndComplete
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::WriteEventAndComplete(
    const RMessagePtr2& aMessage)
    {
    HBufC* tmpBuf = iUriArray->MdcaPoint(0).Alloc();
    if (!tmpBuf)
        {
        LmServerGlobal::Complete(aMessage, KErrNoMemory);
        }
    else
        {
        iUriArray->Delete(0);
        iUriArray->Compress();
        delete iLastUri;
        iLastUri = tmpBuf;

        TPckgBuf<TPosLmDatabaseEvent> event(iEventQueue[0]);
        TPckgBuf<TInt> length(iLastUri->Length());
        if (LmServerGlobal::Write(aMessage, KPosLmServerEventArg, event)
            == KErrNone &&
            LmServerGlobal::Write(aMessage, KPosLmServerUriLengthArg, length)
            == KErrNone)
            {
            LmServerGlobal::Complete(aMessage, KErrNone);
            }
        iEventQueue.Remove(0);
        }
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::AddToEventQueueL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmDbManEventHandler::AddToEventQueueL(
    TPosLmDatabaseEvent aEvent,
    const TDesC& aUri)
    {
    TInt index = KErrNotFound;
    if (aEvent.iEventType == EPosLmDbNewDefaultDbLocation)
        {
        index = iEventQueue.Find(aEvent);
        }

    iUriArray->AppendL(aUri);
    TInt err = iEventQueue.Append(aEvent);

    if (err != KErrNone)
        {
        iUriArray->Delete(iUriArray->Count() - 1);
        User::Leave(err);
        }
    else if (index != KErrNotFound)
        {
        iEventQueue.Remove(index);
        iUriArray->Delete(index);
        }
    }

// End of File