获取手机方向但将屏幕方向固定为纵向

Question

我想获取手机的方向，但保持屏幕方向为竖屏。因此，无论用户将手机旋转到横屏或竖屏，视图都保持不变，但我可以获得它是否更改为横屏或竖屏。 将活动设置为 android:screenOrientation="portrait" 可以解决这两个问题，但是我将无法通过它检测手机方向。

public void onConfigurationChanged(Configuration newConfig) {
    switch (newConfig.orientation) {
    case Configuration.ORIENTATION_PORTRAIT:
        Toast.makeText(this, "Portrait", Toast.LENGTH_SHORT).show();
        break;
    case Configuration.ORIENTATION_LANDSCAPE:
        Toast.makeText(this, "Landscape", Toast.LENGTH_SHORT).show();
        break;
    default:
        break;
    }
}

有人有解决方法吗？

- Arman

---

看一下这个：https://dev59.com/2H7aa4cB1Zd3GeqPvNAK#41104983 这个解决方案使用SensorManager。 - Maher Abuthraa

Answer 1

这里是一个多用途的类，可轻松管理屏幕方向的更改：

public class OrientationManager extends OrientationEventListener {

    public enum ScreenOrientation {
        REVERSED_LANDSCAPE, LANDSCAPE, PORTRAIT, REVERSED_PORTRAIT
    }

    public ScreenOrientation screenOrientation; 
    private OrientationListener listener;

    public OrientationManager(Context context, int rate, OrientationListener listener) {
        super(context, rate);
        setListener(listener);
    }

    public OrientationManager(Context context, int rate) {
        super(context, rate);
    }

    public OrientationManager(Context context) {
        super(context);
    }

    @Override
    public void onOrientationChanged(int orientation) {
        if (orientation == -1){
            return;
        }
        ScreenOrientation newOrientation;
        if (orientation >= 60 && orientation <= 140){
            newOrientation = ScreenOrientation.REVERSED_LANDSCAPE;
        } else if (orientation >= 140 && orientation <= 220) {
            newOrientation = ScreenOrientation.REVERSED_PORTRAIT;
        } else if (orientation >= 220 && orientation <= 300) {
            newOrientation = ScreenOrientation.LANDSCAPE;
        } else {
            newOrientation = ScreenOrientation.PORTRAIT;                    
        }
        if(newOrientation != screenOrientation){
            screenOrientation = newOrientation;
            if(listener != null){
                listener.onOrientationChange(screenOrientation);
            }           
        }
    }

    public void setListener(OrientationListener listener){
        this.listener = listener;
    }

    public ScreenOrientation getScreenOrientation(){
        return screenOrientation;
    }

    public interface OrientationListener {

        public void onOrientationChange(ScreenOrientation screenOrientation);
    }
}

这种方式更加简单易用，可以重复使用，并且您还可以获得REVERSE_LANDSCAPE和REVERSE_PORTRAIT方向。

您必须实现OrientationListener才能在屏幕方向发生变化时得到通知。

不要忘记调用orientationManager.enable()来启用方向跟踪，然后再调用orientationManager.disable()（这两个方法都从OrientationEventListener类继承而来）。

更新：用例示例

MyFragment extends Fragment implements OrientationListener {

    ...

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        orientationManager = new OrientationManager(getActivity(), SensorManager.SENSOR_DELAY_NORMAL, this);
        orientationManager.enable();        
    }

    @Override
    public void onOrientationChange(ScreenOrientation screenOrientation) {
        switch(screenOrientation){
            case PORTRAIT:
            case REVERSED_PORTRAIT:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            break;
            case REVERSED_LANDSCAPE:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
            break;
            case LANDSCAPE:
                MainActivityBase.getInstance().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            break;
        }
    }
}

- edrian

---

太好了，非常感谢。难以相信这个答案只有一个赞。 - formatc

这是一个很好的解决方案，但请注意，这只适用于默认为竖屏模式的智能手机，对于默认为横屏模式的平板电脑，在横屏方向上orientation值将为0，因此在应用逻辑之前需要将270添加到orientation值。要查看设备的默认方向，请参阅https://dev59.com/gm455IYBdhLWcg3wFP9u。 - Jörg Eisfeld

三年后我发现了这个，这是一个非常优雅的解决方案...如果我能够给你超过1个赞哈哈。 - yun

Answer 2

您是否能够通过加速度计来满足您的要求？如果是这样，也许下面这个（未经测试的）片段适合您的目的。

SensorManager sensorManager = (SensorManager) this.getSystemService(Context.SENSOR_SERVICE);
        sensorManager.registerListener(new SensorEventListener() {
            int orientation=-1;;

            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.values[1]<6.5 && event.values[1]>-6.5) {
                    if (orientation!=1) {
                        Log.d("Sensor", "Landscape");
                    }
                    orientation=1;
                } else {
                    if (orientation!=0) {
                        Log.d("Sensor", "Portrait");
                    }
                    orientation=0;
                }
            }

            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // TODO Auto-generated method stub

            }
        }, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_GAME);

- Phillip Fitzsimmons

---

嗨，菲利普。 这就是我自己实现的相同解决方案。在这种情况下，似乎没有其他选择，只能访问传感器以获取设备的方向。 - Arman

如果设备平放在桌子上，就没有太多的价值。 - Johann

有人知道如何检测reverse_landscape吗？ - edrian

这会消耗太多电池吗？ - Neon Warge

Answer 3

我需要一个只在需要时提供方向的解决方案。这个对我有用：

public class SensorOrientationChecker {

public final String TAG = getClass().getSimpleName();

int mOrientation = 0;
private SensorEventListener mSensorEventListener;
private SensorManager mSensorManager;

private static SensorOrientationChecker mInstance;

public static SensorOrientationChecker getInstance() {
    if (mInstance == null)
        mInstance = new SensorOrientationChecker();

    return mInstance;
}

private SensorOrientationChecker() {
    mSensorEventListener = new Listener();
    Context applicationContext = GlobalData.getInstance().getContext();
    mSensorManager = (SensorManager) applicationContext.getSystemService(Context.SENSOR_SERVICE);

}

/**
 * Call on activity onResume()
 */
public void onResume() {
    mSensorManager.registerListener(mSensorEventListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
}

/**
 * Call on activity onPause()
 */
public void onPause() {
    mSensorManager.unregisterListener(mSensorEventListener);
}

private class Listener implements SensorEventListener {

    @Override
    public void onSensorChanged(SensorEvent event) {
        float x = event.values[0];
        float y = event.values[1];

        if (x<5 && x>-5 && y > 5)
            mOrientation = 0;
        else if (x<-5 && y<5 && y>-5)
            mOrientation = 90;
        else if (x<5 && x>-5 && y<-5)
            mOrientation = 180;
        else if (x>5 && y<5 && y>-5)
            mOrientation = 270;

        //Log.e(TAG,"mOrientation="+mOrientation+"   ["+event.values[0]+","+event.values[1]+","+event.values[2]+"]");
                                                                       }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

}

public int getOrientation(){
    return mOrientation;
    }
}

- Asaf Pinhassi

Answer 4

如果禁用屏幕方向更改，那么显然 onConfigurationChanged 将永远不会被调用...

我认为唯一的方法是使用加速度传感器，可以查看 这个链接。

- vitakot

Answer 5

要进入那个活动，您需要在清单文件中设置该活动

android:configChanges="orientation|keyboardHidden"

当用户旋转手机时，它将进入public void onConfigurationChanged()方法。同时请删除

标签。

android:screenOrientation="portrait" 

来自同一活动。

- Sumant

---

但是如果调用onConfigurationChanged()，则方向更改已经完成... 我需要更早的信息。 - Arman

Answer 6

这比编写一个全新的类要简单得多：

 final OrientationEventListener orientationEventListener = new OrientationEventListener( getApplicationContext() ) {

  @Override
  public void onOrientationChanged( final int orientation ) {
    Log.i("", "orientation = " + orientation );
  }
};

orientationEventListener.enable();

- Al Ro

Answer 7

如果有人正在寻找一个Webview/javascript解决方案来回答这个问题，下面的内容可以做到。

这将在窗口上触发自定义的“flip”事件，并带有像jquery一样的“额外参数”。它还设置了window.flip，类似于window.orientation：

$(window).on('flip',function(ev,angle,orientation) {
    console.log(angle,orientation);
    alert(window.flip);
});

---

if (window.DeviceOrientationEvent) {
    jQuery.flip = {
        debug       : false,
        interval    : 1000,
        checked     : false,
        betaflat    : 25,
        gammaflat   : 45,
        orientation : 'portrait-primary',
        angles      : {
            'portrait-primary'      : 0,
            'portrait-secondary'    : 0,
            'landscape-primary'     : 90,
            'landscape-secondary'   : -90       
        },
        timer       : null,
        check       : function(ev) {
            if (!this.checked) {
                var trigger=false;
                if (this.debug) console.log([ev.alpha,ev.beta,ev.gamma]);
                if (ev.beta>this.betaflat) {
                    // if beta is big its portrait
                    if (this.debug) console.log('beta portrait pri');
                    if (this.orientation!='portrait-primary') {
                        this.orientation='portrait-primary';
                        trigger=true;
                    }
                } else if (ev.beta<-this.betaflat) {
                    // if beta is big its portrait
                    if (this.debug) console.log('beta portrait sec');
                    if (this.orientation!='portrait-secondary') {
                        this.orientation='portrait-secondary';
                        trigger=true;
                    }
                } else if (ev.gamma>this.gammaflat) {

                    // else if gamma is big its landscape
                    if (this.debug) console.log('gamma landscape pri');
                    if (this.orientation!='landscape-primary') {
                        this.orientation='landscape-primary';
                        trigger=true;
                    }

                } else if (ev.gamma<-this.gammaflat) {

                    // else if gamma is big its landscape
                    if (this.debug) console.log('gamma landscape sec');
                    if (this.orientation!='landscape-secondary') {
                        this.orientation='landscape-secondary';
                        trigger=true;
                    }

                }
                if (trigger) {
                    if (this.debug) console.log('trigger flip');
                    window.flip = this.angles[this.orientation];
                    $(window).trigger('flip',[window.flip,this.orientation]);
                    this.checked=true;
                }
            }
        }
    }
    $(document).ready(function() {
        setInterval(function() {jQuery.flip.checked=false},jQuery.flip.interval);
        $(window).on('deviceorientation',function(ev) { jQuery.flip.check(ev.originalEvent) });
    });
} else {
    if (this.debug) console.log('DeviceOrientationEvent not supported');
}

jQuery并不是必需的。但我还是将其引入了。

- commonpike

---

解决 Android 中的 Javascript 问题并不是很有帮助。它需要 WebView 或类似的工具来运行脚本，而这可能并不适用于所有情况。 - Arman

哦 - 很好的观点。我生活在自己的世界里。正在更新答案。 - commonpike

那么为什么现在要投反对票？我提到了这是Webview / JavaScript，而楼主没有提到他/她生活在哪个世界。 - commonpike