Android Fragmentation Management

7 min read

(For more resources related to this topic, see here.)

Smartphones, by now, have entered our lives not only as users and consumers but also as producers of our own content. Though this kind of device has been on the market since 1992 (the first was the Simon model by IBM), the big diffusion was driven by Apple’s iPhone, when it was produced in 2007 (last year, the fifth generation of this device was released).

Meanwhile, another big giant, Google, developed an open source product to be used as the internal operating system in mobile devices; in a different manner from the leader of the market, this company doesn’t constraint itself to a unique hardware-specific device, but allows third-party companies to use it on their cell phones, which have different characteristics. The big advantage was also to be able to sell this device to consumers that don’t want to (or can’t have) spend as much money as the Apple phone costs. This allowed Android to win the battle of diffusion.

But there is another side to the coin. A variety of devices by different producers means more fragmentation of the underlying system and a non-uniform user experience that can be really disappointing. As programmers, we have to take into account these problems and this article strives to be a useful guideline to solve that problem.

The Android platform was born in 2003, as the product of a company which at first was known as Android Inc. and which was acquired by Google in 2005. Its direct competitors were and are still today the iOS platform by Apple and the RIM, know as Blackberry. Technically speaking, its core is an operating system using a Linux Kernel, aimed to be installed on devices with very different hardware (mainly mobile devices, but today it is also used in general embedded systems, for example, the game console OUYA that features a modified version of Android 4.0).

Like any software that has been around for a while, many changes happened to the functionality and many versions came out, each with a name of a dessert:

  • Apple Pie (API level 1)
  • Banana Bread (API level 2)
  • 1.5 Cupcake (API level 3)
  • 1.6 – Donut (API level 4)
  • 2.0-2.1x – Eclair (API level 5 to 7)
  • 2.2 – Froyo (API level 8)
  • 2.3 – Gingerbread (API level 9 and 10)
  • 3.0-3.2 – Honeycomb (API level 11 to 13)
  • 4.0 – Ice Cream Sandwich (API level 14 and 15)
  • 4.1 – Jelly Bean (API level 16)

Like in many other software projects, the names are in alphabetical order (another project that follows this approach is the Ubuntu distribution).

The API level written in the parenthesis is the main point about the fragmentation. Each version of software introduces or removes features and bugs. In its lifetime, an operating system such as Android aims to add more fantastic innovations while avoiding breaking pre-installed applications in older versions, but also aims to make available to these older versions the same features with a process technically called backporting.

For more information about the API levels, carefully read the official documentation available at element.html#ApiLevels.

If you look at the diffusion of these versions as given by the following pie chart

you can see there are more than 50 percent of devices have installed versions that we consider outdated with the latest; all that you will read in the article is thought to address these problems, mainly using backporting; in particular, to specifically address the backward compatibility issues with version 3.0 of the Android operating system—the version named Honeycomb.

Version 3.0 was first intended to be installed on tablets, and in general, on devices with large screens. Android is a platform that from the beginning was intended to be used on devices with very different characteristics (think of a system where an application must be usable on VGA screens, with or without physical keyboards, with a camera, and so on); with the release of 3.0, all this was improved with specific APIs thought to extend and make developing applications easier, and also to create new patterns with the graphical user interfaces.

The more important innovation was the introduction of the Fragment class. Earlier, the only main class in developing the Android applications was Activity, a class that provides the user with a screen in order to accomplish a specific task, but that was too coarse grain and not re-usable enough to be used in the applications with large screens such as a tablet. With the introduction of the Fragment class to be used as the basic block, it is now possible to create responsive mobile design; that is, producing content adapting to the context and optimizing the block’s placement, using reflowing or a combination of each Fragment inside the main Activity.

These are concepts inspired by the so called responsive web design, where developers build web pages that adapt to the viewport’s size; the preeminent article about this argument is Responsive Web Design, Ethan Marcotte.

For sake of completeness, let me list other new capabilities introduced with Honeycomb (look into the official documentation for a better understanding of them):

  • Copy and Paste: A clipboard-based framework
  • Loaders: Load data asynchronously
  • Drag and Drop: Permits the moving of data between views
  • Property animation framework: Supersedes the old Animation package, allowing the animation of almost everything into an application
  • Hardware acceleration: From API level 11, the graphic pipeline uses dedicated hardware when it is present
  • Support for encrypted storage

In particular for address these changes and new features, Google make available a particular library called “Support library” that backports Fragment and Loader. Although the main characteristics of this classes are maintained, in the article is explained in detail how to use the low level API related with the threading stuff.

Indeed an Android application is not a unique block of instructions executed one after the other, but is composed of multiple pipelines of execution. The main concepts here are the process and thread. When an application is started, the operating system creates a process (technically a Linux process) and each component is associated to this process.

Together with the process, a thread of execution named main is also created. This is a very important thread because it is in charge of dispatching events to the appropriate user interface elements and receiving events from them. This thread is also called UI Thread.

It’s important to note that the system does not create a separate thread for each element, but instead uses the same UI thread for all of them. This can be dangerous for the responsiveness of your application, since if you perform an intensive or time expensive operation, this will block the entire UI. All Android developers fight against the ANR (Application Not Responding) message that is presented when the UI is not responsive for more than 5 seconds.

Following Android’s documentation, there are only two rules to follow to avoid the ANR:

  • Do not block the UI thread
  • Do not access the Android UI toolkit from outside the UI thread

These two rules can seem simple, but there are some particulars that have to be clear. In the article some examples are shown using not only the Thread class (and the Runnable interface) but also the (very) low-level classes named Looper and Handler. Also the interaction between GUI elements and these classes are investigated to avoid nasty exceptions.

Another important element introduced in Google’s platform is the UI pattern named ActionBar—a piece of interface at the top of an application where the more important menu’s buttons are visualized in order to be easily accessible.

Also a new contextual menu is available in the action bar. When, for example, one or more items in a list are selected (such as, the Gmail application), the appearance of the bar changes and shows new buttons related to the actions available for the selected items.

One thing not addressed by the compatibility package is ActionBar. Since this is a very important element for integration with the Android ecosystem, some alternatives are born, the first one from Google itself, as a simple code sample named ActionBar Compatibility that you can find in the sample/directory of the Android SDK.

In the article, we will follow a different approach, using a famous open source project, ActionBarSherlock. The code for this library is not available from SDK, so we need to download it from its website ( This library allows us to use the most part of the functionality of the original ActionBar implementation such as UP button (that permits a hierarchical navigation), ActionView and contextual action menu.


Thus in this article we learned about Android Fragmentation Management.

Resources for Article :

Further resources on this subject:


Please enter your comment!
Please enter your name here