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

415

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

Mohit Deshpande
quelle
1
Schauen Sie sich diese Antwort in einem ähnlichen Thread an: stackoverflow.com/a/26601009/3072449
Magic Hands Pellegrin

Antworten:

676

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 .

Hackbod
quelle
2
Oh, tut mir leid, ich habe es falsch verstanden. Ich dachte, Sie sagten, dass der Dienst die Konfigurationsänderung nicht sehen würde, wenn sich die Konfiguration ändert. Was Sie beschreiben, ist, dass ... nun, es wird nichts angezeigt, weil sich nichts ändert, weil der Launcher die Bildschirmausrichtung gesperrt hat und nicht zulässt, dass sie sich ändert. Es ist also richtig, dass sich die Ausrichtung nicht ändert, weil sich die Ausrichtung nicht geändert hat. Der Bildschirm ist immer noch im Hochformat.
Hackbod
Das Nächste, was ich tun kann, ist, die Ausrichtung von den Sensoren abzulesen, was Mathematik beinhaltet, die ich im Moment nicht wirklich herausfinden möchte.
Archimedes Trajano
13
Es gibt nichts zu ärgern. Der Bildschirm hat sich nicht gedreht, er befindet sich immer noch im Hochformat, es ist keine Drehung zu sehen. Wenn Sie überwachen möchten, wie der Benutzer sein Telefon bewegt, unabhängig davon, wie der Bildschirm gedreht wird, müssen Sie den Sensor direkt beobachten und entscheiden, wie Sie die Informationen interpretieren möchten, die Sie über die Bewegung des Geräts erhalten.
Hackbod
4
Dies schlägt fehl, wenn die Bildschirmausrichtung festgelegt ist.
AndroidDev
7
Wenn die Aktivität die Anzeige sperrt ( android:screenOrientation="portrait"), gibt diese Methode denselben Wert zurück, unabhängig davon, wie der Benutzer das Gerät dreht. In diesem Fall würden Sie den Beschleunigungsmesser oder den Schwerkraftsensor verwenden, um die Ausrichtung richtig herauszufinden.
Katze
169

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;
}
Jarek Potiuk
quelle
3
Vielen Dank! Das Initialisieren von "Orientierung" ist jedoch überflüssig.
MrMaffen
getWidthund getHeightsind nicht veraltet.
FindOut_Quran
3
@ user3441905, ja das sind sie. Verwenden Sie getSize(Point outSize)stattdessen. Ich benutze API 23.
WindRider
@ jarek-potiuk es ist veraltet.
Hades
53

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)
Paul
quelle
1
Ich mag dies, da es die Art und Weise verwendet, wie das System bereits die Ausrichtung bestimmt
KrustyGString
1
Beste Antwort für Landschafts- / Hochformatprüfung!
vtlinh
Was ist sein Wert in der Standardwertedatei?
Shashank Mishra
46

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

Nguyen Minh Binh
quelle
6
Es gibt einen Tippfehler in Ihrem Beitrag - es sollte heißen .getRotation () nicht getOrientation
Keith
1
+1 dafür. Ich musste die genaue Ausrichtung kennen, nicht nur Landschaft gegen Hochformat. getOrientation () ist korrekt, es sei denn, Sie verwenden SDK 8+. In diesem Fall sollten Sie getRotation () verwenden. Die Umkehrmodi werden in SDK 9+ unterstützt.
Paul
6
@Keith @Paul Ich erinnere mich nicht, wie es getOrientation()funktioniert, aber das ist nicht korrekt, wenn ich es benutze getRotation(). Rotationsquelle "Returns the rotation of the screen from its "natural" orientation." abrufen . Auf einem Telefon, auf dem ROTATION_0 als Hochformat angezeigt wird, ist dies wahrscheinlich korrekt, auf einem Tablet ist die "natürliche" Ausrichtung jedoch wahrscheinlich Querformat, und ROTATION_0 sollte Querformat anstelle von Hochformat zurückgeben.
jp36
Sieht so aus, als wäre dies die bevorzugte Methode. Join forward: developer.android.com/reference/android/view/…
jaysqrd
Dies ist eine falsche Antwort. Warum wurde es gewählt? getOrientation (float [] R, float [] -Werte) berechnet die Ausrichtung des Geräts basierend auf der Rotationsmatrix.
user1914692
29

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,

NguyenDat
quelle
16
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;
        }
anshul
quelle
13

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.

neteinstein
quelle
12

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

Baz
quelle
Beachten Sie, dass getOrient.getSize (Größe) 13 API-Level erfordert
Lester
6

Ü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();        
    }
}
Kumar
quelle
5

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;
    }       
}
maximus
quelle
4

Das Android SDK kann Ihnen Folgendes sagen:

getResources().getConfiguration().orientation
Single 'n Looking
quelle
4

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;
}
ManuelTS
quelle
2

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.

Daniel
quelle
2

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.

steveh
quelle
2

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;
    }
yueyue_projects
quelle
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!

Codebeat
quelle
1

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


quelle
1

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
        }
Mehroz Munir
quelle
1

Ich finde diese Lösung einfach

if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
  user_todat_latout = true;
} else {
  user_todat_latout = false;
}
Issac Nabil
quelle
Im Allgemeinen sind Antworten viel hilfreicher, wenn sie eine Erklärung enthalten, was der Code tun soll und warum dies das Problem löst, ohne andere einzuführen.
Tom Aranda
Ja, tut mir leid, ich dachte, es muss nicht genau erklärt werden, wie dieser Block der Codeüberprüfung ausgerichtet ist, wenn er gleich ist. Configuration.ORIENTATION_PORTRAIT, das heißt App im Hochformat :)
Issac Nabil
1

Nur einfacher zweizeiliger Code

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

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.
Kerelos
quelle
0

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.

qix
quelle
0

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;
}
Android-Entwickler
quelle