The benefits of developing Android applications using commercial Eclipse-based solutions

February 01, 2011

The Android SDK is an advantageous starting point for developing Android code, but the SDK can be enhanced significantly by integration with features...


The Android Software Development Kit (SDK), which Google provides for free, is a great starting point for developing an Android-based smart device application. The SDK contains a variety of useful materials for developers, including extensive documentation, tutorials, samples, best practice guidance, and an array of tools for numerous development purposes.

The SDK’s set of Java APIs gives application developers access to native functions that Android-based devices support, such as 2D and 3D graphics, multimedia codecs, telephony features, and location services. A device emulator in the SDK allows developers to try out their code directly from the development environment without requiring a physical device. And the SDK has an Eclipse plug-in that exposes the Android APIs and SDK tools in a rich Integrated Development Environment (IDE).

Opening the door to collaboration

For an individual developer of Android code, the SDK is valuable and is becoming more so as it is being extended with new features all the time. However, it is missing features that facilitate the collaboration and coordination needed when a development team is creating the application.

By integrating the device-specific, native platform SDK from Google with a compatible commercial development solution, agile teams can achieve tremendous efficiencies and better results. Integrating the native Android SDK with a commercial development environment opens the door to seamless source control, iterative application planning, effortless work item management, and a host of enterprise-quality development capabilities for an Android application.

For instance, many Android applications are structured as hybrid Web applications, where part of the application runs on an application server on the network delivering data to the device from an enterprise storage system, perhaps a mainframe computer. Another part of the hybrid application runs on the device itself, displaying the data it receives across the network and formatting it for the device form factor while accessing the device’s services such as GPS, camera, and accelerometer to deliver a rich and well-performing user experience.

Such a hybrid application is typically created by a small team comprising a few developers of the fundamental business logic and Web application components, a few User Interface (UI) developers, a user experience designer, a couple of testers, and a team leader or manager. Let’s consider how this team can leverage the Android SDK in an environment that allows each member to efficiently communicate and collaborate.

The integrated Eclipse environment

The Android SDK, or more precisely, the Android Development Tools Eclipse plug-in that is part of the SDK, can be combined with an Eclipse-based commercial collaborative development product such as IBM Rational Team Concert (RTC). There is much information available that documents how to get the Android SDK and RTC working within the same Eclipse “shell.” See Figure 1 for an illustration of what the Android SDK looks like when integrated with RTC.


Figure 1: Rational Team Concert enables a development team to easily create and manage Android apps throughout their life cycle.




The commercial IDE (RTC) offers integrated work item management, which allows the team leader to define work for the Android UI developers and assign those tasks to them, separately from the work assigned to the application logic developers and the other team members, including work assigned to the testers. The code changes associated with a particular work item are tied together into a specific change set that is delivered in one shot, so the full code change can be tracked as a unit. As the developers edit files inside their IDE, the change set is automatically maintained. The developers don’t have to do anything special to produce the change set other than edit the files they need to work on.

The change sets can be shared amongst members of the team before being fully integrated with the main code stream. So a change set altering the format of data supplied by the Web application can be shared with the UI developer working on the logic that displays the new data without affecting the rest of the team. Once both UI code changes and Web app code changes are deemed ready, they can be integrated in one synchronized task into the mainline code stream for the rest of the team to use.

Developers working on the Web application can execute the part of the application that runs on the device from their own IDE using the Android device emulator that is part of the SDK. Using the combination of shared change sets and an integrated device emulator, the pairs of developers working on the same feature (UI and Web app logic) can collaborate to work out initial problems that may arise as the result of different understanding about the application details. One of the developers can capture a screenshot of the device emulator using the screen capture tool built into the commercial IDE and share that screen capture with the other developer to show an exact behavioral issue or defect in the code.

Agile team collaborative development tools such as RTC allow the definition of multiple short iterations where a small set of application enhancements are to be implemented and validated. A typical agile iteration is two to four weeks long. The team leader can work with the team to map work items from a backlog list into the specific iterations and assign the work items to individual developers. As the developers pick up the work items and begin to make progress on them, their effort is automatically recorded and available for the team leader to track and view. This makes the information about what has been completed, what is being worked on now, and what is still to be done easy to track and view in a dashboard presentation. Everyone on the team can see how the iteration is progressing and the status of the work items planned for that iteration.

When the testers on the team start the functional testing of the application, they can open defects as work items in the shared development project. They can easily grab screen captures of the failed tests and include them in the defect records. The team leader can track these incoming test defects and work with the team to distribute them for resolution.

Products add value to basic SDK

Several Eclipse-based commercial products can be integrated at the same time with the Android SDK to provide the team with even greater capabilities. For example, the ability to model the device code structure and keep this model in sync with the real source code can be added to the collaborative agile team environment. By integrating a commercial product such as IBM Rational Rhapsody with the combined Android SDK and RTC environment, the team can gain the ability to keep a high-level model of the application in sync with the actual application code. Because the real application structure can be difficult to understand for moderate-sized projects, the ability to generate a model from the source code can prove very valuable for the team.

Commercial static analysis products can be integrated with the Eclipse-based development environment and deliver the ability to analyze the code for quality and security issues. Some of these products can be integrated with the actual change set deliver process so that no code is integrated into the main line code stream unless it has been analyzed for fundamental quality and security issues.

All of the capabilities delivered by the commercial development products extend and enhance the basic SDK supplied by Google. While the Google Android SDK is the fundamental starting point for any project delivering code to be executed on the Android platform, the SDK can be dramatically more effective when integrated with the traditional agile team development features available in other Eclipse-based commercial products becoming more widely available today.

Leigh Williamson is an IBM Distinguished Engineer who has worked in the Austin, Texas lab since 1988, contributing to IBM’s major software projects including OS/2, DB2, AIX, OpenDoc, Java, Component Broker, and WebSphere Application Server. He is currently a member of the IBM Rational Software Chief Technology Officer team, influencing the strategic direction for products in the Rational brand and leading the projects for software development automation and mobile device application development. Leigh holds a BS in Computer Science from Nova University and an MS in Computer Engineering from the University of Texas at Austin.

IBM Rational [email protected]