A more robust approach to unit testing

The most common approach to unit testing is "one class = one unit": for each class, you write a unit test.
But this approach lacks robustness. It produces brittle tests which need to be rewritten when you refactor. It encourages developers to simply rewrite their code as a test, meaning their tests mirror code bugs. And over-reliance on mocks/fakes significantly limits the breadth of the test.

This talk presents a different approach. By focusing on user interactions, not code units, we can optimise our testing and largely solve these problems.

Through concrete, practical examples we will learn:
- How to write robust tests which don't need rewriting when you refactor
- How to tailor tests to actions users perform, not specific code implementations
- Why fakes are often better than mocks

UI layer sorcery

The real magic of an Android app happens in the UI layer. It's more than just presentational: it's about organising flows, exposing data and handling user actions. A well architected UI layer does this in a way that's efficient, scalable, maintainable and testable.

In this talk we will learn the intricacies of UDF architecture (Unidirectional Data Flow) and several strategies for handling UI state in a consistent manner. I will demonstrate how to create the magic using Kotlin + Coroutines + Flows + Compose.

Think like a hacker: Secure coding in Android

Strong Android apps have security built into the architecture and in the fabric of the code.
Through demonstration of real hacking techniques, learn to improve your app's security. Use the latest Android features to protect your app and its data.

The science of a commercially successful app

All apps exist for commercial gain. Whether it's through in-app purchases or ads, or by augmenting real-world products and services, commercial success can be measured, tested and improved.

This talk provides sensible, practical advice on how to maximise your app's commercial potential, including:
- Which monetisation strategies work (and why ads are less effective in 2024)
- Why user experience is crucial and how to continually improve it
- Techniques for generating more downloads from your store page
- Why reviews matter, but probably less than you think
- How effective strategies differ for apps vs games, and for Android vs iOS

This is a code-free non-technical session suitable for app stakeholders, marketeers and CxOs as well as indie developers

Secure user authentication without passwords in Android apps

Jetpack Credential Manager's recent support for passkeys means you can secure user data without relying on passwords or third-party auth.
Why is this important? Passwords are insecure because user behaviour is insecure. Users are subject to phishing attacks, they store passwords insecurely, and they pick guessable ones. Passkeys are the new industry-standard way of solving all these problems.

In this talk, you will learn:
- What passkeys are and how to generate them in your apps
- How to authenticate users using passkeys
- How to store and retrieve passkeys using Jetpack Credential Manager

Let's build a modern camera app in Android

Using the Jetpack CameraX library we can build modern camera experiences in Android apps super-easily.
This talk will demo how to integrate photo and video capture into your app, including:
- The latest updates to CameraX as seen in Google I/O '24
- The modern way to capture and preview images and video
- How to use device-specific features like portrait mode, night mode and face retouching
- Applying transformations such as rotations and cropping - or passing output to AI methods.

Architectural slices: The magic of the UI layer

The real magic of an Android app happens in the UI layer. It's more than just presentational: it's about organising flows, exposing data and handling user actions. A well architected UI layer does this in a way that's efficient, scalable, maintainable and testable.

In this workshop we architect a UI layer from scratch. We will learn the intricacies of UDF architecture (Unidirectional data flow) and several strategies for handling UI state in a consistent manner. We will use Kotlin + Coroutines + Flows + Compose.

Participants will need a laptop with Android Studio and either an Android device or VM.

A clean architecture for Jetpack Compose apps

Compose's code style lends itself well to modern architecture principles. Developers should work on features, not code maintenance.
I present a clean architecture which allows you to deliver secure, extensible, scalable code using Jetpack Compose, and show it it can be tested effectively.
See how this lends itself to getting the best out of every member of a dev team, from junior to senior.

Asynchrony and the infinite conveyor belt: Advanced coroutines and flows

Most likely, you already know how to use coroutines and flows. They're part of our everyday existence. But all too often we learn them through repetition and rote learning, rather than forging a meaningful understanding of what's happening deep down.
So:

- What *really* happens when you mark a function as 'suspend'?
- How come crazy things like infinite loops on the main thread are possible?
- What's the magic link between coroutines and flows?
- What, really, is a scope? A context? A job?

And there's a satisfying conclusion, too! We find that everything is linked: the path that seems to add complexity, in fact takes us back full circle.

This is intended as a vertical dive into the intricacies of a familiar topic, designed so that experienced developers as well as beginners can learn from it.

It's based on my most popular blog series on asynchrony: https://proandroiddev.com/coroutine-patterns-in-android-and-why-they-work-3bf085f53536

Android + MediaPipe + Gemma: Building offline AI-powered apps

Yes, you can run AI models locally on your Android phone! There are many benefits to this: it improves privacy, since nothing leaves the device; it works fully offline; and it saves money on cloud-based services.

In this talk I will show how to build a fully-offline Android app with AI capabilities. We'll see:
- How to run an entire LLM on your phone, thanks to MediaPipe + Gemma
- How AI can tell us what's in a photo
- How gesture recognition works on a live video stream
...and many other things MediaPipe can do

Don't fight the architecture

Good architecture smooths the development path of your Android app for years to come. Bad architecture results in developers spending more time maintaining code and fixing bugs than adding features.

Google's best practice guidelines have changed considerably recently, and the way we develop Android apps is very different from even just a few years ago. But more important than learning the rules is understanding the principles that underpin them, so you can make your own decisions.

So what does good Android app architecture look like? This talk is all about how to be a better, more forward-thinking developer.

After a brief tour of SOLID principles (beloved of interviewers for almost any programming role), we will explore the purpose of Clean Architecture, as well as patterns like MVVM. And finally we will see how a lot of this converges in Google's Modern App Architecture, and how more recent technologies like Hilt, Kotlin Flows and Jetpack Compose make life a lot easier.

This session is aimed at seasoned developers and those looking start a career in software development. Whilst all the examples are with Kotlin + Android, the underlying principles apply whatever your language.

This is an intermediate level talk which assumes a working knowledge of programming. Whilst all examples use Android + Kotlin, the basic principles apply equally to any programming language.

Fun with Android + Bluetooth: A capture-the-flag competition

Android is the perfect platform for hacking with Bluetooth peripherals. Learning how to connect to BLE devices is not only a useful skill for professional developers, it’s also massive fun! Recent releases of Android have improved how BLE interaction works, and this session takes you through the latest Android 14.

It's built around a capture-the-flag competition: the first person to write an app to read my password, wins!

Learn:

- How to write code to send and receive messages from an Android device to any BLE peripheral
- How Android communicates with a BLE device
- All about BLE - how it works and what makes it different to Bluetooth Classic.

And when you get back home you’ll want to try out connecting with all the BLE devices you have lying around! Heart rate monitors, thermometers, proximity sensors, lights, radios, TVs, keyboards, garage doors, …

A very basic understanding of Android development is required. People will need a laptop with Android Studio and, if they want to join the competition, a physical Android device (not VM). I will bring a limited number of devices with me for those who don't have their own.

Beyond mockery: Adventures in Android unit testing

The usual "one class = one unit" approach to unit testing lacks robustness. It produces brittle tests which need to be rewritten when you refactor. It encourages developers to simply rewrite their code as a test, meaning their tests mirror code bugs. And over-reliance on mocks significantly limits the breadth of the test.

This talk presents a different approach. By focusing on user interactions, not code units, we can optimise our testing and largely solve these problems.

Through concrete, practical examples we will learn:
- How to write robust tests which don't need rewriting when you refactor
- How to tailor tests to actions users perform, not specific code implementations
- Why fakes are often better than mocks