Überprüfen Sie die Ausrichtung auf dem Android-Handy

Wie kann ich überprüfen, ob sich das Android-Telefon im Querformat oder im Hochformat befindet?

Die aktuelle Konfiguration, mit der bestimmt wird, welche Ressourcen abgerufen werden sollen, ist im ConfigurationObjekt " Ressourcen" verfügbar :

getResources().getConfiguration().orientation;

Sie können die Orientierung überprüfen, indem Sie sich den Wert ansehen:

int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // In landscape
} else {
    // In portrait
}

Weitere Informationen finden Sie im Android Developer .

Wenn Sie auf einigen Geräten die Ausrichtung getResources (). GetConfiguration (). Orientieren, wird dies falsch verstanden. Wir haben diesen Ansatz ursprünglich in http://apphance.com verwendet . Dank der Remote-Protokollierung von Apphance konnten wir es auf verschiedenen Geräten sehen und wir haben gesehen, dass Fragmentierung hier seine Rolle spielt. Ich habe seltsame Fälle gesehen: zum Beispiel abwechselndes Porträt und Quadrat (?!) Auf dem HTC Desire HD:

CONDITION[17:37:10.345] screen: rotation: 270 orientation: square
CONDITION[17:37:12.774] screen: rotation: 0 orientation: portrait
CONDITION[17:37:15.898] screen: rotation: 90
CONDITION[17:37:21.451] screen: rotation: 0
CONDITION[17:38:42.120] screen: rotation: 270 orientation: square

oder die Orientierung überhaupt nicht ändern:

CONDITION[11:34:41.134] screen: rotation: 0
CONDITION[11:35:04.533] screen: rotation: 90
CONDITION[11:35:06.312] screen: rotation: 0
CONDITION[11:35:07.938] screen: rotation: 90
CONDITION[11:35:09.336] screen: rotation: 0

Auf der anderen Seite sind width () und height () immer korrekt (sie werden vom Fenstermanager verwendet, sollten es also besser sein). Ich würde sagen, die beste Idee ist, die Breiten- / Höhenprüfung IMMER durchzuführen. Wenn Sie über einen Moment nachdenken, ist dies genau das, was Sie wollen - um zu wissen, ob die Breite kleiner als die Höhe (Hochformat) ist, das Gegenteil (Querformat) oder ob sie gleich sind (Quadrat).

Dann kommt es auf diesen einfachen Code an:

public int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    int orientation = Configuration.ORIENTATION_UNDEFINED;
    if(getOrient.getWidth()==getOrient.getHeight()){
        orientation = Configuration.ORIENTATION_SQUARE;
    } else{ 
        if(getOrient.getWidth() < getOrient.getHeight()){
            orientation = Configuration.ORIENTATION_PORTRAIT;
        }else { 
             orientation = Configuration.ORIENTATION_LANDSCAPE;
        }
    }
    return orientation;
}

Eine andere Möglichkeit, dieses Problem zu lösen, besteht darin, sich nicht auf den korrekten Rückgabewert der Anzeige zu verlassen, sondern auf die Auflösung der Android-Ressourcen.

Erstellen Sie die Datei layouts.xmlin den Ordnern res/values-landund res/values-portmit folgendem Inhalt:

res / values-land / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">true</bool>
</resources>

res / values-port / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">false</bool>
</resources>

In Ihrem Quellcode können Sie jetzt wie folgt auf die aktuelle Ausrichtung zugreifen:

context.getResources().getBoolean(R.bool.is_landscape)

Eine vollständige Möglichkeit, die aktuelle Ausrichtung des Telefons festzulegen:

    public String getRotation(Context context){
    final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
           switch (rotation) {
            case Surface.ROTATION_0:
                return "portrait";
            case Surface.ROTATION_90:
                return "landscape";
            case Surface.ROTATION_180:
                return "reverse portrait";
            default:
                return "reverse landscape";
            }
        }

Chear Binh Nguyen

Hier ist eine Code-Snippet-Demo, wie man die Bildschirmorientierung erhält. Dies wurde von Hackbod und Martijn empfohlen :

❶ Auslösen beim Ändern der Ausrichtung:

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
        int nCurrentOrientation = _getScreenOrientation();
    _doSomeThingWhenChangeOrientation(nCurrentOrientation);
}

❷ Holen Sie sich die aktuelle Orientierung, wie Hackbod empfiehlt:

private int _getScreenOrientation(){    
    return getResources().getConfiguration().orientation;
}

❸Es gibt alternative Lösungen, um die aktuelle Bildschirmausrichtung zu erhalten. ❷ Folgen Sie der Martijn- Lösung:

private int _getScreenOrientation(){
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        return display.getOrientation();
}

★ Hinweis : Ich habe versucht, beide implement & ❸ zu implementieren, aber unter RealDevice (NexusOne SDK 2.3) gibt die Ausrichtung die falsche Ausrichtung zurück.

★ Ich empfehle daher die Verwendung einer Lösung used, um eine Bildschirmorientierung zu erhalten, die mehr Vorteile bietet: klar, einfach und wie ein Zauber.

★ Überprüfen Sie sorgfältig die Rückgabe der Ausrichtung, um sicherzustellen, dass sie wie erwartet korrekt ist (möglicherweise abhängig von der Spezifikation der physischen Geräte).

Hoffe es hilft,

int ot = getResources().getConfiguration().orientation;
switch(ot)
        {

        case  Configuration.ORIENTATION_LANDSCAPE:

            Log.d("my orient" ,"ORIENTATION_LANDSCAPE");
        break;
        case Configuration.ORIENTATION_PORTRAIT:
            Log.d("my orient" ,"ORIENTATION_PORTRAIT");
            break;

        case Configuration.ORIENTATION_SQUARE:
            Log.d("my orient" ,"ORIENTATION_SQUARE");
            break;
        case Configuration.ORIENTATION_UNDEFINED:
            Log.d("my orient" ,"ORIENTATION_UNDEFINED");
            break;
            default:
            Log.d("my orient", "default val");
            break;
        }

Verwenden Sie getResources().getConfiguration().orientationes ist der richtige Weg.

Sie müssen nur auf verschiedene Arten von Landschaften achten, auf die Landschaft, die das Gerät normalerweise verwendet, und auf die andere.

Ich verstehe immer noch nicht, wie ich damit umgehen soll.

Es ist einige Zeit vergangen, seit die meisten dieser Antworten veröffentlicht wurden, und einige verwenden veraltete Methoden und Konstanten.

Ich habe Jareks Code aktualisiert , um diese Methoden und Konstanten nicht mehr zu verwenden:

protected int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    Point size = new Point();

    getOrient.getSize(size);

    int orientation;
    if (size.x < size.y)
    {
        orientation = Configuration.ORIENTATION_PORTRAIT;
    }
    else
    {
        orientation = Configuration.ORIENTATION_LANDSCAPE;
    }
    return orientation;
}

Beachten Sie, dass der Modus Configuration.ORIENTATION_SQUAREnicht mehr unterstützt wird.

Ich fand dies auf allen Geräten, auf denen ich es getestet habe, zuverlässig, im Gegensatz zu der Methode, die die Verwendung von vorschlägt getResources().getConfiguration().orientation

Überprüfen Sie die Bildschirmausrichtung zur Laufzeit.

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();

    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();        
    }
}

Es gibt noch eine Möglichkeit:

public int getOrientation()
{
    if(getResources().getDisplayMetrics().widthPixels>getResources().getDisplayMetrics().heightPixels)
    { 
        Toast t = Toast.makeText(this,"LANDSCAPE",Toast.LENGTH_SHORT);
        t.show();
        return 1;
    }
    else
    {
        Toast t = Toast.makeText(this,"PORTRAIT",Toast.LENGTH_SHORT);
        t.show();
        return 2;
    }       
}

Das Android SDK kann Ihnen Folgendes sagen:

getResources().getConfiguration().orientation

Getestet im Jahr 2019 auf API 28, unabhängig davon, ob der Benutzer die Hochformatausrichtung festgelegt hat oder nicht, und mit minimalem Code im Vergleich zu einer anderen, veralteten Antwort liefert das Folgende die richtige Ausrichtung:

/** @return The {@link Configuration#ORIENTATION_SQUARE}, {@link Configuration#ORIENTATION_PORTRAIT}, {@link Configuration#ORIENTATION_LANDSCAPE} constants based on the current phone screen pixel relations. */
private int getScreenOrientation()
{
    DisplayMetrics dm = context.getResources().getDisplayMetrics(); // Screen rotation effected

    if(dm.widthPixels == dm.heightPixels)
        return Configuration.ORIENTATION_SQUARE;
    else
        return dm.widthPixels < dm.heightPixels ? Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
}

Ich denke, dieser Code funktioniert möglicherweise, nachdem die Änderung der Ausrichtung wirksam geworden ist

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

Überschreiben Sie die Funktion Activity.onConfigurationChanged (Configuration newConfig) und verwenden Sie newConfig, Ausrichtung, wenn Sie vor dem Aufruf von setContentView über die neue Ausrichtung benachrichtigt werden möchten.

Ich denke, die Verwendung von getRotationv () hilft nicht, da http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () die Drehung des Bildschirms von seiner "natürlichen" zurückgibt. Orientierung.

Wenn Sie also die "natürliche" Ausrichtung nicht kennen, ist die Rotation bedeutungslos.

Ich habe einen einfacheren Weg gefunden,

  Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  Point size = new Point();
  display.getSize(size);
  int width = size.x;
  int height = size.y;
  if(width>height)
    // its landscape

Bitte sagen Sie mir, ob es ein Problem mit dieser Person gibt.

Dies ist eine Überlagerung aller Telefone wie oneplus3

public static boolean isScreenOriatationPortrait(Context context) {
         return context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
         }

richtiger Code wie folgt:

public static int getRotation(Context context){
        final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();

        if(rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180){
            return Configuration.ORIENTATION_PORTRAIT;
        }

        if(rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270){
            return Configuration.ORIENTATION_LANDSCAPE;
        }

        return -1;
    }

Alter Beitrag, den ich kenne. Unabhängig von der Ausrichtung oder dem Austausch usw. habe ich diese Funktion entwickelt, mit der das Gerät in die richtige Ausrichtung gebracht wird, ohne dass Sie wissen müssen, wie die Hoch- und Querformatfunktionen auf dem Gerät organisiert sind.

   private void initActivityScreenOrientPortrait()
    {
        // Avoid screen rotations (use the manifests android:screenOrientation setting)
        // Set this to nosensor or potrait

        // Set window fullscreen
        this.activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        DisplayMetrics metrics = new DisplayMetrics();
        this.activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

         // Test if it is VISUAL in portrait mode by simply checking it's size
        boolean bIsVisualPortrait = ( metrics.heightPixels >= metrics.widthPixels ); 

        if( !bIsVisualPortrait )
        { 
            // Swap the orientation to match the VISUAL portrait mode
            if( this.activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT )
             { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); }
            else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT ); }
        }
        else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR); }

    }

Klappt wunderbar!

Verwenden Sie diesen Weg,

    int orientation = getResources().getConfiguration().orientation;
    String Orintaion = "";
    switch (orientation)
    {
        case Configuration.ORIENTATION_UNDEFINED: Orintaion = "Undefined"; break;
        case Configuration.ORIENTATION_LANDSCAPE: Orintaion = "Landscrape"; break;
        case Configuration.ORIENTATION_PORTRAIT:  Orintaion = "Portrait"; break;
        default: Orintaion = "Square";break;
    }

In der Zeichenfolge haben Sie das Oriantion

Es gibt viele Möglichkeiten, dies zu tun. Dieser Code funktioniert für mich

 if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }

Ich finde diese Lösung einfach

if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
  user_todat_latout = true;
} else {
  user_todat_latout = false;
}

Nur einfacher zweizeiliger Code

if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // do something in landscape
} else {
    //do in potrait
}

Simpel und einfach :)

1. Erstellen Sie 2 XML-Layouts (z. B. Porträt und Landschaft).

2. Schreiben Sie in die Java-Datei:

   private int intOrientation;

   bei onCreateMethode und vor dem setContentViewSchreiben:

   intOrientation = getResources().getConfiguration().orientation;
   if (intOrientation == Configuration.ORIENTATION_PORTRAIT)
       setContentView(R.layout.activity_main);
   else
       setContentView(R.layout.layout_land);   // I tested it and it works fine.

Es ist auch erwähnenswert, dass es heutzutage weniger gute Gründe gibt, die explizite Ausrichtung zu überprüfen, getResources().getConfiguration().orientationwenn Sie dies aus Layoutgründen tun, da die in Android 7 / API 24+ eingeführte Unterstützung für mehrere Fenster Ihre Layouts in beiden Fällen erheblich beeinträchtigen könnte Orientierung. Es ist besser, die Verwendung <ConstraintLayout>und alternative Layouts in Betracht zu ziehen , die von der verfügbaren Breite oder Höhe abhängen , sowie andere Tricks, um zu bestimmen, welches Layout verwendet wird, z. B. das Vorhandensein oder Nichtvorhandensein bestimmter Fragmente, die an Ihre Aktivität angehängt sind.

Sie können dies verwenden (basierend auf hier ):

public static boolean isPortrait(Activity activity) {
    final int currentOrientation = getCurrentOrientation(activity);
    return currentOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT || currentOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}

public static int getCurrentOrientation(Activity activity) {
    //code based on https://www.captechconsulting.com/blog/eric-miles/programmatically-locking-android-screen-orientation
    final Display display = activity.getWindowManager().getDefaultDisplay();
    final int rotation = display.getRotation();
    final Point size = new Point();
    display.getSize(size);
    int result;
    if (rotation == Surface.ROTATION_0
            || rotation == Surface.ROTATION_180) {
        // if rotation is 0 or 180 and width is greater than height, we have
        // a tablet
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a phone
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            }
        }
    } else {
        // if rotation is 90 or 270 and width is greater than height, we
        // have a phone
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a tablet
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            }
        }
    }
    return result;
}