以编程方式锁定android中的方向

Question

I have the following code.

Java

public void lockScreenOrientation() {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
}

public void unlockScreenOrientation() {
     setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
}

I am calling these functions from javascript. Control is entering these methods. However the orientation is not locked.

I have tried following to lock the orientation

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);

None of these seem to work. Any pointers would be helpful.

Answer 1

I've created a few utility methods to help deal with orientation locking, feel free to use this class.

Example use:

• In an Activity: OrientationUtils.lockOrientationPortrait(MyActivityName.this)
• In a Fragment: OrientationUtils.lockOrientationLandscape(getActivity())

Code:

/** Static methods related to device orientation. */
public class OrientationUtils {
    private OrientationUtils() {}

    /** Locks the device window in landscape mode. */
    public static void lockOrientationLandscape(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
    }

    /** Locks the device window in portrait mode. */
    public static void lockOrientationPortrait(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }

    /** Allows user to freely use portrait or landscape mode. */
    public static void unlockOrientation(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }

}

Here's my full OrientationUtils class on GitHub that can be used in any Android app: https://github.com/danialgoodwin/android-simply-advanced-helper/blob/master/SimplyAdvancedHelperLibrary/src/net/simplyadvanced/utils/OrientationUtils.java

Answer 2

Activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);

Locks the screen (activity) in whatever the orientation it was.

Requires API Level >= 18

Answer 3

This is a class I wrote to handle locking and unlocking the screen orientation. I call toggleScreenOrientationLock(this, prefs, isChecked) from a toggle button's checkedChangedListener, and restoreScreenLock(this, prefs) from onCreate(). In both cases this is your activity and prefs is a SharedPrefences object, used for saving information about the state of the lock.

The complicated part pf the code is the getScreenOrientation() function, which I stole from and cleaned up from here . I'll try to explain logic behind how this works.

When we set the device's orientation with setRequestedOrienation() , we need to know if the device is in landscape or portrait mode, and we need to know if it's a reverse orientation (rotated 180 degrees).

Using getResources().getConfiguration().orientation will answer the question of which orientation we're in. If we could factor in the rotation of the device, we could tell whether it was rotated 180 or not. Unfortunately, depending on the device, ROTATE_0 might be portrait or landscape. Phones typically map ROTATE_0 to portrait, and tablets to landscape.

So the solution used here is to use the screen dimensions to determine if it is in landscape or portrait instead. If the screen is wider than it is tall, then we infer that the device is in a landscape orientation, and vice versa for portrait. Then we can factor in the rotation to figure out whether the orientation is reversed or not.

For example, if the screen is wider than it is tall, then we know we're in a landscape orientation. If the rotation is either 0 or 180 (in the code's logic, this is equal to !isRotatedOrthogonally), then we know that 0 is LANDSCAPE and 180 is REVERSE_LANDSCAPE.

It has been noted elsewhere that this won't work across all devices, since whether 90 or 270 is the reversed orientation is device specific. But this is still probably the best you're going to do; at worst, one orientation will rotate 180 degrees when you lock it, which is what would likely happen if tried locking the screen any other way.

public class ScreenLocker {
    final private static String ROTATION_LOCKED_KEY = "LockedOrientationVal";
    final private static String ROTATION_IS_LOCKED_KEY = "IsRotationLocked";
    final private static String ROTATION_SAVED_KEY = "SavedOrientationVal";

    public static int getScreenOrientation(Activity activity) {
        final Display display = activity.getWindowManager().getDefaultDisplay();
        final int rotation = display.getRotation();

        Point size = new Point();
        display.getSize(size);

        final boolean isWiderThanTall = size.x > size.y;

        final boolean isRotatedOrthogonally = (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270);
        int orientation;

        if (isRotatedOrthogonally) {
            if (isWiderThanTall)
                orientation = (rotation ==  Surface.ROTATION_90) ? ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            else
                orientation = (rotation == Surface.ROTATION_90) ? ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; // normal and reversed switched intended
        }
        else {
            if (isWiderThanTall)
                orientation = (rotation ==  Surface.ROTATION_0) ? ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            else
                orientation = (rotation == Surface.ROTATION_0) ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
        }

        return orientation;
    }

    public static void toggleScreenOrientationLock(Activity activity,SharedPreferences prefs, boolean lock) {
        if(lock)
            lockScreenOrientation(activity, prefs);
        else
            unlockScreenOrientation(activity, prefs);
    }


    // call this from your activity's onCreate() or onResume()
    public static boolean restoreScreenLock(Activity activity, SharedPreferences prefs) {
        final boolean isLocked = prefs.getBoolean(ROTATION_IS_LOCKED_KEY, false);
        final int previousLockedOrientation = prefs.getInt(ROTATION_LOCKED_KEY, -999);

        if(isLocked && previousLockedOrientation != -999) {
            prefs.edit().putInt(ROTATION_SAVED_KEY, activity.getRequestedOrientation()).apply();
            activity.setRequestedOrientation(previousLockedOrientation);
            return true;
        }
        return false;
    }

    private static void lockScreenOrientation(Activity activity, SharedPreferences prefs) {
        final int currentOrientation = activity.getRequestedOrientation();
        final int lockOrientation = getScreenOrientation(activity);

        // checking isCurrentlyLocked prevents the ROTATION_LOCKED_KEY and ROTATION_SAVED_KEY
        // becoming identical, which results in the screen not being able to be unlocked.
        final boolean isCurrentlyLocked = prefs.getBoolean(ROTATION_IS_LOCKED_KEY, false);

        if(!isCurrentlyLocked) {
            activity.setRequestedOrientation(lockOrientation);
            prefs.edit()
                    .putInt(ROTATION_SAVED_KEY, currentOrientation)
                    .putInt(ROTATION_LOCKED_KEY, lockOrientation)
                    .putBoolean(ROTATION_IS_LOCKED_KEY, true)
                    .apply();
        }
    }

    private static void unlockScreenOrientation(Activity activity, SharedPreferences prefs) {
        final int savedOrientation = prefs.getInt(ROTATION_SAVED_KEY, activity.getRequestedOrientation());
        activity.setRequestedOrientation(savedOrientation);
        prefs.edit().putBoolean(ROTATION_IS_LOCKED_KEY, false).apply();
    }
}

Answer 4

Here's another simple solution that works well for me.

private void orientationManager(boolean lock)
{
    int currentOrientation = getResources().getConfiguration().orientation;
    if(lock)
    {
        if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE)
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
        }
        else
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
        }
    }
    else
    {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }
}

I needed to lock orientationManager(true); the current screen orientation when dialogs were opened and unlock orientationManager(false); when the dialog was closed.