The Auction
In case you missed it, Google officially announced today that we'll be applying to participate in the upcoming 700 megahertz spectrum auction. You can read more about it on the Official Google Blog. As Chris notes, we'll be obligated to remain silent on this for awhile -- just so you know.
A Maze of Twisty Little Passages
The end of last week was Thanksgiving in the US, the tradition is to be with family, eat too much food and watch football (not necessarily in that order).
Apparently some folks took the chance to work on Android projects too. We are highlighting a few of the projects that caught our eye.
One of the coming of age rituals of any new platform is the porting of the Z-machine – the interpreter used in the Zork series of games from Infocom. Now Android has the Z-machine thanks to sussman and mariusm. The project, called Twisty, is available on Google code hosting. Thanks for the lost productivity you guys.
Testing is also a hot topic on our Google groups. While JUnit is bundled with the Android SDK to make it possible to do unit testing, there are many other kinds of testing, like automated acceptance testing. Positron builds on the Android instrumentation features from the SDK to make automated acceptance testing of Android applications possible. The author, phil.h.smith, has a pretty good introduction on how to use Positron as well.
Plugins for other IDEs are another favorite on the Android Google groups. While there are only rumblings about a NetBeans plugin at present, the idea-android project already has an early release for IntelliJ IDEA thanks to aefimov.box and intelliyole.
Dion Almaer also picked up on a crossover GWT/Android project which looks pretty amazing too. Chronoscope is an open source charting and visualization library written in GWT. The team were able to take the library, and with 8 hours of playing with Android, had a port to the Android platform.
Of course, there are many more Android projects springing up all the time, as a search of the android label on Google code hosting will demonstrate. It's great to see all this activity just a couple of weeks after the SDK was released.
New magical blue circle on your map
We've all been there: You're out and about, and you need to figure out where you are, what's around you, and how to get there. Google Maps for mobile can help you do all that, but first you have to enter in a starting point using the keypad. And let's face it -- entering things into your phone using the keypad is so 2006. While some people are lucky enough to have GPS-enabled mobile phones that provide location information for Google Maps for mobile, the vast majority of us are not. So what to do?
Starting today, we have an answer: Google Maps for mobile with My Location . My Location is a new beta technology from Google that uses cell tower identification to provide you with approximate location information, so it will work on phones without GPS. Simply fire up Google Maps for mobile, press [0], and the map will indicate your approximate location by centering on a blue circle like this:
If you do have a GPS-enabled device, My Location can actually complement it. My Location kicks in faster than GPS in most cases, so you can access your location even faster on the map. It also works reliably indoors (unlike GPS) and doesn't drain your phone battery at the rate that GPS does.
Of course, this feature is in beta, which in this case means a few different things: First, although accuracy and coverage may vary, both will improve over time as more and more people use Google Maps for mobile. Second, My Location isn't currently supported on all devices (see our Help Center for more on this); we're working on that. Third, we'd love to get your feedback on it -- feel free to leave your comments below.
To give Google Maps for mobile with My Location a try, text "MYLOCATION" to 33669, or head to www.google.com/gmm on your mobile browser.
If you'd like to learn more about the My Location technology, take a look at this short video:
We're open for business
Welcome to the new Google mobile blog. We hope this will be your first stop for the latest news and views from our global team that has been working to bring you innovative mobile products for awhile, now.
Through this blog, we plan to share with you over time more on what we're up to, who we are, and what we think is going on in this dynamic industry. We'll have plenty of product launches, features, and tips to tell you about. We also hope to introduce you to some of our partners and some of our users along with the applications they love. Additionally, we plan to offer up comments on trends in the industry and even an occasional take on non-Google products we feel are particularly noteworthy.
Earlier this month we launched Android, one of our most ambitious mobile initiatives to date. While Android is an important part of our mobile strategy, so too is our goal of developing useful and compelling mobile products for our current and future users, devices, platforms, and partners. As always, you can find out more about our full suite of Google mobile products at mobile.google.com.
Finally, we're very interested in reading what you have to say so we invite you to submit comments below pertinent blog posts. We'll do what we can to respond; feel free to respond to each other as well. For specific questions on Google mobile products, please visit our discussion group and submit them there.
A Stitch in Time
Background: While developing my first useful (though small) application for Android, which was a port of an existing utility I use when podcasting, I needed a way of updating a clock displayed on the UI at regular intervals, but in a lightweight and CPU efficient way.
Problem: In the original application I used java.util.Timer to update the clock, but that class is not such a good choice on Android. Using a Timer introduces a new thread into the application for a relatively minor reason. Thinking in terms of mobile applications often means re-considering choices that you might make differently for a desktop application with relatively richer resources at its disposal. We would like to find a more efficient way of updating that clock.
The Application: The rest of the story of porting the application will be detailed in future blog entries, but if you are interested in the application in question and the construction of it, you can read about it in a not-so-recent Developer.com article about using Matisse (a GUI builder for Swing). The original application is a Java Swing and SE application. It is like a stopwatch with a lap timer that we use when recording podcasts; when you start the recording, you start the stopwatch. Then for every mistake that someone makes, you hit the flub button. At the end you can save out the bookmarked mistakes which can be loaded into the wonderful Audacity audio editor as a labels track. You can then see where all of the mistakes are in the recording and edit them out.
The article describing it is: http://www.developer.com/java/ent/print.php/3589961
In the original version, the timer code looked like this:
class UpdateTimeTask extends TimerTask {
public void run() {
long millis = System.currentTimeMillis() - startTime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;
timeLabel.setText(String.format("%d:%02d", minutes, seconds));
}
}And in the event listener to start this update, the following Timer() instance is used:
if(startTime == 0L) {
startTime = evt.getWhen();
timer = new Timer();
timer.schedule(new UpdateTimeTask(), 100, 200);
}In particular, note the 100, 200 parameters. The first parameter means wait 100 ms before running the clock update task the first time. The second means repeat every 200ms after that, until stopped. 200 ms should not be too noticeable if the second resolution happens to fall close to or on the update. If the resolution was a second, you could find the clock sometimes not updating for close to 2 seconds, or possibly skipping a second in the counting, it would look odd).
When I ported the application to use the Android SDKs, this code actually compiled in Eclipse, but failed with a runtime error because the Timer() class was not available at runtime (fortunately, this was easy to figure out from the error messages). On a related note, the String.format method was also not available, so the eventual solution uses a quick hack to format the seconds nicely as you will see.
Fortunately, the role of Timer can be replaced by the android.os.Handler class, with a few tweaks. To set it up from an event listener:
private Handler mHandler = new Handler();
...
OnClickListener mStartListener = new OnClickListener() {
public void onClick(View v) {
if (mStartTime == 0L) {
mStartTime = System.currentTimeMillis();
mHandler.removeCallbacks(mUpdateTimeTask);
mHandler.postDelayed(mUpdateTimeTask, 100);
}
}
};
A couple of things to take note of here. First, the event doesn't have a .getWhen() method on it, which we handily used to set the start time for the timer. Instead, we grab the System.currentTimeMillis(). Also, the Handler.postDelayed() method only takes one time parameter, it doesn't have a "repeating" field. In this case we are saying to the Handler "call mUpdateTimeTask() after 100ms", a sort of fire and forget one time shot. We also remove any existing callbacks to the handler before adding the new handler, to make absolutely sure we don't get more callback events than we want.
But we want it to repeat, until we tell it to stop. To do this, just put another postDelayed at the tail of the mUpdateTimeTask run() method. Note also that Handler requires an implementation of Runnable, so we change mUpdateTimeTask to implement that rather than extending TimerTask. The new clock updater, with all these changes, looks like this:
private Runnable mUpdateTimeTask = new Runnable() {
public void run() {
final long start = mStartTime;
long millis = SystemClock.uptimeMillis() - start;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;
if (seconds < 10) {
mTimeLabel.setText("" + minutes + ":0" + seconds);
} else {
mTimeLabel.setText("" + minutes + ":" + seconds);
}
mHandler.postAtTime(this,
start + (((minutes * 60) + seconds + 1) * 1000));
}
};and can be defined as a class member field.
The if statement is just a way to make sure the label is set to 10:06 instead of 10:6 when the seconds modulo 60 are less than 10 (hopefully String.format() will eventually be available). At the end of the clock update, the task sets up another call to itself from the Handler, but instead of a hand-wavy 200ms before the update, we can schedule it to happen at a particular wall-clock time — the line: start + (((minutes * 60) + seconds + 1) * 1000) does this.
All we need now is a way to stop the timer when the stop button is pressed. Another button listener defined like this:
OnClickListener mStopListener = new OnClickListener() {
public void onClick(View v) {
mHandler.removeCallbacks(mUpdateTimeTask);
}
};will make sure that the next callback is removed when the stop button is pressed, thus interrupting the tail iteration.
Handler is actually a better choice than Timer for another reason too. The Handler runs the update code as a part of your main thread, avoiding the overhead of a second thread and also making for easy access to the View hierarchy used for the user interface. Just remember to keep such tasks small and light to avoid slowing down the user experience.
So that's it for the first of what will be a series of Android tips. Hopefully this will save you a little head scratching on what will probably be a fairly common thing to want to do (i.e. make something happen or update at regular intervals in a lightweight way in your application). There is plenty of more material from my experience of porting this very simple application which will be covered in some of the future "tips" articles. There are some other great tips being discussed as well as an opportunity ask questions at the Android Developers Discussion Group.
Android: the first week
Wow, what a week! The response from the community on Monday's Android SDK release has been overwhelming. Our forums have been flooded and we're glad to be helping people dig in writing new applications.
A handful of quick notes for this Friday evening:
- We've released a quick point-revision of the SDK to fix some high-priority issues. You can now download M3-RC22a and read the release notes. Don't forget to get Eclipse to update the ADT plugin.
- A couple of good articles on the web for your reading pleasure:
- A developer's perspective on Google's Android SDK
- Why Google chose the Apache Software License [sic] over GPLv2 for Android
- Google Calling: Inside Android, the gPhone SDK
- Finally, we've split our forums into topic areas to make them a bit easier to manage. Be sure to check out the details and join the discussion.
Have a great weekend, and happy Android coding.
Just show me the code
OK, you've downloaded the SDK and are now ready to build the next killer app for mobile (and maybe win some $$$ in the process ;)
Activities? Intents? SimpleCursorAdapter? Huh? Hmm...how do I proceed?
Well, that depends on your style. Some will want to carefully go through all the documentation top-to-bottom, while others may prefer to just dive right into code.
Either path will eventually lead to the sample applications provided in the SDK — these samples will be invaluable in your quest for Android mastery. The samples include:
- API Demos
- A 'kitchen sink' application that covers the most useful aspects and components of the Android APIs. You'll see different implementations of Activities, Services, Notifications, Layouts, as well as methods for working with graphics and text. This application provides a good source of templates for your projects as well as a reference to 'How do I do this?'-type questions.
- Lunar Lander
- A game which demonstrates how to load and draw graphics, animation techniques, taking user input, saving state when the user pauses the game, and more. Coding shouldn't be this fun!
- Note Pad
- You'll learn how to use Intents to open a new screen, access a local database, and more. This sample is a good introduction to application flow and life cycle management, which are vital in developing more complex applications.
Source code and resources for these applications are available in the SDK (samples/) as well as online: http://code.google.com/android/samples/
Here are some suggestions on what to do next:
- Read through each application's manifest file (AndroidManifest.xml) to learn about the typical structures in an Android application.
- Modify the code to familiarize yourself with the building and testing process.
- Use a particular code snippet as either a base template or to get some needed functionality for your own project (why reinvent the wheel?)
Put these sample applications through their paces; and if you get stuck, please post your questions to the Android Developers Discussion Group.
This is the droid you're looking for
Following last week's announcement of the Open Handset Alliance, today we're happy to offer an early look at the Android SDK. We're eager to get feedback from lots of developers in our discussion group. We're also providing developer documentation and this blog to help you get up and going.
You're probably wondering about what's available today. This preview of the SDK will allow you to develop Android applications that you can run, test, profile, and debug using the emulator and the other included tools. Note that the look and feel of the user interface in the emulator is a placeholder for a final version that is under development.
One of our goals in releasing the Android SDK is to unleash the creativity of application developers on the platform. We'd also like to get feedback early enough that we can make changes before the first Android-powered devices are available to the public. We plan to release updates to the SDK regularly which means that there will be additions and changes to the APIs and user experience — subscribe to this blog to stay up to date.
We're really looking forward to seeing all the amazing applications that developers will create on an open mobile phone platform. In fact, you may even want to enter your application into the Android Developer Challenge — a USD$10 million challenge sponsored by Google to support and recognize developers who build great applications for the Android platform.
Subscribe to:
Posts (Atom)