Development mobile applications are often faced with the need to rigidly fix the orientation of the interface. The user experience can be disrupted if the app flips unexpectedly when the device's position changes. Android Studio provides developers with powerful tools to control this behavior, allowing them to control orientation both at design time and at code runtime.
In this article, we'll take a closer look at all the available screen capture methods. You will learn how to properly configure the manifest file for global locking, how to control orientation programmatically inside the Activity, and what features of working with the emulator. Understanding these mechanisms is critical to creating stable and predictable interfaces.
Ignoring orientation settings can result in activity redrawing and loss of application state. Therefore, choosing the right approach depends on the architecture of your project. We will look at both standard and advanced techniques that will help you avoid common mistakes when developing for the platform Android.
Global configuration via AndroidManifest.xml
The most reliable and recommended way to fix orientation is a declarative description in the manifest file. This method ensures that the activity will always start in the specified mode, regardless of how the user is holding the device. To do this, you need to open the file AndroidManifest.xml in the root of your project.
Find the tag <activity>that corresponds to your main activity and add the attribute android:screenOrientation. The value of this attribute determines the behavior of the system. For example, setting the value portrait will hard lock the app into portrait mode, which is the standard for most social networks and instant messengers.
⚠️ Note: Changing the orientation via the manifest applies to the entire activity lifecycle. If you need to dynamically change the orientation in different parts of the application, this method will not work, and you will have to use a programmatic approach.
In addition to the standard values, there are specific settings for different form factors. For example, for tablets or foldable devices, you can use a value lockedthat will fix the current orientation at the time of launch and will not allow it to change even if the gadget is physically rotated. This is especially useful for applications with a unique landscape interface.
Use "unspecified" or "behind" if you want the activity to inherit the orientation from the previous activity on the stack, which is useful for child windows.
Software locking within Activity code
Sometimes more flexible control is needed when the orientation should only change in certain scenarios. In such cases, a method is used setRequestedOrientation() inside the activity class. This approach allows you to dynamically respond to user actions or data received from the server.
The call to this method is usually placed in a method onCreate() or in interface event handlers. The code looks concise and clear: you access the current activity and set a constant from the class ActivityInfo. This makes it possible to switch between modes on the fly without restarting the application.
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); To avoid data loss, make sure you handle saving state correctly in the method onSaveInstanceState(). Modern approaches using ViewModel and Lifecycle-aware components simplify this task significantly.
☑️ Checking software locking
Emulator settings and debugging
When testing in the environment Android Studio often there is a need to simulate rotation devices. The emulator provides convenient buttons for changing orientation, but sometimes they can conflict with your lock settings. Understanding how the emulator interprets your directives will help avoid confusion when debugging.
If you have locked orientation in the manifest, the rotation buttons on the emulator toolbar will have no visual effect on the application, although the emulator itself may rotate. This is normal behavior and confirms that your protection is working correctly. To test different scenarios, you can temporarily disable blocking or create several emulator configurations.
| Parameter | Value in code | Description of behavior |
|---|---|---|
| Portrait | SCREEN_ORIENTATION_PORTRAIT |
Vertical orientation, regardless of sensors |
| Landscape | SCREEN_ORIENTATION_LANDSCAPE |
Horizontal orientation, fixed |
| Sensor | SCREEN_ORIENTATION_SENSOR |
Depends on the device accelerometer |
| Locked | SCREEN_ORIENTATION_LOCKED |
Fixing the current orientation at startup |
It is also worth paying attention to the settings of the virtual device itself. In Device Manager you can set the default orientation for a new launch. This is useful when you are developing an application that should run in landscape mode by default, such as a video editor or game.
Features of working with Fragment and Jetpack Compose
Modern development is increasingly shifting towards modular architecture using Fragment and declarative UI through Jetpack Compose. In these environments, orientation management has its own nuances. Fragments do not have a direct method for setting orientation, since they depend on the host activity.
To control orientation within a fragment, you must access the activity through the requireActivity() or getActivity()method. After this, the same method is called setRequestedOrientation(). However, this must be done carefully so as not to cause a state conflict if the same container contains fragments with different screen requirements.
⚠️ Attention: When using navigation graphs (Navigation Component), the orientation setting in a fragment may be reset when switching between screens, if a different value is set in the manifest of the main activity. Always check the priority of the settings.
In the case of Jetpack Compose, orientation is still controlled at the Activity or Manifest level. However, Compose adapts well to configuration changes. If you disable rotation, your composables will simply render in the available space. For complex logic of rotating elements inside an unchangeable screen, you can use modifiers rotate, but this is a visual trick, not a system lock.
Secrets of working with Configuration Changes
If you want to completely ignore the rotation of the device and not restart the activity, you can add an attribute android:configChanges="orientation|screenSize" to the manifest. But this method is considered an outdated practice and is not recommended for new projects, as it requires manual handling of layout changes.
Typical errors and implementation problems
Even experienced developers sometimes encounter situations where rotation prohibition does not work as expected. One common cause is caching of old versions of the manifest or a conflict between the library settings and your code. Always clean build your project after making changes to AndroidManifest.xml.
Another common problem involves activities running in a separate process or with special startup flags. In such cases, orientation attributes may be ignored by the system until the window is fully initialized. It's also worth checking to see if your application's theme (Theme) does not override any window flags that affect screen behavior.
- 📱 Check to see if you have a theme set in your manifest with an attribute
windowIsTranslucentthat could block orientation changes. - 🔄 Make sure that you do not call the orientation change method after the window has already been completely rendered and frozen.
- 🛠 When testing on real devices from different manufacturers, keep in mind that some shells (MIUI, OneUI) may have their own system restrictions on blocking rotation.
If the application crashes when trying to change the orientation, check Logicat via Logcat in Android Studio. Often the error lies in an attempt to access a non-existent layout resource for a new orientation if you have different layout files for portrait and landscape.
The most common mistake is to forget to rebuild the project after editing the manifest. Use the Build -> Clean Project menu to reset the compilation cache.
Impact of blocking on UX and accessibility
Blocking screen rotation is not only a technical decision, but also an important aspect of user experience (UX). A rigid hold may be convenient for applications with unidirectional data flow, but may be a barrier for people with disabilities who are physically more comfortable holding the device in a certain position.
The need for blocking should be carefully considered. If your application is an e-reader or browser, preventing rotation will be perceived negatively. If this is a cash terminal or kiosk mode, then blocking is required. Always allow the user to understand why the screen is not rotating unless it is obvious from the context.
Modern versions Android exist accessibility features that allow users to force orientation changes through system settings, overriding the application's wishes. The developer must be prepared for the fact that its blocking can be bypassed at the OS level for the sake of the convenience of a specific user.
Is it possible to block rotation only for a specific device?
Yes, this can be done programmatically by checking the device model through Build.MODEL before calling setRequestedOrientation. However, this approach is considered bad practice because it makes the code more difficult to maintain. It's better to use responsive layouts.
Why does the screen blink when the orientation is locked?
Blinking usually indicates that the activity is being destroyed and recreated. This is standard Android behavior when changing configuration. To avoid this, you need to properly save state or use architectural components that survive re-creation.
How to unlock an orientation if it was locked in the manifest?
If an orientation is set in AndroidManifest.xml, you cannot programmatically unlock it. You will have to remove the attribute android:screenOrientation from the manifest and control the orientation solely through code if dynamic change is required.
Does locking the screen affect the performance of the application?
No, locking the orientation does not have a negative impact on performance. On the contrary, it can even improve it by preventing unnecessary interface redraws and resource reloads when the user accidentally rotates the device.
Does locking work in Split Screen mode?
In multitasking mode, the system can ignore orientation requests if two applications share the screen horizontally or vertically. The behavior depends on the version of Android and the implementation of multi-window mode by the device manufacturer.