Some loved the wearable build bot more than others.

Over the Air - 30th September & 1st October
Jamie was speaking about ubiquitous Android at Over The Air on the Friday. The rest of the Novoda team were there for the hackathon too. We came armed with a whole bunch of ideas and a pack of NFC stickers! Hooray we won stuff! I ended up making an app which won the Secure Communications Challenge with an NFC enabled encryptor for your secret messages and the guys won the most wearable hack for a wearable build status bot.

To I’m participating in Planet of the Apps – 4th–7th October in a panel discussion on the first conference day: ‘Can the browser app be the killer app’

And then the biggie… we’re organising and Carl’s speaking at Droidcon UK – 6th & 7th October. Carl will be presenting his talk about Android’s message-driven architecture. The whole Novoda team will be in attendance just kicking about. See you there!

A little further in the future, some of us will be at Droidcon Netherlands on the 22nd & 23rd November.

Lovep.ie

We created a website and Android app for Lovep.ie! The concept is to allow the user to decide how much they can afford to donate, and then divide that amount between a selection of causes. We hope that this would make it easier for people to spread their generosity and include smaller charities and non-profit organisations.

History

Lovep.ie was a drastic simplification of an idea from a previous charity hack. We deleted the previous source and coded it from scratch. This time we made and Android app too, and that turned out to be a good opportunity to play with Roboguice for dependency injection.

Our solution

We used PayPal APIs and the PayPal mobile payments library to create a parallel payment, split evenly between the selected causes. MissionFish provided us some sample charity data and a method for making donations with PayPal through their service. It would, of course, also be possible to make PayPal payments directly to the causes from our app and website.

Future

We have ambitions to release Lovep.ie some time. Hopefully we can find some causes that would like to be involved.

The main components of our continuous integration system are:

Here we wish to share and document our set up and explore some capabilities of the android maven plugin. If you are brand new to it you may wish to first check out Maven in 5 minutes and maven-android-plugin’s useful Getting Started guide.

Android maven plugin helps us with the following android deployment tasks:

We want to show you a real example of an application built with the help of the maven-android-plugin. It’s an Avatar Creator app for WeeWorld.

The app is now on the market, so go ahead and check it out! (0.99$)

If you’re quite familiar with maven and the android plugin, you might want to jump straight to the Real Life Example at the end of this post and check out the full configuration.

Building your App

To buid an apk, your app first needs to cite a version of android platform as a build path dependency in your application’s pom file (as provided scope). More on dependency scope.

<dependency>
  <groupId>com.google.android</groupId>
  <artifactId>android</artifactId>
  <version>2.2.1</version>
  <scope>provided</scope>
  <type>jar</type> <!-- optional -->
</dependency>
<!--Currently valid values: 1.5_r3,1.6_r2,2.0_r1,2.0.1_r1,2.1_r1,2.2.1-->
<!--Those packages are on the maven central repository-->

The project must then reference the maven android plugin within the project’s pom along with the android API level targeted, here we cite version 2.2 (api level 8 )

<plugin>
  <groupId>com.jayway.maven.plugins.android.generation2</groupId>
  <artifactId>maven-android-plugin</artifactId>
  <configuration>
    <sdk>
      <platform>8</platform>
    </sdk>
    <deleteConflictingFiles>true</deleteConflictingFiles>
  </configuration>
  <extensions>true</extensions>
</plugin>

Reference a java compiler version, since the default source and target values are 1.3 and 1.1 respectively, and android uses annotations conforming to java 5

<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.5</source>
    <target>1.5</target>
  </configuration>
</plugin>

If your project uses Any android platform plugins for instance Google maps, additional dependencies will also require referencing in the project’s pom:

<dependency>
  <groupId>com.google.android.maps</groupId>
  <artifactId>maps</artifactId>
  <version>8_r1</version>
  <type>jar</type>
</dependency>
<!-- Current versions:  3, 4_r2, 7_r1, 8_r1 -->
<!-- NOTE: those are the ones defined by goole and are  NOT in the maven
central repository and need to be installed manually with:
mvn install:install-file wih proper parepeters as decribed here:

http://maven.apache.org/plugins/maven-install-plugin/usage.html

e.g. mvn install:install-file
-Dfile=$ANDROID_HOME/add-ons/addon_google_apis_google_inc_8/libs/maps.jar
-DgroupId=com.google.android.maps -DartifactId=maps -Dversion=8_r1
-Dpackaging=jar -->

Additionally one should remember to specify the source directory if the folder structure does not follow the default maven structure:

<sourceDirectory>${project.basedir}/src</sourceDirectory>

At the same time remember NOT to specify the resource directory, as maven-android-plugin handles Android-specific resources on its own, and we don’t wnt duplicates.

This will already get your project building, but there’s much more that maven can do for You. Let’s look at some of that now.

Testing your App with an Instrumentation

You most hopefully have an accompanying instrumentation test instrumentation project for your Android application and maven can build and run these against your previously compiled project. Maven can build the test project, deploy both the app and the test, and run the instrumentation on an attached device or an emulator.

Within the instrumentation test project it will need the following dependency:

<dependency>
   <groupId>com.google.android</groupId>
  <artifactId>android-test</artifactId>
  <version>2.2.1</version>
</dependency>
<!-- Allowed values same as for android package -->
 

If it depends upon the source code of the application which it tests:

<dependency>
  <!-- optional: compile time dependency, in this case so that we can -->
  <!-- read from the R.java for example. -->
  <groupId>my.app.group</groupId>
  <artifactId>myapp</artifactId>
  <version>${project.version}</version>
  <scope>compile</scope>
  <type>jar</type>
</dependency>

Instrumentations are run through a series of interactions within a pseudo environment so you will need to specify the Device/AVD(Android virtual Device) upon which you wish to run tests:

<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>maven-android-plugin</artifactId>
  <configuration>
  <emulator>
    <avd>22</avd>
    <!-- name of the avd to deploy to and run the instrumentation on -->
    <wait>150000</wait> <!-- wait time for the emulator to start -->
    <options>-partition-size 128 -wipe-data</options>
    <!-- additional options to run the emulator with-->
  </emulator>
  <undeployBeforeDeploy>true</undeployBeforeDeploy>
</configuration>

Devices to deploy to can be specified by a serial number but generic “usb” and “emulator” values are also valid. More detailed documentation can be found here.

Instrumentation environment

Instrumentations can interact at various hook in points during the a devices connected lifecycle. Execution and binding it to a maven lifecycle phase is specified like:

<executions>
  <!-- android plugin execution that starts the emulator. -->
  <execution>
    <id>startemulator</id>
    <!-- bound to the 'initialize' phase -->
    <phase>initialize</phase>
    <goals>
      <goal>emulator-start</goal>
    </goals>
  </execution>
</executions>

The configuration above binds the android plugin’s ‘emulator-start’ goal to the ‘initialize’ phase of the maven lifecycle. This is the equivalent of manually executing mvn android:emulator-start, from a directory with a pom containing valid configuration for it. Stopping the emulator does not require this and can be run anywhere and anytime with mvn android:emulator-stop.

If we would like to stop the emulator after running the instrumentation tests, we would add the following execution:

<execution>
  <!-- android plugin execution that starts the emulator. -->
  <id>stopemulator</id>
  <!-- bound to the 'install' phase -->
  <phase>install</phase>
  <goals>
    <goal>emulator-stop</goal>
  </goals>
<execution>

Signing your release

By default, the plugin will sign the apk with the debug key. This can be disabled, producing an unsigned apk.

<configuration>
  <sign>
    <debug>false</debug>
  </sign>
<configuration>

To sign and apk with your key, we will need to use the maven-jarsigner-plugin. Although it’s a different plugin, since it’s very relevant here’s how we did it:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jarsigner-plugin</artifactId>
  <version>1.2</version>
  <executions>
    <execution>
      <id>signing</id>
      <goals>
        <goal>sign</goal>
      </goals>
      <phase>package</phase>
      <inherited>true</inherited>
      <configuration>
        <includes>
          <include>
${project.build.directory}/target/${project.artifactId}-${project.version}.apk
          </include>
        </includes>
        <keystore>${keystore.location}</keystore>
        <storepass>${keystore.password}</storepass>
        <keypass>${keystore.keypass}</keypass>
        <alias>${keystore.alias}</alias>
        <verbose>true</verbose>
      </configuration>
    </execution>
  </executions>
</plugin>

Configures the jarsigner plugin with the files (input, output), and the keystore details. Binds the plugin’s ‘sign’ goal to the ‘package’ phase of the maven lifecycle.

The ${kestore.*} variables above come from the settings.xml file, and look:

<properties>
  <keystore.location>path/to/test.keystore</keystore.location>
  <keystore.password>teststorepass</keystore.password>
  <keystore.keypass>testpass</keystore.keypass>
  <keystore.alias>testkey</keystore.alias>
</properties>

Optimization .apk files via zipalign.

The last stage of a deployment, but also very important is zipaligning the apk after it’s been signed. This aligns archived data in such a way that upon runtime memory can more efficiently store the related data. After this your apk is ready to go to the market. our configuration:

<plugin>
  <groupId>com.jayway.maven.plugins.android.generation2</groupId>
  <artifactId>maven-android-plugin</artifactId>
  <configuration>
    <zipalign>
      <verbose>true</verbose>
      <skip>false</skip><!-- defaults to true -->
      <inputApk>
    ${project.build.directory}/${project.artifactId}-${project.version}.apk
      </inputApk>
      <outputApk>
    ${project.build.directory}/${project.artifactId}_v${project.version}.apk
      </outputApk>
    </zipalign>
  </configuration>
  <executions>
    <execution>
      <id>zipalign</id>
      <phase>verify</phase>
      <goals>
        <goal>zipalign</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Configures the plugin for the zipalign goal and binds that goal the the ‘verify’ phase of the maven lifecycle.

Real Life Example

The above describes taking full control over how maven-android-plugin builds and tests your android application. In reality though, one wouldn’t really use all of the above settings in one pom. Here’s an example of a fully-configured real-life project using ALL of the above:

The project makes use of a parent-child structure and maven profiles to manage both App and Instrumentation projects and handle different cases of builds. Feel free to have a look and se how we’ve done it. For more guides and tips about android development and continuous integrations check back to our blog – we’ll have something here soon!

Topics to expect:

References:

maven-android-plugin site, the Getting Started guide and their wiki page.
Installing a specific file into a local maven repository
Signing apk files with maven
Zipalign apk files with maven-android-plugin

Other relevant and important resources:

Maven: The complete reference book and it’s Android Chapter

Animated LiveWallpaper

Live Wallpapers offer unique screen real estate over widgets and a chance to show off some dashboard visuals. Childhood memories have instilled a message of freedom into the image of a Testerrossa speeding down an open road with a pretty girl ala “Ferris Buellers day off” and Sega’s classic “Outrun”. So What better to express the open platform than an OutRun inspired Live Wallpaper?

A sexy implementation using the openly available github source code:

Download the outrun livewallpaper for the Nexus One
Scenery changes every time the phone is sleeping as you can see here, here and here, in awful quality.

Admittedly my graphics aren’t quite as inspiring.

Download Demo apk compiled for a Nexus One

Animated LiveWallpaper Notes

Src code for Demos projects on Github:
Switch Image on left/right
Switch Animation on left/right

A Live Wallpaper consists of an ‘Engine’ and a ‘Service’. The engine specifies how your wallpaper is rendered while it’s service creates instances for the home screen. A wallpaper service differs from a normal service in addition of  OnEngineCreate(). This has been the first time I’ve used the canvas extensively and I learned you first must lock the canvas and choose which region you wish to redraw. onVisibilityChanged() or onSurfaceChanged() will read much like the instructions of how to draw your canvas from empty. Onvisibility() will first change to true in rendering your wallpaper  preview and this will return false when your wallpaper falls out of view and you transition to your dashboard. This is a handy function as every time your wallpaper falls out of view you can stop everything you are doing and free up the associated resources.

To update the drawn canvas state you need to tell the UI to refresh via a handler. In my case I needed to request an indexed image from within an collection upon each draw, Each time the handler returns back I update my drawn bitmap with a frame from the animation. It should be noted here that you should only be keeping the image Resource IDs in memory rather than the actual binary contents of the images. I was at first doing this, following a demo I downloaded but I soon ran into this error at runtime:

ERROR/AndroidRuntime(1067):
Uncaught handler: thread main exiting due to uncaught exception
java.lang.OutOfMemoryError: bitmap size exceeds VM budget

This is because all of the png images although starting out quite small, when transformed to bitmaps upon interpreation they become a lot larger and quickly fill up the allotted memory allocation. Instead I just kept an array of resIds using res.getIdentifier(). This seems pretty good in the performance stakes.

I chose to play an animation for left and right steering when a user flicks between panels. I kept track of this via the onTouchEvent()’s ACTION_DOWN and then checking which side of the screen their ACTION_UP was upon. The reason I added a timer in there was to add a little delay for the animation so you can appreciate the perfect driving line of the Testerossa.An area that I would like to return to is recognising when the user’s finger has dragged the screen a certain distance. My original approach to recognising significant drag was to monitor the start and end points and see if they lay at different sides of the screen, I have since learned measuring the distance within onOffSetsChanged would probably be a more reliable approach.

The last thing of note with Live Wallpapers is that they have a convenience listener for dropping icons and tapping on the dashboard screen via sendWallpaperCommand() and then acting on the input via onCommand(), these could also be very useful and are used to good effect in the demos with water droplets and colours.

At the moment it seems like the wallpaper is a bit of a memory hog and I’d like to find out why. Any suggestions are appreciated.
We think that the problem is in the BitmapFactory.decodeResources() function recreating the Bitmap every time. In order to get around this I think the best way would be to create a ’spriteSheet’ then move around the area of this big sheet masking it to only the area I need like one of those revolving wheels that show the horse running. Live and learn, I always wondered why people used sprite sheets in games programming I guess this must be one of the reasons.

As a side note, if anyone has any information on how The Nexus One splash screen is able to read in it’s splash screen consisting of 97pngs (/system/media/bootanimation.zip) I’d love to hear how they achieved this. When developing ideas for your Live Wallpapers consider trying to include the interaction of forces particular to the context of a mobile device such as time, movement and position.

Android SDK at time of writing was: android-sdk-mac_x86-2.1 ( SDK version 7 )

Citations & Research

• Really cute anime live wallpaper on google code
• Github: Demo of switching left and right
• Github: Demo of switching Animation on left/right
• Live Wallpaper anim demo APK for Nexus One

Annual since 1987, Mobile world congress is the world’s largest exhibition for the mobile industry and with 47,000 in attendance last year, it’s safe to say that it’s worth mobile companies showing face. Since there is so much happening that week it makes sense to plan well ahead of schedule. Everyone has been sharing lists of events and excited talk but no maps. So I thought it might be worth me throwing in my plans in the hope that someone may benefit from my timings, maps and event lists. These timings are in no way guaranteed as a good judge of how you should spend your time but could help make sure you’ve not missed anything really beneficial. Most of my time is going to be spent in App planet but I really want to try and get around as many exhibition stands as I can in my rare few minutes in between. Feel free to say hello to me if you are in attendance. You can catch me on MotoDev’s panel of Android developers on Monday at 11:30am Hall 7.

WIP have very kindly developed an MWC attendance survival guide which I very much recommend if not just for the Exhibition floor plan.

Mobile World Congress 2010 address
Event Details – http://www.mobileworldcongress.com

View Larger Map

Sim Cards

To obtain a prepaid Spanish sim with 3G Internet I’ve been recommended Yoigo. You need photo ID and the address of your hotel to sign up. Remember to get itit on any day other than Sunday and shops close around 2pm to 4pm:

View Larger Map

Monday

09:00 – MotoDev – Breakfast at Motodev in AppPlanet – Hall 7
11:30 – MotoDev – Android Developer Panel – Hall 7
11:30 – MotoDev – Maximise your Android Market Opportunity – App Planet – Hall 7
12:15 – MotoDev – Lunch with the experts – App Planet – Hall 7
14:00 – Mobile premier awards – Palau De La Música 4 08003 Barcelona, Spain 932 957 200
21:00> – Mobile premier awards dinner – Bel-Luna Jazz Club & Restaurant

MotoDev

More MotoDev event details…
Not much has been mentioned in the Android pres about the motodev sessions but I for one am interested in the opinions of anyone developing plugins for my IDE. They have a bunch of sessions planned at MWC a few of which I’ll be attending.

Mobile Premier awards

View event details
To get to the mobile premier awards take the Espanya tube to Urquinaona then walk straight down the road: Carrer de les Jon que res

View Larger Map

Mobile premier awards dinner

RSVP for the dinner here
A swanky affair after the award ceremony which promises to be both an interesting and beautiful meal.

View Larger Map

Tuesday

08:30 – Opportunities with on-device payments and preloaded content – Tanla MWC Seminar
08:00 – UKTI – Challenges in Japan – Location Sala D
11:30 – UKTI – Turkish / UK Partnering Event – UKTI stand?
17:00 – Scottish Development International – Whisky Reception – Stand, 1E66
18:00 – GoMo – Incognito BAR, calle Fusina 6, 08003 Barcelona, Spain
18:00 – Androiders Dinner at MWC

The Tuesday looks like it will be quite businessy until the evening where a bunch of Androiders will be getting together informally to chat and get dinner. So there is no official page or anything like that, just turn up or message someone who you know will be there(I’m @kevinmcdonagh) and we’ll be glad to have you in acquaintance. The plan is to prey on the hospitality of GoMo and turn up for their free bar and food. This plan should work win/win since a bunch of Android experts will be going to meet with mobile businessy people.

GoMo
Event details – http://www.facebook.com/#!/event.php?eid=180379714149&ref=ts
Here are some directions to get from Mobile World Congress to the GoMo event. I’ll be taking the Espanya Tube to Jamuel:

View Larger Map

Wednesday

08:30 - UKTI – UK / US Panel discussion – UKTI?
09:00 - Android dev lab (Games Dev) – Hall7 App world, MWC
12:30 - Sony Ericsson talk – App world Hall 7
14:00 - Tech crunch Mobile 2010
18:00> - Android cocktails – B Hotel in Gran Vía 389-391, Barcelona (next to MWC congress grounds)
18:30> - Swedish beers – Dostrece, carme 40, 08001, barcelona, Spain , 933017306
19:00> - Carnival of nations party – 7 Sins Bar, Muntaner 7, Barcelona, Spain

There is so much happening on the Wednesday sacrifices will have to be made. I’m really excited to get close to the participants of the Android developer session and get some basic questions out the way from the best in class. I do not currently plan to attend the Tech crunch event as I will instead be using the time to take part in Sony Ericsson’s training sessions. I’m also really looking forward to meeting the Barcelona user group at the Android Cocktails, I’ll have to split my time between this and Swedish beers which will inevitably be more businessy but essential.

Android Cocktails
Event details – http://eventuo.com/event/HN9foG5u6NI
An informal get together with the Barcelona Androids located beside MWC in the Nuñez i Navarro B Hotel

View Larger Map

Swedish Beers
Event Details – http://swedishbeers.blogspot.com/
A small scale yet still international event for businesses interested in mobile.
To Swedish Beers from the Android Cocktails event take the Espanya metro to Liceu:

View Larger Map

WIP Carnival of Nations party
Event Details – http://wipjam.com/party-carnival-of-nations/
In the unlikely event that I’ll have time to get to the Carnival of Nations event it is only 10mins walking distance away: Walking round the corner 10min away:

View Larger Map

Thursday

08:00 - GetJar Demo – App Planet Auditorium, Hall 7, FIRA, Barcelona, Spain
9ish -  WIP Jam – App Planet Auditorium, Hall 7, FIRA, Barcelona, Spain
11:45 – Join people Luncheoning form WIP – Hall 7
15:30 – More WIP Networking type interaction – Hall 7
18:00> Londroid – London Android Meetup

I’m obviously going to give the London Android Meeting a miss this time and instead I’ll be trying to make new WIP friends. Thankfully I can spend the whole day in the same place so no need for running to different locations.

Community Calendar

The closest thing a a community calendar in the Android world is the one started by a bunch of blogger sites including androidguys and anddroidandme
To subscribe to the community maintained Android global events calendar see here:
http://www.google.com/calendar/embed?src=g72pef2iiuu28hmedcnce5h0u4%40group.calendar.google.com&ctz=Europe%2FLondon&gsessionid=ycdhn2eV3gvznWmB8IIIlQ

Upcoming Android Related Events

Mobile World Congress (MWC), Barcelona
15 – 18th Feb
€599 – €4,999
http://www.mobileworldcongress.com
The world’s largest mobile event

Google IO, San francisco
May 19th & 20th
$400/$500/ student $100
http://code.google.com/events/io/2010/
Google’s annual global get together.

Londroid – The London Android meetup
Monthly, free
http://www.meetup.com/android
http://www.londroid.co.uk
Skillsmatter London
- Jan21, Feb18, Mar18, Apr22, May20, Jun17
Our fave monthy meeting. Very much recommended.

GeoMob
Monthly meetings, London 21Jan
http://gmdlondon.ning.com/

Droidcon Berlin, Nov? TBD £100
Droidcon London, Dec? TBD £100
Last year’s explicitly Android themed conference events. Dates will likely be announced within a few months.
http://www.droidcon.de/

Android Meetup Barcelona
16Feb (while MWC)
http://eventuo.com/of/barcelona-androides
A month;y get together in Barcelona. We’ll be attending the one held during MWC.

Android Stammtisch Berlin, C-base
http://www.android-in-berlin.de/
Jan 27, Feb 24
The monthly meetup held in Berlin’s excellent C-base hackspace.

JavaUserGroup
Monthly
http://jroller.com/javawug/

Chigago Android eco-challenge hacakthon
Feb 6th, $1
http://chigtug6.eventbrite.com/

Mobile Monday London
Monthly meetings
http://momolo.org/

FosDem, Brussels Belgium
6-7th Feb
http://fosdem.org/2010/

AppJam
http://www.meetup.com/App-Jam/

Mobile Geeks of London
Monthly meetup
facebook group

CTIA Wireless, Las vegas
March 23-25
http://www.ctiawireless.com/

WhereCampEU
March 12,13th
London
http://wherecamp.eu/

Podcasts

Androidguys – http://www.blogtalkradio.com/androidguys
Motodev – http://www.blogtalkradio.com/motodev
The Java Posse – http://javaposse.com/

Community hotspots

IRC – irc.freenode.net  – #android, #android-dev
The most active community channel for developers just generally getting together and chatting has been the IRC chat room from Android’s conception. A regular haunt for the members of Google’s Android team this chatroom is a the closest thing to a point of contact with the Android team.

Sites

Android neighbourhood – http://okmijnt.appspot.com/ – The AndroidNeighbourhood was started as an extension to the official android site listing all of the upcoming worldwide Android events.
Android and Me – Popular Android enthusiast website with good periodicals and reporting
planetandroid.com – The big daddy Android aggregator. If you watch one site for Android news, watch this one.
anddev.org – This forum has remained one of the most active communities in enthusiast Android development since the early betas
android-devices.net - nice source for upcoming Android devices.
androidbloke.co.uk – UK based news source
androidguys.com – A popular community for android developers and enthusiasts alike
Open intents Group – The chat group for Open intents

Projects

The most important open source projects are undoubtedly:
Open intents -  Open intents is a project to publically declare agreed standards for intents outside Google. The source repo for open intent projects is here: http://code.google.com/p/openintents/
and the open intents registry – http://www.openintents.org/en/intentstable ,
Open Android Alliance – http://code.google.com/p/open-android-alliance/

Although there has been very little movement from the open android alliance, open intents are very active.
Some notable other libraries that which we believe are useful:

Android – source.android.com
Commonsware – Lot of very interesting and useful Android projects including code for caching, tutorials and helpful Adapters.
Droid-fu – A utility library for your daily Android needs
Calculon – Story based functional tests
Angle – an open GL game engine
Live Android – An Android Live OS CD for x86
Android x86 project – x86 ports
Android on Github – Mirror of Android repo
Phone Gap – Take advantage of platform specific features through a generic Javascript API

Signpost – A light-weight client-side OAuth library for Java
RESTProvider - Automatically parses RESTful API responses into a Provider in Android
Maven-android-plugin maven build plugin for android, useful for continuous integration.
OAuth dashboard / providers – An OAuth Library/application for Android. Acts as a dashboard for users permissions that they have allowed/dissalowed to applications and for developers gives them an easy way to securely authenticate using a thirdparty android OAuth implementation.

Busybox – See here for how to install on Android. Adds chown, chgrp, awk, sed, grep, du, vi, pidof, less, tail, gunzip, gzip, tar, bzip2, clear, crontab, crond, diff, httpd, telnet, xargs, su, wget, which
DoomForAndroid – http://code.google.com/p/doom-for-android/ – Doom
androidscreencast – http://code.google.com/p/androidscreencast/ – Control an android device remotely

Twitter

Most popular twits: http://wefollow.com/twitter/android
A list of Android related people I think are worth following on twitter here: http://twitter.com/kevinmcdonagh/droids/members

The Scala Programming Language:

The Scala programming Language is an object oriented functional programming language designed to run on the JVM. It is ideal for programming on the Dalvik Platform as code written with the Scala language is more compact, readable and could possibly have performance benefits (which will be analysed at a later date) and it also supports Java and Android APIs.

You can easily build DSL with Scala and the trait (e.g. mixin) aspect of Scala is very attractive in order to build intricate activities which mixes different logic.

Requirements:

• Eclipse IDE – Galileo Classic v3.6
• Android ADT plugin v0.93
• Android SDK v1.6r1
• Scala eclipse plug-in latest
• Scala-android library latest

In order to create our first Scala project we go about creating first an Android Project in the Eclipse IDE (File->New->Android Project).

Google IO 2009 was held in sunny San Francisco and Novoda’s presence acted as a technical bridge for the Royal Veterinary College, London Knowledge Lab and the wider Bloomsbury Colleges as they further explored Google’s Android platform as a potential tool for the collection of medical & veterinary data. As I was acting on behalf of Academia the trip was very kindly funded by JISC, so a big thank you to them.

Google event’s are renowned for merging developers’ unique personalities with the approachable yet cutting edge image of Google technology. There were brightly coloured bean bags, qr-code scavenger hunts, make shift Google street view holo-chambers, arcade cabinets and robot wars but they were all in aid of furthering the interaction of developers and getting them conversing on areas of tech. As if the fact that all the attendees received free G2 HTC magic phones was not reason enough for conversation.

Talks

The talks were generally of a very high standard with a whole section dedicated to each Google interest  including mobile (Android). Outside of each speaking area was an alcove where Google advocates were freely available for questioning on the intricacies of each specific technology. Each recorded session lasts about an hour so specifically, I recommend watching the following:

Writing Real-Time Games for Android w/ Chris Pruett is well delivered with captivating game development content. Chris considers the resource usage on Android from the perspective of a developer used to a similarly constrained C++ mobile environment.

Android media framework w/ David Sparks contains good graphical representations of media call life cycles from the native system upwards and addresses the techniques while dealing with all forms of media.

Coding for Life — battery life, that is w/ Jeffrey Sharkey offers a primer on how to be mindful of your applications specific actions how they are affecting a device’s power consumption.

Supporting Multiple Devices with One Binary w/ Joe Onorato & Romain guy addresses the problem of standarising the presentation of a UI of multiple ‘densities’ on different devices.

Although not based on Android, another talk which is well worth mentioning was the second day’s big topic of conversation ‘Google wave’ which it has to be said is an exciting convergence in persisted communications.

Attendees & Exhibitors

It was difficult choosing to not attend talks and venturing away from the Android alcove but there were some worthwhile exhibitors.

EA consistently sets a high technical standard on all platforms and the same can be said about their android offerings, Sim city, The Sims, Tetris and Monopoly. Close by them was the extremely nice Spotify (premium content) app which sports intuitive & innovative UI design. Each of the bottom tabs can be slid upwards to reveal a more detailed selection of options within that tab’s context which is a nice touch on an already very usable app.

Mobile media company 1Cast were showing off thier app’s streaming capabilities and the fact that it can search through a huge catalogue of their partners premium content. The very snappy responsiveness signals a mobile media viewing experience which is slowly entering the big leagues.

Swedish Game development company Illusion Labs had their games on show including my personal fave ‘Labyrinth’. Labyrinth works the same as the traditional wooden games but the real charm of this particular port is that it provides such pleasant tactile feedback whenever your metal ball hits against the sides of the wooden box. The subtle feedback makes this an exemplar experience for tactile interaction within mobile games.

Catalista also had a very nice location aware application which allows user to find nearby volunteering opportunities.

Some guys from Tubaloo demonstrated a personalised VoIP build of android which they are planning to soon offer the Latin American market. The threat of VoIP to traditional phone services has been looming on the horizon and we’ve recently seen some movement from Skype onto cellphones but could this signal the start of competition in this market?

Also worth a notable mention even though they weren’t technically exhibiting was the Czech Republic based company Inmite who impressed me with both their development knowledge and their popular ‘Lokola’ application which finds searches through the online portal’s directory of resources relative to the device’s global positioning.

Post Google IO

Eager to network with universities, I was surprised to speak with very few groups doing exploratory research on Google Android especially since I encountered such wide acknowledgment of it’s potential in this area. There were the notable exception of San Francisco State University who are just beginning to look into the possibilities of mobile applications within their current work in blood & disease analysis. Hopefully we can soon establish some talks between them and RVC to exchange experiences. If you yourself know of universities working on with the Android platform then please do contact us!

I was lucky enough to spend some time with the developers from the well intentioned ODK project who are developing free tools to aid the collection of standard data by providing an easy click through forms interface. They wished to emphasize their eagerness to receive participation and feedback which I hopefully helped them with by suggesting some commercial and academic use cases.

Some of  the world’s largest media networks for games, music and television were at Google IO to show off their polished offerings to a standard which has until recently has been reserved for the IPhone. This is encouraging because as industry draws attention to the platform, media companies will invest in the relevant training and as a by product we should hopefully see an explosion of free and organisational offerings. ADC2 itself would usually have had entrepreneurial developers inquiring into Google’s offered cash prize but team this with the fact they have given free devices to their most loyal developer audience ensures that there will soon be fresh activity hitting the Android market.

Android SDK at time of writing was: 1.5_r2

Citations & Research

• Google IO logo sourced from cvander’s Flickr account

X represents the ‘Azimuth’ which is the angle in current reference to Magnetic North. The units of measure are within 0-360 degrees imagining a complete rotation divided by 360 equal divisions. This is easiest interpretted by considering the device from a birds eye view and considering that this is the same response as you would expect from a compass.

Y or ‘Pitch’ is the degree to which the device is tilted forwards or backwards. The measure of pitch is zero when the device is lying flat, -90 when standing upright and 180 when lying flat on the device face. Realising that -90 is the value of the device upstanding and 90 being the value when it is upside down is initially confusing until you think about the aviation analogy. If a plane’s nose is dipping and the plane is losing height a pilot would pull upwards. The upwards values represent the increase in height as the pilot pulled back on the joystick. Using this analogy, holding the device and pulling backwards would increase the height and pushing forwards would decrease the height.

Z or ‘Roll’ is the rotation of the device in relation to the bottom left hand corner of the screen. The units returned represent the degree of change in degrees from 0 – +/-90. Zero is when the device is upright standing and forward facing. Any movement left or right will then increase or decrease to 90 or -90 and on to 0 when going past these values. Each quadrant within the clock face of rotation will progress 0 – 90. During flight a plane’s wings would ideally be aligned with the horizon and the cockpit would be upright at 90 degrees.

Initially dealing with data in this format can be a bit dis-orientating so if you only want to get the angle of the phone moving from an initial upright standing position use the OrientationEventListener. Otherwise the values returned form the SensorEventListener are the Y & Z representing the 0 – 90 degrees of rotation while the angle is passing through a certain quadrant within a full clock face of rotation while X units are returned in relation to Magnetic North.

The OrientationEventListener

The OrientationEventListener provides a much easier solution to detecting the phone’s current angle when you only need the angle of change from upright standing to left/right and around a clock face of rotation. Implementing this interface will enable you to access orientation as a simple int representing the rotation in degrees.

Rather than have you feel the pain of trying to make sense of Android Sensor data from scratch we’ve made a quick printable cheat sheet, so puzzle no more!

SensorEventListener cheatsheet

Android SDK at time of writing was: android-sdk-mac_x86-1.5

Citations & Research

• Flight Dynamics on Wikipedia
• Teach yourself Trigonometry
• Android API: Sensor Event Listener

Latest emulator with on-screen keyboard

‘Cupcake’ is the name of the new Android OS which will shortly hit the consumer market.  Future Android based phones – such as Lenovo or Kogan agora – will by default probably have the CupCake milestone of the OS installed. This new version carries with it, bug fixes and a couple of enhancements such as video recorder and on-screen keyboard.

There are times when your application’s future compatibility testing cannot wait for an official milestone release and you require the very latest  development image of the Android OS to run under the latest Android emulator. There are of course other Android enthusiasts like myself who will find it very exciting to download and play with the source and I’d recommend it, as it is not difficult.  In this article I will detail my experience of following the official android documentation to obtain the latest source from the main Android development branch, in this case the contents of CupCake; compiling it and then finally running the images under the latest emulator.
Development Environment

Manually building the source code is system intensive so you should have a good machine in order to compile the project, enough disk space (around 6GB) and a good connection as you will download around 2GB. Currently, I am running Ubuntu intrepid 8.10 with kernel 2.6.27-11-generic and Sun’s jvm 1.6 on a quad core with 4GB of RAM.
Thus the below assumes you are running similar setup. The official Android installation page lists the procedure for Max OS and Windows.

1. Obtaining the code

I followed the Google documentation wiki page without any problems. I had a previous version of the source code checked out on to my machine which I had to update, thus I had to remove the recovery directory as discussed here and here with the following command: rm -rf recovery bootloader

If you do a fresh init you will not need to remove the 2 directories. As I am on amd64, I also had to install the X11 dev packages and followed the workaround suggested for X11.

Note that I did not need to update the java alternative to ia32-sun-java6-bin and used the sun-java6-jdk instead. Furthermore, I did not need to point ANDROID_JAVA_HOME to my JAVA_HOME variable.

2. Compilation

WIth the source code checked out I now made a compilation with ‘make’. The compilation took some time – around an hour on my quad core – enough time to drink a couple of espressos and poke around the source structure. A successful compilation produced a new directory at the root of the source called ‘out’. This directory contained the newly created build which can then be used to start the emulator.

3. Layering on proprietary libs from the G1 – optional

Specific phone manufacturers commonly bundle their own libraries for specific phones. Usually those libraries are proprietary thus need to be downloaded from the phone itself. For now, this is possible only for the G1 as this wiki page indicates. Note that I used my T-mobile phone, not the dev one.

Running ‘make’ will create a specific build for the phone located under ‘<android_source>/out/target/product/dream’. You can run that build within the emulator which would be specific to the HTC dream. I would not anticipate much difference except that you would not have access to specific proprietary hardware powered devices such as the camera phone.

4. Starting the emulator with the new build

Now with a fresh build, I could start the emulator with the new images.
Issued from the root of source, the following command started the emulator with the dream’s image:

./out/host/linux-x86/bin/emulator
 -system out/target/product/dream
-kernel prebuilt/android-arm/kernel/kernel-qemu
-data out/target/product/dream/userdata.img

If you have followed me this far but did not compile the dream target, you can run the default images as follow:

./out/host/linux-x86/bin/emulator
-system out/target/product/default
-kernel prebuilt/android-arm/kernel/kernel-qemu
-data out/target/product/default/userdata.img

Voila! I had the latest emulator running! I accessed it using ‘adb shell’ and installed my test applications using: adb install <app>.apk
Stumbling a little is to be expected with any new undertaking but I found the solution to the majority of your average source compilation problems can be found within the or on the well tended official source code documention. Otherwise Google Groups hosts’ an active android mailing list who will try their best to answer questions.

Next I will look into setting up eclipse and maybe playing around with the code if my caffeine level stays high enough.

Citations & Research

• Instructions on how to build for the HTC Dream
• Google android news group
• Source Docs
• bootloader folder removal problems upon checkout
• Known Google Android Issues