Introducción de esta sección:

En la sección anterior aprendimos algunos conceptos básicos sobre los sensores, así como el procedimiento para usar sensores. En esta sección les traemos el uso del sensor de orientación. ¡Bien, comencemos con el contenido de esta sección~


1. Concepto del sistema de coordenadas tridimensional:

En la plataforma Android, el marco de trabajo de sensores generalmente usa un sistema de coordenadas tridimensional estándar para representar un valor. Tomando como ejemplo el sensor de orientación que se explicará en esta sección, determinar una dirección también requiere un sistema de coordenadas tridimensional. Después de todo, nuestro dispositivo no siempre puede estar sostenido en posición horizontal, ¿verdad? El valor de orientación que Android nos devuelve es un array flaot de longitud 3, que contiene los valores de tres direcciones. ¡En el documento oficial de la API hay una imagen como esta:sensors_overview

Si no entiendes la imagen, aquí tienes la explicación en texto:

  • Dirección del eje X:: a lo largo de la dirección horizontal de la pantalla, de izquierda a derecha. Si el teléfono no es cuadrado, el lado más corto debe colocarse horizontalmente y el lado más largo verticalmente.
  • Dirección del eje Y:: desde la esquina inferior izquierda de la pantalla, a lo largo de la dirección vertical de la pantalla, apuntando hacia la parte superior de la pantalla
  • Dirección del eje Z:: cuando se coloca horizontalmente, apunta en dirección al cielo

2. Los tres valores del sensor de orientación

Como se mencionó en la sección anterior, el método de devolución de llamada del sensor: el parámetro SensorEvent event en onSensorChanged, el tipo de valor de event es Float[], y tiene como máximo tres elementos, mientras que el sensor de orientación tiene exactamente tres elementos, ¡todos expresados en grados! Sus significados son los siguientes:

values[0]:Ángulo de orientación (azimut), el ángulo de rotación del teléfono alrededor del eje Z. 0 indica el norte (North), 90 indica el este (East), 180 indica el sur (South), 270 indica el oeste (West). Si el valor de values

values[1]: ángulo de inclinación, el grado en que el teléfono se levanta. Este valor cambia cuando el teléfono se inclina alrededor del eje X. El rango de valores está entre [-180, 180]. Si colocas el teléfono sobre una mesa y la mesa está completamente horizontal, values1debería ser 0, aunque pocas mesas son absolutamente horizontales. Desde la parte superior del teléfonocomenzando a levantarse, hasta que el teléfono rota 180 grados alrededor del eje X (en este momento la pantalla queda boca abajo horizontalmente sobre la mesa). Durante este proceso de rotación, values[1] cambiará desde0 a -180entre estos valores, es decir, cuando el teléfono se levanta, values1irá disminuyendo gradualmente hasta llegar a -180; y si desde la parte inferior del teléfonocomenzando a levantarse, hasta que el teléfono rota 180 grados alrededor del eje X, en este momento values[1] cambiaráentre 0 y 180. Podemos usar esta característica de value[1] combinada con value[2] para implementar un nivel de burbuja (regla de nivel).

value[2]: ángulo de giro (roll), el ángulo de rotación alrededor del eje Y, con un rango de valores: [-90, 90]. Supongamos que la pantalla del teléfono está hacia arriba y horizontal sobre la mesa; si la mesa está plana, values2debería ser 0. Si levantas gradualmente el lado izquierdo del teléfono, values[2] irá disminuyendo hasta que el teléfono quede perpendicular, en ese momento values[2] será -90; desde el lado derecho será 0-90; si en la posición vertical continúas rodando hacia la derecha o hacia la izquierda, values[2] continuará cambiando entre -90 y 90.

Si no lo entiendes muy bien, no importa, escribamos un demo para verificarlo y lo sabremos~


3. Un Demo simple para ayudarnos a entender los cambios de estos tres valores:

Imagen del efecto de ejecución:

Código de implementación:

Código del diseño:activity_main.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="5dp">

    <TextView
        android:id="@+id/tv_value1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="方位角"
        android:textSize="18sp"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/tv_value2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="倾斜角"
        android:textSize="18sp"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/tv_value3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="滚动角"
        android:textSize="18sp"
        android:textStyle="bold" />

</LinearLayout>

MainActivity.java:

public class MainActivity extends AppCompatActivity implements SensorEventListener {

    private TextView tv_value1;
    private TextView tv_value2;
    private TextView tv_value3;
    private SensorManager sManager;
    private Sensor mSensorOrientation;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        sManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        mSensorOrientation = sManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
        sManager.registerListener(this, mSensorOrientation, SensorManager.SENSOR_DELAY_UI);
        bindViews();
    }

    private void bindViews() {
        tv_value1 = (TextView) findViewById(R.id.tv_value1);
        tv_value2 = (TextView) findViewById(R.id.tv_value2);
        tv_value3 = (TextView) findViewById(R.id.tv_value3);
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        tv_value1.setText("方位角:" + (float) (Math.round(event.values[0] * 100)) / 100);
        tv_value2.setText("倾斜角:" + (float) (Math.round(event.values[1] * 100)) / 100);
        tv_value3.setText("滚动角:" + (float) (Math.round(event.values[2] * 100)) / 100);
    }

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

    }
}

El código es muy simple~ Si realmente quieres experimentar los cambios de estos tres valores, ejecuta el programa y gira el teléfono para saberlo~


4. Un ejemplo sencillo de brújula de texto

A continuación, escribamos un simple ejemplo de brújula de texto para experimentar. Cuando el texto muestre "Sur", significa que el frente del teléfono apunta hacia el sur.

Imagen del efecto de ejecución:

Implementación del código:

Vista personalizada:CompassView.java

/**
 * Created by Jay on 2015/11/14 0014.
 */
public class CompassView extends View implements Runnable{

    private Paint mTextPaint;
    private int sWidth,sHeight;
    private float dec = 0.0f;
    private String msg  = "正北 0°";

    public CompassView(Context context) {
        this(context, null);
    }

    public CompassView(Context context, AttributeSet attrs) {
        super(context, attrs);
        sWidth = ScreenUtil.getScreenW(context);
        sHeight = ScreenUtil.getScreenH(context);
        init();
        new Thread(this).start();
    }



    public CompassView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    private void init() {

        mTextPaint = new Paint();
        mTextPaint.setColor(Color.GRAY);
        mTextPaint.setTextSize(64);
        mTextPaint.setStyle(Paint.Style.FILL);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText(msg, sWidth / 4 , sWidth / 2, mTextPaint);
    }

    // 更新指南针角度
    public void setDegree(float degree)
    {
        // 设置灵敏度
        if(Math.abs(dec - degree) >= 2 )
        {
            dec = degree;
            int range = 22;
            String degreeStr = String.valueOf(dec);

            // 指向正北
            if(dec > 360 - range && dec < 360 + range)
            {
                msg = "正北 " + degreeStr + "°";
            }

            // 指向正东
            if(dec > 90 - range && dec < 90 + range)
            {
                msg = "正东 " + degreeStr + "°";
            }

            // 指向正南
            if(dec > 180 - range && dec < 180 + range)
            {
                msg = "正南 " + degreeStr + "°";
            }

            // 指向正西
            if(dec > 270 - range && dec < 270 + range)
            {
                msg = "正西 " + degreeStr + "°";
            }

            // 指向东北
            if(dec > 45 - range && dec < 45 + range)
            {
                msg = "东北 " + degreeStr + "°";
            }

            // 指向东南
            if(dec > 135 - range && dec < 135 + range)
            {
                msg = "东南 " + degreeStr + "°";
            }

            // 指向西南
            if(dec > 225 - range && dec < 225 + range)
            {
                msg = "西南 " + degreeStr + "°";
            }

            // 指向西北
            if(dec > 315 - range && dec < 315 + range)
            {
                msg = "西北 " + degreeStr + "°";
            }
        }
    }


    @Override
    public void run() {
        while(!Thread.currentThread().isInterrupted())
        {
            try
            {
                Thread.sleep(100);
            }
            catch(InterruptedException e)
            {
                Thread.currentThread().interrupt();
            }
            postInvalidate();
        }
    }
}

MainActivity.java:

public class MainActivity extends AppCompatActivity implements SensorEventListener {

    private CompassView cView;
    private SensorManager sManager;
    private Sensor mSensorOrientation;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        cView = new CompassView(MainActivity.this);
        sManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        mSensorOrientation = sManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
        sManager.registerListener(this, mSensorOrientation, SensorManager.SENSOR_DELAY_UI);
        setContentView(cView);
    }


    @Override
    public void onSensorChanged(SensorEvent event) {
        cView.setDegree(event.values[0]);
    }

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

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        sManager.unregisterListener(this);
    }
}

Este es un prototipo muy simple de brújula. Si te interesa, puedes dibujar tu propia rosa de los vientos y aguja, y luego implementar una brújula bonita~


5. Descarga del código de ejemplo de esta sección:

SensorDemo2.zip

SensorDemo3.zip


Resumen de esta sección:

Bien, en esta sección presentamos el sensor de orientación más utilizado en Android, así como su uso simple, y escribimos un ejemplo de brújula. Para completar la brújula solo usamos el valor de values