/*
* Copyright (c) 2009 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 a way of sending asynchronous
*                requests from mmapi (JSR-135) to lcdui
*
*/


// Using CCoeControl
#include <coecntrl.h>
// Using MUiEventConsumer
#include <reflcdui.h>
// Using debug macros.
#include <j2me/jdebug.h>

#include "CMIDToLcduiObserver.h"


// Event queue size
const TInt KMaxQueueSlots = 30;


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::CMIDToLcduiObserver
// Constructor.
// ---------------------------------------------------------------------------
//
CMIDToLcduiObserver::CMIDToLcduiObserver():
        CActive(EPriorityStandard)
{
    // Create mutex
    iEventQueue.CreateLocal(KMaxQueueSlots);

    // Install self to Active scheduler
    CActiveScheduler::Add(this);

    iEventQueue.NotifyDataAvailable(iStatus);
    SetActive();
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::~CMIDToLcduiObserver
// Destructor.
// ---------------------------------------------------------------------------
//
CMIDToLcduiObserver::~CMIDToLcduiObserver()
{
    // Unregister all controls
    iRegisteredControls.Reset();

    // Cancel the active object
    Cancel();

    // Close the mutex
    iEventQueue.Close();
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::RegisterControl
// Allows a control to be used during event processing.
// ---------------------------------------------------------------------------
//
#ifdef RD_JAVA_NGA_ENABLED
void CMIDToLcduiObserver::RegisterControl(
    CCoeControl& aControl, MDirectContainer* /*aCallbackContainer*/)
#else
void CMIDToLcduiObserver::RegisterControl(CCoeControl& aControl)
#endif
{
    TInt index = iRegisteredControls.Find(&aControl);

    // Append the control only if it have not been added yet
    if (index == KErrNotFound)
    {
        if (iRegisteredControls.Append(&aControl) != KErrNone)
        {
            // Appending of control failed
            DEBUG("CMIDToLcduiObserver::RegisterControl - Append failed");
        }
    }
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::UnregisterControl
// Removes a control from the list of controls allowed
// to be used in event processing.
// Events which works with this control will be ignored.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::UnregisterControl(CCoeControl& aControl)
{
    TInt index = iRegisteredControls.Find(&aControl);

    if (index != KErrNotFound)
    {
        iRegisteredControls.Remove(index);
    }
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::FlushControl
// Asynchronously flushes the control's graphics content on screen.
// The call may origin in other than lcdui thread.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::FlushControl(
    CCoeControl& aControl,
    const TRect& aRect)
{
    // Can run in non lcdui thread

    // Prepare event data
    TToLcduiEventData data;
    data.iType = EFlushEvent;
    data.iRect = aRect;
    data.iControl = &aControl;

    // Add event to the queue
    iEventQueue.Send(data);
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::InvokeDSAResourcesCallback
// Asynchronously invokes aConsumer->MdcDSAResourcesCallback
// from lcdui thread.
// The call may origin in other than lcdui thread.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::InvokeDSAResourcesCallback(
    CCoeControl& aControl,
    MUiEventConsumer& aConsumer)
{
    // Can run in non lcdui thread

    // Prepare event data
    TToLcduiEventData data;
    data.iType = EDSAResourcesCallbackEvent;
    data.iControl = &aControl;
    data.iConsumer = (void*)&aConsumer;

    // Add event to the queue
    iEventQueue.Send(data);
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::InvokeUICallback
// Asynchronously invokes aConsumer->MdcUICallback
// from lcdui thread.
// The call may origin in other than lcdui thread.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::InvokeUICallback(
    MUiEventConsumer& aConsumer,
    TInt aCallbackId)
{
    // Can run in non lcdui thread

    // Prepare event data
    TToLcduiEventData data;
    data.iType = EUICallbackEvent;
    data.iConsumer = (void*)&aConsumer;
    data.iId = aCallbackId;

    // Add event to the queue
    iEventQueue.Send(data);
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::RunL
// Handles an active object’s request completion event.
// Processes the first available event in queue.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::RunL()
{
    TToLcduiEventData data;

    // Get the event
    iEventQueue.Receive(data);

    // Process the event
    switch (data.iType)
    {
    case EFlushEvent:
        DoFlushControl(data.iControl, data.iRect);
        break;
    case EDSAResourcesCallbackEvent:
        DoInvokeDSAResourcesCallback(data.iControl, (MUiEventConsumer*)data.iConsumer);
        break;
    case EUICallbackEvent:
        DoInvokeUICallback((MUiEventConsumer*)data.iConsumer, data.iId);
        break;
    case ELcduiEvent:
        DoInvokeLcduiEvent((MMIDLcduiEventConsumer*)data.iConsumer,data.iId);
        break;
#ifdef RD_JAVA_NGA_ENABLED
    case ENotifyContentAdded:
        DoInvokeNotifyContentAdded(data.iControl, data.iContainer);
        break;
#endif
    }

    iEventQueue.NotifyDataAvailable(iStatus);
    SetActive();
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::DoCancel
// Implements cancellation of an outstanding request.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::DoCancel()
{
    iEventQueue.CancelDataAvailable();
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::DoFlushControl
// Processes the event invoked by FlushControl.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::DoFlushControl(
    CCoeControl* aControl,
    const TRect& aRect)
{
    TInt index = iRegisteredControls.Find(aControl);

    if (index != KErrNotFound)
    {
        TPoint relativePos =
            aControl->Position() - aControl->PositionRelativeToScreen();
        TRect rectToDraw = aRect;
        rectToDraw.Move(relativePos);
        aControl->DrawNow(rectToDraw);
    }
}


// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::DoInvokeDSAResourcesCallback
// Processes the event invoked by InvokeDSAResourcesCallback.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::DoInvokeDSAResourcesCallback(
    CCoeControl* aControl,
    MUiEventConsumer *aConsumer)
{
    TInt index = iRegisteredControls.Find(aControl);

    if (index != KErrNotFound)
    {
        RWsSession&      session = aControl->ControlEnv()->WsSession();
        CWsScreenDevice* device  = aControl->ControlEnv()->ScreenDevice();
        RDrawableWindow* window  = aControl->DrawableWindow();

        aConsumer->MdcDSAResourcesCallback(session, *device, *window);
    }
}

void CMIDToLcduiObserver::DoInvokeLcduiEvent(
    MMIDLcduiEventConsumer* aConsumer,
    TInt aCallbackId)
{
    if (aConsumer)
    {
        aConsumer->HandleLcduiEvent(aCallbackId);
    }
}

// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::DoInvokeUICallback
// Processes the event invoked by InvokeUICallback.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::DoInvokeUICallback(
    MUiEventConsumer *aConsumer,
    TInt aCallbackId)
{
    aConsumer->MdcUICallback(aCallbackId);
}


#ifdef RD_JAVA_NGA_ENABLED
// ---------------------------------------------------------------------------
// CMIDToLcduiObserver::DoInvokeNotifyContentAdded
// ---------------------------------------------------------------------------
void CMIDToLcduiObserver::DoInvokeNotifyContentAdded(
    CCoeControl* aControl,
    MDirectContainer *aContainer)
{
    TInt index = iRegisteredControls.Find(aControl);
    if (index != KErrNotFound)
    {
        aContainer->MdcNotifyContentAdded();
    }
}
#endif

// ---------------------------------------------------------------------------
// CSwtDcObserver::InvokeDcEvent
// Asynchronously sends an event into a consumer.
// The call may origin in other than eswt thread.
// ---------------------------------------------------------------------------
//
void CMIDToLcduiObserver::InvokeLcduiEvent(
    MMIDLcduiEventConsumer& aConsumer,
    TInt aCallbackId)
{
    // Can run in non lcdui thread

    // Prepare event data
    TToLcduiEventData data;
    data.iType = ELcduiEvent;
    data.iConsumer = (void*)&aConsumer;
    data.iId = aCallbackId;

    // Add event to the queue
    iEventQueue.Send(data);
}