Android 17 Is Here: Everything Developers Need to Know

Google officially released Android 17 on June 16, 2026, making it available on most supported Pixel devices with partner OEMs to follow in the coming months. This is not a minor version bump. Android 17 marks a fundamental shift — Google is moving Android from an operating system to what they're calling an "intelligence system," with deep AI agent integration, mandatory adaptive layouts, strict memory enforcement, and a decisive declaration that Jetpack Compose is now the only path forward for Android UI.

Whether you're building with native Kotlin, Flutter, or React Native, several of these changes will directly impact your apps. Here's the full breakdown.

The Big Picture: Android Becomes an Intelligence System

The headline feature of Android 17 is AppFunctions — a platform API that turns your app's capabilities into tools that AI agents can discover and execute. Think of it as Android's native implementation of the Model Context Protocol (MCP), running on-device.

With AppFunctions, AI assistants like Google Gemini can orchestrate actions across apps on the user's behalf. A user could say "create a note about today's meeting" and Gemini will discover your note app's createNote function, execute it, and return the result — all without the user ever opening your app.

The implementation is surprisingly simple. You annotate a Kotlin class with @AppFunction and add KDoc comments that describe what each function does. The AI agent uses those descriptions to decide when and how to call your function:

class NoteFunctions(private val noteRepository: NoteRepository) {
    /**
     * Adds a new note to the app.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }
}

Google also released an AppFunctions agent skill that analyzes your app's workflows and auto-generates the Kotlin code, optimized KDocs for LLM tool-calling, and ADB commands for testing.

The Gemini integration is in private preview, but you can start building and testing now using the provided test agent app. Early access is available at goo.gle/eap-af.

What this means for Flutter developers: AppFunctions requires native Kotlin code. If you want your Flutter app to participate in the Android AI agent ecosystem, you'll need to write platform channel code or a native plugin that exposes your app's functions. This is a significant opportunity — apps that integrate AppFunctions early will show up in Gemini's action suggestions while competitors won't.

Adaptive-First Is Now Mandatory

This is the change that will break the most apps. Starting with Android 17 (API 37), Google is removing developer opt-outs for orientation and resizability restrictions on large screens (sw > 600dp).

The system will ignore these manifest attributes and APIs entirely:

• screenOrientation

• setRequestedOrientation()

• resizeableActivity=false

• minAspectRatio / maxAspectRatio

Your app must handle any window size, support free-form windowing, and respect the user's device posture. Games listed in the games category on Google Play are the only exception.

With over 580 million large-screen Android devices in the wild and the upcoming launch of Googlebooks (the next generation of ChromeOS built on the Android stack), Google is clearly betting that the multi-form-factor future is here.

New Multitasking: App Bubbles and Desktop Interactive PiP

Android 17 introduces three new windowing modes your app needs to handle:

• App Bubbles — Users can turn any app into a floating bubble by long-pressing its icon. This works on phones, foldables, and tablets.

• Bubble Bar — On large screens, the system taskbar includes a dedicated area to organize floating app bubbles.

• Desktop Interactive PiP — Picture-in-Picture windows are now fully interactive in desktop mode (not just read-only video playback).

Continue On

A new cross-device handoff feature that shows the user's most recently opened mobile app in their tablet taskbar, with a one-tap deep link to continue where they left off. This supports app-to-web fallback if the app isn't installed on the target device.

class MyHandoffActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setHandoffEnabled(true, null)
    }

    override fun onHandoffActivityDataRequested(
        handoffRequestInfo: HandoffActivityDataRequestInfo
    ): HandoffActivityData {
        // Return deep link data for the current state
    }
}

What this means for Flutter developers: Flutter apps are generally in good shape here because Flutter's layout system is inherently flexible. However, if you've been hardcoding SystemChrome.setPreferredOrientations to lock portrait mode, that will be ignored on large screens when targeting API 37. Test your app in split-screen, freeform window, and floating bubble modes. If you're using Riverpod or BLoC for state management, your reactive layouts should adapt naturally — but verify it.

Performance: Strict Memory Limits Are Coming

This is the change most likely to cause production crashes. Android 17 will enforce strict app memory limits based on the device's total RAM, and will abruptly terminate apps that exceed them.

If your app gets killed by these limits, ApplicationExitInfo.getDescription() will return "MemoryLimiter:AnonSwap".

Google is providing several tools to help:

• R8 full mode with the new R8 Configuration Analyzer to shrink bytecode footprint

• LeakCanary is now integrated directly into Android Studio Panda's profiler

• Trigger-based profiling via ProfilingManager with TRIGGER_TYPE_ANOMALY to auto-capture heap dumps when memory limits are hit

Generational Garbage Collection

ART's garbage collector now separates short-lived objects from long-lived ones, running frequent lightweight "young-generation" sweeps instead of expensive full-heap scans. Google reports significant improvements in GC interference with application threads and reduced peak memory usage. This improvement is also being backported to Android 12+ devices through Google Play System updates.

Lock-Free MessageQueue

For apps targeting SDK 37, android.os.MessageQueue now uses a lock-free architecture. This reduces missed frames, improves app startup time, and dramatically improves multithreaded queue performance. Breaking change: apps using reflection on private MessageQueue fields will break.

Static Final Fields Are Truly Final

Starting with SDK 37, modifying static final fields via reflection throws IllegalAccessException. Modifying them via JNI crashes the app immediately. Libraries that relied on this hack need updating.

What this means for Flutter developers: Flutter's Dart VM manages its own heap separately from the Android framework, so the strict memory limits primarily affect the native side — platform channels, native plugins, and the Flutter engine's own memory footprint. However, if you're using heavy native plugins (image processing, ML models, video rendering), test them under the new limits. The LeakCanary integration in Android Studio Panda is useful even for Flutter projects when debugging native memory leaks.

Privacy and Security

Privacy-Preserving Choices

Android 17 continues shifting away from broad permanent permissions toward temporary, session-based access:

• System-Level Contact Picker — Apps can request access to specific fields (email, phone) only for the contacts the user explicitly selects, eliminating the need for READ_CONTACTS.

• Customizable Photo Picker — New PhotoPickerUiCustomizationParams allows portrait-mode thumbnails for video-first apps.

• System-Rendered Location Button — A system-managed location button that grants precise location only for the current session.

• EyeDropper API — A system-level color picker that lets users select any pixel on screen without granting screen capture permissions.

val eyeDropperLauncher = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val color = result.data?.getIntExtra(Intent.EXTRA_COLOR, Color.BLACK)
    }
}

fun launchColorPicker() {
    eyeDropperLauncher.launch(Intent(Intent.ACTION_OPEN_EYE_DROPPER))
}

Local Network Access

Apps targeting SDK 37 must declare ACCESS_LOCAL_NETWORK permission or use system-mediated device pickers for any local network communication (smart home devices, casting, etc.).

SMS OTP Protection

SMS OTP messages are now delayed for three hours for non-intended-recipient apps. Apps should migrate to the SMS Retriever API or SMS User Consent API.

Post-Quantum Cryptography

Android 17 ships with quantum-safe cryptography support, including ML-DSA key generation in secure hardware and a new v3.2 APK Signature Scheme combining classical and ML-DSA signatures.

Android Is Now Compose-First (Views in Maintenance Mode)

This is the most consequential long-term declaration in the release. Google has officially announced that all new Android APIs, libraries, tools, and developer guidance will be built exclusively for Jetpack Compose. Legacy View components (android.widget), Fragments, RecyclerView, and ViewPager are now in maintenance mode — receiving only critical bug fixes and no new features.

Google released an XML to Compose Migration Skill that uses AI to automatically convert legacy View layouts into adaptive Compose code.

What this means for Flutter developers: This is actually validating news. Flutter's declarative widget model was Compose-first before Compose existed. If you're already building with Flutter, you're ahead of the curve — and the gap between Flutter's development model and Android's recommended approach has essentially disappeared. Both ecosystems now share the same fundamental philosophy: declarative UI, composable components, reactive state.

Media and Camera

Android 17 brings significant media improvements:

Note for CameraX users: Update to CameraX 1.5.2 or 1.6.0+ to avoid a crash related to a new dynamic range mode on Android 17 devices.

Breaking Changes Checklist for SDK 37

If you're updating your targetSdkVersion to 37, here's what to test:

How to Get Android 17

Android 17 is rolling out to supported Pixel devices now. If you were on Android 17 Beta 4.1 and haven't moved to a QPR1 beta, opt out of the beta program to receive the stable release OTA.

Partner beta devices are available from Honor, iQOO, Lenovo, OnePlus, OPPO, Realme, Sharp, vivo, and Xiaomi.

For development, use the 64-bit system images with the Android Emulator in Android Studio Quail (Canary build recommended for full Android 17 support).

What Flutter Developers Should Do Right Now

Here's your action list:

1. Test on Android 17 emulator. Install your app on an Android 17 image and run through every screen. Pay special attention to large screen layouts, split-screen mode, and freeform windowing.

2. Check your native plugins. Any plugin that uses reflection on private Android framework fields, loads native libraries dynamically, or consumes significant memory needs testing under the new constraints.

3. Consider AppFunctions. If your app has clear user-facing actions (create, search, send, book, play), building a platform channel to expose @AppFunction annotated Kotlin code is a competitive advantage. When Gemini rolls out AppFunctions to production, your app will be discoverable.

4. Update CameraX dependencies. If you use any camera plugin that wraps CameraX, verify it uses version 1.5.2 or 1.6.0+.

5. Review permission usage. If your app uses READ_CONTACTS, local network access, or reads SMS for OTP verification, plan your migration to the new privacy-preserving alternatives.

Final Thoughts

Android 17 is one of the most impactful releases in years. The move to mandatory adaptive layouts, strict memory enforcement, and AI-first agent integration signals where the entire platform is heading. Google is no longer treating large screens, AI assistants, and performance discipline as optional — they're the baseline.

For Flutter developers specifically, the adaptive-first mandate validates what Flutter has always been good at: building flexible, responsive UIs from a single codebase. The biggest opportunity is AppFunctions — if you move quickly, your Flutter app could be one of the first to work seamlessly with Gemini's on-device agent system.

Start testing today. Android 17 is here.