Android telefonda yönlendirmeyi kontrol edin

Android telefonun Yatay mı yoksa Dikey mi olduğunu nasıl kontrol edebilirim?

Hangi yapılandırmaların alınacağını belirlemek için kullanılan geçerli yapılandırma, Kaynaklar Configurationnesnesinde kullanılabilir:

getResources().getConfiguration().orientation;

Değerine bakarak yönelimi kontrol edebilirsiniz:

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

Daha fazla bilgi Android Geliştiricisinde bulunabilir .

Bazı cihazlarda getResources (). GetConfiguration (). Yönlendirmesini kullanırsanız yanlış anlarsınız. Bu yaklaşımı başlangıçta http://apphance.com adresinde kullandık . Apphance'ın uzaktan günlüğü sayesinde farklı cihazlarda görebiliyorduk ve parçalanmanın burada rol oynadığını gördük. Garip durumlar gördüm: örneğin, HTC Desire HD'de alternatif portre ve kare (?!):

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

veya hiç yön değiştirmeme:

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

Öte yandan, width () ve height () her zaman doğrudur (pencere yöneticisi tarafından kullanılır, bu yüzden daha iyi olmalıdır). En iyi fikir DAİMA genişlik / yükseklik kontrolü yapmak olduğunu söyleyebilirim. Bir anı düşünürseniz, tam olarak istediğiniz şey budur - genişliğin yükseklikten (portre), tersinin (manzara) veya aynı (kare) olup olmadığını bilmek.

Sonra bu basit koda gelir:

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

Bu sorunu çözmenin başka bir yolu, ekrandan doğru dönüş değerine güvenmemek, ancak Android kaynaklarının çözümüne güvenmektir.

Dosyayı layouts.xmlklasörlerde res/values-landve res/values-portaşağıdaki içerikle oluşturun:

res / values-kara / layouts.xml:

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

res / değerler bağlantı / layouts.xml:

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

Kaynak kodunuzda şu anki yönlendirmeye şu şekilde erişebilirsiniz:

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

Telefonun geçerli yönünü belirtmenin tam yolu:

    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

İşte kod snippet demo hackbod ve Martijn tarafından ekran yönlendirme almak için nasıl önerildi :

Entation Yönü değiştirirken tetikleyin:

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

Ha Hackbod'un önerdiği şekilde mevcut yönlendirmeyi alın :

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

CurrentGeçerli ekran yönlendirmesi için alternatif çözüm solution Martijn çözümünü takip edin :

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

★ Not : Ben her iki uygulamak implement & try deneyin, ama RealDevice (NexusOne SDK 2.3) Oryantasyon yanlış yönü döndürür.

★ bu yüzden kullanılan çözüm tavsiye daha fazla avantaja sahip olan Ekran yönelimi elde : açıkça, basit ve bir cazibe gibi çalışmak.

★ Beklediğimiz gibi doğru olduğundan emin olmak için dikkatlice yön geri dönüşünü kontrol edin (fiziksel cihaz özelliklerine bağlı olarak sınırlı olabilir)

Umarım yardımcı olur,

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

kullanım getResources().getConfiguration().orientationDoğru yolu .

Sadece farklı manzara türlerine, cihazın normalde kullandığı manzaraya ve diğer manzaralara dikkat etmelisiniz.

Bunu nasıl yöneteceğinizi hala anlamıyorum.

Bu cevapların çoğunun yayınlanmasından bu yana biraz zaman geçti ve bazıları artık kullanımdan kaldırılmış yöntemler ve sabitler kullanıyor.

Jarek kodunu artık bu yöntemleri ve sabitleri kullanmayacak şekilde güncelledim :

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

Modun Configuration.ORIENTATION_SQUAREartık desteklenmediğini unutmayın .

Bunun, test ettiğim tüm cihazlarda güvenilir olduğunu gördüm. getResources().getConfiguration().orientation

Çalışma zamanında ekran yönünü kontrol edin.

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

Bunu yapmanın bir yolu daha var:

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 size bunun iyi olduğunu söyleyebilir:

getResources().getConfiguration().orientation

2019'da API 28'de test edildi, kullanıcının portre yönünü belirleyip belirlemediğine bakılmaksızın ve başka bir eski moda cevapla karşılaştırıldığında minimum kodla aşağıdakiler doğru yönlendirmeyi sağlar:

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

Yön değişikliği değiştikten sonra bu kod işe yarayabilir düşünüyorum

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

setContentView öğesini çağırmadan önce yeni yönlendirme hakkında bildirim almak istiyorsanız, Activity.onConfigurationChanged (Configuration newConfig) işlevini geçersiz kılın ve newConfig, orientation kullanın.

http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () "doğal" ekran döndürme döndürür çünkü getRotationv () kullanarak yardımcı olmadığını düşünüyorum oryantasyon.

"doğal" yönelimi bilmiyorsanız, rotasyon anlamsızdır.

daha kolay bir yol buldum,

  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

lütfen bana bununla ilgili bir sorun olup olmadığını söyle?

böyle bu oneplus3 gibi tüm telefonlar bindirme olduğunu

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

doğru kodu aşağıdaki gibi:

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

Eski yazı biliyorum. Yönelim ne olursa olsun veya değiştirilebiliyorsa vs.

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

    }

Tıkır tıkır çalışıyor!

Bu şekilde kullanın,

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

Dizede Oriantion var

Bunu yapmanın birçok yolu var, bu kod parçası benim için çalışıyor

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

Bence bu çözüm kolay

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

Sadece basit iki satır kodu

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

Basit ve kolay :)

1. 2 xml düzen (ör. Dikey ve Yatay) yapın

2. Java dosyasına şunu yazın:

   private int intOrientation;

   En onCreateyöntemle ve daha önce setContentViewyazma:

   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.

Ayrıca, günümüzde, Android 7 / API 24+'da tanıtılan Çoklu Pencere Desteği , düzenlerinizle biraz karışıklık yaratabileceğinden getResources().getConfiguration().orientation, düzen nedenleriyle bunu yapıyorsanız açık yönelimi kontrol etmek için daha az iyi bir neden olduğunu belirtmek gerekir. oryantasyon. Daha iyi kullanmayı düşünün ve alternatif düzeni mevcuttur genişlik ve yükseklikte bağımlı sizin Aktivite bağlanmış olan belirli Fragmanlar örneğin kullanılmakta olduğu düzen varlığını belirlemek için başka püf noktaları ile birlikte ya da değil.<ConstraintLayout>

Bunu ( buraya göre ) kullanabilirsiniz:

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