Altura da barra de status no Android

Qual é a altura da barra de status no Android? É sempre o mesmo?

Pelas minhas medidas, parece que é de 25dp, mas não tenho certeza se tem a mesma altura em todas as plataformas.

(Quero saber isso para implementar adequadamente uma transição de desvanecimento de uma atividade que não possui barra de status para outra)

esta pergunta foi respondida antes ... Height of statusbar?

Atualização ::

Método atual:

ok, a altura da barra de status depende do tamanho da tela; por exemplo, em um dispositivo com tamanho de tela de 240 X 320, a altura da barra de status é de 20 px; para um dispositivo com tamanho de tela de 320 X 480, a altura da barra de status é de 25 px, por dispositivo com 480 x 800, a altura da barra de status deve ser 38 px

então eu recomendo usar esse script para obter a altura da barra de status

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

(método antigo) para obter a altura da barra de status no onCreate()método da sua atividade, use este método:

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 todos os exemplos de código que usei para obter a altura da barra de status, o único que realmente parece funcionar no onCreatemétodo de um Activityé o seguinte:

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, a altura real da barra de status é mantida como um recurso do Android. O código acima pode ser adicionado a uma ContextWrapperclasse (por exemplo, uma Activity).

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

Nos dispositivos MDPI, a barra de status é 25px. Podemos usar isso como base e multiplicá-lo pela densidade (arredondada para cima) para obter a altura da barra de status em qualquer dispositivo:

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

Para referência: ldpi = 0,75, mdpi = 1, hdpi = 1,5, xhdpi = 2

Codificar o tamanho ou usar a reflexão para obter o valor status_bar_heighté considerado uma prática ruim. Chris Banes falou sobre isso no Droidcon New York . A maneira recomendada de obter o tamanho da barra de status é através do OnApplyWindowInsetsListener :

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

Isso foi adicionado na API 20 e também é suportado via ViewAppCompat .

Mesclamos algumas soluções:

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

outra alternativa:

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

EDIT: alternativa para runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

De acordo com as diretrizes de design do Google ; a altura da barra de status é 24 dp.

Se você deseja obter a altura da barra de status em pixels, use o método abaixo:

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

que pode ser chamado de atividade com:

statusBarHeight(getResources());

A altura padrão costumava ser 25dp. Com o Android Marshmallow (API 23), a altura foi reduzida para 24dp.

Atualização: lembre-se de que, desde o início da era dos entalhes e das câmeras perfuradas, o uso de uma altura estática para a barra de status não funciona mais. Por favor, use inserções de janela!

isso também funciona com o link de referência

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

Eu tenho o mesmo problema de ter que obter a altura da barra de status em um onCreate. Isso funciona para mim.

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;

Por dentro do 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;
}

Vejo:

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

A altura oficial é 24dp, como declarado oficialmente pelo Google na página do Android Design .

Sim, quando eu tento com o View, fornece o resultado de 25px. Aqui está o código inteiro:

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 px

480x800 + - 38px

Tente o seguinte:

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

não funcionou para mim no método onCreate da atividade, mas funcionou quando o coloquei em um onClickListener e me deu uma medida de 25

a altura da barra de status é 24dp no 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>

você pode encontrar a resposta no código-fonte: frameworks \ base \ core \ res \ res \ values ​​\ dimens.xml

Para resolver isso, usei uma abordagem combinada. Isso é necessário, pois em tablets a barra do sistema já subtrai seus pixels quando display.getHeight () é chamado. Por isso, verifico primeiro se há uma barra do sistema e depois a abordagem de Ben Claytons, que funciona bem em telefones.

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

Graças ao @Niklas +1, esta é a maneira correta de fazer isso.

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

Por favor, desculpe-me se o código não estiver 100% correto, converteu-o do Xamarin C #, mas é exatamente isso. Funciona com entalhes, etc.

Solução de tela cheia alternada:

Esta solução pode parecer uma solução alternativa, mas na verdade explica se seu aplicativo é de tela cheia (também conhecido como ocultar a barra de status) ou não:

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

Dessa forma, se seu aplicativo estiver em tela cheia no momento, barheight será igual a 0.

Pessoalmente, tive que usar isso para corrigir coordenadas absolutas do TouchEvent para contabilizar a barra de status da seguinte forma:

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

E isso terá a coordenada y absoluta, seja o aplicativo em tela cheia ou não.

Aproveitar

No Android 4.1 e superior, você pode definir o conteúdo do aplicativo para aparecer atrás da barra de status, para que o conteúdo não seja redimensionado conforme a barra de status oculta e é exibida. Para fazer isso, use SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Você também pode precisar usar SYSTEM_UI_FLAG_LAYOUT_STABLE para ajudar seu aplicativo a manter um layout estável.

Quando você usa essa abordagem, é de sua responsabilidade garantir que partes críticas da interface do usuário do seu aplicativo (por exemplo, os controles internos de um aplicativo Maps) não acabem sendo cobertas pelas barras do sistema. Isso pode tornar seu aplicativo inutilizável. Na maioria dos casos, você pode lidar com isso adicionando o atributo android: fitsSystemWindows ao seu arquivo de layout XML, definido como true. Isso ajusta o preenchimento do ViewGroup pai para deixar espaço para as janelas do sistema. Isso é suficiente para a maioria dos aplicativos.

Em alguns casos, no entanto, pode ser necessário modificar o preenchimento padrão para obter o layout desejado para o seu aplicativo. Para manipular diretamente como o conteúdo é apresentado em relação às barras do sistema (que ocupam um espaço conhecido como "inserções de conteúdo" da janela), substitua fitSystemWindows (inserções Rect). O método fitSystemWindows () é chamado pela hierarquia de exibição quando as inserções de conteúdo de uma janela são alteradas, para permitir que a janela ajuste seu conteúdo de acordo. Ao substituir esse método, você pode manipular as inserções (e, portanto, o layout do seu aplicativo) da maneira que desejar.

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

Se você sabe exatamente o tamanho VS altura

gostar

por exemplo, em um dispositivo com tamanho de tela de 320 x 480, a altura da barra de status é 25 px; para um dispositivo com 480 x 800, a altura da barra de status deve ser 38 px

então você pode simplesmente obter a largura da sua visualização / tamanho da tela, você pode usar apenas uma instrução if else para obter a altura da barra de status

A razão pela qual a resposta principal não funciona para algumas pessoas é porque você não pode obter as dimensões de uma exibição até que ela esteja pronta para renderizar. Use um OnGlobalLayoutListenerpara obter as dimensões mencionadas quando você puder:

@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 é o método mais confiável.

Como o modo de várias janelas está disponível agora, seu aplicativo pode não ter a barra de status na parte superior.

A solução a seguir lida com todos os casos automaticamente para você.

android:fitsSystemWindows="true"

ou programaticamente

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

você também pode obter a visualização root

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

Para obter mais detalhes sobre como obter a visualização root, consulte - https://stackoverflow.com/a/4488149/9640177

Esse problema recentemente se tornou relevante para mim por causa do entalhe no meu Pixel 3XL. Eu realmente gostei da solução do desenvolvedor do Android , mas queria poder obter a altura da barra de status à vontade, pois era especificamente necessário para uma animação em tela cheia que eu precisava reproduzir. A função abaixo ativou uma consulta confiável:

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

E então na classe de atividade:

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

É claro que você desejará fazer passar uma referência fraca da atividade ao parâmetro estático do método da classe Helper, mas por uma questão de brevidade, abstive-me neste exemplo. O blurBitmape errorHudFrameLayoutsão omitidos pelo mesmo motivo, pois eles não pertencem diretamente à obtenção da altura da barra de status.

Versão Kotlin que combina as duas melhores soluções

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. Toma status_bar_height valor se presente
2. Se status_bar_heightnão estiver presente, calcula a altura da barra de status em Decoração da janela