Hauteur de la barre d'état sous 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 suis pas sûr si elle a la même hauteur sur toutes les plateformes.
(Je veux le savoir pour implémenter correctement une transition en fondu d’une activité qui n’a pas de barre d’état à une autre)
cette question a reçu une réponse avant ... Hauteur de la barre d'état?
Mettre à 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 de 320 x 480 pixels, la hauteur de la barre d'état est de 25 pixels. , pour un appareil de 480 x 800, la hauteur de la barre d'état doit être de 38 pixels
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 méthode onCreate() 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;
}
Parmi tous les exemples de code que j'ai utilisés pour obtenir la hauteur de la barre d'état, le seul qui semble fonctionner dans la méthode onCreate d'une Activity est la suivante:
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 classe ContextWrapper (par exemple une Activity).
Trouvé à 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 25px. Nous pouvons l'utiliser comme base et la multiplier par la densité (arrondie à la hausse) pour obtenir la hauteur de la barre d'état sur n'importe quel périphérique:
int statusBarHeight = Math.ceil(25 * context.getResources().getDisplayMetrics().density);
Pour référence: ldpi = 0,75, mdpi = 1, hdpi = 1,5, xhdpi = 2
J'ai fusionné des 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
Coder en dur la taille ou utiliser la réflexion pour obtenir la valeur de status_bar_height est considéré comme une mauvaise pratique. Chris Banes en a parlé à Droidcon New York }. La méthode recommandée pour obtenir la taille de la barre d'état consiste à utiliser OnApplyWindowInsetsListener :
myView.setOnApplyWindowInsetsListener { view, insets -> {
val statusBarSize = insets.systemWindowInsetTop
return insets
}
Cela a été ajouté à l'API 20 et est également rétroporté via ViewAppCompat .
Selon les directives de conception de Google ; la 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 ci-dessous:
private static int statusBarHeight(Android.content.res.Resources res) {
return (int) (24 * res.getDisplayMetrics().density);
}
qui peut être appelé d'activité avec:
statusBarHeight(getResources());
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;
}
La hauteur officielle est 24dp, .__, comme indiqué officiellement par Google sur Page Web Android Design .
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;
Dans le 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.htmlhttp://developer.Android.com/guide/practices/ui_guidelines/icon_design.html
La hauteur par défaut était de 25dp. Avec Android Marshmallow (API 23), la hauteur a été réduite à 24dp.
Oui, lorsque je l'essaie avec View, le résultat est 25px .
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 été quand je l'ai mise 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 . Ceci est nécessaire car sur les tablettes, la barre système soustrait déjà ses pixels lorsque display.getHeight () est appelé . Je vérifie d’abord si une barre système est présente et puis Ben Clayton approche, ce 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;
}
Solution plein écran bascule:
Cette solution peut ressembler à une solution de contournement, mais elle permet de déterminer si votre application est en plein écran (masquant 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();
Ainsi, si votre application est actuellement en plein écran, barheight sera égal à 0.
Personnellement, je devais l'utiliser pour corriger les coordonnées absolues de TouchEvent afin de prendre en compte la barre d'état de la manière suivante:
@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 y absolue, que l'application soit en plein écran ou non.
Prendre plaisir
Sur Android 4.1 et les versions ultérieures, vous pouvez configurer le contenu de votre application pour qu'il apparaisse derrière la barre d'état, afin que le contenu ne soit pas redimensionné, car la barre d'état est masquée et affichée. 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 vous incombe de vous assurer que les éléments critiques de l'interface utilisateur de votre application (par exemple, les contrôles intégrés d'une application Maps) ne sont pas couverts par les 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 présentation XML, défini sur true. Ceci ajuste le remplissage du ViewGroup parent pour laisser de la place aux fenêtres système. Cela suffit pour la plupart des applications.
Cependant, dans certains cas, 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 disposition de votre contenu par rapport aux barres système (qui occupent un espace appelé "éléments de contenu" de la fenêtre), remplacez fitSystemWindows (éléments de rectification). La méthode fitSystemWindows () est appelée par la hiérarchie des vues lorsque les incrustations de contenu d’une fenêtre ont été modifiées, afin de permettre à la fenêtre d’ajuster son contenu en conséquence. En redéfinissant cette méthode, vous pouvez gérer les encarts (et donc la présentation de votre application) comme vous le souhaitez.
formulaire: https://developer.Android.com/training/system-ui/status.html#behind
Merci à @Niklas +1 c'est la bonne façon de le faire.
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;
}
}
Excusez-moi s'il vous plaît si le code n'est pas correct à 100%, convertissez-le à partir de Xamarin C #, mais c'est le bon choix. Fonctionne avec des encoches, etc.
Si vous connaissez exactement la taille VS la 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 de 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 principale raison pour laquelle la réponse ne fonctionne pas pour certaines personnes est qu’il est impossible d’obtenir les dimensions d’une vue tant qu’elle n’est pas prête à être rendue. Utilisez une OnGlobalLayoutListener pour obtenir lesdites 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.
Ce problème est récemment devenu pertinent pour moi à cause 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 cela était particulièrement nécessaire pour une animation en plein écran que je devais lire. La fonction ci-dessous a activé 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 ensuite 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 statique de la classe Helper, mais par souci de brièveté, je me suis abstenu dans cet exemple. Les blurBitmap et errorHudFrameLayout sont omis pour la même raison, car ils ne concernent pas directement l'obtention de la hauteur de la barre d'état.