/*
* 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 {
if(noException) {
Logger.info(logName + "Dispatcher thread exiting normally");
} else {
Logger.error(logName + "Dispatcher thread exiting abnormally");
}
if(terminatedNotification != null) {
terminatedNotification.run();
terminatedNotification = null;
}
}
}
}
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) {
synchronized(wakeLock) {
wake();
terminatedNotification = runnable;
terminated = true;
}
}
/*
* 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);
}
}