Wysokość paska stanu w systemie Android

Jaka jest wysokość paska stanu w Androidzie? Czy zawsze jest tak samo?

Z moich pomiarów wynika, że ​​jest to 25dp, ale nie jestem pewien, czy ma taką samą wysokość na wszystkich platformach.

(Chcę to wiedzieć, aby poprawnie zaimplementować przejście zanikania z działania, które nie ma paska stanu na takie, które ma)

na to pytanie odpowiedziano wcześniej ... Wysokość paska stanu?

Aktualizacja ::

Obecna metoda:

ok, wysokość paska stanu zależy od rozmiaru ekranu, na przykład w urządzeniu o rozmiarze ekranu 240 x 320 wysokość paska stanu wynosi 20px, w przypadku urządzenia o rozmiarze ekranu 320 x 480 wysokość paska stanu wynosi 25px, dla urządzenie o rozdzielczości 480 x 800 wysokość paska stanu musi wynosić 38 pikseli

więc polecam użyć tego skryptu, aby uzyskać wysokość paska stanu

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

(stara metoda), aby uzyskać wysokość paska stanu w onCreate()metodzie działania, użyj tej metody:

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

Ze wszystkich próbek kodu, których użyłem, aby uzyskać wysokość paska stanu, jedyny, który wydaje się działać w onCreatemetodzie an Activityto:

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

Najwyraźniej rzeczywista wysokość paska stanu jest przechowywana jako zasób Androida. Powyższy kod można dodać do ContextWrapperklasy (np. An Activity).

Znaleziono pod adresem http://mrtn.me/blog/2012/03/17/get-the-height-of-the-status-bar-in-android/

Na urządzeniach MDPI pasek stanu ma 25px. Możemy użyć tego jako podstawy i pomnożyć go przez gęstość (zaokrągloną w górę), aby uzyskać wysokość paska stanu na dowolnym urządzeniu:

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

Dla porównania: ldpi = .75, mdpi = 1, hdpi = 1,5, xhdpi = 2

Zakodowanie wielkości lub użycie odbicia w celu uzyskania wartości status_bar_heightjest uważane za złą praktykę. Chris Banes mówił o tym w Droidcon w Nowym Jorku . Zalecanym sposobem uzyskania rozmiaru paska stanu jest użycie OnApplyWindowInsetsListener :

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

Zostało to dodane w API 20 i jest również backportowane przez ViewAppCompat .

Połączyłem niektóre rozwiązania razem:

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

inna alternatywa:

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

EDYCJA: Alternatywa dla runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

Zgodnie z wytycznymi projektowymi Google ; wysokość paska stanu wynosi 24 dp.

Jeśli chcesz uzyskać wysokość paska stanu w pikselach, możesz użyć poniższej metody:

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

które można wywołać z działania z:

statusBarHeight(getResources());

Domyślna wysokość wynosiła 25dp. W Androidzie Marshmallow (API 23) wysokość została zmniejszona do 24dp.

Aktualizacja: należy pamiętać, że od czasów, w których zaczęły się ery wycięć i aparatów wykrawających, używanie statycznej wysokości paska stanu już nie działa. Zamiast tego użyj wstawek okiennych!

działa to również z linkiem referencyjnym

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

Mam ten sam problem z koniecznością uzyskania wysokości paska stanu w obiekcie onCreate. To działa dla mnie.

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;

Wewnątrz 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;
}

Widzieć:

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

Oficjalna wysokość jest 24dp, zgodnie z oficjalnym stwierdzeniem Google na stronie Android Design .

Tak, kiedy próbuję z View, daje wynik 25px. Oto cały kod:

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

240x320 - 20px

320 x 480 - 25 pikseli

480x800 + - 38px

Spróbuj tego:

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

nie działało to dla mnie w metodzie onCreate dla działania, ale działało, gdy umieściłem go w onClickListener i dał mi pomiar 25

wysokość paska stanu wynosi 24dp w Androidzie 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>

odpowiedź znajdziesz w kodzie źródłowym: frameworks \ base \ core \ res \ res \ values ​​\ dimens.xml

Aby rozwiązać ten problem, zastosowałem podejście kombinowane. Jest to konieczne, ponieważ na tabletach pasek systemowy odejmuje już swoje piksele po wywołaniu metody display.getHeight (). Najpierw sprawdzam, czy pasek systemowy jest obecny, a następnie zbliża się Ben Claytons, który działa dobrze na telefonach.

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

Dzięki @Niklas +1 jest to właściwy sposób, aby to zrobić.

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

Przepraszam, jeśli kod nie jest w 100% poprawny, przekonwertowałem go z Xamarin C #, ale to jest właśnie tego. Działa z wycięciami itp.

Przełączone rozwiązanie pełnoekranowe:

To rozwiązanie może wyglądać jak obejście, ale w rzeczywistości bierze pod uwagę to, czy aplikacja działa na pełnym ekranie (czyli ukrywanie paska stanu), czy nie:

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

W ten sposób, jeśli Twoja aplikacja jest obecnie na pełnym ekranie, barheight będzie równa 0.

Osobiście musiałem to wykorzystać do skorygowania bezwzględnych współrzędnych TouchEvent, aby uwzględnić pasek stanu w następujący sposób:

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

I to uzyska absolutną współrzędną y, niezależnie od tego, czy aplikacja będzie pełnoekranowa, czy nie.

Cieszyć się

W Androidzie 4.1 i nowszych możesz ustawić zawartość aplikacji tak, aby pojawiała się za paskiem stanu, aby zawartość nie zmieniała się, ponieważ pasek stanu ukrywa się i pokazuje. Aby to zrobić, użyj SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Konieczne może być również użycie SYSTEM_UI_FLAG_LAYOUT_STABLE, aby pomóc aplikacji zachować stabilny układ.

Gdy zastosujesz to podejście, Twoim obowiązkiem jest upewnić się, że krytyczne części interfejsu aplikacji (na przykład wbudowane elementy sterujące w aplikacji Mapy) nie zostaną zakryte przez paski systemowe. Może to spowodować, że Twoja aplikacja będzie bezużyteczna. W większości przypadków można sobie z tym poradzić, dodając atrybut android: fitsSystemWindows do pliku układu XML, ustawiony na wartość true. Dostosowuje to dopełnienie nadrzędnej grupy ViewGroup, aby pozostawić miejsce dla okien systemu. Jest to wystarczające dla większości aplikacji.

W niektórych przypadkach może być jednak konieczne zmodyfikowanie domyślnego dopełnienia, aby uzyskać pożądany układ aplikacji. Aby bezpośrednio manipulować układem zawartości w stosunku do pasków systemowych (które zajmują przestrzeń zwaną „wstawkami zawartości” okna), należy przesłonić fitSystemWindows (wstawki Rect). Metoda fitSystemWindows () jest wywoływana przez hierarchię widoku, gdy zmieniają się wstawki zawartości okna, aby umożliwić odpowiednie dostosowanie zawartości okna. Przesłaniając tę ​​metodę, możesz obsługiwać wstawki (a więc i układ aplikacji) w dowolny sposób.

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

Jeśli znasz dokładnie rozmiar VS wysokość

lubić

na przykład w urządzeniu o rozmiarze ekranu 320 x 480 wysokość paska stanu wynosi 25 pikseli, w przypadku urządzenia o rozdzielczości 480 x 800 wysokość paska stanu musi wynosić 38 pikseli

możesz po prostu uzyskać szerokość widoku / rozmiar ekranu, wystarczy użyć instrukcji if else, aby uzyskać wysokość paska stanu

Powodem, dla którego najlepsza odpowiedź nie działa dla niektórych osób, jest to, że nie można uzyskać wymiarów widoku, dopóki nie będzie on gotowy do renderowania. Użyj a, OnGlobalLayoutListeneraby uzyskać wspomniane wymiary, kiedy faktycznie możesz:

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

To najbardziej niezawodna metoda.

Ponieważ tryb wielu okien jest już dostępny, aplikacja może nie mieć paska stanu u góry.

Po rozwiązaniu automatycznie załatw wszystkie sprawy.

android:fitsSystemWindows="true"

lub programowo

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

możesz również uzyskać widok roota przez

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

Aby uzyskać więcej informacji na temat uzyskiwania widoku głównego, patrz: https://stackoverflow.com/a/4488149/9640177

Ten problem stał się ostatnio dla mnie istotny ze względu na wycięcie w moim Pixelu 3XL. Naprawdę podobało mi się rozwiązanie dla programistów Androida , ale chciałem mieć możliwość uzyskania wysokości paska stanu do woli, ponieważ było to szczególnie potrzebne do animacji pełnoekranowej, w którą musiałem grać. Poniższa funkcja umożliwiła niezawodne zapytanie:

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

A potem w klasie aktywności:

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

Oczywiście będziesz chciał przekazać słabe odniesienie aktywności do parametru metody statycznej klasy Helper, ale dla zwięzłości powstrzymałem się w tym przykładzie. blurBitmapI errorHudFrameLayoutsą pomijane z tego samego powodu, ponieważ nie odnoszą się bezpośrednio do uzyskania wysokość paska stanu.

Wersja Kotlin, która łączy dwa najlepsze rozwiązania

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. Trwa status_bar_height wartość, jeśli występuje
2. Jeśli status_bar_heightnie jest obecny, oblicza wysokość paska stanu na podstawie wystroju okna