What's new in Android

What's new in Android — Android Developers

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)

Reading summary

Google is transitioning Android from a conventional operating system into an intelligent, proactive platform, establishing Jetpack Compose as the mandatory UI development standard while enforcing strict runtime, memory, and security boundaries. Platform leads Daniel Galpin, Nick Butcher, and Ash Nohe outlined this trajectory, highlighting agentic inter-app orchestration, Vulkan graphics standardization, and mandatory large-screen responsiveness across an expanding device ecosystem. Jetpack Compose Mandate and Legacy View Maintenance (1:09) Under the "Compose First" initiative, Google has officially declared Jetpack Compose the exclusive foundation for future Android UI development, tools, and architectural guidance. Concurrently, legacy View-centric frameworks—including Fragment, RecyclerView, and Material View Components—have entered maintenance mode. Nick Butcher noted these libraries are now considered functionally complete and will only receive critical bug fixes, though Google has no immediate plans to delete them. To support migrations, Android Studio will incorporate agentic AI tooling capable of analyzing dependency graphs and generating verified layout migrations backed by before-and-after screenshot tests. Compose versions 1.10 and 1.11 introduce performance improvements alongside the experimental Styles API, which standardizes styleable attributes to decouple structural behavior from appearance and visual states. Demonstrating declarative UI efficiency in production, Google highlighted TikTok’s adoption of modern Compose APIs across high-traffic flows, which delivered a 20% to 30% reduction in screen load times and a 78% speedup on a particularly complex screen. Android 17 Memory Limits and Runtime Optimizations (8:04) Driven by global memory supply constraints and hardware fabrication costs, Android 17 introduces enforceable system-level memory limits that terminate rogue processes experiencing unconstrained leaks, logging the exit reason as "memory limiter" via ApplicationExitInfo. To assist developers, the ProfilingManager API introduces automated diagnostic triggers for anomalous memory or out-of-memory events, cold start bottlenecks, and CPU spikes, complemented by native LeakCanary integration in Android Studio. At the runtime level, ART is deploying lighter young-generation garbage collection via Google Play system updates to more than one billion active devices. Targeting Android 17 also closes a historical loophole that permitted modifying static final fields via reflection, unblocking deeper ART compiler optimizations. In addition, the OS integrates a lock-free MessageQueue architecture that Galpin claimed speeds up contention scenarios by up to 5,000 times. For build-time optimization, Google launched the R8 Configuration Analyzer to flag broad keep rules; Tinder utilized the tool to remove a single problematic rule, securing an immediate 28% APK size reduction alongside lower cold start latency and ANR rates. AppFunctions and Tiered Artificial Intelligence Architecture (14:58) To transition beyond manual app navigation, Android is introducing AppFunctions as both a platform API and Jetpack library. The system standardizes on-device Model Context Protocol (MCP) implementations, letting applications expose their business domain capabilities as structured Kotlin suspend functions marked with @AppFunction. AI choreographers like Gemini can discover these tools and execute end-to-end workflows across disparate applications—such as extracting news articles and staging them in chat apps—running secondary tasks on background virtual displays while prompting the user for approval at sensitive transaction checkpoints. The AI infrastructure is divided between local on-device execution and cloud services. On-device processing relies on Gemini Nano, active on over 140 million devices, with the open Gemma 4-based Nano 4 planned for flagship hardware later in the year to support private, offline execution via the ML Kit prompt API. For workloads requiring server compute, Firebase AI Logic connects apps to Gemini cloud models, while the A2UI protocol enables cloud agents to stream dynamic user interfaces directly into a client-side Jetpack Compose renderer. Platform Security, Media Restrictions, and Adaptive Displays (24:00) Android 17 hardens security by enforcing that dynamically loaded native libraries be mounted read-only and quarantining inbound SMS one-time passwords from third-party app access for three hours. Developers are directed to use Credential Manager for identity verification and passkey migration. Network discovery of local smart nodes now mandates the ACCESS_LOCAL_NETWORK permission, though developers can bypass broad access by using privacy-preserving pickers such as the Output Switcher, EyeDropper API, and Photo Picker. Media rules have also tightened: unsolicited background audio is restricted strictly to foreground tasks or MediaSessionService implementations. For rendering, Android 17 standardizes on Vulkan as its core graphics pipeline, utilizing the ANGLE layer to translate legacy OpenGL calls, while releasing the Jetpack WebGPU library for Kotlin. Across form factors, Android 17 will ignore orientation locks and fixed aspect ratio flags on large screens—a category spanning over 580 million users—mandating fluid responsive windowing via Navigation 3. This adaptive expansion extends further to Wear OS 7, XR headsets and display glasses via the Glimmer library, Car App Library 1.9, and the upcoming Android-based Googlebook desktop platform. Google’s announcements establish an explicit architectural trajectory: mandatory adoption of Jetpack Compose, strict runtime accountability under new Android 17 memory thresholds, and structured integration into agentic tool-calling systems via AppFunctions. While these changes offer substantial performance and discovery advantages, they place an immediate migration and refactoring burden on engineering teams relying on legacy View hierarchies, reflective access patterns, and fixed-aspect large-screen layouts.

Source quotes

[1:09] Nick Butcher: And we believe that all Android UI should now be built with Jetpack Compose. [8:04] Daniel Galpin: With the mission to prevent a bad acting app from significantly degrading user experience, Android 17 introduces memory limits. [3:53] Nick Butcher: The Styles API defines a standardized set of styleable attributes which help you to separate Compose behavior from its appearance.

Original transcript

[0:00] [MUSIC PLAYING] [0:06] DANIEL GALPIN: Hello, and welcome to What's [0:08] New in Android, your guided tour of the latest [0:11] and greatest changes in Android development. [0:13] We're going to highlight some of the ways [0:15] we're helping you build delightful, [0:17] performant, and intelligent apps, all while keeping [0:20] users safe. [0:21] We're going to cover how Android is evolving from an operating [0:25] system into an intelligent system, [0:28] and how your app can leverage this shift [0:30] to deliver more proactive, and helpful, and context aware [0:34] experiences. [0:37] ASH NOHE: We need that. [0:38] We'll dive into performance. [0:40] It's no secret we're seeing a shift [0:42] where device memory is more important than ever. [0:45] Not only have we made strides in memory optimizations [0:48] in Android 17, we're providing the tooling and API [0:52] support to help you stay ahead of stricter memory [0:55] requirements later this year. [0:57] We'll also cover improvements in media, camera, and GPU [1:01] capabilities, and how to build adaptive apps for the expanding [1:05] ecosystem, from XR to cars to premium laptops. [1:09] NICK BUTCHER: But we'll start with the latest updates [1:11] to our recommended native stack of Kotlin, Jetpack, [1:15] and my favorite, Jetpack Compose. [1:17] [CHEERING] [1:21] Now, this stack delivers you the most performant and device [1:24] optimized experience. [1:25] Whether you're developing in Android Studio [1:27] or developing through Android CLI, [1:29] it gives you direct access to the latest updates straight [1:32] from us, like new platform APIs, and we support it [1:34] with great tools. [1:36] So this stack makes sure that you're [1:38] ready for any new opportunities, such as new form factors [1:42] or for new platform APIs. [1:46] In the five years that we've been developing Jetpack Compose, [1:49] we've been working hard to give you [1:50] all of the features, performance, and tools [1:52] that you need to build beautiful UIs that [1:54] run across the variety of Android devices. [1:57] And you've told us that you're far more productive when [2:00] working with Compose. [2:02] Compose has matured into the standard for building Android [2:05] UI. [2:08] And we believe that all Android UI should now [2:10] be built with Jetpack Compose. [2:12] We call this going Compose First. [2:16] So from now on, we're going to be [2:17] providing all APIs, libraries, tools, and guidance in Compose. [2:21] And we consider the View components [2:23] that Compose replaces to now be in maintenance mode. [2:27] [CHEERING] [2:32] But don't worry. [2:33] We have no plans to deprecate or remove View components just yet. [2:39] [LAUGHTER] [2:42] You're not supposed to laugh at that. [2:44] But they will receive no new features [2:46] and will only be shipping critical bug fixes to them [2:48] from now on. [2:50] The same goes for View-based libraries [2:52] like Fragment, RecyclerView, and Material View Components. [2:55] We consider them to be complete, and they too will only receive [2:58] critical features-- critical bug fixes, sorry-- [3:01] as we focus all of our efforts on Jetpack Compose. [3:05] We believe that all Android UI should now be built with Compose [3:08] and that you should consider converting existing UI [3:11] to Compose as you touch it to receive [3:13] the many benefits of Compose. [3:15] To help you to convert, and in addition to the skill [3:18] that we've already launched to help you to convert XML [3:20] to Compose, we're also working on some new tools [3:23] in Android Studio. [3:25] Now, these tools use the knowledge of your Android [3:27] project in order to augment the agent [3:30] to help it to convert your UI, things like deterministically [3:33] understanding the styles and the resources [3:35] that your layouts reference, or creating [3:37] screenshot tests to help you to compare the before and after [3:41] and ensure that you're getting a good conversion. [3:44] These will be coming to Android Studio soon, and to learn more, [3:48] check out the What's New in DevTools talk coming up later. [3:53] The recent Compose 1.10 and 1.11 releases added a whole raft [3:57] of new features, from the retain API to more deterministic [4:01] testing APIs, improvements to shared element transitions, [4:04] and new text field features. [4:07] One of the larger changes that I'm really excited about [4:09] is the new Styles API, which is experimental in Compose 1.11. [4:14] Now, we've heard your feedback that you want more customization [4:16] of components. [4:18] The Styles API defines a standardized set [4:21] of styleable attributes which help [4:23] you to separate [INAUDIBLE] Compose behavior [4:26] from its appearance. [4:28] So we think you can use this to make [4:29] much more, easier customization of the components. [4:33] Styles has built-in support for different states, [4:36] even letting you animate state changes so you can build much [4:38] more responsive components. [4:41] And it's performant out of the box, [4:43] automatically minimizing recompositions for you. [4:47] So we're working on Styles, and we'd [4:49] love your feedback as we continue to build this out. [4:51] And we plan to add Style support to our Material [4:54] Components in a future release. [4:56] [APPLAUSE] [5:02] For more details, I highly encourage you to check out [5:04] this talk on the Style system. [5:07] So Compose not only helps you to build a more stylish app, [5:09] but it also can help it be performant. [5:12] In our latest release, Compose 1.11, [5:14] we're seeing even better performance across key CUJs [5:17] like scroll jank, startup speed, and even [5:20] in hybrid UIs where you interleave Views and Compose. [5:24] To back this up, we're releasing a new suite [5:26] of benchmarks which compare real-world app performance [5:29] between Views and Compose. [5:30] These are open source, so you can check them out and verify [5:33] the results for yourself. [5:35] And best of all, you get most of these benefits [5:37] just by upgrading the Compose version. [5:39] So make sure that you're using the latest release. [5:43] And it's not just benchmarks. [5:44] We see this in production too. [5:46] In fact, TikTok told us that the expressive Compose [5:50] APIs helped them to rewrite a number of their screens [5:53] into Compose. [5:54] And this not only made their code more maintainable, [5:57] but they also saw performance improvements, [5:59] seeing a reduction in page load time of up to 20% to 30%. [6:02] And in one case, they saw a huge 78% speed up. [6:07] And speaking of performance, R8 is a critical tool [6:10] for streamlining your app. [6:12] It helps to remove unused code and resources, [6:15] and can rewrite code to optimize startup and runtime performance. [6:18] But we've heard from you that it can [6:20] be hard to know if you're getting the most out of R8. [6:25] Wait, let me go back. [6:27] So for example, Grab had huge impact [6:30] by enabling R8 on their 9 million line code base. [6:34] Doing so, they saw a 25% reduction in ANRs [6:36] and a 16% reduction in APK size. [6:41] And in conjunction with reworking their baseline [6:43] and startup profile, they also saw a 27% reduction [6:47] in startup time. [6:49] So R8 is pretty great, but we have heard from you [6:52] that it can be hard to know if you're [6:53] getting the most out of it. [6:55] And to that end, we're bringing new R8 insights [6:57] into the Play Console to help you to identify opportunities [7:00] to improve. [7:01] These are going to start rolling out from today and more widely [7:04] later this year. [7:06] And to help you to act on these insights, [7:09] we also have launched the R8 configuration analyzer. [7:12] So this is a tool that runs a report [7:14] and will give you a score for how [7:16] effective your optimization, obfuscation, [7:19] and resource shrinking is. [7:21] And it helps you to spot opportunities to further shrink [7:23] your app. [7:26] For example, it might help you to find [7:28] some keep rules which are overly broad, [7:30] which might be thwarting some of R8's optimizations. [7:33] For example, Tinder had already invested in using R8 [7:36] and seen many benefits. [7:38] But by using the configuration analyzer, [7:40] they were able to find a problematic keep rule. [7:42] Now, removing this one single keep rule, [7:44] they saw a reduction in their APK size of 28%, [7:48] and they reduced their ANR and cold start rates as well. [7:52] And we're also publishing a new skill [7:54] to help AI agents to work with R8. [7:57] And so this skill works with the configuration analyzer, [8:00] and it helps you to get the most out of R8. [8:04] But R8 is just a start. [8:06] Current rising hardware costs and RAM supply constraints [8:08] are forcing a shift in the device [8:10] ecosystem, where memory management is [8:12] more important than ever. [8:14] Optimizing your app's memory footprint [8:16] ensures that your app can deliver the best performance [8:18] across all form factors. [8:21] DANIEL GALPIN: And to ensure that the next generation [8:23] of devices delivers the premium experience that Android [8:26] users expect, we'll be partnering with you to optimize [8:29] how Android manages memory. [8:32] NICK BUTCHER: Over the coming year, [8:34] we'll be rolling out new tools to help making building memory [8:36] efficient apps much simpler. [8:39] You can look out for memory-- [8:42] so you can look out for actionable memory telemetry [8:44] right in the Play Console, alongside smarter debugging [8:46] tools right in Android Studio. [8:49] These updates will help you to stay ahead of the platform [8:52] shifts to stricter memory management that [8:54] are coming later this year. [8:57] DANIEL GALPIN: With the mission to prevent a bad acting app [9:00] from significantly degrading user experience, [9:02] Android 17 introduces memory limits. [9:05] Now, these limits are designed to largely impact apps [9:07] with runaway resource problems such as memory leaks. [9:12] And if your app session is actually [9:14] impacted by these app memory limits, [9:16] get description in application exitInfo [9:19] will contain the string of memory limiter. [9:22] NICK BUTCHER: And to help you to debug excessive memory usage, [9:25] Android 17 has a profiling trigger of type anomaly or out [9:28] of memory to the ProfilingManager API, [9:31] which you can use to get app-specific heap [9:33] dumps to help you to diagnose and to fix memory issues. [9:36] Android 17 also introduces new profiling [9:38] triggers for type cold start and excessive CPU. [9:42] And LeakCanary integration into the Android Studio Profiler [9:45] can help you to track down memory leaks faster, [9:48] and you can ask Gemini to help explain the leak [9:50] and suggest a fix. [9:53] So that's a high-level overview of some of the ways [9:55] that we're helping you to optimize the memory [9:57] management of your app. [9:58] You should check out this talk for more details. [10:01] DANIEL GALPIN: So the platform is also [10:03] working to reduce memory usage. [10:05] For example, Android 17 restricts the size [10:08] of images in notifications with custom views, [10:11] stripping them out if they exceed certain thresholds. [10:14] Now, let me nerd out for a moment. [10:17] I could do a whole talk on garbage. [10:19] But ART is introducing more frequent, less resource [10:22] intensive young generation collections in its GC, [10:26] and this both improves memory management and performance. [10:29] And best of all, it's not just available on Android 17, [10:32] it's also available to over a billion devices through Google [10:35] Play system updates. [10:36] And so I didn't even know you could modify static final fields [10:40] on Android using reflection. [10:42] And now, once you target Android 17, [10:45] you won't be able to do it anymore. [10:47] And this is cool because it actually [10:49] allows ART to more aggressively apply [10:51] more of those sweet performance optimizations. [10:54] Just make sure to test your app just in case [10:56] your app or one of its dependencies relies on this. [11:00] And believe it or not, I am psyched [11:03] that Android 17 introduces a new lock-free implementation [11:07] of the Android MessageQueue. [11:09] And I mean, this is awesome. [11:10] It reduces UI jank while massively speeding up [11:14] high-contention scenarios. [11:15] And there is some cool computer science [11:17] that makes this possible. [11:19] And who doesn't like numbers up to 5,000 times faster [11:23] in particularly contentious cases? [11:26] With goals of improved GPU performance and system power [11:30] efficiency, Android is supporting the Vulkan API [11:33] as its native GPU API. [11:35] Now, Vulkan is already used directly [11:37] by high-performance middleware and game engines [11:39] that want maximum control. [11:41] And other APIs like OpenGL and WebGPU [11:44] are then layered on top of Vulkan. [11:48] I know there's another one. [11:49] There we go. [11:50] Hi. [11:52] With Android 17, many more devices [11:54] will prosper by using Vulkan to process all graphics commands. [12:01] If your app or game is still using OpenGL, [12:03] ANGLE will translate its OpenGL to Vulkan, [12:06] and we recommend testing on ANGLE today [12:08] to ensure you're ready for the Vulkan transition. [12:11] We're also enabling more ways to access Vulkan. [12:14] So for apps to leverage GPU performance, [12:18] we've built an idiomatic Kotlin API for WebGPU, [12:22] the modern GPU API designed for manage code environments [12:25] like ART and the web. [12:27] And it's more capable, portable, and concise than older [12:30] standards. [12:31] Now to get started, just add the Jetpack WebGPU dependency [12:34] to your project. [12:36] And for example, the upcoming Adobe Premiere app-- [12:38] [CHEERING] [12:40] Yeah, awesome. [12:42] --uses WebGPU along with Jetpack Media3 [12:45] transformer for creating and posting things [12:47] like YouTube Shorts with cool templates and effects. [12:52] NICK BUTCHER: To help you get the most out of GPU, CPU, [12:54] memory, and battery, and more, the new Android Performance [12:57] Analyzer unifies our system-wide insights [12:59] into a single cohesive toolchain, which can drastically [13:03] simplify performance debugging. [13:05] Engineered for speed, the analyzer [13:07] is up to 26 times faster at loading and rendering traces [13:11] than the original GPU Inspector, while maintaining broad GPU [13:13] compatibility. [13:15] And it runs either as a standalone utility [13:17] or within the studio profiler. [13:20] And some of our partners are seeing great success [13:22] with this new performance analyzer. [13:23] Netmarble reduced the GPU usage by up to 90% in "The Seven [13:27] Deadly Sins: Origin." [13:29] And The Forge reduced per frame CPU usage in key Vulkan APIs [13:33] by up to 50%. [13:35] DANIEL GALPIN: Now, performance is [13:36] just one way we're helping you delight your Android users. [13:40] We're creating a platform that delivers [13:42] new, helpful, AI-powered experience that actually [13:46] anticipate users' needs. [13:47] Now for you, this means not only new discovery surfaces [13:51] for more and deeper app engagement, [13:53] but users are actually getting better and safer app [13:56] experiences. [13:57] And we're doing this at every level of the stack. [13:59] This is what we mean when we say that Android [14:02] is evolving from an operating system to an intelligent system. [14:06] Now, your apps will be at the center of these changes [14:09] in different ways. [14:10] First, let's talk about how AI can enhance the ways users [14:14] interact with your app with proactive help, [14:17] leveraging the platform's deep understanding of native UI [14:20] built with Kotlin and Compose. [14:22] An example of this is our next-generation autofill, [14:25] which works to get your app higher form completion rates, [14:28] all using the same hints you're currently providing autofill. [14:31] We can also help protect your users today on Pixel [14:34] with using AI to identify scam patterns in notifications [14:38] from popular messaging apps, warning users [14:41] before they respond to a potential threat. [14:44] Now, Magic Cue was introduced last year on Pixel 10, [14:46] and it surfaces helpful information and actions [14:48] within apps. [14:49] And this is a new place for users [14:51] to engage with and discover app content. [14:53] And as you can see here, it's expanding [14:55] to more apps, such as Snapchat. [14:58] Now, improving your apps with proactive AI features [15:01] is awesome, but we're entering the agentic era, where [15:05] agents and assistants complete tasks on behalf of users, [15:09] and your app can participate. [15:11] I mean, after all, Android has always [15:12] been designed to have multiple apps work together [15:14] to share a task, such as composing an email with a photo. [15:18] But now, agents such as Gemini can [15:21] act as an orchestrator across multiple apps. [15:24] Now to this end, Gemini can analyze app screens [15:28] and navigate through tasks, stopping for user input [15:31] when it needs clarification at sensitive areas [15:33] like transactions, with no code needed [15:35] from you in almost all cases. [15:37] The user can do other tasks while Android actually [15:40] runs the app in the background on a virtual display. [15:43] And we'll be rolling this experience out more widely [15:46] in the future. [15:48] But you can take control of the capabilities [15:51] your app exposes by integrating with a new API, AppFunctions. [15:57] Now, AppFunctions is an Android platform API [15:59] in a Jetpack library that simplifies building Android MCP [16:03] integrations. [16:04] It empowers your app to behave like on device MCP [16:07] servers, contributing functions that act as tools for use [16:10] by client agents and assistants like Gemini. [16:13] Now, AppFunctions integration with Gemini [16:15] is currently in a private preview with trusted testers, [16:19] but you can begin preparing your apps now using AppFunctions. [16:22] Now, if you built your app with clearly separated data [16:25] and presentation layers following our recommendations, [16:28] adding AppFunctions can be really, really straightforward. [16:31] So let me show you what that looks like. [16:34] All right, so here we are on our laptop. [16:40] Let me actually show you a little bit of what we've done. [16:43] We've actually got a skill that can actually add AppFunctions [16:47] automatically to your project. [16:50] And it works even better if you actually [16:53] have architected your app well, but it can work in all cases [16:55] really. [16:56] And the key thing is that we're going [16:58] to do this today with the Now in Android news aggregation app. [17:01] So let me quickly just show you. [17:03] If you haven't seen this, this is what [17:06] that looks like, very nice. [17:07] You see we've got Compose first as part of the news that we're [17:11] aggregating. [17:11] Now, what the agent has actually done, though, is pretty cool. [17:17] So you can see we've just given it a very, very simple prompt. [17:19] Create AppFunctions that provide access to topics and news [17:22] articles, and enable users to follow, and things like that. [17:24] It activates the skill. [17:26] We've installed that into the project, [17:28] and it's going to do a lot of things for you. [17:30] It's going to upgrade things. [17:31] Let's scroll to the bottom and look at all that it's done. [17:34] So again, we've updated the SDK. [17:35] We've added dependencies. [17:36] We've created metadata. [17:38] And more importantly, we've actually [17:39] implemented four useful AppFunctions, [17:42] to list topics, list news articles, [17:45] follow topics, and bookmark things. [17:47] And this is the actual code that was generated. [17:49] Like as you can see here, we're really literally running [17:51] all this from Android Studio. [17:52] And I have not made any changes to the project. [17:55] This actually worked the first time, which is always nice. [17:57] And you can see it's created this AppFunction for list [18:00] topics. [18:00] And what's really great about the way [18:02] that Jetpack Library works is that you can [18:05] see that this is pretty normal. [18:06] We've just annotated it with AppFunctions. [18:09] It's a normal suspend function that runs with the context. [18:11] You can see here that it's actually returning [18:14] a fairly reasonable data model. [18:16] And let me do that one more time. [18:18] There, a very reasonable data model. [18:21] And also, we're documenting it using KDoc. [18:25] And the library is just going to make sure [18:26] that that gets all the way to the agent that's using it. [18:30] The same thing that makes me understand it also [18:32] makes our agents understand it. [18:34] And you can see we can list topics and news articles. [18:37] We can follow topics. [18:38] And we can create bookmarks. [18:40] But how do you test this? [18:42] Well, we've actually gone and created [18:45] an agent that can do that for you. [18:47] So let's go to our running device, [18:49] and let's switch over to our test agent. [18:52] [HUMMING] [18:54] All right, so first of all, we want [18:55] to do things deterministically. [18:57] So let's take a look at what functions [18:58] we're exporting inside of Now in Android. [19:01] So we've got list topics. [19:02] We can run those functions. [19:03] And you see we get some lovely JSON. [19:05] And you notice ID number 3 is Compose. [19:08] All right, we'll use that when we go to listNewsArticles. [19:10] We can also add parameters here right in the test agent [19:13] and run them. [19:15] And, again, beautifully-- this is actually [19:17] happening, by the way. [19:18] This is not canned or anything like that. [19:20] All right, let's talk about the next thing. [19:22] The next thing we want to be able to do [19:24] is actually run against a live instance of Gemini. [19:27] So we've hooked it up to a regular cloud [19:28] instance of Gemini. [19:29] And we do things like, hey, "show me the article on Compose [19:36] UI first." [19:39] That's how you know it's not really [19:40] canned because I would never make a typo in a canned demo. [19:44] Demo gods, let's do this. [19:46] All right, so it's connecting to Now in Android app. [19:49] And Gemini actually has to do a bit of work [19:51] here because you notice we didn't have a great API [19:53] for actually searching this. [19:54] So it's actually pulling the topics, [19:55] pulling all the articles, and then [19:57] giving you the article that you selected. [19:58] And Gemini is doing all that work. [20:00] But we can take it one further. [20:01] [APPLAUSE] [20:03] Thank you. [20:05] We can also say "send the Compose UI first article to Nick [20:13] Butcher." [20:14] Eh, just to Nick. [20:16] All right. [20:17] So now what we've done is we actually [20:18] have a second app that uses AppFunctions [20:20] that actually is a chat app. [20:21] We connect to that. [20:22] We're going to find out who Nick is, first of all. [20:25] And then we're going to go and send that article to him. [20:27] It's actually recalled our app. [20:29] And so now if we go over to our chat application [20:34] eventually-- come on, I can use this in an emulator, I promise. [20:37] All right, there we go. [20:39] This is the article, "Android UI Development is Compose First." [20:43] So that is, again, the agent working together [20:47] with two different apps using AppFunctions. [20:49] You can imagine all the cool things this can do. [20:51] All right, back to our slides. [20:53] So check out our tools, and you can experiment with AppFunctions [20:56] today. [20:56] You can join our early access program [20:58] for the chance to be among the first apps [21:00] to deploy AppFunctions to production. [21:02] Now, proactive functionality and automation is a good start, [21:06] but we want to bring the power of AI [21:08] into every part of the Android experience. [21:11] And that means helping your apps make direct use of AI [21:14] with both on-device and server-side implementations. [21:18] Now, using on device models such as Gemini Nano [21:20] keeps sensitive user data local, works without connectivity, [21:24] and also has no per transaction costs. [21:27] Nano is now available on over 140 million devices, [21:31] and it's based on our open Gemma models. [21:34] So you can look for Nano 4 based on the Apache license [21:37] Gemma 4 on flagship devices later this year. [21:40] It features better multilingual support, more battery [21:43] efficiency, and new advanced capabilities. [21:46] And you can test out some of those new capabilities [21:48] today using the AI Core Developer Preview [21:50] and start building with the ML Kit prompt API. [21:54] Now, popular apps are already using the prompt API [21:56] with existing Nano models. [21:58] For example, Webex uses it to translate short chat messages. [22:03] And Photoshop is testing it to automatically rename [22:06] layers and images using imports and exports, which [22:08] is something I've always wanted it to do, [22:10] so I'm excited about that. [22:12] So check out this talk to learn more [22:14] about using on-device models. [22:17] And of course, there are times when [22:18] you want to leverage a cloud-based solution. [22:21] So ABCmouse used Gemini with Google Cloud [22:25] to build a closed-loop feature, which [22:27] offers personalized support when it detects [22:29] that a child needs help. [22:31] And because it's implemented in the cloud, [22:33] it even works on entry-level kids' tablets. [22:36] Now, Gemini Cloud models have advanced capabilities, [22:39] and you can use them directly in production Android [22:41] apps via Firebase AI Logic. [22:43] If you want to build cloud-based agents, [22:46] the A2UI protocol allows them to display UI on the client. [22:50] And on Android, a new Jetpack Compose renderer [22:52] is coming soon to help you display A2UI. [22:55] And to learn more about all of these cloud options and more, [22:58] you can check out this talk. [23:05] ASH NOHE: So those experiences include everyone. [23:08] And so your app reaches the most users, [23:10] you'll want to make your app accessible. [23:12] Here are three things to help. [23:14] First, we've published new guidance [23:16] on scaling your app's content with gestures in Compose. [23:19] DANIEL GALPIN: My ancient eyes thank you [23:21] all in advance for implementing this everywhere. [23:25] ASH NOHE: Second, Talkback can now [23:27] automatically generate image descriptions [23:29] for image composables. [23:31] Now, we still recommend as a best practice [23:34] to define your own content descriptions, [23:36] but this comes in handy when you can't, like [23:38] with user-generated content. [23:39] DANIEL GALPIN: And it's great to see [23:41] AI being used for some cool accessibility wins. [23:43] ASH NOHE: Yeah. [23:44] Finally, the new Accessibility Scanner [23:46] is better than ever at catching common issues [23:48] in your apps like low contrast and small touch targets. [23:52] DANIEL GALPIN: Just use it please, please [23:55] ASH NOHE: I agree. [23:56] Thank you, Dan. [23:58] See this talk for more updates. [24:00] DANIEL GALPIN: Now, privacy and security [24:02] are essential foundations of a great Android experience, [24:05] and this help fosters the trust that users [24:07] need to store their most personal data. [24:10] Now, to that end, Android 17 adds many new privacy [24:13] and security features that you want [24:14] to make sure your app is ready for, such as making sure [24:17] that native libraries are read only when your app dynamically [24:20] loads them, as well as SMS One-Time Password or OTP [24:24] protection, which delays most apps from getting access [24:27] to messages that contain OTPs for three hours. [24:30] But, and this is the cool part, you [24:33] may be able to avoid using OTPs altogether [24:37] because Credential Manager now provides verified email address [24:41] and phone number verification. [24:43] And the traditional creation feature in Credential Manager [24:46] lets apps automatically create passkeys for their existing [24:50] password users. [24:51] And the passkeys are stored in the user's credential provider [24:54] as long as the user opts in. [24:56] Health Connect allows users control over [24:58] their private health data, but this year, apps can actually [25:02] request that the user sync helpful data from another app [25:05] to simplify cross-app setup. [25:08] The CompanionDeviceManager offers a unified dialog [25:11] for device association and nearby permission requests, [25:17] removing multiple pop-ups. And this contains new profiles [25:19] for medical devices and fitness trackers [25:21] that also help efficiently request permissions. [25:24] Because in general, we're trying to simplify security user [25:27] experiences while actually making everything more secure. [25:31] As an example, apps targeting Android 17 now [25:34] require the ACCESS_LOCAL_NETWORK permission [25:36] to discover and connect to devices [25:38] on the local area network, such as smart home devices or casting [25:41] receivers. [25:41] ASH NOHE: But what if you just need [25:43] access to a little bit of data, and you [25:45] don't want to have to request broad sensitive permissions? [25:48] DANIEL GALPIN: Worry not, programmers, [25:50] you can use privacy preserving pickers. [25:52] ASH NOHE: For example, apps supporting Google Cast [25:55] can use Output Switcher to get access to specific streaming [25:58] devices, rather than having to request ACCESS_LOCAL_NETWORK. [26:03] With the new EyeDropper API, apps with color pickers [26:06] can get any pixel's color on the screen [26:08] without having to request broad screen capture permissions. [26:12] And if you use the Contacts Picker, [26:14] you can get access to specific fields and specific contacts [26:17] without having to request the broad read contacts [26:20] permission, which grants you access to the entire contacts [26:23] list. [26:25] And finally, Photo Picker has long [26:27] been around to reduce broad media access, [26:29] and now it's useful in more places [26:31] because it supports portrait gridview. [26:34] Those pickers are one way we're improving the core experience. [26:37] Here's another way we're making it more integrated. [26:40] Last year, we unveiled Live Update notifications [26:43] for a few select styles. [26:46] This year, we've added the metric style [26:47] template for health and fitness apps, timers, and travel apps. [26:52] And you can use the semantic color API [26:54] to convey state in your live update. [26:57] We're also planning for a more unified call history [27:00] by bringing call logs from apps like WhatsApp [27:02] and Meet together in the same native phone app. [27:06] And later this year, we're updating [27:08] thousands of our cute but flat emoji to be delightfully richer. [27:13] All you need to do to get this in your app [27:15] is use a system emoji. [27:18] And finally, Picture in Picture has a new Jetpack library [27:21] for video playback, call, and navigation. [27:24] If you use it with CameraX, your users [27:26] can read a script while recording their social media [27:29] content. [27:30] Speaking of cameras, we've built on-device APIs [27:34] for AI-powered effects so you can give users [27:36] the advanced tools that they need to tell [27:38] the stories they want to share. [27:41] For example, Instagram's Edits app [27:43] improved video quality using the on-device image and video [27:48] enhancement library. [27:50] Let's see a demo of this library working in our sample app [27:53] with images. [27:54] DANIEL GALPIN: All right, cool. [27:58] ASH NOHE: All right. [28:08] I adore this photo of my mom taken [28:11] during her rebellious teenage years. [28:13] But being an old photograph, it's grainy and blurry. [28:17] So I'm going to press AI Enhance, [28:19] and the on-device library will return a clearer image [28:22] where details like her eyes are more well defined. [28:27] At a high level, to get this working, [28:29] we're going to tell the API to use [28:32] certain effects like upscaling. [28:34] We could have also selected Deblur and Denoise, Tone [28:38] Mapping, and then our mode is Enhancement Mode Bitmap. [28:43] Or we could have also provided a surface view. [28:45] And then after the user has made their selection, [28:49] we will call processBitmapAsync to actually apply those effects [28:54] on the given bitmap or, in this case, the image of my mom. [28:57] So let's select another image, this one in color. [29:03] Since all of this is run on device, [29:05] it won't cost you a cent in server costs, [29:09] and users can even use this while in airplane mode, which [29:14] you can see here. [29:16] [APPLAUSE] [29:22] So what you can see from this image, [29:24] the resulting image is brighter due to the tone mapping, [29:27] and then the letters PB here are sharper [29:30] because of the upscaling. [29:33] Let's take a look at that. [29:35] And there we go. [29:37] Back to the slides. [29:38] [MUSIC PLAYING] [29:41] DANIEL GALPIN: Oh, wait, wait, wait. [29:43] Unexpected background audio. [29:47] I don't like it. [29:49] Users don't like it. [29:50] And one of the many improvements in Android 17 [INAUDIBLE] [29:53] reduce those embarrassing audio moments [29:57] by restricting the use of audio APIs [29:59] to foreground apps and foreground services [30:02] with while-in-use capabilities. [30:04] Using media session service to manage background audio playback [30:07] actually can help mitigate impact. [30:09] And because you've asked, exact alarms are exempted. [30:16] Now, other Android 17 media improvements [30:18] include support for new pro image and video formats, [30:21] improved audio streaming and voice quality with HE-AAC, [30:25] and camera enhancements, including [30:27] vendor-defined extensions. [30:30] Next-generation Eclipsa video is officially launching on Android [30:34] 17, with high-quality HDR playback that addresses things [30:38] unpredictable light levels and rendering issues, [30:41] and ExoPlayer provides out-of-the-box support. [30:44] Now, to learn how to take advantage [30:45] of these and many other improvements [30:47] through our Jetpack, Media3, and CameraX APIs, [30:50] check out this talk. [30:53] NICK BUTCHER: Thank you. [30:56] So Android is a multi-device ecosystem. [30:59] Users moving between their phones, their foldables, [31:02] their tablets, their watches, their headsets, their cars, [31:05] and their TVs, and they expect their apps to move with them. [31:09] And your app should. [31:11] There are now over 580 million large screen users, [31:15] and they spend more and engage more with their apps. [31:18] And they also expect more, such as making [31:20] use of the full screen regardless of the orientation [31:23] or aspect ratio, which is why in Android 17, [31:26] we now ignore these attributes on large screen devices, [31:30] and you can no longer opt out. [31:33] So use the Navigation 3 or Compose adaptive libraries [31:36] in order to build a rich, adaptive app. [31:38] They handle the heavy lifting for you, [31:40] covering common scenarios out of the box. [31:42] So for example, version 1.1 of the Navigation free library [31:45] recently added scene decorators, which [31:48] helps you to add UI elements such as navigation rails [31:50] and bars at the scene level rather than at the NavEntry [31:53] level, which can be extremely handy for controlling [31:56] things like the visibility of global navigation UI. [31:58] Oh, and speaking of navigation free, we've heard you. [32:01] You want support for deep links, and we're [32:03] pleased to say it's just landed in version 1.2 Alphas. [32:08] We're also working on a trio of new Compose APIs [32:11] to help you to build adaptively. [32:13] Firstly, MediaQuery greatly simplifies [32:15] querying a device's capabilities such as screen size or pointer [32:20] precision or keyboard presence so that you can use [32:23] these signals to adapt your UI. [32:26] Next up, we're launching a new FlexBox implementation, which [32:30] is a very flexible layout to help you to grow, shrink, [32:33] or wrap elements depending on the available size, again, [32:35] helping you to build components which will [32:37] resize for different devices. [32:40] And finally, Grid is a new layout [32:42] which you can use to divide up and place your content [32:45] into a regular grid structure. [32:47] Now, this can be extremely useful as a root-level layout [32:50] if you want to rearrange your content based [32:52] on different screen sizes. [32:54] FlexBox, MediaQuery, and Grid are all experimental APIs [32:58] in Compose 1.11. [33:00] So please try them out and give us your feedback. [33:03] And speaking of large screens, don't forget about the largest [33:06] screen in your house, your TV. [33:08] Pointer remotes are coming to Google TVs [33:10] to help you to quickly navigate around the interface. [33:14] Check out our documentation and ensure [33:15] you're using the latest TV libraries [33:18] to make sure your app is ready for this change. [33:23] ASH NOHE: In a multi-device ecosystem, [33:25] users move between their devices, [33:27] picking the best one for their task at hand. [33:30] Continue On lets users start a task on one device [33:33] and transition it to another. [33:36] NICK BUTCHER: Bubbles? [33:37] Haven't we had Bubbles since Android 11? [33:39] ASH NOHE: Well, now we have more bubbles. [33:40] Any app can be bubbled, and they're not just for chat apps [33:43] anymore. [33:43] And on large screen devices, users have a new Bubble bar [33:46] to help manage their bubbles. [33:49] Widgets are another way users multitask, [33:52] and because users see them a lot, [33:54] they may help improve user loyalty. [33:56] For example, Gratitude found 25% higher retention [34:01] among widget users. [34:03] And widgets aren't just for tiny phone home screens anymore. [34:06] They show up on foldables, tablets, and more, especially [34:11] since this year, we're gearing up [34:12] to bring widgets to the millions of compatible cars. [34:16] And Tiles is evolving into Wear Widgets under Jetpack Glance. [34:21] So as a developer, your key takeaway [34:23] here is to use Jetpack Glance to build widgets [34:26] for the adaptive ecosystem. [34:29] When you're building with Glance, [34:30] you may directly or indirectly come across a new library [34:33] called Remote Compose. [34:35] This library enables expressive widget animations [34:38] like the snap scrolling one you see here. [34:42] OK, see these talks to learn more [34:44] about building adaptive widgets and apps. [34:49] Let's talk more about Wear. [34:50] [APPLAUSE] [34:54] This year, we're releasing Wear OS 7, [34:57] and thanks to platform improvements, [34:59] you can expect up to 10% better battery life, [35:02] so users can do more with your apps. [35:05] Let's first look at features that automatically extend [35:08] from the phone to the watch. [35:11] When a user starts a media session [35:13] on your app from the phone, they can automatically [35:16] choose to have system playback controls show up [35:19] on their watches. [35:21] And their watches can control their paired phone's media [35:24] output, for example, to switch from speakers to headphones. [35:28] Watch manufacturers may bridge live update notifications [35:32] from the phone to the watch. [35:34] And again, this doesn't require any work on your end. [35:38] But if you do have a Wear OS app, [35:40] you can choose to create local live update notifications, which [35:43] comes in handy when the user is walking around [35:46] without their phone. [35:48] And finally, with zero effort on your end, [35:51] mobile UI automation handles complex tasks hands free, [35:55] like ordering from DoorDash. [35:58] If you do have a Wear OS app, you [36:00] could also create AppFunctions with agents like Gemini [36:03] to invoke in-app flows, starting a workout with Samsung Health. [36:09] OK, here are three more features if you do have a Wear OS app. [36:15] We just went over Wear widgets. [36:17] We're also launching Wear Workout Tracker in Google Play [36:20] services later this year. [36:22] So apps like Runkeeper can use this for metrics and media [36:25] controls. [36:27] Compose for Wear OS 1.6 supports Navigation 3, [36:30] and a new local ambient mode manager [36:32] helps you manage content while your device is in a power saving [36:36] state. [36:37] The Wear OS 7 Canary emulator is available in Android Studio [36:41] now, so you can get hands on with all our new features. [36:44] See our blog and docs to learn more. [36:47] Let's talk about the other wearable form factor. [36:51] If you are already building adaptively for Android, [36:53] you are already building for XR headsets, [36:57] and your existing app extends to wired XR glasses. [37:00] With these devices, you can create immersive experiences [37:04] like transporting the user to a virtual world. [37:07] But if you prefer designing everyday interactions instead, [37:11] you can create augmented experiences with audio glasses [37:15] and display glasses. [37:17] Here the user's focus stays grounded in the real world, [37:20] but their experience is enhanced with visual and audio overlays. [37:25] We've made improvements to both immersive and augmented [37:28] experiences with the Android XR SDK. [37:31] And fundamental Jetpack XR SDK libraries will be in beta soon. [37:36] So let's look at just four new improvements. [37:39] First, you can soon build immersive worlds while keeping [37:43] your app size small by creating geometry in real time, [37:47] rather than shipping large 3D models in your app's binary. [37:52] Second, are you lost? [37:54] Not anymore, because we're introducing [37:57] navigating with the Geospatial API for wired XR glasses. [38:02] Third, we've expanded support with Godot and Unreal Engine. [38:06] We support Android XR vendor extensions [38:09] like scene understanding, light estimation, face tracking, [38:12] and more. [38:14] Fourth, we've improved Jetpack Compose Glimmer, [38:17] which are the composables you'll use [38:18] to design for the visual and interaction constraints [38:21] of display glasses. [38:24] We've added new interactive components like vertical lists [38:27] and stacks, and there's a new skill [38:29] so you can add Glimmer to your app easily. [38:33] We've just scratched the surface, [38:35] so see these talks to learn more. [38:37] And apply to the XR developer catalyst program [38:40] to get access to hardware, resources, [38:42] grant funding for wired XR glasses and display glasses. [38:47] OK, we're shifting gears from the glasses [38:50] you wear to the car that gets you there. [38:52] We've simplified building apps for cars [38:54] by increasing parity between the two systems, [38:57] between both Android Auto and cars with Google built in. [39:01] So here are the ways you can build [39:03] for both platforms at once. [39:05] First, use latest Car App Library templates [39:08] for driving optimized UI. [39:11] This year, you can use both the media app templates [39:13] on Android Auto and cars with Google built in, [39:16] and you can use the Google Maps SDK with the Maps [39:20] with Content Template on both platforms, too. [39:24] In Car App Library 1.9, we're adding [39:26] 10 new flexible components and layouts for both platforms. [39:31] You'll see enhanced chips, expandable headers, [39:35] progress bars, and more. [39:37] With these components, apps like Amazon Music and Spotify [39:41] can express their brand and add features from other form factors [39:46] into cars. [39:48] Many media app developers are building with Car App Library [39:51] 1.9, and you can too by signing up for early access. [39:55] Finally, in the Android show, we shared our plan [39:58] to release a new Car App Library APIs to transition from parked [40:02] to driving on both systems later this year, [40:06] and how you can build equivalent video [40:08] experiences on both platforms. [40:10] So for example, users can watch HD videos while parked. [40:15] See the docs to learn more. [40:20] NICK BUTCHER: So we're almost at the end. [40:21] We're going to leave you with one last takeaway. [40:24] The next iteration of ChromeOS, built with parts of the Android [40:27] stack, is here, and it's called Googlebook, [40:30] and it will run your Android apps better than ever. [40:32] So consider also supporting desktop experiences [40:35] in your adaptive app. [40:36] For example Bandlab, PowerDirector, and Notability, [40:39] they added things such as keyboard shortcuts, drag [40:42] and drop, or custom pointers to their adaptive layouts [40:45] to improve their desktop experience. [40:48] See these talks to learn about adaptive development [40:50] and how to create desktop class apps. [40:53] DANIEL GALPIN: So we've covered a lot of ways [40:55] to help you build incredible apps, [40:58] and starting with how Android is evolving from an operating [41:01] system to an intelligent system with your apps at the center [41:05] of this transformation. [41:06] We're also preparing for the future with Android 17, [41:09] with support for the latest media and GPU standards, [41:12] and a focus on memory optimization [41:14] and system-wide performance so that apps [41:17] are fast and responsive on every device. [41:21] ASH NOHE: We're helping you foster user trust [41:22] with features like SMS one-time password protection [41:26] and privacy preserving pickers. [41:29] And as users, move across the multi-device ecosystem, [41:32] your app can meet them where they're [41:33] at with adaptive APIs and Navigation 3. [41:37] NICK BUTCHER: And finally, we're officially Compose first. [41:40] We're focusing all of our new APIs, libraries, tools, [41:43] and guidance on our most productive toolkit, [41:46] which makes it fast and easy for you to build incredible apps. [41:49] So together, we can ensure that the entire app [41:52] ecosystem can deliver high-quality experiences [41:55] to Android users. [41:56] Please see the deep dive talks to learn more [41:58] about each of these topics. [41:59] And thank you for joining us today. [42:01] [MUSIC PLAYING]