logo标签列表

安卓：检测设备旋转

androidandroid-layoutscreen-orientation
24
我需要在我的应用程序中检测方向变化，但我不希望我的布局从纵向变为横向。目前，我正在使用OrientationEventListener，但仅检测方向角度是不够的。我想要检测用户是从纵向变为横向还是从横向变为纵向，而不仅仅是检测方向角度是否为90或270。

我想要执行与Android更改活动方向相同的检测。我尝试重写onConfigurationChanged并检查方向是否为横向/纵向，但这仍会将我的活动布局更改为横向。

有没有办法使用onConfigurationChanged但强制布局保持为纵向？
是否有另一种方法可以检测方向变化而不使用OrientationEventListener？最终，我可以实现自己的方向更改算法，对此有什么想法吗？它必须比if(90-THRESHOLD <= orientation <= 90+THRESHOLD)复杂，我想检测用户是否进行了完整的移动：纵向->横向或横向->纵向。
感谢您的帮助，
Filipe
2
抱歉，我对你真正需要的东西有些糊涂了。据我所知，在这种情况下，除非你实际允许配置更改（也就是视图必须旋转），否则无法使用onConfigurationChanged()。在事件被分派到窗口系统之前，没有办法拦截它。 - devunwired
5个回答
37

好的，在尝试使用Android API但无法达到我需要的效果后，我实现了自己的算法，实际上并不那么复杂：我使用了OrientationEventListener，并计算了方向是否在4个方向点（在我的代码中，我只检测LANDSCAPE_RIGHT和PORTRAIT_UP）：

orientationListener = new OrientationEventListener(context, SensorManager.SENSOR_DELAY_UI) {
        public void onOrientationChanged(int orientation) {
            if(canShow(orientation)){
                show();
            } else if(canDismiss(orientation)){
                dismiss();
            }
        }
    };

@Override
public void onResume(){
    super.onResume();
    orientationListener.enable();
}

@Override
public void onPause(){
    super.onPause();
    orientationListener.disable();
}

private boolean isLandscape(int orientation){
        return orientation >= (90 - THRESHOLD) && orientation <= (90 + THRESHOLD);
    }

private boolean isPortrait(int orientation){
    return (orientation >= (360 - THRESHOLD) && orientation <= 360) || (orientation >= 0 && orientation <= THRESHOLD);
}

public boolean canShow(int orientation){
    return !visible && isLandscape(orientation);
}

public boolean canDismiss(int orientation){
    return visible && !dismissing && isPortrait(orientation);
}
好的，现在我又有一个问题。我想在我的活动视图顶部显示的视图必须是横向模式。如何强制一个视图保持横向而不强制应用程序也这样做？ - ffleandro
我遇到了一个问题，看起来和你的问题很接近。show()和dismiss()方法是什么？当我尝试你的例子时，我得到了一个运行时异常：ERROR/AndroidRuntime(7868): FATAL EXCEPTION: main android.app.SuperNotCalledException: Activity Orientation did not call through to super.onConfigurationChanged()。 - leshka
但如果我在方法开头调用super，所有方向（包括我不想支持的方向）都会显示。 - leshka
在这种情况下，“THRESHOLD”值是什么，为什么我们需要它？我也陷入了困境，并尝试使用此代码来获取当前方向。 - User7723337
例如，如果您快速旋转设备，则可能直接从85º度旋转到92º度，而不会在90º度处精确分派事件。阈值是您用于检测是否接近特定角度以便进行四舍五入的值。尝试不同的值，我认为我使用了15或30。 - ffleandro
11

你好，screamingnoises，这是你在寻找的内容吗？

// Set background image, rotatable
    View view = getWindow().getDecorView(); 
    int orientation = getResources().getConfiguration().orientation; 
    if (Configuration.ORIENTATION_LANDSCAPE == orientation) { 
        //Do SomeThing; // Landscape
    } else { 
        //Do SomeThing;  // Portrait
    }
是的，这个方法可行。谢谢。我宁愿使用onConfigurationChanged方法，因为使用你的解决方案仍需要OrientationEventListener来检查方向。我会等待Devunwired的回复，看他是否有解决方案。否则我会将你的解决方案标记为已接受 ;) - ffleandro
我的答案行不通，所以我撤回了它。尽管如此，我担心这个问题也会遇到同样的问题。如果您不允许配置从纵向到横向实际更改，资源将永远报告设备方向无论是什么都是纵向。 - devunwired
实际上这并没有起作用。如果我在清单文件中使用属性screenOrientation="portrait"将活动锁定为纵向模式，这并不起作用。这只是告诉屏幕方向是什么，并不能检测屏幕方向的变化。 - ffleandro
不错的点子伙计，谢谢！这正是我需要的！ - narancs
8
我创建了以下类来检测方向变化，保持我的Activity的原始方向：
public class SensorOrientationChangeNotifier {

    public final String TAG = getClass().getSimpleName();
    private ArrayList<WeakReference<SensorOrientationChangeNotifier.Listener>> mListeners = new ArrayList<WeakReference<SensorOrientationChangeNotifier.Listener>>(3);

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

    private static SensorOrientationChangeNotifier mInstance;

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

        return mInstance;
    }

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

    }

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

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

    private class NotifierSensorEventListener implements SensorEventListener {

        @Override
        public void onSensorChanged(SensorEvent event) {
            float x = event.values[0];
            float y = event.values[1];
            int newOrientation = mOrientation;
            if (x < 5 && x > -5 && y > 5)
                newOrientation = 0;
            else if (x < -5 && y < 5 && y > -5)
                newOrientation = 90;
            else if (x < 5 && x > -5 && y < -5)
                newOrientation = 180;
            else if (x > 5 && y < 5 && y > -5)
                newOrientation = 270;

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

        }

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

        }

    }

    public int getOrientation() {
        return mOrientation;
    }

    public interface Listener {
        void onOrientationChange(int orientation);
    }

    public void addListener(SensorOrientationChangeNotifier.Listener listener) {
        if (get(listener) == null) // prevent duplications
            mListeners.add(new WeakReference<SensorOrientationChangeNotifier.Listener>(listener));

        if (mListeners.size() == 1) {
            onResume(); // this is the first client
        }
    }

    public void remove(SensorOrientationChangeNotifier.Listener listener) {
        WeakReference<SensorOrientationChangeNotifier.Listener> listenerWR = get(listener);
        remove(listenerWR);
    }

    private void remove(WeakReference<SensorOrientationChangeNotifier.Listener> listenerWR) {
        if (listenerWR != null)
            mListeners.remove(listenerWR);

        if (mListeners.size() == 0) {
            onPause();
        }

    }

    private WeakReference<SensorOrientationChangeNotifier.Listener> get(SensorOrientationChangeNotifier.Listener listener) {
        for (WeakReference<SensorOrientationChangeNotifier.Listener> existingListener : mListeners)
            if (existingListener.get() == listener)
                return existingListener;
        return null;
    }

    private void notifyListeners() {
        ArrayList<WeakReference<SensorOrientationChangeNotifier.Listener>> deadLiksArr = new ArrayList<WeakReference<SensorOrientationChangeNotifier.Listener>>();
        for (WeakReference<SensorOrientationChangeNotifier.Listener> wr : mListeners) {
            if (wr.get() == null)
                deadLiksArr.add(wr);
            else
                wr.get().onOrientationChange(mOrientation);
        }

        // remove dead references 
        for (WeakReference<SensorOrientationChangeNotifier.Listener> wr : deadLiksArr) {
            mListeners.remove(wr);
        }
    }

    public boolean isPortrait(){
        return mOrientation == 0 || mOrientation == 180;
    }

    public boolean isLandscape(){
        return !isPortrait();
    }
}

请按如下方式使用：
在AndroidManifest.xml中 -
    <activity
        ...
        android:screenOrientation="portrait"
        >

在您的活动中：

public class MainActivity extends Activity implements  SensorOrientationChangeNotifier.Listener {

    @Override
    protected void onResume() {
        super.onResume();

        SensorOrientationChangeNotifier.getInstance().addListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        SensorOrientationChangeNotifier.getInstance().remove(this);
    }

    @Override
    public void onOrientationChange(int orientation) {
            if (orientation == 90 || orientation == 270){
                 // Do some landscape stuff
                } else {
                 // Do some portrait stuff
                 }
        }
    }
}
1

这是Asaf Pinhassi的答案的Kotlin版本。

import android.content.Context
import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager
import java.lang.ref.WeakReference
import java.util.*

class SensorOrientationChangeNotifier private constructor(context: Context) {
val TAG = javaClass.simpleName
private val mListeners = ArrayList<WeakReference<Listener?>>(3)
var orientation = 0
    private set
private val mSensorEventListener: SensorEventListener
private val mSensorManager: SensorManager

/**
 * Call on activity reset()
 */
private fun onResume() {
    mSensorManager.registerListener(mSensorEventListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL)
}

/**
 * Call on activity onPause()
 */
private fun onPause() {
    mSensorManager.unregisterListener(mSensorEventListener)
}

private inner class NotifierSensorEventListener : SensorEventListener {
    override fun onSensorChanged(event: SensorEvent) {
        val x = event.values[0]
        val y = event.values[1]
        var newOrientation: Int = orientation
        if (x < 5 && x > -5 && y > 5) newOrientation = 0 else if (x < -5 && y < 5 && y > -5) newOrientation = 90 else if (x < 5 && x > -5 && y < -5) newOrientation = 180 else if (x > 5 && y < 5 && y > -5) newOrientation = 270

        //Log.e(TAG,"mOrientation="+mOrientation+"   ["+event.values[0]+","+event.values[1]+","+event.values[2]+"]");
        if (orientation != newOrientation) {
            orientation = newOrientation
            notifyListeners()
        }
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}

interface Listener {
    fun onOrientationChange(orientation: Int)
}

fun addListener(listener: Listener) {
    if (get(listener) == null) // prevent duplications
        mListeners.add(WeakReference(listener))
    if (mListeners.size == 1) {
        onResume() // this is the first client
    }
}

fun remove(listener: Listener) {
    val listenerWR = get(listener)
    remove(listenerWR)
}

private fun remove(listenerWR: WeakReference<Listener?>?) {
    if (listenerWR != null) mListeners.remove(listenerWR)
    if (mListeners.size == 0) {
        onPause()
    }
}

private operator fun get(listener: Listener): WeakReference<Listener?>? {
    for (existingListener in mListeners) if (existingListener.get() === listener) return existingListener
    return null
}

private fun notifyListeners() {
    val deadLiksArr = ArrayList<WeakReference<Listener?>>()
    for (wr in mListeners) {
        if (wr.get() == null) deadLiksArr.add(wr) else wr.get()!!.onOrientationChange(orientation)
    }

    // remove dead references
    for (wr in deadLiksArr) {
        mListeners.remove(wr)
    }
}

val isPortrait: Boolean
    get() = orientation == 0 || orientation == 180

val isLandscape: Boolean
    get() = !isPortrait

companion object {
    private var mInstance: SensorOrientationChangeNotifier? = null
    fun getInstance(context: Context): SensorOrientationChangeNotifier? {
        if (mInstance == null) mInstance = SensorOrientationChangeNotifier(context)
        return mInstance
    }
}

init {
    mSensorEventListener = NotifierSensorEventListener()
    mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
}
}
-3
为了检测方向，我们将要求活动提供活动的宽度和高度，以便我们可以找到宽度>高度，这将是“横向”或相反的高度>宽度，即“纵向”-以下代码已经测试并工作正常。
@SuppressWarnings("deprecation")
public void detectScreenOrientation(){
WindowManager wm = getWindowManager();
Display d = wm.getDefaultDisplay();
if (d.getWidth() > d.getHeight()){
    Log.d("Orientation","Landscape mode");
}
else {
    Log.d("Orientation", "Portrait mode");
}
}
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接