Google has finally pushed the stable build, and the Android 17 new feature list is one of the biggest in years, with the full set of Android 17 new features spanning the home screen, the camera stack, and app security. This roundup of Android 17 new features covers each one in order of impact. The Android 17 stable release landed on June 16, 2026 as API level 37, and these new features touch everything from the home screen to the camera stack to app signing. If you have been searching for a clear rundown of the Android 17 new features, this guide walks through every major new feature with real code you can drop into your own project, plus the smaller Android 17 features that are easy to miss but still matter for daily development. By the end, you will know exactly which of these Android 17 new features are worth adopting first, and which new features can simply wait, since not every Android 17 new feature needs a same-week migration.
The most talked about entry in the Android 17 new features roundup is Bubbles for every app. Before this release, only messaging apps could float a bubble over other windows. Now, long-pressing almost any app icon on the home screen shows a ""Bubble"" option, and the bubble bar manages every open bubble on tablets and foldables. This is one of the most visible new features for regular apps, not just chat clients, and it changes how users expect multitasking to feel on a phone or tablet.
For developers, adopting these new features does not require a rewrite. You still rely on the existing Notification and BubbleMetadata APIs, but Android 17 now lets the system offer bubbling as a launcher shortcut action instead of only through a notification. Here is a minimal example that configures a bubble-ready notification using one of these new features:
import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.drawable.Icon
fun showBubbleNotification(context: Context, bubbleActivityIntent: Intent) {
val channelId = ""android17_bubbles_channel""
val manager = context.getSystemService(NotificationManager::class.java)
val channel = NotificationChannel(
channelId,
""Android 17 Bubbles"",
NotificationManager.IMPORTANCE_HIGH
)
manager.createNotificationChannel(channel)
val bubbleIntent = PendingIntent.getActivity(
context, 0, bubbleActivityIntent, PendingIntent.FLAG_MUTABLE
)
val bubbleIcon = Icon.createWithResource(context, android.R.drawable.ic_dialog_info)
val bubbleData = Notification.BubbleMetadata.Builder(bubbleIntent, bubbleIcon)
.setDesiredHeight(600)
.setAutoExpandBubble(false)
.setSuppressNotification(false)
.build()
val notification = Notification.Builder(context, channelId)
.setContentTitle(""New in Android 17"")
.setContentText(""This app now supports bubbles"")
.setSmallIcon(android.R.drawable.ic_dialog_info)
.setBubbleMetadata(bubbleData)
.build()
manager.notify(1001, notification)
}
Once this notification posts, the user can long-press the app icon or the notification itself and choose to bubble it, and the floating window stays available while they work in other apps. Among all the Android 17 new features, this one is likely to show up in the most day to day screenshots, and it is a good starting point if you only have time to ship one of the Android 17 new features this quarter.
Privacy controls got a real upgrade too. One of the more practical Android 17 new features is the system-rendered location button, which lets an app request the user's precise location for a single session without triggering the usual repeated permission dialogs. Instead of your app asking the operating system for location and hoping the user trusts the prompt, the button itself is drawn by the system, so the user always knows exactly what they are tapping. These privacy-first new features are a running theme across Android 17.
import android.Manifest
import android.content.pm.PackageManager
import android.widget.Button
import androidx.core.content.ContextCompat
class DeliveryMapActivity {
fun bindLocationButton(button: Button, context: android.content.Context) {
val granted = ContextCompat.checkSelfPermission(
context, ""android.permission.USE_LOCATION_BUTTON""
) == PackageManager.PERMISSION_GRANTED
button.text = if (granted) ""Share precise location"" else ""Enable location button""
button.setOnClickListener {
// The system renders and verifies this button; a tap here
// grants a single precise-location session to this activity.
requestOneTimePreciseLocation(context)
}
}
private fun requestOneTimePreciseLocation(context: android.content.Context) {
println(""Requesting one-time precise location session"")
}
}
This new location button is a direct response to how often apps used to nag people for background location just to show a map pin. Alongside it, Android 17 also splits password visibility settings so a brief on-screen echo only happens for touch input, while physical keyboards can keep characters hidden by default, and Find Hub now forces a fingerprint or face check on a phone marked lost even if someone already knows the PIN. These new features work together to make Android 17 noticeably harder to snoop on than earlier releases.
If you own more than one Android device, Cross-device Handoff is one of the Android 17 new features you will notice immediately, and it is one of the new features built for people who switch screens all day. Start a task on your phone, and Android 17 can suggest the same app on your tablet's taskbar so you resume exactly where you left off. This launches with phone-to-tablet transfers first, built on CompanionDeviceManager.
import android.companion.CompanionDeviceManager
import android.content.Context
fun enableHandoff(context: Context, associationId: Int) {
val manager = context.getSystemService(CompanionDeviceManager::class.java)
manager.setHandoffEnabled(associationId, true)
println(""Handoff enabled for association id: $associationId"")
}
Behind this feature sit two new ranging features that also shipped with Android 17: ultra-wideband DL-TDOA ranging built on the FiRA 4.0 specification for privacy-preserving indoor navigation, and WiFi proximity detection based on WiFi Alliance specs. Together these new features make it easier for the operating system to know which of your devices is nearby and worth handing a task off to.
Not every entry in the Android 17 new feature list is about visible polish; some of these Android 17 new features are strictly for developers. Apps that target Android 17, API level 37, on screens 600dp wide or larger can no longer lock their orientation or block resizing. The system now ignores screenOrientation, resizeableActivity, minAspectRatio, and maxAspectRatio on those large screens, with exemptions for smaller devices and apps in the Games category.
<activity
android:name="".MainActivity""
android:screenOrientation=""portrait""
android:resizeableActivity=""false"">
<!--
On a large-screen device running Android 17, these two attributes
are ignored once the app targets API level 37. Plan your layouts
to be resizable instead of relying on a locked orientation.
-->
</activity>
This single change in Android 17 is arguably the most consequential one among all the Android 17 new features for teams still shipping phone-only layouts, because a tablet or foldable running Android 17 will resize the window regardless of what the manifest says.
Security engineers get one of the more forward-looking Android 17 new features in this release, and it is one of the new features that will matter for years: post-quantum cryptography hybrid signing. The updated v3.2 APK Signature Scheme can combine a classical RSA or EC signature with an ML-DSA signature in the same package, so an app stays verifiable even after quantum-resistant algorithms become mandatory. Android 17 also exposes a public HPKE service provider interface so libraries can plug in hybrid public-key encryption without waiting for a platform update.
import android.crypto.hpke.HpkeSpi
import java.security.Provider
import java.security.Security
fun registerHpkeProvider(provider: Provider) {
Security.addProvider(provider)
val spi = Security.getService(provider, ""HPKE"", ""DHKEM_X25519_HKDF_SHA256"")
println(""Registered HPKE provider for Android 17: ${spi != null}"")
}
Alongside signing and HPKE, Android 17 new feature coverage also includes a shorter window for OTP abuse: apps can no longer read an incoming SMS one-time code programmatically until three hours have passed, which pushes everyone toward the SMS Retriever or SMS User Consent APIs instead of broad SMS read permissions. These security-focused new features round out the Android 17 story for anyone building apps that handle sensitive data.
A quieter but very welcome entry in the Android 17 new feature set is how the system responds to configuration changes; this Android 17 new feature is one that most users will never notice directly, but developers will. Android 17 no longer restarts your Activity by default when the keyboard visibility, navigation mode, touchscreen state, color mode, or desktop UI mode changes. Previously, each of these triggered a full onCreate cycle unless you handled it yourself.
import android.content.res.Configuration
import android.app.Activity
class NotesActivity : Activity() {
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
// Android 17 now calls this instead of recreating the activity
// for keyboard, navigation, touchscreen, and color mode changes.
println(""Configuration updated without a restart: $newConfig"")
}
}
If your app genuinely needs the old restart behavior for one of those configuration types, add the new android:recreateOnConfigChanges manifest attribute to opt back in. Android 17 pairs this new behavior with quieter background audio handling too: playback, focus requests, and volume changes from an app that is not in a valid lifecycle state now fail silently instead of interrupting whatever the user is actually doing, and this applies no matter what SDK version the app targets. Both of these new features are easy to overlook in a changelog, but they change real app behavior on every Android 17 device.
Screen recording got a visual refresh in Android 17 as well, with a floating toolbar that keeps pause, stop, and camera controls close at hand instead of buried in a notification shade. Alongside it, the new EyeDropper API is one of the smaller new features that lets an app sample a pixel color from anywhere on screen through a system-level picker, without needing screen capture permission at all:
import android.graphics.Color
fun onColorPicked(pickedColor: Int) {
val hex = String.format(""#%06X"", 0xFFFFFF and pickedColor)
println(""Android 17 EyeDropper returned color: $hex"")
}
Photo and contact pickers also improved: the photo picker gained a PhotoPickerUiCustomizationParams option to switch from the classic 1:1 grid to a 9:16 portrait layout, and a new session-based Contacts Picker intent grants temporary access to a chosen contact without a broad permanent permission. Small as they are, these new features add up across a typical Android 17 app, and picker-level features like these are exactly the kind of Android 17 new features that quietly improve everyday workflows.
Beyond the headline items, Android 17 ships a long list of smaller new features worth knowing about, and several of these new features are the kind that only show up once you hit them in production, especially if you maintain a large or older codebase:
None of these changes are as visible as bubbles or the location button, but together these new features make up a large share of the Android 17 new features that show up in a typical migration checklist, and skipping them is one of the easiest ways to miss real Android 17 new features during an upgrade.
To see a few of the Android 17 new features working together, here is a complete, self-contained Kotlin example that combines two of these new features in one screen: it reacts to a configuration change without a restart and then reports the device's precise location button state, mirroring how a real app might combine two of these Android 17 new features:
import android.app.Activity
import android.content.pm.PackageManager
import android.content.res.Configuration
import androidx.core.content.ContextCompat
class Android17DemoActivity : Activity() {
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
logConfigChange(newConfig)
}
private fun logConfigChange(newConfig: Configuration) {
println(""Android 17 skipped the restart for this configuration change"")
println(""New UI mode: ${newConfig.uiMode}"")
}
fun checkLocationButtonPermission(): String {
val granted = ContextCompat.checkSelfPermission(
this, ""android.permission.USE_LOCATION_BUTTON""
) == PackageManager.PERMISSION_GRANTED
return if (granted) {
""Android 17 location button is ready for a one-time precise fix""
} else {
""Android 17 location button permission has not been granted yet""
}
}
}
fun main() {
val demo = Android17DemoActivity()
val fakeConfig = Configuration()
demo.onConfigurationChanged(fakeConfig)
println(demo.checkLocationButtonPermission())
}
This small demo captures two of the most practical Android 17 new features in one place: the activity survives a configuration change without losing its state, and it can check the new location button permission before asking the user for anything. Together with bubbles, cross-device handoff, and the security-focused new features described above, these Android 17 new features give both users and developers a lot of new features to explore in this release.