I am now working on an android application, that is just gonna be for demo purposes. So during the development of the project, we didn't focus a lot on the orientation changes to the application. Whenever there is an orientation change, the application crashes. It is now too late to maintain the data for each activity or fragment.
So my question is, is there a way to set the orientation to potrait throughout the application. Even if the user rotates the phone, can we maintain the state to be potrait?
TL;TR: add this to your AndroidManifest.xml
<activity android:name=".YourActivity"
android:configChanges="orientation"
android:screenOrientation="portrait"/>
You can checkout this answer as well.
From Java:
#Override
public void onCreate(Bundle
savedInstanceState){
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
From XML:
<activity
android:name=".ActivityName"
android:label="#string/app_name"
android:screenOrientation="portrait" />
In the app I am developing,I am implementing a splashscreen This splashscreen comes at the start of the app. When the splashscreen is launched, the action bar is visible for a small moment say half a second and then disappears. I am not sure why this is happening. Could any one please help me in resolving this issue. I have implemented the following code in the manifest file.
<activity
android:name="com.example.trycatch.SplashscreenActivity"
android:label="#string/app_name"
android:theme="#android:style/Theme.NoTitleBar.Fullscreen"
android:noHistory = "true"
android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
</intent-filter>
</activity>
And below is the activity file snippet
#Override
protected void onResume() {
setContentView(R.layout.splashscreen);
super.onResume();
}
Could anyone please help me. Thanks for your time.
PS: I am using sherlock actionbar library
Use the following code in the activity(that means in your java file) before setContentView()
requestWindowFeature(Window.FEATURE_NO_TITLE);
add this in your android manifest file
<activity
android:name="com.example.abc.SplashScreen"
android:label="#string/app_name"
android:theme="#style/Theme.Sherlock.NoActionBar" ></activity>
use following code to disappear Action Bar:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
getActionBar().hide();
setContentView(R.layout.splash);
more info
I have created an activity and two layouts for the activity, one each for landscape and portrait mode. Both the layouts have same Views and IDs. In the manifest file, I have added
android:configChanges="orientation" in the activity.
Now, according to the documentation, the activity is not restarted if I mention configChanges and include the onConfigurationChanged method.
onCreate(Bundle savedInstanceState) {
Log.i("Message","inside oncreate()") ;
}
onConfigurationChanged(Configuration newConfig) {
Log.i("Message","inside onconfigurationchanged()") ;
}
My log is showing both messages when i change the orientation. Is there any way to stop the onCreate() method from being called when the orientation changes?
maybe you could add more configurations changes that you wish to ignore, since starting of a certain API on android, the orientation consist of other flags , as the documentation says about "orientation" :
The screen orientation has changed — the user has rotated the device.
Note: If your application targets API level 13 or higher (as declared
by the minSdkVersion and targetSdkVersion attributes), then you should
also declare the "screenSize" configuration, because it also changes
when a device switches between portrait and landscape orientations.
so, please try to use , and tell us if it helped :
android:configChanges=orientation|screenSize"
here's the documentation about "screenSize":
The current available screen size has changed. This represents a
change in the currently available size, relative to the current aspect
ratio, so will change when the user switches between landscape and
portrait. However, if your application targets API level 12 or lower,
then your activity always handles this configuration change itself
(this configuration change does not restart your activity, even when
running on an Android 3.2 or higher device). Added in API level 13.
EDIT: here's my simple code to show that it works:
public class MainActivity extends Activity {
#Override
protected void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i("Message","inside oncreate()");
}
#Override
public void onConfigurationChanged(final Configuration newConfig) {
super.onConfigurationChanged(newConfig);
Log.i("Message","inside onconfigurationchanged()");
}
}
manifest:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.test" android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" android:targetSdkVersion="17" />
<application android:allowBackup="true" android:icon="#drawable/ic_launcher"
android:label="#string/app_name" android:theme="#style/AppTheme">
<activity android:name="com.example.test.MainActivity"
android:label="#string/app_name" android:configChanges="orientation|screenSize">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Official documentation said that "orientation" in manifest is able to prevent restarts when the screen orientation changes and "keyboardHidden" to prevent restarts when the keyboard availability changes.
All you need to do is declare the following codes in your manifest:
<activity android:name=".MyActivity"
android:configChanges="orientation|keyboardHidden"
android:label="#string/app_name">
It works for my project.
If it doesn't work, try to change "keyboardHidden" to "screenSize".
I developed on application using android sdk 4.0 and I install that .apk file in my samsung tab. When I run that application it is working properly. If I change the tab portrait to landscape or in reverse the screen also changed.
But my requirement is irrespective of changing the mode either portrait to landscape to Landscape to portrait, my application should run in portrait mode only.
add android:screenOrientation="portrait" for each activity in your manifest.xml file.
You can do this programmatically too, for all your activities making an AbstractActivity that all your activities extends.:-
public abstract class AbstractActivity extends Activity {
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
}
You can define mode in AndroidManifest.xml as follows,
android:screenOrientation="portrait" after the android:name=".activityName"
for example like this,
<activity android:name=".MainActivity" android:label="#string/app_name" android:screenOrientation="portrait">
and from activity class you can use following code,
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
You can use this for landscape
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
To change to portrait mode, use the
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
In your manifest file,
<activity android:name=".MainActivity" android:label="#string/app_name" android:screenOrientation="portrait">
Then add this to your java class:
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
If you search first, you'll find this question answered already. I'll post the answer again here though.
Go to your manifest file, and under the activity that you want to keep portrait only, insert the following line
android:screenOrientation="portrait"
An example is given below.
<activity android:name=".YourActivity"
android:label="Your Activoity"
android:screenOrientation="portrait">
this will make your activity forced to be in portrait mode only, even if you hold the device in landscape mode.
How can I disable landscape mode for some of the views in my Android app?
Add android:screenOrientation="portrait" to the activity in the AndroidManifest.xml. For example:
<activity android:name=".SomeActivity"
android:label="#string/app_name"
android:screenOrientation="portrait" />
Since this has become a super-popular answer, I feel very guilty as forcing portrait is rarely the right solution to the problems it's frequently applied to.
The major caveats with forced portrait:
This does not absolve you of having to think about activity
lifecycle events or properly saving/restoring state. There are plenty of
things besides app rotation that can trigger an activity
destruction/recreation, including unavoidable things like multitasking. There are no shortcuts; learn to use bundles and retainInstance fragments.
Keep in mind that unlike the fairly uniform iPhone experience, there are some devices where portrait is not the clearly popular orientation. When users are on devices with hardware keyboards or game pads a la the Nvidia Shield, on Chromebooks, on foldables, or on Samsung DeX, forcing portrait can make your app experience either limiting or a giant usability hassle. If your app doesn't have a strong UX argument that would lead to a negative experience for supporting other orientations, you should probably not force landscape. I'm talking about things like "this is a cash register app for one specific model of tablet always used in a fixed hardware dock."
So most apps should just let the phone sensors, software, and physical configuration make their own decision about how the user wants to interact with your app. A few cases you may still want to think about, though, if you're not happy with the default behavior of sensor orientation in your use case:
If your main concern is accidental orientation changes mid-activity that you think the device's sensors and software won't cope with well (for example, in a tilt-based game) consider supporting landscape and portrait, but using nosensor for the orientation. This forces landscape on most tablets and portrait on most phones, but I still wouldn't recommend this for most "normal" apps (some users just like to type in the landscape softkeyboard on their phones, and many tablet users read in portrait - and you should let them).
If you still need to force portrait for some reason, sensorPortrait may be better than portrait for Android 2.3 (Gingerbread) and later; this allows for upside-down portrait, which is quite common in tablet usage.
I was not aware of the AndroidManifest.xml file switch until reading this post, so in my apps I have used this instead:
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); // Fixed portrait orientation
Add android:screenOrientation="portrait" in your manifest file where you declare your activity. Like this:
<activity
android:name=".yourActivity"
....
android:screenOrientation="portrait" />
If you want to do it using Java code, try:
setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
before you call setContentView method for your activity in onCreate().
A lot of the answers here are suggesting to use "portrait" in your AndroidManifest.xml file. This might seem like a good solution - but as noted in the documentation, you are singling out devices that may only have landscape. You are also forcing certain devices (that work best in landscape) to go into portrait, not getting the proper orientation.
My suggestion is to use "nosensor" instead. This will leave the device to use its default preferred orientation, will not block any purchases/downloads on Google Play, and will ensure the sensor doesn't mess up your (NDK, in my case) game.
If you want to disable Landscape mode for your Android app (or a single activity) all you need to do is add:
android:screenOrientation="portrait" to the activity tag in AndroidManifest.xml file.
Like:
<activity
android:name="YourActivityName"
android:icon="#drawable/ic_launcher"
android:label="Your App Name"
android:screenOrientation="portrait">
Another way: A programmatic approach.
If you want to do this programmatically, i.e., using Java code. You can do so by adding the below code in the Java class of the activity that you don't want to be displayed in landscape mode.
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
Just add this line in your Manifest:
android:screenOrientation="portrait"
Like:
<manifest
package="com.example.speedtest"
android:versionCode="1"
android:versionName="1.0" >
<application
android:allowBackup="true"
android:icon="#drawable/ic_launcher"
android:label="#string/app_name"
android:theme="#style/AppTheme" >
<activity
android:name="ComparisionActivity"
android:label="#string/app_name"
android:screenOrientation="portrait" >
</activity>
</application>
</manifest>
If you want user-settings, then I'd recommend setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
You can change the settings from a settings menu.
I require this because my timers must correspond to what's on the screen, and rotating the screen will destroy the current activity.
You can do this for your entire application without having to make all your activities extend a common base class.
The trick is first to make sure you include an Application subclass in your project. In its onCreate(), called when your app first starts up, you register an ActivityLifecycleCallbacks object (API level 14+) to receive notifications of activity lifecycle events.
This gives you the opportunity to execute your own code whenever any activity in your app is started (or stopped, or resumed, or whatever). At this point you can call setRequestedOrientation() on the newly created activity.
And do not forget to add app:name=".MyApp" in your manifest file.
class MyApp extends Application {
#Override
public void onCreate() {
super.onCreate();
// register to be informed of activities starting up
registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
#Override
public void onActivityCreated(Activity activity,
Bundle savedInstanceState) {
// new activity created; force its orientation to portrait
activity.setRequestedOrientation(
ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
....
});
}
}
Use this in onCreate() of the Activity
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
You should change android:screenOrientation="sensorPortrait" in AndroidManifest.xml
Just add this attribute in your activity tag.
android:screenOrientation="portrait"
If you don't want to go through the hassle of adding orientation in each manifest entry of activity better, create a BaseActivity class (inherits 'Activity' or 'AppCompatActivity') which will be inherited by every activity of your application instead of 'Activity' or 'AppCompatActivity' and just add the following piece of code in your BaseActivity:
#Override
protected void onCreate(#Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
// rest of your code......
}
Add android:screenOrientation="portrait" to the activity you want to disable landscape mode in.
How to change orientation in some of the view
Instead of locking orientation of the entire activity, you can use this class to dynamically lock orientation from any of your view pragmatically:
Make your view Landscape
OrientationUtils.lockOrientationLandscape(mActivity);
Make your view Portrait
OrientationUtils.lockOrientationPortrait(mActivity);
Unlock Orientation
OrientationUtils.unlockOrientation(mActivity);
Orientation Util Class
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.os.Build;
import android.view.Surface;
import android.view.WindowManager;
/* * This class is used to lock orientation of android app in nay android devices
*/
public class OrientationUtils {
private OrientationUtils() {
}
/** Locks the device window in landscape mode. */
public static void lockOrientationLandscape(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
}
/** Locks the device window in portrait mode. */
public static void lockOrientationPortrait(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
/** Locks the device window in actual screen mode. */
public static void lockOrientation(Activity activity) {
final int orientation = activity.getResources().getConfiguration().orientation;
final int rotation = ((WindowManager) activity.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay()
.getRotation();
// Copied from Android docs, since we don't have these values in Froyo
// 2.2
int SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 8;
int SCREEN_ORIENTATION_REVERSE_PORTRAIT = 9;
// Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO
if (!(Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO)) {
SCREEN_ORIENTATION_REVERSE_LANDSCAPE = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
SCREEN_ORIENTATION_REVERSE_PORTRAIT = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}
if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90) {
if (orientation == Configuration.ORIENTATION_PORTRAIT) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
} else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
} else if (rotation == Surface.ROTATION_180 || rotation == Surface.ROTATION_270) {
if (orientation == Configuration.ORIENTATION_PORTRAIT) {
activity.setRequestedOrientation(SCREEN_ORIENTATION_REVERSE_PORTRAIT);
} else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
activity.setRequestedOrientation(SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
}
}
}
/** Unlocks the device window in user defined screen mode. */
public static void unlockOrientation(Activity activity) {
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER);
}
}
Use:
android:configChanges="keyboardHidden|orientation"
android:screenOrientation="portrait"
You must set the orientation of each activity.
<activity
android:name="com.example.SplashScreen2"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#android:style/Theme.Black.NoTitleBar" >
</activity>
<activity
android:name="com.example.Registration"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#android:style/Theme.Black.NoTitleBar" >
</activity>
<activity
android:name="com.example.Verification"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#android:style/Theme.Black.NoTitleBar" >
</activity>
<activity
android:name="com.example.WelcomeAlmostDone"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#android:style/Theme.Black.NoTitleBar" >
</activity>
<activity
android:name="com.example.PasswordRegistration"
android:label="#string/app_name"
android:screenOrientation="portrait"
android:theme="#android:style/Theme.Black.NoTitleBar" >
</activity>
If you are using Xamarin C#, some of these solutions will not work. Here is the solution I found to work.
[Activity(MainLauncher = true, Icon = "#drawable/icon", ScreenOrientation = ScreenOrientation.Portrait)]
Above the class works well, similar to the other solutions. Also, it is not globally applicable and needs to be placed in each activity header.
Put it into your manifest.
<activity
android:name=".MainActivity"
android:label="#string/app_name"
android:screenOrientation="sensorPortrait" />
The orientation will be portrait, but if the user's phone is upside down, it shows the correct way as well. (So your screen will rotate 180 degrees.)
The system ignores this attribute if the activity is running in multi-window mode.
More: https://developer.android.com/guide/topics/manifest/activity-element
Add a class inside the oncreate() method:
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
You can force your particular activity to always remain in portrait mode by writing this in your manifest.xml file:
<activity
android:name=".MainActivity"
android:screenOrientation="portrait"></activity>
You can also force your activity to remain in portrait mode by writing following line in your activity's onCreate() method:
#Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.your_layout);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
Either in the manifest class:
<activity android:name=".yourActivity"
....
android:screenOrientation="portrait" />
Or programmatically:
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
Note: you should call this before setContentView method for your activity in onCreate().
<android . . . >
. . .
<manifest . . . >
. . .
<application>
<activity
android:name=".MyActivity"
android:screenOrientation="portrait"
android:configChanges="keyboardHidden|orientation">
</activity>
</application>
</manifest>
</android>
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="in.co.nurture.bajajfinserv">
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
<application
android:allowBackup="true"
android:icon="#mipmap/ic_launcher"
android:label="#string/app_name"
android:roundIcon="#mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="#style/AppTheme">
<activity android:name=".MainActivity" android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
We can restrict the Activity in portrait or landscape mode by using the attribute or android:screenOrientation.
If we have more than one activity in our program then we have the freedom to restrict any one of activity in any one the mode and it never affects the others which you don't want.
Add the below command to your project,
npm install
npm i react-native-orientation-locker
Then you use a manifest class like,
React_Native (Your Project Folder)/
android/app/src/main/AndroidManifest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.payroll_react">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
<application
android:name=".MainApplication"
android:label="#string/app_name"
android:icon="#mipmap/ic_launcher"
android:allowBackup="false"
android:theme="#style/AppTheme">
<activity
android:name=".MainActivity"
android:label="#string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
</application>
</manifest>
In the <apphome>/platform/android directory, create AndroidManifest.xml (copying it from the generated one).
Then add android:screenOrientation="portrait" to all of the activity elements.
Add android:screenOrientation="portrait" in the AndroidManifest.xml file.
For example:
<activity
android:name=".MapScreen"
android:screenOrientation="portrait"></activity>
It worked for me. Try to add this code in the AndroidManifest file:
<application
android:allowBackup="true"
android:icon="#mipmap/ic_launcher"
android:label="#string/app_name"
android:roundIcon="#mipmap/ic_launcher_round"
android:supportsRtl="true"
android:screenOrientation="portrait"
android:theme="#style/AppTheme">
....
....
</application>
The following attribute on the activity in AndroidManifest.xml is all you need:
android:configChanges="orientation"
So, full activity node:
<activity
android:name="Activity1"
android:icon="#drawable/icon"
android:label="App Name"
android:configChanges="orientation">
In Kotlin, the same can be programmatically achieved using the below:
requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
If your activity is related to the first device orientation state, get the current device orientation in the onCreate method and then fix it forever:
int deviceRotation = ((WindowManager) getBaseContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
if(deviceRotation == Surface.ROTATION_0) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
else if(deviceRotation == Surface.ROTATION_180)
{
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
}
else if(deviceRotation == Surface.ROTATION_90)
{
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
else if(deviceRotation == Surface.ROTATION_270)
{
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
}