Android 17 Deep Dive: New APIs, Critical Updates, and Migration Priorities

Google’s approach to Android releases just took a sharp turn. With API level 37, the company has ditched the traditional Developer Preview cycle in favor of a rolling Android Canary channel. Features now ship the moment they clear internal validation rather than waiting for scheduled quarterly updates. But that’s just the beginning. This release fundamentally changes how your app must handle large displays, process messages, access user data, and respect privacy boundaries.

If you’re planning to target SDK 37, you need to move fast. Platform Stability drops in March 2026, with the final public release coming several months after. Between now and then, you’ll need to tackle mandatory responsive design requirements, eliminate any reflection touching framework internals, swap out broad permissions for scoped alternatives, and prepare for a completely reworked message handling system. Let’s break down what actually matters and how to implement it.

📱 Responsive Design Is No Longer Optional for Tablets and Foldables

Starting with SDK 37, orientation locks and fixed aspect ratios won’t work on devices with screens measuring 600dp or larger in their smallest dimension. The platform will completely disregard screenOrientation, resizeableActivity, minAspectRatio, and maxAspectRatio attributes. Your UI needs to gracefully handle every conceivable window configuration users throw at it.

Two exceptions exist: devices below the 600dp threshold and any app declaring android:appCategory="game" in its manifest. Everyone else must adapt. Before Platform Stability hits, spin up Pixel Tablet and Pixel Fold emulators with targetSdkPreview = "CinnamonBun" to catch layout breakage early.

Here’s how to migrate from locked configurations to flexible ones:

// ❌ OLD APPROACH (Android 17 will ignore this on large screens)
<activity android:screenOrientation="portrait" android:resizeableActivity="false" />

// ✅ NEW APPROACH
<activity android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout" />

Leverage Jetpack’s WindowSizeClass to build truly adaptive interfaces:

@Composable
fun AdaptiveScreen() {
    val windowSizeClass = currentWindowAdaptiveInfo().windowSizeClass
    when (windowSizeClass.windowWidthSizeClass) {
        WindowWidthSizeClass.COMPACT -> PhoneLayout()
        WindowWidthSizeClass.MEDIUM -> TabletLayout()
        WindowWidthSizeClass.EXPANDED -> DesktopLayout()
    }
}

⚡ Configuration Changes No Longer Destroy Your Activities

Android 17 stops recreating Activities when users connect keyboards, switch navigation modes, toggle dark mode, or dock their device. Instead, onConfigurationChanged() receives the update while your Activity keeps running. This eliminates the jarring interruptions that previously killed video playback mid-stream or wiped unsaved form data when someone plugged in a Bluetooth keyboard.

For the rare cases where you genuinely need a full Activity restart for specific configuration shifts, explicitly declare them:

<activity
    android:name=".MainActivity"
    android:recreateOnConfigChanges="keyboard|keyboardHidden|navigation|touchscreen|colorMode" />

🔍 ProfilingManager: Automatic Diagnostics When Things Go Wrong

Debugging production issues just got easier. The new ProfilingManager ships with three automated triggers that capture diagnostic snapshots exactly when failures occur:

• 🚀 TRIGGER_TYPE_COLD_START — records call stacks and system traces during cold launches
• 💥 TRIGGER_TYPE_OOM — dumps the Java heap the instant an OutOfMemoryError fires
• ⚠️ TRIGGER_TYPE_KILL_EXCESSIVE_CPU_USAGE — samples call stacks when the system terminates your app for burning too much CPU

Built-in rate limiting prevents runaway data collection: once per 24 hours for cold starts, hourly for OOM events, and every 6 hours for CPU-related kills. Register a listener and pipe results straight to your crash reporting backend:

val profilingManager = context.getSystemService(ProfilingManager::class.java)
val coldStartTrigger = ProfilingTrigger.Builder(ProfilingTrigger.TRIGGER_TYPE_COLD_START)
    .setRateLimitingPeriodHours(24)
    .build()
profilingManager.registerForAllProfilingResults(executor) { result ->
    when (result.triggerType) {
        ProfilingTrigger.TRIGGER_TYPE_COLD_START -> uploadTrace(result)
        ProfilingTrigger.TRIGGER_TYPE_OOM -> uploadHeapDump(result)
        ProfilingTrigger.TRIGGER_TYPE_KILL_EXCESSIVE_CPU_USAGE -> uploadCpuProfile(result)
    }
}

⚡ Under the Hood: Lock-Free Message Processing and Enhanced JobScheduler Debugging

The platform now uses a lock-free MessageQueue implementation called DeliQueue for all apps targeting SDK 37. This dramatically reduces main-thread contention and eliminates frame drops caused by message queue locks. The downside? Any code using reflection to access private MessageQueue fields will immediately crash. Scan your dependencies and custom profiling tools now—switch to public APIs like Handler.post or coroutines before you target the new SDK.

JobScheduler gets a debugging upgrade with getPendingJobReasonStats(), which returns pending reasons and their cumulative durations in one call:

val stats = jobScheduler.getPendingJobReasonStats(jobId)
// Example output: PENDING_JOB_REASON_CONSTRAINT_CHARGING -> 60000 (milliseconds)

ART’s new generational garbage collector prioritizes young-generation collections, which translates to shorter pauses for allocation-heavy workloads.

🔐 Session-Based Contact Access Replaces Blanket Permissions

The days of requesting READ_CONTACTS for everything are over. Android 17’s Contacts Picker (ACTION_PICK_CONTACTS) grants temporary access exclusively to the contacts users explicitly select. No broad permission dialog, no indefinite data access.

val pickerLauncher = registerForActivityResult(
    ActivityResultContracts.PickContact()
) { uri ->
    uri?.let { 
        context.contentResolver.query(it, arrayOf(Contacts.DISPLAY_NAME), null, null, null)
            ?.use { cursor -> 
                if (cursor.moveToFirst()) processContact(cursor.getString(0))
            }
    }
}

// Launch the picker
pickerLauncher.launch(null)

Access automatically expires when the session ends, giving users precise control over their data.

🔄 Handoff API: Seamless Cross-Device Activity Continuation

Users can now start a task on one Android device and pick it up instantly on another. The Handoff API makes this possible with minimal integration work. Enable it on a per-Activity basis:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setHandoffEnabled(true)
}

override fun onHandoffActivityRequested(): HandoffActivityData {
    return HandoffActivityData.Builder()
        .setDeepLink("myapp://article/$currentArticleId")
        .setExtras(Bundle().apply { putInt("scroll_position", scrollY) })
        .build()
}

Nearby devices automatically surface available activities in their launcher and taskbar, creating a fluid multi-device experience.

🛡️ Detect and Respond to Advanced Protection Mode

Advanced Protection Mode lets high-risk users enable enhanced security measures. Your app can detect when a user has opted in and adjust its security posture accordingly:

// AndroidManifest.xml: <uses-permission android:name="android.permission.QUERY_ADVANCED_PROTECTION_MODE" />

val apm = context.getSystemService(AdvancedProtectionManager::class.java)
if (apm?.isAdvancedProtectionEnabled() == true) {
    enforceHardenedPolicy() // Disable WebView JavaScript, enable certificate pinning, etc.
}

apm?.registerAdvancedProtectionCallback(executor) { enabled ->
    if (enabled) enforceHardenedPolicy() else restoreStandardPolicy()
}

🎨 Semantic Colors for Live Notifications and System-Wide Color Picking

Live Update notifications now support semantic color annotations. Apply meaning through color—blue for informational, green for safe states, orange for caution, red for critical alerts—without building custom notification layouts:

val ssb = SpannableStringBuilder()
    .append("Status: ")
    .append("SAFE", Notification.createSemanticStyleAnnotation(SEMANTIC_STYLE_SAFE), 0)
    .append(", ")
    .append("CAUTION", Notification.createSemanticStyleAnnotation(SEMANTIC_STYLE_CAUTION), 0)

Notification.Builder(context, channelId)
    .setContentText(ssb)
    .setOngoing(true)
    .build()

The EyeDropper API enables pixel-perfect color sampling from anywhere on the screen without requesting screen capture permissions. Design apps, accessibility tools, and color utilities can now offer color-picking features without the overhead of MediaProjection or CAPTURE_VIDEO_OUTPUT.

📸 Professional Camera Controls and Next-Gen Video Compression

Dynamic output switching — CameraCaptureSession.updateOutputConfigurations() eliminates the 200–500ms freeze that occurred when switching between photo and video modes. Reconfigure outputs on the fly without tearing down the entire session:

fun switchToVideo(session: CameraCaptureSession, videoOutput: OutputConfiguration) {
    session.updateOutputConfigurations(listOf(previewOutput, videoOutput))
}

📹 VVC (H.266) codec support — Versatile Video Coding delivers 50% better compression than HEVC while maintaining the same visual quality.

🎥 Constant quality encoding — MediaRecorder.setVideoEncodingQuality() now supports CQ mode for more consistent visual fidelity across varying scene complexity.

🎵 Background audio enforcement — Playback, audio focus requests, and volume adjustments silently fail when your app lacks an active foreground lifecycle state, closing a longstanding privacy loophole.

📊 Carrier data plan integration — SubscriptionInfo.getStreamingAppMaxDownlinkKbps() and getStreamingAppMaxUplinkKbps() expose actual carrier bandwidth limits, enabling streaming apps to select appropriate quality tiers based on the user’s plan constraints rather than guessing.

💬 Universal bubbles — Long-press any launcher icon to float the entire app in a resizable window. On tablets and foldables, a dedicated bubble bar in the taskbar manages multiple concurrent floating windows. Follow multi-window best practices to ensure your app works correctly in bubble mode.

⚠️ Critical Migrations Required Before Targeting SDK 37

🌐 Cleartext HTTP is deprecated — android:usesCleartextTraffic no longer works for apps targeting SDK 37. The platform blocks cleartext connections by default. Create a Network Security Configuration file and whitelist only the specific domains that absolutely require HTTP. Use domain-config for production exceptions and debug-overrides for local development servers.

📡 Local network discovery requires runtime permission — The new ACCESS_LOCAL_NETWORK runtime permission (part of the NEARBY_DEVICES group) gates all LAN scanning and device communication. Request it before attempting local discovery. A system-provided device picker lets users authorize specific devices rather than granting blanket network access.

📱 SMS OTP access delayed by three hours — To combat OTP hijacking attacks, Android 17 delays programmatic SMS access for three hours after receipt. Default SMS apps and approved companion device apps are exempt. Migrate immediately to the SMS Retriever API or SMS User Consent API for OTP handling.

⚙️ MessageQueue reflection will crash your app — The lock-free DeliQueue implementation breaks any reflection targeting private MessageQueue fields. Third-party profiling libraries and custom Looper implementations that hook into internals will fail immediately. Audit your codebase and all dependencies for MessageQueue reflection before targeting SDK 37.

🔔 Custom notification size limits enforced — The platform applies strict size constraints to custom RemoteViews in notifications. Oversized layouts will be rejected or severely truncated. Stick with standard notification templates whenever possible.

🧠 NPU usage requires manifest declaration — Apps that directly access the Neural Processing Unit must declare FEATURE_NEURAL_PROCESSING_UNIT in the manifest. This enables proper installation filtering on devices without NPU hardware.

🔗 Essential Resources:

• Complete Android 17 Features and APIs Reference
• ProfilingManager Official Documentation
• Behavior Changes Affecting All Apps
• Behavior Changes for Apps Targeting Android 17
• Join the Android 17 Beta Program

Android 17 draws a clear line in the sand: apps must gracefully adapt to any screen configuration, respect granular permission models, and avoid coupling to platform internals. The mandatory responsive layout enforcement, combined with lock-free message processing and tightened privacy controls, demonstrates Google’s expectation that every app should deliver a polished experience across phones, tablets, foldables, and beyond. Start testing on Pixel Tablet and Fold emulators today, eliminate manifest antipatterns and reflection hacks now, and prepare your codebase before Platform Stability arrives in March. ✨

Thanks for reading! 🙌