it-swarm-ja.com

画面サイズをピクセル単位で取得する

いくつかのカスタム要素を作成し、それらをプログラム的に右上隅に配置したい(上端からnピクセル、右端からmピクセル)。したがって、画面の幅と高さを取得してから位置を設定する必要があります。

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

メインのアクティビティでscreenWidthscreenHeightを取得する方法

1740
Niko Gamulin

表示サイズをピクセル単位で指定したい場合は、 getSize を使用します。

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

あなたがActivityに入っていないのなら、WINDOW_SERVICEを通してデフォルトのDisplayを取得することができます。

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

あなたがフラグメントの中にいて、これを完成させたいのであれば、単にActivity.WindowManager(Xamarin.Android内)またはgetActivity()。getWindowManager()(Java内)を使用してください。

getSizeが導入される前(APIレベル13)、現在は非推奨となっているgetWidthおよびgetHeightメソッドを使用できます。

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

あなたが説明しているユースケースのために、しかし、レイアウトのマージン/パディングはより適切に思えます。

もう1つの方法があります: DisplayMetrics

サイズ、密度、フォントの拡大縮小など、ディスプレイに関する一般的な情報を記述する構造体。 DisplayMetricsメンバーにアクセスするには、次のようにオブジェクトを初期化します。

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

以下の情報を取得するためにwidthPixelsを使用できます。 

msgstr "ディスプレイの絶対幅(ピクセル単位)"

例:

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

一つの方法は:

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

これは非推奨です。代わりに次のコードを試してください。コードの最初の2行は、DisplayMetricsオブジェクトです。このオブジェクトには、heightPixels、widthPixelsなどのフィールドが含まれています。

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;
359
Balaji.K

それはあなたの質問には答えないかもしれませんが、もしあなたがViewのディメンションが必要だがレイアウトがまだレイアウトされていないときにあなたのコードが実行されているなら知っておくと便利です。 (例えばonCreate()の中で)あなたはView.getViewTreeObserver().addOnGlobalLayoutListener()ViewTreeObserver.OnGlobalLayoutListenerを設定し、そこにビューの次元を必要とする関連コードを置くことができます。リスナーのコールバックは、レイアウトがレイアウトされたときに呼び出されます。

114

(2012年の回答、古くなっているかもしれません)Honeycomb以前をサポートしたい場合は、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を使用しているユーザーのほとんどに依存していますが、これは残されたものです。

104
digiphd

私はすべての可能な「解決策」を試みて失敗しました、そして私はElliott Hughesの「Dalvik Explorer」アプリがどんなAndroidデバイス/ 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) {
}
64

最も簡単な方法: 

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

Androidデバイスのステータスバーの高さにアクセスするには、それを取得するためのプログラムによる方法をお勧めします。

サンプルコード

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

変数resultはピクセルの高さを与えます。

素早いアクセス

Enter image description here

Title barNavigation bar、およびContent Viewの高さの詳細については、Androidデバイスの画面サイズをご覧ください。

46
Swapnil Sonar

最初に(たとえばfindViewById()によって)ビューを取得してから、ビュー自体で getWidth() を使用できます。

30
Marcin Gil

私は2つの関数を持っています。1つはコンテキストを送信するためのもので、もう1つはピクセル単位で高さと幅を取得するためのものです。

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

これは私がタスクに使用するコードです:

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

十分きれいに見えますが、それでも、廃止予定の世話をします。

17
Pijusn

これはもっと良い解決策ではないでしょうか。 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以降でのみ機能します。

私は何かが足りないのですか?

17
David Corsalini

XMLを使用して動的に拡大縮小するために、 "Android:layout_weight"という属性があります。 

このスレッド のsynicの応答を修正した以下の例は、画面の75%を占めるボタン(weight = .25)と、画面の残りの25%を占めるテキストビュー(weight =。)を示しています。 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>
17
Crbreingan

画面の幅と高さを求めます。

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

フランチェスコの答えに加えて。ウィンドウ内の位置またはスクリーン内の位置を調べたい場合は、より適切なもう1つのオブザーバは ViewTreeObserver.OnPreDrawListener() です。

これはまた、onCreate()時にほとんど未知であるビューの他の属性を見つけるためにも使用できます。スクロールされた位置、スケールされた位置.

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

Activityで次のコードを使用します。

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

私はこれがトリックをやっているのを見つけた。

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

Activity内ではなくView内にいる(またはスコープ内にView型の変数がある)場合は、WINDOW_SERVICEを使用する必要はありません。それから、あなたは少なくとも2つの方法を使うことができます。

最初:

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

第二:

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

我々がここで呼ぶすべてのこのメソッドは非推奨ではありません。

11
Sergei Pikalev
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);
    }
}
11

画面の寸法を取得するには、表示メトリックを使用します

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;
9
sharath kumar

彼はディスプレイサイズを実際のピクセル数で望んでいたので、これはOPの答えではありません。私は「デバイスに依存しないピクセル」で寸法を求めていました、そしてここから答えをまとめてください 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);
8
RenniePet

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

あなたは 高さ サイズを得ることができます:

getResources().getDisplayMetrics().heightPixels;

そして width sizeを使って

getResources().getDisplayMetrics().widthPixels; 
7
Jéwôm'

このように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;
}
7
Simon Heinen

まずXMLファイルをロードしてから、次のコードを書きます。

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

画面の解像度に合わせて幅と高さを表示します。

5
duggu

以下の方法に従ってください。

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

使用可能な画面サイズ なし ステータスバー および アクションバー を検索している人のために(これも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);
}
5

アクティビティのonCreateの中で、レイアウトに使用可能なスペースの正確な寸法を知る必要がある場合があります。

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

WindowManager、Points、またはDisplaysのオーバーヘッドが不要な場合は、高さと幅がmatch_parentに設定されていれば、XMLの一番上のビュー項目の高さと幅の属性を取得できます。 (これは、レイアウトが画面全体を占める限り有効です。)

たとえば、XMLが次のように始まっているとします。

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

findViewById(R.id.entireLayout).getWidth()は画面の幅を返し、findViewById(R.id.entireLayout).getHeight()は画面の高さを返します。

4
christinac

その幅と高さに match_parent があるルートビューとしてLinearLayoutを使ったスプラッシュスクリーンアクティビティがあります。これはそのアクティビティのonCreate()メソッドのコードです。私はアプリの他のすべての活動でこれらの措置を使用します。

int displayWidth = getRawDisplayWidthPreHoneycomb();
int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
pf.setScreenParameters(displayWidth, usableDisplayHeight);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
    myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
        @Override
        public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
            if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                return;
            }
            int displayWidth = Math.min(right, bottom);
            int usableDisplayHeight = Math.max(right, bottom);
            pf.setScreenParameters(displayWidth, usableDisplayHeight);
        }
    });
}

上記のメソッドの実装は次のとおりです。

private int getRawDisplayWidthPreHoneycomb() {
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int widthPixels = displayMetrics.widthPixels;
    int heightPixels = displayMetrics.heightPixels;

    return Math.min(widthPixels, heightPixels);
}

private int getRawDisplayHeightPreHoneycomb() {
    WindowManager w = getWindowManager();
    Display d = w.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    d.getMetrics(metrics);

    int widthPixels = metrics.widthPixels;
    int heightPixels = metrics.heightPixels;

    return Math.max(widthPixels, heightPixels);
}

public int getStatusBarHeight() {
    int statusBarHeight = 0;

    int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "Android");
    if (resourceId > 0) {
        statusBarHeight = getResources().getDimensionPixelSize(resourceId);
    }

    return statusBarHeight;
}

これにより、すべてのAPIバージョンとさまざまな種類のデバイス(携帯電話とタブレット)で、使用可能なディスプレイの高さと幅がすべての種類のバー(ステータスバー、ナビゲーションバー)を除いて表示されます。

3
Rutger

コトリン

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
}
2
Khemraj

Displayクラスが機能しない場合、上記の答えは機能しません。その場合は、下記の方法で幅と高さを取得できます。

private static final int WIDTH_INDEX = 0;
private static final int HEIGHT_INDEX = 1;

    public static int[] getScreenSize(Context context) {
        int[] widthHeight = new int[2];
        widthHeight[WIDTH_INDEX] = 0;
        widthHeight[HEIGHT_INDEX] = 0;

        try {
            WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Display display = windowManager.getDefaultDisplay();

            Point size = new Point();
            display.getSize(size);
            widthHeight[WIDTH_INDEX] = size.x;
            widthHeight[HEIGHT_INDEX] = size.y;

            if (!isScreenSizeRetrieved(widthHeight))
            {
                DisplayMetrics metrics = new DisplayMetrics();
                display.getMetrics(metrics);
                widthHeight[0] = metrics.widthPixels;
                widthHeight[1] = metrics.heightPixels;
            }

            // Last defense. Use deprecated API that was introduced in lower than API 13
            if (!isScreenSizeRetrieved(widthHeight)) {
                widthHeight[0] = display.getWidth(); // deprecated
                widthHeight[1] = display.getHeight(); // deprecated
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return widthHeight;
    }

    private static boolean isScreenSizeRetrieved(int[] widthHeight) {
        return widthHeight[WIDTH_INDEX] != 0 && widthHeight[HEIGHT_INDEX] != 0;
    }
2

下位バージョンと互換性のあるシンプルな機能。

/**
 * @return screen size int[width, height]
 *
 * */
public int[] getScreenSize(){
    Point size = new Point();
    WindowManager w = getWindowManager();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2){
        w.getDefaultDisplay().getSize(size);
        return new int[]{size.x, size.y};
    }else{
        Display d = w.getDefaultDisplay();
        //noinspection deprecation
        return new int[]{d.getWidth(), d.getHeight()};
    }
}

使用するには:

int width = getScreenSize()[0];
int height = getScreenSize()[1];
1
Jakob

これがKotlinの実装における上記のいくつかの答えからの簡単な適応です。マニフェストで上記のwindowsSoftInput = "adjustResize"が必要です。

class KeyboardWatcher(private val layoutRooView: View) {

    companion object {
        private const val MIN_KEYBOARD_HEIGHT = 200f
    }

    private val displayMetrics: DisplayMetrics = layoutRooView.resources.displayMetrics
    private var stateVisible = false

    var observer: ((Boolean) -> Unit)? = null

    init {
        layoutRooView.viewTreeObserver.addOnGlobalLayoutListener {
            val heightDiff = layoutRooView.rootView.height - layoutRooView.height
            if (!stateVisible && heightDiff > dpToPx(MIN_KEYBOARD_HEIGHT)) {
                stateVisible = true
                observer?.invoke(stateVisible)
            } else if(stateVisible) {
                stateVisible = false
                observer?.invoke(stateVisible)
            }
        }
    }

    private fun dpToPx(valueInDp: Float): Float {
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, displayMetrics)
    }
}

そして使用する:

val activityRootView = findViewById<ViewGroup>(R.id.activityRoot)
KeyboardWatcher(activityRootView).observer = { visible ->
    if (visible) do something here ...
}
1
Joao Gavazzi

この関数はおおよその画面サイズをインチ単位で返します。

public double getScreenSize()
{
        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        int width=dm.widthPixels;
        int height=dm.heightPixels;
        int dens=dm.densityDpi;
        double wi=(double)width/(double)dens;
        double hi=(double)height/(double)dens;
        double x = Math.pow(wi,2);
        double y = Math.pow(hi,2);
        double screenInches = Math.sqrt(x+y);
        return screenInches;
}
1
Abhishek
DisplayMetrics dm = getResources().getDisplayMetrics();
float fwidth = dm.density * dm.widthPixels;
float fheight = dm.density * dm.heightPixels;

MinSDKVersionが原因でgetSizeでエラーが発生し、廃止予定のメソッド(getWidthgetHeight)を使用したくない場合は、getMetricsソリューションが2011年に投稿されましたそしてNikはgetDisplayMetricsがステータスバーのサイズも考慮することを説明するコメントを付け加えました。

他のコメントでは、寸法の正確な浮動小数点値を取得するためにスケール( 密度 )を掛けることを参照しています。 Android v2.2(API 8)およびv4.0で良好な結果が得られ、 エラーなし/警告なし

0
Armfoot

私はそれが最も簡単だと思う

private fun checkDisplayResolution() {
    val displayMetrics = DisplayMetrics().also {
        windowManager.defaultDisplay.getMetrics(it)
    }

    Log.i(TAG, "display width: ${displayMetrics.widthPixels}")
    Log.i(TAG, "display height: ${displayMetrics.heightPixels}")
    Log.i(TAG, "display width dpi: ${displayMetrics.xdpi}")
    Log.i(TAG, "display height dpi: ${displayMetrics.ydpi}")
    Log.i(TAG, "display density: ${displayMetrics.density}")
    Log.i(TAG, "display scaled density: ${displayMetrics.scaledDensity}")
}
0
Artem Botnev

私は上記の提案を使い、私たちの質問のためにコトリン版を作りました。これがkotlinを使っている人たちにさらなる助けを提供してくれることを願います:

private val screenDimensions: Int by lazy {
    val display = (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
    Point()
        .also { size ->
            when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 -> display.getRealSize(size)
                else -> display.getSize(size)
            }
        }
}

screenDimensions.x // width
screenDimensions.y // height
0
Mike T

これらのAPIによって返される高さは、 デバイスの物理的な高さよりも少なくなります。 ボタンバーの高さが引かれるためです。

たとえば、Moto X 4では正しいwidthPixels(1080)が返されますが、デバイスの画面の高さが1920ピクセルであっても1776の高さが返されます。

0
Tyler