The Android ecosystem is evolving faster than ever– foldables, Chromebooks, car displays, and large-format tablets are no longer niche devices. In response, Android 16 is enforcing a major change that will affect how every developer handles screen orientation.
In short: fixed orientations like portrait or landscape will no longer be honored for most apps. If you’ve been locking your app to portrait mode and ignoring rotation events, that approach won’t work anymore.
This is not just a cosmetic tweak– it’s a paradigm shift in UI design, state handling, and user experience.
What’s Changing in Android 16
Until Android 15, you could simply add this in your AndroidManifest.xml:
< activity. android: name =". MainActivity" android: screenOrientation =" portrait"/ >
and your app would never rotate. Even if the device was flipped sideways, Android would respect your wish and keep the UI fixed.
From Android 16 onward, this behavior will be deprecated for most use cases. Apps will be expected to:.
- Support all orientations (portrait, landscape, reverseLandscape, etc).
- React to runtime orientation changes.
- Handle UI state preservation when the layout changes shape.
If you try to force portrait mode on Android 16 without following the new guidelines, you’ll either get warnings during build or see your app rotate regardless of the manifest setting.
Why Google is Doing This.
While it might feel restrictive, the reasoning is logical:.
Foldables need apps that adapt seamlessly when the screen folds/unfolds. Chromebooks run Android apps in resizable windows that can be rotated or resized freely. Multi-display setups (car dashboards, TVs, external monitors) don’t work well with orientation-locked apps. By removing the “easy way out” of locking orientation, Google is nudging developers toward truly adaptive UIs.
The Real Impact for Developers.
If your app already supports both orientations gracefully– congratulations, you’re ahead of the curve.
But if you’ve been relying on fixed orientations to avoid dealing with:.
- Activity recreation on rotation.
- State loss during configuration changes.
- Complex responsive layouts.
then Android 16 is going to be a wake-up call.
Handling Orientation Changes the Right Way.
Since you can no longer avoid orientation changes, you need to embrace them in your architecture.
1. Preserve State with ViewModel
The ViewModel in Android Jetpack survives configuration changes, making it a go-to solution for keeping data intact when the screen rotates:
class MainViewModel : ViewModel() {
var counter = 0
}
class MainActivity : ComponentActivity() {
private val viewModel: MainViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button = findViewById<Button>(R.id.counterButton)
button.text = viewModel.counter.toString()
button.setOnClickListener {
viewModel.counter++
button.text = viewModel.counter.toString()
}
}
}
No matter how many times the user rotates the device, the counter value remains intact.
2. Use Compose for Responsive Layouts
If you’re building with Jetpack Compose, orientation handling becomes much easier with LocalConfiguration:
@Composable
fun AdaptiveLayout() {
val configuration = LocalConfiguration.current
if (configuration.orientation == Configuration.ORIENTATION_PORTRAIT) {
Column {
Text("Portrait Layout")
// Portrait-specific UI
}
} else {
Row {
Text("Landscape Layout")
// Landscape-specific UI
}
}
}
This approach allows you to render completely different layouts depending on orientation, without restarting the activity.
3. Use onConfigurationChanged for Specific Adjustments
If you prefer handling certain UI adjustments manually, you can opt into configuration changes in your manifest:
<activity
android:name=".MainActivity"
android:configChanges="orientation|screenSize" />
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
// Adjust UI for landscape
} else {
// Adjust UI for portrait
}
}
Caution: This skips activity recreation, so you must handle all layout adjustments yourself.
Alternative Approaches to Smooth Transitions
ConstraintLayout + Guidelines: Build flexible layouts that adapt naturally without separate XML files.
Foldable APIs: Use WindowManager Jetpack library to detect folding posture and adapt layout accordingly. Adaptive Typography & Spacing: Scale text and paddings based on available space, not fixed DP values.
The Road Ahead
Android 16’s orientation policy is a push toward universal adaptability. At first, it might feel like extra work, but in the long run, it ensures your app:
- Works across more devices without hacks
- Feels natural on foldables and large screens
- Survives the inevitable trend toward multi-screen workflows
The truth is, the earlier you adapt, the smoother the transition will be when Android 16 lands.
