Android Development: Lotsa Links

This is meant to be a living archive of Android presentations, articles, videos, whatever that I've presented, co-presented, written, been a witness to, or simply enjoyed and learned from. People ask for this stuff occasionally ("Where can I learn more about performance tuning on Android?" or "Where can I see more videos of Romain? He's so dreamy, with that almost-real French accent!"), so I thought it would be worth recording the links somewhere where I can add new ones over time as stuff comes online (and delete old ones as they become obsolete).

I'll attempt to categorize things, but there is overlap on these topics. So the studious developer will, of course, watch and read everything. Twice.

The links are presented in rough reverse-chronological order in each section. Some talks date way back to 2010, but they're still relevant today (the advantage of APIs that don't go away...).

General Android Development

Android Developers Backstage (Tor Norbye, Chet Haase, and guests)
Tor and I interview other Android developers to talk about whatever it is that they do to help developers better understand how that stuff works.

Performance

Android Performance Workshop, Part 1 (Devoxx 2013) (Romain Guy & Chet Haase)
This presentation is all about memory on Android: how the system works, things to think about to avoid garbage collection, and tools to use to help detect and debug problems.

Android Performance Workshop, Part 2 (Devoxx 2013) (Romain Guy & Chet Haase)
This talk covers some platform improvements, performance tips, and case studies of chasing and fixing performance issues.

Android Graphics Performance (Google I/O 2013) (Romain Guy & Chet Haase)
More performance tips with demos of using the tools to find and fix problems.

Android Performance Case Study (Romain Guy)
This article from Romain shows how he used many of Android's performance tools to debug performance issues like overdraw on a real world app.

For Butter or Worse (Google I/O 2012) (Romain Guy & Chet Haase)
Romain and I discussed the graphics architecture of Android, along with various tips for achieving better performance.

Important Android Stuff, Part 2 (Devoxx 2012) (Romain Guy & Chet Haase)
More performance tips, more tools usage, more finding and fixing performance problems. More, more, more.

Android Tools (Devoxx 2011) (Romain Guy & Chet Haase)
A talk about some of the tools and techniques used for finding and fixing performance problems.

Android Performance Patterns (Colt McAnlis)
This series of videos from Colt helps you understand how things work and what you need to know to write better performing Android apps.

Graphics & Animation

Material Design (Devoxx 2014 keynote) (Nick Butcher & Chet Haase)
This talk is a combination of the design underpinnings of Material Design and some the platform API details for writing Material Design applications on both Android and Polymer.

Material Witness (Devoxx 2014) (Romain Guy & Chet Haase)
A talk about some of the Material Design APIs and techniques in the Android 5.0 Lollipop release, showing how they are used in a couple of sample applications.
This talk overlaps with a talk by the same name at Google I/O 2014, but this version is updated to the final APIs (the Google I/O talk was based on the APIs in the L Developer Preview release).

Material Science (Google I/O 2014) (Adam Powell & Chet Haase)
This is a talk on writing Material Design applications. Some of the API details have changed since this presentation, since it was based on the L Developer Preview release, but the underlying ideas of developing for Material Design is the same.

Important Android Stuff, Part 1 (Devoxx 2012) (Romain Guy & Chet Haase)
An overview of the Animation APIs, both pre-3.0 (the android.view.animation classes) and post-3.0 (the android.animation classes, Object Animator, etc.).

Curved Motion in Android (Chet Haase)
New APIs in Android 5.0 Lollipop make this much easier (and built into the platform), but this article explains how to use ObjectAnimator and TypeEvaluator to make your animations curve on earlier releases.

Android Graphics and Animation (Devoxx 2010) (Romain Guy & Chet Haase)
Romain and I talk about the general process of rendering Views on Android, graphics APIs for achieving various graphical effects, and the pre-3.0 Animation APIs.

Dive Into Android, Part 1 (Devoxx 2010) (Romain Guy)
Romain talks about the broader concepts of layout on Android, and the various built-in layout classes to use. He then steps through an example of creating a simple custom layout, to explain the process of measurement and layout that such a subclass must handle.

Dive Into Android, Part 2 (Devoxx 2010) (Romain Guy & Chet Haase)
Tips and techniques for creating graphical effects in Android applications.

Writing Custom Views for Android (Google I/O 2013) (Romain Guy & Adam Powell)
Romain and Adam Powell talk about custom views.

Stick GUIs (Romain Guy & Chet Haase)
Romain and I talk about various rich graphical effects for Android applications.

Android's Font Renderer (Romain Guy)
Romain's article about how Android renders text using the GPU.

DevBytes (Chet Haase & many others)
It's definitely worth checking out the DevBytes playlist. The content there is diverse, but it's clear to tell from the title whether it's something that you're interested in, and they all provide a quick deep dive into their topic of choice. There are a bunch of videos specific to animation and graphical effects, but there are many more videos on a wide range of Android topics.

Devoxx 2013 Presentations

All of the talks from Devoxx 2013 are now freely available on the parleys.com website. This includes all of the talks that I did with Romain Guy on Android:
Filthy Rich [Android] Clients
What's New in Android
Android Performance Workshop Part 1
Android Performance Workshop Part 2

There's also an interview about the new features in KitKat.

Then there's this somewhat less relevant Patterns, Shmatterns talk I did about software design patterns.

All of the slides from the Android talks are posted on Romain's blog.

Google I/O 2014: Rehash

All of the videos have been posted from the various sessions I was in this year. Here they are, along with links to the slides.

What's new in Android

A presentation with +Dan Sandler that provides a quick overview of some of the larger features and new APIs in the L Developer Preview release and other new bits in the recent Androidosphere. There's also a really good deep-dive into Notifications, since Dan's the non-local expert on the subject.

Slides (PDF)

---

Material science

This session, presented with +Adam Powell, provides an overview of the engineering side of the Material design system. Many of the other sessions at Google I/O this year discussed the design side; this presentation covers the technical details of the APIs and the capabilities exposed by the framework for Android developers.

Slides (PDF)

---

Material witness

I was happy to be joined once again by former Android developer and UI Toolkit team lead +Romain Guy for this talk on some of the new Material design elements in the L Developer Preview release. The idea behind this talk was to go a bit deeper into using and explaining the new APIs, as well as explaining how some of the features, like realtime soft shadows, work.

For slides as well as demo code, check out Romain's blog at curious-creature.org.

---

Android fireside chat

This session, organized and moderated by +Reto Meier, I found to be more interesting than other such panels I've seen. Often, these things tend to have a lot of awkward silences as the panelists try to figure out the most interesting way of saying "No comment" since there's a general policy on Android of not talking about future development plans. This time, there was a lot of discussion around how and why some parts of the system work, which I enjoyed as an audience member that just happened to be sitting somewhat closer to the panel.

Android KitKat: Developer Info

We just released Android KitKat and posted lots of information about it:

Developer highlights: http://developer.android.com/about/versions/kitkat.html

Android Developers Blog: http://android-developers.blogspot.com/2013/10/android-44-kitkat-and-updated-developer.html

Videos (an overview one plus lots of others that dive deeper into specific features): https://www.youtube.com/watch?v=sONcojECWXs&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K&index=1

I'll specifically call out the video on Transitions, which is something I recorded last week after finally finishing the feature. I hope that the API is another step toward making animations easier and more automatic in Android applications.

DevBytes: Cartoon Animation Techniques

This time, we wrap up the series on cartoon animation techniques with a demo that shows a few of the techniques in the context of a larger application. Because it's nice to know how to write the code, but you might also be wondering why you might want to.

For some real-world context, you could also check out games such as Candy Crush Saga (a horribly addictive game I've gotten sucked into that's less like casual gaming and more like casual crack). It uses a veritable plethora of cartoon animation techniques to keep the player engaged with the game and disengaged from their life.

This and other cartoon animation techniques were discussed in the talk A Moving Experience at Google I/O 2013

Code: http://developer.android.com/shareables/devbytes/ToonGame.zip

YouTube: https://www.youtube.com/watch?v=8sG3bAPOhyw&list=PLWz5rJ2EKKc_XOgcRukSoKKjewFJZrKV0

DevBytes: Squash & Stretch

Cartoon animation uses a technique called "squash & stretch" for achieving different effects of objects interacting with their environment.

This episode shows how we can use similar techniques to get more organic and lively animations in user interfaces.

This and other cartoon animation techniques were discussed in the talk A Moving Experience at Google I/O 2013.

Code: http://developer.android.com/shareables/devbytes/SquashAndStretch.zip

YouTube: https://www.youtube.com/watch?v=wJL1oW6DlCc

Or, in illustrated form:

DevBytes: Anticipation & Overshoot, Part 2

Like my previous DevBytes episode, Anticipation and Overshoot, Part I," this episode covers cartoon animation techniques for making UI elements more engaging and playful. The code in this episode shows how to change and animate how a button is drawn to make it seem more alive and organic.

This and other cartoon animation techniques were discussed in the talk A Moving Experience at Google I/O 2013.

Code: http://developer.android.com/shareables/devbytes/Anticipation.zip

YouTube: DevBytes: Anticipation and Overshoot - Part 2

DevBytes: Anticipation and Overshoot, Part 1

Some principles of cartoon animation can be used to provide more engaging and more interactive experiences in applications.

This episode demonstrates principles of anticipation and overshoot with a simple button click, showing how to animate changes in the button's appearance to make it interact more playfully with the user.

This and other cartoon animation techniques were discussed in the talk A Moving Experience at Google I/O 2013

Code: http://developer.android.com/shareables/devbytes/LiveButton.zip

YouTube: https://www.youtube.com/watch?v=uQ7PTe7QMQM

DevBytes: Curved Motion

This is a demo that +Romain Guy and I showed in our A Moving Experience talk at Google I/O this year, showing how to use the existing TypeEvaluator and Animator APIs to get curved motion for your animations.

In the real world, things don't move in straight lines. Moving items around on the screen should feel as natural as possible; sometimes curved motion can help.

This episode shows how to use the existing animation APIs to get easy curved motion for your UIs.

The helper classes come from an article I posted on my blog last year:
http://graphics-geek.blogspot.com/2012/01/curved-motion-in-android.html

YouTube: https://www.youtube.com/watch?v=JVGg4zPRHNE

Code: http://developer.android.com/shareables/devbytes/CurvedMotion.zip

DevBytes: Animating Multiple Properties in Parallel

Suppose you want to animate multiple properties in parallel on some target object. How would you do it? ValueAnimator? Multiple ObjectAnimators?

This episode covers different ways of animating multiple properties, and specifically covers the use of the lesser-known PropertyValuesHolder class.

YouTube: https://www.youtube.com/watch?v=WvCZcy3WGP4

Code: http://developer.android.com/shareables/devbytes/MultiPropertyAnimations.zip

DevBytes: Animating ListView Deletion: Now on Gingerbread!

In this episode, I tried to anticipate the question I knew would come up on my previous show about animating ListView deletion: "But how would I do this on Gingerbread?"

Here's how.

YouTube: https://www.youtube.com/watch?v=PeuVuoa13S8&list=PLWz5rJ2EKKc_XOgcRukSoKKjewFJZrKV0&index=1

Code: http://developer.android.com/shareables/devbytes/ListViewItemAnimations.zip

DevBytes: Animating ListView Deletion

It's Friday: must be time for another DevBytes episode.

Finally, here is the DevBytes episode around the ListView animation demo in the talk A Moving Experience that I gave with Romain Guy at Google I/O last month.

The code is nearly the same as that in the I/O talk, except I tweaked it to make it more general-purpose. Specifically, it no longer depends on the setHasTransientState() method (introduced in Jellybean 4.1) to keep the views around while fiddling with layout. Instead, it uses an adapter with stable itemIds, and uses those Ids to track where the content is before and after layout.

As written, the code is still dependent on Android 4.1, but that's only because of the use of ViewPropertyAnimator.withEndAction() method, which is really just syntactic sugar around adding a listener and running the end-action code in the onAnimationEnd() callback. So you could totally port this code all the way back to Android 3.1 (when ViewPropertyAnimator was introduced) or even 3.0 (if you use ObjectAnimator instead).

Watch the video. Check out the code. Play with ListView. Animate. Enjoy.

A Moving Experience: http://www.youtube.com/watch?v=ihzZrS69i_s

DevBytes on YouTube: http://www.youtube.com/playlist?list=PLWz5rJ2EKKc_XOgcRukSoKKjewFJZrKV0

Code: http://developer.android.com/shareables/devbytes/ListViewRemovalAnimation.zip

DevBytes: Custom Activity Animations

It's Friday: time for another DevBytes.

It's been a while, but they're back. At least until the queue runs out again and I write another glut of demos to talk about.

This episode, and most of the upcoming ones (teaser alert!) are around demos/code that we showed in A Moving Experience, the animation talk that +Romain Guy and I gave at Google I/O 2013.

Custom Activity Animations:
Window animations provide an easy way to animate transitions between activities. The animations can be customized to some extent, but there's only so much interaction between the launching and launched activities that you can take advantage of with the standard window animations.
This episode covers a different technique for fully customizable animations.

Video: http://www.youtube.com/watch?v=CPxkoe2MraA

Code: http://developer.android.com/shareables/devbytes/ActivityAnimations.zip

Google I/O Presentations Now Live

Romain Guy and I gave two talks at Google I/O yesterday which are now live on YouTube:

Android Graphics Performance: http://www.youtube.com/watch?v=vQZFaec9NpA



Slides for Android Graphics Performance are posted on Romain's blog.


A Moving Experience: http://www.youtube.com/watch?v=ihzZrS69i_s



A Moving Experience Slides:

• Keynote
• PDF
• PDF with speaker notes

The code from the animation demos will be posted soon, probably in conjunction with future DevBytes episodes.

DevBytes: Layout Transitions

The LayoutTransition class (added in Android 3.0) enables easy fade/move/resize animations when items are added to or removed from a ViewGroup, usually with just one line of code. This video shows how this works and also shows the new ability added in JellyBean (Android 4.1) to animate other changes to the layout as well, not limited to items being added or removed.

YouTube:
https://www.youtube.com/watch?v=55wLsaWpQ4g

Code:
http://developer.android.com/shareables/devbytes/LayoutTransChanging.zip

DevBytes: PictureViewer

PictureViewer: How to use ViewPropertyAnimator to get a cross-fade effect as new bitmaps get installed in an ImageView.

TransitionDrawable is a handy and easy facility for cross-fading between two drawables. But if you want to cross-fade between an arbitrary set of images, you might want something more general-purpose. Here's one approach.

YouTube: https://www.youtube.com/watch?v=9XbKMUtVnJA

Code: http://developer.android.com/shareables/devbytes/PictureViewer.zip

DevBytes: Request During Layout

Horrible things can result from calling requestLayout() during a layout pass. DON'T DO THIS.

The demo that I wrote to show why this is bad seems very contrived, but I have since run across application code that did nearly the exact same thing, explicitly calling requestLayout() during onLayout(). Ugh. Typically, the cases where this problem occurs are a tad more subtle than that.

YouTube: https://www.youtube.com/watch?v=HbAeTGoKG6k

Code: http://developer.android.com/shareables/devbytes/RequestDuringLayout.zip

Crystal Methodology: The Future of Software Development Process Methodology Effectiveness

Most people that know me know that I can't say enough about process. In this presentation at Devoxx 2012, I tried to change that.

If the embed below isn't working for you, you can watch the talk on the parleys.com site.

DevBytes: ListView Deletion

How animating ListView views can lead to artifacts if those views are recycled before you animate them.

YouTube: https://www.youtube.com/watch?v=NewCSg2JKLk

Code: http://developer.android.com/shareables/devbytes/ListViewDeletion.zip

DevBytes: ListView Animations

How animating ListView items can lead to problems as views are recycled, and how to perform these types of animations correctly with new API added in Jellybean.

Code: http://developer.android.com/shareables/devbytes/ListViewAnimations.zip

YouTube: https://www.youtube.com/watch?v=8MIfSxgsHIs