Hauteur de la barre d'état dans Android

Quelle est la hauteur de la barre d'état dans Android? Est-ce toujours la même chose?

D'après mes mesures, il semble que ce soit 25dp, mais je ne sais pas s'il a la même hauteur sur toutes les plateformes.

(Je veux savoir ceci pour implémenter correctement une transition de fondu d'une activité qui n'a pas de barre d'état à une qui en a)

cette question a été répondue avant ... Hauteur de la barre d'état?

Mise à jour ::

Méthode actuelle:

ok, la hauteur de la barre d'état dépend de la taille de l'écran, par exemple dans un appareil avec une taille d'écran de 240 X 320 la hauteur de la barre d'état est de 20 pixels, pour un appareil avec une taille d'écran de 320 X 480 la hauteur de la barre d'état est de 25 pixels, pour un appareil avec 480 x 800 la hauteur de la barre d'état doit être de 38 px

donc je recommande d'utiliser ce script pour obtenir la hauteur de la barre d'état

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

(ancienne méthode) pour obtenir la hauteur de la barre d'état sur la onCreate()méthode de votre activité, utilisez cette méthode:

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

De tous les exemples de code que j'ai utilisés pour obtenir la hauteur de la barre d'état, le seul qui semble réellement fonctionner dans la onCreateméthode d'un Activityest le suivant:

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

Apparemment, la hauteur réelle de la barre d'état est conservée en tant que ressource Android. Le code ci-dessus peut être ajouté à une ContextWrapperclasse (par exemple un Activity).

Trouvé sur http://mrtn.me/blog/2012/03/17/get-the-height-of-the-status-bar-in-android/

Sur les périphériques MDPI, la barre d'état est de 25 pixels. Nous pouvons l'utiliser comme base et le multiplier par la densité (arrondie vers le haut) pour obtenir la hauteur de la barre d'état sur n'importe quel appareil:

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

Pour référence: ldpi = 0,75, mdpi = 1, hdpi = 1,5, xhdpi = 2

Coder en dur la taille ou utiliser la réflexion pour obtenir la valeur de status_bar_heightest considéré comme une mauvaise pratique. Chris Banes en a parlé au Droidcon New York . La méthode recommandée pour obtenir la taille de la barre d'état est via le OnApplyWindowInsetsListener :

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

Cela a été ajouté dans l'API 20 et est également rétroporté via ViewAppCompat .

J'ai fusionné quelques solutions ensemble:

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

une autre alternative:

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

EDIT: Alternative à runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

Selon les directives de conception de Google ; la hauteur de la barre d'état est de 24 dp.

Si vous souhaitez obtenir la hauteur de la barre d'état en pixels, vous pouvez utiliser la méthode ci-dessous:

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

qui peut être appelé de l'activité avec:

statusBarHeight(getResources());

La hauteur par défaut était de 25dp. Avec Android Marshmallow (API 23), la hauteur a été réduite à 24dp.

Mise à jour: veuillez noter que depuis l'âge des encoches et des caméras perforées, l'utilisation d'une hauteur statique pour la barre d'état ne fonctionne plus. Veuillez utiliser des encarts de fenêtre à la place!

cela fonctionne également avec le lien de réfraction

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

J'ai le même problème d'avoir à obtenir la hauteur de la barre d'état dans un onCreate. Cela fonctionne pour moi.

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;

À l'intérieur du 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;
}

Voir:

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

La hauteur officielle est 24dp, comme indiqué officiellement par Google sur la page Web Android Design .

Oui, lorsque je l'essaye avec View, il fournit le résultat de 25 pixels. Voici tout le 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);
            }
        }
    }
}

240x320 - 20px

320x480 - 25px

480x800 + - 38px

Essaye ça:

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

cela n'a pas fonctionné pour moi dans la méthode onCreate pour l'activité, mais l'a fait quand je l'ai mis dans un onClickListener et m'a donné une mesure de 25

la hauteur de la barre d'état est de 24dp dans 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>

vous pouvez trouver la réponse dans le code source: frameworks \ base \ core \ res \ res \ values ​​\ dimens.xml

Pour résoudre ce problème, j'ai utilisé une approche combinée. Cela est nécessaire car sur les tablettes, la barre système soustrait déjà ses pixels lorsque display.getHeight () est appelé. Je vérifie donc d'abord si une barre système est présente, puis l'approche de Ben Claytons, qui fonctionne bien sur les téléphones.

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

Grâce à @Niklas +1, c'est la bonne façon de procéder.

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

Veuillez m'excuser si le code n'est pas correct à 100%, converti à partir de Xamarin C # mais c'est juste. Fonctionne avec des encoches, etc.

Solution plein écran basculée:

Cette solution peut ressembler à une solution de contournement, mais elle explique en fait si votre application est en plein écran (aka masquer la barre d'état) ou non:

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

De cette façon, si votre application est actuellement en plein écran, elle barheightsera égale à 0.

Personnellement, j'ai dû utiliser cela pour corriger les coordonnées absolues de TouchEvent pour tenir compte de la barre d'état comme suit:

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

Et cela obtiendra la coordonnée absolue absolue, que l'application soit en plein écran ou non.

Prendre plaisir

Sur Android 4.1 et supérieur, vous pouvez définir le contenu de votre application pour qu'il apparaisse derrière la barre d'état, afin que le contenu ne se redimensionne pas lorsque la barre d'état se cache et s'affiche. Pour ce faire, utilisez SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Vous devrez peut-être également utiliser SYSTEM_UI_FLAG_LAYOUT_STABLE pour aider votre application à conserver une mise en page stable.

Lorsque vous utilisez cette approche, il devient de votre responsabilité de vous assurer que les parties critiques de l'interface utilisateur de votre application (par exemple, les contrôles intégrés dans une application Maps) ne finissent pas par être couvertes par des barres système. Cela pourrait rendre votre application inutilisable. Dans la plupart des cas, vous pouvez gérer cela en ajoutant l'attribut android: fitsSystemWindows à votre fichier de disposition XML, défini sur true. Cela ajuste le remplissage du ViewGroup parent pour laisser de l'espace aux fenêtres système. C'est suffisant pour la plupart des applications.

Dans certains cas, cependant, vous devrez peut-être modifier le remplissage par défaut pour obtenir la mise en page souhaitée pour votre application. Pour manipuler directement la présentation de votre contenu par rapport aux barres système (qui occupent un espace connu sous le nom de "insertions de contenu" de la fenêtre), remplacez fitSystemWindows (insertions rect). La méthode fitSystemWindows () est appelée par la hiérarchie des vues lorsque les encarts de contenu d'une fenêtre ont changé, pour permettre à la fenêtre d'ajuster son contenu en conséquence. En remplaçant cette méthode, vous pouvez gérer les encarts (et donc la disposition de votre application) comme vous le souhaitez.

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

Si vous connaissez exactement la taille VS hauteur

comme

par exemple, dans un appareil avec une taille d'écran de 320 X 480, la hauteur de la barre d'état est de 25 pixels, pour un appareil avec 480 x 800, la hauteur de la barre d'état doit être de 38 pixels.

alors vous pouvez simplement obtenir la largeur de votre vue / la taille de l'écran, vous pouvez simplement utiliser une instruction if else pour obtenir la hauteur de la barre d'état

La raison pour laquelle la première réponse ne fonctionne pas pour certaines personnes est que vous ne pouvez pas obtenir les dimensions d'une vue tant qu'elle n'est pas prête à être rendue. Utilisez un OnGlobalLayoutListenerpour obtenir ces dimensions lorsque vous pouvez réellement:

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

Il s'agit de la méthode la plus fiable.

Étant donné que le mode multi-fenêtres est maintenant disponible, votre application peut ne pas avoir de barre d'état en haut.

La solution suivante gère automatiquement tous les cas pour vous.

android:fitsSystemWindows="true"

ou par programme

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

vous pouvez également obtenir une vue racine par

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

Pour plus de détails sur l'obtention de la vue racine, consultez - https://stackoverflow.com/a/4488149/9640177

Ce problème est récemment devenu pertinent pour moi en raison de l'encoche de mon Pixel 3XL. J'ai vraiment aimé la solution du développeur Android , mais je voulais pouvoir obtenir la hauteur de la barre d'état à volonté, car elle était spécifiquement nécessaire pour une animation plein écran que je devais jouer. La fonction ci-dessous a permis une requête fiable:

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

Et puis dans la classe d'activité:

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

Vous voudrez bien sûr faire passer une référence faible de l'activité au paramètre de méthode de la classe Helper statique, mais par souci de concision, je me suis abstenu dans cet exemple. Les blurBitmapet errorHudFrameLayoutsont omis pour la même raison, car ils ne concernent pas directement l'obtention de la hauteur de la barre d'état.

Version Kotlin qui combine deux meilleures solutions

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. Prend de la status_bar_heightvaleur si elle est présente
2. Si status_bar_heightn'est pas présent, calcule la hauteur de la barre d'état à partir du décor de fenêtre