Hauteur de la barre d'état dans Android

de tous les échantillons 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 méthode onCreate d'un Activity est ceci:

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 comme une ressource Android. Le code ci-dessus peut être ajouté à une classe ContextWrapper (par exemple un Activity ).

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

sur les appareils MDPI, la barre d'état est de 25px. Nous pouvons l'utiliser comme base et la multiplier par la densité (arrondie) 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=.75, mdpi=1, hdpi= 1,5, xhdpi=2

selon Google design guidelines ; hauteur de la barre d'état est de 24 dp.

si vous voulez obtenir la hauteur de la barre d'état en pixels, vous pouvez utiliser la méthode suivante:

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

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

cela fonctionne aussi avec la référence 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;
}

coder en dur la taille ou à l'aide de la réflexion pour obtenir la valeur de status_bar_height est 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
}

ceci a été ajouté dans API 20 et est également rétroporté via ViewAppCompat .

j'ai le même problème de devoir 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 de la 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

Oui, quand je l'ai essayer avec Vue il fournit le résultat de 25px. Voici le code complet:

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

hauteur officielle est 24dp , comme il est déclaré officiellement par Google sur Android Design webpage .

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

240x320 - 20px

320x480-25px

480x800+ - 38px

essayez ceci:

    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 oncréate pour l'activité, mais l'a fait quand je l'ai mis dans un onClickListener et m'a donné une mesure de 25

pour résoudre ceci, j'ai utilisé une approche combinée. Cela est nécessaire car sur les tablettes la barre de système soustrait déjà ses pixels lors de l'affichage.getHeight () est appelé. Donc je vérifie d'abord si une barre système est présente, puis L'approche de Ben Claytons, qui fonctionne très 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;
}

la hauteur de la barre d'état est 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: cadres\base\core\res\res\les valeurs de\dimens.xml

Solution Complète Sur Écran Partagé:

cette solution peut ressembler à une solution de contournement, mais elle tient compte du fait que votre application est fullscreen (alias cacher 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, barheight sera égal à 0.

personnellement, j'ai dû l'utiliser pour corriger les coordonnées absolues de TouchEvent pour rendre 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 qui obtiendra la coordonnée y absolue que l'application soit fullscreen ou non.

Profiter

sur Android 4.1 et supérieur, vous pouvez définir le contenu de votre application pour apparaître derrière la barre de statut, de sorte que le contenu ne se redimensionne pas que la barre de statut se cache et montre. Pour ce faire, utilisez SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Vous pouvez également avoir besoin D'utiliser SYSTEM_UI_FLAG_LAYOUT_STABLE pour aider votre application à maintenir 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 commandes intégrées dans une application Maps) ne vous retrouvez pas couvert 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 mise en page XML, défini à true. Ceci ajuste le rembourrage du groupe de vue parent pour laisser de l'espace pour les fenêtres du système. Cela est suffisant pour la plupart des applications.

dans certains cas, cependant, vous pouvez avoir besoin de modifier le padding par défaut pour obtenir la mise en page désirée pour votre application. De manipulez directement la disposition de votre contenu par rapport aux barres système (qui occupent un espace connu sous le nom de fenêtre "content insets"), outrepassez fitSystemWindows(Rect insets). La méthode fitSystemWindows () est appelée par la hiérarchie de la vue lorsque les insets de contenu pour une fenêtre ont changé, pour permettre à la fenêtre d'ajuster son contenu en conséquence. En outrepassant cette méthode, vous pouvez gérer les insets (et donc la mise en page de votre application) comme vous le souhaitez.

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

si vous connaissez exactement la taille en fonction de la hauteur

comme

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

alors vous pouvez juste obtenir la largeur de votre vue / la taille de l'écran vous pouvez juste utiliser un If else statement pour obtenir la hauteur de la barre d'état

la raison pour laquelle la réponse supérieure ne fonctionne pas pour certaines personnes est que vous ne pouvez pas obtenir les dimensions d'une vue jusqu'à ce qu'elle soit prête à rendre. Utilisez un OnGlobalLayoutListener pour obtenir ces dimensions alors que 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
        }
    }
}

C'est la méthode la plus fiable.