para - instalar sensor magnetico android

Cómo verificar la orientación natural(predeterminada) del dispositivo en Android(es decir, obtener un paisaje para, por ejemplo, Motorola Charm o Flipout)

Question

Tengo una actividad que muestra la vista previa de la cámara, por lo que debe establecerse solo como paisaje. En la parte inferior (independientemente de la rotación del dispositivo) quiero mostrar una vista de texto. Estoy utilizando OrientationEventListener, que da la orientación del dispositivo desde su posición natural. Puedo implementar una solución que funcione bien en los dispositivos de retrato vertical, pero para que funcione también en los dispositivos de paisaje predeterminados, debo ser consciente de que se ejecuta en dicho dispositivo. Por lo tanto, la pregunta es ¿cómo verificarlo?

Answer 1

@Urboss, no puede. Primero debe conocer la orientación predeterminada del dispositivo, ya que ambos métodos devuelven los cambios basándose en él (es decir, si el valor predeterminado es vertical, el resultado que está buscando será 1 o ROTAR_90, por lo tanto, es horizontal, pero , si el valor predeterminado es horizontal, el resultado es 0).

Y hasta donde sé, encontrar la orientación predeterminada del dispositivo no es trivial :(

¿Alguien puede arrojar algo de luz sobre este tema?

Answer 2

Aquí está mi solución:

public class ActivityOrientationTest extends Activity {
private static final String TAG = "ActivityOrientationTest";
private int mNaturalOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
private TextView mTextView;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);        
    setContentView(R.layout.main);
    mTextView = (TextView)findViewById(R.id.text);
    setDefaultOrientation();        
}

private void setDefaultOrientation(){
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER);

    Display display;         
    display = getWindow().getWindowManager().getDefaultDisplay();
    int rotation = display.getRotation();
    int width = 0;
    int height = 0;
    switch (rotation) {
    case Surface.ROTATION_0:
    case Surface.ROTATION_180:
        Log.i(TAG, "Rotation is: 0 or 180");
        width = display.getWidth();
        height = display.getHeight();
        break;
    case Surface.ROTATION_90:       
    case Surface.ROTATION_270:
        Log.i(TAG, "Rotation is: 90 or 270");
        width = display.getHeight();
        height = display.getWidth();
        break;
    default:
        break;
    }

    if(width > height){
        Log.i(TAG, "Natural Orientation is landscape");
        mTextView.setText("Natural Orientation is landscape");
        mNaturalOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
    } else {
        Log.i(TAG, "Natural Orientation is portrait");
        mNaturalOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        mTextView.setText("Natural Orientation is portrait");
    } 

    setRequestedOrientation(mNaturalOrientation);
}

Display.getRotation () solo es compatible con API de nivel 8 o superior, por lo que si necesita admitir dispositivos más antiguos, deberá llamar a Display.getOrientation ().

Answer 3

Bueno, puedes averiguar cuál es la orientación actual de @Urboss. No se puede obtener el diseño (paisaje / retrato) de esa manera, por lo que tendrás que obtener el ancho / alto de la pantalla para verificar si la posición actual (cambia o no, pero has verificado eso;)) es horizontal o retrato:

    DisplayMetrics dm = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(dm);
    wPix = dm.widthPixels;
    hPix = dm.heightPixels;

(Así que si la rotación es 0 y obtienes un paisaje con la metrix anterior, tu dispositivo es el paisaje predeterminado. Si la rotación es de 90 grados y tu retrato, el valor predeterminado también es horizontal, y así sucesivamente)

Answer 4

Después de horas y horas de tratar de resolver esto. No es posible. Sin embargo, lo más cercano que puede hacer es establecer la orientación a "NOSENSOR"

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);

Lo que esto hará es configurar su aplicación a la orientación natural del dispositivo. En este punto, puede obtener el alto y el ancho de la pantalla usando la clase DisplayMetrics y calcular si está en horizontal o vertical. Después de averiguar si es un paisaje o retrato, puede hacer esto

setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_XXXXX);

Donde XXXX es LANDSCAPE o PORTRAIT.

El caso donde hacer esto puede no funcionar es si tiene un teclado deslizable.

Answer 5

Este método puede ayudar:

public int getDeviceDefaultOrientation() {

    WindowManager windowManager =  (WindowManager) getSystemService(Context.WINDOW_SERVICE);

    Configuration config = getResources().getConfiguration();

    int rotation = windowManager.getDefaultDisplay().getRotation();

    if ( ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) &&
            config.orientation == Configuration.ORIENTATION_LANDSCAPE)
        || ((rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) &&    
            config.orientation == Configuration.ORIENTATION_PORTRAIT)) {
      return Configuration.ORIENTATION_LANDSCAPE;
    } else { 
      return Configuration.ORIENTATION_PORTRAIT;
    }
}

Answer 6

Gracias a la excelente respuesta anterior del diyismo, también agregué la lógica para verificar la posición de orientación real (paisaje a la derecha, retrato, paisaje a la izquierda, retrato volteado): Aquí está el código:

@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
    //The coordinate-system is defined relative to the screen of the phone in its default orientation
    int orientation = 0;
    float roll=0;
    float pitch=0;
    switch (getWindowManager().getDefaultDisplay().getRotation())  {
        case Surface.ROTATION_0:
                 roll=event.values[2];
                 pitch=event.values[1];
            break;
            case Surface.ROTATION_90:
                 roll=event.values[1];
                 pitch=-event.values[2];
            break;
            case Surface.ROTATION_180:
                 roll=-event.values[2];
                 pitch=-event.values[1];
            break;
            case Surface.ROTATION_270:
                 roll=-event.values[1];
                 pitch=event.values[2];
            break;
           }

    if (pitch >= -45 && pitch < 45 && roll >= 45)
        orientation = 0;
    else if (pitch < -45 && roll >= -45 && roll < 45) 
        orientation = 1; 
    else if (pitch >= -45 && pitch < 45 && roll < -45) 
        orientation = 2;
    else if (pitch >= 45 && roll >= -45 && roll < 45 ) 
        orientation = 3;

    if (m_nOrientation != orientation) { //orientation changed event
        m_Inst.Debug(LOG_TAG,"onSensorChanged: orientation:" + orientation);
        m_nOrientation = orientation;
        // fire event for new notification, or update your interface here
    }
}

Este código también se publica aquí: http://www.pocketmagic.net/?p=2847

Answer 7

Mi solución (probada en HTC desire y SamSung galaxy tab 10.1):

    private class compass_listener implements SensorEventListener
            {public void onAccuracyChanged(Sensor sensor, int accuracy) {}

             public void onSensorChanged(SensorEvent event)
                    {float roll=0;
                     float pitch=0;
                     switch (((Activity)context).getWindowManager().getDefaultDisplay().getRotation())
                            {case Surface.ROTATION_0:
                                  roll=event.values[2];
                                  pitch=event.values[1];
                             break;
                             case Surface.ROTATION_90:
                                  roll=event.values[1];
                                  pitch=-event.values[2];
                             break;
                             case Surface.ROTATION_180:
                                  roll=-event.values[2];
                                  pitch=-event.values[1];
                             break;
                             case Surface.ROTATION_270:
                                  roll=-event.values[1];
                                  pitch=event.values[2];
                             break;
                            }
                     JSONObject json=new JSONObject();
                     try
                         {json.put("roll", roll);
                          json.put("pitch", pitch);
                          json.put("azimuth", event.values[0]);
                         }
                     catch (JSONException e)
                           {throw new RuntimeException(e);
                           }
                     java_2_js(webview, "intent_compass_change", json);
                    }
            }

Answer 8

Puede definir utilizando rotación y orientación. No es necesario usar sensores ni oyentes, simplemente llame al método DefaultPaisaje siempre que lo desee.

private boolean isDefaultLandscape(final Context context)
{
    Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
    int rotation = display.getRotation();
    int orientation = context.getResources().getConfiguration().orientation;

    switch (rotation)
    {
        case Surface.ROTATION_180:
        case Surface.ROTATION_0:
        {
            return orientation == Configuration.ORIENTATION_LANDSCAPE;
        }
        default:
        {
            return orientation == Configuration.ORIENTATION_PORTRAIT;
        }
    }
}

Answer 9

Se puede hacer usando Display.getOrientation() o Display.getRotation() (para nivel de API> = 8).

Answer 10

es muy simple resolver esto

int orient = this.getResources (). getConfiguration () orientación;

si devuelve 1 o 2

1 es el retrato 2 es paisaje

Answer 11

http://android-developers.blogspot.com/2010/09/one-screen-turn-deserves-another.html

Answer 12

public static boolean isDeviceDefaultOrientationLandscape(Activity a) {

    WindowManager windowManager = (WindowManager) a.getSystemService(Context.WINDOW_SERVICE);

    Configuration config = a.getResources().getConfiguration();

    int rotation = windowManager.getDefaultDisplay().getRotation();

    boolean defaultLandsacpeAndIsInLandscape = (rotation == Surface.ROTATION_0 ||
            rotation == Surface.ROTATION_180) &&
            config.orientation == Configuration.ORIENTATION_LANDSCAPE;

    boolean defaultLandscapeAndIsInPortrait = (rotation == Surface.ROTATION_90 ||
            rotation == Surface.ROTATION_270) &&
            config.orientation == Configuration.ORIENTATION_PORTRAIT;

    return defaultLandsacpeAndIsInLandscape || defaultLandscapeAndIsInPortrait;
}