Periksa orientasi pada ponsel Android

Bagaimana saya bisa mengecek apakah ponsel Android dalam Landscape atau Portrait?

Konfigurasi saat ini, seperti yang digunakan untuk menentukan sumber daya yang akan diambil, tersedia dari objek Sumber Configuration:

getResources().getConfiguration().orientation;

Anda dapat memeriksa orientasi dengan melihat nilainya:

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

Informasi lebih lanjut dapat ditemukan di Pengembang Android .

Jika Anda menggunakan orientasi getResources (). GetConfiguration (). Pada beberapa perangkat, Anda akan salah. Kami menggunakan pendekatan itu pada awalnya di http://apphance.com . Berkat pendataan jarak jauh Apphance kami dapat melihatnya di perangkat yang berbeda dan kami melihat bahwa fragmentasi memainkan perannya di sini. Saya melihat kasus-kasus aneh: misalnya bergantian potret dan persegi (?!) di 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

atau tidak mengubah orientasi sama sekali:

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

Di sisi lain, lebar () dan tinggi () selalu benar (digunakan oleh manajer jendela, jadi seharusnya lebih baik). Saya akan mengatakan ide terbaik adalah melakukan pengecekan lebar / tinggi SELALU. Jika Anda berpikir tentang sesaat, inilah yang Anda inginkan - untuk mengetahui apakah lebar lebih kecil dari tinggi (potret), kebalikan (lanskap) atau jika sama (persegi).

Lalu turun ke kode sederhana ini:

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

Cara lain untuk memecahkan masalah ini adalah dengan tidak mengandalkan nilai pengembalian yang benar dari layar tetapi mengandalkan penyelesaian sumber daya Android.

Buat file layouts.xmldi folder res/values-landdan res/values-portdengan konten berikut:

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>

Dalam kode sumber Anda sekarang Anda dapat mengakses orientasi saat ini sebagai berikut:

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

Cara sepenuhnya menentukan orientasi ponsel saat ini:

    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

Berikut ini adalah cuplikan cuplikan kode cara mendapatkan orientasi layar direkomendasikan oleh hackbod dan Martijn :

❶ Pemicu saat mengubah Orientasi:

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

❷ Dapatkan orientasi saat ini sebagai rekomendasi hackbod :

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

❸Ada solusi alternatif untuk mendapatkan orientasi layar saat ini ❷ ikuti solusi Martijn :

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

★ Catatan : Saya sudah mencoba keduanya mengimplementasikan ❷ & ❸, tetapi pada RealDevice (NexusOne SDK 2.3) Orientasi mengembalikan orientasi yang salah.

★ Jadi saya sarankan untuk menggunakan solusi ❷ untuk mendapatkan orientasi layar yang memiliki lebih banyak keuntungan: jelas, sederhana dan bekerja seperti pesona.

★ Periksa kembali orientasi dengan hati-hati untuk memastikan benar seperti yang kami harapkan (Mungkin terbatas tergantung pada spesifikasi perangkat fisik)

Semoga ini bisa membantu,

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

Gunakan getResources().getConfiguration().orientationdengan cara yang benar.

Anda hanya harus waspada terhadap berbagai jenis lanskap, lanskap yang biasanya digunakan perangkat dan lainnya.

Masih tidak mengerti bagaimana cara mengaturnya.

Beberapa waktu telah berlalu sejak sebagian besar jawaban ini telah diposting dan beberapa menggunakan metode dan konstanta yang sudah tidak digunakan lagi.

Saya telah memperbarui kode Jarek untuk tidak menggunakan metode dan konstanta ini lagi:

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

Perhatikan bahwa mode Configuration.ORIENTATION_SQUAREini tidak didukung lagi.

Saya menemukan ini dapat diandalkan pada semua perangkat saya sudah mengujinya berbeda dengan metode yang menyarankan penggunaan getResources().getConfiguration().orientation

Periksa orientasi layar dalam runtime.

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

Ada satu cara lagi untuk melakukannya:

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

Android SDK dapat memberi tahu Anda ini dengan baik:

getResources().getConfiguration().orientation

Diuji pada 2019 pada API 28, terlepas dari pengguna telah menetapkan orientasi potret atau tidak, dan dengan kode minimal dibandingkan dengan yang lain, jawaban yang sudah ketinggalan zaman , yang berikut ini memberikan orientasi yang benar:

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

Saya pikir kode ini dapat berfungsi setelah perubahan orientasi berlaku

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

timpa Activity.onConfigurationChanged (Configuration newConfig) berfungsi dan gunakan newConfig, orientasi jika Anda ingin diberitahu tentang orientasi baru sebelum memanggil setContentView.

saya pikir menggunakan getRotationv () tidak membantu karena http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () Mengembalikan rotasi layar dari "alami" orientasi.

jadi kecuali Anda tahu orientasi "alami", rotasi tidak ada artinya.

saya menemukan cara yang lebih mudah,

  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

tolong beri tahu saya jika ada masalah dengan seseorang ini?

seperti ini overlay semua ponsel seperti oneplus3

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

kode yang benar sebagai berikut:

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

Posting lama saya tahu. Apa pun orientasi mungkin atau ditukar dll. Saya merancang fungsi ini yang digunakan untuk mengatur perangkat dalam orientasi yang benar tanpa perlu tahu bagaimana fitur potret dan lansekap diatur pada perangkat.

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

    }

Bekerja seperti pesona!

Gunakan cara ini,

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

dalam String Anda memiliki Oriantion

ada banyak cara untuk melakukan ini, kode ini berfungsi untuk saya

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

Saya pikir solusi ini mudah

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

Hanya dua kode baris sederhana

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

Sederhana dan mudah :)

1. Buat 2 xml layout (yaitu Potret dan Lanskap)

2. Di file java, tulis:

   private int intOrientation;

   di onCreatemetode dan sebelum setContentViewmenulis:

   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.

Perlu juga dicatat bahwa saat ini, ada alasan yang kurang bagus untuk memeriksa orientasi eksplisit dengan getResources().getConfiguration().orientationjika Anda melakukannya karena alasan tata letak, karena Dukungan Multi-Jendela yang diperkenalkan di Android 7 / API 24+ dapat mengacaukan tata letak Anda sedikit di kedua orientasi. Lebih baik untuk mempertimbangkan penggunaan <ConstraintLayout>, dan tata letak alternatif bergantung pada lebar atau tinggi yang tersedia , bersama dengan trik lain untuk menentukan tata letak mana yang sedang digunakan, misalnya ada atau tidaknya fragmen tertentu yang melekat pada Aktivitas Anda.

Anda dapat menggunakan ini (berdasarkan di sini ):

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