it-swarm.com.de

Überprüfen Sie die Ausrichtung am Android-Telefon

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

360
Mohit Deshpande

Die aktuelle Konfiguration zur Bestimmung der abzurufenden Ressourcen ist im Configuration-Objekt der Ressourcen verfügbar:

getResources().getConfiguration().orientation;

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

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

Weitere Informationen finden Sie im Android Developer .

588
hackbod

Wenn Sie die getResources (). GetConfiguration (). -Orientierung auf einigen Geräten verwenden, wird dies falsch sein. Wir haben diesen Ansatz anfangs in http://apphance.com verwendet. Dank der Remote-Protokollierung von Apphance konnten wir es auf verschiedenen Geräten sehen und wir haben gesehen, dass die Fragmentierung hier eine Rolle spielt. Ich habe seltsame Fälle gesehen: Zum Beispiel abwechselnd Portrait und Square (?!) 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 (es wird vom Window Manager verwendet, also sollte es besser sein). Ich würde sagen, dass die beste Idee ist, die Breite/Höhe IMMER zu überprüfen. 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 (Landschaft) oder ob sie gleich ist (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;
}
167
Jarek Potiuk

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 zu setzen.

Erstellen Sie die Datei layouts.xml in den Ordnern res/values-land und res/values-port mit 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 nun wie folgt auf die aktuelle Ausrichtung zugreifen:

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

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

    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

46

Hier ist eine Code-Snippet-Demo, wie man die Bildschirmausrichtung von hackbod und Martijn empfahl:

❶ Auslösen bei Änderung der Orientierung:

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

❷ Aktuelle Orientierung als hackbod recommend:

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

❸Es gibt eine alternative Lösung für die aktuelle Bildschirmausrichtung. ❷ follow Martijn solution:

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

Hinweis: Ich habe versucht, beide implementieren ❷ & ❸, aber bei RealDevice (NexusOne SDK 2.3) Orientierung wird die falsche Ausrichtung zurückgegeben.

★ Also ich empfohlene Lösung verwenden ❷ um die Bildschirmausrichtung zu erhalten, die mehr Vorteile bietet: klar, einfach und arbeiten wie ein Zauber. 

★ Überprüfen Sie sorgfältig die Ausrichtung, um sicherzustellen, dass sie korrekt ist (erwartet, abhängig von den Spezifikationen der physischen Geräte)

Hoffe es hilft,

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

Verwenden Sie getResources().getConfiguration().orientation, es ist der richtige Weg.

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

Immer noch nicht verstehen, wie das geht.

13
neteinstein

Es ist einige Zeit vergangen, seit die meisten dieser Antworten veröffentlicht wurden, und einige verwenden nun 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_SQUARE nicht mehr unterstützt wird.

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

11
Baz

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

Es gibt eine weitere Möglichkeit, dies zu tun:

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

Das Android SDK kann Ihnen dies gut sagen:

getResources().getConfiguration().orientation
4

ich denke, die Verwendung von getRotationv () hilft nicht, weil http://developer.Android.com/reference/Android/view/Display.html#getRotation%28%29 getRotation () Gibt die Drehung des Bildschirms aus seiner "natürlichen" Ausrichtung zurück.

wenn Sie also nicht die "natürliche" Orientierung kennen, ist Rotation sinnlos.

ich habe einen leichteren 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?

2
steveh

Ich denke, dass dieser Code funktionieren kann, nachdem die Orientierungsänderung wirksam geworden ist

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

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

2
Daniel

Getestet im Jahr 2019 auf API 28, unabhängig davon, ob der Benutzer Hochformat eingestellt hat oder nicht, und mit minimalem Code im Vergleich zu einer anderen, veralteten Antwort liefert Folgendes 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;
}
2
ManuelTS

dies ist eine Überlagerung aller Telefone wie oneplus3

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

rechter 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;
    }
1
yueyue_projects

Simpel und einfach :)

  1. Erstellen Sie 2 XML-Layouts (d. H. Portrait und Landscape).
  2. In der Java-Datei schreiben Sie:

    private int intOrientation;
    

    bei onCreate-Methode und vor setContentView schreiben:

    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.
    
1
Kerelos

Ich finde diese Lösung einfach

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

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 den Oriantion

1
user5037478

Alte Post, die ich kenne. Was auch immer die Ausrichtung sein mag oder vertauscht ist usw. Ich habe diese Funktion entwickelt, mit der das Gerät in die richtige Ausrichtung gebracht wird, ohne dass man wissen muss, wie die Porträt- und Landschaftsmerkmale auf dem Gerät angeordnet 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!

1
Codebeat

es gibt viele Wege, 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
        }
1
Mehroz Munir

In der Aktivitätsdatei:

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

    private void checkOrientation(Configuration newConfig){
        // Checks the orientation of the screen
        if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
            Log.d(TAG, "Current Orientation : Landscape");
            // Your magic here for landscape mode          
        } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
            Log.d(TAG, "Current Orientation : Portrait");
            // Your magic here for portrait mode         
        }
    }

UND in der Manifest-Datei:

<activity Android:name=".ActivityName"
            Android:configChanges="orientation|screenSize">

Ich hoffe es hilft dir ..!

0
Viral Patel

Es ist auch erwähnenswert, dass es heutzutage weniger gute Gründe gibt, mit getResources().getConfiguration().orientation nach einer expliziten Ausrichtung zu suchen, wenn Sie dies aus Layoutgründen tun, da Multi-Window-Support , eingeführt in Android 7/API 24+, Ihre Layouts beeinträchtigen könnte ziemlich viel in beiden Richtungen. Es empfiehlt sich, die Verwendung von <ConstraintLayout> und alternativen Layouts in Abhängigkeit von der verfügbaren Breite oder Höhe zusammen mit anderen Tricks zu berücksichtigen, um zu bestimmen, welches Layout verwendet wird, z. das Vorhandensein oder Nicht-Vorhandensein bestimmter Fragmente an Ihre Aktivität.

0
qix

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

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