Android - 一种新奇的冷启动速度优化思路(Fragment极度懒加载 + Layout子线程预加载)

2401_85699862

于 2024-06-25 03:47:57 发布

阅读量900

点赞数 15

文章标签： android

本文链接：https://blog.csdn.net/2401_85699862/article/details/139943694

版权

public CharSequence getPageTitle(int position) {
return mPageTitleList.get(position);
}

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

@Override
public long getItemId(int position) {
//这个地方的重写非常关键，super中是返回position，
//如果不重写，还是会继续找到FragmentManager中缓存的Fragment
return mFragmentList.get(position).hashCode();
}

@Override
public int getItemPosition(@NonNull Object object) {
//不在数据集合里面的话，return POSITION_NONE，进行item的重建
int index = mFragmentList.indexOf(object);
if (index == -1) {
return POSITION_NONE;
} else {
return mFragmentList.indexOf(object);
}
}

void refreshFragments(ArrayList fragmentList) {
mFragmentList = fragmentList;
notifyDataSetChanged();
}
}

其他的相关代码：

（1）实现ViewPager.OnPageChangeListener，来监控ViewPager的滑动状态，才可以在滑动到下一个tab的时候进行Fragment替换的操作，其中mDefaultTab是我们通过接口返回的当前启动展示的tab序号

@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}

@Override
public void onPageSelected(int position) {
mCurrentSelectedTab = position;
}

@Override
public void onPageScrollStateChanged(int state) {
if (!hasReplacedAllEmptyFragments && mCurrentSelectedTab != mDefaultTab && state == 0) {
//当满足： 1. 没有全部替换完 2. 当前tab不是初始化的默认tab（默认tab不会用空的Fragment去替换） 3. 滑动结束了，即state = 0
replaceEmptyFragmentsIfNeed(mCurrentSelectedTab);
}
}

备注：

onPageScrollStateChanged接滑动的状态值。一共有三个取值：

0：什么都没做
1：开始滑动
2：滑动结束

一次引起页面切换的滑动，state的顺序分别是： 1 -> 2 -> 0

（2）进行Fragment的替换，这里因为我们的tab数量是可能根据全局config信息而改变的，所以这个地方写的稍微纠结了一些。

/**

如果全部替换完了，直接return
替换过程：
1. 找到当前空的tab在mEmptyFragmentList 中的实际下标
@param tabId 要替换的tab的tabId - （当前空的Fragment在adapter数据列表mFragmentList的下标）
*/
private void replaceEmptyFragmentsIfNeed(int tabId) {
if (hasReplacedAllEmptyFragments) {
return;
}
int tabRealIndex = mEmptyFragmentList.indexOf(mFragmentList.get(tabId)); //找到当前的空Fragment在 mEmptyFragmentList 是第几个
if (tabRealIndex > -1) {
if (Collections.replaceAll(mFragmentList, mEmptyFragmentList.get(tabRealIndex), mDataFragmentList.get(tabRealIndex))) {
mTabsAdapter.refreshFragments(mFragmentList); //将mFragmentList中的相应empty fragment替换完成之后刷新数据
boolean hasAllReplaced = true;
for (Fragment fragment : mFragmentList) {
if (fragment instanceof EmptyPlaceHolderFragment) {
hasAllReplaced = false;
break;
}
}
if (hasAllReplaced) {
mEmptyFragmentList.clear(); //全部替换完成的话，释放引用
}
hasReplacedAllEmptyFragments = hasAllReplaced;
}
}
}

六、神奇的的预加载（预加载View，而不是data）

Android在启动过程中可能涉及到的一些View的预加载方案：

WebView提前创建好，因为webview创建的耗时较长，如果首屏有h5的页面，可以提前创建好。
Application的onCreate时，就可以开始在子线程中进行后面要用到的Layout的inflate工作了，最先想到的应该是官方提供的AsyncLayoutInflater
填充View的数据的预加载，今天的内容不涉及这一项

6.1 需要预加载什么

直接看图，这个是首页四个子Tab Fragment的基类的layout，因为某些东西设计的不合理，导致层级是非常的深，直接导致了首页上的三个tab加上FeedMainFragment自身，光将这个View inflate出来的时间就非常长。因此我们考虑在子线程中提前inflate layout

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

6.2 修改AsyncLayoutInflater

官方提供了一个类，可以来进行异步的inflate，但是有两个缺点：

每次都要现场new一个出来
异步加载的view只能通过callback回调才能获得（死穴）

因此决定自己封装一个AsyncInflateManager，内部使用线程池，且对于inflate完成的View有一套缓存机制。而其中最核心的LayoutInflater则直接copy出来就好。

先看AsyncInflateManager的实现，这里我直接将代码copy进来，而不是截图了，这样你们如果想用其中部分东西，可以直接copy：

/**

@author zoutao
用来提供子线程inflate view的功能，避免某个view层级太深太复杂，主线程inflate会耗时很长，
实就是对 AsyncLayoutInflater进行了抽取和封装
*/
public class AsyncInflateManager {
private static AsyncInflateManager sInstance;
private ConcurrentHashMap<String, AsyncInflateItem> mInflateMap; //保存inflateKey以及InflateItem，里面包含所有要进行inflate的任务
private ConcurrentHashMap<String, CountDownLatch> mInflateLatchMap;
private ExecutorService mThreadPool; //用来进行inflate工作的线程池

private AsyncInflateManager() {
mThreadPool = new ThreadPoolExecutor(4, 4, 0, TimeUnit.MILLISECONDS, new LinkedBlockingDeque());
mInflateMap = new ConcurrentHashMap<>();
mInflateLatchMap = new ConcurrentHashMap<>();
}

public static AsyncInflateManager getInstance() {
单例
}

/**

用来获得异步inflate出来的view
@param context
@param layoutResId 需要拿的layoutId
@param parent container
@param inflateKey 每一个View会对应一个inflateKey，因为可能许多地方用的同一个 layout，但是需要inflate多个，用InflateKey进行区分
@param inflater 外部传进来的inflater，外面如果有inflater，传进来，用来进行可能的SyncInflate，
@return 最后inflate出来的view
*/
@UiThread
@NonNull
public View getInflatedView(Context context, int layoutResId, @Nullable ViewGroup parent, String inflateKey, @NonNull LayoutInflater inflater) {
if (!TextUtils.isEmpty(inflateKey) && mInflateMap.containsKey(inflateKey)) {
AsyncInflateItem item = mInflateMap.get(inflateKey);
CountDownLatch latch = mInflateLatchMap.get(inflateKey);
if (item != null) {
View resultView = item.inflatedView;
if (resultView != null) {
//拿到了view直接返回
removeInflateKey(inflateKey);
replaceContextForView(resultView, context);
return resultView;
}

if (item.isInflating() && latch != null) {
//没拿到view，但是在inflate中，等待返回
try {
latch.wait();
} catch (InterruptedException e) {
Log.e(TAG, e.getMessage(), e);
}
removeInflateKey(inflateKey);
if (resultView != null) {
replaceContextForView(resultView, context);
return resultView;
}

}
//如果还没开始inflate，则设置为false，UI线程进行inflate
item.setCancelled(true);
}
}
//拿异步inflate的View失败，UI线程inflate
return inflater.inflate(layoutResId, parent, false);
}

/**

inflater初始化时是传进来的application，inflate出来的view的context没法用来startActivity，
因此用MutableContextWrapper进行包装，后续进行替换
*/
private void replaceContextForView(View inflatedView, Context context) {
if (inflatedView == null || context == null) {
return;
}
Context cxt = inflatedView.getContext();
if (cxt instanceof MutableContextWrapper) {
((MutableContextWrapper) cxt).setBaseContext(context);
}
}

@UiThread
private void asyncInflate(Context context, AsyncInflateItem item) {
if (item == null || item.layoutResId == 0 || mInflateMap.containsKey(item.inflateKey) || item.isCancelled() || item.isInflating()) {
return;
}
onAsyncInflateReady(item);
inflateWithThreadPool(context, item);
}

private void onAsyncInflateReady(AsyncInflateItem item) {
…
}

private void onAsyncInflateStart(AsyncInflateItem item) {
…
}

private void onAsyncInflateEnd(AsyncInflateItem item, boolean success) {
item.setInflating(false);
CountDownLatch latch = mInflateLatchMap.get(item.inflateKey);
if (latch != null) {
//释放锁
latch.countDown();
}
…
}

private void removeInflateKey(String inflateKey) {
…
}

private void inflateWithThreadPool(Context context, AsyncInflateItem item) {
mThreadPool.execute(new Runnable() {
@Override
public void run() {
if (!item.isInflating() && !item.isCancelled()) {
try {
onAsyncInflateStart(item);
item.inflatedView = new BasicInflater(context).inflate(item.layoutResId, item.parent, false);
onAsyncInflateEnd(item, true);
} catch (RuntimeException e) {
Log.e(TAG, “Failed to inflate resource in the background! Retrying on the UI thread”, e);
onAsyncInflateEnd(item, false);
}
}
}
});
}

/**

copy from AsyncLayoutInflater - actual inflater
*/
private static class BasicInflater extends LayoutInflater {
private static final String[] sClassPrefixList = new String[]{“android.widget.”, “android.webkit.”, “android.app.”};

BasicInflater(Context context) {
super(context);
}

public LayoutInflater cloneInContext(Context newContext) {
return new BasicInflater(newContext);
}

protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
for (String prefix : sClassPrefixList) {
try {
View view = this.createView(name, prefix, attrs);
if (view != null) {
return view;
}
} catch (ClassNotFoundException ignored) {
}
}
return super.onCreateView(name, attrs);
}
}
}

这里我用一个AsyncInflateItem来管理一次要inflate的一个单位，

/**

@author zoutao
*/
public class AsyncInflateItem {
String inflateKey;
int layoutResId;
ViewGroup parent;
OnInflateFinishedCallback callback;
View inflatedView;

private boolean cancelled;
private boolean inflating;

//还有一些set get方法
}

以及最后inflate的回调callback：

public interface OnInflateFinishedCallback {
void onInflateFinished(AsyncInflateItem result);
}

经过这样的封装，外面可以直接在Application的onCreate中，开始异步的inflate view的任务。调用如下：

AsyncInflateUtil.startTask();

/**

@author zoutao
*/
public class AsyncInflateUtil {
public static void startTask() {
Context context = new MutableContextWrapper(CommonContext.getApplication());
AsyncInflateManager.getInstance().asyncInflateViews(context,
new AsyncInflateItem(InflateKey.TAB_1_CONTAINER_FRAGMENT, R.layout.fragment_main),
new AsyncInflateItem(InflateKey.SUB_TAB_1_FRAGMENT, R.layout.fragment_load_list),
new AsyncInflateItem(InflateKey.SUB_TAB_2_FRAGMENT, R.layout.fragment_load_list),
new AsyncInflateItem(InflateKey.SUB_TAB_3_FRAGMENT, R.layout.fragment_load_list),
new AsyncInflateItem(InflateKey.SUB_TAB_4_FRAGMENT, R.layout.fragment_load_list));

}

public class InflateKey {
public static final String TAB_1_CONTAINER_FRAGMENT = “tab1”;
public static final String SUB_TAB_1_FRAGMENT = “sub1”;
public static final String SUB_TAB_2_FRAGMENT = “sub2”;
public static final String SUB_TAB_3_FRAGMENT = “sub3”;
public static final String SUB_TAB_4_FRAGMENT = “sub4”;

要如何成为Android架构师？

搭建自己的知识框架，全面提升自己的技术体系，并且往底层源码方向深入钻研。
大多数技术人喜欢用思维脑图来构建自己的知识体系，一目了然。这里给大家分享一份大厂主流的Android架构师技术体系，可以用来搭建自己的知识框架，或者查漏补缺；

对应这份技术大纲，我也整理了一套Android高级架构师完整系列的视频教程，主要针对3-5年Android开发经验以上，需要往高级架构师层次学习提升的同学，希望能帮你突破瓶颈，跳槽进大厂；

最后我必须强调几点：

1.搭建知识框架可不是说你整理好要学习的知识顺序，然后看一遍理解了能复制粘贴就够了，大多都是需要你自己读懂源码和原理，能自己手写出来的。
2.学习的时候你一定要多看多练几遍，把知识才吃透，还要记笔记，这些很重要！最后你达到什么水平取决你消化了多少知识
3.最终你的知识框架应该是一个完善的，兼顾广度和深度的技术体系。然后经过多次项目实战积累经验，你才能达到高级架构师的层次。

你只需要按照在这个大的框架去填充自己，年薪40W一定不是终点，技术无止境

-1719258465233)]

对应这份技术大纲，我也整理了一套Android高级架构师完整系列的视频教程，主要针对3-5年Android开发经验以上，需要往高级架构师层次学习提升的同学，希望能帮你突破瓶颈，跳槽进大厂；

最后我必须强调几点：

你只需要按照在这个大的框架去填充自己，年薪40W一定不是终点，技术无止境

2401_85699862

关注

15
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
Android - 一种新奇的冷启动速度优化思路(Fragment极度懒加载 + Layout子线程预加载)

1.搭建知识框架可不是说你整理好要学习的知识顺序，然后看一遍理解了能复制粘贴就够了，大多都是需要你自己读懂源码和原理，能自己手写出来的。2.学习的时候你一定要多看多练几遍，把知识才吃透，还要记笔记，这些很重要！最后你达到什么水平取决你消化了多少知识3.最终你的知识框架应该是一个完善的，兼顾广度和深度的技术体系。然后经过多次项目实战积累经验，你才能达到高级架构师的层次。你只需要按照在这个大的框架去填充自己，年薪40W一定不是终点，技术无止境。
复制链接

扫一扫