/*

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

*

*/

package javax.microedition.lcdui;

import org.eclipse.swt.widgets.Widget;

/*

 * Event dispatcher singleton class. Takes care of dispatching the UI callbacks

 * to the MIDlet in a dedicated dispatcher thread. Owns and encapsulates an

 * event queue of callback events.

 */

final class EventDispatcher

{

    private static EventDispatcher singleton;

    private static EventQueue eventQueue;

    private static Thread dispatcherThread;

    private static boolean terminated;

    private static Object wakeLock;

    private static Object callbackLock;

    private static boolean pendingWake;

    private static Runnable terminatedNotification;

    private final static String logName = "LCDUI event dispatcher: ";

    /*

     * LCDUI-internal event class for callback events.

     */

    static final class LCDUIEvent

    {

        /*

         * High bits of the event event type identifier are used to group the

         * events that are handled the same way in the Event Dispatcher.

         */

        static final int CANVASBIT = 0x80000000;

        static final int CUSTOMITEMBIT = 0x40000000;

        static final int DISPLAYABLEBIT = 0x20000000;

        static final int EVENTTYPEMASK = CANVASBIT|CUSTOMITEMBIT|DISPLAYABLEBIT;

        /*

         * Event type identifiers.

         */

        static final int CANVAS_HIDENOTIFY = 1|CANVASBIT;

        static final int CANVAS_KEYPRESSED = 2|CANVASBIT;

        static final int CANVAS_KEYREPEATED = 3|CANVASBIT;

        static final int CANVAS_KEYRELEASED = 4|CANVASBIT;

        static final int CANVAS_PAINT_NATIVE_REQUEST = 5|CANVASBIT;

        static final int CANVAS_PAINT_MIDLET_REQUEST = 6|CANVASBIT;

        static final int CANVAS_POINTERDRAGGED = 7|CANVASBIT;

        static final int CANVAS_POINTERPRESSED = 8|CANVASBIT;

        static final int CANVAS_POINTERRELEASED = 9|CANVASBIT;

        static final int CANVAS_SHOWNOTIFY = 10|CANVASBIT;

        static final int DISPLAYABLE_SIZECHANGED = 11|DISPLAYABLEBIT;

        static final int DISPLAYABLE_COMMANDACTION = 12|DISPLAYABLEBIT;

        static final int CUSTOMITEM_HIDENOTIFY = 13|CUSTOMITEMBIT;

        static final int CUSTOMITEM_KEYPRESSED = 14|CUSTOMITEMBIT;

        static final int CUSTOMITEM_KEYREPEATED = 15|CUSTOMITEMBIT;

        static final int CUSTOMITEM_KEYRELEASED = 16|CUSTOMITEMBIT;

        static final int CUSTOMITEM_PAINT_NATIVE_REQUEST = 17|CUSTOMITEMBIT;

        static final int CUSTOMITEM_PAINT_MIDLET_REQUEST = 18|CUSTOMITEMBIT;

        static final int CUSTOMITEM_POINTERDRAGGED = 19|CUSTOMITEMBIT;

        static final int CUSTOMITEM_POINTERPRESSED = 20|CUSTOMITEMBIT;

        static final int CUSTOMITEM_POINTERRELEASED = 21|CUSTOMITEMBIT;

        static final int CUSTOMITEM_SHOWNOTIFY = 22|CUSTOMITEMBIT;

        static final int CUSTOMITEM_SIZECHANGED = 23|CUSTOMITEMBIT;

        static final int CUSTOMITEM_TRAVERSE = 24|CUSTOMITEMBIT;

        static final int CUSTOMITEM_TRAVERSEOUT = 25|CUSTOMITEMBIT;

        static final int ITEM_COMMANDACTION = 26;

        static final int ITEMSTATELISTENER_ITEMSTATECHANGED = 27;

        static final int RUNNABLE_CALLSERIALLY = 28;

        /*

         * Event parameters.

         */

        int type;

        int x;

        int y;

        int width;

        int height;

        int keyCode;

        Runnable runnable;

        Command command;

        CommandListener commandListener;

        ItemCommandListener itemCommandListener;

        Item item;

        /*

         * Handler object. The object that the LCDUIEvent will be passed to

         * when the event is dispatched. Based on the event type it's known

         * what type of an object it must be. The handler object will

         * implement how to do the actual callback.

         */

        Object handlerObject;

        /*

         * The associated eSWT widget. Used to store the eSWT widget which

         * the original eSWT event was for. E.g. in Form the CustomItem's

         * widget may change while the event is in the queue.

         */

        Widget widget;

        /*

         * Used by EventQueue.

         */

        LCDUIEvent next;

        private LCDUIEvent()

        {

        }

    }

    /*

     * The event loop executed in a dedicated dispatcher thread. Events are

     * popped from the queue and dispatched oldest first until there are no

     * more events. Then the thread sleeps until new events are posted or

     * termination is requested. Any exceptions thrown from the event handlers

     * are let through to the runtime which should lead into termination of

     * all threads in the process.

     */

    private static class EventLoop implements Runnable

    {

        private boolean noException;

        public void run()

        {

            try

            {

                Logger.info(logName + "Dispatcher thread started");

                while(true)

                {

                    LCDUIEvent event;

                    do

                    {

                        synchronized(wakeLock)

                        {

                            if(terminated)

                            {

                                cleanup();

                                noException = true;

                                return;

                            }

                            event = eventQueue.pop();

                            pendingWake = false;

                        }

                        if(event != null)

                        {

                            synchronized(callbackLock)

                            {

                                // No callbacks are sent if already terminating

                                if(!terminated)

                                {

                                    handleEvent(event);

                                }

                            }

                        }

                    }

                    while(event != null);

                    // No more events

                    waitForWake();

                }

            }

            finally

            {

                {

                }

            }

        }

    }

    private EventDispatcher()

    {

        wakeLock = new Object();

        callbackLock = new Object();

        eventQueue = new EventQueue();

        dispatcherThread = new Thread(new EventLoop(), this.toString());

        dispatcherThread.start();

    }

    /*

     * Cleanup that is done when closing down in a controlled way.

     */

    private static void cleanup()

    {

        eventQueue = null;

        dispatcherThread = null;

    }

    /*

     * Synchronized to the EventDispatcher class to synchronize with multiple

     * clients requesting the instance concurrently.

     */

    static synchronized EventDispatcher instance()

    {

        if(singleton == null)

        {

            singleton = new EventDispatcher();

        }

        return singleton;

    }

    /*

     * LCDUIEvent factory.

     */

    LCDUIEvent newEvent(int type, Object handlerObject)

    {

        LCDUIEvent event = new LCDUIEvent();

        event.type = type;

        event.handlerObject = handlerObject;

        return event;

    }

    /*

     * UI thread and the application threads call to add an event to the queue.

     * Synchronized to the EventDispatcher instance to synchronize with queries about

     * the queue content.

     */

    synchronized void postEvent(LCDUIEvent event)

    {

        // New events ignored after terminate() has been called.

        if(terminated)

        {

            return;

        }

        eventQueue.push(event);

        wake();

    }

    /*

     * Asynchronously terminates the event dispatcher. If it's currently

     * executing a callback it will finish it but not execute any callbacks

     * after it. Events possibly remaining in the queue are discarded. The

     * method is synchronized to the EventDispatcher instance to synchronize

     * with queue content manipulation and query operations.

     *

     * @param runnable Called when dispatcher is out of the final callback and

     * is going to die.

     */

    synchronized void terminate(Runnable runnable)

    {

        {

        }

    }

    /*

     * Canvas.serviceRepaints support is implemented in EventDispatcher so that

     * it's possible to synchronize properly with termination and other

     * callbacks without exposing the event dispatcher's internal

     * implementation details to other classes. This method must be called

     * directly in the application thread calling Canvas.serviceRepaints(). It

     * can be either the dispatcher thread or any application thread. Never

     * the UI thread.

     */

    void serviceRepaints(Canvas canvas)

    {

        // Synchronizing to callbackLock guarantees that dispatcher thread is

        // not in a callback and is not going to make a callback until the lock

        // is freed from here. If this is the dispatcher thread then it already

        // holds the lock.

        synchronized(callbackLock)

        {

            // Synchronized to the EventDispatcher instance to synchronize with

            // terminate() calls. Lock is freed before the callback so that

            // it's possible to complete a terminate() call during the

            // callback. Event loop is going to check after acquiring the

            // callbackLock if terminate() was called during this callback.

            synchronized(this)

            {

                if(terminated)

                {

                    return;

                }

            }

            // Canvas.paint() is called back directly in the thread that called

            // serviceRepaints(). Event is not really needed but is created so

            // that the same APIs can be used.

            LCDUIEvent event = newEvent(LCDUIEvent.CANVAS_PAINT_MIDLET_REQUEST, canvas);

            event.widget = canvas.getContentComp();

            canvas.doCallback(event);

        }

    }

    private static void wake()

    {

        synchronized(wakeLock)

        {

            wakeLock.notify();

            pendingWake = true;

        }

    }

    private static void waitForWake()

    {

        try

        {

            synchronized(wakeLock)

            {

                // If there has been a call to wake() then one more iteration

                // must be executed before entering wait().

                if(!pendingWake)

                {

                    wakeLock.wait();

                }

            }

        }

        catch(InterruptedException interruptedException)

        {

        }

    }

    private static void handleEvent(LCDUIEvent event)

    {

        switch(event.type & LCDUIEvent.EVENTTYPEMASK)

        {

        case LCDUIEvent.CANVASBIT:

            handleCanvasEvent(event);

            break;

        case LCDUIEvent.CUSTOMITEMBIT:

            handleCustomItemEvent(event);

            break;

        case LCDUIEvent.DISPLAYABLEBIT:

            handleDisplayableEvent(event);

            break;

        default:

            handleOtherEvent(event);

            break;

        }

        // When returning from here all the references to the event have been

        // lost and the objects referenced by the event can be gc'd. No need

        // to set the fields to null.

    }

    private static void handleCanvasEvent(LCDUIEvent event)

    {

        Canvas canvas = (Canvas)event.handlerObject;

        canvas.doCallback(event);

    }

    private static void handleCustomItemEvent(LCDUIEvent event)

    {

        Form form = (Form)event.handlerObject;

        form.doCallback(event);

    }

    private static void handleDisplayableEvent(LCDUIEvent event)

    {

        Displayable displayable = (Displayable)event.handlerObject;

        displayable.doCallback(event);

    }

    private static void handleOtherEvent(LCDUIEvent event)

    {

        switch(event.type)

        {

        case LCDUIEvent.RUNNABLE_CALLSERIALLY:

            handleCallSerially(event);

            break;

        case LCDUIEvent.ITEM_COMMANDACTION:

            handleItemCommandListenerCommandAction(event);

            break;

        default:

            Logger.error(logName + "Unknown event type: " + event.type);

            break;

        }

    }

    private static void handleCallSerially(LCDUIEvent event)

    {

        Display display = (Display)event.handlerObject;

        display.doCallback(event);

    }

    private static void handleItemCommandListenerCommandAction(LCDUIEvent event)

    {

        Item item = (Item)event.handlerObject;

        item.doCallback(event);

    }

}