Getter für defaultDisplay: Display!’ ist veraltet. In Java veraltet

Ich brauche die Breite des Bildschirms. Aber kürzlich Android gefunden defaultDisplay Veraltet mit Meldung:

Getter für defaultDisplay: Display!’ ist veraltet. In Java veraltet

Code:

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
return displayMetrics.widthPixels

Bitte schlagen Sie eine Alternative vor.

defaultDisplay wurde in API-Level 30 (Android R) und höher als veraltet markiert. Das heißt, wenn Sie eine SDK-Mindestkonfiguration unter API-Level 30 haben, sollten Sie beide Implementierungen mit dem alten veralteten Code und dem neuen empfohlenen Code haben.

Nachdem Sie das Problem korrekt behoben haben, können Sie mit @Suppress(“DEPRECATION”) Warnungen unterdrücken

Beispiel: Kotlin-Lösung

    val outMetrics = DisplayMetrics()

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
        val display = activity.display
        display?.getRealMetrics(outMetrics)
    } else {
        @Suppress("DEPRECATION")
        val display = activity.windowManager.defaultDisplay
        @Suppress("DEPRECATION")
        display.getMetrics(outMetrics)
    }

WindowManager.getDefaultDisplay() wurde in API-Level 30 zugunsten von veraltet Context.getDisplay() Methode, die mindestens API-Level 30 erfordert.

Im Augenblick, androidx.core.content.ContextCompat scheint keine Abwärtskompatibilität zu bieten getDisplay() Methode.

Wenn Sie nur die Standardanzeige abrufen müssen, anstatt unterschiedliche Methoden für unterschiedliche API-Ebenen zu verwenden, wie andere Antworten vorschlagen, können Sie dies tun DisplayManager.getDisplay(Display.DEFAULT_DISPLAY) Methode (unterstützt seit API 17), um das gleiche Ergebnis zu erzielen.

Veralteter Code:

val defaultDisplay = getSystemService<WindowManager>()?.defaultDisplay

Neuer Code:

val defaultDisplay = getSystemService<DisplayManager>()?.getDisplay(Display.DEFAULT_DISPLAY)

Ref: androidx.core-Quellcode

Wenn Sie die Größe des Fensters ermitteln möchten, wählen Sie das neue Jetpack WindowManager-Bibliothek Bietet eine gemeinsame API-Oberfläche für neue Window Manager-Funktionen (z. B. faltbare Geräte und Chrome OS) in allen alten und neuen Plattformversionen.

dependencies {
    implementation "androidx.window:window:1.0.0-beta02"
}

Jetpack WindowManager bietet zwei Möglichkeiten zum Abrufen Fenstermetriken Informationen, als asynchroner Stream oder synchron.

Asynchroner WindowMetrics-Ablauf:

Verwenden WindowInfoRepository#currentWindowMetrics um von der Bibliothek benachrichtigt zu werden, wenn sich die Fenstergröße ändert, unabhängig davon, ob diese Änderung eine Konfigurationsänderung auslöst.

import androidx.window.layout.WindowInfoRepository
import androidx.window.layout.WindowInfoRepository.Companion.windowInfoRepository
import androidx.window.layout.WindowMetrics
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.flowWithLifecycle

lifecycleScope.launch(Dispatchers.Main) {
    windowInfoRepository().currentWindowMetrics.flowWithLifecycle(lifecycle)
        .collect { windowMetrics: WindowMetrics ->
           val currentBounds = windowMetrics.bounds // E.g. [0 0 1350 1800]
           val width = currentBounds.width()
           val height = currentBounds.height()
        }
}

• Notiz: lifecycleScope Und flowWithLifecycle() sind Teil von Jetpack Lifecycle-Bibliothek.

Synchrone Fenstermetriken:

Verwenden WindowMetricsCalculator wenn Sie Code in einer Ansicht schreiben, in der die asynchrone API zu schwierig zu handhaben sein kann (z. B onMeasure oder während des Tests).

import androidx.window.layout.WindowMetricsCalculator
import androidx.window.layout.WindowMetrics

val windowMetrics = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity)
val currentBounds = windowMetrics.bounds // E.g. [0 0 1350 1800]
val width = currentBounds.width()
val height = currentBounds.height()

Ref: Entbündelung des WindowManager | Android-Entwicklermedium

Diese Methode wurde in API-Level 30 veraltet.

Verwenden Context.getDisplay() stattdessen.

Veraltete Methode: getDefaultDisplay

Neue Methode: getDisplay

Versuchen Sie etwas wie Folgendes:

    private Display getDisplay(@NonNull WindowManager windowManager) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            // This one (context) may or may not have a display associated with it, due to it being
            // an application context
            return getDisplayPostR();
        } else {
            return getDisplayPreR(windowManager);
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.R)
    private Display getDisplayPostR() {
        // We can't get the WindowManager by using the context we have, because that context is a
        // application context, which isn't associated with any display. Instead, grab the default
        // display, and create a DisplayContext, from which we can use the WindowManager or
        // just get that Display from there.
        //
        // Note: the default display doesn't have to be the one where the app is on, however the
        // getDisplays which returns a Display[] has a length of 1 on Pixel 3.
        //
        // This gets rid of the exception interrupting the onUserLogin() method
        Display defaultDisplay = DisplayManagerCompat.getInstance(context).getDisplay(Display.DEFAULT_DISPLAY);
        Context displayContext = context.createDisplayContext(defaultDisplay);
        return displayContext.getDisplay();
    }

    @SuppressWarnings("deprecation")
    private Display getDisplayPreR(@NonNull WindowManager windowManager) {
        return windowManager.getDefaultDisplay();
    }

oder um die tatsächliche Größe zu erhalten:

    private Point getScreenResolution() {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        if (wm == null) {
            return null;
        }
        Display display = getDisplay(wm);

        return getSize(display, wm);
    }

    private Point getSize(Display forWhichDisplay, WindowManager windowManager) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            return getSizePostR(windowManager);
        } else {
            return getSizePreR(forWhichDisplay);
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.R)
    private Point getSizePostR(@NonNull WindowManager windowManager) {
        WindowMetrics currentWindowMetrics = windowManager.getCurrentWindowMetrics();
        Rect bounds = currentWindowMetrics.getBounds();

        // Get the insets, such as titlebar and other decor views
        WindowInsets windowInsets = currentWindowMetrics.getWindowInsets();
        Insets insets = windowInsets.getInsets(WindowInsets.Type.navigationBars());
        // If cutouts exist, get the max of what we already calculated and the system's safe insets
        if (windowInsets.getDisplayCutout() != null) {
            insets = Insets.max(
                    insets,
                    Insets.of(
                            windowInsets.getDisplayCutout().getSafeInsetLeft(),
                            windowInsets.getDisplayCutout().getSafeInsetTop(),
                            windowInsets.getDisplayCutout().getSafeInsetRight(),
                            windowInsets.getDisplayCutout().getSafeInsetBottom()
                    )
            );
        }
        // Calculate the inset widths/heights
        int insetsWidth = insets.right + insets.left;
        int insetsHeight = insets.top + insets.bottom;

        // Get the display width
        int displayWidth = bounds.width() - insetsWidth;
        int displayHeight = bounds.height() - insetsHeight;

        return new Point(displayWidth, displayHeight);
    }

    // This was deprecated in API 30
    @SuppressWarnings("deprecation")
    private Point getSizePreR(Display display) {
        Point size = new Point();
        if (isRealDisplaySizeAvailable()) {
            display.getRealSize(size);
        } else {
            display.getSize(size);
        }

        return size;
    }

    private static boolean isRealDisplaySizeAvailable() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1;
    }

ich benutze DisplayCompatManager um Breite und Höhe auf Android R-Above zu erhalten und zu verwenden DisplayMatrics um es auf eine andere Android-Version zu bekommen.

Das ist also mein Code ( + @Suppress(“DEPRECATION”) )

private fun screenValue() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {

        val defaultDisplay =
            DisplayManagerCompat.getInstance(this).getDisplay(Display.DEFAULT_DISPLAY)
        val displayContext = createDisplayContext(defaultDisplay!!)

        width = displayContext.resources.displayMetrics.widthPixels
        height = displayContext.resources.displayMetrics.heightPixels

        Log.e(tag, "width (ANDOIRD R/ABOVE): $width")
        Log.e(tag, "height (ANDOIRD R/ABOVE) : $height")

    } else {

        val displayMetrics = DisplayMetrics()
        @Suppress("DEPRECATION")
        windowManager.defaultDisplay.getMetrics(displayMetrics)

        height = displayMetrics.heightPixels
        width = displayMetrics.widthPixels

        Log.e(tag, "width (BOTTOM ANDROID R): $width")
        Log.e(tag, "height (BOTTOM ANDROID R) : $height")

    }
}

Wenn Sie meinen Kern in Github sehen möchten

In der API-Level-31-Methode Display.getRealMetrics() war ebenfalls veraltet. Die empfohlene Methode ist die Verwendung WindowManager#getCurrentWindowMetrics(). Ich bevorzuge den folgenden Ansatz, um die Bildschirmgröße zu ermitteln:

object ScreenSizeCompat {
    private val api: Api =
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) ApiLevel30()
        else Api()

    /**
     * Returns screen size in pixels.
     */
    fun getScreenSize(context: Context): Size = api.getScreenSize(context)

    @Suppress("DEPRECATION")
    private open class Api {
        open fun getScreenSize(context: Context): Size {
            val display = context.getSystemService(WindowManager::class.java).defaultDisplay
            val metrics = if (display != null) {
                DisplayMetrics().also { display.getRealMetrics(it) }
            } else {
                Resources.getSystem().displayMetrics
            }
            return Size(metrics.widthPixels, metrics.heightPixels)
        }
    }

    @RequiresApi(Build.VERSION_CODES.R)
    private class ApiLevel30 : Api() {
        override fun getScreenSize(context: Context): Size {
            val metrics: WindowMetrics = context.getSystemService(WindowManager::class.java).currentWindowMetrics
            return Size(metrics.bounds.width(), metrics.bounds.height())
        }
    }
}

Und um beispielsweise die Bildschirmhöhe zu ermitteln, verwenden Sie es Activity:

ScreenSizeCompat.getScreenSize(this).height

Der folgende Code kann auf alle Android-Versionen (von SDK 16 bis SDK 33+) ohne veraltete Warnung angewendet werden.

import android.hardware.display.DisplayManager;
import android.view.Display;
import android.util.DisplayMetrics;
import android.content.Context;

// ...

    @NonNull
    public static DisplayMetrics getDisplayMetrics(@NonNull Context context) {
        DisplayManager displayManager = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
        Display defaultDisplay = displayManager.getDisplay(Display.DEFAULT_DISPLAY);
        Context defaultDisplayContext = context.createDisplayContext(defaultDisplay);
        return defaultDisplayContext.getResources().getDisplayMetrics();
    }