Comment obtenir la hauteur de l'ActionBar?

J'essaie d'obtenir la hauteur du ActionBar(en utilisant Sherlock) chaque fois qu'une activité est créée (spécialement pour gérer les changements de configuration lors de la rotation où la hauteur de l'ActionBar peut changer).

Pour cela, j'utilise la méthode ActionBar.getHeight()qui ne fonctionne que lorsque le ActionBarest affiché.

Lorsque la première activité est créée pour la première fois, je peux appeler getHeight()le onCreateOptionsMenurappel. Mais cette méthode n'est pas appelée après.

Ma question est donc de savoir quand puis-je appeler getHeight () et être assuré qu'il ne renvoie pas 0? Ou si ce n'est pas possible, comment puis-je régler la hauteur de l'ActionBar?

Bien que la réponse de @ birdy soit une option si vous souhaitez contrôler explicitement la taille de l'ActionBar, il existe un moyen de la remonter sans verrouiller la taille que j'ai trouvée dans la documentation de support. C'est un peu gênant mais ça a marché pour moi. Vous aurez besoin d'un contexte, cet exemple serait valide dans une activité.

// 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, vous devez utiliser cet attribut:

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

Ok, je cherchais plusieurs fois sur Google et j'arrivais à ce post plusieurs fois, donc je pense que ce sera bien d'être décrit non seulement pour Sherlock mais aussi pour appcompat:

Hauteur de la barre d'action avec appCompat

Assez similaire à la description de @Anthony, vous pouvez la trouver avec le code suivant (je viens de changer l'ID de la ressource):

TypedValue tv = new TypedValue();

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

Problème de pré-sandwitch

J'avais besoin de la hauteur de la barre d'action car sur les appareils pré ICE_CREAM_SANDWITCH, ma vue chevauchait la barre d'action. J'ai essayé de paramétrer android: layout_marginTop = "? Android: attr / actionBarSize", android: layout_marginTop = "? Attr / actionBarSize", paramétrer le chevauchement pour afficher / actionbar et même fixer la hauteur de la barre d'action avec un thème personnalisé mais rien n'a fonctionné. Voilà à quoi ça ressemblait:

Malheureusement, j'ai découvert qu'avec la méthode décrite ci-dessus, je n'obtiens que la moitié de la hauteur (je suppose que la barre d'options n'est pas mise en place), donc pour résoudre complètement le problème, je dois doubler la hauteur de la barre d'action et tout semble correct:

Si quelqu'un connaît une meilleure solution (que de doubler actionBarHeight), je serai heureux de me le faire savoir car je viens du développement iOS et j'ai trouvé la plupart des choses de la vue Android assez déroutantes :)

Cordialement,

hris.to

@Anthony answer fonctionne pour les appareils qui prennent en charge ActionBaret pour les appareils qui ne prennent en charge que la Sherlock Action Barméthode suivante doit être utilisée

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

je pense que le moyen le plus sûr serait:

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

Pour définir la hauteur de ActionBarvous pouvez créer de nouveaux Themecomme celui-ci:

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

et définissez ceci Themesur votre 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 vous utilisez une barre d'outils comme ActionBar,

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

puis utilisez simplement le layout_height de la barre d'outils.

int actionBarHeight = toolbar.getLayoutParams().height;

vous pouvez utiliser cette fonction pour obtenir la hauteur de la barre d'action.

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

Une méthode prête pour répondre à la réponse la plus populaire:

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

Cette méthode d'aide devrait être utile pour quelqu'un. Exemple: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();
        }
    }
}

il vous suffit d'ajouter ceci.

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

J'ai trouvé un moyen plus générique de le découvrir:

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

où « mainView » est la vue racine de votre mise en page.

L'idée est essentiellement d'obtenir la position Y de la vue principale telle qu'elle est définie juste en dessous de la barre d'action (ou de la barre d'outils).

La hauteur de la barre d'action diffère selon le thème appliqué. Si vous utilisez AppCompatActivity, la hauteur sera différente dans la plupart des cas de l'activité normale.

Si vous utilisez AppCompatActivity, vous devez utiliser R.attr.actionBarSize au lieu 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, vous pouvez utiliser? Attr / actionBarSize, mais si vous avez besoin d'accéder à cette valeur en Java, vous devez utiliser le code ci-dessous:

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

Voici une version mise à jour avec Kotlin que j'ai utilisée en supposant que le téléphone est plus élevé que Honeycomb:

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

Si vous utilisez Xamarin / C #, voici le code que vous recherchez:

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

Un moyen simple de trouver la hauteur de la barre d'action consiste à utiliser la onPrepareOptionMenuméthode Activity .

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

Dans javafx (en utilisant Gluon), la hauteur est définie à l'exécution ou quelque chose comme ça. Tout en étant capable d'obtenir la largeur comme d'habitude ...

double width = appBar.getWidth();

Vous devez créer un auditeur:

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

... Et prenez la valeur la plus récente à laquelle il a changé. Pour avoir de la hauteur.

Après avoir essayé tout ce qui existe sans succès, j'ai découvert, par accident, un moyen fonctionnel et très simple d'obtenir la hauteur par défaut de la barre d'action.

Uniquement testé en API 25 et 24

C #

Resources.GetDimensionPixelSize(Resource.Dimension.abc_action_bar_default_height_material); 

Java

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