Wie man in Android die Bildschirmabmessungen als Pixel erhält

Question

Ich habe einige benutzerdefinierte Elemente erstellt, die ich programmgesteuert in der oberen rechten Ecke platzieren möchte ( n Pixel vom oberen Rand und m Pixel vom rechten Rand). Daher muss ich die Bildschirmbreite und die Bildschirmhöhe ermitteln und dann die Position festlegen:

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

Wie erhalte ich screenWidth y screenHeight in der Hauptaktivität?

Answer 1

Ich habe obige Vorschläge verwendet und eine Kotlin-Version für unsere Frage erstellt. Hoffe, dies bietet einige zusätzliche Hilfe für diejenigen, die Kotlin verwenden:

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

Answer 2

Ich denke, es ist am einfachsten

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

Answer 3

DisplayMetrics dm = getResources().getDisplayMetrics();
float fwidth = dm.density * dm.widthPixels;
float fheight = dm.density * dm.heightPixels;

Si getSize aufgrund Ihrer minSDKVersion einen Fehler erhält und Sie keine veralteten Methoden verwenden wollen ( getWidth & getHeight ), die getMetrics Lösung wurde ursprünglich im Jahr 2011 von Balaji.K. veröffentlicht. Und Nik hat einen Kommentar hinzugefügt, der erklärt getDisplayMetrics berücksichtigt auch die Größe der Statusleiste.

Einige andere Kommentare beziehen sich auf das Multiplizieren mit der Skala ( Dichte ), um den genauen Float-Wert der Abmessungen zu erhalten. Getestet in Android v2.2 (API 8) und v4.0 mit guten Ergebnissen und keine Fehler/Warnungen .

Answer 4

- Kotlin Version über Extension Property

Es gibt mehrere Möglichkeiten, die Bildschirmgröße in Android zu erreichen, aber ich denke, die beste Lösung könnte unabhängig von einer Context Instanz, so dass Sie sie überall in Ihrem Code verwenden können. Hier habe ich eine Lösung über eine Kotlin-Erweiterungseigenschaft bereitgestellt, die es einfach macht, die Bildschirmgröße in Pixeln sowie die dp :

DimensionUtils.kt

import android.content.res.Resources
import android.graphics.Rect
import android.graphics.RectF
import android.util.DisplayMetrics
import kotlin.math.roundToInt

/**
 * @author aminography
 */

private val displayMetrics: DisplayMetrics by lazy { Resources.getSystem().displayMetrics }

val screenRectPx: Rect
    get() = displayMetrics.run { Rect(0, 0, widthPixels, heightPixels) }

val screenRectDp: RectF
    get() = displayMetrics.run { RectF(0f, 0f, widthPixels.px2dp, heightPixels.px2dp) }

val Number.px2dp: Float
    get() = this.toFloat() / displayMetrics.density

val Number.dp2px: Int
    get() = (this.toFloat() * displayMetrics.density).roundToInt()

Verwendung:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val widthPx = screenRectPx.width()
        val heightPx = screenRectPx.height()
        println("[PX] screen width: $widthPx , height: $heightPx")

        val widthDp = screenRectDp.width()
        val heightDp = screenRectDp.height()
        println("[DP] screen width: $widthDp , height: $heightDp")
    }
}

Ergebnis:

Wenn sich das Gerät im portrait Orientierung:

[PX] screen width: 1440 , height: 2392
[DP] screen width: 360.0 , height: 598.0

Wenn sich das Gerät im landscape Orientierung:

[PX] screen width: 2392 , height: 1440
[DP] screen width: 598.0 , height: 360.0

---

Wenn Sie kein Fan von Kotlin sind, verwenden Sie die Java-Version:

import android.content.res.Resources;
import android.graphics.Rect;
import android.graphics.RectF;
import android.util.DisplayMetrics;

/**
 * @author aminography
 */
public class DimensionUtils {

    private static DisplayMetrics displayMetrics;

    private static DisplayMetrics getDisplayMetrics() {
        if (displayMetrics == null) {
            displayMetrics = Resources.getSystem().getDisplayMetrics();
        }
        return displayMetrics;
    }

    public static Rect screenRectPx() {
        return new Rect(0, 0, getDisplayMetrics().widthPixels, getDisplayMetrics().heightPixels);
    }

    public static RectF screenRectDp() {
        return new RectF(0f, 0f, px2dp(getDisplayMetrics().widthPixels), px2dp(getDisplayMetrics().heightPixels));
    }

    public static float px2dp(int value) {
        return value / getDisplayMetrics().density;
    }

    public static int dp2px(float value) {
        return (int) (value * getDisplayMetrics().density);
    }
}

Answer 5

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
}

JAVA

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