Cara mendapatkan dimensi layar sebagai piksel di Android

Saya membuat beberapa elemen khusus, dan saya ingin secara terprogram menempatkannya di sudut kanan atas ( npiksel dari tepi atas dan mpiksel dari tepi kanan). Karena itu saya perlu mendapatkan lebar layar dan tinggi layar dan kemudian mengatur posisi:

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

Bagaimana saya mendapatkan screenWidthdan screenHeightdalam Kegiatan utama?

Jika Anda ingin dimensi tampilan dalam piksel, Anda dapat menggunakan getSize:

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

Jika Anda tidak dalam, ActivityAnda bisa mendapatkan default Displaymelalui WINDOW_SERVICE:

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

Jika Anda berada dalam fragmen dan ingin menyelesaikan ini cukup gunakan Activity.WindowManager (di Xamarin.Android) atau getActivity (). GetWindowManager () (dalam java).

Sebelum getSizediperkenalkan (di API level 13), Anda bisa menggunakan getWidthdan getHeightmetode yang sudah usang:

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

Namun untuk kasus penggunaan yang Anda gambarkan, margin / padding di tata letak tampaknya lebih tepat.

Cara lain adalah: DisplayMetrics

Struktur yang menjelaskan informasi umum tentang tampilan, seperti ukurannya, kerapatan, dan penskalaan font. Untuk mengakses anggota DisplayMetrics, inisialisasi objek seperti ini:

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

Kita dapat menggunakan widthPixelsuntuk mendapatkan informasi untuk:

"Lebar absolut layar dalam piksel."

Contoh:

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

Salah satu caranya adalah:

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

Itu sudah usang, dan Anda harus mencoba kode berikut sebagai gantinya. Dua baris kode pertama memberi Anda DisplayMetricsobjek. Benda ini berisi bidang-bidang seperti heightPixels, widthPixels.

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

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

Mungkin tidak menjawab pertanyaan Anda, tetapi mungkin berguna untuk mengetahui (saya mencari sendiri ketika saya sampai pada pertanyaan ini) bahwa jika Anda memerlukan dimensi Tampilan tetapi kode Anda sedang dieksekusi ketika tata letaknya belum ditata (misalnya dalam onCreate()) Anda dapat mengatur ViewTreeObserver.OnGlobalLayoutListenerdengan View.getViewTreeObserver().addOnGlobalLayoutListener()dan memasukkan kode yang relevan yang membutuhkan dimensi tampilan di sana. Callback pendengar akan dipanggil ketika tata letak akan ditata.

(Jawaban 2012, mungkin kedaluwarsa) Jika Anda ingin mendukung pra Honeycomb, Anda harus memasukkan kompatibilitas sebelum API 13. Sesuatu seperti:

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

Tentu saja metode yang sudah usang pada akhirnya akan dikeluarkan dari SDK terbaru, tetapi sementara kami masih mengandalkan sebagian besar pengguna kami yang memiliki Android 2.1, 2.2 dan 2.3, inilah yang tersisa.

Saya telah mencoba semua "solusi" yang mungkin gagal dan saya perhatikan bahwa aplikasi "Dalvik Explorer" Elliott Hughes selalu menunjukkan dimensi yang benar pada perangkat Android / versi OS. Saya akhirnya melihat proyek open source-nya yang dapat ditemukan di sini: https://code.google.com/p/enh/

Inilah semua kode yang relevan:

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: versi yang sedikit ditingkatkan (hindari pengecualian menembak pada versi OS yang tidak didukung):

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

Cara termudah:

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

Untuk mengakses ketinggian bilah status untuk perangkat Android, kami lebih memilih cara terprogram untuk mendapatkannya:

Kode sampel

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

Variabel resultmemberikan tinggi dalam piksel.

Untuk akses cepat

Untuk informasi lebih lanjut tentang ketinggian Title bar, Navigation bardan Content View, silakan lihat Ukuran Layar Perangkat Android .

Pertama dapatkan view (mis. Oleh findViewById()) dan kemudian Anda bisa menggunakan getWidth () pada view itu sendiri.

Saya memiliki dua fungsi, satu untuk mengirim konteks dan yang lainnya mendapatkan tinggi dan lebar dalam piksel:

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

dan

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

Untuk penskalaan dinamis menggunakan XML ada atribut yang disebut "android: layout_weight"

Contoh di bawah ini, yang dimodifikasi dari respons synic pada utas ini , memperlihatkan tombol yang mengambil 75% layar (bobot = .25) dan tampilan teks mengambil 25% layar yang tersisa (bobot = .75).

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

Ini adalah kode yang saya gunakan untuk tugas:

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

Tampak cukup bersih, namun tetap harus menjaga penghinaan.

Bukankah ini solusi yang jauh lebih baik? DisplayMetrics hadir dengan semua yang Anda butuhkan dan berfungsi dari API 1.

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

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

Anda juga bisa mendapatkan tampilan aktual (termasuk dekorasi layar, seperti Bilah Status atau bilah navigasi perangkat lunak) menggunakan getRealMetrics , tetapi ini hanya berfungsi pada 17+ saja.

Apakah saya melewatkan sesuatu?

Hanya menambah jawaban Francesco. Pengamat lain yang lebih tepat, jika Anda ingin mengetahui lokasi di jendela atau lokasi di layar adalah ViewTreeObserver.OnPreDrawListener ()

Ini juga dapat digunakan untuk menemukan atribut lain dari tampilan yang sebagian besar tidak diketahui pada waktu onCreate () misalnya posisi yang digulir, posisi yang diskalakan.

Menggunakan kode berikut dalam Aktivitas.

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

Temukan lebar dan tinggi layar:

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

Dengan ini, kita bisa mendapatkan SDK 13 terbaru dan di atas.

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

Saya menemukan ini berhasil.

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

Perlu dikatakan, bahwa jika Anda tidak berada di Activity, tetapi di View(atau memiliki variabel Viewtipe dalam cakupan Anda), tidak perlu digunakan WINDOW_SERVICE. Maka Anda dapat menggunakan setidaknya dua cara.

Pertama:

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

Kedua:

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

Semua metode yang kami sebut di sini tidak usang.

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

Untuk mendapatkan dimensi layar gunakan metrik tampilan

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

Dapatkan tinggi dan lebar dalam piksel

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

Ini bukan jawaban untuk OP, karena ia ingin dimensi tampilan dalam piksel nyata. Saya ingin dimensi dalam "perangkat-independen-piksel", dan menyusun jawaban dari sini https://stackoverflow.com/a/17880012/253938 dan di sini https://stackoverflow.com/a/6656774/253938 saya datang dengan ini:

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

Anda bisa mendapatkan ukuran tinggi menggunakan:

getResources().getDisplayMetrics().heightPixels;

dan ukuran lebar menggunakan

getResources().getDisplayMetrics().widthPixels; 

Ada cara non-usang untuk melakukan ini menggunakan DisplayMetrics (API 1), yang menghindari kekacauan mencoba / menangkap:

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

Saya akan membungkus kode getSize seperti ini:

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

Untuk yang mencari dimensi layar yang dapat digunakan tanpa Bilah Status dan Bilah Tindakan (juga berkat jawaban Swapnil):

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

Pertama-tama muat file XML dan kemudian tulis kode ini:

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

Tampilkan lebar dan tinggi sesuai resolusi layar Anda.

Ikuti metode di bawah ini:

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
}

Ada kalanya Anda perlu mengetahui dimensi tepat ruang yang tersedia untuk tata letak saat berada di aktivitas onCreate. Setelah beberapa pemikiran saya berhasil dengan cara ini.

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

Jika karena alasan tertentu Anda tidak ingin menambahkan aktivitas lain ke manifes Android, Anda dapat melakukannya dengan cara ini:

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

Jika Anda tidak ingin overhead WindowManagers, Points, atau Display, Anda dapat mengambil atribut tinggi dan lebar dari item View paling atas di XML Anda, asalkan tinggi dan lebarnya diatur ke match_parent. (Ini berlaku selama tata letak Anda memenuhi seluruh layar.)

Misalnya, jika XML Anda dimulai dengan sesuatu seperti ini:

<?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" >

Kemudian findViewById(R.id.entireLayout).getWidth()akan mengembalikan lebar layar dan findViewById(R.id.entireLayout).getHeight()akan mengembalikan tinggi layar.