Doug Abbott - Embedded Linux development using Eclipse

The JFace toolkit is built on top of the SWT and is a high-level GUI layer that addresses the needs of Eclipse itself. JFace provides components that create views and support events, control tasks using progress components, and manage UI resources such as fonts. Of course, the GUI requirements of Eclipse are common to many applications, which makes JFace useful outside the Eclipse environment.

eRCP implements a subset of the SWT called, not surprisingly, the embedded Standard Widget Toolkit (eSWT) that provides a set of controls, panels, and other widgets commonly used as building blocks of user interfaces in embedded devices Additionally, eSWT introduces a new component, mobile extensions, primarily targeted at the needs of mobile devices such as PDAs and smart phones.

The design of SWT emphasizes portability among operating systems by keeping the native code layer as small and simple as possible. That’s fine in desktop environments where there’s ample processor horsepower to compensate for the performance hit of platform-independent code. But in mobile devices, performance is a critical issue. So eSWT sacrifices portability to put more of the functionality in the native layer.

eSWT consists of three elements:

• Core

• Expanded

• Mobile extensions

Figure 7.17 illustrates where eSWT fits in the scheme of things.

Figure 7.17: eSWT UI toolkit architecture.

eRCP then is a collection of runtime libraries supporting a range of platforms that includes:

• Windows Mobile 2003/5/6

• WindowsCE 5.0 Professional

• Nokia series 80: Includes emulator

• Windows desktop: For testing

Unfortunately, there’s no Linux runtime, so in order to play around with eRCP, you’ll need a Windows Eclipse installation. Download the latest version of the Windows desktop runtime from the eRCP Download Page at http://www.eclipse.org/ercp/downloads-page.html. This is a zip file that creates its own directory. I suggest unzipping it in your Eclipse directory.

The eRCP package includes three fairly simple demos that are started from batch files. Try them out. Unfortunately, the demos don’t appear to include source code. There is an example [9] This particular example comes from a paper describing the embedded Rich Client Platform posted at IBM’s Developer Works, at http://www-128.ibm.com/developerworks/opensource/library/os-ecl-rcp/. Check it out. with source code in your EclipseSamples/directory in the form of a JAR file that you’ll need to import into Eclipse.

Click File→Import…, expand Plug-in Development and select Plug-ins and Fragments. This brings up the dialog in Figure 7.18. In the Import fromsection, uncheck The target platformand browse to your EclipseSamples/directory. In Import As, select Projects with source foldersand click Next. Only one plug-in will be found. Select that and Addit to the Plug-ins and Fragmentsto import list. Click Finish.

Figure 7.18: Import Plug-ins and Fragments dialog.

Back in the Project Development perspective you’ll find a new project in the Package Explorer view. Take a look at some of the Java files and open the manifest to get a feel for what’s going on.

However, before you can build and run the example, you must point PDE at the correct target environment. Select Window→Preferences→Plug-in Development→Target Platform. Browse to the eRCP/ directory under the eRCP installation directory. Back in the Manifest editor launch the application.

Plug-ins, written in Java, are the mechanism for extending the functionality of Eclipse. The Plug-in Development Environment (PDE), itself a collection of plug-ins, provides intuitive graphical tools to aid the process of plug-in development.

Eclipse defines some 200 extension points where the basic platform can be enhanced by plugging in extensions. The role of a plug-in, then, is to implement extensions.

Normal plug-ins execute as extensions of the Eclipse workbench. The Rich Client Platform (RCP) provides a mechanism that allows you to use the same plug-in development environment to build stand-alone Java applications that utilize Eclipse UI features. Another project, the embedded Rich Client Platform (eRCP), brings the same capability to embedded devices.

The next chapter looks at a couple of advanced features of Eclipse that are also of value to embedded developers, source code control using CVS, and software design modeling using UML.

There are countless books on Java programming. Here are a few that look interesting.

Block, Joshua. 2008. Effective Java . (2nd ed.) Prentice-Hall.

Eckel, Bruce. 2006. Thinking in Java . (4th ed.) Prentice Hall.

Horstmann, Cay S., and Gary Cornell. 2007. Core Java Volume 1 — Fundamentals . (8th ed.) Prentice Hall.

Horstmann, Cay S., and Gary Cornell. 2007. Core Java Volume 2 — Advanced Features . (8th ed.) Prentice Hall.

Sierra, Kathy, and Bert Bates. 2005. Head First Java . (2nd ed.) O’Reilly.

http://www.java.sun.com/ — This is Sun’s website for Java developers.

http://www.geocities.com/kollurihari/hari/programming.html/ — This is an interesting and very extensive website with tutorials on a wide range of software topics including Java. Nothing on Eclipse yet.

Here is a great starting point for writing plug-ins.

Clayberg, Eric and Dan Rubel, Eclipse: Building Commercial Quality Plug-ins, 2 nd edition, Addison-Wesley, 2006.

With a solid background in CDT, it’s time to turn our attention to some other tools in the Eclipse workshop that can aid software developers. Specifically, in this chapter we’ll look at source code control using CVS and software design modeling using UML.

UML (Unified Modeling Language) is a mechanism for expressing the constructs and relationships of complex systems, in particular software systems. More specifically, it is a graphical notation that can be used to describe the various models of a software system.

Some of the ways UML is useful include:

• Requirements capture

• Expressing system concepts as classes

• Understanding how objects interact with each other in specific scenarios

• Characterizing the life cycle of objects by identifying the various states to which an object can transition

• Organizing classes into packages and subsystems

• Depicting the deployment of components in a final system

The UML 2.x specifications [10] Version 2.0 was released by the Object Management Group (OMG) in 2003. define 13 types of diagrams that are split into three categories:

• Structural diagrams. Identify the objects in the model:

○ Class diagram

○ Component diagram

○ Composite structure diagram

○ Deployment diagram

○ Object diagram

○ Package diagram

• Behavior diagrams. Describe what must happen in the system being modeled:

○ Activity diagram

○ State machine diagram

○ Use case diagram

• Interaction diagrams. A subset of Behavior diagrams, these emphasize the flow of control and data among the objects in the model: