10

这很容易与另一个问题重复，我只是在努力找出要搜索的内容。

我的相机应用程序被锁定在横向模式（在清单中），如下所示：

android:screenOrientation="landscape"

但是，当设备旋转为纵向时，我仍然希望旋转一些 UI 元素（尽管 android 仍然会认为它是横向的，但这是故意的）。

所以我试过这个来检查方向

int rotation = this.getWindowManager().getDefaultDisplay()
            .getRotation();
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0:
            Log.d("Rotation", "0");
            break;
        case Surface.ROTATION_90:
            Log.d("Rotation", "90");
            break;
        case Surface.ROTATION_180:
            Log.d("Rotation", "180");
            break;
        case Surface.ROTATION_270:
            Log.d("Rotation", "270");
            break;
    }

不幸的是，无论我如何转动手机，它总是返回 90。无论Android“认为”方向是什么，是否有更强大的方法来获取方向？

4

5 回答 5

11

所以在我考虑之后，我意识到我可以实现一个与 Android 本身用来确定方向的算法类似的算法。我使用 onSenseorChanged 回调来做到这一点

public static final int UPSIDE_DOWN = 3;
public static final int LANDSCAPE_RIGHT = 4;
public static final int PORTRAIT = 1;
public static final int LANDSCAPE_LEFT = 2;
public int mOrientationDeg; //last rotation in degrees
public int mOrientationRounded; //last orientation int from above 
private static final int _DATA_X = 0;
private static final int _DATA_Y = 1;
private static final int _DATA_Z = 2;
private int ORIENTATION_UNKNOWN = -1;
@Override
public void onSensorChanged(SensorEvent event) 
{
    Log.d(TAG, "Sensor Changed");
    float[] values = event.values;
    int orientation = ORIENTATION_UNKNOWN;
    float X = -values[_DATA_X];
    float Y = -values[_DATA_Y];
    float Z = -values[_DATA_Z];        
    float magnitude = X*X + Y*Y;
    // Don't trust the angle if the magnitude is small compared to the y value
    if (magnitude * 4 >= Z*Z) {
        float OneEightyOverPi = 57.29577957855f;
        float angle = (float)Math.atan2(-Y, X) * OneEightyOverPi;
        orientation = 90 - (int)Math.round(angle);
        // normalize to 0 - 359 range
        while (orientation >= 360) {
            orientation -= 360;
        } 
        while (orientation < 0) {
            orientation += 360;
        }
    }
    //^^ thanks to google for that code
    //now we must figure out which orientation based on the degrees
    Log.d("Oreination", ""+orientation);
    if (orientation != mOrientationDeg) 
    {
        mOrientationDeg = orientation;
        //figure out actual orientation
        if(orientation == -1){//basically flat

        }
        else if(orientation <= 45 || orientation > 315){//round to 0
            tempOrientRounded = 1;//portrait
        }
        else if(orientation > 45 && orientation <= 135){//round to 90
            tempOrientRounded = 2; //lsleft
        }
        else if(orientation > 135 && orientation <= 225){//round to 180
            tempOrientRounded = 3; //upside down
        }
        else if(orientation > 225 && orientation <= 315){//round to 270
            tempOrientRounded = 4;//lsright
        }

    }

    if(mOrientationRounded != tempOrientRounded){
            //Orientation changed, handle the change here
        mOrientationRounded = tempOrientRounded;

    }
}

它看起来比实际复杂，但只要知道它可以工作（我会说和系统一样好）。不要忘记在 onResume 和 onPause 中为加速度计注册传感器更改事件监听器

于 2013-02-13T14:19:19.910 回答
4

对于检测方向，我将其用于向传感器管理器注册：

mSensorOrientation = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);      
mSensorManager.registerListener(this, mSensorOrientation, SensorManager.SENSOR_DELAY_NORMAL);

然后这用于检测方向变化，您可以在评论中放置自己的方法实现。

常数：

public static final int LYING = 0;
public static final int LANDSCAPE_RIGHT = 1;
public static final int PORTRAIT = 2;
public static final int LANDSCAPE_LEFT = 3;



public void onSensorChanged(SensorEvent event) {

Sensor sensorEvent = event.sensor;

if ((sensorEvent.getType() == Sensor.TYPE_ORIENTATION)) {

    float [] eventValues = event.values;

    // current orientation of the phone
    float xAxis = eventValues[1];
    float yAxis = eventValues[2];

    if ((yAxis <= 25) && (yAxis >= -25) && (xAxis >= -160)) {

        if (previousOrientation != PORTRAIT){
            previousOrientation = PORTRAIT;

            // CHANGED TO PORTRAIT
        }

    } else if ((yAxis < -25) && (xAxis >= -20)) {

        if (previousOrientation != LANDSCAPE_RIGHT){
            previousOrientation = LANDSCAPE_RIGHT;

            // CHANGED TO LANDSCAPE RIGHT
        }

    } else if ((yAxis > 25) && (xAxis >= -20)){

        if (previousOrientation != LANDSCAPE_LEFT){
            previousOrientation = LANDSCAPE_LEFT;

            // CHANGED TO LANDSCAPE LEFT
        }
    }
}

}

于 2013-02-12T15:40:34.133 回答
2

在做了一些研究并尝试了一些东西之后，当我将传感器设置为：

mSensorOrientation = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

Sensor.TYPE_ORIENTATION 已被弃用，并且根据来自不同人的一些示例代码检索方向给了我不好的结果。我真的不知道它是否可以，但它对我有用。

于 2013-06-03T09:37:39.730 回答
1

这是 @Jameo 答案的略微修改的 Kotlin 版本。我需要度数来计算锁定方向的活动中的相机旋转。也请给他点赞。

private var rotationDeg: Int = 0
private var rotationRoundedClockwise: Int = 0

override fun onSensorChanged(event: SensorEvent) {
    Timber.d("Sensor Changed")
    val newRotationDeg = calculateNewRotationDegree(event)
    //^^ thanks to google for that code
    // now we must figure out which orientation based on the degrees
    Timber.d("rotation: $newRotationDeg")
    if (newRotationDeg != rotationDeg) {
        rotationDeg = newRotationDeg
        rotationRoundedClockwise = calculateRoundedRotation(newRotationDeg)
    }
    Timber.d("rotationRoundedClockwise: $rotationRoundedClockwise")
}

private val X_AXIS_INDEX = 0
private val Y_AXIS_INDEX = 1
private val Z_AXIS_AXIS = 2
private val ORIENTATION_UNKNOWN = -1

private fun calculateRoundedRotation(newRotationDeg: Int): Int {
    return if (newRotationDeg <= 45 || newRotationDeg > 315) { // round to 0
        0  // portrait
    } else if (newRotationDeg in 46..135) { // round to 90
        90  // clockwise landscape
    } else if (newRotationDeg in 136..225) { // round to 180
        180  // upside down portrait
    } else if (newRotationDeg in 226..315) { // round to 270
        270  // anticlockwise landscape
    } else {
        0
    }
}

private fun calculateNewRotationDegree(event: SensorEvent): Int {
    val values = event.values
    var newRotationDeg = ORIENTATION_UNKNOWN
    val X = -values[X_AXIS_INDEX]
    val Y = -values[Y_AXIS_INDEX]
    val Z = -values[Z_AXIS_AXIS]
    val magnitude = X * X + Y * Y
    // Don't trust the angle if the magnitude is small compared to the y value
    if (magnitude * 4 >= Z * Z) {
        val ONE_EIGHTY_OVER_PI = 57.29577957855f
        val angle = Math.atan2((-Y).toDouble(), X.toDouble()).toFloat() * ONE_EIGHTY_OVER_PI
        newRotationDeg = 90 - Math.round(angle)
        // normalize to 0 - 359 range
        while (newRotationDeg >= 360) {
            newRotationDeg -= 360
        }
        while (newRotationDeg < 0) {
            newRotationDeg += 360
        }
    }
    return newRotationDeg
}

private fun getCameraRotation(): Int {
    return when (rotationRoundedClockwise) {
        0 -> 90
        90 -> 180
        180 -> 270
        270 -> 0
        else -> 90
    }
}

这是监听事件的方法。

override fun onCreate() {
    super.onCreate()
    (activity?.getSystemService(SENSOR_SERVICE) as? SensorManager)?.let {
            sensorManager = it
        }
}

override fun onResume() {
    super.onResume()

    sensorManager.registerListener(this,
            sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
            SensorManager.SENSOR_DELAY_NORMAL)
}

override fun onPause() {
    super.onPause()

    sensorManager.unregisterListener(this)
}
于 2018-04-16T11:15:35.173 回答
0

@panavtec 对 API 23 的回答的翻译，以此作为参考

class MyActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private float[] lastMagFields = new float[3];;
    private float[] lastAccels = new float[3];;
    private float[] rotationMatrix = new float[16];
    private float[] orientation = new float[4];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
    }

    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD), SensorManager.SENSOR_DELAY_GAME);
        sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
    }

    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }

    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    public void onSensorChanged(SensorEvent event) {
        switch (event.sensor.getType()) {
            case Sensor.TYPE_ACCELEROMETER:
                System.arraycopy(event.values, 0, lastAccels, 0, 3);
                break;
            case Sensor.TYPE_MAGNETIC_FIELD:
                System.arraycopy(event.values, 0, lastMagFields, 0, 3);
                break;
            default:
                return;
        }

        if (SensorManager.getRotationMatrix(rotationMatrix, null, lastAccels, lastMagFields)) {
            SensorManager.getOrientation(rotationMatrix, orientation);

            float xAxis = (float) Math.toDegrees(orientation[1]);
            float yAxis = (float) Math.toDegrees(orientation[2]);

            int orientation = Configuration.ORIENTATION_UNDEFINED;
            if ((yAxis <= 25) && (yAxis >= -25) && (xAxis >= -160)) {
                Log.d(TAG, "Portrait");
                orientation = Configuration.ORIENTATION_PORTRAIT;
            } else if ((yAxis < -25) && (xAxis >= -20)) {
                Log.d(TAG, "Landscape Right");
                orientation = Configuration.ORIENTATION_LANDSCAPE;
            } else if ((yAxis > 25) && (xAxis >= -20)){
                orientation = Configuration.ORIENTATION_LANDSCAPE;
                Log.d(TAG, "Landscape Left");
            }
        }
    }
}
于 2016-11-13T17:30:28.893 回答