How do I get the CURRENT orientation (ActivityInfo.SCREEN_ORIENTATION_*) of an Android device?

AndroidScreen Orientation

Android Problem Overview

I would like to find out the detailed orientation of a device, preferably one of SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT, SCREEN_ORIENTATION_REVERSE_LANDSCAPE, SCREEN_ORIENTATION_REVERSE_PORTRAIT from ActivityInfo or equivalent.

Some of the answers here on StackOverflow included

getWindowManager().getDefaultDisplay().getRotation()

but this doesn't really tell me whether the device is in portrait or landscape mode, only how it's turned with reference to its natural position - which in turn can be landscape or portrait in the first place.

getResources().getConfiguration().orientation

returns one of the following three: ORIENTATION_LANDSCAPE, ORIENTATION_PORTRAIT, ORIENTATION_SQUARE, which then doesn't really tell me which way the phone is turned (whether it's upside down or which of the sides it's turned to).

I know I could use the latter in combination with DisplayMetrics to find out the device's natural orientation, but is there really no better way?

Android Solutions

Solution 1 - Android

I ended up using the following solution:

private int getScreenOrientation() {
	int rotation = getWindowManager().getDefaultDisplay().getRotation();
	DisplayMetrics dm = new DisplayMetrics();
	getWindowManager().getDefaultDisplay().getMetrics(dm);
	int width = dm.widthPixels;
	int height = dm.heightPixels;
	int orientation;
	// if the device's natural orientation is portrait:
	if ((rotation == Surface.ROTATION_0
			|| rotation == Surface.ROTATION_180) && height > width ||
		(rotation == Surface.ROTATION_90
			|| rotation == Surface.ROTATION_270) && width > height) {
		switch(rotation) {
			case Surface.ROTATION_0:
				orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
				break;
			case Surface.ROTATION_90:
				orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
				break;
			case Surface.ROTATION_180:
				orientation =
					ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
				break;
			case Surface.ROTATION_270:
				orientation =
					ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
				break;
			default:
				Log.e(TAG, "Unknown screen orientation. Defaulting to " +
						"portrait.");
				orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
				break;				
		}
	}
	// if the device's natural orientation is landscape or if the device
	// is square:
	else {
		switch(rotation) {
			case Surface.ROTATION_0:
				orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
				break;
			case Surface.ROTATION_90:
				orientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
				break;
			case Surface.ROTATION_180:
				orientation =
					ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
				break;
			case Surface.ROTATION_270:
				orientation =
					ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
				break;
			default:
				Log.e(TAG, "Unknown screen orientation. Defaulting to " +
						"landscape.");
				orientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
				break;				
		}
	}
	
	return orientation;
}

NOTE: Some users (Geltrude and holtaf in the comments below) pointed out that this solution will not work on all devices as the direction of rotation from the natural orientation is not standardized.

Solution 2 - Android

Simple approach would be to use

getResources().getConfiguration().orientation

1 is for Potrait and 2 for Landscape.

Solution 3 - Android

public static int getScreenOrientation(Activity activity) {
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        int orientation = activity.getResources().getConfiguration().orientation;
        if (orientation == Configuration.ORIENTATION_PORTRAIT) {
          if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_270) {
            return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
          } else {
            return ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
          }
        }
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
          if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90) {
            return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
          } else {
            return ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
          }
        }
        return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
      }

Solution 4 - Android

getResources().getConfiguration().orientation is the standard way of knowing current orientation being used. However, if it doesn't fulfill your needs then perhaps you may use Sensors to calculate it in terms of angle. Read this and this

Solution 5 - Android

I think your problem is that you can detect landscape and portrait but not reverse landscape and reverse protrait as they are not supported in older versions. To detect what you can do is that you can use both oreintation and rotation. I am giving you an idea it may be useful for you.

try this i think it may solve your problem.

            int orientation = getResources().getConfiguration().orientation;
            int rotation = getWindowManager().getDefaultDisplay().getRotation();
            int actual_orientation = -1;
            if (orientation == Configuration.ORIENTATION_LANDSCAPE
            &&  (rotation == Surface.ROTATION_0 
            ||  rotation == Surface.ROTATION_90)){
                orientation = Configuration.ORIENTATION_LANDSCAPE;
            } else if (orientation == Configuration.ORIENTATION_PORTRAIT
                  &&  (rotation == Surface.ROTATION_0 
                   ||  rotation == Surface.ROTATION_90)) {
                orientation = Configuration.ORIENTATION_PORTRAIT;
            } else if (orientation == Configuration.ORIENTATION_LANDSCAPE
                  &&  (rotation == Surface.ROTATION_180 
                   ||  rotation == Surface.ROTATION_270)){
                orientation = //any constant for reverse landscape orientation;
            } else {
                if (orientation == Configuration.ORIENTATION_PORTRAIT
                        &&  (rotation == Surface.ROTATION_180 
                         ||  rotation == Surface.ROTATION_270)){
                      orientation = //any constant for reverse portrait orientation;
                }
            }

Solution 6 - Android

I ended up using Zoltán's answer above, which works great, except when I tried it on a tablet (a Samsung P6210 Galaxy Tab 7.0 Plus). In portrait mode, it returned SCREEN_ORIENTATION_REVERSE_PORTRAIT. So in the else statement (if natural orientation is landscape) I swapped the cases for ROTATION_90 and ROTATION_270, and everything seems to work fine. (I don't have enough reputation to post this as a comment to Zoltán's answer.)

Solution 7 - Android

You could do it in a very simple way: get the screen widhtand height. screen width will be always higher when device is in landscape orientation.

Display display = getWindowManager().getDefaultDisplay();
	int width = display.getWidth(); 
	int height = display.getHeight();
	Toast.makeText(getApplicationContext(), "" + width + "," + height,
			Toast.LENGTH_SHORT).show();
	if (width > height) {
		Toast.makeText(getApplicationContext(), "LandScape",
				Toast.LENGTH_SHORT).show();
	}

Solution 8 - Android

Does this solve your problem?

public static int getscrOrientation(Activity act)
{
	Display getOrient = act.getWindowManager()
			.getDefaultDisplay();

	int orientation = getOrient.getOrientation();

	// Sometimes you may get undefined orientation Value is 0
	// simple logic solves the problem compare the screen
	// X,Y Co-ordinates and determine the Orientation in such cases
	if (orientation == Configuration.ORIENTATION_UNDEFINED) {

		Configuration config = act.getResources().getConfiguration();
		orientation = config.orientation;

		if (orientation == Configuration.ORIENTATION_UNDEFINED) {
			// if height and widht of screen are equal then
			// it is square orientation
			if (getOrient.getWidth() == getOrient.getHeight()) {
				orientation = Configuration.ORIENTATION_SQUARE;
			} else { // if widht is less than height than it is portrait
				if (getOrient.getWidth() < getOrient.getHeight()) {
					orientation = Configuration.ORIENTATION_PORTRAIT;
				} else { // if it is not any of the above it will defineitly
							// be landscape
					orientation = Configuration.ORIENTATION_LANDSCAPE;
				}
			}
		}
	}
	return orientation; // return value 1 is portrait and 2 is Landscape
						// Mode
}
Categories
Recommended Android Solutions
Recommended Screen Orientation Solutions

Previous Solution:

I get 'Command Not Found' when I try to run Android Emulator on Mac OS X

AndroidMacosShellEmulation

Next Solution:

In Ruby, what's the relationship between 'new' and 'initialize'? How to return nil while initializing?

RubyConstructorReturnNew OperatorInitializer

Attributions

All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionZolt&#225;nView Question on Stackoverflow
Solution 1 - AndroidZoltánView Answer on Stackoverflow
Solution 2 - AndroidNileshView Answer on Stackoverflow
Solution 3 - AndroidUma sankar pradhanView Answer on Stackoverflow
Solution 4 - AndroidwaqaslamView Answer on Stackoverflow
Solution 5 - AndroidBharat SharmaView Answer on Stackoverflow
Solution 6 - AndroidpfalstadView Answer on Stackoverflow
Solution 7 - AndroidVettiyanakanView Answer on Stackoverflow
Solution 8 - AndroidConsciousView Answer on Stackoverflow