So prüfen Sie die natürliche (Standard) Ausrichtung des Geräts auf Android (d. H. Landschaft für z. B. Motorola Charm oder Flipout)

Question

Ich habe eine Aktivität, die Vorschau von der Kamera zeigt, also muss sie nur als Querformat eingestellt werden. Ganz unten (unabhängig von der Gerätedrehung) möchte ich eine Textansicht anzeigen. Ich verwende OrientationEventListener, der die Ausrichtung des Geräts von seiner natürlichen Position aus angibt. Ich kann eine Lösung implementieren, die gut auf Hochformat-Standardgeräten funktioniert, aber damit es auch auf Landscape-Standardgeräten funktioniert, muss ich darauf achten, auf einem solchen Gerät zu laufen. Also die Frage ist, wie man es überprüft?

Answer 1

Es kann mit Display.getOrientation() oder Display.getRotation() (für API-Ebene> = 8) erfolgen.

Answer 2

@Urboss, kann es nicht. Sie müssen zunächst die Standardausrichtung des Geräts kennen, da beide Methoden die darauf basierenden Änderungen zurückgeben (dh, wenn der Standardwert "Porträt" ist, wird das Ergebnis 1 oder ROTATE_90 sein, also ist es Landscape) Wenn der Standardwert Landscape ist, ist das Ergebnis 0).

Und soweit ich weiß, finden die Standardausrichtung des Gerätes ist nicht trivial :(

Wer etwas Licht in dieses Thema werfen?

Answer 3

Nun, können Sie herausfinden, was aktuelle Ausrichtung ist So wie @Urboss sagt, man kann das Layout (Landschaft/Portrait) natürlich nicht bekommen, also muss man die Bildschirmbreite/-höhe bekommen, um zu überprüfen, ob die aktuelle (egal ob geändert oder nicht), aber das hat man überprüft ;)) Position ist Querformat oder Hochformat:

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

(Wenn also die Drehung 0 ist und Sie eine Landschaft mit über Metrix erhalten, ist Ihr Gerät die Standard-Landschaft. Wenn die Drehung 90 Grad ist und Sie im Hochformat sind, ist der Standard auch Querformat und so weiter.

Answer 4

Nach stundenlangem Versuch, das herauszufinden. Es ist nicht möglich. die nächste Sache, die Sie tun können ist jedoch die Orientierung auf „NOSENSOR“

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR); 

Was wird dies tun gesetzt ist Ihre Anwendung auf die natürliche Ausrichtung des Geräts einzustellen. An diesem Punkt können Sie die Höhe und Breite der Anzeige mit der DisplayMetrics-Klasse ermitteln und berechnen, ob Sie im Quer- oder Hochformat sind. Nachdem Sie dann herausgefunden haben, ob es Querformat oder Hochformat ist, können Sie dies tun

setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_XXXXX);

Wobei XXXX entweder LANDSCHAFT oder PORTRÄT ist.

Der Fall, in dem dies nicht funktioniert, ist, wenn Sie eine ausziehbare Tastatur haben.

Answer 5

Hier ist meine Lösung:

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() wird nur in API-Ebene unterstützt 8 oder höher, so, wenn Sie ältere Geräte unterstützen müssen Sie Display.getOrientation anrufen müssen().

Answer 6

Meine Lösung (getestet bei HTC Wunsch und 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 7

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

Answer 8

Diese Methode kann helfen: -

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 9

Dank diyism ausgezeichnete Antwort oben, habe ich auch die Logik, um die tatsächliche Ausrichtung Position zu überprüfen (Landschaft rechts , Porträt, Querformat links, Porträt gespiegelt): Hier ist der Code:

@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 
    } 
} 

Dieser Code wird auch hier gepostet: http://www.pocketmagic.net/?p=2847

Answer 10

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; 
} 

Answer 11

seine sehr einfach, diese

int orientieren = this.getResources() lösen getConfiguration() Orientierung;..

wenn sie zurückkehren 1 oder 2

1 ist Portrait 2 ist Landschaft

Answer 12

Sie mithilfe Drehung und Ausrichtung definieren. Sie müssen keine Sensoren oder Listener verwenden. Rufen Sie einfach die isDefaultLandscape-Methode auf, wann immer Sie möchten.

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; 
     } 
    } 
}