By Wouter van Oortmerssen, Fun Propulsion Labs at Google
Game developers, we've just released FlatBuffers, a C++ serialization library that allows you to read data without unpacking or allocating additional memory, as an open source project.
FlatBuffers stores serialized data in buffers in a cross-platform way, supporting format evolution that is fully forwards and backwards compatible through a schema. These buffers can be stored in files or sent across the network as-is, and accessed in-place without parsing overhead.
The FlatBuffers schema compiler and runtime is written in platform independent C++ with no library dependencies outside the STL, which makes it possible to use on any platform that has a C++ compiler. We have provided methods to build the FlatBuffers library, example applications, and unit tests for Android, Linux, OSX and Windows. The schema compiler can generate code to read and write FlatBuffers binary files for C++ and Java. It can additionally parse JSON-formatted data into type-safe binaries.
Game developers can use this library to store game data with less overhead than alternative solutions (e.g. Protocol Buffers or JSON). We’re excited about the possibilities, and want to hear from you about how we can make this even better!
A few weeks ago, Timothy and I were chatting about designing apps for wearables to validate some of the content we’re planning for Google I/O 20141. We talked a lot about how these devices require scrutiny to preserve user attention while exposing some unique new surface areas for developers. We also discussed user context and how the apps we make should be opportunistic, presenting themselves in contexts where they’re useful; it’s more important than ever to think of apps on wearable devices not as icons on a grid but rather as functional overlays on the operating system itself.
But while I’d designed a number of touch UIs for Android in the past and Timothy had a ton of experience with Glass, neither of us had really gone through the exercise of actually designing an app for Android Wear. So we set out to put our ideas in practice and see what designing for this new platform is like.
Before we got started, we needed an idea. Last year, I participated in an informal Glass design sprint in NYC run by Nadya Direkova, and my sprint team came up with a walking tour app. The idea was you’d choose from a set of nearby tours, walk between the stops, and at each stop on the tour, learn about the destination.
My rough mocks of a walking tour app from a Glass design sprint.
While the design sprint ended at rough mocks, the idea stuck around in my mind, and came up again during this exercise. It seemed like a perfect example of a contextually aware app that could enhance your Android Wear experience.
Designing a walking tour app for Android Wear
We started fleshing out the idea by thinking through the app’s entry points: how will users “launch” this app? While exposing a “start XYZ walking tours app” voice command is pretty standard, it’d be interesting to also suggest nearby walking tours as you go about your day by presenting notifications in the user’s context stream. These notifications would be “low priority,” so you’d only see them after addressing the more important stuff like text messages from friends. And with today’s geofencing and location functionality in Google Play services, this type of contextual awareness is possible in a battery-friendly way.
At this point we were pretty excited and decided to begin mocking up the UI. Rather than starting from scratch, we used Taylor Ling’s excellent Android Wear 0.1 design template as a baseline, which includes templates for both square and round devices. We started with square since we were most familiar with rectangle UI design:
Idea: You get a notification in the context stream when a walking tour is available nearby.
I’ve got to admit, it was pretty thrilling designing in such a constrained environment. 140x140 dp (280x280 px @ XHDPI) isn’t a lot of space to work with, so you need to make some tough choices about when and how to present information. But these are exactly the types of problems that make design really, really fun. You end up spending more time thinking and less time actually pushing pixels around in Photoshop or Sketch.
We pretty quickly fleshed out the rest of the app for square devices. They included just a handful of additional screens: a dynamic notification showing the distance to your next stop, and a 4-page detail screen when you arrive at the tour stop, where you can spend a few moments reading about where you’re standing.
A notification guiding you to your next stop, and a multi-page stop detail screen for learning about the stop when you get there.
Seeing our design in real life
Here’s the thing—there’s only so much you can do in Photoshop. To truly understand a platform as a designer, you really need to use (and ideally live with) a real device, and see your work on that device. Only then can you fully evaluate the complexity of your flows, the size of your touch targets, or the legibility of your text.
Luckily, Timothy and I both had test devices—I sported an LG G Watch prototype and Timothy carried a Moto 360 prototype. We then needed a way to quickly send screens to our devices so we could iterate on the design. A few years ago I’d published the Android Design Preview tool that lets you mirror a part of your screen to a connected Android device. Much to our delight, the tool worked great with Android Wear! After seeing our mocks show up on my LG G Watch, we made a few small tweaks and felt much more confident that the overall idea “felt right” on the wrist.
Android Design Preview mirrors a part of your computer screen to an Android device. It’s especially awesome seeing your UI running on an LG G Watch prototype.
Designing for round devices
We’d never designed round UIs before, so we weren’t sure what this new adventure would be like. Quite frankly, it ended up being unbelievably easy: tweaking all 8 of our screen mocks for round took under an hour. When you’re only showing the most important 2 or 3 pieces of information on screen at a time, that’s only 2 or 3 pieces of information you need to optimize for round devices. All in all, there were only a few types of minor tweaks we made:
Scaled up backgrounds to 160x160 dp (320x320 px @ XHDPI)
Bumped up content margins from 12dp on square to 26dp on round; this means content was 116x116 dp on square and only a little smaller at 108x108 dp on round
Pushed down circular actions like “Continue tour” to better vertically center with the watch frame
Center-aligned certain short snippets of text on round devices as opposed to left-aligning on square
Dropped the side padding for context stream cards (the platform automatically does this for notifications, so there isn’t any actual work to do here)
These weren’t completely different layouts—rather, the same layout with slightly tweaked metrics.
It’s hard to articulate the excitement we felt when we mirrored the mocks to Timothy’s Moto 360 prototype with Android Design Preview. To put it lightly, our minds were blown.
There’s something special and awe-inspiring about seeing one of your UIs running on a round screen..
And that was it—with round and square mocks complete, and mirrored on our devices, we’d gotten our first glimpse at designing apps for this exciting new platform. Below are our completed mocks for the tour discovery and engagement flows, not a grid of app icons in sight. You can download the full PSDs here.
An eye-opening experience
Designing for Android Wear is pretty different from designing for the desktop, phones or tablets. Just like with Glass, you really need to think carefully about the information and actions you present to the user, and even more so about the contexts in which your app will come to the surface.
As a designer, that’s the fun part—working with constraints involving scarce resources like device size and user attention means it’s more important than ever to think deeply about your ideas and iterate on them early and often. The actual pixel-pushing part of the process is far, far easier.
So there we were, putting our ideas into practice, on real actual device prototypes that we could’ve only dreamed about only a few years ago. It was the most fun I’ve had designing UIs in a long time. Remember that feeling when you first dreamed up an app, mocked or even coded it up, and ran it on your Android phone? It was that same feeling all over again, but amplified, because you were actually wearing your app. I can’t wait for you all to experience it!
1 Have we mentioned #io14 will have tons of great content around both design and wearable computing? Make sure to tune in June 25th and 26th!
Hey game developers, back in March you may remember we added new game statistics in the Google Play Developer Console for those of you who had implemented Google Play Games: our cross-platform game services for Android, iOS and the web.
Starting today, we're providing more insights into how your games are being used by adding country, age, and gender dimensions to the existing set of reports available in the Developer console. You’ll see demographics integrated into Overview stats as well as the Players reports for New and Active users.
In the Overview stats you can now see highlights of activity by age group, most active countries, and gender.
With a better understanding of your users’ demographic composition, you'll be able to make more effective decisions to improve retention and monetization. Here a few ways you could imagine using these new stats:
You just launched your new game globally, and expected it do particularly well in Germany. Using country demographic data, you see that Germany is much less active than expected. After some digging, you realize that your tutorial was not properly translated to German. Based on this insight, you immediately roll out a fix to see if you can improve active users in Germany.
In the Players stats section the new metrics reveal trends in how your app is doing across age groups, countries, and gender.
After Looking at your new demographics report you realize that your game is really popular with women in their mid-20s. Your in-app purchase data corroborates this, showing that the one female hero character is the most popular purchase. Empowered by this data, you race to add female hero characters to your game.
Additionally, if you're already using Google Play game services, there's no extra integration needed! By logging in to the Google Play Developer Console you can start using demographics to better inform your decisions today.
Adding extra pages to notifications with the Android Wear Developer Preview is really simple, and it all comes down to one extra line of code shown highlighted here:
Notification notification1 = new WearableNotifications.Builder(builder1) .addPages(extras) .build();
The video embedded above demonstrated some code that helps notify a user when library books are overdue. The code is included below using similar notification APIs you are already familiar with, but this time we build up a list of extra pages and then add them. The wearable-specific code is highlighted below:
// Nuke all previous notifications and generate unique ids NotificationManagerCompat.from(this).cancelAll(); int notificationId = 0;
// Titles, authors, and overdue status of some books to display String[] titles = { "How to survive with no food", "Sailing around the world", "Navigation on the high seas", "Avoiding sea monsters", "Salt water distillation", "Sail boat maintenance" }; String[] authors = { "I. M. Hungry", "F. Magellan", "E. Shackleton", "K. Kracken", "U. R. Thirsty", "J. Macgyver" }; Boolean[] overdue = { true, true, true, true, true, false }; List extras = new ArrayList();
// Extra pages of information for the notification that will // only appear on the wearable int numOverdue = 0; for (int i = 0; i < titles.length; i++) { if (!overdue[i]) continue; BigTextStyle extraPageStyle = new NotificationCompat.BigTextStyle(); extraPageStyle.setBigContentTitle("Overdue Book " + (i+1)) .bigText("Title: " + titles[i] + ", Author: " + authors[i]); Notification extraPageNotification = new NotificationCompat.Builder(this) .setStyle(extraPageStyle) .build(); extras.add(extraPageNotification); numOverdue++; }
// Main notification that will appear on the phone handset and the wearable Intent viewIntent1 = new Intent(this, MainActivity.class); PendingIntent viewPendingIntent1 = PendingIntent.getActivity(this, notificationId+1, viewIntent1, 0); NotificationCompat.Builder builder1 = new NotificationCompat.Builder(this) .addAction(R.drawable.ic_action_done, "Returned", viewPendingIntent1) .setContentTitle("Books Overdue") .setContentText("You have " + numOverdue + " books due at the library") .setSmallIcon(R.drawable.ic_launcher); Notification notification1 = new WearableNotifications.Builder(builder1) .addPages(extras) .build();
// Issue the notification NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this); notificationManager.notify(notificationId+1, notification1);
Follow these simple steps to see the example in action:
2. Once the IDE is ready, create a new Android project with all the defaults. Make sure it compiles and runs before you continue to make fixing any problems easier.
3. Add the necessary support libraries by following the installation instructions so that your project supports wearable notifications.
4. Create a method in your main activity called showPageNotifications(), and paste all the code into it.
5. Call showPageNotifications() from your activity’s onCreate() to show the notifications automatically at startup. Alternatively, add a button that calls the method on click.
6. Add the below imports, or just have your IDE auto-add the missing imports.
8. Build the project. If there are any compile issues try a clean build of the project.
9. You can now run the application on your phone, and see the results on the wearable emulator.
Once again, you can see that building with Android Wear is really easy! After experimenting with this code, check out the detailed documentation for the full story.
Stacking notifications with the Android Wear Developer Preview is really simple—it requires only a few lines of extra notification code:
Notification wearableNotification = new WearableNotifications.Builder( notificationCompatBuilder) .setGroup(“messages”) .build();
A few weeks ago, I published a new DevBytes video which covered how to implement stacking notifications with Android Wear:
In the video, I included a demonstration of what these notifications look like in the emulator, and thought it would be useful to share the code for the demo. If you’re just getting started with stacked notifications, this should be all you need to get up and running right away. So here it is, with some additional instructions below. The wearable-specific code is highlighted and in bold.
// Nuke all previous notifications and generate unique ids NotificationManagerCompat.from(this).cancelAll(); int notificationId = 0;
// String to represent the group all the notifications will be a part of final String GROUP_KEY_MESSAGES = "group_key_messages";
// Group notification that will be visible on the phone NotificationCompat.Builder builderG = new NotificationCompat.Builder(this) .setContentTitle("2 Pet Notifications") .setContentText("Mila and Dylan both sent messages") .setSmallIcon(R.drawable.ic_launcher) .setLargeIcon(bitmapMila); Notification summaryNotification = new WearableNotifications.Builder(builderG) .setGroup(GROUP_KEY_MESSAGES, WearableNotifications.GROUP_ORDER_SUMMARY) .build();
// Separate notifications that will be visible on the watch Intent viewIntent1 = new Intent(this, MainActivity.class); PendingIntent viewPendingIntent1 = PendingIntent.getActivity(this, notificationId+1, viewIntent1, 0); NotificationCompat.Builder builder1 = new NotificationCompat.Builder(this) .addAction(R.drawable.ic_action_done, "Treat Fed", viewPendingIntent1) .setContentTitle("Message from Mila") .setContentText("What's for dinner? " + "Can we have steak?") .setSmallIcon(R.drawable.ic_launcher); Notification notification1 = new WearableNotifications.Builder(builder1) .setGroup(GROUP_KEY_MESSAGES) .build();
Intent viewIntent2 = new Intent(this, MainActivity.class); PendingIntent viewPendingIntent2 = PendingIntent.getActivity(this, notificationId+2, viewIntent2, 0); NotificationCompat.Builder builder2 = new NotificationCompat.Builder(this) .addAction(R.drawable.ic_action_done, "Water Filled", viewPendingIntent2) .setContentTitle("Message from Dylan") .setContentText("Can you refill our water bowl?") .setSmallIcon(R.drawable.ic_launcher); Notification notification2 = new WearableNotifications.Builder(builder2) .setGroup(GROUP_KEY_MESSAGES) .build();
// Issue the group notification NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this); notificationManager.notify(notificationId+0, summaryNotification);
// Issue the separate wear notifications notificationManager.notify(notificationId+2, notification2); notificationManager.notify(notificationId+1, notification1);
Once the IDE is ready, create a new Android project with all the defaults. Make sure it compiles and runs before you continue to make fixing any problems easier.
Add the necessary support libraries by following the installation instructions so that your project supports wearable notifications.
Create a method in your main activity called showTheNotifications(), and paste all the code into it.
Call showTheNotifications() from your activity’s onCreate method to show the notifications automatically at startup. Alternatively, add a button that calls the method on click.
Add the below imports, or just have your IDE auto-add the missing imports.
Add the images on the right to your drawable directories.
res/drawable-xxhdpi/ic_action_done.png
res/drawable-nodpi/mila128.jpg
Build the project. If there are any compile issues try a clean build of the project.
You can now run the application on your phone, and see the results on the wearable.
And that’s basically it, it’s really simple! Once you have a good feel for how the code works, make sure to check out the stacking notifications documentation to learn more. Make sure to also familiarize yourself with the Android Wear Design Principles, which explain more about the types of icons that should be used for actions. For the picture of the dog, it’s important you use an image that is quite small, and not straight from a digital camera, since there are limits to the size of the images that can be handled by the API.
I hope this post is useful in helping you to get started with Android Wear notifications!
By Ibrahim Elbouchikhi, Google Play Product Manager
Sales of apps and games on Google Play are up by more than 300 percent over the past year. And today, two-thirds of Google Play purchases happen outside of the United States, with international sales continuing to climb. We’re hoping to fuel this momentum by making Google Play payments easier and more convenient for people around the world.
PayPal support
Starting today, we're making it possible for people to choose PayPal for their Google Play purchases in 12 countries, including the U.S., Germany, and Canada. When you make a purchase on Google Play in these countries, you'll find PayPal as an option in your Google Wallet; just enter your PayPal account login and you'll easily be able to make purchases. Our goal is to provide users with a frictionless payment experience, and this new integration is another example of how we work with partners from across the payments industry to deliver this to the user.
Carrier billing and Google Play gift cards in more countries
Carrier billing—which lets people charge purchases in Google Play directly to their phone bill—continues to be a popular way to pay. We’ve just expanded coverage to seven more countries for a total of 24, including Singapore, Thailand and Taiwan. That means almost half of all Google Play users have this option when making their purchases.
We’ve also made Google Play gift cards available to a total of 13 countries, including Japan and Germany.
Support for developer sales in more countries
Developers based in 13 new countries can now sell apps on Google Play (with new additions such as Indonesia, Malaysia and Turkey), bringing the total to 45 countries with support for local developers. We’ve also increased our buyer currency support to 28 new countries, making it even easier for you to tailor your pricing in 60 countries.
Nothing for you to do!
Of course, as developers, when it comes to payments, there’s nothing for you to do; we process all payments, reconcile all currencies globally, and make a monthly deposit in your designated bank account. This means you get to focus on what you do best: creating beautiful and engaging apps and games.
A new release of Google Play services has now been rolled out to the world, and as usual we have a number of features that can make your apps better than before. This release includes a major enhancement to Maps with the introduction of Street View, as well as new features in Location, Games Services, Mobile Ads, and Wallet API.
Here are the highlights of Google Play services release 4.4:
Google Maps Android API
Starting with a much anticipated announcement for the Google Maps Android API: Introducing Street View. You can now embed Street View imagery into an activity enabling your users to explore the world through panoramic 360-degree views. Programmatically control the zoom and orientation (tilt and bearing) of the Street View camera, and animate the camera movements over a given duration. Here is an example of what you can do with the API, where the user navigates forward one step:
We've also added more features to the Indoor Maps feature of the API. You can turn the default floor picker off - useful if you want to build your own. You can also detect when a new building comes into focus, and find the currently-active building and floor. Great if you want to show custom markup for the active level, for example.
Activity Recognition
And while we are on the topic of maps, let’s turn to some news in the Location API. For those of you that have used this API, you may have seen the ability already there to detect if the device is in a vehicle, on a bicycle, on foot, still, or tilting.
In this release, two new activity detectors have been added: Running, and Walking. So a great opportunity to expand your app to be even more responsive to your users. And for you that have not worked with this capability earlier, we hardly need to tell the cool things you can do with it. Just imagine combining this capability with features in Maps, Games Services, and other parts of Location...
Games Services Update
In the 4.3 release we introduced Game Gifts, which allows you to request gifts or wishes. And although there are no external API changes this time, the default requests sending UI has been extended to now allow the user to select multiple Game Gifts recipients. For your games this means more collaboration and social engagement between your players.
Mobile Ads
For Mobile Ads, we’ve added new APIs for publishers to display in-app promo ads, which enables users to purchase advertised items directly. We’re offering app developers control of targeting specific user segments with ads, for example offering high-value users an ad for product A, or new users with an ad for product B, etc.
With these extensions, users can conveniently purchase in-app items that interest them, advertisers can reach consumers, and your app connects the dots; a win-win-win in other words.
Wallet Fragments
For the Instant Buy API, we’ve now reduced the work involved to place a Buy With Google button in an app. The WalletFragment API introduced in this release makes it extremely easy to integrate Google Wallet Instant Buy with an existing app. Just configure these fragments and add them to your app.
And that’s another release of Google Play services. The updated Google Play services SDK is now available through the Android SDK manager. Coming up in June is Google I/O, no need to say more…
(from the 
