Friday, June 4, 2010

[Gd] Google Hackfest and Reception at RailsConf

| More

Google Code Blog: Google Hackfest and Reception at RailsConf

Many of the developer and enterprise products presented at Google I/O are of great interest to the Rails Community. We know developers attending RailsConf are ready to roll up their sleeves to start hacking, so Google is hosting a hackfest and reception at the Renaissance Baltimore Harborplace Hotel in Maryland DF (5th Floor). The event will be on June 9th from 7:00pm to 11:30pm, and of course we'll have food, beer and swag. Space is limited, so please register now, we'll send out an email when your registration has been confirmed.

Steven Bazyl will be helping folks integrate their existing Rails apps into Google Apps Marketplace using OpenID, OAuth, and the Google Data APIs. The Google Apps Marketplace offers products and services designed for Google users, including installable apps that integrate with Google Apps.

Ryan Brown and John Woodell will be getting folks setup with Duby or JRuby on App Engine, and David Masover will be helping folks with the DataMapper adapter. Google App Engine enables developers to build and host web apps on the same systems that power Google applications. JVM languages like Duby and JRuby operate on App Engine for Java.

Seth Ladd will be available to talk about the Chrome Web Store. The Chrome Web Store a very easy way to distribute and monetize apps written in HTML, HTML5, or even Flash. The Chrome Web Store is a perfect way to market and distribute your Rails application, run that app on any platform or device (mobile or desktop), sign up users, and make money.

Seth will also be running two surveys at the conference, and would love your feedback on HTML5 and the Chrome Web Store. These in-person surveys are to help him gauge developer interest and knowledge in these technologies. To entice participants, he will have lots of t-shirts on hand to give away to attendees at the conference who participates in the survey. Look for him while at the conference, let him know your thoughts, and collect your t-shirt (while supplies last).

RailsConf attendees that sign up for the hackfest by June 8th, can request a Google Storage account to use at the hackfest. Google Storage for Developers a RESTful service for storing and accessing your data on Google's infrastructure. The service combines the performance and scalability of Google's cloud with advanced security and sharing capabilities.

We're looking forward to the great talks and to meeting lots of developers. Can't wait to do some coding with you at RailsConf 2010!

By Seth Ladd, Chrome Developer Relations Team

[Gd] Tech Talks and Fireside Chats at I/O 2010

| More

Google Code Blog: Tech Talks and Fireside Chats at I/O 2010

Today we’re releasing videos from the Tech Talks and Fireside Chats at I/O 2010. A look back on each track:

Tech Talks:

From new programming languages to venture capital to 5-minute lightning talks, the Tech Talks track at I/O was a veritable potpourri of geeky goodness.

You can find videos and slides for the Tech Talks on the linked session titles below:

  • Go programming - The Go programming language was released as an open source project in late 2009. Rob Pike and Russ Cox discussed how programming in Go differs from other languages.

  • Opening up Closure Library - Closure Library is the open-source JavaScript library behind some of Google's big web apps like Gmail and Google Docs. Nathan Naze talked about the library, its design, and how to integrate it in with your setup.

  • Optimize every bit of your site serving & web pages with Page Speed - Richard Rabbat and Bryan McQuade talked about Page Speed, an open-source Firefox/Firebug Add-on which allows web developers to evaluate and improve the performance of their web pages.

  • SEO site advice from the experts - Matt Cutts, Greg Grothaus, Tiffany Lane, and Vanessa Fox offered SEO feedback on a number of actual websites submitted by the audience.

  • Beyond design: Creating positive user experiences - John Zeratsky and Matt Shobe shared their tips on how to keep users coming back to your applications through a positive user experience.

  • How to lose friends and alienate people: The joys of engineering leadership - Brian Fitzpatrick and Ben Collins-Sussman regaled the audience with tips on how to lead vs. manage.

  • Ignite Google I/O - Brady Forrest and Ignite returned to I/O with an awesome line-up of speakers - Ben Huh, Matt Harding, Clay Johnson, Bradley Vickers, Aaron Koblin, Michael Van Riper, Anne Veling, and James Young.

  • Technology, innovation, computer science, & more: A VC panel - This year was the first time that we had investors/VCs speaking at I/O. Albert Wenger, Chris Dixon, Dave McClure, Paul Graham, Brad Feld, and Dick Costolo (moderator) debated hot tech topics including betting on start-ups with non-technical founders and open vs closed platforms.
The Tech Talk videos are also available in this YouTube playlist.

Fireside Chats:

In the 9 fireside chats at I/O this year, Google teams were eager to talk about the latest ongoings with their respective product areas, as well as spend most of the time on audience Q&A.

This year, we decided to record fireside chats because we know how popular they are not just with I/O attendees, but everyone interested in hearing from the engineers behind our products. You can find videos for the fireside chats below:

These videos can also be found in this Fireside Chats YouTube playlist or the YouTube playlist for each session track. (ex. the two Android Fireside Chats are also in the Android playlist)

On Monday, we’ll be posting the last batch of I/O videos from the Geo, Google APIs, and Google Wave tracks. Stay tuned!

Posted by Christine Tsai, Google I/O Team

[Gd] Google Chrome’s Developer Tools Improve Productivity

| More

Chromium Blog: Google Chrome’s Developer Tools Improve Productivity

At Google I/O 2010 we presented on Google Chrome’s Developer Tools and enjoyed getting the in-person feedback from developers. We wanted to list some of the new and improved features we presented at I/O that set apart our tools in helping developers become more productive.
  • The Scripts panel now allows editing JavaScript without having to reload the page. Just double-click on the line in the function body while debugging and make your changes. We’ll patch the underlying optimized machine code at run-time and continue the execution. [video]
  • CPU profiler captures the state of your app at a rate of 1,000 samples per second without modifications to the running optimized machine code. The resulting tree view makes it easy to find out where to focus efforts on speeding up the web app. [video]
  • The new Timeline panel provides a simple view of the AJAX application execution. It records everything that happens in the browser from JavaScript execution to styles re-calculations and then visualizes it in a simple waterfall with timing information and traces to the source code. See the demo fragment at [video].
  • The improved Heap profiler can take snapshots of the JavaScript heap, visualize and compare them. This makes finding and fighting memory leaks a much easier task. See the demo fragment at [video].
We also covered a number of general Inspector improvements in the WebKit blog recently. Watch them live in the DevTools panel walk through from the I/O video.

We welcome feedback: to submit a bug or feature request please use the Chromium issue tracker and mention DevTools in the summary.

We hope you like the new improved Google Chrome Developer Tools. Note that some of the features above are only available on Google Chrome’s Dev Channel at this moment. For more info please check out the DevTools site.

Posted by Pavel Feldman, Software Engineer

Thursday, June 3, 2010

[Gd] Google Chrome at Google I/O 2010

| More

Google Code Blog: Google Chrome at Google I/O 2010

We kicked off Day 1 of Google I/O this year by highlighting the progress of the web platform.

The Day 1 keynote included a number of exciting announcements and demos from the Chrome Team. To demonstrate the power of building with HTML5, Sundar Pichai invited on stage a number of Chrome partners, including Clicker who demonstrated the power of video and highlighted one of the big open questions for the web: the need for a freely available, high quality video codec for the tag. With the support of Mozilla, Opera, and Adobe, we announced the launch of the WebM Project, which makes a high quality video codec freely available to everyone.

We also announced the upcoming Chrome Web Store, which will launch later this year to help make great web applications more discoverable. We showed how rich web apps and content like Sports Illustrated will be discovered, launched, and even purchased from the Web Store when it launches later this year.

In addition to our keynote announcements, the Chrome Team also led a number of sessions throughout both days of the conference, focusing on Chrome, HTML5, and the web as a platform.

Here’s a recap of what was covered in our sessions:
  • Beyond JavaScript: programming the web with native code - Although JavaScript performance is rapidly increasing, there are still applications for which native code is a better choice. Learn about Native Client and how you can use it to build rich applications with all of the advantages and power of the web.
  • Chrome Extensions - how-to - Google Chrome shipped an extensions API in version 4.0. Since last year, new capabilites have been added to the extensions framework, and many people have already written powerful extensions with minimal effort. Find out how to write an extension, and what's coming next in Chrome Extensions.
  • HTML5 status update - Where is HTML5 today? What new features are now broadly supported, what features are on the horizon, and what features are on the chopping block? How do we decide what to implement, what to propose, and what to drop? Find out.
  • Developing web apps for the Chrome Web Store - Google Chrome is a powerful platform for developing web apps. With Chrome web apps, we're making it easier for users to discover and use these apps. Learn how to build and sell apps for the Chrome Web Store.
  • WebM Open Video Playback in HTML5 - The new open VP8 codec and WebM file format present exciting opportunities for innovation in HTML5 . In this session, you'll see WebM playback in action while YouTube and Brightcove engineers show you how to support the format in your own HTML5 site.
  • Google Chrome's Developer Tools - In this session we'll give an overview of Developer Tools for Google Chrome that is a part of the standard Chrome distribution. Chrome Developer Tools allow inspecting, debugging and tuning the web applications and many more. In addition to this overview we would like to share some implementation details of the Developer Tools features and call for your contribution.
  • Developing With HTML5 - This session covers the HTML5 APIs available to Google Chrome and Google Chrome OS applications and Google Chrome extensions. Learn how to design web applications for a Google Chrome OS netbook using the latest web technologies.
  • Using Google Chrome Frame - Google Chrome Frame brings the HTML5 platform and fast Javascript performance to IE6, 7 & 8. This session will cover the latest on Google Chrome Frame, what it can do for you and your customers, how it can be used, and a sneak peak into what's planned next.

In case you couldn’t attend in-person, all the links above include videos and slides from each session. You can also find all the Chrome session videos on this YouTube playlist. Thanks to everyone who showed up this year and made Google I/O such a great event.

By Ian Fette, Google Chrome Team

[Gd] The Social Web at Google I/O 2010

| More

Google Code Blog: The Social Web at Google I/O 2010

Google I/O attendees and speakers this year had the opportunity to participate in some fascinating and important conversations around the social web. The Developer Sandbox featured 16 companies on hand to talk about their social efforts, including Atlassian, eBay, IBM, LinkedIn, MySpace, Ning, Plaxo, Playfish, Yahoo!, and Voxeo.

In addition, nine sessions on social topics took place during the 2-day conference -- dealing with everything from real-time streams to OpenSocial in the enterprise. Of particular emphasis were open standards such as ActivityStreams, PubSubHubbub, OAuth, Salmon, and Webfinger that are fast becoming the foundational technologies for a more open and social web. The Google Buzz API was announced and covered in detail. And, of course, a deep look was taken at the future of the social web.

This is a big year for the social web, and we hope that the videos and slides from each session will expand your knowledge of and engagement with these exciting ideas and technologies:

  • What's the hubbub about Google Buzz APIs? - Chris Chabot introduces the Google Buzz API and provides a deep dive on the open standards it uses such as ActivityStreams, PubSubHubbub, OAuth, Salmon, and WebFinger, and demonstrates how to build your own apps on top of the API.
  • iGoogle developer portal and tools - The iGoogle Gadget Dashboard and the OpenSocial Development Environment are introduced by Shih-chia Cheng and Albert Cheng to help you build and maintain better OpenSocial gadgets for iGoogle.
  • Make your application real-time with PubSubHubbub - Atom and RSS feeds are even more valuable when they’re pushed to subscribers in real-time. In this session, Brett Slatkin (Google) and Julien Genestoux (Superfeedr) show you how to implement PubSubHubbub for better stream publishing and consumption.
  • The open & social web - Chris Messina uses a carton narrative to tell the epic story of Jack and Kate, explaining how immigration, staying in touch, and sharing rich media relate to emerging technologies like OpenID, WebFinger, and publishing technologies like PubSubHubbub, ActivityStreams, and Salmon.
  • Bridging the islands: Building fluid social experiences across websites - Once you’ve seen Chris Messina’s talk on the open & social web, you’re bound to ask how you connect your site to the rest of the Social Web to increase traffic, engagement, and relevance. John Panzer and Joseph Smarr give you the answer: by adopting the awesome open technologies described in this talk!
  • Where is the social web going next? - Kara Swisher moderates a panel of leading experts from LinkedIn, Yahoo, Google, Microsoft, Twitter, and MySpace debating issues like privacy and providing their best guesses at the direction of the foundational technologies of the social web.

You can also find all the Social Web I/O 2010 session videos on this YouTube playlist.

We had a great time at Google I/O this year and look forward to a long and fruitful discussion of everything social as we continue to work hard at making the the web more social, and the social web more open. Stay tuned to our progress on the Google Social Web Blog.

By Timothy Jordan, Developer Relations

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update

The Dev channel has been updated to 6.0.422.0 for Mac, Linux, and Windows

  • VP8/WebM support has been added
  • Crash when changing networks or waking from sleep (Issue: 44724)
  • See All
  • Fix a crash when downloading a file with no tabs open (Issue: 44454)
  • Fix idle renderer CPU usage regression. (Issue: 44494)
  • Add a preference for the tab key cycling between just form fields, or links as well. (Issue: 31177)
  • Download shelf now slides out instead of collapsing
  • CUPS “add printer” crashes tab (Issue 30880)
More details about additional changes are available in the svn log of all revision.

You can find out about getting on the Dev channel here:

If you find new issues, please let us know by filing a bug at

Jason Kersey
Google Chrome

[Gd] Beta Channel Update

| More

Google Chrome Releases: Beta Channel Update

Google Chrome 5.0.375.70 has been released to the Beta channel for Linux, Mac and Windows to fix some crash and stability issues.

If you spot any issues, please let us know:

Anthony Laforge
Google Chrome Team

[Gd] Enterprise Developer sessions at Google I/O 2010

| More

Google Apps Developer Blog: Enterprise Developer sessions at Google I/O 2010

If you didn't attend Google I/O 2010 you can see the videos of every session on YouTube. All of the Enterprise sessions are now online. See the link at the bottom of this post. Over the next week every session from every track will be available. Check out the Google I/O site for a complete list of session abstracts and videos.

There was a big focus on developing software for businesses at Google I/O this year, centered around three themes: build and sell apps in the Marketplace, customize and extend Google's apps, and build your own apps for internal use. The news kicked off the day before Google I/O with the announcement of Gmail contextual gadgets and many enhancements for Google Apps Script, including JDBC support. Then during the keynote, we launched Google App Engine for Business and announced our collaboration with VMware, and continued with the announcement of Google Wave (Labs) availability in Google Apps and Exchange support in Android 2.2 (aka Froyo).

Altogether there were more than a dozen technical sessions focused on the enterprise and more than 20 Google Apps Marketplace vendors demoing in the Enterprise Developer Sandbox.

Here’s a recap of a few of the sessions below. You can find the videos and slides for these sessions on the linked session title:

You can also find all videos for Enterprise I/O 2010 sessions in this YouTube playlist.

We’re excited to see the great strides our enterprise developer community has made, and we're looking forward to seeing even more innovation and progress at next year’s I/O. We hope to see you then!

Posted by Don Dodge, Google Apps team


[Gd] Rock the Vote: Community Representatives election is open!

| More

OpenSocial API Blog: Rock the Vote: Community Representatives election is open!

The election for the OpenSocial Foundation's community board representatives is now open. If you previously applied for membership, you should have received an email directing you to submit your ballot. The election will close at 11:59 PM PDT on Tuesday, June 15, 2010. You can find information on each person on the
candidate info page.

Two of these candidates will be elected by the community to serve on the
OpenSocial Foundation's Board of Directors. As a reminder, the role of the OpenSocial Foundation is to promote the OpenSocial specification, and to help ensure that it remains freely implementable by all, in perpetuity. You can find more information about the foundation by visiting the OpenSocial Foundation FAQ.

If you have not submitted a membership application to the OpenSocial Foundation, and would like to have your voice heard in this election you still may do so. To be eligible to vote in the current election, you must submit the OpenSocial Foundation membership application (it's free) by 11:59 PM PDT on Tuesday, June 8, 2010.

If you have any questions or comments about the election please visit the
OpenSocial community forum.

Posted by Mark Weitzel, on behalf of the OpenSocial Foundation


Wednesday, June 2, 2010

[Gd] WebSocket Protocol Updated

| More

Chromium Blog: WebSocket Protocol Updated

WebSocket is "TCP for the Web," a next-generation full-duplex communication technology for web applications being standardized as a part of Web Applications 1.0. The WebSocket protocol is more efficient than HTTP as used in Ajax, so it is more suitable for real time and dynamic web applications. WebSocket also provides a very simple API that can be used to communicate bidirectionally between the web browser and a server, so it makes it easy to develop such web apps.

We initially implemented WebSocket in WebKit, which has been available in WebKit nightly builds and in Google Chrome. The initial implementation was based on draft-hixie-thewebsocketprotocol-75. Early adopters were able to start developing web apps using WebSocket on real browsers, and provide feedback about the WebSocket specification.

Based on community feedback, the WebSocket specification has been updated to draft-ietf-hybi-thewebsocketprotocol-00 (also known as draft-hixie-thewebsocketprotocol-76).
This version relaxes requirements on handshake messages to make it easier to implement with HTTP libraries, and introduces nonce-based challenge-response to protect from cross protocol attacks. These changes make it incompatible with draft-hixie-thewebsocketprotocol-75; a client implementation of -75 can’t talk with a server implementation of -76, and vice versa.

Developers should be aware that starting from WebKit nightly build r59903 and Chrome 6.0.414.0 (r47952), the client will talk to a server using -76 version of the protocol, so it will fail to open WebSocket connections with a WebSocket server based on draft-hixie-thewebsocketprotocol-75. Since -75 version of the protocol is obsoleted and no longer supported in future version of browsers, to support new clients you need to update the server implementation. (Note that Chrome 5 uses -75 version of protocol).

The WebSocket protocol is still actively being changed. Until there is more consensus, we will continue to update our implementation to follow the latest draft of specification, rather than worrying about breaking changes.

We’re more than happy to hear your feedback, and encourage you to file any bugs you find on our issue tracker.

Posted by Fumitoshi Ukai (鵜飼文敏), Software Engineer

[Gd] Datastore Performance Growing Pains

| More

Google App Engine Blog: Datastore Performance Growing Pains

As many of you know, App Engine’s Datastore performance has been seriously degraded over the last few weeks. In addition to May 25th’s 45 minute Datastore outage, applications have seen an increased latency and thus errors as a result of timeouts. As a rough estimate, we have seen Datastore latency increases of around 2.5x. Comparing April 1st to June 1st on the Status Site shows this trend. These issues in turn have caused problems with other parts of the App Engine service that also rely on the Datastore, such as Task Queues and the Admin Console.

There are a lot of different reasons for the problems over the last few weeks, but at the root of all of them is ultimately growing pains. Our service has grown 25% every two months for the past six months. To accommodate this growth, App Engine has expanded, both increasing our computing footprint and moving between Google datacenters to accommodate our growing size. Although we have moved and expanded, it hasn’t been enough-- and performance has suffered.

We want you to know we are taking the current problems with the Datastore very seriously. We have put other Datastore projects on hold to dedicate more people to accelerating improvements to Datastore performance, and to our datacenter configuration. We expect the Datastore may still have a few issues for the next two weeks, as we respond to the problem. After that point you should begin to see rapid improvements in performance, back to normal levels. Until that point, however, we believe Datastore performance may continue to be at a level that we feel is unacceptable.

So until performance has returned to a state we are proud of, and that you are satisfied with, your applications will not be charged for Datastore costs, for either storage or Datastore CPU effective on your May 31st bill. When we are convinced we have returned Datastore performance to a level we consider acceptable, we will give you a 7-day notification on this blog before we begin charging again (Note: Your Datastore CPU budget will still control your app’s CPU usage though you will not be charged for the Datastore CPU. So please don’t turn your budget to $0 during this period).

We hope this gives more clarity into the current issues you’ve seen with your application and we sincerely appreciate your patience as we work through them.

Thank you

The App Engine Team


[Gd] Android at Google I/O 2010

| More

Google Code Blog: Android at Google I/O 2010

The Android intensity at Google I/O 2010 was definitely palpable. The Android presence included all of Day 2’s keynote along with a full session track, office hours, an Android device display of over 50 phones, and (many people’s favorite) the Developer Sandbox.

Vic Gundotra kicked off the Day 2 keynote with over 20 demos of the new features from Android release 2.2, internally called “Froyo” (see this summary on the Android Developers’ Blog). The second half of the keynote was devoted to Google TV. For more details on that announcement, you can read The Google TV Story.

During the conference, there were ten in-depth sessions dedicated to Android, two fireside chats (including one with OEMs), and one session that combined discussion of Android and iPhone issues. The sessions were:

A beginner’s guide to Android, by Reto Meier. This one featured an amazingly packed, wall-to-wall, no-standing-room-left crowd, and once it became apparent that the crowd was already quite Android-savvy, the session turned into a Best and Worst Practices talk.

Writing real-time games for Android, redux, by Chris Pruett. A crash course in Android game development: everything you need to know to get started writing 2D and 3D games, as well as tips, tricks, and benchmarks to help your code reach optimal performance. The crowd in this session’s room showed that games are one of the hottest Android application areas.

The world of ListView, by Romain Guy and Adam Powell. It might seem a bit odd to dedicate an entire session to one UI widget, but Android’s ListView is large, reasonably complex, and very widely used. Romain and Adam had to work hard to fit their material into just one talk.

Casting a wide net: how to target all Android devices, by Justin Mattson. This session covered an increasingly important subject now that there are over 60 Android devices, with significant variations in their size, shape, and capabilities.

Developing Android REST client applications, by Virgil Dobjanschi. Virgil discussed the meat and potatoes of fitting Android clients into an increasingly-RESTful Web ecosystem. No user-interface flash here, but totally essential back-end plumbing guidance.

A JIT Compiler for Android's Dalvik VM, by Ben Cheng and Bill Buzbee. JIT stands for “Just In Time”, and it’s a technique for making compute-heavy Android programs run faster; maybe as much as four times faster. Definitely behind-the-scenes stuff, but a subject nearly everyone cares about.

Writing zippy Android apps, by Brad Fitzpatrick. Making your code run fast requires combining good design with a large grab-bag of hard-won best practices. For any serious Android developer: this is a must-see session, so I hope you make use of the session video and slides!

Advanced Android audio techniques, by Dave Sparks. Integrating audio into your apps involves a lot of choices and trade-offs at a bunch of levels. Furthermore, there are new media framework APIs in Android 2.2. Lots of good, detailed drill-down in this session.

Building push applications for Android, by Debajit Ghosh. What was called “push” while it was being built is now called Cloud To Device Messaging (C2DM), and it’s very nicely integrated into the SDK; we anticipate that a lot of developers will want to use this.

Android UI design patterns, by Chris Nesladek et al. The Android User Experience team shared their insights on how to design great Android apps.

There were also two Fireside chats. One with a panel of Android handset manufacturers, and another with a stage full of leading engineers from the Android team. The panelists took questions from the people in the room and from over the Web via Google Moderator and Google Wave.

On Thursday afternoon, a gaggle of Android engineers held office hours; the area was absolutely jam-packed with developers full of questions about everything from low-level hardware interfaces to telephony chips up through the finer points of Live Wallpapers. Everyone had fun and went home tired.

On both days of the conference, there was a large (bright green, of course) display case full of Android devices, surrounded by the app developers and handset manufacturers participating in the Developer Sandbox. This area was crowded from the start of I/O until the security folks eventually chased out the stragglers after closing. Here is quick video of a slow walk past the big display case.

Videos and slides for each session are linked from the titles above, and you can find all the Android session videos from Google I/O 2010 in this YouTube playlist.

The Android team had an amazing time meeting the developer community at this year’s I/O, and we hope you’ll stay up-to-date on Android news by following us on the Android Developers Blog!

By Android Developer Relations


[Gd] Developers go big for business at Google I/O 2010

| More

Google Code Blog: Developers go big for business at Google I/O 2010

There was a big focus on developing software for businesses at Google I/O this year, centered around three themes: build and sell apps in the Marketplace, customize and extend Google's apps, and build your own apps for internal use. The news kicked off the day before Google I/O with the announcement of Gmail contextual gadgets and many enhancements for Google Apps Script, including JDBC support. Then during the keynote, we launched Google App Engine for Business and announced our collaboration with VMware, and continued with the announcement of Google Wave (Labs) availability in Google Apps and Exchange support in Android 2.2 (aka Froyo).

Altogether there were more than a dozen technical sessions focused on the enterprise and more than 20 Google Apps Marketplace vendors demoing in the Enterprise Developer Sandbox.

Here’s a recap of a few of the sessions below. You can find the videos and slides for these sessions on the linked session title:

You can also find all videos for Enterprise I/O 2010 sessions in this YouTube playlist.

We’re excited to see the great strides our enterprise developer community has made, and we're looking forward to seeing even more innovation and progress at next year’s I/O. We hope to see you then!

Posted by Ryan Boyd, Google Apps team

[Gd] Allowing applications to play nice(r) with each other: Handling remote control buttons

| More

Android Developers Blog: Allowing applications to play nice(r) with each other: Handling remote control buttons

[This post is by Jean-Michel Trivi, an engineer working on the Android Media framework, whose T-shirt of the day reads “all your media buttons are belong to you”. — Tim Bray]

Many Android devices come with the Music application used to play audio files stored on the device. Some devices ship with a wired headset that features transport control buttons, so users can for instance conveniently pause and restart music playback, directly from the headset.

But a user might use one application for music listening, and another for listening to podcasts, both of which should be controlled by the headset remote control.

If your media playback application creates a media playback service, just like Music, that responds to the media button events, how will the user know where those events are going to? Music, or your new application?

In this article, we’ll see how to handle this properly in Android 2.2. We’ll first see how to set up intents to receive “MEDIA_BUTTON” intents. We’ll then describe how your application can appropriately become the preferred media button responder in Android 2.2. Since this feature relies on a new API, we’ll revisit the use of reflection to prepare your app to take advantage of Android 2.2, without restricting it to API level 8 (Android 2.2).gi

An example of the handling of media button intents

In our AndroidManifest.xml for this package we declare the class RemoteControlReceiver to receive MEDIA_BUTTON intents:

<receiver android:name="RemoteControlReceiver">
<action android:name="android.intent.action.MEDIA_BUTTON" />

Our class to handle those intents can look something like this:

public class RemoteControlReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
/* handle media button intent here by reading contents */
/* of EXTRA_KEY_EVENT to know which key was pressed */

In a media playback application, this is used to react to headset button presses when your activity doesn’t have the focus. For when it does, we override the Activity.onKeyDown() or onKeyUp() methods for the user interface to trap the headset button-related events.

However, this is problematic in the scenario we mentioned earlier. When the user presses “play”, what application should start playing? The Music application? The user’s preferred podcast application?

Becoming the “preferred” media button responder

In Android 2.2, we are introducing two new methods in to declare your intention to become the “preferred” component to receive media button events: registerMediaButtonEventReceiver() and its counterpart, unregisterMediaButtonEventReceiver(). Once the registration call is placed, the designated component will exclusively receive the ACTION_MEDIA_BUTTON intent just as in the example above.

In the activity below were are creating an instance of AudioManager with which we will register our component. We therefore create a ComponentName instance that references our intended media button event responder.

public class MyMediaPlaybackActivity extends Activity {
private AudioManager mAudioManager;
private ComponentName mRemoteControlResponder;

public void onCreate(Bundle savedInstanceState) {
mAudioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE);
mRemoteControlResponder = new ComponentName(getPackageName(),

The system handles the media button registration requests in a “last one wins” manner. This means we need to select where it makes sense for the user to make this request. In a media playback application, proper uses of the registration are for instance:

  • when the UI is displayed: the user is interacting with that application, so (s)he expects it to be the one that will respond to the remote control,

  • when content starts playing (e.g. content finished downloading, or another application caused your service to play content)

Registering is here performed for instance when our UI comes to the foreground:

public void onResume() {

If we had previously registered our receiver, registering it again will push it up the stack, and doesn’t cause any duplicate registration.

Additionally, it may make sense for your registered component not to be called when your service or application is destroyed (as illustrated below), or under conditions that are specific to your application. For instance, in an application that reads to the user her/his appointments of the day, it could unregister when it’s done speaking the calendar entries of the day.

public void onDestroy() {

After “unregistering”, the previous component that requested to receive the media button intents will once again receive them.

Preparing your code for Android 2.2 without restricting it to Android 2.2

While you may appreciate the benefit this new API offers to the users, you might not want to restrict your application to devices that support this feature. Andy McFadden shows us how to use reflection to take advantage of features that are not available on all devices. Let’s use what we learned then to enable your application to use the new media button mechanism when it runs on devices that support this feature.

First we declare in our Activity the two new methods we have used previously for the registration mechanism:

    private static Method mRegisterMediaButtonEventReceiver;
private static Method mUnregisterMediaButtonEventReceiver;

We then add a method that will use reflection on the class to find the two methods when the feature is supported:

private static void initializeRemoteControlRegistrationMethods() {
try {
if (mRegisterMediaButtonEventReceiver == null) {
mRegisterMediaButtonEventReceiver = AudioManager.class.getMethod(
new Class[] { ComponentName.class } );
if (mUnregisterMediaButtonEventReceiver == null) {
mUnregisterMediaButtonEventReceiver = AudioManager.class.getMethod(
new Class[] { ComponentName.class } );
/* success, this device will take advantage of better remote */
/* control event handling */
} catch (NoSuchMethodException nsme) {
/* failure, still using the legacy behavior, but this app */
/* is future-proof! */

The method fields will need to be initialized when our Activity class is loaded:

    static {

We’re almost done. Our code will be easier to read and maintain if we wrap the use of our methods initialized through reflection by the following. Note in bold the actual method invocation on our AudioManager instance:

    private void registerRemoteControl() {
try {
if (mRegisterMediaButtonEventReceiver == null) {

} catch (InvocationTargetException ite) {
/* unpack original exception when possible */
Throwable cause = ite.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
} else {
/* unexpected checked exception; wrap and re-throw */
throw new RuntimeException(ite);
} catch (IllegalAccessException ie) {
Log.e(”MyApp”, "unexpected " + ie);

private void unregisterRemoteControl() {
try {
if (mUnregisterMediaButtonEventReceiver == null) {

} catch (InvocationTargetException ite) {
/* unpack original exception when possible */
Throwable cause = ite.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
} else {
/* unexpected checked exception; wrap and re-throw */
throw new RuntimeException(ite);
} catch (IllegalAccessException ie) {
System.err.println("unexpected " + ie);

We are now ready to use our two new methods, registerRemoteControl() and unregisterRemoteControl() in a project that runs on devices supporting API level 1, while still taking advantage of the features found in devices running Android 2.2.


[Gd] In The Open, For RLZ

| More

Chromium Blog: In The Open, For RLZ

When we released a new stable version of Google Chrome last March, we tried to improve the transparency and privacy options of Google Chrome. One area where we’ve seen a lot of interest and questions is the RLZ library that is built into Google Chrome. RLZ gives us the ability to accurately measure the success of marketing promotions and distribution partnerships in order to meet our contractual and financial obligations. It assigns non-unique, non-personally identifiable promotion tracking labels to client products; these labels sometimes appear in Google search queries in Google Chrome.

Documenting Google Chrome’s use of promotional tags and tokens was a good start, but we wanted to take this transparency a step further. Our goal was to not only show you exactly how we were sending distribution information, but also what information was included and how it was generated.

Today, we’ve open-sourced the code that generates the RLZ parameter that sometimes appears in Google search queries. We’ve made the RLZ library its own project on the Google Code site, since this is the same library that is used in other Google products. This is analogous to how we opened Omaha, the Google Updater technology, as its own open-source project.

Chromium will also continue to exist as it always has, without any RLZ library included. And, you can still download a Google Chrome with no RLZ behavior at But now that RLZ is open, Google Chrome distributed through promotional means will include this open-source implementation of RLZ.

It is our hope that we are not only opening up a previously-closed part of Google Chrome and providing better transparency, but that we’re also offering up potentially useful code to others who may use it in their own projects.

We know this is just a small step, but we think that the RLZ project will provide better transparency and value to the community. We want to hear what you think, so please keep the feedback coming!

Posted by Roger Tawa, Software Engineer, and Glenn Wilson, Product Manager

[Gd] [Libraries][Update] jQueryUI 1.8.2

| More

Google AJAX API Alerts: [Libraries][Update] jQueryUI 1.8.2

jQueryUI was updated to 1.8.2.

Tuesday, June 1, 2010

[Gd] Open sourcing Thoughtsite - A discussion forum designed for Google App Engine

| More

Google App Engine Blog: Open sourcing Thoughtsite - A discussion forum designed for Google App Engine

Editor's Note: Cross-posted from the Open Source at Google Blog.

Google App Engine is a powerful system, designed to take all the pain of infrastructure management and performance scaling out of web application programming. App Engine applications are easy to build, easy to maintain, and easy to scale as your traffic and data storage needs grow.

While there are a lot of open source projects available to learn how to use App Engine, there have been few open sourced, comprehensive web applications built on App Engine to help you learn how best to use the advanced features that App Engine provides.

Enter... Thoughtsite!

Thoughtsite is a discussions/forum web app designed for Google App Engine. The main features of the app are:

  • A flexible system that could be used for any kind of discussion forum.

  • Voting, tagging, comments and a reputation point system for users.

  • Full text search on App Engine with Apache Lucene.

  • Search for threads by tags or by keywords. Threads can also be linked to from user profiles.

  • Users gain reputation points based on community votes for their contributions.

  • Full-fledged user profiles with info, points, contributions, user's personal tag cloud, etc.

  • Basic duplication detection filters to detect similar threads so posters can avoid creating a new thread if one already exists.

  • Basic spam and gaming filters (self-voting, cross-voting, etc.).

  • Comprehensive admin section that allows moderation of individual posts and users. Users can flag objectionable content or trolls.

Best of all, Thoughtsite is completely open source using an Apache 2 license and the code is available for download.

We hope you download the source, take it apart and play with it. Thoughtsite will work as a complete app if you want to use it to host a discussion forum on your own domain, but its real value is in taking it apart to understand how it uses App Engine under the hood.

Posted by Fred Sauer, App Engine Team

[Gd] GWT at Google I/O 2010

| More

Google Code Blog: GWT at Google I/O 2010

This year's Google I/O was one to remember, with demos and presentations that showcased the power of HTML5 for consumers and businesses, as well as a complete proliferation of Android apps and devices (some of which ended up in the hands of attendees).

Day one included a keynote presentation by our own Bruce Johnson and SpringSource's Ben Alex. Here they announced the Google and VMware partnership which makes it easy for developers to harness the power of Spring Roo and GWT to build rich enterprise web apps that are cloud portable. As part of this announcement, the GWT team released GWT 2.1 M1, which not only includes VMware integration, but also Data Presentation Widgets and an MVP Framework.

Along with the great keynotes, there were plenty of in-depth GWT sessions. In the event that you missed them, here's a recap:
  • Measure in milliseconds redux: Meet Speed Tracer - Kelly Norton is back for round two to demonstrate what milliseconds of latency means to end-users, as well as how to identify the sources of latency within your app using Speed Tracer.

  • Faster apps faster: Optimizing apps with the GWT Compiler - Have you ever wondered how you can speed up your GWT compiles? If so, follow along with Ray Cromwell as he delves into this topic, as well as other tips and tricks that you can use to streamline development with GWT.

  • Architecting for performance with GWT - Last year we announced Google Wave, a cutting edge web app that introduces a new way of collaborating and communicating. This year Wave team lead Adam Shuck, and GWT UI guru Joel Webber share with everyone the optimizations both teams use when building GWT-based web apps.

  • GWT Linkers target HTML5 Web Workers, Chrome Extensions, and more - GWT has some extremely interesting technology under the hood, and Matt Mastracci, CTO of dotspots, knows this as well as anyone else. For this year's I/O he provides an overview of GWT linkers, as well as how they created a one that turns a GWT module into an HTML5 Web Worker, and one that generates an HTML App Cache manifest automatically.

  • GWT's UI overhaul: UiBinder, ClientBundle, and Layout Panels - GWT 2.0 shipped with some major UI enhancements that make it very easy to speed up your app, decrease load time, and control layout. In this session, Ray Ryan and Joel Webber show you how these new features interact with one another, and how you can use them to create the most optimal web app.

  • GWT + HTML5 can do what?! If you missed the YouTube video of Quake II running in the browser, this session not only replays it, but goes into great detail as to how the three Googlers actually made it happen using HTML5 features such as WebGL and WebSockets.

  • GWT testing best practices - In 2009, Ray Ryan gave a talk on how to architect a GWT app using the MVP design pattern. This year, Wave's Daniel Danilatos follows-up on Ray's talk, with a detailed overview of how to remove the pain of testing GWT apps using the MVP architecture.

  • Architecting GWT applications for production at Google - If you haven't noticed, it's required that at least one of Ray's talks has the word "Architecting" in it. The good news is that his talks live up to their titles, and this session is no exception. Not only does Ray evolve the concepts discussed in his 2009, "Best Practices for Architecting GWT Apps", he dives into some of the upcoming GWT 2.1 features, and invites Ben Alex, from VMware, on stage to talk about the integration between Spring Roo and GWT.
In addition to the linked session titles where you'll find the videos and slides, you can also find all videos in this YouTube playlist for GWT I/O 2010 sessions.

It was fantastic meeting everyone out at I/O, and we hope that it was as exciting and educational for you as it was for us. As always, stay on top of the latest GWT 2.1 release progress on the GWT Blog, and be on the lookout for posts from other I/O tracks coming soon!

By Chris Ramsdale, GWT Team

[Gd] The App Engine Team’s trip to I/O 2010 (Recap & Videos)

| More

Google Code Blog: The App Engine Team’s trip to I/O 2010 (Recap & Videos)

This year’s Google I/O included a flurry of announcements and presentations for the App Engine team. Thanks to everyone who attended our sessions, stopped by the Sandbox, or came to meet the team at our office hours. It was great to meet all of you. For the App Engine developers out there that weren't able to make it out this year, we wanted to give you a quick recap on what you missed.

We opened up the first day’s keynote with App Engine’s very own Kevin Gibbs announcing App Engine for Business and doing a demo of the new Business Admin Console. There’s lots of great new features coming with App Engine for Business so if you missed the announcement, please read more about it and sign up to be a part of the preview. We also announced our work with VMWare to connect our development tools in order to allow developers to use SpringSource tools and Google Web Toolkit to build applications and deploy them on App Engine.

If you were watching the keynote, you might have missed the announcement that we released version 1.3.4 of the App Engine SDK which included a brand new bulkloader and experimental support for OpenID and OAuth. The Blobstore API is also no longer experimental and supports files up to 2GB in size.

In addition to all the high profile announcements in the keynote, we also hosted a number of great sessions about App Engine development for the rest of the conference. Thanks to the dedicated I/O organizers, videos of all the App Engine sessions are now available so anyone can watch them (with more to come in the next few days):
  • Appstats - RPC instrumentation and optimizations for App Engine - Guido van Rossum went into detail on how to use Appstats, a new tool for App Engine developers which provides deep insight into why requests are slow and what they’re doing under the covers.

  • Run corporate applications on Google App Engine? Yes we do - Ben Fried (Google’s CIO) and his team joined us to give an update on their progress of moving Google’s corporate applications to App Engine, the problems they ran into, and the success they had. They also announced that two of their apps are now being open sourced for anyone to use.

  • Batch data processing with App Engine - Mike Aizatsky introduced Mapper, a new tool which allows App Engine developers which makes it simple to write code that is run over large datasets such as a Blobstore file or Datastore entities.

  • Data migration in App Engine - Matthew Blain gave a complete introduction to the brand new Bulk Loader which shipped as part of App Engine’s 1.3.4 SDK. The session also provided a look into how to use the Bulk Loader with Java applications and ways to import complex data models from a number of different sources.

  • What's hot in Java for App Engine - The same duo from last year’s introduction of the Java SDK, Don Schwarz and Toby Reyelts, were back again this year to give an update on the progress of the Java SDK. Performance optimizations, compatibility, and new APIs are all covered giving a peak under the hood for Java developers.

  • Building high-throughput data pipelines with Google App Engine - Brett Slatkin reviewed the Task Queue and introduced a number of strategies used to improve the performance of applications doing very high volumes of task queue work. This session is based on lessons learned by Brett while building PubSubHubbub on App Engine.

  • Testing techniques for Google App Engine - Max Ross argued the virtues of proper software testing and then went to detail on how to test your App Engine code properly and how to use App Engine to test all the rest of your code.

  • Next gen queries - Alfred Fuller closed out the conference with a great overview of recent improvements to the Datastore query planner and the new types of queries that are possible, as well as a look at a few features on the horizon.
In addition to the linked session titles where you'll find the videos and slides, you can also find all videos in this YouTube playlist for App Engine I/O 2010 sessions.

There’s plenty of great information in all the presentations, so for those of you that missed, we highly recommend you watch the videos and read the slides. For everyone else that made it to I/O this year, thank you for making this year’s I/O a complete success. It’s incredibly energizing for us to see all your hard work, thoughtful questions, and great ideas on App Engine. We’re already excited to see what you all surprise us with at next year’s I/O!

By Sean Lynch, App Engine Team