Wednesday, August 20, 2008

Robotripping: hands on with the Android SDK beta

Google has announced the availability of the first Android SDK beta and
also disclosed the roadmap for the upcoming 1.0 release. The platform
has improved significantly since the early prereleases, and the API is
now richer and more complete.

Android applications and user interface

The user interface has been completely redesigned, with a strong focus
on attractiveness and usability. The new home screen provides a loose
grid for placing icons and small widgets, such as a digital clock and
search bar. Users can drag application launchers to the home screen
directly from the main menu. The widgets and icons are organized across
three separate home screen panes that the user can flip between with a
dragging gesture.

The main application menu flies up from a tab at the bottom of the
screen and displays launchers for all of the installed programs. The
home screen background image is now configurable through a wallpaper
selector that is activated from the hardware menu button. The top row
of the screen has a status bar with a clock and notification icons.
Dragging down that bar will provide access to the notification pane,
which shows information about missed calls, recent messages, and other
application-specific notices.

The applications included with the platform have been improved, too.
The entire set of software exhibits a uniformly high level of
usability. The dialer and address book are pretty much what one would
expect, but everything is a lot more polished now. The mapping software
got some new features, including support for Google Streetview, but
still has a few bugs. For instance, switching between modes on the map
will clear an active search, and there is no way to have street view
and satellite view enabled at once.

The application with the most impressive improvements is the web browser. I recently gave Opera Mobile 9.5 a rave review,
and I consider it a pretty strong mobile browser. Android's built-in
browser delivers all of the same features but with a cleaner and less
clunky user interface.

Android offers a flawlessly desktop-like browsing experience with
excellent support for JavaScript and modern web applications. When the
user zooms in and out of the page, the text automatically rewraps to
fit the screen. The fonts are beautifully crisp at most zoom levels and
the text is very readable. Users can open multiple pages at once and
switch between them using a thumbnail grid view. Android provides a
browsing experience that is easily comparable to that of the iPhone,
which is unsurprising—both use the WebKit rendering engine.

Application porting

The SDK is still extremely easy to install and configure. The user
just has to download and decompress the SDK, install the Eclipse
plugin, and then provide the plugin with the path of the SDK. If you
already have Eclipse installed, it's really a five-minute operation.
Keep in mind that you have to have at least Eclipse 3.3 in order to use
the plugin (Ubuntu is being lame and still doesn't have it).

One of the biggest improvements in the Eclipse plugin is the new visual
preview feature for XML user interface files. This displays a graphical
representation of the UI so that developers don't have to run their
program to see how the layout looks. It still has some limitations and
doesn't properly display some of the more complex widgets, but it's
good enough for basic forms.

The API has changed significantly since the early prereleases. The simple Twitter test program that I wrote with the first SDK release and then updated for the second release
couldn't easily be ported to the new version. Some of the packages I
was using (DateUtil, for instance) are no longer included, and I
haven't been able to figure out yet exactly what I'm supposed to be
using instead. Google has published extensive documentation to describe the differences between this version and the previous one, so it's really just a matter of investing some time and doing the research.

I suspect that some of the more sophisticated programs will have to
undergo major refactoring and rewrites. Unfortunately, the API changes
were not publicly documented incrementally, and Google declined to make
new SDK releases available to the general developer community until
now, so developers will have to make a big adjustment all at once.

The API is very rich and it provides a very diverse selection of
controls. In addition to the conventional buttons, checkboxes,
combo-boxes, and toggle switches, the toolkit also includes some nice extras, like controls for an embedded WebKit renderer and an image selector. There is also a comprehensive notification API for displaying application-specific notices to the user and for adding icons to the status bar.

Some nice aesthetic features are available, too, like support for 3D
transitions, blurring an application when displaying modal dialogs, and
other similar visual flourishes. Media playback controls and OpenGL
support are also included in the SDK. To see a bunch of the supported
controls and other API features in action, check out the API Demos
program that is included in the emulator.

One pretty major disappointment is that there is no API for creating home screen widgets. Some comments
posted by Google engineers in the Android Google Group seem to indicate
that they are still working on addressing widget security issues and
could add an API for it later, after the 1.0 release.

Openness still in question

Google has repeatedly touted the inclusiveness of an open platform
as the primary quality that differentiates Android from competing
mobile operating systems. Unfortunately, mismanagement and market
pressures have largely undermined that advantage and disenfranchised some of the Linux enthusiasts in the third-party developer community.

Although the availability of an updated SDK will satisfy some of the
critics, it doesn't undo the mistakes that Google made during the
development process. Android is still an insular stack, created through
a closed development process in a complete vacuum, with input only from
the carriers, handset makers, and a small group of handpicked
developers. So far, there has been no evidence of the transparency and inclusiveness that Google promised when the platform was announced.

The abandonment of this commitment during the development process is
frustrating, but will likely be forgiven in the long term if Google
gets it right after the hardware hits shelves. Ultimately, the most
important test will come later this year when Google finally opens the
source code. At that time, Google will have the opportunity to restore
its credibility as an open platform provider by adopting a
participatory governance model, accepting third-party patches, and
allowing the community—and not just the carriers and handset makers—to
influence the future of the platform. If Google just does a code drop
and then continues ignoring a majority of third-party developers, it's
not going to help much.

Google has already taken some important steps to improve the transparency of Android development. A developer roadmap
has been published with a schedule of upcoming releases and some
details about naming conventions and compatibility. Google aims to have
release candidates ready next month and will do the official 1.0
release in the third quarter of 2008. Devices will supposedly be
available by the fourth quarter, which is when Google will open the
code base.

Coming soon

The most significant area where Android has an advantage over the
iPhone right now is in the potential for hardware diversity. Users who
want a mobile device with a hardware keyboard, full Bluetooth support,
a microSD slot, and any number of other similar features that haven't
been blessed by His Steveness, will not be inclined to buy an iPhone.
The iPhone's one-size-fits-all approach is conducive to a great user
experience, but necessarily locks the product out of large segments of
the market. Android, on the other hand, can be shipped on a wide range
of hardware devices that are designed to cater to the needs of specific
audiences. That alone will give Android a big boost in the competitive
mobile phone market.

During the months leading up to this release, the lack of public
information about Android progress significantly deflated my own
enthusiasm for the platform and left me with the impression that it was
falling into the vaporware trap. The latest release has renewed my
interest and demonstrated forcefully that Android is not vaporware. We
also have word that an Android-based handset from T-Mobile is going to
be coming soon.

From :