Java Reference
In-Depth Information
object. The base class of all LCDUI widget peers is an interface called
MMIDComponent
, which provides some generic methods common to
all native LCDUI peers. Most of the other adaptor interfaces build on
MMIDComponent
and typically map to the LCDUI classes.
For example, when a MIDlet creates a UI component, such as an
Alert
, a native method in the core framework calls
MMIDCompo-
nentFactory::CreateAlertL()
, which creates a concrete peer
from the widgets DLL. This returns an
MMIDAlert
pointer which is
stored in the Java object. When the user invokes a method, such as
Alert.setString()
, the handle can then be passed into native
method calls, where it is converted back into a pointer to the native
MMIDAlert
and the required native operation is performed in the wid-
gets DLL. The same pattern is repeated for other LCDUI widgets (i.e. the
peers for Command and List in LCDUI are the native
MMIDCommand
and
MMIDList
, respectively). The implementation class must satisfy
the adaptor interface contract but internally may do so using a single
CCoeControl
or a set of
CCoeControls
as required and as applicable
in each UI platform.
The graphics-rendering module can be replaced or modified if desired
by the licensee, but typically is left unchanged since graphics-rendering
operations do not impose any dependency on the UI platform and
use common and generic Symbian OS rendering APIs. For example,
when
Canvas.paint()
is called, the user code draws on the passed
Graphics
object by invoking the rendering methods (e.g.,
Graph-
ics.drawRect(int x, int y, int width, int height)
). All
the information required to perform the rendering is serialized and
packed as buffered commands into an efficient command buffer which
is then flushed to a native buffer to do native processing. In the native
layer, the execution moves from the core framework to the graphics DLL,
where the commands processor of the
MMIDComponent
executes all the
buffered operations using the native Symbian OS rendering primitives
(e.g., Graphic subsystem Device, Context, Bitmaps, etc.).
The Game API package provides a series of classes that enable the
development of rich gaming content for wireless devices and minimizes
the amount of work done in Java applications. The API uses the standard
low-level graphics classes from MIDP (
Graphics
,
Image
, etc.) so that
the high-level Game API classes can be used in conjunction with graphics
primitives.
In Symbian OS v9.1, the Java layer in the core framework and the
graphics DLL have been substantially redesigned to support the high
performance required by visually rich Java applications such as games.
The native support for the gaming API in versions of Symbian OS before
v9.1 has been deprecated and the
javax.microedtion.lcdui.game
package was reimplemented in pure Java, with much improved perfor-
mance and additional collision detection support.
