Controlla l'orientamento sul telefono Android

Come posso verificare se il telefono Android è in orizzontale o verticale?

La configurazione corrente, utilizzata per determinare quali risorse recuperare, è disponibile dall'oggetto Risorse Configuration:

getResources().getConfiguration().orientation;

Puoi verificare l'orientamento osservando il suo valore:

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

Ulteriori informazioni sono disponibili nello sviluppatore Android .

Se usi l'orientamento di getResources (). GetConfiguration (). Su alcuni dispositivi, lo sbaglierai. Inizialmente abbiamo utilizzato questo approccio su http://apphance.com . Grazie alla registrazione remota di Apphance abbiamo potuto vederlo su diversi dispositivi e abbiamo visto che la frammentazione gioca il suo ruolo qui. Ho visto casi strani: ad esempio alternando ritratto e quadrato (?!) su 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

o non cambiare affatto l'orientamento:

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

D'altra parte, width () e height () sono sempre corretti (è usato dal gestore delle finestre, quindi dovrebbe essere meglio). Direi che l'idea migliore è quella di fare SEMPRE la larghezza / altezza. Se pensi a un momento, questo è esattamente ciò che vuoi: sapere se la larghezza è inferiore all'altezza (ritratto), l'opposto (paesaggio) o se sono uguali (quadrati).

Quindi arriva a questo semplice codice:

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

Un altro modo di risolvere questo problema è non basarsi sul valore di ritorno corretto dal display ma fare affidamento sulla risoluzione delle risorse Android.

Crea il file layouts.xmlnelle cartelle res/values-lande res/values-portcon il seguente contenuto:

res / valori-terra / layouts.xml:

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

res / valori-port / layouts.xml:

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

Nel tuo codice sorgente ora puoi accedere all'orientamento corrente come segue:

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

Un modo completo per specificare l'orientamento corrente del telefono:

    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

Ecco la demo dello snippet di codice su come ottenere l'orientamento dello schermo consigliato da hackbod e Martijn :

❶ Attiva quando cambia orientamento:

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

❷ Ottieni l'orientamento attuale come consiglia hackbod :

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

❸ Esistono soluzioni alternative per ottenere l'orientamento attuale dello schermo ❷ seguire la soluzione Martijn :

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

★ Nota : ho provato entrambi a implementare ❷ & ❸, ma su RealDevice (NexusOne SDK 2.3) Orientamento restituisce l'orientamento errato.

★ Quindi consiglio di utilizzare la soluzione ❷ per ottenere l'orientamento dello schermo che ha più vantaggi: chiaramente, semplice e funziona come un fascino.

★ Controlla attentamente il ritorno dell'orientamento per assicurarti che sia corretto come previsto (potrebbe essere limitato a seconda delle specifiche dei dispositivi fisici)

Spero che ti aiuti

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

Usa getResources().getConfiguration().orientationè nel modo giusto.

Devi solo fare attenzione ai diversi tipi di paesaggi, il paesaggio che il dispositivo utilizza normalmente e l'altro.

Ancora non capisco come gestirlo.

È passato del tempo da quando sono state pubblicate la maggior parte di queste risposte e alcune utilizzano metodi e costanti ormai obsoleti.

Ho aggiornato il codice di Jarek per non utilizzare più questi metodi e costanti:

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

Si noti che la modalità Configuration.ORIENTATION_SQUAREnon è più supportata.

Ho trovato questo affidabile su tutti i dispositivi su cui l'ho testato in contrasto con il metodo che suggerisce l'utilizzo di getResources().getConfiguration().orientation

Controlla l'orientamento dello schermo in fase di esecuzione.

@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();        
    }
}

C'è un altro modo per farlo:

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

L'SDK di Android può dirti bene:

getResources().getConfiguration().orientation

Testato nel 2019 su API 28, indipendentemente dal fatto che l'utente abbia impostato o meno l'orientamento verticale e con un codice minimo rispetto a un'altra risposta obsoleta , quanto segue offre l'orientamento corretto:

/** @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;
}

Penso che questo codice potrebbe funzionare dopo che il cambiamento di orientamento ha avuto effetto

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

sovrascrivere la funzione Activity.onConfigurationChanged (Configurazione newConfig) e utilizzare newConfig, orientamento se si desidera ricevere una notifica sul nuovo orientamento prima di chiamare setContentView.

penso che usare getRotationv () non sia d'aiuto perché http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () Restituisce la rotazione dello schermo dal suo "naturale" orientamento.

quindi, a meno che non si conosca l'orientamento "naturale", la rotazione non ha senso.

ho trovato un modo più semplice,

  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

per favore dimmi se c'è un problema con questo qualcuno?

tale si sovrappone a tutti i telefoni come oneplus3

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

codice giusto come segue:

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

Vecchio post lo so. Qualunque sia l'orientamento può essere o viene scambiato, ecc. Ho progettato questa funzione che viene utilizzata per impostare il dispositivo nell'orientamento corretto senza la necessità di sapere come sono organizzate le caratteristiche del ritratto e del paesaggio sul dispositivo.

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

    }

Funziona come un fascino!

Usa in questo modo,

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

nella corda hai l'Oriantion

ci sono molti modi per farlo, questo pezzo di codice funziona per me

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

Penso che questa soluzione sia facile

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

Solo un semplice codice a due righe

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

Semplice e facile :)

1. Crea 2 layout xml (ovvero verticale e orizzontale)

2. Nel file java, scrivi:

   private int intOrientation;

   al onCreatemetodo e prima di setContentViewscrivere:

   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.

Vale anche la pena notare che al giorno d'oggi, ci sono meno buone ragioni per verificare l'orientamento esplicito con getResources().getConfiguration().orientationse lo stai facendo per motivi di layout, poiché il supporto multi-finestra introdotto in Android 7 / API 24+ potrebbe rovinare un po 'i tuoi layout in entrambi orientamento. Meglio considerare l'utilizzo <ConstraintLayout>e i layout alternativi che dipendono dalla larghezza o dall'altezza disponibili , insieme ad altri trucchi per determinare quale layout viene utilizzato, ad esempio la presenza o meno di determinati frammenti attaccati alla tua attività.

Puoi usarlo (basato su qui ):

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