Android Developers
AI-assisted summary of What's new in Android — original source. Check the original for full context.
Source published:
Key ideas
- Google has officially declared a mandatory 'Compose First' standard for all Android UI, shifting legacy View components, Fragment, and RecyclerView into maintenance mode with no future feature development. (1:09)
- Android 17 introduces enforceable system-level memory limits that terminate misbehaving apps, citing 'memory limiter' in ApplicationExitInfo, while ART rolls out lighter, more frequent garbage collection to over a billion active devices. (8:04)
- The platform introduces the AppFunctions API and Jetpack library, transforming Android apps into on-device Model Context Protocol (MCP) servers that orchestrator agents like Gemini can query and chain across applications. (14:58)
- Android 17 strictly enforces full-screen execution on large screens by ignoring manifest orientation locks and aspect ratio flags, while Bubbles expand beyond messaging to support any app alongside a dedicated bubble bar. (30:56)
Detailed notes
## Background This video was published by the Android Developers YouTube channel on May 21, 2026. According to the description, the presentation covers the latest breakthroughs in Android development, including Jetpack Compose UI advancements, improvements in developer productivity, new form factor support, and the evolution of Android 17 into an intelligent, agent-driven system.
## TL;DR The keynote outlines a major transition for the Android platform, declaring a "Compose First" mandate that shifts all future development efforts and API support to Jetpack Compose while placing legacy View components into maintenance mode. It highlights performance-focused upgrades in Android 17, such as a lock-free MessageQueue and strict memory limits, while introducing AppFunctions as a new framework for integrating apps into agentic AI workflows. The presentation also details expanded support for cross-device ecosystems—ranging from wearables and cars to XR headsets—and emphasizes privacy-preserving system UI integration.
## Atmosphere & style The presentation carries the polished, high-energy atmosphere of a major Google I/O keynote, blending technical authority with a sense of urgent, forward-looking momentum. The speakers—Nick, Ash, and Daniel—maintain a conversational, rapport-driven dynamic, frequently punctuating deep-dive engineering details with playful banter and self-aware quips about legacy code. The narrative feels both prescriptive and visionary, framing the platform's evolution as an exciting, necessary leap into an era of intelligent, proactive computing.
## Bulletin - [01:09](https://www.youtube.com/watch?v=8PxuWdjESfg&t=69s) Google has officially declared a mandatory 'Compose First' standard for all Android UI, shifting legacy View components, Fragment, and RecyclerView into maintenance mode with no future feature development. - [08:04](https://www.youtube.com/watch?v=8PxuWdjESfg&t=484s) Android 17 introduces enforceable system-level memory limits that terminate misbehaving apps, citing 'memory limiter' in ApplicationExitInfo, while ART rolls out lighter, more frequent garbage collection to over a billion active devices. - [14:58](https://www.youtube.com/watch?v=8PxuWdjESfg&t=898s) The platform introduces the AppFunctions API and Jetpack library, transforming Android apps into on-device Model Context Protocol (MCP) servers that orchestrator agents like Gemini can query and chain across applications. - [30:56](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1856s) Android 17 strictly enforces full-screen execution on large screens by ignoring manifest orientation locks and aspect ratio flags, while Bubbles expand beyond messaging to support any app alongside a dedicated bubble bar.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=8PxuWdjESfg&t=0s) Android is undergoing a structural paradigm shift from a traditional mobile operating system to an intelligent, proactive agentic platform. - [01:09](https://www.youtube.com/watch?v=8PxuWdjESfg&t=69s) Compose First is now the official baseline: all future UI libraries, APIs, and guidance will be exclusive to Jetpack Compose as legacy Views enter maintenance mode. - [03:53](https://www.youtube.com/watch?v=8PxuWdjESfg&t=233s) The experimental Styles API in Compose 1.11 separates structural behavior from visual presentation, providing first-class state animation without component forking. - [06:08](https://www.youtube.com/watch?v=8PxuWdjESfg&t=368s) Dedicated Play Console insights and the R8 Configuration Analyzer uncover overly broad keep rules to dramatically cut APK size, ANR rates, and startup latency. - [08:04](https://www.youtube.com/watch?v=8PxuWdjESfg&t=484s) Android 17 implements hard memory limits and new ProfilingManager triggers to prevent runaway leaks amid global hardware and RAM constraints. - [10:35](https://www.youtube.com/watch?v=8PxuWdjESfg&t=635s) Reflection on static final fields is blocked when targeting Android 17, enabling aggressive runtime optimizations alongside a 5,000x faster lock-free MessageQueue. - [11:26](https://www.youtube.com/watch?v=8PxuWdjESfg&t=686s) Vulkan becomes the primary standard native graphics pipeline across devices, accompanied by an idiomatic Jetpack WebGPU library for managed Kotlin runtimes. - [12:52](https://www.youtube.com/watch?v=8PxuWdjESfg&t=772s) The Android Performance Analyzer unifies CPU, GPU, memory, and battery telemetry into a single profiler up to 26 times faster than the legacy GPU Inspector. - [14:58](https://www.youtube.com/watch?v=8PxuWdjESfg&t=898s) AppFunctions standardizes on-device Model Context Protocol (MCP) servers, empowering agents like Gemini to automate cross-application workflows securely. - [20:47](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1247s) On-device AI continues expanding via Gemini Nano on over 140 million devices, with open Apache-licensed Gemma 4 arriving on high-end hardware later in the year. - [23:05](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1385s) TalkBack gains generative AI fallback descriptions for uncaptioned images, while Accessibility Scanner receives sharper contrast and touch target detection. - [24:00](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1440s) Android 17 quarantines SMS OTP codes for three hours from third-party apps, promoting Credential Manager passkeys and zero-SMS phone and email identity verifications. - [25:41](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1541s) Privacy-preserving pickers expand with the EyeDropper API and Contacts Picker, allowing targeted data selection without broad system permissions. - [29:41](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1781s) Android 17 blocks unsolicited background audio playback, requiring apps to operate in the foreground or maintain an active MediaSessionService. - [30:56](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1856s) Orientation locks and aspect ratios are permanently ignored on large screens, forcing full-screen adaptive interfaces powered by Navigation 3 and Compose adaptive tools. - [34:49](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2089s) Wear OS 7 delivers up to 10% better battery efficiency, paired with phone-to-watch media routing and bridged live update notifications. - [38:47](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2327s) The Android stack expands into automotive and desktop form factors, including Car App Library 1.9 video playback while parked and Googlebook desktop adaptations.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=8PxuWdjESfg&t=0s) Evolving Android from Operating System to Intelligent System
Daniel Galpin kicks off the keynote by introducing the team's guided tour of the latest advances in Android development, centering on how to craft delightful, performant, and safe applications. Rather than treating Android merely as a foundational software layer, the platform team is steering a broader paradigm shift where Android evolves from a conventional operating system into a proactive, intelligent system. Daniel explains that this evolution is designed to help applications tap into deeper context awareness and provide proactive user experiences without compromising security.
Ash Nohe underscores that raw device performance and memory efficiency have become foundational to this intelligent future. With hardware shifts making system memory more critical than ever, Android 17 is pairing deep platform-level memory optimizations with new developer APIs and tooling to help engineering teams prepare for much stricter memory thresholds arriving later in the year. Beyond memory, Ash previews major advances across media, camera pipelines, and GPU capabilities, alongside adaptive layouts that stretch across emerging device ecosystems—including extended reality (XR), connected vehicles, and premium laptop form factors.
Daniel Galpin captures the overarching ambition of the platform's new direction: “We're going to cover how Android is evolving from an operating system into an intelligent system, and how your app can leverage this shift to deliver more proactive, and helpful, and context aware experiences.”
[01:09](https://www.youtube.com/watch?v=8PxuWdjESfg&t=69s) Going Compose First: The Native Stack and View Maintenance Mode
Nick Butcher turns to Google’s recommended modern native stack: Kotlin, Android Jetpack, and Jetpack Compose. This stack provides direct, day-one access to new platform capabilities and form factors whether developers work inside Android Studio or via the Android CLI. Marking five years of continuous Compose development, Nick notes that developer feedback has proven teams are substantially more productive when working declaratively. Having reached full maturity across all categories of Android devices, Compose is officially declared the mandatory standard for all Android UI development under an initiative Google calls "Compose First."
Under Compose First, Google is now delivering all future APIs, libraries, developer tools, and architectural guidance exclusively in Jetpack Compose. Concurrently, the legacy View components that Compose replaces are officially entering maintenance mode. When the live audience reacts with laughter to his reassurance that Google has no immediate plans to deprecate or delete legacy View components just yet, Nick quipped back, “You're not supposed to laugh at that.” Legacy View components, along with View-centric Jetpack libraries such as `Fragment`, `RecyclerView`, and Material View Components, are now classified as functionally complete; they will receive no new features going forward and will only be updated for critical bug fixes.
To accelerate the migration of existing codebases, Google is complementing its existing XML-to-Compose migration skill with upcoming agentic AI tools directly inside Android Studio. These Studio tools build an understanding of the project's dependency graph and layout resources to assist migrations deterministically. They can resolve referenced styles and themes accurately and automatically generate before-and-after screenshot tests to verify pixel parity.
Nick Butcher firmly establishes Google's engineering stance on modern Android interface development: “And we believe that all Android UI should now be built with Jetpack Compose.”
[03:53](https://www.youtube.com/watch?v=8PxuWdjESfg&t=233s) Compose 1.10 and 1.11: The New Styles API
The Compose 1.10 and 1.11 releases deliver a broad collection of developer-requested enhancements, including the new retain API, deterministic UI testing interfaces, text field improvements, and enhanced shared element transitions. The flagship addition in Compose 1.11 is the experimental Styles API, developed specifically to resolve long-standing developer feedback requesting more flexible, deep component customization without having to fork or rebuild UI components from scratch.
The Styles API establishes a standardized set of styleable attributes designed to cleanly decouple a composable's structural behavior from its visual presentation. The system features first-class, built-in support for interactive component states, even allowing engineers to animate transitions between different visual states seamlessly. Under the hood, Styles is engineered for high rendering efficiency, automatically minimizing unnecessary recompositions. Google is actively soliciting developer feedback on the experimental API and plans to bring full Styles support to Material Components in an upcoming library release.
Nick Butcher emphasizes the architectural intent behind the feature: “The Styles API defines a standardized set of styleable attributes which help you to separate Compose behavior from its appearance.”
[05:07](https://www.youtube.com/watch?v=8PxuWdjESfg&t=307s) Real-World Compose Performance and Benchmarks
Addressing lingering skepticism regarding declarative UI rendering overhead, Nick presents data from the Compose 1.11 release demonstrating tangible performance improvements across critical user journeys (CUJs). The team observed noticeable reductions in scroll jank and faster app cold starts, alongside smoother rendering in hybrid architectures where legacy Views and Composables are interleaved within the same hierarchy. To allow teams to validate these claims on their own hardware, Google has open-sourced an extensive benchmark suite comparing production-style View and Compose layouts.
These performance gains are not confined to synthetic tests; they translate directly into top-tier production environments. As a prominent case study, TikTok re-engineered several high-traffic screens using modern Compose APIs. In addition to making their UI code significantly easier to maintain, TikTok recorded a 20% to 30% reduction in screen load time across rewritten flows, with one particularly complex screen achieving a 78% speedup. Crucially, Nick emphasizes that developers inherit the vast majority of these platform optimizations simply by upgrading their project's Compose dependencies to the latest version.
Nick Butcher highlights the measurable gains across hybrid and pure setups alike: “In our latest release, Compose 1.11, we're seeing even better performance across key CUJs like scroll jank, startup speed, and even in hybrid UIs where you interleave Views and Compose.”
[06:08](https://www.youtube.com/watch?v=8PxuWdjESfg&t=368s) Maximizing R8 Optimization with Play Console Insights and AI
Shrinking and optimizing application binaries via R8 remains one of the highest-leverage interventions for runtime health, app startup, and APK footprint. Nick highlights the ride-hailing and delivery platform Grab, which enabled R8 across its massive 9-million-line codebase. By combining R8 optimization with revised baseline and startup profiles, Grab unlocked dramatic performance wins across its fleet: - 25% reduction in Application Not Responding (ANR) events - 16% reduction in total APK download size - 27% reduction in cold startup time
Recognizing that many engineering teams struggle to determine whether their R8 configurations are operating at peak efficiency, Google is introducing dedicated R8 insights within the Google Play Console, rolling out immediately and expanding throughout the year. Alongside these dashboard insights, Google launched the standalone R8 Configuration Analyzer. This utility evaluates project compilation and issues an efficiency score measuring optimization, obfuscation, and resource shrinking, helping developers uncover overly broad `-keep` rules that inadvertently block dead-code elimination.
```mermaid flowchart TD accTitle: R8 Configuration Analyzer and Optimization Pipeline accDescr: Diagram illustrating how the R8 Configuration Analyzer inspects rules to optimize APK size, ANRs, and startup times.
subgraph Analysis["Configuration Analysis"] A["App Project & Rules"] --> B["R8 Configuration Analyzer"] B --> C["Efficiency Score & Keep Rule Report"] B --> D["AI Agent R8 Skill"] end
subgraph Optimization["Rule Remediation"] C --> E["Identify Overly Broad Keep Rules"] D --> E E --> F["Prune / Refine ProGuard Keep Directives"] end
subgraph ProductionResults["Production Impact (e.g., Tinder)"] F --> G["28% APK Size Reduction"] F --> H["Lower ANR & Cold Start Rates"] end ```
To illustrate the hidden cost of broad rules, Nick points to Tinder, an app that had already invested heavily in R8. When running the new Configuration Analyzer, Tinder's engineering team discovered a single problematic keep rule. Removing that solitary rule produced an immediate 28% reduction in total APK size while simultaneously lowering both cold start latency and ANR rates. To assist teams in auditing and adjusting their configurations, Google is also releasing a specialized AI agent skill designed to interpret analyzer reports and guide developers through optimizing R8 keep rules.
Nick Butcher underscores the outsized impact that fine-tuning ProGuard and R8 rules can have: “Now, removing this one single keep rule, they saw a reduction in their APK size of 28%, and they reduced their ANR and cold start rates as well.”
[08:04](https://www.youtube.com/watch?v=8PxuWdjESfg&t=484s) Stricter Memory Management and Android 17 Memory Limits
Rising hardware fabrication costs and global RAM supply constraints are driving an industry-wide reassessment of client-side memory budgets. Nick and Daniel warn that memory management is no longer an afterthought, especially when building adaptive apps that scale down to budget devices or scale up to complex multi-window environments. Over the coming year, Google is deploying end-to-end memory tracking tools, spanning actionable memory telemetry inside the Play Console and enhanced memory profilers inside Android Studio.
To safeguard system stability against rogue apps that monopolize device resources, Android 17 introduces enforceable platform memory limits. These hard boundaries are calibrated to catch pathological resource consumption, such as unconstrained background memory leaks. When an app process is terminated due to exceeding these thresholds, the historical crash record retrieved via `ApplicationExitInfo.getDescription()` explicitly includes the reason string `"memory limiter"`.
```mermaid flowchart LR accTitle: Android 17 Memory Diagnostics Architecture accDescr: Flow showing ProfilingManager triggers feeding into Android Studio Profiler and Gemini assistance for memory leak remediation.
subgraph Triggers["Android 17 Profiling Triggers"] T1["Anomaly / OOM"] T2["Cold Start"] T3["Excessive CPU"] end
subgraph Diagnostics["Diagnostics Pipeline"] T1 --> PM["ProfilingManager API"] T2 --> PM T3 --> PM PM --> HD["App-Specific Heap Dumps"] end
subgraph Profiler["Android Studio Profiler"] HD --> LC["Integrated LeakCanary"] LC --> GEM["Gemini Leak Explanation & Code Fix"] end ```
To help developers track down leaks before users hit these limits, Android 17 adds new automated triggers to the `ProfilingManager` API: - **Anomaly or Out of Memory (OOM):** Captures targeted, app-specific heap dumps directly at the point of failure. - **Cold Start:** Traces execution bottlenecks during initial process launch. - **Excessive CPU:** Captures performance traces when background computation spikes abnormally.
Within Android Studio, LeakCanary is now integrated directly into the Studio Profiler. Developers can analyze captured heap dumps and immediately prompt Gemini to explain the retained reference chain and suggest actionable code patches. At the OS level, Android 17 restricts the dimensions of images embedded within custom notification views, aggressively stripping oversized bitmaps that exceed defined system thresholds.
Daniel Galpin then turns to low-level runtime internals, expressing his enthusiasm: “I could do a whole talk on garbage.” He explains that the Android Runtime (ART) is introducing lighter, significantly more frequent young-generation garbage collection cycles. This architectural adjustment reduces collection pauses and smooths out frame pacing. Because ART is decoupled from base OS releases, this garbage collection upgrade is not restricted to Android 17; it is rolling out modularly via Google Play system updates to more than one billion active devices.
Daniel Galpin articulates the philosophy behind enforcing system-level memory caps: “With the mission to prevent a bad acting app from significantly degrading user experience, Android 17 introduces memory limits.”
[10:35](https://www.youtube.com/watch?v=8PxuWdjESfg&t=635s) ART Optimizations and Lock-Free MessageQueue in Android 17
Daniel Galpin continues walking through the low-level runtime and system performance enhancements arriving in Android 17, kicking off with an unexpected restriction on reflection. Many developers might not have even realized it was historically possible to modify static final fields using reflection on Android, but targeting Android 17 shuts the door on that behavior for good. Closing this loophole gives the Android Runtime (ART) the freedom to apply much more aggressive runtime optimizations across compiled code. Developers are cautioned to audit their applications and third-party dependencies early to ensure nothing inadvertently breaks when upgrading target SDK versions.
Galpin expresses genuine excitement about another core system plumbing overhaul: Android 17 swaps out the traditional message pipeline for a brand-new, lock-free implementation of the `MessageQueue`. Eliminating locks directly curbs UI thread jank and delivers massive speedups under heavy concurrency. Explaining the sheer scale of the win, Daniel Galpin quips, “And who doesn't like numbers up to 5,000 times faster in particularly contentious cases?”
- Reflection can no longer modify static final fields when targeting Android 17, unblocking deeper ART compiler optimizations. - The Android `MessageQueue` transitions to a lock-free architecture, dramatically cutting contention and UI frame drops.
---
[11:26](https://www.youtube.com/watch?v=8PxuWdjESfg&t=686s) Vulkan Standardization and the Jetpack WebGPU API
Android is doubling down on Vulkan as its native graphics API to maximize GPU throughput and conserve system battery power. Vulkan already powers demanding middleware and high-end gaming engines requiring explicit low-level control, while abstractions like OpenGL and WebGPU sit directly atop it. In Android 17, significantly more devices will route all rendering commands straight through Vulkan. For applications and games still anchored to legacy OpenGL pipelines, the ANGLE translation layer converts OpenGL calls directly to Vulkan behind the scenes, and teams are strongly urged to validate their code against ANGLE immediately to prepare for the wider ecosystem migration.
To broaden access to modern GPU hardware without forcing managed code developers into C++ ndk gymnastics, the team unveiled an idiomatic Kotlin wrapper for WebGPU. Designed specifically for managed runtimes like ART as well as the web, WebGPU offers a much cleaner, more portable, and concise API surface than legacy equivalents. Developers can integrate it simply by importing the Jetpack WebGPU dependency. To illustrate its real-world production readiness, Galpin points to the upcoming Adobe Premiere Android app, which pairs Jetpack WebGPU with the Jetpack Media3 transformer pipeline to render stylized video templates, visual effects, and exports for formats like YouTube Shorts.
```mermaid flowchart TD accTitle: Graphics API Architecture in Android 17 accDescr: Diagram showing how applications, high-performance engines, and managed frameworks map down to Vulkan and native GPU hardware.
subgraph AppLayers["Application & Middleware Layers"] A["Legacy OpenGL Apps & Games"] B["High-Performance Engines & Middleware"] C["Managed Apps / Jetpack WebGPU (Kotlin)"] end
subgraph Translation["Translation & Abstraction"] ANGLE["ANGLE Translation Layer"] WebGPURuntime["WebGPU Runtime (ART & Web)"] end
subgraph CoreHardware["Native Graphics Platform"] VulkanAPI["Vulkan API (Native GPU API)"] GPU["Device GPU Hardware"] end
A --> ANGLE ANGLE --> VulkanAPI B --> VulkanAPI C --> WebGPURuntime WebGPURuntime --> VulkanAPI VulkanAPI --> GPU ```
---
[12:52](https://www.youtube.com/watch?v=8PxuWdjESfg&t=772s) Android Performance Analyzer
Nick Butcher takes the stage to introduce the Android Performance Analyzer, a unified profiling toolchain designed to consolidate CPU, GPU, memory, and battery metrics into one cohesive diagnostic workspace. By bringing fragmented performance signals together, the tool eliminates guesswork when investigating complex frame pacing regressions and hardware bottlenecks. The analyzer operates either as an integrated pane within the Android Studio Profiler or as an independent, lightweight standalone utility.
Performance was a core requirement for the new profiler itself. Emphasizing its raw throughput and broad hardware support, Nick Butcher notes: “Engineered for speed, the analyzer is up to 26 times faster at loading and rendering traces than the original GPU Inspector, while maintaining broad GPU compatibility.” Major game studios and engine creators are already seeing dramatic gains in production:
- **Netmarble** trimmed GPU utilization by up to 90% in *The Seven Deadly Sins: Origin*. - **The Forge** slashed per-frame CPU overhead in critical Vulkan graphics APIs by as much as 50%.
---
[13:35](https://www.youtube.com/watch?v=8PxuWdjESfg&t=815s) Evolving Android to an Intelligent System
Daniel Galpin returns to outline how artificial intelligence is shifting from standalone utility features toward fundamental operating system infrastructure. Rather than forcing users to manually navigate multiple app silos, the platform is being re-engineered to anticipate user intent proactively, unlocking fresh discovery surfaces and driving deeper application engagement while protecting user privacy. As Galpin summarizes this paradigm shift: “This is what we mean when we say that Android is evolving from an operating system to an intelligent system.”
Because the platform maintains a structural understanding of native UI constructed with Kotlin and Jetpack Compose, on-device AI can assist users in context without requiring bespoke code changes from developers. Next-generation autofill leverages existing autofill hints to intelligently boost form completion rates. On Pixel devices, on-device models inspect notification payloads from popular messaging apps to detect common scam patterns and issue pre-emptive warnings before a user falls prey to fraud. Meanwhile, Magic Cue—originally introduced on Pixel 10 to suggest relevant contextual actions inside apps—is broadening its reach to integrate with major third-party platforms like Snapchat.
---
[14:58](https://www.youtube.com/watch?v=8PxuWdjESfg&t=898s) The Agentic Era and the AppFunctions API
The presentation pivots to the agentic era, where intelligent orchestrators carry out end-to-end workflows spanning multiple applications on the user's behalf. Android has long supported inter-app cooperation through primitives like intents, but models like Gemini can now serve as active choreographers across entire task chains. Gemini can visually inspect app screens, navigate interface hierarchies, and execute actions, running the target application silently on a background virtual display while the user continues other tasks on their primary screen. To preserve trust, the orchestrator automatically halts and prompts the user whenever it encounters sensitive checkpoints, such as finalizing monetary transactions.
To give developers explicit control over how their business logic is exposed to external agents, Android is introducing AppFunctions. Built as both a platform API and an Android Jetpack library, AppFunctions standardizes the creation of on-device Model Context Protocol (MCP) integrations. Through this architecture, an Android app functions effectively as an on-device MCP server, registering callable tools and capabilities that client agents like Gemini can inspect and invoke. The direct Gemini integration is currently in a private preview with trusted testers, but teams following clean architecture principles can immediately begin exposing their domain models.
```mermaid flowchart LR accTitle: AppFunctions and On-Device MCP Integration accDescr: Flow diagram showing how Gemini acts as a client agent invoking tools exposed by on-device app MCP servers.
User["User Task Prompt"] --> Gemini["Gemini Orchestrator (Client Agent)"]
subgraph AppMCP["App as On-Device MCP Server"] AppFuncAPI["AppFunctions API (Jetpack)"] DomainLayer["Domain / Data Repository"] end
Gemini -->|"Discovers & calls tools"| AppFuncAPI AppFuncAPI -->|"Executes suspend functions"| DomainLayer DomainLayer -->|"Structured JSON / Data Model"| Gemini Gemini -->|"Composes inter-app result"| SecondaryApp["Secondary App (e.g., Chat / Email)"] ```
---
[16:34](https://www.youtube.com/watch?v=8PxuWdjESfg&t=994s) Live Demo: Exposing AppFunctions in "Now in Android"
Galpin sits down at a laptop to demonstrate how easily an existing application can expose functionality to an AI agent. Starting with the open-source *Now in Android* news aggregation app, he runs an automated coding skill in Android Studio against a straightforward prompt: create AppFunctions to access topics and news articles, and allow users to follow topics or bookmark content. The skill updates project dependencies, configures Android SDK metadata, and implements four structured functions—`listTopics`, `listNewsArticles`, `followTopic`, and `bookmark`—without breaking a sweat on the first run.
Under the hood, these capabilities are exposed as standard Kotlin `suspend` functions annotated with `@AppFunction`. They accept and return strongly typed data models and include human-readable KDoc descriptions, which the Jetpack library serializes and passes directly down to the LLM agent to describe what each tool does. To prove everything works, Galpin opens a dedicated on-device test agent app and runs deterministic function calls, fetching a JSON list of topics where ID number 3 corresponds to Compose, followed by querying articles filtered by that ID.
Switching from manual testing to a live, unscripted Gemini cloud instance, Galpin issues natural language voice prompts to demonstrate agentic tool calling and cross-app orchestration:
- When asked to “show me the article on Compose UI first,” Galpin commits a minor typing error and jokes to the audience, “That's how you know it's not really canned because I would never make a typo in a canned demo.” - Without a native search API exposed in the app, Gemini intelligently chains tools together: it invokes `listTopics`, retrieves the articles, evaluates the content, and surfaces the correct match: *"Android UI Development is Compose First."* - Galpin then issues a multi-app command: “send the Compose UI first article to Nick.” Gemini contacts a second installed sample chat app exposing AppFunctions, resolves Nick Butcher's contact identity, passes the article payload from *Now in Android* into the chat interface, and presents the completed draft ready to send.
[20:47](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1247s) On-Device and Cloud AI: AppFunctions, Gemini Nano, and A2UI
Proactive functionality and automated agent workflows are expanding rapidly through AppFunctions, allowing two distinct apps to coordinate actions smoothly. Developers can experiment with these tools right away and nominate themselves for the early access program to become the first wave deploying AppFunctions into production. Beyond cross-app orchestration, Google's core mission is embedding AI throughout the Android operating system by supporting both local on-device inference and cloud-based systems.
On-device inference through models like Gemini Nano ensures that sensitive user telemetry stays strictly on the device, allows tasks to execute completely offline without network connectivity, and eliminates per-transaction cloud processing bills. Gemini Nano is currently active across more than 140 million Android hardware units. Looking forward, Google is preparing Nano 4, powered by the open, Apache-licensed Gemma 4 model architecture, targeting flagship Android hardware later in the year. Nano 4 brings expanded multilingual capabilities, heightened battery efficiency, and deeper contextual reasoning. Developers can immediately experiment with these upcoming capabilities via the AI Core Developer Preview and write integration code using the ML Kit prompt API. Production apps are already taking advantage of this; Webex leverages the prompt API to translate incoming chat messages locally, while Adobe Photoshop is testing the API to automatically generate descriptive layer and asset names on import and export.
For workloads demanding heavier parameters, server-side implementations bridge the gap. Educational platform ABCmouse deployed Gemini on Google Cloud to create a closed-loop monitoring feature that identifies when a child encounters learning roadblocks and serves tailored interactive assistance, running effortlessly even on low-cost children's tablets. Android teams can invoke Gemini cloud models directly inside their applications through Firebase AI Logic. When building agentic experiences requiring dynamic server-driven interfaces, Google's A2UI protocol lets remote agents stream renderable visual components down to the user's phone, backed by an upcoming Jetpack Compose renderer.
```mermaid flowchart TD accTitle: Android AI Deployment Architecture accDescr: Diagram illustrating on-device versus cloud AI processing pathways in Android apps.
subgraph OnDevice["On-Device AI (Gemini Nano / Gemma 4)"] direction TB A["App (Prompt API / AI Core)"] --> B["Local Inference Engine"] B --> C["Private Data / Offline Execution"] end
subgraph CloudAI["Cloud-Side AI (Google Cloud / Firebase)"] direction TB D["App Client"] --> E["Firebase AI Logic / Cloud Models"] E --> F["A2UI Agent Protocol"] F --> G["Jetpack Compose Renderer"] end ```
- Gemini Nano runs locally without external network roundtrips, carries zero server-side operational compute fees, and has achieved an active footprint exceeding 140 million devices. - Nano 4, derived from the open Gemma 4 release under the Apache license, will roll out to high-end flagship phones later in the year. - The A2UI protocol pairs server-side agentic planning with an upcoming Jetpack Compose client renderer to display adaptive dynamic user interfaces.
---
[23:05](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1385s) Accessibility Breakthroughs
Ash Nohe underscores that creating expansive experiences requires intentional accessibility work so every user can navigate applications without friction. First, Android has introduced new developer documentation outlining how to scale Compose UI layouts effectively using standard pinch and zoom gestures. Daniel Galpin interjects with heartfelt relief: “My ancient eyes thank you all in advance for implementing this everywhere.”
Second, TalkBack has gained generative AI support, enabling it to synthesize natural-language spoken descriptions for standalone `Image` composables on the fly. While Google still urges developers to supply hard-coded, semantic content descriptions whenever possible, this automated fallback handles uncaptioned user-submitted media feeds. Third, the overhauled Accessibility Scanner tool provides significantly sharper detection of common layout flaws, flagging sub-standard color contrast ratios and undersized interactive touch boundaries. Daniel Galpin emphatically pleads with the audience: “Just use it please, please.”
---
[24:00](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1440s) Privacy and Security in Android 17
Daniel Galpin emphasizes that privacy and platform security remain the Bedrock of user trust when storing intimate personal details on a smartphone: “Now, privacy and security are essential foundations of a great Android experience, and this help fosters the trust that users need to store their most personal data.” To solidify this, Android 17 enforces strict security controls at the system layer. Dynamically loaded native libraries must be mounted read-only to prevent malicious code injection during execution. Additionally, Android 17 introduces SMS One-Time Password (OTP) safeguards, which intentionally quarantine and hold back inbound SMS messages containing security codes for three hours from standard third-party application access.
```mermaid flowchart LR accTitle: Android 17 Authentication Flow accDescr: Flow diagram showing how Credential Manager bypasses SMS OTPs with verified identities and passkeys.
subgraph AuthMethods["Credential Manager Workflow"] direction TB A["Authentication Request"] --> B{"Identity Verification"} B -->|"Verified Email / Phone"| C["Zero-SMS Verification"] B -->|"Existing Password Account"| D["Automatic Passkey Creation"] D --> E["User Credential Provider"] end ```
Developers can bypass fragile OTP friction entirely through Credential Manager's newly integrated telephone and email identity verification pipelines. Credential Manager can also automatically generate and upgrade legacy password accounts to cryptographically secure passkeys without disrupting the user, securely synchronizing them into the user's chosen credential provider upon consent.
- Health Connect gains inter-app data syncing capabilities, allowing an onboarding app to directly ask users to pull existing health datasets stored by another installed fitness application. - `CompanionDeviceManager` combines hardware association steps and localized nearby device permission dialogs into a single interaction pane, adding dedicated profiles for health trackers and medical devices. - Network security tightens: apps targeting Android 17 must explicitly request the `ACCESS_LOCAL_NETWORK` permission before they can sweep for, discover, or bind to local area network nodes such as smart thermostats or casting targets.
---
[25:41](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1541s) Privacy-Preserving Pickers and Integrated UI
Ash Nohe raises the common dilemma where an app only needs an isolated piece of user information, asking why engineers should have to demand expansive, sensitive permissions just to read a simple data point. Daniel Galpin reassures developers that Android’s privacy-preserving pickers resolve this friction by isolating system-brokered data. For example, apps leveraging Google Cast can switch between target hardware through the native Output Switcher dialog rather than requesting the all-encompassing `ACCESS_LOCAL_NETWORK` permission.
Similarly, the new EyeDropper API lets graphic tools and color swatches sample the color value of any pixel on the screen without demanding full-screen recording or display capture rights. The Contacts Picker enables granular retrieval of an isolated contact name or specific phone field without compelling the user to grant broad read permissions over their entire personal address book. Photo Picker continues this architectural pattern, having recently added portrait grid view modes so apps can integrate photo selection seamlessly without requesting persistent storage permissions.
System UI integration expands beyond data pickers: - **Live Update Notifications:** Building on last year’s release, Android 17 introduces the structured "metric style" notification layout, explicitly targeted at elapsed stopwatches, fitness metrics, and travel itineraries, with support for the semantic color API to convey status changes. - **Unified Call Log History:** The system phone dialer is opening up to surface and unify incoming and outgoing VoIP call records from third-party services like WhatsApp and Google Meet inside a single shared log screen. - **Richer System Emoji:** Google is replacing thousands of legacy flat Android emoji with fully updated, vibrantly shaded vector assets; apps simply need to render standard system emoji to inherit the graphical overhaul automatically. - **Picture-in-Picture Jetpack Library:** A dedicated Jetpack library unifies PiP support across media playback, video conferencing, and turn-by-turn navigation, enabling content creators to run teleprompter scripts over active CameraX video feeds.
---
[27:30](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1650s) On-Device AI Camera & Image Enhancement Demo
To empower creators, Android has built on-device media enhancement APIs directly into system libraries, letting camera and photo apps run AI-powered post-processing directly on hardware silicon. Social platforms like Instagram's Edits app utilize these bundled on-device image and video enhancement libraries to clean up artifacting and sharpen footage.
On stage, Ash Nohe demonstrates these enhancement APIs live using a personal photograph:
> “I adore this photo of my mom taken during her rebellious teenage years. But being an old photograph, it's grainy and blurry. So I'm going to press AI Enhance, and the on-device library will return a clearer image where details like her eyes are more well defined.”
```mermaid flowchart LR accTitle: On-Device AI Enhancement Pipeline accDescr: Pipeline of image processing from input selection through AI filters to output bitmap.
subgraph InputStage["Media Input"] A["Source Bitmap / SurfaceView"] end
subgraph ProcessingPipeline["Enhancement Engine"] B["Deblur & Denoise"] C["AI Tone Mapping"] D["Hardware Upscaling"] end
subgraph OutputStage["Execution"] E["processBitmapAsync()"] F["Enhanced Image Output"] end
A --> B B --> C C --> D D --> E E --> F ```
The underlying API configuration requires setting the enhancement mode—such as using an in-memory bitmap or passing an active `SurfaceView`—and chaining requested operation flags, which include deblurring, denoising, tone mapping, and resolution upscaling. Once configured, calling `processBitmapAsync()` processes the image frame. In a second color image test, Ash toggles airplane mode to prove that the processing runs entirely on the local device chipset with zero server costs, instantly brightening muted colors through tone mapping and pulling out crisp edges on background lettering.
---
[29:41](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1781s) Android 17 Audio Restrictions, Pro Media Formats, and Eclipsa Video
Right as the presentation switches slides, loud, unexpected background audio abruptly blares through the auditorium speakers. Daniel Galpin cuts in: “Unexpected background audio. I don't like it. Users don't like it.” Android 17 directly tackles this frustration by shutting down unsolicited media playback. The OS limits audio playback APIs strictly to foreground applications or active foreground services configured with explicit while-in-use capabilities. Developers running audio players can preserve lawful background playback by routing through the standard `MediaSessionService`, while system exact alarms remain fully exempted from these playback restrictions.
Additional Android 17 media upgrades include: - Native decoding and capture support for professional photography and video encoding formats. - Clearer audio streaming pipelines and elevated voice compression powered by modernized HE-AAC profiles. - Expanded camera enhancements, including specialized vendor-defined hardware extensions. - The official arrival of next-generation Eclipsa video on Android 17, providing high-fidelity HDR color rendering that eliminates unpredictable ambient backlighting problems, supported out of the box by ExoPlayer and Media3.
---
[30:56](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1856s) Adaptive UIs and the Multi-Device Ecosystem
Nick Butcher takes the stage to frame Android as an inherently heterogeneous multi-device environment where users expect apps to move fluidly across phones, foldables, tablets, smartwatches, headsets, automotive dashes, and televisions. The large-screen category alone represents a massive, highly engaged cohort:
> “There are now over 580 million large screen users, and they spend more and engage more with their apps.”
Large-screen device users expect software to expand comfortably across large canvases without awkward letterboxing. Because of this, Android 17 enforces full-screen execution on large screens by intentionally ignoring legacy orientation locks and rigid aspect ratio flags in application manifests, entirely removing the ability for developers to opt out. To build responsive interfaces that adapt natively to any window geometry, developers should turn to the Navigation 3 and Compose adaptive toolsets, which manage complex multi-pane states out of the box starting with Navigation 1.1.
### [31:45](https://www.youtube.com/watch?v=8PxuWdjESfg&t=1905s) Jetpack Compose Updates and Adaptive APIs The speakers outline significant updates to Jetpack Compose aimed at simplifying complex UI requirements. Scene decorators have been introduced to manage global navigation UI elements, such as rails and bars, at the scene level rather than the individual navigation entry level. Additionally, deep link support has officially arrived in the 1.2 Alpha versions of the navigation library. To facilitate adaptive design, three new experimental APIs have been launched in Compose 1.11: `MediaQuery` for querying device capabilities, a new `FlexBox` implementation for responsive content wrapping, and `Grid` for structured, root-level layout management across varying screen sizes.
* **Scene Decorators**: Enables control over global navigation visibility. * **Deep Links**: Now available in version 1.2 Alpha. * **Experimental APIs (Compose 1.11)**: `MediaQuery`, `FlexBox`, and `Grid`. * **TV Updates**: Google TV is adding support for "pointer remotes," and developers are encouraged to update their TV libraries accordingly.
### [33:23](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2003s) Expanding the Adaptive Ecosystem: Bubbles, Widgets, and Glance The conversation shifts to the multi-device ecosystem and "Continue On" functionality, which allows users to transition tasks between devices. A significant change is coming to Android bubbles; previously restricted to chat apps, any application can now be "bubbled," and large-screen devices will feature a dedicated bubble bar for improved management. Widgets are also being emphasized as a tool for user retention—highlighting the app "Gratitude," which saw a 25% increase in retention among widget users—and they are expanding into the automotive space. Developers are urged to use Jetpack Glance for all adaptive widget needs, including the new "Wear Widgets," which evolve from the old Tiles system.
* **Bubbles**: No longer exclusive to chat; supported by a new bubble bar on large screens. * **Widgets**: Expanding to cars and tablets; users show higher loyalty/retention. * **Remote Compose**: A library enabling expressive widget animations like snap-scrolling.
### [34:49](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2089s) Wear OS 7 and Hands-Free Automations Wear OS 7 brings a 10% improvement in battery life, alongside new features that bridge phone and watch experiences. Media sessions initiated on a phone can now automatically show playback controls on a paired watch, allowing users to switch output devices seamlessly. Live update notifications can be bridged from the phone to the watch automatically, though developers can also implement local notifications for when the user is disconnected from their phone. Furthermore, mobile UI automation enables hands-free tasks, and developers can use "AppFunctions" with agents like Gemini to invoke specific in-app flows, such as starting a workout.
* **Wear OS 7**: Up to 10% better battery efficiency. * **Wear Workout Tracker**: Launching in Google Play services later this year. * **Development Tools**: Compose for Wear OS 1.6 now supports Navigation 3 and a local ambient mode manager. The Wear OS 7 Canary emulator is available in Android Studio.
### [36:47](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2207s) Android XR SDK and Immersive Experiences The speakers emphasize that existing adaptive Android apps are already positioned for XR headsets. The Android XR SDK provides paths for both immersive virtual experiences and augmented interactions for display/audio glasses. To improve performance and developer experience, the team is introducing real-time geometry creation to keep app binaries small, Geospatial API integration for navigation, and expanded support for game engines like Godot and Unreal. New interactive components, such as vertical lists and stacks, are being added to "Glimmer"—the set of composables designed for display glasses.
* **XR Developer Catalyst Program**: Developers are encouraged to apply for access to hardware, resources, and grant funding. * **Glimmer Improvements**: New vertical lists and stacks for glasses-based UI.
### [38:47](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2327s) Automotive and Desktop Evolution Google is working to increase parity between Android Auto and "cars with Google built-in." Car App Library 1.9 introduces 10 new flexible components, including enhanced chips, expandable headers, and progress bars. The team is also working on new APIs to handle the transition from parked to driving states, including support for HD video playback while the vehicle is parked. Moving to desktop, the presenters announce "Googlebook"—the next iteration of ChromeOS built with the Android stack—and urge developers to incorporate keyboard shortcuts, drag-and-drop, and custom pointers to ensure their apps feel at home on desktop hardware.
* **Car App Library 1.9**: Includes media templates and maps SDK consistency across platforms. * **Desktop Support**: Developers should support adaptive layouts for desktop-class interactions.
### [40:53](https://www.youtube.com/watch?v=8PxuWdjESfg&t=2453s) Closing Remarks on Android 17 and "Compose First" The presentation concludes by summarizing the transformation of Android from an operating system into an intelligent, agent-driven ecosystem. The team highlights the upcoming Android 17 release, which will focus on memory optimization, GPU standards, and system-wide performance. Security remains a pillar, with continued work on privacy-preserving pickers and SMS one-time password protection. The speakers reiterate their "Compose first" mandate: “We're focusing all of our new APIs, libraries, tools, and guidance on our most productive toolkit, which makes it fast and easy for you to build incredible apps.”
* **Core Focus**: Memory optimization, privacy, and the "Compose first" development strategy.
## Notable quotes > [01:09](https://www.youtube.com/watch?v=8PxuWdjESfg&t=69s) And we believe that all Android UI should now be built with Jetpack Compose. — Nick Butcher
> [08:04](https://www.youtube.com/watch?v=8PxuWdjESfg&t=484s) With the mission to prevent a bad acting app from significantly degrading user experience, Android 17 introduces memory limits. — Daniel Galpin
> [03:53](https://www.youtube.com/watch?v=8PxuWdjESfg&t=233s) The Styles API defines a standardized set of styleable attributes which help you to separate Compose behavior from its appearance. — Nick Butcher
## Mentioned Android, Android 17, Android Studio, Jetpack Compose, Kotlin, Daniel Galpin, Ash Nohe, Nick Butcher, R8, Google Play Console, Grab, Tinder, TikTok, ART, LeakCanary, Vulkan, WebGPU, OpenGL, ANGLE, Adobe Premiere, Jetpack Media3, Android Performance Analyzer, Netmarble, The Forge, Gemini, AppFunctions, Gemini Nano, Gemma 4, A2UI, TalkBack, Credential Manager, Health Connect, Google Cast, Instagram, Wear OS 7, Jetpack Glance, Android XR SDK, Godot, Unreal Engine, Android Auto, Googlebook
## Video description Explore what’s new in Android development. Explore new UI breakthroughs with Jetpack Compose, improvements in developer productivity, and how to unlock additional form factors for your app. Learn about Android 17, including performance improvements, new capabilities for media and camera apps, new functionality for desktop and large screened apps, and how we're using agentic automation to empower users to get more done faster.
Resources: Learn more → https://goo.gle/compose-first Learn more → https://goo.gle/r8-analyzer Unified call history → https://goo.gle/4fp7YQz Android X → https://goo.gle/3PJrNrm Wear → https://goo.gle/4dJTEAS Android XR SDK → https://goo.gle/4nxB7uP Android for Cars overview → https://goo.gle/42WWYmh Android for Cars Early Access Programs - New Categories Self Nomination → https://goo.gle/CAL-EAP AI opn Android → https://goo.gle/42Dx2vC
Speakers: Nick Butcher, Ash Nohe, Daniel Galpin
Watch the Android sessions from Google I/O 2026 → https://goo.gle/Android-at-IO2026
Subscribe to Android Developers → https://goo.gle/AndroidDevs
#GoogleIO
Event: Google I/O 2026
Products Mentioned: Android, Mobile, AI/Machine Learning
[Source](https://www.youtube.com/watch?v=8PxuWdjESfg)