Cách lấy kích thước màn hình dưới dạng pixel trong Android

Tôi đã tạo một số thành phần tùy chỉnh và tôi muốn lập trình chúng ở góc trên bên phải ( npixel từ cạnh trên và mpixel từ cạnh phải). Do đó, tôi cần lấy chiều rộng màn hình và chiều cao màn hình rồi đặt vị trí:

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

Làm thế nào để tôi có được screenWidthvà screenHeighttrong Hoạt động chính?

Nếu bạn muốn kích thước hiển thị bằng pixel, bạn có thể sử dụng getSize:

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

Nếu bạn không ở trong một Activitybạn có thể lấy mặc định Displayqua WINDOW_SERVICE:

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

Nếu bạn đang ở trong một đoạn và muốn hoàn thành việc này, chỉ cần sử dụng Activity.WindowManager (trong Xamarin.Android) hoặc getActivity (). GetWindowManager () (trong java).

Trước khi getSizeđược giới thiệu (trong API cấp 13), bạn có thể sử dụng getWidthvà getHeightcác phương thức hiện không dùng nữa:

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

Đối với trường hợp sử dụng mà bạn mô tả, tuy nhiên, phần lề / phần đệm trong bố cục có vẻ phù hợp hơn.

Một cách khác là: DisplayMetrics

Một cấu trúc mô tả thông tin chung về màn hình, chẳng hạn như kích thước, mật độ và tỷ lệ phông chữ của nó. Để truy cập các thành viên DisplayMetrics, hãy khởi tạo một đối tượng như thế này:

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

Chúng tôi có thể sử dụng widthPixelsđể có được thông tin cho:

"Độ rộng tuyệt đối của màn hình tính bằng pixel."

Thí dụ:

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

Một cách là:

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

Nó không được dùng nữa và thay vào đó bạn nên thử đoạn mã sau. Hai dòng mã đầu tiên cung cấp cho bạn các DisplayMetricsobjecs. Đối tượng này chứa các trường như heightPixels, widthPixels.

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

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

Nó có thể không trả lời câu hỏi của bạn, nhưng có thể hữu ích khi biết (tôi đã tự tìm kiếm câu hỏi này khi tôi đến câu hỏi này) rằng nếu bạn cần kích thước của Chế độ xem nhưng mã của bạn đang được thực thi khi bố cục của nó chưa được đặt ra (ví dụ như trong onCreate()), bạn có thể thiết lập một ViewTreeObserver.OnGlobalLayoutListenervới View.getViewTreeObserver().addOnGlobalLayoutListener()và đặt mã có liên quan mà cần chiều của quan điểm đó. Cuộc gọi lại của người nghe sẽ được gọi khi bố trí sẽ được đặt ra.

(Câu trả lời năm 2012, có thể đã hết hạn) Nếu bạn muốn hỗ trợ trước Honeycomb, bạn sẽ cần đặt khả năng tương thích ngược trước API 13. Một cái gì đó như:

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

Tất nhiên, các phương thức không dùng nữa cuối cùng sẽ được đưa ra khỏi SDK gần đây nhất, nhưng mặc dù chúng tôi vẫn dựa vào hầu hết người dùng có Android 2.1, 2.2 và 2.3, đây là những gì chúng tôi còn lại.

Tôi đã thử tất cả các "giải pháp" có thể không thành công và tôi nhận thấy rằng ứng dụng "Dalvik Explorer" của Elliott Hughes luôn hiển thị kích thước chính xác trên bất kỳ phiên bản thiết bị / HĐH Android nào. Cuối cùng tôi đã xem xét dự án nguồn mở của anh ấy có thể tìm thấy ở đây: https://code.google.com.vn/p/enh/

Đây là tất cả các mã có liên quan:

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: phiên bản cải tiến nhẹ (tránh bắn ngoại lệ trên phiên bản HĐH không được hỗ trợ):

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

Cách đơn giản nhất:

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

Để truy cập chiều cao của thanh trạng thái cho thiết bị Android, chúng tôi thích cách lập trình hơn để có được nó:

Mã mẫu

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

Biến resultcho chiều cao trong pixel.

Để truy cập nhanh

Để biết thêm thông tin về chiều cao của Title bar, Navigation barvà Content View, nhìn vui lòng vào Android màn hình thiết bị kích cỡ .

Trước tiên hãy xem (ví dụ: bởi findViewById()) và sau đó bạn có thể sử dụng getWidth () trên chính chế độ xem.

Tôi có hai chức năng, một để gửi bối cảnh và chức năng khác nhận chiều cao và chiều rộng tính bằng pixel:

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

và

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

Để mở rộng quy mô bằng cách sử dụng XML, có một thuộc tính được gọi là "android: layout_ weight"

Ví dụ dưới đây, được sửa đổi từ phản hồi của synic trên chuỗi này , hiển thị nút chiếm 75% màn hình (weight = 0,25) và chế độ xem văn bản chiếm 25% còn lại của màn hình (weight = 0,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>

Đây là mã tôi sử dụng cho nhiệm vụ:

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

Có vẻ đủ sạch và chưa, chăm sóc sự phản đối.

Đây không phải là một giải pháp tốt hơn nhiều sao? DisplayMetrics đi kèm với mọi thứ bạn cần và hoạt động từ 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;
}

Bạn cũng có thể có được màn hình thực tế (bao gồm cả kiểu dáng màn hình, chẳng hạn như Thanh trạng thái hoặc thanh điều hướng phần mềm) bằng cách sử dụng getRealMetrics , nhưng điều này chỉ hoạt động trên 17+.

Tui bỏ lỡ điều gì vậy?

Chỉ cần thêm vào câu trả lời của Francesco. Trình quan sát khác có nhiều apt hơn, nếu bạn muốn tìm ra vị trí trong cửa sổ hoặc vị trí trên màn hình là ViewTreeObserver.OnPreDrawListener ()

Điều này cũng có thể được sử dụng để tìm các thuộc tính khác của chế độ xem hầu như không xác định tại thời điểm onCreate (), ví dụ: vị trí cuộn, vị trí được chia tỷ lệ.

Sử dụng mã sau trong Hoạt động.

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

Tìm chiều rộng và chiều cao của màn hình:

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

Sử dụng điều này, chúng tôi có thể nhận được SDK 13 mới nhất và cao hơn.

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

Tôi tìm thấy điều này đã lừa

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

Cần phải nói rằng, nếu bạn không tham gia Activity, nhưng trong View(hoặc có biến Viewloại trong phạm vi của bạn), thì không cần sử dụngWINDOW_SERVICE . Sau đó, bạn có thể sử dụng ít nhất hai cách.

Đầu tiên:

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

Thứ hai:

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

Tất cả các phương pháp này chúng tôi gọi ở đây không được phản đối.

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

Để lấy kích thước màn hình, hãy sử dụng số liệu hiển thị

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

Lấy chiều cao và chiều rộng tính bằng pixel

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

Đây không phải là câu trả lời cho OP, vì anh muốn kích thước hiển thị bằng pixel thực. Tôi muốn kích thước trong "pixel độc lập với thiết bị" và tập hợp các câu trả lời từ đây https://stackoverflow.com/a/17880012/253938 và tại đây https://stackoverflow.com/a/6656774/253938 Tôi đã đưa ra Với cái này:

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

Bạn có thể lấy kích thước chiều cao bằng cách sử dụng:

getResources().getDisplayMetrics().heightPixels;

và kích thước chiều rộng bằng cách sử dụng

getResources().getDisplayMetrics().widthPixels; 

Có một cách không được chấp nhận để thực hiện việc này bằng DisplayMetrics (API 1), đó là tránh sự lộn xộn của thử / bắt:

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

Tôi sẽ bọc mã getSize như thế này:

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

Đối với những người đang tìm kiếm kích thước màn hình có thể sử dụng mà không có Thanh trạng thái và Thanh hành động (cũng nhờ câu trả lời của 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);
}

Đầu tiên tải tệp XML và sau đó viết mã này:

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

Hiển thị chiều rộng và chiều cao theo độ phân giải màn hình của bạn.

Thực hiện theo các phương pháp dưới đây:

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
}

Đôi khi bạn cần biết kích thước chính xác của không gian có sẵn cho bố cục khi trong onCreate của một hoạt động. Sau một số suy nghĩ, tôi đã làm việc theo cách này.

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

Nếu vì lý do nào đó bạn không muốn thêm một hoạt động khác vào bảng kê khai Android, bạn có thể thực hiện theo cách này:

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

Nếu bạn không muốn chi phí chung của WindowManager, Points hoặc Display, bạn có thể lấy các thuộc tính chiều cao và chiều rộng của mục View trên cùng trong XML của mình, miễn là chiều cao và chiều rộng của nó được đặt thành match_parent. (Điều này đúng miễn là bố cục của bạn chiếm toàn bộ màn hình.)

Ví dụ: nếu XML của bạn bắt đầu bằng thứ gì đó như thế này:

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

Sau đó findViewById(R.id.entireLayout).getWidth()sẽ trả về chiều rộng của màn hình và findViewById(R.id.entireLayout).getHeight()sẽ trả về chiều cao của màn hình.