Sessions List

Come to the Ask Android Office Hours area to get your questions answered with Google experts on topics including: Compose, Navigation 3, Performance, AI on Android and more… These topics will be covered during this office hours session: Adaptive Apps, Testing Tools

Come to the Ask Android Office Hours area to get your questions answered with Google experts on topics including: Compose, Navigation 3, Performance, AI on Android and more… These topics will be covered during this office hours session: Performance, Passkeys

Come to the Ask Android Office Hours area to get your questions answered with Google experts on topics including: Compose, Navigation 3, Performance, AI on Android and more… These topics will be covered during this office hours session: Navigation 3 Camera and Media

Come to the Ask Android Office Hours area to get your questions answered with Google experts on topics including: Compose, Navigation 3, Performance, AI on Android and more… These topics will be covered during this office hours session: Compose, AI on Android

Join us for an interactive discussion with Google's Bangalore-based Developer Relations team moderated by community leader Jitin Sharma. This is your chance to hear candid and unscripted responses to pressing questions from the community.

Android Studio's AI capabilities are getting major updates. In this talk, we'll explore the newest features of the Android Studio agent, an Android-native assistant designed to accelerate your workflow from design to code. We'll showcase how the agent can handle complex, multi-step tasks, such as refactoring large codebases, generating and running tests, updating dependencies, and fixing build errors. We'll also cover a suite of new UI-specific features. Discover how to instantly convert visual designs and screenshots into production-ready Jetpack Compose code and transform UIs using simple natural language directly from the Compose Preview. We'll also demonstrate how you can generate Compose Previews and their necessary sample data, and even suggest accessibility improvements.

Kotlin Multiplatform is no longer just experimental. It is now powering production apps at scale. But what does adoption really look like in a large app with millions of users? In this session, you’ll learn how the Physics Wallah app (10M+ downloads) adopted Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP), even when CMP for iOS was still in its early alpha stage. You’ll explore why the team chose KMP, how it helped deliver features faster across Android and iOS, and the challenges faced along the way. You’ll discover how KMP reshaped engineering culture by merging separate iOS and Android teams into a single mobile team, improving collaboration and reducing duplicated effort. On the technical side, you’ll dive into how the team introduced an umbrella architecture within their repo to speed up building, testing, and sharing iOS frameworks. By the end, you’ll know what it really takes to adopt KMP and CMP at scale — the wins, the challenges, and the practices that helped us unify mobile development in one of India’s biggest apps. We’ll also have time for Q&A.

Jetpack Compose has redefined how we build UIs... but most apps still fall back on ViewModels and scattered logic that don’t scale well. As complexity grows, this leads to inconsistent screens, hard-to-reproduce bugs, and duplicated code. In this talk, we’ll look at how to move beyond MVVM/MVI into a reactive state machine model that fits Compose’s declarative style. You’ll learn how to design clean state contracts, coordinate transitions across navigation stacks and dialogs, and handle side effects like navigation or snackbars in a predictable way. We’ll also cover async patterns, modularizing domain state, debugging techniques for tracking state evolution, and testing UIs with simulated states and time-based transitions. By the end, you’ll leave with practical techniques to make Compose apps more scalable, debuggable, and easier to maintain.

Android apps are stepping into an era where intelligence isn’t a novelty—it’s an expectation. Users want apps that can anticipate needs, act autonomously, and collaborate to get things done. Stitching APIs and hardcoding logic no longer scales to meet this demand. In this session, we’ll explore how Firebase Genkit enables developers to build multi-agent (A2A) Android apps using its Agent–Flow–Tool architecture. Genkit makes it possible to design agents that operate independently, delegate tasks, and use LLM-powered reasoning, planning, and natural language to make smarter decisions. We’ll bring this to life with a demo: a smart cooking assistant powered by a Chef Agent, Recipe Agent, and Inventory Agent. Together, they discover recipes, check available ingredients, and suggest dynamic menus. Through live coding and walkthroughs, you’ll see how to design and connect agents, manage errors gracefully, and keep systems scalable. By the end, you’ll walk away with a clear framework for building modular, intelligent, and production-ready Android apps—whether in the kitchen or in any industry that benefits from collaborative agents.

Navigating between screens should be simple, yet it's often a source of complexity. In this session, we'll explore Jetpack Navigation 3 - a new library for navigation that reduces this complexity and puts you in control. Learn how to create screens, navigate between them and encapsulate your navigation code using this new API.

AI tools are moving fast, but what do they really mean for Android and Kotlin Multiplatform developers? In this talk, I’ll show how AI coding agents such as Google’s Gemini and Junie can fix bugs, refactor messy code, and even generate new features. We’ll also explore Model Context Protocols (MCPs), a way for multiple AI helpers to work together. For example, one agent pull the issue description, another might read the external repo related to the project, and another search internet and come up with facts, so repetitive dev tasks get done faster and with fewer errors. This won’t be theory. You’ll see real demos with numbers and edge cases. I’ll show where these AI agents actually save time in Android and KMP development, where they stumble or fail completely, and how you can use them safely in your own projects. By the end of this session, you’ll have a clear and realistic picture of how AI fits into your workflow today - the wins, the pitfalls, and how to ship better app code week after week.

This talk will help break down how to use Perfetto to find problems in the app that are worth investigating. We will also look at instrumenting the app to emit traces using custom Gradle plugins; and subsequently look at writing custom Perfetto plugins to help highlight performance problems in your Android application. You will learn to: Implement Custom Tracing: Leverage the power of custom Gradle plugins to seamlessly instrument your application and emit bespoke trace events, giving you unparalleled visibility into your app's logic. Automate Analysis: Use Perfetto TraceProcessor to process your unique trace data, automatically highlighting regressions and surfacing complex performance problems specific to your application.

Monitoring performance and stability on mobile apps is often limited to crash rates and app launch times. But as apps become critical business drivers, metrics must evolve to capture more complex and granular signals—like page load latency and mean time to complete critical flows. As you measure deeper, cracks begin to appear in happy paths, helping uncover those elusive P99 problems and hard-to-reproduce edge cases. This talk will focus on building an observability mindset for Android apps—covering what, when, and how to measure. We'll also explore emerging solutions like OpenTelemetry and show how Android apps can integrate into mature observability backends used by modern infrastructures.

In this session, you will learn about how to add different AI effects to your camera and media pipeline in your Android app

Most AI for Android talks end at showing a snippet of Kotlin generated by a model. But if you’ve ever shipped an app, you know that’s just 10% of the job. In this session, I want to share how I’ve been using Gemini Code Assist inside Android Studio and the Gemini CLI to help with the tougher parts: wiring up Compose screens, creating test coverage on the fly, and even trimming down painful Gradle build times. I’ll also show how AI can be slotted into release pipelines so that it’s not just “helping with code” but actually supporting the whole lifecycle. This talk comes out of real experiments with enterprise teams where some things clicked instantly and others failed spectacularly. You’ll see live demos, a few patterns that genuinely saved me time, and some hard-learned lessons about where AI still struggles. Key Takeaways : 1. Why I think about Android work in two loops: inner (code/debug/test) and outer (build/release) and how AI fits into both. 2. Examples of using Gemini Code Assist for Compose screens and tests that actually made it into production. 3. How Gemini CLI plugged into CI/CD and helped cut down build headaches in my experiments. 4. Lessons from my failures - where AI didn’t work, and what I would do differently next time. 5. A realistic view of what’s possible now vs. what’s still hype in AI for Android.

Open source Android libraries are powerful tools—but with great power comes great responsibility, especially when it comes to your public API. In this talk, we’ll dive into the practical challenges of building Android libraries in the open, and how to thoughtfully design, document, and maintain your public-facing APIs. I’ll share lessons learned from real-world projects, including: - How to decide what should be public vs internal - Using tools like @RestrictTo, internal, and visibility modifiers effectively - Planning for stability and deprecation strategies - Communicating changes with users and contributors - Avoiding accidental API exposure in Kotlin

Server Driven Cross-Platform UI Revolution to Take Over WebViews WebViews are everywhere, they're fast to deploy, easy to update, and flexible. But they’re also brittle, hard to maintain, and pose serious security risks to the app specially for fintech domain. We asked ourselves: Is there a better way to deliver dynamic content across platforms without the WebView baggage? In this session, we’ll share how we’re replacing WebViews with a fully native, server-driven UI framework built using Kotlin Multiplatform and Jetpack Compose Multiplatform. You’ll get a deep dive into how we designed our dynamic UI engine, how we defined a JSON-based UI schema, and how we ensured performance and flexibility across Android, iOS and Desktop too all in a single Kotlin codebase. Expect real-world lessons from our rollout, performance benchmarks, and how Compose Multiplatform helped us build fast without learning Flutter or React Native. If you’re tired of maintaining complex WebViews and want a modern, secure, cross-platform Kotlin-native solution for dynamic UI, this talk is for you.

Gojek, Southeast Asia's leading super app with over 100 million+ downloads, faced a critical challenge: an escalating rate of Application Not Responding (ANR) events and frozen frames, which severely impacted user experience and app visibility. Our user-perceived ANR rate peaked at a troubling 1.3%. This session will dive deep into the comprehensive strategy we deployed to systematically combat this issue, successfully achieving a 65% reduction in our user-perceived ANR rate. We'll explore both the proactive architectural changes and the real-time incident response techniques we used to stabilize a massive, feature-rich application. Learn how a large-scale engineering team identified and resolved the subtle, often non-obvious causes of thread blockages, transforming the stability of one of the world's largest on-demand platforms. - Decoding Non-Actionable ANRs: Learn our methodology for investigating and resolving deeply entrenched issues like the "Native poll once" ANR, which accounted for 90% of our original ANR logs but offered no direct stack trace. - Proactive Prevention via Tooling: Understand how to build custom lint rules and coding restrictions specifically tailored to prevent common ANR patterns, making your code safer before it ships. - Advanced Debugging Workflows: Get a practical look at using powerful tools like Perfetto and Android Studio Profiler to triage and identify the root cause of ANRs, moving beyond simple logcat analysis. - Identifying Large-Scale Patterns: Discover the common thread-blocking patterns we observed across our ANR fixing journey and we believe sharing this will be helpful to solve the ANRs across the domain like using device class base system to provide device wise features as per device capability, Object parsing efficient way, and many more

Every user interacts with an app differently yet most apps treat everyone the same. What if your Android app could actually learn from each user and adapt over time, while still keeping their data safe? In this talk, I’ll share how to build privacy-first personalization into Android apps using simple, practical tools that are already available like ML Kit, TensorFlow Lite, and Android’s Smart Features APIs. We’ll look at how apps can track meaningful user behavior, store preferences securely, and use lightweight on-device models to deliver smarter recommendations or dynamic UI experiences. I’ll also touch on how federated learning concepts can help apps improve personalization collectively, without sharing raw user data. The goal is to show that AI-powered personalization doesn’t have to mean massive cloud systems it can be fast, local, and ethical. Key Takeaways: - Learn how to make Android apps adapt to users through on-device learning. - Understand how to collect user interaction data safely and transparently. - Explore ML Kit and TensorFlow Lite for real-world personalization use cases. - Apply privacy-first techniques using federated learning ideas. - See how responsible AI can boost both engagement and user trust.

How do you make AI testing trustworthy—and fast? We’ll unpack Drizz’s approach to interpretable prompting (GEPA) and a decision-tree policy that tames hallucinations for deterministic results. Then we’ll show how dynamic caching (screen/command-level) turns repeated flows into sub-second lookups, driving measurable gains in accuracy, time, and cost. Expect real Android case studies, live flows, and practical patterns you can use to harden your CI without locator hell.

Imagine using an app and the app dies/crashes under a resource constrained environment while you’re doing something important & you needed the app the most. Under such conditions, the app performance isn’t just about being smooth or non sluggish, it actually hinders the ability to use the app in a productive way. This directly influences the effectiveness and usability of the app. This session talks about how we’ve envisioned apps to be resource aware(or adaptive) and shifting the paradigm from being reactive firefighting to proactive adaptation. We’ll walk you through the design of adaptive app framework which is a new framework that monitors device health in real time, smoothen noisy signals into stable signals and empowers feature teams to gracefully degrade under stress instead of crashing or causing regression in rollouts. We’ll talk about how we have designed a lightweight profiler that runs safely in production. This framework takes into account battery drain, memory pressure, thermal stress, network conditions and different business related rules too to take informed decisions in predicting the app health state. We’ll also talk about the strategies for keeping the health signal stable, avoiding flip-flopping and how we can ensure core experience remains reliable under degraded conditions. Whether you’re building a large scale consumer app or smaller product app, your app must perform reliably in a resource constrained(or stressed) environment across a diverse spectrum of devices. This talk will provide you techniques to design apps that remain reliable and resilient under real world resource constrained conditions.

Kotlin Multiplatform showed us how to share logic. The next frontier is making that shared logic intelligent — and keeping it fast. This advanced session dives deep into how AI agents integrate within modern Kotlin-based Android architectures using Koog, Gemini Nano, and Vertex AI. We’ll explore how to run agents safely and efficiently across Android, iOS, and backend targets — with a strong focus on runtime performance, profiling, and observability. You’ll see how to design and tune agent lifecycles, optimize coroutine-based concurrency for background inference, and measure real-world behavior when running MediaPipe GenAI models locally. We’ll cover how to analyze (profiling) CPU and GPU utilization, memory pressure, and thread contention when agents are reasoning offline — and how to interpret those traces to find bottlenecks in on-device inference. We’ll close with production-ready strategies: structured fallback hierarchies, adaptive inference pipelines, and system-level optimizations that help AI-driven Kotlin apps remain responsive, energy-efficient, and scalable in real-world conditions. By the end, you’ll walk away with a deep understanding of how to embed, measure, and optimize intelligence directly inside your Android codebase — not just integrate it.

Every engineer eventually inherits a legacy codebase — a complex beast that slows down innovation and frustrates teams. But how do you start taming it? What truly constitutes "legacy," and where do you strike first for maximum impact? This talk shares hard-learnt lessons from the front lines of building and re-architecting some of the world's most complex food delivery apps at Foodpanda, Foodora, and Delivery Hero. We will move beyond theory to offer a practical playbook for transforming large-scale Android applications while navigating the intricate dance of technical vision and business demands. This session will cover five key lessons: Defining Legacy: A framework for identifying legacy code, locating architectural hotspots, and strategically choosing your first refactoring target. The Conundrum of Refactor vs. Rearchitect: Understanding the critical difference, when each approach is relevant, and what they truly entail for your team and timeline. The Marriage of Product & Engineering: Mastering the balancing act of delivering new features while simultaneously executing a large-scale re-architecture without losing momentum. Convincing Stakeholders: How to effectively communicate a compelling technical vision, get buy-in from product and business leaders, and become a trusted team player. Choosing Your Weapons: A pragmatic guide to selecting the right architectural patterns, tools, and modularization strategies for the job at hand. Join this session and tackle your most daunting legacy challenges in your code-bases, leaving with a playbook that has been tested and proven at scale.

Join us on an enlightening quest as we unravel the realm of Compose UI performance. With a multitude of tools at our disposal, the challenge lies in knowing where to start and how to choose. Together, we'll diagnose and optimize a flawed app in real-time, providing you with practical insights and guidelines to navigate the world of Compose UI performance! Agenda: - Introducing the Janky App: Showcasing the flawed app and its evident performance issues. - Performance Toolkit: Exploring diagnostic tools like Layout Inspector, Systrace, etc. - Live Coding Demonstration: Real-time diagnosis and optimization of the janky app to improve its performance. - Assessing Performance: Evaluating the app's performance before and after optimization. - Building the Runbook & Discussing Performance Pitfalls: Creating a troubleshooting guide for common Compose UI performance bottlenecks, with strategies to avoid them. By journey's end, you'll know where to start and what tools to start with to diagnose and fix common performance issues in your Compose UI!

Modern mobile apps must do more than just work. They must work smartly, even when offline. (Think of common applications like Twitter or Instagram.) This talk will walk through building an AI-enhanced, offline-first architecture on Android using Jetpack and custom vector stores. You’ll learn how to integrate on-device LLMs, enable smooth bi-directional sync with backend stores, and adopt scalable syncing patterns used in real-world apps. We’ll also cover sync conflict resolution, data serialization formats, and an efficient approach to user-local data modeling. All without sacrificing performance.

Through this talk, my aim is to share the following - Common Mistakes People Make that Slows Down their Gradle Builds - Latest in Gradle: Configuration Cache, Parallel Configuration Cache, support/enhancements for the latest JVM - Gradle's Kotlin DSL vs Groovy: Why you should/shouldn't migrate to the Kotlin DSL - Optimising Gradle for CI/CD and Ephermal CI/CD instances - How companies with 100s of developers or huge teams manage their Gradle modules for quickest build times

Kotlin compiler plugins let you extend the compiler itself - to generate new code or modify existing code. They unlock the power to automate boilerplate code and enforce your own rules. But building them is not easy - the learning curve is steep and no official documentation. In this talk, I’ll share my journey of creating a Kotlin compiler plugin from scratch and taking it all the way to production in a real Android app. We’ll walk through the challenges, practical use cases, and lessons learned from turning plugins into tools that solve real business problems. If you’ve ever wished the compiler could just “do it for you,” this session will show you how to turn that wish into production-ready reality.

Moving to a single-activity architecture is a well-known Android best practice—but what happens when your app already has 60+ activities, multiple teams working in parallel, complex navigation patterns, and deeply entangled module dependencies? In this talk, I’ll walk you through how we at SumUp tackled this architectural tech debt in our banking app. It wasn’t a greenfield rewrite—it was a carefully planned and executed migration within an actively developed, large-scale codebase. You’ll learn: Why we decided to take on this migration and how we built alignment around it How we approached navigation and module ownership in a fragmented system What architectural decisions we made (and changed) along the way How we handled real-world blockers like inter-module dependencies and feature rollouts What tools, strategies, and communication methods helped us drive this change The tangible impact it had on development velocity, stability, and maintainability This talk offers practical takeaways for any team trying to modernize their architecture incrementally—without stopping the world.

Google's Gemini models have redefined possibilities. This essential session grants Android developers a deep, practical overview of the APIs and features at your disposal. We'll cut through the complexity, covering the critical steps: selecting the optimal model, integrating the newest on-device GenAI enhancements, leveraging Firebase AI Logic, and constructing a powerful in-app agent. Prepare to walk away with concrete code samples and a profound understanding of Google's Generative AI models, empowering you to embed cutting-edge intelligence into your apps

"The Credential Manager API has seen significant adoption since passkeys arrived on the scene. Now, Android is taking user authentication to the next level by expanding support across the entire ecosystem, from phones and watches to cars and TVs. In this talk, we'll explore how the Credential Manager API is evolving to enable seamless and secure sign-in experiences on Android Auto, Wear OS, Google TV, and beyond. We'll dive into the latest API capabilities, showcase real-world examples of successful implementations, and demonstrate how you can leverage these advancements to simplify user journeys and enhance security in your own Android apps. Key Takeaways: 1. Explore how Credential Manager extends its support to Wear, TV, and Auto, delivering a unified authentication experience across all Android devices. 2. Deep dive into working implementation of how users can automatically sign-in on new Android devices using Restore Credentials through partner showcase. 3. Discover the new & exciting Credential Manager API capabilities such as automatic passkey upgrade for existing users, credentials import/export across providers, Signal API to update passkey deletion status on user’s provider etc. 4. Engage with real-world case studies demonstrating the business metric improvements following the adoption of Credential Manager."

Key Takeaways 1-Don’t trust the device — design your app assuming the environment is hostile. 2- Secure early — architecture & decisions made before coding matter the most. 3- Use platform security — Keystore, integrity checks, and server-side validation. 4- Protect app components — validate intents, deep links, and exposed surfaces. 5- Enable runtime defense — detect root, hooking, overlays, and abuse signals.

Compose Multiplatform provides a unified codebase for Android, iOS, desktop, and beyond, but what is it really like when you start building your first app with it? As a fresh face switching over to Compose or Kotlin Multiplatform from my current setup, I have discovered the experience is full of surprises and wanders: tooling issues, debugging, platform-specific problems, and the excitement of seeing one UI finally take shape everywhere. During the course of this presentation, I'll present my real experience of starting with Compose Multiplatform: what succeeded, what failed, and what I would have wanted to know ahead of time. We'll see the initial setup errors I encountered, the difficult aspects the tutorials leave out, and the little secrets that simplified things for me. No matter if you're a Compose Multiplatform newcomer or just thinking of applying it on your subsequent project, you'll leave with a thorough understanding of the fresh developer obstacles and how to sidestep them , so that you can waste less time debugging and devote more time developing. Key Takeaways: 1. The most common setup mistakes beginners face in CMP projects 2. Debugging challenges across Android, iOS, and desktop — and how to deal with them 3. Practical tips that tutorials often leave out 4. How to avoid beginner obstacles and save time in your own project

This session aims at introducing a new AI offering from Zebra - Frontline AI Enablers. Frontline AI Enablers is a bundle comprising of fine-tuned AI Models, SDK and solution accelerators, that will help developers and partners build Enterprise grade AI applications on the Zebra's Android Mobile devices. This AI Suite is compatible to be used with Android's CameraX framework, making it a simple to use, and quick to build platform. The session will introduce the key concepts of Frontline AI Enablers, and its capabilities - especially the AI Data Capture SDK. The session will also showcase a few demo applications built using AI Data Capture SDK. The target audience will be Android developers and/or companies working on building enterprise applications on Android. https://www.zebra.com/ap/en/software/mobile-computer-software/zebra-mobile-computing-ai-suite.html

This session focuses on how Blinkit optimized app performance at scale, with emphasis on four key areas — app launch time, UI rendering, stability, and network efficiency. We'll walk through several practical strategies that drove these improvements - including App Startup Optimization, Lightweight TextView, View Caching, pre-warming the OkHttp client, lazy JSON parsing, Wi-Fi location caching and much more. We'll also introduce Droid Dex - an open-source tool that provides deep insights into device performance across CPU, memory, storage, network, and battery, helping teams make smarter, data-driven optimisation decisions like selectively delivering high-performance features to capable devices. Together, these initiatives have significantly reduced load times, improved stability, and elevated the overall user experience for millions of Blinkit users.

Screenshot testing has become popular over the last few years, but most organizations limit their screenshot testing to just core design libraries, or they might disincentivize adding screenshot tests because of scaling issues. In this talk I'll give you insights into why you might have trouble scaling up your screenshot testing efforts: from flakiness, to dealing with developer friction and education, and the more obvious issues with scaling your storage for screenshots. We'll talk through potential solutions for each of these problems. We'll also show how screenshot testing can be used as a "social" tool to demonstrate the value of your testing efforts, and encouraging more testing in your team. (After all, non-engineers can understand screenshots, even if they don't understand code.) This talk generalizes to iOS and Flutter too, which hit the same scaling issues with screenshot testing.

Coroutines often feel like magic until something breaks. In this talk, we’ll build a tiny coroutine framework from scratch using only Kotlin’s built-in features. We’ll start by looking at how a coroutine is executed line by line after compiler transformations. Then, we’ll explore the core constructs Kotlin gives us and implement our own lightweight versions of launch, withContext, and Dispatchers to see how it all comes together. Key Takeaways - Build simple coroutine constructs that emulate library functions like launch, withContext, etc. - Understand how the compiler rewrites suspending code. - Develop a clear mental model of coroutine control flow. - Recognize and avoid common pitfalls when working with coroutines. - Gain confidence to write more predictable and less error-prone async code

In the ever-evolving Android ecosystem, security is no longer optional—it's mission critical. This lightning talk will walk you through the most common real-world security pitfalls developers face while building Android apps—from insecure data storage and weak authentication flows to man-in-the-middle attacks and exposed APIs. Through real examples and short code demos, I’ll highlight: The top 5 most common security flaws in Android apps (and how attackers exploit them) Modern best practices for securing user data and network communication How tools like Jetpack Security, EncryptedSharedPreferences, and SafetyNet help you stay protected Quick wins to implement defense-in-depth without slowing down development Whether you're building fintech, healthtech, or even a simple social app, this talk will give you actionable tips to make your apps safer—today.

Bluetooth development across Android, iOS, and embedded platforms (like ESP32, Nordic, and custom SoCs) often leads to fragmented codebases, inconsistent user experiences, and endless compatibility issues. In this session, we’ll present a clean, scalable architecture for managing cross-platform BLE communication. Learn how to abstract transport and security logic, use shared protocol definitions (Protobuf/FlatBuffers), and apply clean architecture principles using Kotlin Multiplatform, Swift, and C. The talk includes code examples, interop strategies, and CI techniques to keep multi-platform Bluetooth sane. Takeaways: Designing a common protocol and transport layer for Android, iOS, and embedded targets. Kotlin Multiplatform tips for BLE state machines and business logic reuse. Testing and validating interop using shared simulators and log-based CI flows. Lessons learned from deploying Bluetooth features in real-world AR wearables.

From checking a sports score to tracking a delivery, we often need information the moment it happens. With Android 16, Live Update Notifications became a game-changer! They allow users to see real-time updates directly on their notification panel or lock screen without even opening an app! In this talk, I will cover the following points: - How Does a Notification Become a Live Update? - Implementation of Live Update Notification - How we took full advantage of all available functions of Live Update Notifications at Box Box Club and delivered the best experience. With these insights, you can build a Live Update Notification that keeps the user informed in real-time.

We all build Android apps — but while they perform flawlessly on some devices, they lag, stutter, or feel janky on others. Animations freeze, scrolling breaks, and often, there’s no clear indication of what went wrong. In this talk, we’ll dive deep into understanding performance in Android apps. You’ll learn how to leverage powerful tools like Android Studio Profiler, System Tracing, and Perfecto to identify and debug performance issues. We’ll then explore how to automate performance testing using Jetpack Macrobenchmark, helping you catch regressions early. Beyond tooling, we’ll discuss how to monitor performance at scale and share best practices to ensure smooth user experiences across a wide range of devices. Throughout the session, we’ll walk through real-world examples, and by the end, you’ll be equipped to make your Android apps truly buttery smooth.

we all have been told to think in compose, but what happens when the standard row, column and box arent enough. how do we build custom, high performance ui without falling back to the xml. This session will go deep into the compose UI rendering pipelines. i will start by deconstructing the three phase of frames: composition, layouts and drawing. Audience will learn how to write thier own layout composables from scratch, giving them full control over the measurement and placement of Ui element. We will then dive into the graphics layer, exploring how to achieve advances effects like rotations, shaders and complex clipping with hardware acceleration. how to use it as powerful tool to optimize performance by decreasing recomposition scopes.

Reliable Android emulator infrastructure is the backbone of effective UI test automation, yet many teams struggle to select the right infrastructure for running their tests. At Maestro, we've scaled our infrastructure to run 5,000-10,000 daily UI tests across various Android/IOS versions, providing valuable insights for teams of all sizes. This session demystifies production-grade emulator management for automated UI testing. Learn how we give our emulators superpowers so that they can be your better companions.

This session provides a practical, low effort steps to inspect and improve performance. - We will start with why you should care about performance - Look at the benefits of R8 - We will enable R8, and intentionally trigger a common crash (e.g., from reflection). - Use R8's tools like retrace to de-obfuscate the stack trace and find the true root cause. - Analyze R8's configuration path and output files (like configuration.txt) to understand why R8 removed the specific class or method. - Write a specific, narrow keep rule that fixes the bug without unnecessarily bloating your app. - Look at how to test R8 enabled builds - Add Profile guided optimizations to improve startup performance - Wrap it up This session will give you the tools and confidence to diagnose any R8-related issue and write precise, efficient keep rules. Attendees will leave this session knowing how to: - Implement R8 in a new or existing Android project correctly. - Debug minified apps by de-obfuscating stack traces to find the real source of a crash. - Analyze R8's build outputs to understand what code was kept, removed, and why. - Identify the root cause of common R8 issues, especially those related to reflection, serialization, or JNI. - Write effective, narrow keep rules that target the specific problem instead of using broad rules that harm optimization. - Verify R8's configuration to ensure your rules are being applied as expected and are having the intended effect. - Implement Profile guided optimizations