This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process document) and is written to declare its intent and scope. This proposal is written to solicit additional participation and input from the Eclipse community. You are invited to comment on and/or join the project. Please send all feedback to the http://www.eclipse.org/newsportal/thread.php?group=eclipse.dsdp.mtj newsgroup.
The Java programming language is becoming more and more popular in mobile
devices. Also, the richness of the device Java environment is getting better all the
time and more applications can be written using Java, instead of native
languages. As Java continues to grow in popularity, along with the proliferation
of higher functioning mobile devices, it is apparent that Java applications can
be developed to run on multiple targets, with a common set of application code.
Developing applications to the mobile Java environment presents unique challenges to developers. Specifically, unlike the straightforward J2SE and J2EE environments, there are a number of configurations and profiles (such as MIDP on top of the CLDC and Foundation and Personal Profiles on top of the CDC), along with a number of JSRs (and umbrella JSRs such as JTWI or JSR-248) that require development tools to assist in managing the runtimes/class libraries for development work and runtime binding. This ability to develop for multiple targets and use common source code with different build configurations is critical in mobile Java development projects. In addition to this management of runtimes and the challenges it presents, mobile Java applications have unique launching and debug requirements and unlike J2SE or J2EE, applications are not always just placed on a server for download as needed. Rather, developers require device emulators for on-development-system test and debug, the ability to launch, test, debug and analyze performance of the applications on the devices themselves, where varying classes of these devices have different methods and levels of connectivity. There is also the need for a robust deployment solution to deliver the code under development to the device, and also be able to map that to a production deployment solution. Of course, this is all in addition to the “normal” set of application development tools (such as code creation, UI design and so on) for a specific market segment.
A common set of tooling and frameworks across these targets, and the mobile Java space makes the development effort and cost manageable for developers. This is why it is important to have robust Eclipse frameworks in place to support mobile Java application development alongside the rich client and server counterparts
The goal of the Mobile Tools for Java project is to extend existing Eclipse
frameworks to support mobile device Java application development.
MTJ will enable developers to develop, debug and deploy mobile Java applications to emulators and real devices.
Normally runtimes are managed in Eclipse as a JRE. In the mobile segment, the runtime environment is a device emulator or real device. The MTJ project will provide features to manage mobile runtimes and provide frameworks for device vendors to add those runtimes to the development environment.
One vital part in mobile development is testing on real devices. To make that as easy as possible the developer must have methods to transfer mobile applications to handheld devices using local methods (e.g. Bluetooth, USB, IrDA). The idea of MTJ is to develop a framework that provides an API for vendor specific plug-ins, which then do the actual deployment.
The goal is to enhance normal build process with mobile extensions like JAR and JAD file generation. With the varying configurations and profiles of mobile Java, this is a critical feature to enable developers to manage code production. Another requirement is to provide ways to add additional tasks to the build process e.g. signing. This work should extend the builder frameworks of Eclipse.
This is related to Device & Emulator framework. The goal of this item is to enhance the current Debugging environment so that it is possible to use mobile runtimes, either emulator or a real device. This task extends to launching the JVM and applications(s) on the local emulator or on the device itself, and allowing the developer to attach to that application under test. In the mobile space, this is tightly integrated with the Device and Emulator frameworks, and will need to provide a robust framework for device and platform makers to extend to their devices’ specific connectivity. This work should extend the debug frameworks of Eclipse.
Application wizards in general exist in the Eclipse platform. It is possible to generate Java projects with or without application skeleton code but the existing wizards are not usable for Mobile development. This task is tied to the differing configurations and profiles of mobile Java and relieves the developer of needing to worry about the boilerplate code for each of the application configuration/profile types. One of the goals of MTJ is to enhance the existing wizards by providing Mobile specific project wizard.
The goal of these tools is to improve efficiency (easy drag and drop without
coding) and also decrease the entry barrier for newcomers. There are already
visual designers in the Eclipse platform but they don’t contain support for
mobile devices. The target is to bring mobile UI styles, components and layout
rules to Eclipse. The idea is to create a framework that enables the use of
different kinds of UI implementations e.g. different resolutions, different
vendor specific look and feel.. Also in the scope of this project, in addition
to this framework is at a minimum. a generic UI designer implementation.
A Screen Flow designer tool would provide ways to develop application logic easily. It would provide easy drag and drop functionality to add different kind of screens and transitions between them. These transitions are caused by mobile specific ways like commands, list item selections.
The idea is to utilize Eclipse Visual Editor Project and extend it so that device screen engines from different vendors can be plugged in.
The mobile application market is world wide so applications typically need to be localized. Therefore, an important requirement is for tooling that makes this task easier.
Mobile devices are restricted by memory so it is important that code is compresses as small as possible. There are a number of ways this can be accomplished. Obfuscation is one possibility, along with tooling and frameworks to enable performance and size analysis on the emulators or physical devices, which can be driven back into the build process or just for the developer to streamline their own code.
Security becomes more important in mobile devices because they are open and accessible to 3rd party developers. One solution for this is to require that the applications be signed with an authorized signing certificate. The signing process is very similar to signing a normal JAR signing but there are some specific mobile needs. The goal of MTJ is to support tooling to sign mobile applications. This signing tool will provide extensibility to add solution specific signing tools. This is exemplary of other external tools for mobile Java that need to be able to be integrated to a customizable build process.
This project is currently in proposal phase and Nokia is actively seeking interested parties for this project. Detailed planning for initial delivery of MTJ is underway and development is beginning.
Mika Hoikkala, Nokia (proposed project lead)
Arto Laurila, Nokia
Marius Voicu, Nokia
Minna Bloigu, Nokia
+ 2 TBD, Nokia
The goal for the MTJ project is to have a first release simultaneous with the next main release of the Platform. Due to the aggressive schedule, the premise for this first release is to have the core set of functionality to provide a project that is usable by a mobile Java developer to generate and test code.
It is hoped and assumed that a fair amount of needed functionality will be contributed by Nokia and also by other project contributors. The first step for the project is to understand scope of initial contribution and then plan what new code needs to developed, what to utilize from contributions and how to refactor and integrated new and existing code to one initial package.Regardless of the initial contribution, focus in the first phase is to develop mandatory pieces from a mobile development point of view. The most important features are Device & Emulator framework, Deployment framework and Mobile enhanced build process. This work will be immediately followed by code development tooling such as wizards and UI builder. Then followed by other tooling like localization and obfuscation.
The working draft of the plan calls for interim milestone releases in December 2005, March 2006 with a first release level delivery concurrent with the next major release of the Eclipse platform (at the time of this writing, this would be Eclipse 3.2). Due to the early stage of this project this is subject to change.It is a challenging task to define the content and future directions of the Mobile Tools for Java project at this point. The high level intent is to provide mobile tool frameworks for any interesting enhancements in the mobile world. There will be a placeholder for any JSR or de facto standard that gets industry acceptance. Here are a few examples: JSR-232 (Mobile Operational Management), JSR-249 (Mobile Service Architecture for CDC), JSR-271 (MIDP 3.0) and so on.
Back to the top