Android'de ekran boyutları piksel olarak nasıl alınır

Bazı özel öğeler oluşturdum ve bunları programlı olarak sağ üst köşeye yerleştirmek istiyorum ( nüst kenardan mpikseller ve sağ kenardan pikseller). Bu nedenle ekran genişliğini ve ekran yüksekliğini almam ve daha sonra konumu ayarlamam gerekiyor:

int px = screenWidth - m;
int py = screenHeight - n;

Nasıl alırım screenWidthve screenHeightana Aktivite içinde?

Ekran boyutlarını piksel cinsinden istiyorsanız aşağıdakileri kullanabilirsiniz getSize:

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Bir oturumda değilseniz Activity, varsayılanı Displayşuradan alabilirsiniz WINDOW_SERVICE:

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Eğer bir parça içinde ve bunu başarmak istiyorsanız sadece Activity.WindowManager (Xamarin.Android) veya getActivity (). GetWindowManager () (java) kullanın.

Daha önce getSizetanıtıldı (API düzey 13'te), artık kullanımdan kaldırılmış olan getWidthve getHeightyöntemlerini kullanabilirsiniz :

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

Bununla birlikte, tanımladığınız kullanım durumunda, mizanpajdaki bir kenar boşluğu / dolgu daha uygun görünür.

Başka bir yol: DisplayMetrics

Bir ekran hakkında boyutu, yoğunluğu ve yazı tipi ölçeklendirmesi gibi genel bilgileri tanımlayan bir yapı. DisplayMetrics üyelerine erişmek için aşağıdaki gibi bir nesne başlatın:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Aşağıdakilerle ilgili widthPixelsbilgi almak için kullanabiliriz :

Msgstr "Ekranın piksel cinsinden mutlak genişliği."

Misal:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

Bunun bir yolu:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();
int height = display.getHeight();

Kullanımdan kaldırılmıştır ve bunun yerine aşağıdaki kodu denemeniz gerekir. İlk iki kod satırı size DisplayMetricsobjeleri verir . Bu nesneler aşağıdaki alanları içerir:heightPixels , widthPixels.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

int height = metrics.heightPixels;
int width = metrics.widthPixels;

Sorunuza cevap vermeyebilir, ancak bir Görünümün boyutuna ihtiyacınız varsa ancak düzeniniz henüz düzenlenmediğinde kodunuzun yürütüldüğünü bilmek (bu soruya geldiğimde kendimi arıyordum) bilmek yararlı olabilir. (örneğin içinde onCreate()) ViewTreeObserver.OnGlobalLayoutListenerile bir ayar yapabilir View.getViewTreeObserver().addOnGlobalLayoutListener()ve görünümün boyutuna ihtiyaç duyan ilgili kodu oraya koyabilirsiniz. Düzen düzenlendiğinde dinleyicinin geri çağrısı çağrılacaktır.

(2012 yanıtı, güncel olmayabilir) Petek öncesi desteği desteklemek istiyorsanız, API 13'ten önce geriye dönük uyumluluk koymanız gerekir.

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Tabii ki kullanımdan kaldırılan yöntemler en son SDK'lardan çıkartılacak, ancak Android 2.1, 2.2 ve 2.3'e sahip olan kullanıcılarımızın çoğuna güvenirken, geride kaldığımız şey bu.

Tüm olası "çözümleri" başarısız bir şekilde denedim ve Elliott Hughes'un "Dalvik Explorer" uygulamasının herhangi bir Android cihaz / OS sürümünde her zaman doğru boyutu gösterdiğini fark ettim. Burada bulunan açık kaynak projesine baktım: https://code.google.com/p/enh/

İlgili tüm kodlar:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

EDIT: biraz geliştirilmiş sürüm (desteklenmeyen işletim sistemi sürümünde istisnaları tetiklemekten kaçının):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

En basit yol:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 

Android cihazlar için durum çubuğunun yüksekliğine erişmek için, bunu almanın programlı bir yolunu tercih ediyoruz:

Basit kod

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

Değişken result pikseldeki yüksekliği verir.

Hızlı erişim için

Yüksekliği hakkında daha fazla bilgi için Title bar, Navigation barve Content Viewüzerinde, nazik bir görünüm Android Cihaz Ekran Boyutları .

Önce görünümü alın (örn. İlefindViewById() ) ve sonra görünümün kendisinde getWidth () öğesini kullanabilirsiniz .

Biri bağlamı göndermek ve diğeri piksel cinsinden yükseklik ve genişlik almak için iki işlevi var:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

ve

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}

XML kullanarak dinamik ölçeklendirme için "android: layout_weight" adı verilen bir özellik var

Aşağıdaki örnek, bu iş parçacığında synic'in yanıtından değiştirilerek , ekranın% 75'ini (ağırlık = .25) alan bir düğme ve ekranın kalan% 25'ini (ağırlık = .75) alan bir metin görünümünü gösterir.

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>

Bu görev için kullandığım kod:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

Yeterince temiz görünüyor ve henüz kullanımdan kaldırılıyor.

Bu daha iyi bir çözüm değil mi? DisplayMetrics , ihtiyacınız olan her şeyle birlikte gelir ve API 1'den çalışır.

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

Ayrıca getRealMetrics yazılımını kullanarak gerçek ekranı da (Durum Çubuğu veya yazılım gezinme çubuğu gibi ekran dekorları dahil) alabilirsiniz , ancak bu yalnızca 17'den fazla sürümde çalışır.

Bir şey mi kaçırıyorum?

Sadece Francesco'nun cevabına ekliyoruz. Penceredeki konumu veya ekrandaki konumu bulmak istiyorsanız, daha uygun olan diğer gözlemci ViewTreeObserver.OnPreDrawListener () 'dır.

Bu aynı zamanda onCreate () zamanında çoğunlukla bilinmeyen bir görünümün, örneğin kaydırılan konum, ölçeklendirilmiş konum gibi diğer niteliklerini bulmak için de kullanılabilir.

Etkinlik'te aşağıdaki kodu kullanarak.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

Ekranın genişliğini ve yüksekliğini bulun:

width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();

Bunu kullanarak, en son ve üstü SDK 13'ü alabiliriz.

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}

DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Bunun hile yaptığını buldum.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

Söylemeniz gerekir, eğer değilseniz Activity, ancak kapsamınızda Viewdeğişken Viewtürü varsa, kullanmaya gerek yoktur.WINDOW_SERVICE . Sonra en az iki yol kullanabilirsiniz.

İlk:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

İkinci:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

Burada dediğimiz tüm bu yöntemler kullanımdan kaldırılmamıştır.

public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}

Ekran boyutlarını almak için ekran metriklerini kullanın

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

Yüksekliği ve genişliği piksel olarak alın

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;

Bu, OP'nin ekran boyutlarını gerçek piksellerde istediği için bir cevap değil. Boyutları "cihazdan bağımsız piksellerde" istedim ve buradan cevapları bir araya getirerek https://stackoverflow.com/a/17880012/253938 ve burada https://stackoverflow.com/a/6656774/253938 geldi Bununla:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);

Yükseklik boyutunu kullanarak şunları yapabilirsiniz :

getResources().getDisplayMetrics().heightPixels;

ve genişlik boyutu

getResources().getDisplayMetrics().widthPixels; 

Deneme / yakalama dağınıklığını önleyen DisplayMetrics (API 1) kullanarak bunu yapmanın kullanımdan kaldırılmış bir yolu vardır:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;

GetSize kodunu şu şekilde sararım:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}

Durum Çubuğu ve İşlem Çubuğu olmadan kullanılabilir ekran boyutunu arayanlar için (ayrıca Swapnil'in cevabı sayesinde):

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}

Önce XML dosyasını yükleyin ve ardından şu kodu yazın:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

Ekran çözünürlüğünüze göre genişliği ve yüksekliği gösterin.

Aşağıdaki yöntemleri uygulayın:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}

Kotlin

fun getScreenHeight(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.heightPixels
}

fun getScreenWidth(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.widthPixels
}

Bir etkinliğin onCreate'indeyken bir mizanpaj için kullanılabilir alanın kesin boyutlarını bilmeniz gereken zamanlar vardır. Bazıları düşündükten sonra bu şekilde çalıştım.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

Herhangi bir nedenle Android bildirimine başka bir etkinlik eklemek istemiyorsanız, bunu şu şekilde yapabilirsiniz:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    

WindowManager'ların, Noktaların veya Ekranların ek yükünü istemiyorsanız, yüksekliği ve genişliği match_parent olarak ayarlanmışsa, XML'inizdeki en üstteki Görünüm öğesinin yükseklik ve genişlik niteliklerini alabilirsiniz. (Bu, mizanpajınız tüm ekranı kapladığı sürece geçerlidir.)

Örneğin, XML'iniz böyle bir şeyle başlıyorsa:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

Sonra findViewById(R.id.entireLayout).getWidth()ekranın genişliğini findViewById(R.id.entireLayout).getHeight()döndürür ve ekranın yüksekliğini döndürür.