android 底部标签栏CommonTabLayout搭建项目底部菜单（带消息提醒）

2401_84132401

1025人浏览 · 2024-04-15 08:35:47

2401_84132401 · 2024-04-15 08:35:47 发布

this.mContext = context;

mTabsContainer = new LinearLayout(context);

addView(mTabsContainer);

obtainAttributes(context, attrs);

//get layout_height

String height = attrs.getAttributeValue(“http://schemas.android.com/apk/res/android”, “layout_height”);

//create ViewPager

if (height.equals(ViewGroup.LayoutParams.MATCH_PARENT + “”)) {

} else if (height.equals(ViewGroup.LayoutParams.WRAP_CONTENT + “”)) {

} else {

int[] systemAttrs = {android.R.attr.layout_height};

TypedArray a = context.obtainStyledAttributes(attrs, systemAttrs);

mHeight = a.getDimensionPixelSize(0, ViewGroup.LayoutParams.WRAP_CONTENT);

a.recycle();

}

mValueAnimator = ValueAnimator.ofObject(new PointEvaluator(), mLastP, mCurrentP);

mValueAnimator.addUpdateListener(this);

}

private void obtainAttributes(Context context, AttributeSet attrs) {

TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CommonTabLayout);

mIndicatorStyle = ta.getInt(R.styleable.CommonTabLayout_tl_indicator_style, 0);

mIndicatorColor = ta.getColor(R.styleable.CommonTabLayout_tl_indicator_color, Color.parseColor(mIndicatorStyle == STYLE_BLOCK ? “#4B6A87” : “#ffffff”));

mIndicatorHeight = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_height,

dp2px(mIndicatorStyle == STYLE_TRIANGLE ? 4 : (mIndicatorStyle == STYLE_BLOCK ? -1 : 2)));

mIndicatorWidth = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_width, dp2px(mIndicatorStyle == STYLE_TRIANGLE ? 10 : -1));

mIndicatorCornerRadius = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_corner_radius, dp2px(mIndicatorStyle == STYLE_BLOCK ? -1 : 0));

mIndicatorMarginLeft = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_margin_left, dp2px(0));

mIndicatorMarginTop = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_margin_top, dp2px(mIndicatorStyle == STYLE_BLOCK ? 7 : 0));

mIndicatorMarginRight = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_margin_right, dp2px(0));

mIndicatorMarginBottom = ta.getDimension(R.styleable.CommonTabLayout_tl_indicator_margin_bottom, dp2px(mIndicatorStyle == STYLE_BLOCK ? 7 : 0));

mIndicatorAnimEnable = ta.getBoolean(R.styleable.CommonTabLayout_tl_indicator_anim_enable, true);

mIndicatorBounceEnable = ta.getBoolean(R.styleable.CommonTabLayout_tl_indicator_bounce_enable, true);

mIndicatorAnimDuration = ta.getInt(R.styleable.CommonTabLayout_tl_indicator_anim_duration, -1);

mIndicatorGravity = ta.getInt(R.styleable.CommonTabLayout_tl_indicator_gravity, Gravity.BOTTOM);

mUnderlineColor = ta.getColor(R.styleable.CommonTabLayout_tl_underline_color, Color.parseColor(“#ffffff”));

mUnderlineHeight = ta.getDimension(R.styleable.CommonTabLayout_tl_underline_height, dp2px(0));

mUnderlineGravity = ta.getInt(R.styleable.CommonTabLayout_tl_underline_gravity, Gravity.BOTTOM);

mDividerColor = ta.getColor(R.styleable.CommonTabLayout_tl_divider_color, Color.parseColor(“#ffffff”));

mDividerWidth = ta.getDimension(R.styleable.CommonTabLayout_tl_divider_width, dp2px(0));

mDividerPadding = ta.getDimension(R.styleable.CommonTabLayout_tl_divider_padding, dp2px(12));

mTextsize = ta.getDimension(R.styleable.CommonTabLayout_tl_textsize, sp2px(13f));

mTextSelectColor = ta.getColor(R.styleable.CommonTabLayout_tl_textSelectColor, Color.parseColor(“#ffffff”));

mTextUnselectColor = ta.getColor(R.styleable.CommonTabLayout_tl_textUnselectColor, Color.parseColor(“#AAffffff”));

mTextBold = ta.getInt(R.styleable.CommonTabLayout_tl_textBold, TEXT_BOLD_NONE);

mTextAllCaps = ta.getBoolean(R.styleable.CommonTabLayout_tl_textAllCaps, false);

mIconVisible = ta.getBoolean(R.styleable.CommonTabLayout_tl_iconVisible, true);

mIconGravity = ta.getInt(R.styleable.CommonTabLayout_tl_iconGravity, Gravity.TOP);

mIconWidth = ta.getDimension(R.styleable.CommonTabLayout_tl_iconWidth, dp2px(0));

mIconHeight = ta.getDimension(R.styleable.CommonTabLayout_tl_iconHeight, dp2px(0));

mIconMargin = ta.getDimension(R.styleable.CommonTabLayout_tl_iconMargin, dp2px(2.5f));

mTabSpaceEqual = ta.getBoolean(R.styleable.CommonTabLayout_tl_tab_space_equal, true);

mTabWidth = ta.getDimension(R.styleable.CommonTabLayout_tl_tab_width, dp2px(-1));

mTabPadding = ta.getDimension(R.styleable.CommonTabLayout_tl_tab_padding, mTabSpaceEqual || mTabWidth > 0 ? dp2px(0) : dp2px(10));

ta.recycle();

}

public void setTabData(ArrayList tabEntitys) {

if (tabEntitys == null || tabEntitys.size() == 0) {

throw new IllegalStateException(“TabEntitys can not be NULL or EMPTY !”);

}

this.mTabEntitys.clear();

this.mTabEntitys.addAll(tabEntitys);

notifyDataSetChanged();

}

/** 关联数据支持同时切换fragments */

public void setTabData(ArrayList tabEntitys, FragmentActivity fa, int containerViewId, ArrayList fragments) {

mFragmentChangeManager = new FragmentChangeManager(fa.getSupportFragmentManager(), containerViewId, fragments);

setTabData(tabEntitys);

}

/** 更新数据 */

public void notifyDataSetChanged() {

mTabsContainer.removeAllViews();

this.mTabCount = mTabEntitys.size();

View tabView;

for (int i = 0; i < mTabCount; i++) {

if (mIconGravity == Gravity.LEFT) {

tabView = View.inflate(mContext, R.layout.layout_tab_left, null);

} else if (mIconGravity == Gravity.RIGHT) {

tabView = View.inflate(mContext, R.layout.layout_tab_right, null);

} else if (mIconGravity == Gravity.BOTTOM) {

tabView = View.inflate(mContext, R.layout.layout_tab_bottom, null);

} else {

tabView = View.inflate(mContext, R.layout.layout_tab_top, null);

}

tabView.setTag(i);

addTab(i, tabView);

}

updateTabStyles();

}

/** 创建并添加tab */

private void addTab(final int position, View tabView) {

TextView tv_tab_title = (TextView) tabView.findViewById(R.id.tv_tab_title);

tv_tab_title.setText(mTabEntitys.get(position).getTabTitle());

ImageView iv_tab_icon = (ImageView) tabView.findViewById(R.id.iv_tab_icon);

iv_tab_icon.setImageResource(mTabEntitys.get(position).getTabUnselectedIcon());

tabView.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

int position = (Integer) v.getTag();

if (mCurrentTab != position) {

setCurrentTab(position);

if (mListener != null) {

mListener.onTabSelect(position);

}

} else {

if (mListener != null) {

mListener.onTabReselect(position);

}

});

/** 每一个Tab的布局参数 */

LinearLayout.LayoutParams lp_tab = mTabSpaceEqual ?

new LinearLayout.LayoutParams(0, LayoutParams.MATCH_PARENT, 1.0f) :

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

if (mTabWidth > 0) {

lp_tab = new LinearLayout.LayoutParams((int) mTabWidth, LayoutParams.MATCH_PARENT);

}

mTabsContainer.addView(tabView, position, lp_tab);

}

private void updateTabStyles() {

for (int i = 0; i < mTabCount; i++) {

View tabView = mTabsContainer.getChildAt(i);

tabView.setPadding((int) mTabPadding, 0, (int) mTabPadding, 0);

TextView tv_tab_title = (TextView) tabView.findViewById(R.id.tv_tab_title);

tv_tab_title.setTextColor(i == mCurrentTab ? mTextSelectColor : mTextUnselectColor);

tv_tab_title.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextsize);

// tv_tab_title.setPadding((int) mTabPadding, 0, (int) mTabPadding, 0);

if (mTextAllCaps) {

tv_tab_title.setText(tv_tab_title.getText().toString().toUpperCase());

}

if (mTextBold == TEXT_BOLD_BOTH) {

tv_tab_title.getPaint().setFakeBoldText(true);

} else if (mTextBold == TEXT_BOLD_NONE) {

tv_tab_title.getPaint().setFakeBoldText(false);

}

ImageView iv_tab_icon = (ImageView) tabView.findViewById(R.id.iv_tab_icon);

if (mIconVisible) {

iv_tab_icon.setVisibility(View.VISIBLE);

CustomTabEntity tabEntity = mTabEntitys.get(i);

iv_tab_icon.setImageResource(i == mCurrentTab ? tabEntity.getTabSelectedIcon() : tabEntity.getTabUnselectedIcon());

LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(

mIconWidth <= 0 ? LinearLayout.LayoutParams.WRAP_CONTENT : (int) mIconWidth,

mIconHeight <= 0 ? LinearLayout.LayoutParams.WRAP_CONTENT : (int) mIconHeight);

if (mIconGravity == Gravity.LEFT) {

lp.rightMargin = (int) mIconMargin;

} else if (mIconGravity == Gravity.RIGHT) {

lp.leftMargin = (int) mIconMargin;

} else if (mIconGravity == Gravity.BOTTOM) {

lp.topMargin = (int) mIconMargin;

} else {

lp.bottomMargin = (int) mIconMargin;

}

iv_tab_icon.setLayoutParams(lp);

} else {

iv_tab_icon.setVisibility(View.GONE);

}

private void updateTabSelection(int position) {

for (int i = 0; i < mTabCount; ++i) {

View tabView = mTabsContainer.getChildAt(i);

final boolean isSelect = i == position;

TextView tab_title = (TextView) tabView.findViewById(R.id.tv_tab_title);

tab_title.setTextColor(isSelect ? mTextSelectColor : mTextUnselectColor);

ImageView iv_tab_icon = (ImageView) tabView.findViewById(R.id.iv_tab_icon);

CustomTabEntity tabEntity = mTabEntitys.get(i);

iv_tab_icon.setImageResource(isSelect ? tabEntity.getTabSelectedIcon() : tabEntity.getTabUnselectedIcon());

if (mTextBold == TEXT_BOLD_WHEN_SELECT) {

tab_title.getPaint().setFakeBoldText(isSelect);

}

private void calcOffset() {

final View currentTabView = mTabsContainer.getChildAt(this.mCurrentTab);

mCurrentP.left = currentTabView.getLeft();

mCurrentP.right = currentTabView.getRight();

final View lastTabView = mTabsContainer.getChildAt(this.mLastTab);

mLastP.left = lastTabView.getLeft();

mLastP.right = lastTabView.getRight();

// Log.d(“AAA”, “mLastP—>” + mLastP.left + “&” + mLastP.right);

// Log.d(“AAA”, “mCurrentP—>” + mCurrentP.left + “&” + mCurrentP.right);

if (mLastP.left == mCurrentP.left && mLastP.right == mCurrentP.right) {

invalidate();

} else {

mValueAnimator.setObjectValues(mLastP, mCurrentP);

if (mIndicatorBounceEnable) {

mValueAnimator.setInterpolator(mInterpolator);

}

if (mIndicatorAnimDuration < 0) {

mIndicatorAnimDuration = mIndicatorBounceEnable ? 500 : 250;

}

mValueAnimator.setDuration(mIndicatorAnimDuration);

mValueAnimator.start();

}

private void calcIndicatorRect() {

View currentTabView = mTabsContainer.getChildAt(this.mCurrentTab);

float left = currentTabView.getLeft();

float right = currentTabView.getRight();

mIndicatorRect.left = (int) left;

mIndicatorRect.right = (int) right;

if (mIndicatorWidth < 0) { //indicatorWidth小于0时,原jpardogo’s PagerSlidingTabStrip

} else {//indicatorWidth大于0时,圆角矩形以及三角形

float indicatorLeft = currentTabView.getLeft() + (currentTabView.getWidth() - mIndicatorWidth) / 2;

mIndicatorRect.left = (int) indicatorLeft;

mIndicatorRect.right = (int) (mIndicatorRect.left + mIndicatorWidth);

}

@Override

public void onAnimationUpdate(ValueAnimator animation) {

View currentTabView = mTabsContainer.getChildAt(this.mCurrentTab);

IndicatorPoint p = (IndicatorPoint) animation.getAnimatedValue();

mIndicatorRect.left = (int) p.left;

mIndicatorRect.right = (int) p.right;

if (mIndicatorWidth < 0) { //indicatorWidth小于0时,原jpardogo’s PagerSlidingTabStrip

} else {//indicatorWidth大于0时,圆角矩形以及三角形

float indicatorLeft = p.left + (currentTabView.getWidth() - mIndicatorWidth) / 2;

mIndicatorRect.left = (int) indicatorLeft;

mIndicatorRect.right = (int) (mIndicatorRect.left + mIndicatorWidth);

}

invalidate();

}

private boolean mIsFirstDraw = true;

@Override

protected void onDraw(Canvas canvas) {

super.onDraw(canvas);

if (isInEditMode() || mTabCount <= 0) {

return;

}

int height = getHeight();

int paddingLeft = getPaddingLeft();

// draw divider

if (mDividerWidth > 0) {

mDividerPaint.setStrokeWidth(mDividerWidth);

mDividerPaint.setColor(mDividerColor);

for (int i = 0; i < mTabCount - 1; i++) {

View tab = mTabsContainer.getChildAt(i);

canvas.drawLine(paddingLeft + tab.getRight(), mDividerPadding, paddingLeft + tab.getRight(), height - mDividerPadding, mDividerPaint);

}

// draw underline

if (mUnderlineHeight > 0) {

mRectPaint.setColor(mUnderlineColor);

if (mUnderlineGravity == Gravity.BOTTOM) {

canvas.drawRect(paddingLeft, height - mUnderlineHeight, mTabsContainer.getWidth() + paddingLeft, height, mRectPaint);

} else {

canvas.drawRect(paddingLeft, 0, mTabsContainer.getWidth() + paddingLeft, mUnderlineHeight, mRectPaint);

}

//draw indicator line

if (mIndicatorAnimEnable) {

if (mIsFirstDraw) {

mIsFirstDraw = false;

calcIndicatorRect();

}

} else {

calcIndicatorRect();

}

if (mIndicatorStyle == STYLE_TRIANGLE) {

if (mIndicatorHeight > 0) {

mTrianglePaint.setColor(mIndicatorColor);

mTrianglePath.reset();

mTrianglePath.moveTo(paddingLeft + mIndicatorRect.left, height);

mTrianglePath.lineTo(paddingLeft + mIndicatorRect.left / 2 + mIndicatorRect.right / 2, height - mIndicatorHeight);

mTrianglePath.lineTo(paddingLeft + mIndicatorRect.right, height);

mTrianglePath.close();

canvas.drawPath(mTrianglePath, mTrianglePaint);

}

} else if (mIndicatorStyle == STYLE_BLOCK) {

if (mIndicatorHeight < 0) {

mIndicatorHeight = height - mIndicatorMarginTop - mIndicatorMarginBottom;

} else {

}

if (mIndicatorHeight > 0) {

if (mIndicatorCornerRadius < 0 || mIndicatorCornerRadius > mIndicatorHeight / 2) {

mIndicatorCornerRadius = mIndicatorHeight / 2;

}

mIndicatorDrawable.setColor(mIndicatorColor);

mIndicatorDrawable.setBounds(paddingLeft + (int) mIndicatorMarginLeft + mIndicatorRect.left,

(int) mIndicatorMarginTop, (int) (paddingLeft + mIndicatorRect.right - mIndicatorMarginRight),

(int) (mIndicatorMarginTop + mIndicatorHeight));

mIndicatorDrawable.setCornerRadius(mIndicatorCornerRadius);

mIndicatorDrawable.draw(canvas);

}

} else {

/* mRectPaint.setColor(mIndicatorColor);

calcIndicatorRect();

canvas.drawRect(getPaddingLeft() + mIndicatorRect.left, getHeight() - mIndicatorHeight,

mIndicatorRect.right + getPaddingLeft(), getHeight(), mRectPaint);*/

if (mIndicatorHeight > 0) {

mIndicatorDrawable.setColor(mIndicatorColor);

if (mIndicatorGravity == Gravity.BOTTOM) {

mIndicatorDrawable.setBounds(paddingLeft + (int) mIndicatorMarginLeft + mIndicatorRect.left,

height - (int) mIndicatorHeight - (int) mIndicatorMarginBottom,

paddingLeft + mIndicatorRect.right - (int) mIndicatorMarginRight,

height - (int) mIndicatorMarginBottom);

} else {

mIndicatorDrawable.setBounds(paddingLeft + (int) mIndicatorMarginLeft + mIndicatorRect.left,

(int) mIndicatorMarginTop,

paddingLeft + mIndicatorRect.right - (int) mIndicatorMarginRight,

(int) mIndicatorHeight + (int) mIndicatorMarginTop);

}

mIndicatorDrawable.setCornerRadius(mIndicatorCornerRadius);

mIndicatorDrawable.draw(canvas);

}

//setter and getter

public void setCurrentTab(int currentTab) {

mLastTab = this.mCurrentTab;

this.mCurrentTab = currentTab;

updateTabSelection(currentTab);

if (mFragmentChangeManager != null) {

mFragmentChangeManager.setFragments(currentTab);

}

if (mIndicatorAnimEnable) {

calcOffset();

} else {

invalidate();

}

public void setIndicatorStyle(int indicatorStyle) {

this.mIndicatorStyle = indicatorStyle;

invalidate();

}

public void setTabPadding(float tabPadding) {

this.mTabPadding = dp2px(tabPadding);

updateTabStyles();

}

public void setTabSpaceEqual(boolean tabSpaceEqual) {

this.mTabSpaceEqual = tabSpaceEqual;

updateTabStyles();

}

public void setTabWidth(float tabWidth) {

this.mTabWidth = dp2px(tabWidth);

updateTabStyles();

}

public void setIndicatorColor(int indicatorColor) {

this.mIndicatorColor = indicatorColor;

invalidate();

}

public void setIndicatorHeight(float indicatorHeight) {

this.mIndicatorHeight = dp2px(indicatorHeight);

invalidate();

}

public void setIndicatorWidth(float indicatorWidth) {

this.mIndicatorWidth = dp2px(indicatorWidth);

invalidate();

}

public void setIndicatorCornerRadius(float indicatorCornerRadius) {

this.mIndicatorCornerRadius = dp2px(indicatorCornerRadius);

invalidate();

}

public void setIndicatorGravity(int indicatorGravity) {

this.mIndicatorGravity = indicatorGravity;

invalidate();

}

public void setIndicatorMargin(float indicatorMarginLeft, float indicatorMarginTop,

float indicatorMarginRight, float indicatorMarginBottom) {

this.mIndicatorMarginLeft = dp2px(indicatorMarginLeft);

this.mIndicatorMarginTop = dp2px(indicatorMarginTop);

this.mIndicatorMarginRight = dp2px(indicatorMarginRight);

this.mIndicatorMarginBottom = dp2px(indicatorMarginBottom);

invalidate();

}

public void setIndicatorAnimDuration(long indicatorAnimDuration) {

this.mIndicatorAnimDuration = indicatorAnimDuration;

}

public void setIndicatorAnimEnable(boolean indicatorAnimEnable) {

this.mIndicatorAnimEnable = indicatorAnimEnable;

}

public void setIndicatorBounceEnable(boolean indicatorBounceEnable) {

this.mIndicatorBounceEnable = indicatorBounceEnable;

}

public void setUnderlineColor(int underlineColor) {

this.mUnderlineColor = underlineColor;

invalidate();

}

public void setUnderlineHeight(float underlineHeight) {

this.mUnderlineHeight = dp2px(underlineHeight);

invalidate();

}

public void setUnderlineGravity(int underlineGravity) {

this.mUnderlineGravity = underlineGravity;

invalidate();

}

public void setDividerColor(int dividerColor) {

this.mDividerColor = dividerColor;

invalidate();

}

public void setDividerWidth(float dividerWidth) {

this.mDividerWidth = dp2px(dividerWidth);

invalidate();

}

public void setDividerPadding(float dividerPadding) {

this.mDividerPadding = dp2px(dividerPadding);

invalidate();

}

public void setTextsize(float textsize) {

this.mTextsize = sp2px(textsize);

updateTabStyles();

}

public void setTextSelectColor(int textSelectColor) {

this.mTextSelectColor = textSelectColor;

updateTabStyles();

}

public void setTextUnselectColor(int textUnselectColor) {

this.mTextUnselectColor = textUnselectColor;

updateTabStyles();

}

public void setTextBold(int textBold) {

this.mTextBold = textBold;

updateTabStyles();

}

public void setIconVisible(boolean iconVisible) {

this.mIconVisible = iconVisible;

updateTabStyles();

}

public void setIconGravity(int iconGravity) {

this.mIconGravity = iconGravity;

notifyDataSetChanged();

}

public void setIconWidth(float iconWidth) {

this.mIconWidth = dp2px(iconWidth);

updateTabStyles();

}

public void setIconHeight(float iconHeight) {

this.mIconHeight = dp2px(iconHeight);

updateTabStyles();

}

public void setIconMargin(float iconMargin) {

this.mIconMargin = dp2px(iconMargin);

updateTabStyles();

}

public void setTextAllCaps(boolean textAllCaps) {

this.mTextAllCaps = textAllCaps;

updateTabStyles();

}

public int getTabCount() {

return mTabCount;

}

public int getCurrentTab() {

return mCurrentTab;

}

public int getIndicatorStyle() {

return mIndicatorStyle;

}

public float getTabPadding() {

return mTabPadding;

}

public boolean isTabSpaceEqual() {

return mTabSpaceEqual;

}

public float getTabWidth() {

return mTabWidth;

}

public int getIndicatorColor() {

return mIndicatorColor;

}

public float getIndicatorHeight() {

return mIndicatorHeight;

}

public float getIndicatorWidth() {

return mIndicatorWidth;

}

public float getIndicatorCornerRadius() {

return mIndicatorCornerRadius;

}

public float getIndicatorMarginLeft() {

return mIndicatorMarginLeft;

}

public float getIndicatorMarginTop() {

return mIndicatorMarginTop;

}

public float getIndicatorMarginRight() {

return mIndicatorMarginRight;

}

public float getIndicatorMarginBottom() {

return mIndicatorMarginBottom;

}

public long getIndicatorAnimDuration() {

return mIndicatorAnimDuration;

}

public boolean isIndicatorAnimEnable() {

return mIndicatorAnimEnable;

}

public boolean isIndicatorBounceEnable() {

return mIndicatorBounceEnable;

}

public int getUnderlineColor() {

return mUnderlineColor;

}

public float getUnderlineHeight() {

return mUnderlineHeight;

}

public int getDividerColor() {

return mDividerColor;

}

public float getDividerWidth() {

return mDividerWidth;

}

public float getDividerPadding() {

return mDividerPadding;

}

public float getTextsize() {

return mTextsize;

}

public int getTextSelectColor() {

return mTextSelectColor;

}

public int getTextUnselectColor() {

return mTextUnselectColor;

}

public int getTextBold() {

return mTextBold;

}

public boolean isTextAllCaps() {

return mTextAllCaps;

}

public int getIconGravity() {

return mIconGravity;

}

public float getIconWidth() {

return mIconWidth;

}

public float getIconHeight() {

return mIconHeight;

}

public float getIconMargin() {

return mIconMargin;

}

public boolean isIconVisible() {

return mIconVisible;

}

public ImageView getIconView(int tab) {

View tabView = mTabsContainer.getChildAt(tab);

ImageView iv_tab_icon = (ImageView) tabView.findViewById(R.id.iv_tab_icon);

return iv_tab_icon;

}

public TextView getTitleView(int tab) {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

光有这些思路和搞懂单个知识的应用是还远远不够的，在Android开源框架设计思想中的知识点还是比较多的，想要搞懂还得学会整理和规划：我们常见的**Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架，**这些都是属于Android开源框架设计思想的。如下图所示：

这位阿里P8大佬针对以上知识点，熬夜整理出了一本长达1042页的完整版如何解读开源框架设计思想PDF文档，内容详细，把Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架这些知识点从源码分析到实战应用都讲的简单明了。

由于文档内容过多，篇幅受限，只能截图展示部分

整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~

你的支持，我的动力；祝各位前程似锦，offer不断！！！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

[外链图片转存中…(img-E7rE6R7u-1713141338591)]

[外链图片转存中…(img-uxnHjm9e-1713141338591)]

[外链图片转存中…(img-AZSMYVCF-1713141338592)]

[外链图片转存中…(img-LtWsQpBj-1713141338592)]

[外链图片转存中…(img-aWMF3fOY-1713141338592)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

[外链图片转存中…(img-QNbabiZg-1713141338593)]

由于文档内容过多，篇幅受限，只能截图展示部分

[外链图片转存中…(img-FybdClHs-1713141338593)]

[外链图片转存中…(img-sPENZBMY-1713141338593)]

整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~

你的支持，我的动力；祝各位前程似锦，offer不断！！！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

沁言学术 vs Grammarly：中文学术写作与语料库本地化支持的表现剖析

Grammarly是全球写作工具，语料库以英文为主，支持基本中文检查；沁言学术是本土AI平台，语料库深度本地化，针对中文学术设计。中文学术写作：Grammarly基础语法/拼写（本地化弱），沁言学术AI生成/优化（深度支持）。语料库本地化：Grammarly通用库（英文主导），沁言学术本土库（CNKI等集成）。整体：Grammarly免费版通用，付费版高级；沁言学术免费版入门，AI付费优化。表现亮