Altura de la barra de estado en Android

De todas las muestras de código que he usado para obtener la altura de la barra de estado, la única que realmente parece funcionar en el método onCreate de an Activity es esta:

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

Aparentemente la altura real de la barra de estado se mantiene como un recurso de Android. El código anterior se puede agregar a una clase ContextWrapper (por ejemplo, an Activity).

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

En dispositivos MDPI, la barra de estado es de 25px. Podemos usar esto como base y multiplicarlo por la densidad (redondeada hacia arriba) para obtener la altura de la barra de estado en cualquier dispositivo:

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

Para referencia: ldpi=.75, mdpi=1, hdpi=1.5, xhdpi = 2

De acuerdo con las directrices de diseño de Google; la altura de la barra de estado es de 24 dp.

Si desea obtener la altura de la barra de estado en píxeles, puede usar el siguiente método:

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

Que se puede llamar desde la actividad con:

statusBarHeight(getResources());

He fusionado algunas soluciones:

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

Otra alternativa:

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

EDITAR: Alternativa a runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

Esto también funciona con el 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;
}

Codificar el tamaño o usar la reflexión para obtener el valor de status_bar_height se considera una mala práctica. Chris Banes habló de esto en el Droidcon de Nueva York. La forma recomendada de obtener el tamaño de la barra de estado es a través del OnApplyWindowInsetsListener :

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

Esto se agregó en la API 20 y también se retroporta a través de ViewAppCompat.

Tengo el mismo problema de tener que obtener la altura de la barra de estado en un onCreate. Esto funciona para mí.

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;

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

Véase:

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

Sí cuando lo pruebo con View proporciona el resultado de 25px. Aquí está todo el código :

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

La altura oficial es 24dp, como se indica oficialmente por Google en Página web de diseño de Android .

La altura predeterminada solía ser 25dp. Con Android Marshmallow (API 23) la altura se redujo a 24dp.

240x320-20px

320x480-25px

480x800 + - 38px

Prueba esto:

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

No funcionó para mí en el método onCreate para la actividad, pero lo hizo cuando lo puse en un OnClickListener y me dio una medida de 25

Para resolver esto, utilicé un enfoque combinado. Esto es necesario, ya que en las tabletas la barra del sistema ya resta sus píxeles cuando se muestra.getHeight () es llamada. Así que primero compruebo si una barra del sistema está presente, y luego Ben Claytons se acerca, que funciona bien en los teléfonos.

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 altura de la barra de estado es 24dp en 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>

Puede encontrar la respuesta en el código fuente: frameworks\base\core\res\res\values\dimens.xml

Solución de pantalla completa conmutada:

Esta solución puede parecer una solución alternativa, pero en realidad explica si su aplicación está a pantalla completa (también conocida como ocultar la barra de estado) o no:

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

De esta manera, si su aplicación está actualmente a pantalla completa, barheight será igual a 0.

Personalmente tuve que usar esto para corregir las coordenadas absolutas de TouchEvent para dar cuenta de la barra de estado de la siguiente manera:

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

Y eso obtendrá la coordenada y absoluta si la aplicación está a pantalla completa o ni.

Disfruta

En Android 4.1 y versiones posteriores, puedes configurar el contenido de tu aplicación para que aparezca detrás de la barra de estado, de modo que el contenido no cambie de tamaño, ya que la barra de estado se oculta y se muestra. Para hacer esto, use SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. También es posible que necesites usar SYSTEM_UI_FLAG_LAYOUT_STABLE para ayudar a tu app a mantener un diseño estable.

Cuando utiliza este enfoque, es su responsabilidad asegurarse de que las partes críticas de la interfaz de usuario de su aplicación (por ejemplo, los controles integrados en una aplicación de Maps) no termines siendo cubierto por las barras del sistema. Esto podría hacer que su aplicación inutilizable. En la mayoría de los casos, puede manejar esto agregando el atributo android:fitsSystemWindows a su archivo de diseño XML, establecido en true. Esto ajusta el relleno del grupo de vista principal para dejar espacio para las ventanas del sistema. Esto es suficiente para la mayoría de las aplicaciones.

En algunos casos, sin embargo, es posible que deba modificar el relleno predeterminado para obtener el diseño deseado para su aplicación. Para manipular directamente cómo se presenta tu contenido en relación con las barras del sistema (que ocupan un espacio conocido como "inserciones de contenido" de la ventana), anule fitSystemWindows(inserciones Rect). El método fitSystemWindows () es llamado por la jerarquía de vistas cuando las inserciones de contenido de una ventana han cambiado, para permitir que la ventana ajuste su contenido en consecuencia. Al anular este método, puede manejar las inserciones (y, por lo tanto, el diseño de su aplicación) querer.

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

Si sabes exactamente el tamaño VS altura

Me gusta

Por ejemplo, en un dispositivo con un tamaño de pantalla de 320 X 480 la altura de la barra de estado es de 25px, para un dispositivo con 480 x 800 la altura de la barra de estado debe ser de 38px

Entonces puede obtener el ancho de su vista / el tamaño de la pantalla puede usar una instrucción if else para obtener la altura de la barra de estado

La razón por la que la respuesta superior no funciona para algunas personas es porque no puede obtener las dimensiones de una vista hasta que esté lista para renderizarse. Use un OnGlobalLayoutListener para obtener dichas dimensiones cuando realmente pueda:

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

Este es el método más confiable.