Android에서 화면 크기를 픽셀로 가져오는 방법

Android에서 화면 크기를 픽셀로 가져오는 방법

를 만들었는데 방식으로 배치하려고 .n 및 위 가 의 픽 및 셀m오른쪽 가장자리의 픽셀).따라서 화면 너비와 화면 높이를 얻은 다음 위치를 설정해야 합니다.

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

어떻게 해야 할 것screenWidth그리고.screenHeight주요 활동에서?

디스플레이 치수를 픽셀 단위로 표시하려면 다음을 사용할 수 있습니다.

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

만약 당신이 그렇지 않다면.Activity인 " 값을수있다니습얻을기본▁the"를 얻을 수 .Display경유로WINDOW_SERVICE:

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

단편적인 상황에서 이 작업을 수행하려면 [활동]을 사용하십시오.창 관리자(Xamarin).Android) 또는 getActivity().getWindowManager()(java)를 선택합니다.

getSize 13되어 (API 레벨 13) 소었에며으, 당사수있다니를 할 수 .getWidth그리고.getHeight현재는 더 이상 사용되지 않는 메서드:

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

사용 사례의 경우에는 레이아웃의 여백/패딩이 더 적합하다고 설명하고 있습니다.

다른 방법은 디스플레이 메트릭입니다.

크기, 밀도, 글꼴 크기 등 디스플레이에 대한 일반적인 정보를 설명하는 구조입니다.DisplayMetrics 멤버에 액세스하려면 다음과 같은 개체를 초기화합니다.

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

우리는 사용할 수 있습니다.widthPixels다음에 대한 정보 얻기:

"픽셀 단위로 표시되는 디스플레이의 절대 폭입니다.

예:

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

API 레벨 30 업데이트

final WindowMetrics metrics = windowManager.getCurrentWindowMetrics();
 // Gets all excluding insets
 final WindowInsets windowInsets = metrics.getWindowInsets();
 Insets insets = windowInsets.getInsetsIgnoringVisibility(WindowInsets.Type.navigationBars()
         | WindowInsets.Type.displayCutout());

 int insetsWidth = insets.right + insets.left;
 int insetsHeight = insets.top + insets.bottom;

 // Legacy size that Display#getSize reports
 final Rect bounds = metrics.getBounds();
 final Size legacySize = new Size(bounds.width() - insetsWidth,
         bounds.height() - insetsHeight);

한 가지 방법은:

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

이 코드는 더 이상 사용되지 않으며 대신 다음 코드를 사용해야 합니다.처음 두 줄의 코드는 다음과 같습니다.DisplayMetrics물건 이 에는 이개는다같필포함니다합드를과 같은 되어 있습니다.heightPixels,widthPixels.

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

API 레벨 30 업데이트

final WindowMetrics metrics = windowManager.getCurrentWindowMetrics();
 // Gets all excluding insets
 final WindowInsets windowInsets = metrics.getWindowInsets();
 Insets insets = windowInsets.getInsetsIgnoringVisibility(WindowInsets.Type.navigationBars()
         | WindowInsets.Type.displayCutout());

 int insetsWidth = insets.right + insets.left;
 int insetsHeight = insets.top + insets.bottom;

 // Legacy size that Display#getSize reports
 final Rect bounds = metrics.getBounds();
 final Size legacySize = new Size(bounds.width() - insetsWidth,
         bounds.height() - insetsHeight);

도 있지만, 때 것을 아는 할 수 : View 답지의차않레있지만, View 원않예배치직아있에수되때유것코있확실을지았드가행되고는지는하다니인습이할용질이문이필웃만요이아지에하하을도수예▁it▁view▁is)▁questioni▁(▁if▁when▁but▁be,▁question▁yourfor▁you▁it'▁may▁not▁to▁code▁know▁being있).onCreate()를 설정할 수 있습니다.ViewTreeObserver.OnGlobalLayoutListener와 함께View.getViewTreeObserver().addOnGlobalLayoutListener()뷰의 차원이 필요한 관련 코드를 거기에 넣습니다.레이아웃이 배치되면 수신기의 콜백이 호출됩니다.

(2012년 답변, 최신 버전이 아닐 수 있음) 프리 허니콤을 지원하려면 API 13 이전에 이전 버전과의 호환성을 설정해야 합니다.다음과 같은 것:

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

물론 사용되지 않는 방법은 결국 최신 SDK에서 제외될 것이지만, 여전히 대부분의 사용자가 Android 2.1, 2.2 및 2.3을 사용하고 있지만, 이것이 우리에게 남아 있는 것입니다.

저는 가능한 모든 "솔루션"을 시도했지만 성공하지 못했고 엘리엇 휴즈의 "달빅 익스플로러" 앱이 안드로이드 기기/OS 버전에서 항상 올바른 치수를 보여준다는 것을 알게 되었습니다.저는 결국 https://code.google.com/p/enh/ 에서 찾을 수 있는 그의 오픈 소스 프로젝트를 보게 되었습니다.

다음은 모든 관련 코드입니다.

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

편집: 약간 개선된 버전(지원되지 않는 OS 버전에서는 예외 발생 방지):

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

가장 간단한 방법:

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

Android 장치의 상태 표시줄 높이에 액세스하려면 프로그래밍 방식을 사용하는 것이 좋습니다.

샘플코드

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

수result픽셀의 높이를 제공합니다.

빠른 액세스를 위해

은 높에대자내용은한세한이.Title bar,Navigation bar그리고.Content ViewAndroid 장치 화면 크기를 확인하십시오.

번째 : 먼예보기저사자용예(▁(기)보▁first▁view:eg자)findViewById()그런 다음 보기 자체에서 getWidth를 사용할 수 있습니다.

두 가지 기능이 있습니다. 하나는 컨텍스트를 전송하는 기능이고 다른 하나는 픽셀 단위로 높이와 너비를 얻는 기능입니다.

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

그리고.

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을 사용하여 동적으로 확장하는 경우 "android:layout_weight"라는 속성이 있습니다.

이 스레드에서 synic의 응답을 수정한 아래 예제에서는 화면의 75%를 차지하는 버튼(무게 = .25)과 화면의 나머지 25%를 차지하는 텍스트 보기(무게 = .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>

작업에 사용하는 코드는 다음과 같습니다.

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

충분히 깨끗해 보이지만, 여전히 그는 그의 가치를 떨어뜨리고 있습니다.

이것이 훨씬 더 좋은 해결책이 아닐까요?DisplayMetrics는 필요한 모든 것을 제공하며 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;
}

getRealMetrics를 사용하여 실제 디스플레이(상태 표시줄 또는 소프트웨어 탐색 모음 등의 화면 장식 포함)를 얻을 수도 있지만, 이 기능은 17+에서만 작동합니다.

내가 뭘 빼놓았나요?

프란체스코의 대답을 덧붙이는 것 뿐입니다.창 또는 화면의 위치를 확인하려면 ViewTreeObserver가 더 적합합니다.미리 그리기 수신기()

이는 스크롤된 위치, 축척된 위치 등 Create() 시간에 대부분 알 수 없는 뷰의 다른 속성을 찾는 데도 사용할 수 있습니다.

화면 너비 및 높이 찾기:

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

이것을 이용하여 우리는 최신 이상의 SDK 13을 얻을 수 있습니다.

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

활동에서 다음 코드를 사용합니다.

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

에 있지 만당신여기없다면에이요약▁▁need없다면,▁you여▁that▁say▁to,▁in▁are.Activity 그나러로View(또는 변수가 있음)View범위에 입력), 을 사용할 필요가 없습니다.WINDOW_SERVICE그러면 적어도 두 가지 방법을 사용할 수 있습니다.

첫 번째:

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

두 번째:

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

우리가 여기서 부르는 이 모든 방법은 사용되지 않습니다.

OP가 실제 픽셀의 디스플레이 치수를 원했기 때문에 이것은 OP에 대한 답변이 아닙니다.저는 "device-independent-device"의 치수를 원했고, 여기 https://stackoverflow.com/a/17880012/253938 과 여기 https://stackoverflow.com/a/6656774/253938 의 답변을 종합하여 다음과 같이 생각해냈습니다.

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

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

화면 치수를 가져오려면 디스플레이 메트릭 사용

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

높이 및 너비(픽셀) 가져오기

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

저는 이것이 효과가 있다는 것을 알았습니다.

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

다음을 사용하여 높이 크기를 가져올 수 있습니다.

getResources().getDisplayMetrics().heightPixels;

폭 크기는 다음을 사용하여

getResources().getDisplayMetrics().widthPixels; 

DisplayMetrics(API 1)를 사용하여 이 작업을 수행하는 것이 권장되지 않는 방법으로 시도/캐치의 혼란을 방지할 수 있습니다.

 // 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 코드를 다음과 같이 포장합니다.

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

상태 표시줄 및 수행 표시줄 없이 사용 가능한 화면 치수를 검색하는 사용자(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);
}

코틀린

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
}

먼저 XML 파일을 로드한 후 다음 코드를 작성합니다.

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

화면 해상도에 따라 너비와 높이를 표시합니다.

다음 방법을 따릅니다.

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

작성 중인 활동에서 레이아웃에 사용할 수 있는 공간의 정확한 크기를 알아야 할 경우가 있습니다.생각 끝에 저는 이런 식으로 해냈습니다.

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

어떤 이유로 Android 매니페스트에 다른 활동을 추가하지 않으려는 경우 다음과 같은 방법으로 작업을 수행할 수 있습니다.

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

코틀린에서는 훨씬 간단합니다.

val displayMetrics = Resources.getSystem().displayMetrics
displayMetrics.heightPixels
displayMetrics.widthPixels

언급URL : https://stackoverflow.com/questions/1016896/how-to-get-screen-dimensions-as-pixels-in-android