Làm cách nào để xác định độ rộng màn hình theo dp hoặc nhúng khi chạy trong Android?

Tôi cần mã hóa bố cục của các widget Android bằng cách sử dụng dip / dp (trong các tệp java). Trong thời gian chạy nếu tôi mã ,

int pixel=this.getWindowManager().getDefaultDisplay().getWidth();

cái này trả về chiều rộng màn hình tính bằng pixel (px). Để chuyển đổi nó thành dp, tôi đã mã hóa:

int dp =pixel/(int)getResources().getDisplayMetrics().density ;

Điều này dường như không trả lời đúng. Tôi đã tạo trình giả lập của WVGA800 có độ phân giải màn hình là 480 x 800. Khi chạy trình giả lập và để mã in các giá trị của pixel và dp, nó đã lên tới 320 ở cả hai. Trình giả lập này là 240 dpi với hệ số tỷ lệ sẽ là 0,75.

Thử cái này

Display display = getWindowManager().getDefaultDisplay();
DisplayMetrics outMetrics = new DisplayMetrics ();
display.getMetrics(outMetrics);

float density  = getResources().getDisplayMetrics().density;
float dpHeight = outMetrics.heightPixels / density;
float dpWidth  = outMetrics.widthPixels / density;

HOẶC LÀ

Cảm ơn @ Tomáš Hubálek

DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();    
float dpHeight = displayMetrics.heightPixels / displayMetrics.density;
float dpWidth = displayMetrics.widthPixels / displayMetrics.density;

Tôi vấp phải câu hỏi này từ Google và sau đó tôi đã tìm thấy một giải pháp dễ dàng hợp lệ cho API> = 13.

Để tham khảo trong tương lai:

Configuration configuration = yourActivity.getResources().getConfiguration();
int screenWidthDp = configuration.screenWidthDp; //The current width of the available screen space, in dp units, corresponding to screen width resource qualifier.
int smallestScreenWidthDp = configuration.smallestScreenWidthDp; //The smallest screen size an application will see in normal operation, corresponding to smallest screen width resource qualifier.

Xem tham chiếu lớp cấu hình

Chỉnh sửa: Theo ghi nhận của Nick Baicoianu, điều này trả về chiều rộng / chiều cao có thể sử dụng của màn hình (nên là những thứ thú vị trong hầu hết các mục đích sử dụng). Nếu bạn cần kích thước hiển thị thực tế dính vào câu trả lời hàng đầu.

Bạn đang thiếu giá trị mật độ mặc định là 160.

    2 px = 3 dip if dpi == 80(ldpi), 320x240 screen
    1 px = 1 dip if dpi == 160(mdpi), 480x320 screen
    3 px = 2 dip if dpi == 240(hdpi), 840x480 screen

Nói cách khác, nếu bạn thiết kế bố cục của bạn với chiều rộng bằng 160dip ở chế độ dọc, nó sẽ là một nửa màn hình trên tất cả các thiết bị ldpi / mdpi / hdpi (trừ máy tính bảng, tôi nghĩ vậy)

Làm thế nào về việc sử dụng này thay thế?

final DisplayMetrics displayMetrics=getResources().getDisplayMetrics();
final float screenWidthInDp=displayMetrics.widthPixels/displayMetrics.density;
final float screenHeightInDp=displayMetrics.heightPixels/displayMetrics.density;

DisplayMetrics displayMetrics = new DisplayMetrics();

getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);

int width_px = Resources.getSystem().getDisplayMetrics().widthPixels;

int height_px =Resources.getSystem().getDisplayMetrics().heightPixels;

int pixeldpi = Resources.getSystem().getDisplayMetrics().densityDpi;


int width_dp = (width_px/pixeldpi)*160;
int height_dp = (height_px/pixeldpi)*160;

Trả lời bằng kotlin:

  context?.let {
        val displayMetrics = it.resources.displayMetrics
        val dpHeight = displayMetrics.heightPixels / displayMetrics.density
        val dpWidth = displayMetrics.widthPixels / displayMetrics.density
    }

Đơn giản hóa cho Kotlin:

val widthDp = resources.displayMetrics.run { widthPixels / density }
val heightDp = resources.displayMetrics.run { heightPixels / density }

Nhận chiều rộng và chiều cao màn hình về DP với một số trang trí tốt:

Bước 1: Tạo giao diện

public interface ScreenInterface {

   float getWidth();

   float getHeight();

}

Bước 2: Tạo lớp người thực hiện

public class Screen implements ScreenInterface {
    private Activity activity;

    public Screen(Activity activity) {
        this.activity = activity;
    }

    private DisplayMetrics getScreenDimension(Activity activity) {
        DisplayMetrics displayMetrics = new DisplayMetrics();
        activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
        return displayMetrics;
    }

    private float getScreenDensity(Activity activity) {
        return activity.getResources().getDisplayMetrics().density;
    }

    @Override
    public float getWidth() {
        DisplayMetrics displayMetrics = getScreenDimension(activity);
        return displayMetrics.widthPixels / getScreenDensity(activity);
    }

    @Override
    public float getHeight() {
        DisplayMetrics displayMetrics = getScreenDimension(activity);
        return displayMetrics.heightPixels / getScreenDensity(activity);
    }
} 

Bước 3: Nhận chiều rộng và chiều cao trong hoạt động:

Screen screen = new Screen(this); // Setting Screen
screen.getWidth();
screen.getHeight();

Nếu bạn chỉ muốn biết về chiều rộng màn hình của mình, bạn chỉ có thể tìm kiếm "chiều rộng màn hình nhỏ nhất" trong tùy chọn nhà phát triển của mình. Bạn thậm chí có thể chỉnh sửa nó.

Thử cái này:

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

Vấn đề của bạn là với việc chuyển float thành int, mất độ chính xác. Bạn cũng nên nhân với hệ số và không chia.

Làm cái này:

int dp = (int)(pixel*getResources().getDisplayMetrics().density);