Altezza della barra di stato in Android

Qual è l'altezza della barra di stato in Android? È sempre lo stesso?

Dalle mie misurazioni sembra che sia 25dp, ma non sono sicuro che abbia la stessa altezza su tutte le piattaforme.

(Voglio sapere questo per implementare correttamente una transizione di dissolvenza da un'attività che non ha una barra di stato a una che lo fa)

questa domanda ha avuto risposta prima ... Altezza della barra di stato?

Aggiornamento ::

Metodo attuale:

ok, l'altezza della barra di stato dipende dalle dimensioni dello schermo, ad esempio in un dispositivo con dimensioni dello schermo 240 X 320 l'altezza della barra di stato è 20px, per un dispositivo con dimensioni dello schermo 320 X 480 l'altezza della barra di stato è 25px, per un dispositivo con 480 x 800 l'altezza della barra di stato deve essere di 38 px

quindi consiglio di utilizzare questo script per ottenere l'altezza della barra di stato

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

(vecchio metodo) per ottenere l'altezza della barra di stato sul onCreate()metodo della tua attività, utilizza questo metodo:

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

Di tutti gli esempi di codice che ho usato per ottenere l'altezza della barra di stato, l'unico che sembra funzionare nel onCreatemetodo di un Activityè questo:

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

Apparentemente l'altezza effettiva della barra di stato viene mantenuta come risorsa Android. Il codice sopra può essere aggiunto a una ContextWrapperclasse (ad es. Un Activity).

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

Sui dispositivi MDPI, la barra di stato è 25px. Possiamo usarlo come base e moltiplicarlo per la densità (arrotondato per eccesso) per ottenere l'altezza della barra di stato su qualsiasi dispositivo:

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

Per riferimento: ldpi = .75, mdpi = 1, hdpi = 1.5, xhdpi = 2

La codifica forzata delle dimensioni o l'utilizzo della riflessione per ottenere il valore di status_bar_heightè considerata una cattiva pratica. Chris Banes ne ha parlato al Droidcon di New York . Il modo consigliato per ottenere le dimensioni della barra di stato è tramite OnApplyWindowInsetsListener :

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

Questo è stato aggiunto in API 20 ed è anche backportato tramite ViewAppCompat .

Ho unito alcune soluzioni insieme:

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

un'altra 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 a runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126

Secondo le linee guida di progettazione di Google ; l'altezza della barra di stato è di 24 dp.

Se vuoi ottenere l'altezza della barra di stato in pixel puoi usare il metodo seguente:

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

che può essere chiamato dall'attività con:

statusBarHeight(getResources());

L'altezza predefinita era 25dp. Con Android Marshmallow (API 23) l'altezza è stata ridotta a 24dp.

Aggiornamento: tenere presente che, a partire dall'età delle tacche e delle fotocamere a punzone intero, l'utilizzo di un'altezza statica per la barra di stato non funziona più. Si prega di utilizzare inserti di finestra invece!

questo funziona anche con il link di riferimento

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

Ho lo stesso problema di dover ottenere l'altezza della barra di stato in un onCreate. Questo funziona per me.

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;

All'interno di 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;
}

Vedere:

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

L'altezza ufficiale è 24dp, come dichiarato ufficialmente da Google sulla pagina Web di Android Design .

Sì, quando lo provo con View fornisce il risultato di 25px. Ecco l'intero codice:

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

Prova questo:

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

non ha funzionato per me nel metodo onCreate per l'attività, ma quando l'ho inserito in un onClickListener e mi ha dato una misurazione di 25

l'altezza della barra di stato è 24dp in 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>

puoi trovare la risposta nel codice sorgente: frameworks \ base \ core \ res \ res \ valori \ dimens.xml

Per risolvere questo, ho usato un approccio combinato. Ciò è necessario poiché sui tablet la barra di sistema sottrae già i pixel quando viene chiamato display.getHeight (). Quindi prima controllo se è presente una barra di sistema, quindi l'approccio di Ben Claytons, che funziona perfettamente sui telefoni.

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

Grazie a @Niklas +1 questo è il modo corretto di farlo.

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

Mi scusi se il codice non è corretto al 100%, convertito da Xamarin C # ma questo è il giusto. Funziona con tacche, ecc.

Attiva soluzione a schermo intero:

Questa soluzione può sembrare una soluzione alternativa, ma in realtà spiega se l'app è a schermo intero (ovvero nasconde la barra di stato) oppure no:

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

In questo modo, se l'app è attualmente a schermo intero, barheight sarà uguale a 0.

Personalmente ho dovuto usarlo per correggere le coordinate TouchEvent assolute per tenere conto della barra di stato in questo modo:

@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 questo otterrà la coordinata y assoluta sia che l'app sia a schermo intero o meno.

Godere

Su Android 4.1 e versioni successive, puoi impostare il contenuto dell'applicazione in modo che appaia dietro la barra di stato, in modo che il contenuto non venga ridimensionato quando la barra di stato si nasconde e mostra. Per fare ciò, utilizzare SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Potrebbe inoltre essere necessario utilizzare SYSTEM_UI_FLAG_LAYOUT_STABLE per aiutare l'app a mantenere un layout stabile.

Quando si utilizza questo approccio, diventa responsabilità dell'utente assicurarsi che parti critiche dell'interfaccia utente dell'app (ad esempio, i controlli integrati in un'applicazione Maps) non finiscano per essere coperte dalle barre di sistema. Ciò potrebbe rendere la tua app inutilizzabile. Nella maggior parte dei casi puoi gestirlo aggiungendo l'attributo android: fitsSystemWindows al tuo file di layout XML, impostato su true. Ciò regola il riempimento del ViewGroup principale per lasciare spazio alle finestre di sistema. Questo è sufficiente per la maggior parte delle applicazioni.

In alcuni casi, tuttavia, potrebbe essere necessario modificare il riempimento predefinito per ottenere il layout desiderato per l'app. Per manipolare direttamente il modo in cui il contenuto viene distribuito rispetto alle barre di sistema (che occupano uno spazio noto come "insiemi di contenuti" della finestra), sovrascrivi fitSystemWindows (insiemi Rect). Il metodo fitSystemWindows () viene chiamato dalla gerarchia della vista quando gli inserimenti del contenuto di una finestra sono cambiati, per consentire alla finestra di adeguare il contenuto di conseguenza. Sovrascrivendo questo metodo puoi gestire gli inserti (e quindi il layout della tua app) come desideri.

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

Se conosci esattamente la dimensione VS altezza

piace

ad esempio in un dispositivo con dimensioni dello schermo 320 X 480 l'altezza della barra di stato è 25 px, per un dispositivo con 480 x 800 l'altezza della barra di stato deve essere 38 px

quindi puoi semplicemente ottenere la larghezza della tua vista / le dimensioni dello schermo che puoi semplicemente usare un'istruzione if else per ottenere l'altezza della barra di stato

Il motivo per cui la risposta principale non funziona per alcune persone è perché non è possibile ottenere le dimensioni di una vista fino a quando non è pronta per il rendering. Usa un OnGlobalLayoutListenerper ottenere tali dimensioni quando puoi effettivamente:

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

Questo è il metodo più affidabile.

Poiché la modalità multi-finestra è ora disponibile, la tua app potrebbe non avere la barra di stato in cima.

La seguente soluzione gestisce automaticamente tutti i casi.

android:fitsSystemWindows="true"

o programmaticamente

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

puoi anche ottenere la vista radice da

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

Per maggiori dettagli su come ottenere root-view consultare - https://stackoverflow.com/a/4488149/9640177

Questo problema recentemente è diventato rilevante per me a causa della tacca nel mio Pixel 3XL. Mi è piaciuta molto la soluzione per sviluppatori Android , ma volevo essere in grado di ottenere l'altezza della barra di stato a piacimento, poiché era specificamente necessario per un'animazione a schermo intero che dovevo giocare. La funzione seguente abilita una query affidabile:

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 poi nella classe di attività:

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

Naturalmente vorrai far passare un debole riferimento dell'attività al parametro del metodo della classe Helper statico, ma per brevità mi sono trattenuto in questo esempio. I blurBitmape errorHudFrameLayoutvengono omessi per lo stesso motivo, poiché non riguardano direttamente l'ottenimento dell'altezza della barra di stato.

Versione di Kotlin che combina due migliori soluzioni

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. Prende status_bar_heightvalore se presente
2. Se status_bar_heightnon è presente, calcola l'altezza della barra di stato dall'arredamento della finestra