Please help me to make tab layout with swipable and use style it?

Question

I want show 'layout1' in first tab and 'layout2' in 2th tab. How to create tab layout using fragments and viewpager. Also you can swipe between tab view as it is the functionality of viewpager which is not possible when using TabHost.

for example:

Answer 1

Create a parent Fragment

public class ShareSpaceFragment extends Fragment {

private static Context mContext = null;
private boolean mTabletSize = false;
private static SlidingTabLayout mSlidingTabLayout = null;
SmartDocFactory homeFact = null;
HomeManagement home = null;
Localization local;
public static ViewPager pager;

public ShareSpaceFragment() {
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {

    View view = inflater.inflate(R.layout.fragment_sharespace, container,
            false);
    homeFact = FactoryGenerator.getFactory(Constants.HOME);
    home = homeFact.getHomeManagement(Constants.SHARESPACE);
    local = home.readAssets(mContext);
    mTabletSize = getResources().getBoolean(R.bool.isTablet);
    mContext = getActivity();
    pager = (ViewPager) view.findViewById(R.id.pager);

    ShareSpaceAdapter pagerAdapter = new ShareSpaceAdapter(mContext,
            getChildFragmentManager());
    pager.setOffscreenPageLimit(2);
    pager.setAdapter(pagerAdapter);
    mSlidingTabLayout = (SlidingTabLayout) view
            .findViewById(R.id.sliding_tabs_share);
    mSlidingTabLayout.setViewPager(pager);
    mSlidingTabLayout
            .setCustomTabColorizer(new SlidingTabLayout.TabColorizer() {

                // the color of the indicator
                @Override
                public int getIndicatorColor(int position) {
                    return Color.WHITE;
                }

                @Override
                public int getDividerColor(int position) {
                    return 0;
                }

            });

    return view;
}}

Step 2:Adapter corresponds to main Fragment

public class ShareSpaceAdapter extends FragmentPagerAdapter {

final int PAGE_COUNT = 3;
private Context mContext = null;
SmartDocFactory homeFact = null;
HomeManagement home = null;
private Localization local = null;

public ShareSpaceAdapter(Context mContext, FragmentManager fm) {
    super(fm);
    this.mContext = mContext;
    try {
        if (home == null) {
            homeFact = FactoryGenerator.getFactory(Constants.HOME);
            home = homeFact.getHomeManagement(Constants.SHARESPACE);
        }
        local = home.readAssets(mContext);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public Fragment getItem(int arg0) {
    Fragment frgmt = null;

    switch (arg0) {
    case 0:

        frgmt = new ShareSpaceFiles(mContext);
        break;
    case 1:

        frgmt = new ShareSpaceFolder(mContext);
        break;
    case 2:

        frgmt = new ShareSpaceInbox(mContext);
        break;

    default:
        break;
    }

    return frgmt;
}

@Override
public int getCount() {
    return PAGE_COUNT;
}

@Override
public CharSequence getPageTitle(int position) {

    switch (position) {
    case 0: // Fragment # 0 - This will show FirstFragment
        return local.getmFiles();// "FILES";
    case 1: // Fragment # 0 - This will show FirstFragment different title
        return local.getmFolders();// "FOLDERS";
    case 2:
        return local.getmMessages();// "MESSAGES";

    default:
        return null;

    }}
}

In getItem() method write your child fragments

step 3 Parent Fragment xml file

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:gravity="right"
 tools:context="com.teknowmics.smartdocs.ShareSpace" >
 <com.teknowmics.smartdocs.helpers.SlidingTabLayout
    android:id="@+id/sliding_tabs_share"
    android:layout_width="match_parent"
    android:background="#1DAD52"
    android:layout_height="wrap_content"
    android:layout_marginTop="-10dp"
    />

<android.support.v4.view.ViewPager
    android:id="@+id/pager"
    android:layout_weight="1.5"
    android:layout_width="match_parent"
    android:layout_below="@id/sliding_tabs_share"
    android:background="@android:color/white"
    android:layout_height="fill_parent"

>

    <!-- <android.support.v4.view.PagerTabStrip
        android:id="@+id/pager_tab_strip"
        android:layout_width="fill_parent"
        android:layout_height="50dp"
        android:layout_gravity="top"
        android:background="#1DAD52"

        android:textColor="#ffffff" 
        /> -->


</android.support.v4.view.ViewPager>

step 4:slidingTabLayout.java

public class SlidingTabLayout extends HorizontalScrollView {

/**
 * Allows complete control over the colors drawn in the tab layout. Set with
 * {@link #setCustomTabColorizer(com.webarts.loyalwin.slidingtab.library.SlidingTabLayout.TabColorizer)}
 * .
 */
public interface TabColorizer {

    /**
     * @return return the color of the indicator used when {@code position}
     *         is selected.
     */
    int getIndicatorColor(int position);

    /**
     * @return return the color of the divider drawn to the right of
     *         {@code position}.
     */
    int getDividerColor(int position);

}

private static final int TITLE_OFFSET_DIPS = 24;
private static final int TAB_VIEW_PADDING_DIPS = 20;
private static final int TAB_VIEW_TEXT_SIZE_SP = 14;

private int mTitleOffset;

private int mTabViewLayoutId;
private int mTabViewTextViewId;

private ViewPager mViewPager;
private ViewPager.OnPageChangeListener mViewPagerPageChangeListener;

private final SlidingTabStrip mTabStrip;

public SlidingTabLayout(Context context) {
    this(context, null);
}

public SlidingTabLayout(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
}

public SlidingTabLayout(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);

    // Disable the Scroll Bar
    setHorizontalScrollBarEnabled(false);
    // Make sure that the Tab Strips fills this View
    setFillViewport(true);

    mTitleOffset = (int) (TITLE_OFFSET_DIPS * getResources()
            .getDisplayMetrics().density);

    mTabStrip = new SlidingTabStrip(context);
    addView(mTabStrip, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
}

/**
 * Set the custom
 * {@link com.webarts.loyalwin.slidingtab.library.SlidingTabLayout.TabColorizer}
 * to be used.
 * <p/>
 * If you only require simple custmisation then you can use
 * {@link #setSelectedIndicatorColors(int...)} and
 * {@link #setDividerColors(int...)} to achieve similar effects.
 */
public void setCustomTabColorizer(TabColorizer tabColorizer) {
    mTabStrip.setCustomTabColorizer(tabColorizer);
}

/**
 * Sets the colors to be used for indicating the selected tab. These colors
 * are treated as a circular array. Providing one color will mean that all
 * tabs are indicated with the same color.
 */
public void setSelectedIndicatorColors(int... colors) {
    mTabStrip.setSelectedIndicatorColors(colors);
}

/**
 * Sets the colors to be used for tab dividers. These colors are treated as
 * a circular array. Providing one color will mean that all tabs are
 * indicated with the same color.
 */
public void setDividerColors(int... colors) {
    mTabStrip.setDividerColors(colors);
}

/**
 * Set the {@link android.support.v4.view.ViewPager.OnPageChangeListener}.
 * When using
 * {@link com.webarts.loyalwin.slidingtab.library.SlidingTabLayout} you are
 * required to set any
 * {@link android.support.v4.view.ViewPager.OnPageChangeListener} through
 * this method. This is so that the layout can update it's scroll position
 * correctly.
 * 
 * @see android.support.v4.view.ViewPager#setOnPageChangeListener(android.support.v4.view.ViewPager.OnPageChangeListener)
 */
public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
    mViewPagerPageChangeListener = listener;
}

/**
 * Set the custom layout to be inflated for the tab views.
 * 
 * @param layoutResId
 *            Layout id to be inflated
 * @param textViewId
 *            id of the {@link android.widget.TextView} in the inflated view
 */
public void setCustomTabView(int layoutResId, int textViewId) {
    mTabViewLayoutId = layoutResId;
    mTabViewTextViewId = textViewId;
}

/**
 * Sets the associated view pager. Note that the assumption here is that the
 * pager content (number of tabs and tab titles) does not change after this
 * call has been made.
 */
public void setViewPager(ViewPager viewPager) {
    mTabStrip.removeAllViews();

    mViewPager = viewPager;
    if (viewPager != null) {
        viewPager.setOnPageChangeListener(new InternalViewPagerListener());
        populateTabStrip();
    }
}

/**
 * Create a default view to be used for tabs. This is called if a custom tab
 * view is not set via {@link #setCustomTabView(int, int)}.
 */
@SuppressLint("NewApi")
protected TextView createDefaultTabView(Context context) {
    TextView textView = new TextView(context);
    textView.setGravity(Gravity.CENTER);
    textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, TAB_VIEW_TEXT_SIZE_SP);
    textView.setTypeface(Typeface.DEFAULT_BOLD);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        // If we're running on Honeycomb or newer, then we can use the
        // Theme's
        // selectableItemBackground to ensure that the View has a pressed
        // state
        TypedValue outValue = new TypedValue();
        getContext().getTheme().resolveAttribute(
                android.R.attr.selectableItemBackground, outValue, true);
        textView.setBackgroundResource(outValue.resourceId);
    }

    // make them in uppercase
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
        // If we're running on ICS or newer, enable all-caps to match the
        // Action Bar tab style
        // textView.setAllCaps(true);
    }

    int padding = (int) (TAB_VIEW_PADDING_DIPS * getResources()
            .getDisplayMetrics().density);
    textView.setPadding(40, padding, 40, padding);

    return textView;
}

private void populateTabStrip() {
    final PagerAdapter adapter = mViewPager.getAdapter();
    final OnClickListener tabClickListener = new TabClickListener();

    for (int i = 0; i < adapter.getCount(); i++) {
        View tabView = null;
        TextView tabTitleView = null;

        if (mTabViewLayoutId != 0) {
            // If there is a custom tab view layout id set, try and inflate
            // it
            tabView = LayoutInflater.from(getContext()).inflate(
                    mTabViewLayoutId, mTabStrip, false);
            tabTitleView = (TextView) tabView
                    .findViewById(mTabViewTextViewId);
        }

        if (tabView == null) {
            tabView = createDefaultTabView(getContext());
        }

        if (tabTitleView == null && TextView.class.isInstance(tabView)) {
            tabTitleView = (TextView) tabView;
        }

        tabTitleView.setText(adapter.getPageTitle(i));
        tabTitleView.setTextColor(getResources().getColorStateList(
                R.color.tab_text_color));

        mTabStrip.addView(tabView);

        if (i == mViewPager.getCurrentItem()) {
            tabView.setSelected(true);
        }

        tabView.setOnClickListener(tabClickListener);

    }
}

@Override
protected void onAttachedToWindow() {
    super.onAttachedToWindow();

    if (mViewPager != null) {
        scrollToTab(mViewPager.getCurrentItem(), 0);
    }
}

private void scrollToTab(int tabIndex, int positionOffset) {
    final int tabStripChildCount = mTabStrip.getChildCount();
    if (tabStripChildCount == 0 || tabIndex < 0
            || tabIndex >= tabStripChildCount) {
        return;
    }

    View selectedChild = mTabStrip.getChildAt(tabIndex);
    if (selectedChild != null) {
        int targetScrollX = selectedChild.getLeft() + positionOffset;

        if (tabIndex > 0 || positionOffset > 0) {
            // If we're not at the first child and are mid-scroll, make sure
            // we obey the offset
            targetScrollX -= mTitleOffset;
        }

        scrollTo(targetScrollX, 0);
    }
}

private class InternalViewPagerListener implements
        ViewPager.OnPageChangeListener {
    private int mScrollState;

    @Override
    public void onPageScrolled(int position, float positionOffset,
            int positionOffsetPixels) {
        int tabStripChildCount = mTabStrip.getChildCount();
        if ((tabStripChildCount == 0) || (position < 0)
                || (position >= tabStripChildCount)) {
            return;
        }

        mTabStrip.onViewPagerPageChanged(position, positionOffset);

        View selectedTitle = mTabStrip.getChildAt(position);
        int extraOffset = (selectedTitle != null) ? (int) (positionOffset * selectedTitle
                .getWidth()) : 0;
        scrollToTab(position, extraOffset);

        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageScrolled(position,
                    positionOffset, positionOffsetPixels);
        }
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        mScrollState = state;

        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageScrollStateChanged(state);
        }
    }

    @Override
    public void onPageSelected(int position) {
        if (mScrollState == ViewPager.SCROLL_STATE_IDLE) {
            mTabStrip.onViewPagerPageChanged(position, 0f);
            scrollToTab(position, 0);
        }
        for (int i = 0; i < mTabStrip.getChildCount(); i++) {
            mTabStrip.getChildAt(i).setSelected(position == i);
        }
        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageSelected(position);
        }
    }

}

private class TabClickListener implements OnClickListener {
    @Override
    public void onClick(View v) {
        for (int i = 0; i < mTabStrip.getChildCount(); i++) {
            if (v == mTabStrip.getChildAt(i)) {
                mViewPager.setCurrentItem(i);
                return;
            }
        }
    }
}

Step 5: SlidingTabStrip.java

class SlidingTabStrip extends LinearLayout {

private static final int DEFAULT_BOTTOM_BORDER_THICKNESS_DIPS = 0;
private static final byte DEFAULT_BOTTOM_BORDER_COLOR_ALPHA = 0x26;
private static final int SELECTED_INDICATOR_THICKNESS_DIPS = 4;
private static final int DEFAULT_SELECTED_INDICATOR_COLOR = 0xFFFFFFFF;
private static final int DEFAULT_DIVIDER_THICKNESS_DIPS = 1;
private static final byte DEFAULT_DIVIDER_COLOR_ALPHA = 0x20;
private static final float DEFAULT_DIVIDER_HEIGHT = 0.5f;
private final int mBottomBorderThickness;
private final Paint mBottomBorderPaint;
private final int mSelectedIndicatorThickness;
private final Paint mSelectedIndicatorPaint;
private final int mDefaultBottomBorderColor;
private final Paint mDividerPaint;
private final float mDividerHeight;
private int mSelectedPosition;
private float mSelectionOffset;

private SlidingTabLayout.TabColorizer mCustomTabColorizer;
private final SimpleTabColorizer mDefaultTabColorizer;

SlidingTabStrip(Context context) {
    this(context, null);
}

SlidingTabStrip(Context context, AttributeSet attrs) {
    super(context, attrs);
    setWillNotDraw(false);

    final float density = getResources().getDisplayMetrics().density;

    TypedValue outValue = new TypedValue();
    context.getTheme().resolveAttribute(R.attr.colorForeground, outValue,
            true);
    final int themeForegroundColor = outValue.data;

    mDefaultBottomBorderColor = setColorAlpha(themeForegroundColor,
            DEFAULT_BOTTOM_BORDER_COLOR_ALPHA);

    mDefaultTabColorizer = new SimpleTabColorizer();
    mDefaultTabColorizer
            .setIndicatorColors(DEFAULT_SELECTED_INDICATOR_COLOR);
    mDefaultTabColorizer.setDividerColors(setColorAlpha(
            themeForegroundColor, DEFAULT_DIVIDER_COLOR_ALPHA));

    mBottomBorderThickness = (int) (DEFAULT_BOTTOM_BORDER_THICKNESS_DIPS * density);
    mBottomBorderPaint = new Paint();
    mBottomBorderPaint.setColor(mDefaultBottomBorderColor);

    mSelectedIndicatorThickness = (int) (SELECTED_INDICATOR_THICKNESS_DIPS * density);
    mSelectedIndicatorPaint = new Paint();

    mDividerHeight = DEFAULT_DIVIDER_HEIGHT;
    mDividerPaint = new Paint();
    mDividerPaint
            .setStrokeWidth((int) (DEFAULT_DIVIDER_THICKNESS_DIPS * density));
}

void setCustomTabColorizer(SlidingTabLayout.TabColorizer customTabColorizer) {
    mCustomTabColorizer = customTabColorizer;
    invalidate();
}

void setSelectedIndicatorColors(int... colors) {
    // Make sure that the custom colorizer is removed
    mCustomTabColorizer = null;
    mDefaultTabColorizer.setIndicatorColors(colors);
    invalidate();
}

void setDividerColors(int... colors) {
    // Make sure that the custom colorizer is removed
    mCustomTabColorizer = null;
    mDefaultTabColorizer.setDividerColors(colors);
    invalidate();
}

void onViewPagerPageChanged(int position, float positionOffset) {
    mSelectedPosition = position;
    mSelectionOffset = positionOffset;
    invalidate();
}

@Override
protected void onDraw(Canvas canvas) {
    final int height = getHeight();
    final int childCount = getChildCount();
    final int dividerHeightPx = (int) (Math.min(
            Math.max(0f, mDividerHeight), 1f) * height);
    final SlidingTabLayout.TabColorizer tabColorizer = mCustomTabColorizer != null ? mCustomTabColorizer
            : mDefaultTabColorizer;

    // Thick colored underline below the current selection
    if (childCount > 0) {
        View selectedTitle = getChildAt(mSelectedPosition);
        int left = selectedTitle.getLeft();
        int right = selectedTitle.getRight();
        int color = tabColorizer.getIndicatorColor(mSelectedPosition);

        if (mSelectionOffset > 0f
                && mSelectedPosition < (getChildCount() - 1)) {
            int nextColor = tabColorizer
                    .getIndicatorColor(mSelectedPosition + 1);
            if (color != nextColor) {
                color = blendColors(nextColor, color, mSelectionOffset);
            }

            // Draw the selection partway between the tabs
            View nextTitle = getChildAt(mSelectedPosition + 1);
            left = (int) (mSelectionOffset * nextTitle.getLeft() + (1.0f - mSelectionOffset)
                    * left);
            right = (int) (mSelectionOffset * nextTitle.getRight() + (1.0f - mSelectionOffset)
                    * right);
        }

        mSelectedIndicatorPaint.setColor(color);

        canvas.drawRect(left, height - mSelectedIndicatorThickness, right,
                height, mSelectedIndicatorPaint);
    }

    // Thin underline along the entire bottom edge
    canvas.drawRect(0, height - mBottomBorderThickness, getWidth(), height,
            mBottomBorderPaint);

    // Vertical separators between the titles
    int separatorTop = (height - dividerHeightPx) / 2;
    for (int i = 0; i < childCount - 1; i++) {
        View child = getChildAt(i);
        mDividerPaint.setColor(tabColorizer.getDividerColor(i));
        canvas.drawLine(child.getRight(), separatorTop, child.getRight(),
                separatorTop + dividerHeightPx, mDividerPaint);
    }
}

/**
 * Set the alpha value of the {@code color} to be the given {@code alpha}
 * value.
 */
private static int setColorAlpha(int color, byte alpha) {
    return Color.argb(alpha, Color.red(color), Color.green(color),
            Color.blue(color));
}

/**
 * Blend {@code color1} and {@code color2} using the given ratio.
 * 
 * @param ratio
 *            of which to blend. 1.0 will return {@code color1}, 0.5 will
 *            give an even blend, 0.0 will return {@code color2}.
 */
private static int blendColors(int color1, int color2, float ratio) {
    final float inverseRation = 1f - ratio;
    float r = (Color.red(color1) * ratio)
            + (Color.red(color2) * inverseRation);
    float g = (Color.green(color1) * ratio)
            + (Color.green(color2) * inverseRation);
    float b = (Color.blue(color1) * ratio)
            + (Color.blue(color2) * inverseRation);
    return Color.rgb((int) r, (int) g, (int) b);
}

private static class SimpleTabColorizer implements
        SlidingTabLayout.TabColorizer {
    private int[] mIndicatorColors;
    private int[] mDividerColors;

    @Override
    public final int getIndicatorColor(int position) {
        return mIndicatorColors[position % mIndicatorColors.length];
    }

    @Override
    public final int getDividerColor(int position) {
        return mDividerColors[position % mDividerColors.length];
    }

    void setIndicatorColors(int... colors) {
        mIndicatorColors = colors;
    }

    void setDividerColors(int... colors) {
        mDividerColors = colors;
    }
}}

Import the required packages

Answer 2

You have to try new design support library.

In which new TabLayout is introduced ..?

You can check out over here..

http://android-developers.blogspot.in/2015/05/android-design-support-library.html

Answer 3

There is a good example code on AndroidHive that should contain all informations you need to create a tab layout by yourself or just take the code form it. ;)