Speed delivery of Android devices and applications with model-driven development

Speed delivery of Android devices and applications
with model-driven development
Skill Level: Intermediate

Beery D. Holstein (Beery.Holstein@il.ibm.com)
Senior Manager, Rhapsody Product Development
IBM

06 Jun 2011

Along with the Android software stack rapidly gaining market share for applications
on a variety of devices, embedded product designs are becoming more complex and
product lifecycles are shrinking. Efficient development has become essential. This
article presents several situations where using model-driven development (MDD) can
help developers speed the delivery of Android-based devices and applications.
The Android software stack is rapidly gaining market share for applications on a
variety of devices, such as smart phones, tablets, televisions, and in-vehicle
information and entertainment systems. The diversity of market segments, an
explosion in the number of new devices, and the demands of heterogeneous users
are forcing device manufacturers and application providers to introduce high-quality,
innovative products in shorter time frames. At the same time, shrinking development
budgets and a tough economic environment make efficient use of development
resources a critical necessity.

With embedded product designs becoming more complex and product lifecycles
shrinking, efficient development has become essential. The emergence of
model-driven development (MDD) has made it possible to accelerate the
development process. With MDD, software engineers can more clearly understand
and analyze requirements, define design specifications, test system concepts using
simulation, and automatically generate code for direct deployment on the target
hardware. This article presents several scenarios where using MDD can help
developers speed the delivery of Android-based devices and applications.

About the Android stack

Speed delivery of Android devices and applications with model-driven development Trademarks
© Copyright IBM Corporation 2011 Page 1 of 14

developerWorks® ibm.com/developerWorks

Android is a software stack for mobile devices. It includes an operating system,
middleware, and key applications (see the link to "What is Android" in Resources for
more information). The Android SDK provides the tools and APIs necessary to begin
developing applications on the Android platform, using the Java programming
language. These include a device emulator, tools for debugging, memory and
performance profiling, and a plug-in for the Eclipse development environment.
Figure 1 shows the major components of the Android operating system within the
application framework, libraries, Android runtime, and Linux kernel.

Figure 1. Major components of the Android software stack

Larger view of Figure 1.

Android software developers can be classified into two kinds: platform vendors and
application developers.

• Platform vendors are the companies that combine software and hardware
to produce the actual devices. These devices serve as the hosting


ibm.com/developerWorks developerWorks®

environment for smart device applications, at least for the "on-device"
portion of the application. (Many such applications also include a server
component.)
• Application developers are the organizations that create the software that
calls upon the services exposed by the Android device ("the platform"). In
this categorization, it is important to note that platform vendors frequently
want to deliver their devices preloaded with a set of applications so that
the devices are useful immediately, as delivered Consequently, it is
common for platform vendors to develop applications and to ensure that
applications developed by third parties work properly with the device the
vendor intended to provide.

Model-driven development for embedded systems
Models are used to represent a system at higher levels of abstraction, while
promoting consistency, accuracy, and precision. Because the models are at a higher
level of abstraction than the source code, they permit the construction of views that
can answer specific questions about the functionality, structure, or behavior of the
system or software. It is important to distinguish between "pictures" and semantic
models. A disconnected picture showing a vague concept can be useful, but a
semantically deep model that represents details of the relevant aspects of the
software can provide huge benefits to the developer and other stakeholders.
Specifically, good models are connected to the software so they always represent
the actual content of the source, which increases consistency across views and
improves communication of the software.

The most popular modeling language in the world is the Unified Modeling Language
(UML), which has been in use for over a decade with huge success. UML is based
on a relatively formal definition, known as a metamodel, which gives the language
both precision and scope. UML diagrams provide a view of system aspects by
graphically representing the model elements and their relationships. A model that
focuses on the functionality and behavior of the application can be used to generate
a fully executable application that is ready to be deployed on a specific target,
RTOS, middleware, and communication mechanisms (see the two books by Bruce
Powell Douglass cited in Resources.

Note:
IBM® Rational® Rhapsody® is a visual development environment for systems
engineers and software developers who are creating real-time or embedded
systems and software. The author uses this software to demonstrate some of the
concepts involved in model-driven development (MDD) in convergence with the
Android SDK for this article.



Converging MDD with Android software development
MDD provides several ways to speed up the development of Android devices. This
is accomplished through a deeper understanding of Android applications and the
Android framework, by updating and creating Android applications, and by
connecting the software development to requirements, testing, and planning. These
benefits are leveraged from within Eclipse, which is the primary development
environment for Android hosts, both the Android SDK and the MDD tools for
Android.

The Android API as part of the model

UML is a powerful language for modeling, but it provides only a generic template of
information for systems. Over the years, UML has spawned a number of variants,
known as profiles, for specific areas of development. Modeling closer to the relevant
domain reduces ambiguity and provides a clearer view of the design intention for
colleagues and customers.

To facilitate development in the Android domain, the Android Framework is being
visualized through a model library that consists of the various packages, classes,
and public interfaces found in the Android API and through a profile that
encapsulates some of the main Android building blocks as stereotypes. Developers
can drag elements from the profile and from the model library into UML diagrams.
This enriches the design with API use and guides Android application generation
from the model. Figure 2 shows a UML profile and a model library based on the
Android API. The profile and the model library are used during visualization,
creation, and update of Android applications from within the MDD tooling. This
enables developers to use the Android terminology in designs.

Figure 2. The Android API visualized through a model library and a UML profile



Developing an Android device involves new code, modifications to existing code,
existing code that does not change, and third-party libraries. Existing code and
third-party libraries can be visualized in the model, resulting in a graphical
representation of their structure and relations using UML class diagrams. Such
visualization allows developers to understand different aspects of an existing
Android application and to communicate them to various stakeholders, such as
customers, managers, architects, other developers, and testers. They can also
extract documentation from the model, thereby providing a different aspect of
communication.

During visualization of an application (and parts of its associated
AndroidManifest.xml file), the Android profile and model library are automatically
used to identify Android-specific elements, such as activities and services. This
results in visualizing not only the application itself, but also its relationship to and its
use of the Android API, as shown in Figure 3. Also shown is how MDD is integrated
as a plug-in for the Eclipse environment (see the link to Paul Urban's article in
Resources), facilitating modeling, coding, and simulation alongside the Android
Development Tools (ADT).

Figure 3. Visualizing the structure and algorithm of an Android application




In addition to providing graphical representation, MDD tools can depict execution of
the application inside the graphical environment, which enables a better
understanding of the application's runtime behavior. Figure 4 shows how the runtime
interactions between elements in an Android application that was instrumented with
a code agent are automatically captured during its execution. The interactions are
captured to a UML sequence diagram in which the vertical lines in the sequence
diagram are elements from the Android application, and the horizontal lines show
the invocation of operations between elements. By showing the higher-level
abstraction of interactions between several elements in the Android application, the
runtime behavior of an application is better understood and better communicated to
various stakeholders.

Figure 4. Graphical environment provides insight into runtime behavior




Creation and updating

It is of very little practical value to have diagrams that are not directly connected to
the source code. Experience has clearly shown that having two representations of
the system semantics, one in the model and the other in the code, quickly diverges
so that the model and the code no longer match.

Starting with a fresh model or from a model used to visualize an existing Android
application, a matched Eclipse-Android project is created by the MDD plug-in, and
the project is populated with code generated from the model. This includes the static
portion of the models (for example, packages, classes, and operations) and the
behavior modeling (state machine). During this process, the Android profile and
model library are automatically used to create some of the "glue" code needed to
connect the user code to the Android framework.

Figure 5 shows code generated from a structural model representation. As
developers change the model, the source code is automatically updated. Similarly, if
the source code is updated, the model is automatically changed to reflect the new
source code contents. This ability to associate the model code associativity
promotes agility, because the developer can choose to work either in the model or in
the source code, and synchronicity between the two is automatically maintained.

Figure 5. Code generated from the structural model



Debugging and testing

Although defects are most likely introduced early in the process, they are often found
only later on. Moreover, the cost for repairing defects goes up exponentially the later
they are discovered. As a result, the challenge is how to find defects closer to the
time that they are introduced. If the model correctly depicts the intended functionality
and behavior of the application, the model can be brought to life and used to enable
early testing and debugging at the model level of abstraction.

In Figure 6, an Android simulator is used to execute an application generated from a
model. You can simultaneously see the active state highlighted in UML state charts
(created by the developer and used earlier in generating the application) and view
the UML sequence diagrams that were automatically generated during execution.
You can then compare the sequence diagrams to the application's expected
behavior, so you can validate proper design operation. You can also compare the
automatically generated sequence diagrams to those from a previous execution of
the application to identify changes in behavior that might indicate regressions. A
model-based testing (MBT) tool can further use the automatically generated
sequence diagrams to execute them automatically, thus both driving and monitoring
testing.

Figure 6. Debugging can be done at the code level and model level




Collaboration

Developing Android devices and applications can involve managing host system
development, legacy application maintenance, hardware development, and more.
Managing the integration of these different domains introduces complexity and
requires that a holistic view of the architecture be available to development teams
working independently on these different domains. The complexity of Android
devices leads to increasing challenges in managing joint development lifecycles,
testing sequences, and rollouts, and in monitoring and managing these systems
after they are delivered. The challenge is further expanded by the large number of
distributed teams, which often include agencies, contractors, OEMs, and suppliers.

Continuous validation and verification is fostered by combining requirements,
models, quality management, and project monitoring, as shown in Figure 7. The
models are made centrally accessible to the entire team and become the source of
the entire design. A demo on YouTube (see references) shows how Rational Team
Center is leveraged for project planning and monitoring.

Figure 7. Collaboratively managing delivery of a smart device or application



For example, as Figure 8 shows, MDD can be used to better understand
requirements by visualizing them in the model. The requirements are stored in the
model, and their relationship to design elements and test cases can be created,
thereby helping to provide traceability information within the model. This, in turn, can
be used during testing to produce requirements a coverage matrix and reports. The
information from the requirements, such as the ID or specification, can be
automatically generated into the Android application code to enable traceability from
requirements, design in the model, and implementation in code.

Figure 8. Requirements as part of the model




Conclusions
Combining MDD capabilities with the Android development environment can help
improve productivity, as well as time to market, plus reduce costs. Aside from
providing a convenient single environment for both Android coding and modeling, it
offers developers visual specification of design requirements. Moreover, the
framework can be used to visualize existing Android applications, thereby offering
insight into their structure and behavior. The use of models that connect the
requirements, design, and code also simplifies documentation and enables the
document to be automatically generated.

After the model has been created within the Android development environment,
Android applications can be automatically delivered. In addition, the model can be
used to execute the design, providing validation and allowing defects to be
discovered early in the design's lifecycle. This execution also offers automated
software unit and regression testing for improved quality of code. The integrated
environment is also a vital factor in enabling collaboration among distributed teams
and across development organizations.



Resources
Learn
• Cited in this article:
• Krasner, Jerry. What Do You Do When the Horse You're Riding Drops
Dead? Why Model Driven Design is Emerging as a Preferred Best
Practice. A white paper published by Embedded Market Forecasters, a
division of American Technology, Inc. (2007).
• What is Android? Android Developers website. The Android Architecture
diagram in Figure 2 is from the Android Open Source Project and used
according to terms described in the Creative Commons 2.5 Attribution
License.
• The Eclipse Foundation.
• Getting Started with UML, UML Resource Page, Object Management
Group website.
• Douglass, Bruce Powell. Real-Time UML Workshop for Embedded
Systems. Newnes (2006).
• Douglass, Bruce Powell. Real Time UML: Advances in the UML for
Real-Time Systems (3rd Edition). Addison-Wesley Professional (2004).
• Urban, Paul. Combining Code Development, Modeling, and Simulation
with Eclipse, Dr. Dobb's Journal (October 2009).

• To learn more about using Rational Rhapsody Developer for collaborative,
model-driven development for embedded systems, start with these overviews:
Introduction to Rational Rhapsody, the Rational Rhapsody Developer product
page, and the Rational Rhapsody page on IBM developerWorks. Explore the
various versions, too:
• IBM® Rational® Rhapsody® Architect for Software, a visual development
environment for embedded systems and software
• IBM® Rational® Rhapsody® Architect for Systems Engineers
• IBM® Rational® Rhapsody® Designer for Systems Engineers
• IBM® Rational® Rhapsody® Developer edition. This edition is required for
Eclipse users and editions are available to create specialized projects in C,
C++, Java, and Ada languages.

• Visit the Rational software area on developerWorks for technical resources and
best practices for Rational Software Delivery Platform products.



• Stay current with developerWorks technical events and webcasts focused on a
variety of IBM products and IT industry topics.
• Attend a free developerWorks Live! briefing to get up-to-speed quickly on
IBM products and tools, as well as IT industry trends.
• Watch developerWorks on-demand demos, ranging from product
installation and setup demos for beginners to advanced functionality for
experienced developers.

• Watch the Rational Solution for Android mobile application development demo
on YouTube.
• Improve your skills. Check the Rational training and certification catalog, which
includes many types of courses on a wide range of topics. You can take some
of them anywhere, any time, and many of the "Getting Started" ones are free.
Get products and technologies
• Download Rational Rhapsody Developer and try it free for 30 days.
• Evaluate IBM software in the way that suits you best: Download it for a trial, try
it online, use it in a cloud environment, or spend a few hours in the SOA
Sandbox learning how to implement service-oriented architecture efficiently.
Discuss
• Join the discussion in the Rational Rhapsody forum.
• Share your knowledge and help others who use Rational software by writing a
developerWorks article. You'll get worldwide exposure, RSS syndication, a
byline and a bio, and the benefit of professional editing and production on the
developerWorks Rational website. Find out what makes a good
developerWorks article and how to proceed. Start by finding out what makes a
good developerWorks Rational article.
• Follow Rational software on Facebook, Twitter (@ibmrational), and YouTube,
and add your comments and requests.
• Ask and answer questions and increase your expertise when you get involved
in the Rational forums, cafés, and wikis.
• Connect with others who share your interests by joining the developerWorks
community and responding to the developer-driven blogs.

About the author
Beery D. Holstein



Beery Holstein has more than 20 years experience in developing
software engineering tools and over a decade of experience with
developing Rhapsody, an MDD tool for the embedded, real-time
software development industry. He was one of the first members of the
team that developed Rhapsody, before it became part of IBM Rational
software (i-Logix and then Telelogic). Beery is now managing the
development of the core product, including among other things, the
code generation, reverse engineering, and round-trip capabilities that
underlie support for Android.


Speed delivery of Android devices and applications with model-driven development

More Related Content

What's hot (17)

Viewers also liked (20)

Similar to Speed delivery of Android devices and applications with model-driven development (20)

More from Bill Duncan (20)

Recently uploaded (20)

Speed delivery of Android devices and applications with model-driven development