Höhe der Statusleiste in Android

Wie hoch ist die Statusleiste in Android? Ist es immer das gleiche?

Aus meinen Messungen geht hervor, dass es 25 dp ist, aber ich bin mir nicht sicher, ob es auf allen Plattformen die gleiche Höhe hat.

(Ich möchte dies wissen, um einen Überblendungsübergang von einer Aktivität ohne Statusleiste zu einer Aktivität ohne Statusleiste ordnungsgemäß zu implementieren.)

Diese Frage wurde schon einmal beantwortet ... Höhe der Statusleiste?

Update ::

Aktuelle Methode:

OK, die Höhe der Statusleiste hängt von der Bildschirmgröße ab. Bei einem Gerät mit einer Bildschirmgröße von 240 x 320 beträgt die Höhe der Statusleiste beispielsweise 20 Pixel. Bei einem Gerät mit einer Bildschirmgröße von 320 x 480 beträgt die Höhe der Statusleiste 25 Pixel Bei Geräten mit 480 x 800 muss die Höhe der Statusleiste 38px betragen

Daher empfehle ich, dieses Skript zu verwenden, um die Höhe der Statusleiste zu ermitteln

Rect rectangle = new Rect();
Window window = getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(rectangle);
int statusBarHeight = rectangle.top;
int contentViewTop = 
    window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
int titleBarHeight= contentViewTop - statusBarHeight;

   Log.i("*** Elenasys :: ", "StatusBar Height= " + statusBarHeight + " , TitleBar Height = " + titleBarHeight); 

(alte Methode) onCreate()Verwenden Sie diese Methode , um die Höhe der Statusleiste für die Methode Ihrer Aktivität zu ermitteln:

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

Von allen Codebeispielen, die ich verwendet habe, um die Höhe der Statusleiste zu ermitteln, scheint das einzige, das tatsächlich in der onCreateMethode von a zu funktionieren scheint, Folgendes zu sein Activity:

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

Anscheinend wird die tatsächliche Höhe der Statusleiste als Android-Ressource beibehalten. Der obige Code kann einer ContextWrapperKlasse (z Activity. B. einer ) hinzugefügt werden .

Gefunden unter http://mrtn.me/blog/2012/03/17/get-the-height-of-the-status-bar-in-android/

Auf MDPI-Geräten beträgt die Statusleiste 25 Pixel. Wir können dies als Basis verwenden und es mit der Dichte (aufgerundet) multiplizieren, um die Höhe der Statusleiste auf jedem Gerät zu erhalten:

int statusBarHeight = Math.ceil(25 * context.getResources().getDisplayMetrics().density);

Als Referenz: ldpi = 0,75, mdpi = 1, hdpi = 1,5, xhdpi = 2

Das Hardcodieren der Größe oder das Verwenden von Reflexion, um den Wert von zu erhalten, status_bar_heightwird als schlechte Praxis angesehen. Chris Banes hat auf der Droidcon New York darüber gesprochen . Die empfohlene Methode zum Abrufen der Größe der Statusleiste ist der OnApplyWindowInsetsListener :

myView.setOnApplyWindowInsetsListener { view, insets -> {
  val statusBarSize = insets.systemWindowInsetTop
  return insets
}

Dies wurde in API 20 hinzugefügt und wird auch über ViewAppCompat zurückportiert .

Ich habe einige Lösungen zusammengeführt:

public static int getStatusBarHeight(final Context context) {
    final Resources resources = context.getResources();
    final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
    if (resourceId > 0)
        return resources.getDimensionPixelSize(resourceId);
    else
        return (int) Math.ceil((VERSION.SDK_INT >= VERSION_CODES.M ? 24 : 25) * resources.getDisplayMetrics().density);
    }

eine andere Alternative:

    final View view = findViewById(android.R.id.content);
    runJustBeforeBeingDrawn(view, new Runnable() {
        @Override
        public void run() {
            int statusBarHeight = getResources().getDisplayMetrics().heightPixels - view.getMeasuredHeight();
        }
    });

BEARBEITEN: Alternative zu runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

Gemäß den Google-Designrichtlinien ; Die Höhe der Statusleiste beträgt 24 dp.

Wenn Sie die Höhe der Statusleiste in Pixel erhalten möchten, können Sie die folgende Methode verwenden:

private static int statusBarHeight(android.content.res.Resources res) {
    return (int) (24 * res.getDisplayMetrics().density);
}

die von Aktivität mit aufgerufen werden kann mit:

statusBarHeight(getResources());

Die Standardhöhe war 25dp. Mit Android Marshmallow (API 23) wurde die Höhe auf 24dp reduziert.

Update: Bitte beachten Sie, dass die Verwendung einer statischen Höhe für die Statusleiste seit Beginn des Zeitalters der Kerben und Lochkameras nicht mehr funktioniert. Bitte verwenden Sie stattdessen Fenstereinsätze!

Dies funktioniert auch mit dem Refrence- Link

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

Ich habe das gleiche Problem, dass ich die Höhe der Statusleiste in einem onCreate abrufen muss. Das funktioniert bei mir.

private static final int LOW_DPI_STATUS_BAR_HEIGHT = 19;

private static final int MEDIUM_DPI_STATUS_BAR_HEIGHT = 25;

private static final int HIGH_DPI_STATUS_BAR_HEIGHT = 38;

Innerhalb des onCreate:

DisplayMetrics displayMetrics = new DisplayMetrics();
((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getMetrics(displayMetrics);

int statusBarHeight;

switch (displayMetrics.densityDpi) {
    case DisplayMetrics.DENSITY_HIGH:
        statusBarHeight = HIGH_DPI_STATUS_BAR_HEIGHT;
        break;
    case DisplayMetrics.DENSITY_MEDIUM:
        statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT;
        break;
    case DisplayMetrics.DENSITY_LOW:
        statusBarHeight = LOW_DPI_STATUS_BAR_HEIGHT;
        break;
    default:
        statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT;
}

Sehen:

http://developer.android.com/reference/android/util/DisplayMetrics.html http://developer.android.com/guide/practices/ui_guidelines/icon_design.html

Die offizielle Größe ist 24dp, wie von Google offiziell auf der Android Design-Webseite angegeben .

Ja, wenn ich es mit View versuche, liefert es das Ergebnis von 25px. Hier ist der gesamte Code:

public class SpinActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LinearLayout lySpin = new LinearLayout(this);
        lySpin.setOrientation(LinearLayout.VERTICAL);       
        lySpin.post(new Runnable()
        {
            public void run()
            {
                Rect rect = new Rect();
                Window window = getWindow();
                window.getDecorView().getWindowVisibleDisplayFrame(rect);
                int statusBarHeight = rect.top;
                int contentViewTop = 
                    window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
                int titleBarHeight = contentViewTop - statusBarHeight;
                System.out.println("TitleBarHeight: " + titleBarHeight 
                    + ", StatusBarHeight: " + statusBarHeight);
            }
        }
    }
}

240 x 320 - 20 Pixel

320 x 480 - 25 Pixel

480 x 800 + - 38 Pixel

Versuche dies:

    Rect rect = new Rect();
    Window win = this.getWindow();
    win.getDecorView().getWindowVisibleDisplayFrame(rect);
    int statusBarHeight = rect.top;
    int contentViewTop = win.findViewById(Window.ID_ANDROID_CONTENT).getTop();
    int titleBarHeight = contentViewTop - statusBarHeight;
    Log.d("ID-ANDROID-CONTENT", "titleBarHeight = " + titleBarHeight );

Bei der onCreate-Methode für die Aktivität hat es bei mir nicht funktioniert, aber beim Einfügen in einen onClickListener und bei einer Messung von 25

Die Höhe der Statusleiste beträgt 24dp in Android 6.0

 <!-- Height of the status bar -->
 <dimen name="status_bar_height">24dp</dimen>
 <!-- Height of the bottom navigation / system bar. -->
 <dimen name="navigation_bar_height">48dp</dimen>

Die Antwort finden Sie im Quellcode: Frameworks \ Base \ Core \ Res \ Res \ Values ​​\ Dimens.xml

Um dies zu lösen, habe ich einen Kombinationsansatz verwendet. Dies ist erforderlich, da auf Tablets die Systemleiste bereits die Pixel subtrahiert, wenn display.getHeight () aufgerufen wird. Also überprüfe ich zuerst, ob eine Systemleiste vorhanden ist, und dann Ben Claytons Ansatz, der auf Telefonen gut funktioniert.

public int getStatusBarHeight() {
    int statusBarHeight = 0;

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

    return statusBarHeight;
}

private boolean hasOnScreenSystemBar() {
    Display display = getWindowManager().getDefaultDisplay();
    int rawDisplayHeight = 0;
    try {
        Method getRawHeight = Display.class.getMethod("getRawHeight");
        rawDisplayHeight = (Integer) getRawHeight.invoke(display);
    } catch (Exception ex) {
    }

    int UIRequestedHeight = display.getHeight();

    return rawDisplayHeight - UIRequestedHeight > 0;
}

Dank @Niklas +1 ist dies der richtige Weg.

public class MyActivity extends Activity implements android.support.v4.View.OnApplyWindowInsetsListener {

    Rect windowInsets;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.my_activity);

        View rootview = findViewById(android.R.id.content);

        android.support.v4.View.ViewCompat.setOnApplyWindowInsetsListener(rootview, this);
    }

    android.support.v4.View.WindowInsetsCompat android.support.v4.View.OnApplyWindowInsetsListener.OnApplyWindowInsets(View v, android.support.v4.View.WindowInsetsCompat insets)
    {
        windowInsets = new Rect();
        windowInsets.set(insets.getSystemWindowInsetLeft(), insets.getSystemWindowInsetTop(), insets.getSystemWindowInsetRight(), insets.getSystemWindowInsetBottom());
        //StatusBarHeight = insets.getSystemWindowInsetTop();

        //Refresh/Adjust view accordingly

        return insets;
    }
}

Bitte entschuldigen Sie, wenn der Code nicht 100% korrekt ist, konvertieren Sie ihn von Xamarin C #, aber dies ist das Richtige. Funktioniert mit Kerben usw.

Umgeschaltete Vollbildlösung:

Diese Lösung mag wie eine Problemumgehung aussehen, berücksichtigt jedoch tatsächlich, ob Ihre App im Vollbildmodus angezeigt wird (auch bekannt als Ausblenden der Statusleiste) oder nicht:

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point(); display.getSize(size);
int barheight = size.y - findViewById(R.id.rootView).getHeight();

Wenn Ihre App derzeit im Vollbildmodus angezeigt barheightwird, entspricht dies 0.

Persönlich musste ich dies verwenden, um absolute TouchEvent-Koordinaten zu korrigieren, um die Statusleiste wie folgt zu berücksichtigen:

@Override
public boolean onTouch(View view,MotionEvent event) {
    Display display = getWindowManager().getDefaultDisplay();
    Point size = new Point(); display.getSize(size);
    int YCoord = (int)event.getRawY() - size.y + rootView.getHeight());
}

Und das wird die absolute y-Koordinate erhalten, ob die App Vollbild ist oder nicht.

Genießen

Unter Android 4.1 und höher können Sie festlegen, dass der Inhalt Ihrer Anwendung hinter der Statusleiste angezeigt wird, damit die Größe des Inhalts nicht geändert wird, wenn die Statusleiste ausgeblendet und angezeigt wird. Verwenden Sie dazu SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Möglicherweise müssen Sie auch SYSTEM_UI_FLAG_LAYOUT_STABLE verwenden, damit Ihre App ein stabiles Layout beibehält.

Wenn Sie diesen Ansatz verwenden, liegt es in Ihrer Verantwortung, sicherzustellen, dass kritische Teile der Benutzeroberfläche Ihrer App (z. B. die in einer Maps-Anwendung integrierten Steuerelemente) nicht von Systemleisten abgedeckt werden. Dies könnte Ihre App unbrauchbar machen. In den meisten Fällen können Sie dies tun, indem Sie das Attribut android: fitSystemWindows zu Ihrer XML-Layoutdatei hinzufügen, das auf true festgelegt ist. Dadurch wird der Abstand der übergeordneten ViewGroup angepasst, um Platz für die Systemfenster zu lassen. Dies ist für die meisten Anwendungen ausreichend.

In einigen Fällen müssen Sie jedoch möglicherweise die Standardauffüllung ändern, um das gewünschte Layout für Ihre App zu erhalten. Überschreiben Sie fitSystemWindows (Rect-Einfügungen), um direkt zu steuern, wie Ihr Inhalt relativ zu den Systemleisten angeordnet ist (die einen Bereich einnehmen, der als "Inhaltseinfügungen" des Fensters bezeichnet wird). Die Methode fitSystemWindows () wird von der Ansichtshierarchie aufgerufen, wenn sich die Inhaltseinfügungen für ein Fenster geändert haben, damit das Fenster seinen Inhalt entsprechend anpassen kann. Durch Überschreiben dieser Methode können Sie die Einfügungen (und damit das Layout Ihrer App) beliebig behandeln.

Formular: https://developer.android.com/training/system-ui/status.html#behind

Wenn Sie genau die Größe VS Höhe kennen

mögen

Bei einem Gerät mit einer Bildschirmgröße von 320 x 480 beträgt die Statusleistenhöhe beispielsweise 25 Pixel. Bei einem Gerät mit 480 x 800 muss die Statusleistenhöhe 38 Pixel betragen

Dann können Sie einfach die Breite Ihrer Ansicht / die Bildschirmgröße abrufen. Sie können einfach eine if else-Anweisung verwenden, um die Höhe der Statusleiste abzurufen

Der Grund, warum die Top-Antwort für einige Benutzer nicht funktioniert, liegt darin, dass Sie die Abmessungen einer Ansicht erst abrufen können, wenn sie zum Rendern bereit ist. Verwenden Sie ein OnGlobalLayoutListener, um die angegebenen Abmessungen zu erhalten, wenn Sie tatsächlich können:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    final ViewGroup decorView = (ViewGroup) this.getWindow().getDecorView();
    decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            if (Build.VERSION.SDK_INT >= 16) {
                decorView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
            } else {
                // Nice one, Google
                decorView.getViewTreeObserver().removeGlobalOnLayoutListener(this);
            }
            Rect rect = new Rect();
            decorView.getWindowVisibleDisplayFrame(rect);
            rect.top; // This is the height of the status bar
        }
    }
}

Dies ist die zuverlässigste Methode.

Da der Mehrfenstermodus jetzt verfügbar ist, hat Ihre App möglicherweise keine Statusleiste oben.

Die folgende Lösung behandelt alle Fälle automatisch für Sie.

android:fitsSystemWindows="true"

oder programmatisch

findViewById(R.id.your_root_view).setFitsSystemWindows(true);

Sie können auch Root-Ansicht von erhalten

findViewById(android.R.id.content).getRootView();
or
getWindow().getDecorView().findViewById(android.R.id.content)

Weitere Informationen zum Abrufen der Root-Ansicht finden Sie unter https://stackoverflow.com/a/4488149/9640177

Dieses Problem wurde kürzlich für mich aufgrund der Kerbe in meinem Pixel 3XL relevant. Ich mochte die Lösung für Android-Entwickler sehr , aber ich wollte in der Lage sein, die Höhe der Statusleiste nach Belieben zu ermitteln, da dies speziell für eine Vollbildanimation erforderlich war, die ich abspielen musste. Die folgende Funktion ermöglichte eine zuverlässige Abfrage:

private val DEFAULT_INSET = 96
fun getInsets(view: View?): Int {
     var inset = DEFAULT_INSET
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {//Safe because only P supports notches
          inset = view?.rootWindowInsets?.stableInsetTop ?: DEFAULT_INSET
     }
     return inset
}

fun blurView(rootView: View?, a: SpacesActivity?) {
    val screenBitmap = getBitmapFromView(rootView!!)
    val heightDifference = getInsets(rootView)
    val croppedMap = Bitmap.createBitmap(
                    screenBitmap, 0, heightDifference,
                    screenBitmap.width,
                    screenBitmap.height - heightDifference)
    val blurredScreen = blurBitmap(croppedMap)
    if (blurredScreen != null) {
         val myDrawable = BitmapDrawable(a!!.resources, blurredScreen)
         a.errorHudFrameLayout?.background = myDrawable
         a.appBarLayout?.visibility = View.INVISIBLE
   }
}

Und dann in der Aktivitätsklasse:

fun blurView() {
    this.runOnUiThread {
        Helper.blurView(this)
    }
}

Sie möchten natürlich eine schwache Referenz der Aktivität an den statischen Parameter der Helper-Klassenmethode übergeben, aber der Kürze halber habe ich in diesem Beispiel darauf verzichtet. Die blurBitmapund errorHudFrameLayoutwerden aus demselben Grund weggelassen, da sie nicht direkt mit dem Abrufen der Höhe der Statusleiste zusammenhängen.

Kotlin-Version, die zwei beste Lösungen kombiniert

fun getStatusBarHeight(): Int {
    val resourceId = resources.getIdentifier("status_bar_height", "dimen", "android")
    return if (resourceId > 0) resources.getDimensionPixelSize(resourceId)
    else Rect().apply { window.decorView.getWindowVisibleDisplayFrame(this) }.top
}

1. Nimmt status_bar_heightWert, wenn vorhanden
2. Wenn status_bar_heightnicht vorhanden, wird die Höhe der Statusleiste aus dem Fensterdekor berechnet