Onglet Conception de la prise en charge Android Présentation: Centre de gravité et défilement du mode

98

J'essaye d'utiliser le nouveau Design TabLayout dans mon projet. Je veux que la mise en page s'adapte à chaque taille et orientation d'écran, mais elle peut être vue correctement dans une seule orientation.

Je traite avec Gravity and Mode définissant mon tabLayout comme:

    tabLayout.setTabGravity(TabLayout.GRAVITY_CENTER);
    tabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);

Je m'attends donc à ce que s'il n'y a pas de place, le tabLayout soit scrollable, mais s'il y a de la place, il est centré.

Des guides:

public static final int GRAVITY_CENTER Gravité utilisée pour disposer les onglets au centre du TabLayout.

public static final int GRAVITY_FILL Gravité utilisée pour remplir le TabLayout autant que possible. Cette option ne prend effet que lorsqu'elle est utilisée avec MODE_FIXED.

public static final int MODE_FIXED Les onglets fixes affichent tous les onglets simultanément et sont mieux utilisés avec du contenu qui bénéficie de pivots rapides entre les onglets. Le nombre maximum d'onglets est limité par la largeur de la vue. Les onglets fixes ont la même largeur, en fonction de l'étiquette d'onglet la plus large.

public static final int MODE_SCROLLABLE Les onglets déroulants affichent un sous-ensemble d'onglets à tout moment et peuvent contenir des étiquettes d'onglets plus longues et un plus grand nombre d'onglets. Ils sont mieux utilisés pour parcourir les contextes dans les interfaces tactiles lorsque les utilisateurs n'ont pas besoin de comparer directement les étiquettes des onglets.

Donc GRAVITY_FILL est compatible uniquement avec MODE_FIXED mais, at ne spécifie rien pour GRAVITY_CENTER, je m'attends à ce qu'il soit compatible avec MODE_SCROLLABLE, mais c'est ce que j'obtiens en utilisant GRAVITY_CENTER et MODE_SCROLLABLE

entrez la description de l'image ici

Donc, il utilise SCROLLABLE dans les deux orientations, mais il n'utilise pas GRAVITY_CENTER.

C'est ce à quoi je m'attendrais pour le paysage; mais pour avoir cela, je dois définir MODE_FIXED, donc ce que j'obtiens en portrait est:

entrez la description de l'image ici

Pourquoi GRAVITY_CENTER ne fonctionne-t-il pas pour SCROLLABLE si le tabLayout correspond à l'écran? Existe-t-il un moyen de définir dynamiquement la gravité et le mode (et de voir ce que j'attends)?

Merci beaucoup!

EDITED: Voici la disposition de mon TabLayout:

<android.support.design.widget.TabLayout
    android:id="@+id/sliding_tabs"
    android:layout_width="match_parent"
    android:background="@color/orange_pager"
    android:layout_height="wrap_content" />
Javier Delgado
la source
@ Fighter42 avez-vous trouvé une solution à cela? Je suis confronté au même problème.
Spynet
Le seul moyen que j'ai trouvé était d'obtenir la taille de vos onglets (manuellement), puis de configurer les paramètres de mise en page de manière dynamique selon si cela correspond ou non.
Javier Delgado
@ Fighter42, pouvez-vous publier un exemple de code pour la solution que vous utilisez?
Sammys
1
Je sais que ma réponse n'est pas bonne pour la logique mais cela m'aide. Mettez des espaces avant et après le texte. Ensuite, il sera déroulant. dans les deux modes.
AmmY

Réponses:

127

Effets de gravité uniquement MODE_FIXED .

Une solution possible consiste à définir votre layout_widthto wrap_contentet layout_gravityto center_horizontal:

<android.support.design.widget.TabLayout
    android:id="@+id/sliding_tabs"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    app:tabMode="scrollable" />

Si les onglets sont plus petits que la largeur de l'écran, le TabLayoutlui - même sera également plus petit et il sera centré à cause de la gravité. Si les onglets sont plus grands que la largeur de l'écran, le TabLayoutcorrespondra à la largeur de l'écran et le défilement s'activera.

tachyonflux
la source
1
J'utilise la conception matérielle pour mon application. J'ai suivi l'exemple de androidhive.info/2015/09/… Tab scrollable ne fonctionne pas dans les appareils Kitkat et Jelly Bean. Dans Lollipop, je suis capable de faire défiler l'onglet, mais dans d'autres que les appareils Lollipop, l'onglet scrollable ne fonctionne pas mais le balayage fonctionne bien. Puis-je savoir quel serait le problème.
user2681579
Cela n'a pas fonctionné pour moi sur l'API 15 / support.design:25.1.0. Les tabulations étaient justifiées à gauche lorsqu'elles étaient plus étroites que la largeur de la fenêtre. Réglage app:tabMaxWidth="0dp"et android:layout_centerHorizontal="true"travail pour centrer les onglets.
Baker
1
Cela a fonctionné pour moi. Les onglets sont toujours centrés, mais lorsqu'ils ne sont pas réellement défilables, ils ne remplissent pas toute la largeur.
José Augustinho
14

c'est comme ça que je l'ai fait

TabLayout.xml

<android.support.design.widget.TabLayout
            android:id="@+id/tab_layout"
            android:layout_height="wrap_content"
            android:layout_width="wrap_content"
            android:background="@android:color/transparent"
            app:tabGravity="fill"
            app:tabMode="scrollable"
            app:tabTextAppearance="@style/TextAppearance.Design.Tab"
            app:tabSelectedTextColor="@color/myPrimaryColor"
            app:tabIndicatorColor="@color/myPrimaryColor"
            android:overScrollMode="never"
            />

Oncreate

@Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mToolbar = (Toolbar) findViewById(R.id.toolbar_actionbar);
        mTabLayout = (TabLayout)findViewById(R.id.tab_layout);
        mTabLayout.setOnTabSelectedListener(this);
        setSupportActionBar(mToolbar);

        mTabLayout.addTab(mTabLayout.newTab().setText("Dashboard"));
        mTabLayout.addTab(mTabLayout.newTab().setText("Signature"));
        mTabLayout.addTab(mTabLayout.newTab().setText("Booking/Sampling"));
        mTabLayout.addTab(mTabLayout.newTab().setText("Calendar"));
        mTabLayout.addTab(mTabLayout.newTab().setText("Customer Detail"));

        mTabLayout.post(mTabLayout_config);
    }

    Runnable mTabLayout_config = new Runnable()
    {
        @Override
        public void run()
        {

           if(mTabLayout.getWidth() < MainActivity.this.getResources().getDisplayMetrics().widthPixels)
            {
                mTabLayout.setTabMode(TabLayout.MODE_FIXED);
                ViewGroup.LayoutParams mParams = mTabLayout.getLayoutParams();
                mParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
                mTabLayout.setLayoutParams(mParams);

            }
            else
            {
                mTabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
            }
        }
    };

J'ai apporté de petits changements à la solution de @Mario Velasco sur la partie exécutable

Flux
la source
Cette solution a les mêmes problèmes que j'ai mentionnés sur la solution de Tiago.
Sotti
Cette solution fonctionne sur un onglet sans icône, que faire si j'ai une icône avec du texte ?? : /
Emre Tekin
@EmreTekin oui cela fonctionne avec une icône, mes onglets avaient des icônes avec du texte
Flux
tabLayout.getWidth()renvoie toujours zéro pour moi
ishandutta2007
9

simplifie les choses, ajoutez simplement l'application: tabMode = "scrollable" et android: layout_gravity = "bottom"

juste comme ça

<android.support.design.widget.TabLayout
android:id="@+id/tabs"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
android:layout_gravity="bottom"
app:tabMode="scrollable"
app:tabIndicatorColor="@color/colorAccent" />

entrez la description de l'image ici

Rajesh Kumar
la source
7
Ce n'est pas ce que le créateur demande. Le problème avec cette approche est que dans les scénarios où vous avez 2 onglets ou 3 trois onglets dans les téléphones où le texte est petit, vous aurez une mise en page comme le Google Play Store où les onglets sont sur le côté gauche. Le créateur veut que les onglets atteignent d'un bord à l'autre lorsque cela est possible, et défilent autrement.
Sotti
Même problème. Tu peux le réparer?
Hoang Duc Tuan
8

Comme je n'ai pas trouvé pourquoi ce comportement se produit, j'ai utilisé le code suivant:

float myTabLayoutSize = 360;
if (DeviceInfo.getWidthDP(this) >= myTabLayoutSize ){
    tabLayout.setTabMode(TabLayout.MODE_FIXED);
} else {
    tabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
}

Fondamentalement, je dois calculer manuellement la largeur de mon tabLayout, puis je règle le mode Tab en fonction de si le tabLayout s'intègre ou non dans l'appareil.

La raison pour laquelle j'obtiens manuellement la taille de la mise en page est que tous les onglets n'ont pas la même largeur en mode Défilement, ce qui pourrait provoquer que certains noms utilisent 2 lignes comme cela m'est arrivé dans l'exemple.

Javier Delgado
la source
Avec cette solution, le texte pourrait potentiellement être réduit et utiliser également 2 lignes. Voir d'autres réponses et solutions dans ce fil à ce sujet. Vous réduisez le risque que cela apparaisse mais apparaîtra souvent de toute façon lorsque le TabLayout est un peu plus petit que le screenWidth.
Sotti
7

Regardez android-tablayouthelper

Basculer automatiquement entre TabLayout.MODE_FIXED et TabLayout.MODE_SCROLLABLE dépend de la largeur totale de l'onglet.

Derek Beattie
la source
Mais lorsque les titres des onglets sont dynamiques. Le texte va dans la ligne suivante. Et si vous utilisez une mise en page personnalisée pour l'onglet. Ellipsize du texte à la fin comme
AndroidGeek
4

C'est la solution que j'ai utilisée pour basculer automatiquement entre SCROLLABLEet FIXED+ FILL. C'est le code complet de la solution @ Fighter42:

(Le code ci-dessous montre où placer la modification si vous avez utilisé le modèle d'activité à onglets de Google)

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);
    // Create the adapter that will return a fragment for each of the three
    // primary sections of the activity.
    mSectionsPagerAdapter = new SectionsPagerAdapter(getSupportFragmentManager());

    // Set up the ViewPager with the sections adapter.
    mViewPager = (ViewPager) findViewById(R.id.container);
    mViewPager.setAdapter(mSectionsPagerAdapter);

    // Set up the tabs
    final TabLayout tabLayout = (TabLayout) findViewById(R.id.tabs);
    tabLayout.setupWithViewPager(mViewPager);

    // Mario Velasco's code
    tabLayout.post(new Runnable()
    {
        @Override
        public void run()
        {
            int tabLayoutWidth = tabLayout.getWidth();

            DisplayMetrics metrics = new DisplayMetrics();
            ActivityMain.this.getWindowManager().getDefaultDisplay().getMetrics(metrics);
            int deviceWidth = metrics.widthPixels;

            if (tabLayoutWidth < deviceWidth)
            {
                tabLayout.setTabMode(TabLayout.MODE_FIXED);
                tabLayout.setTabGravity(TabLayout.GRAVITY_FILL);
            } else
            {
                tabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
            }
        }
    });
}

Disposition:

    <android.support.design.widget.TabLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal" />

Si vous n'avez pas besoin de remplir la largeur, mieux vaut utiliser la solution @karaokyo.

Mario Velasco
la source
cela fonctionne bien; basculer entre paysage et portrait fait exactement ce que vous attendez. Google devrait implémenter cela dans le modèle par défaut pour l'activité par onglets.
Someone Somewhere
Cette réponse a les mêmes problèmes que j'ai mentionnés dans la solution de Tiago.
Sotti
4

J'ai créé une classe AdaptiveTabLayout pour y parvenir. C'était le seul moyen que j'ai trouvé pour résoudre le problème, répondre à la question et éviter / contourner les problèmes que les autres réponses ici ne font pas.

Remarques:

  • Gère les dispositions de téléphone / tablette.
  • Gère les cas où il y a assez de place pour MODE_SCROLLABLEmais pas assez de place pourMODE_FIXED . Si vous ne gérez pas ce cas, cela se produira sur certains appareils, vous verrez différentes tailles de texte ou afficherez deux lignes de texte dans certains onglets, ce qui semble mauvais.
  • Il obtient de vraies mesures et ne fait aucune hypothèse (comme l'écran a une largeur de 360dp ou autre ...). Cela fonctionne avec des tailles d'écran réelles et des tailles d'onglets réelles. Cela signifie que cela fonctionne bien avec les traductions car ne suppose aucune taille d'onglet, les onglets sont mesurés.
  • Traite les différentes passes de la phase onLayout afin d'éviter un surcroît de travail.
  • La largeur de la mise en page doit être wrap_contentsur le xml. Ne définissez aucun mode ou gravité sur le xml.

AdaptiveTabLayout.java

import android.content.Context;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.design.widget.TabLayout;
import android.util.AttributeSet;
import android.widget.LinearLayout;

public class AdaptiveTabLayout extends TabLayout
{
    private boolean mGravityAndModeSeUpNeeded = true;

    public AdaptiveTabLayout(@NonNull final Context context)
    {
        this(context, null);
    }

    public AdaptiveTabLayout(@NonNull final Context context, @Nullable final AttributeSet attrs)
    {
        this(context, attrs, 0);
    }

    public AdaptiveTabLayout
    (
            @NonNull final Context context,
            @Nullable final AttributeSet attrs,
            final int defStyleAttr
    )
    {
        super(context, attrs, defStyleAttr);
        setTabMode(MODE_SCROLLABLE);
    }

    @Override
    protected void onLayout(final boolean changed, final int l, final int t, final int r, final int b)
    {
        super.onLayout(changed, l, t, r, b);

        if (mGravityAndModeSeUpNeeded)
        {
            setModeAndGravity();
        }
    }

    private void setModeAndGravity()
    {
        final int tabCount = getTabCount();
        final int screenWidth = UtilsDevice.getScreenWidth();
        final int minWidthNeedForMixedMode = getMinSpaceNeededForFixedMode(tabCount);

        if (minWidthNeedForMixedMode == 0)
        {
            return;
        }
        else if (minWidthNeedForMixedMode < screenWidth)
        {
            setTabMode(MODE_FIXED);
            setTabGravity(UtilsDevice.isBigTablet() ? GRAVITY_CENTER : GRAVITY_FILL) ;
        }
        else
        {
            setTabMode(TabLayout.MODE_SCROLLABLE);
        }

        setLayoutParams(new LinearLayout.LayoutParams
                (LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));

        mGravityAndModeSeUpNeeded = false;
    }

    private int getMinSpaceNeededForFixedMode(final int tabCount)
    {
        final LinearLayout linearLayout = (LinearLayout) getChildAt(0);
        int widestTab = 0;
        int currentWidth;

        for (int i = 0; i < tabCount; i++)
        {
            currentWidth = linearLayout.getChildAt(i).getWidth();

            if (currentWidth == 0) return 0;

            if (currentWidth > widestTab)
            {
                widestTab = currentWidth;
            }
        }

        return widestTab * tabCount;
    }

}

Et voici la classe DeviceUtils:

import android.content.res.Resources;

public class UtilsDevice extends Utils
{
    private static final int sWIDTH_FOR_BIG_TABLET_IN_DP = 720;

    private UtilsDevice() {}

    public static int pixelToDp(final int pixels)
    {
        return (int) (pixels / Resources.getSystem().getDisplayMetrics().density);
    }

    public static int getScreenWidth()
    {
        return Resources
                .getSystem()
                .getDisplayMetrics()
                .widthPixels;
    }

    public static boolean isBigTablet()
    {
        return pixelToDp(getScreenWidth()) >= sWIDTH_FOR_BIG_TABLET_IN_DP;
    }

}

Utilisez l'exemple:

<?xml version="1.0" encoding="utf-8"?>

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.com.stackoverflow.example.AdaptiveTabLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="?colorPrimary"
        app:tabIndicatorColor="@color/white"
        app:tabSelectedTextColor="@color/text_white_primary"
        app:tabTextColor="@color/text_white_secondary"
        tools:layout_width="match_parent"/>

</FrameLayout>

Essentiel

Problèmes / Demandez de l'aide:

  • Vous verrez ceci:

Logcat:

W/View: requestLayout() improperly called by android.support.design.widget.TabLayout$SlidingTabStrip{3e1ebcd6 V.ED.... ......ID 0,0-466,96} during layout: running second layout pass
W/View: requestLayout() improperly called by android.support.design.widget.TabLayout$TabView{3423cb57 VFE...C. ..S...ID 0,0-144,96} during layout: running second layout pass
W/View: requestLayout() improperly called by android.support.design.widget.TabLayout$TabView{377c4644 VFE...C. ......ID 144,0-322,96} during layout: running second layout pass
W/View: requestLayout() improperly called by android.support.design.widget.TabLayout$TabView{19ead32d VFE...C. ......ID 322,0-466,96} during layout: running second layout pass

Je ne sais pas comment le résoudre. Aucune suggestion?

  • Pour faire les mesures enfant TabLayout, je fais quelques castings et hypothèses (comme l'enfant est un LinearLayout contenant d'autres vues ....) Cela pourrait poser des problèmes avec les mises à jour ultérieures de la bibliothèque de support de conception. Une meilleure approche / suggestions?
Sotti
la source
4
 <android.support.design.widget.TabLayout
                    android:id="@+id/tabList"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center"
                    app:tabMode="scrollable"/>
user3205930
la source
1

C'est le seul code qui a fonctionné pour moi:

public static void adjustTabLayoutBounds(final TabLayout tabLayout,
                                         final DisplayMetrics displayMetrics){

    final ViewTreeObserver vto = tabLayout.getViewTreeObserver();
    vto.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

        @Override
        public void onGlobalLayout() {

            tabLayout.getViewTreeObserver().removeOnGlobalLayoutListener(this);

            int totalTabPaddingPlusWidth = 0;
            for(int i=0; i < tabLayout.getTabCount(); i++){

                final LinearLayout tabView = ((LinearLayout)((LinearLayout) tabLayout.getChildAt(0)).getChildAt(i));
                totalTabPaddingPlusWidth += (tabView.getMeasuredWidth() + tabView.getPaddingLeft() + tabView.getPaddingRight());
            }

            if (totalTabPaddingPlusWidth <= displayMetrics.widthPixels){

                tabLayout.setTabMode(TabLayout.MODE_FIXED);
                tabLayout.setTabGravity(TabLayout.GRAVITY_FILL);

            }else{
                tabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
            }

            tabLayout.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
        }
    });
}

Le DisplayMetrics peut être récupéré en utilisant ceci:

public DisplayMetrics getDisplayMetrics() {

    final WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
    final Display display = wm.getDefaultDisplay();
    final DisplayMetrics displayMetrics = new DisplayMetrics();

    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
        display.getMetrics(displayMetrics);

    }else{
        display.getRealMetrics(displayMetrics);
    }

    return displayMetrics;
}

Et votre XML TabLayout devrait ressembler à ceci (n'oubliez pas de définir tabMaxWidth sur 0):

<android.support.design.widget.TabLayout
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/tab_layout"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:tabMaxWidth="0dp"/>
Tiago
la source
1
C'est presque là mais il y a quelques problèmes. Le problème le plus évident est que sur certains appareils (et la plupart des appareils lents), vous verrez en fait comment la disposition est modifiée et changée.
Sotti
1
Il y a un autre problème, cette approche mesure la largeur totale du TabLayout pour décider s'il faut faire défiler ou non. Ce n'est pas très précis. Il y a des situations où le TabLayout n'atteint pas les deux bords en mode défilable, mais il n'y a pas assez de place pour le mode fixe sans réduire le texte d'abuser du nombre de lignes sur l'onglet (généralement 2). Ceci est une conséquence directe du fait que les onglets en mode fixe ont une largeur fixe (screenWidth / numberOfTabs) alors qu'en mode scrollable ils enveloppent le texte + les paddings.
Sotti
1

Tout ce dont vous avez besoin est d'ajouter ce qui suit à votre TabLayout

custom:tabGravity="fill"

Alors vous aurez:

xmlns:custom="http://schemas.android.com/apk/res-auto"
<android.support.design.widget.TabLayout
        android:id="@+id/tabs"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        custom:tabGravity="fill"
        />
RicNjesh
la source
Ce n'est pas ce que le créateur demande. Le problème ici est que les onglets ne pourront jamais faire défiler et que vous vous débarrasserez de l'espace sur l'écran. Les onglets commenceront à réduire son texte et finiront par en avoir deux lignés.
Sotti
1

J'ai résolu cela en utilisant

if(tabLayout_chemistCategory.getTabCount()<4)
    {
        tabLayout_chemistCategory.setTabGravity(TabLayout.GRAVITY_FILL);
    }else
    {
        tabLayout_chemistCategory.setTabMode(TabLayout.MODE_SCROLLABLE);

    }
Zohaib Khaliq
la source
1

Exemple très simple et ça marche toujours.

/**
 * Setup stretch and scrollable TabLayout.
 * The TabLayout initial parameters in layout must be:
 * android:layout_width="wrap_content"
 * app:tabMaxWidth="0dp"
 * app:tabGravity="fill"
 * app:tabMode="fixed"
 *
 * @param context   your Context
 * @param tabLayout your TabLayout
 */
public static void setupStretchTabLayout(Context context, TabLayout tabLayout) {
    tabLayout.post(() -> {

        ViewGroup.LayoutParams params = tabLayout.getLayoutParams();
        if (params.width == ViewGroup.LayoutParams.MATCH_PARENT) { // is already set up for stretch
            return;
        }

        int deviceWidth = context.getResources()
                                 .getDisplayMetrics().widthPixels;

        if (tabLayout.getWidth() < deviceWidth) {
            tabLayout.setTabMode(TabLayout.MODE_FIXED);
            params.width = ViewGroup.LayoutParams.MATCH_PARENT;
        } else {
            tabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
            params.width = ViewGroup.LayoutParams.WRAP_CONTENT;
        }
        tabLayout.setLayoutParams(params);

    });

}
LordTAO
la source
Merci pour l'idée. Avec un peu de changement pour mon cas, ça marche comme du charme
Eren Tüfekçi
1

Ma solution finale

class DynamicModeTabLayout : TabLayout {

    constructor(context: Context?) : super(context)
    constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr)

    override fun setupWithViewPager(viewPager: ViewPager?) {
        super.setupWithViewPager(viewPager)

        val view = getChildAt(0) ?: return
        view.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED)
        val size = view.measuredWidth

        if (size > measuredWidth) {
            tabMode = MODE_SCROLLABLE
            tabGravity = GRAVITY_CENTER
        } else {
            tabMode = MODE_FIXED
            tabGravity = GRAVITY_FILL
        }
    }
}
utilisateur4097210
la source