एंड्रॉइड सपोर्ट डिज़ाइन टैबलैयूट: ग्रेविटी सेंटर और मोड स्क्रॉलेबल


98

मैं अपने प्रोजेक्ट में नए डिजाइन टैबलैयूट का उपयोग करने की कोशिश कर रहा हूं। मैं चाहता हूं कि लेआउट हर स्क्रीन आकार और अभिविन्यास के अनुकूल हो, लेकिन इसे एक अभिविन्यास में सही ढंग से देखा जा सकता है।

मैं गुरुत्वाकर्षण और मोड के साथ अपने टैबलैट को सेट कर रहा हूं:

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

इसलिए मुझे उम्मीद है कि यदि कोई कमरा नहीं है, तो टैबआउट स्क्रॉल करने योग्य है, लेकिन अगर कमरा है, तो यह केंद्रित है।

गाइड से:

सार्वजनिक स्थैतिक अंतिम int GRAVITY_CENTER गुरुत्व टैबलैटआउट के केंद्र में टैब का उपयोग करता था।

सार्वजनिक स्थैतिक अंतिम int GRAVITY_FILL गुरुत्वाकर्षण जितना संभव हो उतना TabLayout भरने के लिए उपयोग किया जाता है। यह विकल्प केवल तब प्रभावी होता है जब MODE_FIXED के साथ उपयोग किया जाता है।

सार्वजनिक स्थैतिक अंतिम int MODE_FIXED निश्चित टैब सभी टैब को समवर्ती रूप से प्रदर्शित करते हैं और उन सामग्री के साथ सर्वोत्तम रूप से उपयोग किए जाते हैं जो टैब के बीच त्वरित पिवोट्स से लाभान्वित होते हैं। टैब की अधिकतम संख्या दृश्य की चौड़ाई से सीमित है। विस्तृत टैब लेबल के आधार पर निश्चित टैब की चौड़ाई समान होती है।

सार्वजनिक स्थिर अंतिम int MODE_SCROLLABLE स्क्रॉल करने योग्य टैब किसी भी समय टैब का एक सबसेट प्रदर्शित करते हैं, और इसमें लंबे समय तक टैब लेबल और बड़ी संख्या में टैब हो सकते हैं। जब वे सीधे टैब लेबलों की तुलना करने की आवश्यकता नहीं करते हैं, तो वे स्पर्श इंटरफेस में ब्राउज़िंग संदर्भों के लिए उपयोग किए जाते हैं।

तो GRAVITY_FILL केवल MODE_FIXED के साथ संगत है, लेकिन, GRAVITY_CENTER के लिए कुछ भी निर्दिष्ट नहीं करता है, मुझे उम्मीद है कि यह MODE_SCROLLABLE के साथ संगत होगा, लेकिन यह वही है जो मैं GRAVITY_CENTER और MODE_SCROLLABLE

यहां छवि विवरण दर्ज करें

इसलिए यह दोनों झुकावों में SCROLLABLE का उपयोग कर रहा है, लेकिन यह GRAVITY_CENTER का उपयोग नहीं कर रहा है।

यह वही है जो मैं परिदृश्य के लिए उम्मीद करूंगा; लेकिन यह करने के लिए, मुझे MODE_FIXED सेट करने की आवश्यकता है, इसलिए मुझे पोर्ट्रेट में जो मिलता है वह है:

यहां छवि विवरण दर्ज करें

अगर टैबलाऊट स्क्रीन पर फिट बैठता है तो GRAVITY_CENTER SCROLLABLE के लिए काम क्यों नहीं कर रहा है? क्या गुरुत्वाकर्षण और मोड को गतिशील रूप से सेट करने का कोई तरीका है (और यह देखने के लिए कि मैं क्या उम्मीद कर रहा हूं)?

आपका बहुत बहुत धन्यवाद!

संपादित करें: यह मेरे टैब लेआउट का लेआउट है:

<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" />

@ फाइटर 42 क्या आपको इसका कोई हल मिला? मैं भी ऐसी ही समस्या का सामना कर रहा हूँ।
स्पाइनेट

एकमात्र तरीका जो मैंने पाया, वह आपके टैब का आकार (मैन्युअल रूप से) प्राप्त कर रहा था और फिर लेआउट पैरामीटर को कॉन्फ़िगर करता है कि यह फिट बैठता है या नहीं।
जेवियर डेलगाडो

@ Fighter42, क्या आप उस समाधान के लिए कुछ नमूना कोड पोस्ट कर सकते हैं जो आप उपयोग कर रहे हैं?
शाम १२:१२ पर सैम

1
मुझे पता है कि मेरा जवाब तार्किक के लिए अच्छा नहीं है लेकिन यह मेरी मदद करता है। पाठ से पहले और बाद में कुछ रिक्त स्थान रखें। तब यह स्क्रॉल किया जाएगा। दोनों मोड में।
अम्मी

जवाबों:


127

टैब गुरुत्वाकर्षण केवल प्रभाव MODE_FIXED

एक संभव समाधान अपने सेट करने के लिए है layout_widthकरने के लिए wrap_contentऔर layout_gravityकरने के लिए 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" />

यदि टैब स्क्रीन की चौड़ाई से छोटी हैं, तो TabLayoutस्वयं भी छोटा होगा और यह गुरुत्वाकर्षण के कारण केंद्रित होगा। यदि टैब स्क्रीन की चौड़ाई से बड़ी हैं, तो स्क्रीन की चौड़ाई TabLayoutसे मेल खाएगी और स्क्रॉल सक्रिय हो जाएगा।


1
मैं अपने ऐप के लिए मटीरियल डिज़ाइन का उपयोग कर रहा हूं। मैंने androidhive.info/2015/09/… से नमूना का पालन किया था । किटकैट और जेली बीन उपकरणों में टैब स्क्रॉल करने योग्य काम नहीं कर रहा है। लॉलीपॉप में मैं टैब को स्क्रॉल करने में सक्षम हूं, लेकिन लॉलीपॉप डिवाइस के अलावा अन्य टैब स्क्रॉल करने योग्य काम नहीं कर रहा है, लेकिन स्वाइप ठीक काम कर रहा है। मुझे पता है कि क्या समस्या होगी।
user2681579

यह मेरे लिए एपीआई 15 / support.design:25.1.0 पर काम नहीं किया। खिड़की की चौड़ाई की तुलना में संकीर्ण होने पर टैब को उचित ठहराया गया था। सेटिंग app:tabMaxWidth="0dp"और android:layout_centerHorizontal="true"केंद्र टैब पर काम किया।
बेकर

1
इसने मेरे लिए काम किया। टैब सभी मार्ग केंद्रित हैं, लेकिन जब वे वास्तव में स्क्रॉल करने योग्य नहीं होते हैं, तो वे सभी चौड़ाई नहीं भरते हैं।
जोस

14

मैंने इस तरह से इसे किया

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

मैंने रननीय हिस्से पर @Mario Velasco के समाधान के छोटे बदलाव किए


इस समाधान में वही समस्याएं हैं जिनका मैंने टियागो के समाधान पर उल्लेख किया है।
सोती

यह सॉल्यूशन आइकन के बिना टैब पर काम करता है, अगर मेरे पास टेक्स्ट के साथ आइकन है तो क्या होगा ?? : /
एमरे टेकिन

@EmreTekin हाँ यह एक आइकन के साथ काम करता है, मेरे टैब में टेक्स्ट के साथ आइकन थे
फ्लक्स

tabLayout.getWidth()हमेशा मेरे लिए शून्य लौटता है
ishandutta2007

9

चीजें सरल रखता है बस ऐप जोड़ें: tabMode = "स्क्रॉल करने योग्य" और Android: लेआउट_ग्रेविटी = "निचला"

सिर्फ इस तरह

<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" />

यहां छवि विवरण दर्ज करें


7
यह वह नहीं है जो निर्माता पूछ रहा है। इस दृष्टिकोण के साथ समस्या यह है कि ऐसे परिदृश्यों में जहाँ आपके फ़ोन में 2 टैब या 3 तीन टैब हैं जहाँ पाठ छोटा है, आपके पास Google Play Store जैसा एक लेआउट होगा जहाँ टैब बाईं ओर हैं। निर्माता चाहता है कि टैब किनारे से किनारे तक पहुंच सके जब यह संभव हो, और अन्यथा स्क्रॉल करें।
सोती

एक ही समस्या है। यू इसे ठीक कर सकते हैं?
होआंग

8

जैसा कि मैंने नहीं पाया कि यह व्यवहार क्यों होता है मैंने निम्नलिखित कोड का उपयोग किया है:

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

असल में, मुझे मैन्युअल रूप से अपने टैबलैटआउट की चौड़ाई की गणना करनी होगी और फिर मैं टैब मोड को इस बात पर निर्भर करता हूं कि टैबलैटआउट डिवाइस में फिट बैठता है या नहीं।

मुझे मैन्युअल रूप से लेआउट का आकार क्यों मिलता है इसका कारण यह है कि सभी टैब में स्क्रॉल करने योग्य मोड में समान चौड़ाई नहीं है, और इससे यह भड़क सकता है कि कुछ नाम 2 लाइनों का उपयोग करते हैं जैसा कि उदाहरण में मेरे साथ हुआ था।


इस समाधान के साथ पाठ संभावित रूप से सिकुड़ सकता है और साथ ही 2 लाइनों का उपयोग कर सकता है। इसके बारे में इस धागे में अन्य उत्तर और समाधान देखें। आप इस प्रदर्शित होने के जोखिम को कम कर रहे हैं, लेकिन अक्सर तब भी दिखाई देगा जब टैबलाइउट स्क्रीनविद से थोड़ा छोटा है।
सोती

7

को देखो android-tablayouthelper

स्वचालित रूप से TabLayout.MODE_FIXED को स्विच करें और TabLayout.MODE_SCROLLABLE कुल टैब चौड़ाई पर निर्भर करता है।


लेकिन जब टैब टाइटल गतिशील होते हैं। पाठ अगली पंक्ति में जाता है। और यदि टैब के लिए कस्टम लेआउट का उपयोग करें। पाठ अंत में दीर्घवृत्त की तरह है
AndroidGeek

4

यह वह समाधान है जिसका उपयोग मैंने स्वचालित रूप से SCROLLABLEऔर FIXED+ के बीच परिवर्तन के लिए किया था FILL। यह @ लड़ाकू 42 समाधान के लिए पूरा कोड है:

(नीचे दिया गया कोड दिखाता है कि यदि आपने 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);
            }
        }
    });
}

लेआउट:

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

यदि आपको चौड़ाई भरने की आवश्यकता नहीं है, तो @karaokyo समाधान का उपयोग करना बेहतर है।


यह अच्छी तरह से काम करता है; लैंडस्केप और पोर्ट्रेट के बीच स्विच करना वैसा ही होता है जैसा आप उम्मीद कर सकते हैं। Google को टैब्ड गतिविधि के लिए डिफ़ॉल्ट टेम्पलेट में इसे लागू करना चाहिए।
कोई व्यक्ति

इस जवाब में वही समस्याएं हैं जिनका मैंने टियागो के समाधान में उल्लेख किया है।
सोती

4

मैंने इसे प्राप्त करने के लिए एक AdaptiveTabLayout वर्ग बनाया। यह एकमात्र तरीका था जो मुझे वास्तव में समस्या को हल करने, सवाल का जवाब देने और अन्य समस्याओं से बचने के लिए मिला था।

टिप्पणियाँ:

  • फोन / टैबलेट लेआउट संभालती है।
  • उन मामलों को संभालता है, जहां के लिए पर्याप्त जगह MODE_SCROLLABLEनहीं है , लेकिन इसके लिए पर्याप्त जगह नहीं है MODE_FIXED। यदि आप इस मामले को नहीं संभालते हैं, तो यह कुछ उपकरणों पर होने वाला है, आपको कुछ टैब में विभिन्न पाठ आकार या पाठ की दो पंक्तियाँ दिखाई देंगी, जो खराब दिखती हैं।
  • यह वास्तविक उपाय प्राप्त करता है और कोई भी धारणा नहीं बनाता है (जैसे स्क्रीन 360dp चौड़ी या जो भी हो ...)। यह वास्तविक स्क्रीन आकार और वास्तविक टैब आकार के साथ काम करता है। इसका अर्थ है अनुवाद के साथ अच्छी तरह से काम करता है क्योंकि किसी भी टैब का आकार ग्रहण नहीं करता है, टैब को माप मिलता है।
  • अतिरिक्त काम से बचने के लिए ऑन-लाईट चरण में अलग-अलग पास के साथ सौदा।
  • लेआउट की चौड़ाई wrap_contentxml पर होनी चाहिए । 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;
    }

}

और यह 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;
    }

}

उदाहरण का उपयोग करें:

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

सार

समस्याएँ / मदद के लिए पूछें:

  • आप इसे देखेंगे:

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

मुझे यकीन नहीं है कि इसे कैसे हल किया जाए। कोई सुझाव?

  • TabLayout बच्चे के उपाय करने के लिए, मैं कुछ कास्टिंग और धारणाएं बना रहा हूं (जैसे बच्चा एक LinearLayout है जिसमें अन्य दृश्य हैं ....) इससे डिज़ाइन समर्थन लाइब्रेरी अद्यतनों में और समस्याएँ हो सकती हैं। एक बेहतर दृष्टिकोण / सुझाव?

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"/>

1

यह एकमात्र कोड है जो मेरे लिए काम करता है:

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

DisplayMetrics का उपयोग करके इसे पुनः प्राप्त किया जा सकता है:

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

और आपका TabLayout XML इस तरह दिखना चाहिए (tabMaxWidth को 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"/>

1
यह लगभग वहां है लेकिन कुछ समस्याएं हैं। सबसे स्पष्ट समस्या यह है कि कुछ उपकरणों में (और अधिकांश धीमी गति से) आप वास्तव में देखेंगे कि लेआउट कैसे संशोधित और बदला जाता है।
सोती

1
एक और समस्या है, यह दृष्टिकोण तय करने के लिए टैबलैट की कुल चौड़ाई को मापता है कि क्या स्क्रॉल करने योग्य है या नहीं। यह बहुत सटीक नहीं है। ऐसी स्थितियां हैं जहां स्क्रॉल मोड के दौरान टैबलैटआउट दोनों किनारों तक नहीं पहुंचता है, लेकिन टैब पर लाइनों की संख्या का दुरुपयोग करने के पाठ को सिकोड़ने के बिना निश्चित मोड के लिए पर्याप्त जगह नहीं है (आमतौर पर 2)। यह निश्चित मोड में टैब का एक सीधा परिणाम है, जिसमें एक निश्चित चौड़ाई (स्क्रीनविद / नंबरऑफटैब) है, जबकि स्क्रॉल करने योग्य मोड में वे टेक्स्ट + पेडिंग को लपेट रहे हैं।
सोती

1

आपको बस अपनी टैबलाईट में निम्नलिखित जोड़ना है

custom:tabGravity="fill"

तो फिर आपके पास होगा:

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"
        />

यह वह नहीं है जो निर्माता पूछ रहा है। यहां समस्याएं हैं टैब कभी स्क्रॉल नहीं होंगे, और आपको स्क्रीन में जगह से छुटकारा मिल जाएगा। टैब पाठ को सिकोड़ना शुरू कर देगा और अंततः वे दो पंक्तिबद्ध हो जाएंगे।
सोती

1

मैंने निम्नलिखित का उपयोग करके इसे हल किया

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

    }

1

बहुत सरल उदाहरण है और यह हमेशा काम करता है।

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

    });

}

विचार के लिए धन्यवाद। मेरे मामले के लिए थोड़ा सा बदलाव के साथ, आकर्षण की तरह काम करता है
एरेन टुफेकी

1

मेरा अंतिम समाधान

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
        }
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.