¿Cómo obtener la altura de ActionBar?

Estoy tratando de obtener la altura de ActionBar(usando Sherlock) cada vez que se crea una actividad (especialmente para manejar los cambios de configuración en la rotación donde la altura de ActionBar podría cambiar).

Para esto utilizo el método ActionBar.getHeight()que funciona solo cuando ActionBarse muestra.

Cuando se crea la primera actividad por primera vez, puedo llamar getHeight()a la onCreateOptionsMenudevolución de llamada. Pero este método no se llama después.

Entonces, mi pregunta es cuándo puedo llamar a getHeight () y estar seguro de que no devuelve 0. O si no es posible, ¿cómo puedo configurar la altura de la barra de acciones?

Si bien la respuesta de @ birdy es una opción si desea controlar explícitamente el tamaño de ActionBar, hay una manera de extraerlo sin bloquear el tamaño que encontré en la documentación de soporte. Es un poco incómodo, pero funcionó para mí. Necesitará un contexto, este ejemplo sería válido en una Actividad.

// Calculate ActionBar height
TypedValue tv = new TypedValue();
if (getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true))
{
    Int actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());
}

Kotlin :

val tv = TypedValue()
if (requireActivity().theme.resolveAttribute(android.R.attr.actionBarSize, tv, true)) {
    val actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data, resources.displayMetrics)
}

En XML, debe usar este atributo:

android:paddingTop="?android:attr/actionBarSize"

Ok, busqué en Google y llegué a esta publicación varias veces, así que creo que será bueno que me describan no solo para Sherlock sino también para appcompat:

Altura de la barra de acción con appCompat

Bastante similar a la descripción de @Anthony, puede encontrarlo con el siguiente código (acabo de cambiar la identificación del recurso):

TypedValue tv = new TypedValue();

if (getActivity().getTheme().resolveAttribute(R.attr.actionBarSize, tv, true))
{
    int actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());
}

Problema Pre Sandwitch

Necesitaba la altura de la barra de acción porque en dispositivos pre ICE_CREAM_SANDWITCH mi vista se superponía a la barra de acción. Intenté configurar android: layout_marginTop = "? Android: attr / actionBarSize", android: layout_marginTop = "? Attr / actionBarSize", configurando la superposición desactivada para ver / barra de acción e incluso altura de barra de acción fija con tema personalizado pero nada funcionó. Así se veía:

Desafortunadamente, descubrí que con el método descrito anteriormente obtengo solo la mitad de la altura (supongo que la barra de opciones no está en su lugar), así que para solucionar completamente el problema, necesito duplicar la altura de la barra de acción y todo parece estar bien:

Si alguien conoce una mejor solución (que doblar actionBarHeight), me alegrará avisarme cuando vengo del desarrollo de iOS y encontré que la mayoría de las cosas de la vista de Android son bastante confusas :)

Saludos,

hris.to

La respuesta @Anthony funciona para dispositivos que admiten ActionBary para aquellos dispositivos que solo admiten el Sherlock Action Barsiguiente método

    TypedValue tv = new TypedValue();
    if (getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true))
        actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());

    if(actionBarHeight ==0 && getTheme().resolveAttribute(com.actionbarsherlock.R.attr.actionBarSize, tv, true)){
            actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());
    }

   //OR as stated by @Marina.Eariel
   TypedValue tv = new TypedValue();
   if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.HONEYCOMB){
      if (getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true))
        actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());
   }else if(getTheme().resolveAttribute(com.actionbarsherlock.R.attr.actionBarSize, tv, true){
        actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,getResources().getDisplayMetrics());
   }

Creo que la forma más segura sería:

private int getActionBarHeight() {
    int actionBarHeight = getSupportActionBar().getHeight();
    if (actionBarHeight != 0)
        return actionBarHeight;
    final TypedValue tv = new TypedValue();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        if (getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true))
            actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data, getResources().getDisplayMetrics());
    } else if (getTheme().resolveAttribute(com.actionbarsherlock.R.attr.actionBarSize, tv, true))
        actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data, getResources().getDisplayMetrics());
    return actionBarHeight;
}

Para establecer la altura de ActionBarusted puede crear nuevos Themecomo este:

<?xml version="1.0" encoding="utf-8"?>
<resources>   
    <style name="Theme.FixedSize" parent="Theme.Sherlock.Light.DarkActionBar">
        <item name="actionBarSize">48dip</item>
        <item name="android:actionBarSize">48dip</item> 
    </style> 
 </resources>

y configura esto Themea tu Activity:

android:theme="@style/Theme.FixedSize"

Java:

    int actionBarHeight;
    int[] abSzAttr;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        abSzAttr = new int[] { android.R.attr.actionBarSize };
    } else {
        abSzAttr = new int[] { R.attr.actionBarSize };
    }
    TypedArray a = obtainStyledAttributes(abSzAttr);
    actionBarHeight = a.getDimensionPixelSize(0, -1);

xml:

    ?attr/actionBarSize

Si está utilizando una barra de herramientas como la barra de acciones,

Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

entonces simplemente use el layout_height de la barra de herramientas.

int actionBarHeight = toolbar.getLayoutParams().height;

puedes usar esta función para obtener la altura de la barra de acción.

public int getActionBarHeight() {
    final TypedArray ta = getContext().getTheme().obtainStyledAttributes(
            new int[] {android.R.attr.actionBarSize});
    int actionBarHeight = (int) ta.getDimension(0, 0);
    return actionBarHeight;
}

Este método de ayuda debería ser útil para alguien. Ejemplo:int actionBarSize = getThemeAttributeDimensionSize(this, android.R.attr.actionBarSize);

public static int getThemeAttributeDimensionSize(Context context, int attr)
{
    TypedArray a = null;
    try{
        a = context.getTheme().obtainStyledAttributes(new int[] { attr });
        return a.getDimensionPixelSize(0, 0);
    }finally{
        if(a != null){
            a.recycle();
        }
    }
}

solo tienes que agregar esto.

public int getActionBarHeight() {
        int height;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            height = getActivity().getActionBar().getHeight();
        } else {
            height = ((ActionBarActivity) getActivity()).getSupportActionBar().getHeight();

        }
        return height;
    }

Encontré una forma más genérica de descubrirlo:

  int[] location = new int[2];
  mainView.getLocationOnScreen(location);
  int toolbarHeight = location[1];

donde ' mainView ' es la vista raíz de su diseño.

La idea es básicamente obtener la posición Y de mainView, ya que se establece justo debajo de la barra de acciones (o barra de herramientas).

La altura de la barra de acción difiere según el tema aplicado. Si estás usando AppCompatActivity la altura será diferente en la mayoría de los casos de la Actividad normal.

Si está utilizando AppCompatActivity , debe usar R.attr.actionBarSize en lugar de android.R.attr.actionBarSize

public static int getActionBarHeight(Activity activity) {
        TypedValue typedValue = new TypedValue();

        int attributeResourceId = android.R.attr.actionBarSize;
        if (activity instanceof AppCompatActivity) {
            attributeResourceId = R.attr.actionBarSize;
        }

        if (activity.getTheme().resolveAttribute(attributeResourceId, typedValue, true)) {
            return TypedValue.complexToDimensionPixelSize(typedValue.data, activity.getResources().getDisplayMetrics());
        }

        return (int) Math.floor(activity.getResources()
                .getDimension(R.dimen.my_default_value));
    }

En xml, puede usar? Attr / actionBarSize, pero si necesita acceder a ese valor en Java, debe usar el siguiente código:

public int getActionBarHeight() {
        int actionBarHeight = 0;
        TypedValue tv = new TypedValue();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            if (getTheme().resolveAttribute(android.R.attr.actionBarSize, tv,
                    true))
                actionBarHeight = TypedValue.complexToDimensionPixelSize(
                        tv.data, getResources().getDisplayMetrics());
        } else {
            actionBarHeight = TypedValue.complexToDimensionPixelSize(tv.data,
                    getResources().getDisplayMetrics());
        }
        return actionBarHeight;
    }

Un método listo para cumplir con la respuesta más popular:

public static int getActionBarHeight(
  Activity activity) {

  int actionBarHeight = 0;
  TypedValue typedValue = new TypedValue();

  try {

    if (activity
      .getTheme()
      .resolveAttribute(
        android.R.attr.actionBarSize,
        typedValue,
        true)) {

      actionBarHeight =
        TypedValue.complexToDimensionPixelSize(
          typedValue.data,
          activity
            .getResources()
            .getDisplayMetrics());
    }

  } catch (Exception ignore) {
  }

  return actionBarHeight;
}

Aquí hay una versión actualizada con Kotlin que utilicé suponiendo que el teléfono sea más alto que Honeycomb:

val actionBarHeight = with(TypedValue().also {context.theme.resolveAttribute(android.R.attr.actionBarSize, it, true)}) {
            TypedValue.complexToDimensionPixelSize(this.data, resources.displayMetrics)
        }

Si está utilizando Xamarin / C #, este es el código que está buscando:

var styledAttributes = Context.Theme.ObtainStyledAttributes(new[] { Android.Resource.Attribute.ActionBarSize });
var actionBarSize = (int)styledAttributes.GetDimension(0, 0);
styledAttributes.Recycle();

The action bar now enhanced to app bar.So you have to add conditional check for getting height of action bar.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
   height = getActivity().getActionBar().getHeight();
 } else {
  height = ((ActionBarActivity) getActivity()).getSupportActionBar().getHeight();
}

Una forma sencilla de encontrar la altura de la barra de acción es desde el onPrepareOptionMenumétodo Actividad .

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
           ....
           int actionBarHeight = getActionBar().getHeight());
           .....
    }

En javafx (usando Gluon), la altura se establece en tiempo de ejecución o algo similar. Si bien puede obtener el ancho como de costumbre ...

double width = appBar.getWidth();

Tienes que crear un oyente:

GluonApplication application = this;

application.getAppBar().heightProperty().addListener(new ChangeListener(){
    @Override
    public void changed(ObservableValue observable, Object oldValue, Object newValue) {
        // Take most recent value given here
        application.getAppBar.heightProperty.get()
    }
});

... Y tome el valor más reciente al que cambió. Para obtener la altura.

Después de probar todo lo que está ahí fuera sin éxito, descubrí, por accidente, una forma funcional y muy fácil de obtener la altura predeterminada de la barra de acción.

Solo probado en API 25 y 24

C#

Resources.GetDimensionPixelSize(Resource.Dimension.abc_action_bar_default_height_material); 

Java

getResources().getDimensionPixelSize(R.dimen.abc_action_bar_default_height_material);