Android Fragment 要你何用?

Android Fragment 要你何用?,第1张

Android Fragment 要你何用? 前言

系列文章:

Android Activity 与View 的互动思考
Android Activity 生命周期详解及监听
Android onSaveInstanceState/onRestoreInstanceState 原来要这么理解
Android Fragment 要你何用?

关于Fragment 的分析网上已经有许多优秀文章流传,有些人觉得它的生命周期比较复杂,不好控制,实属鸡肋。有些人认为它封装得比较好,属于"轻量级的Activity",值得在工程里引入。
通过本篇文章,你将了解到:

1、为什么需要Fragment
2、添加Fragment的方式
3、Activity 与Fragment 生命周期的联动
4、常见的控制Fragment 方法

1、为什么需要Fragment Fragment 定义

Fragment 翻译为中文:碎片、片段。
最早在Android 3.0时引入的,为了应用能够适配大屏幕的设备而提供的一种灵活的UI 组件。

Fragment 与View、Activity 关系 和View 对比


如上图,App 需要适配手机与平板。
因为有公用的界面,因此尽可能地想复用公用部分,这个时候我们想到了View。将View 抽取出来作为一个公共UI组件,分别放在手机和平板对应的布局文件里。若是View里包含了比较多的逻辑,以后就不好复用这个组件了。并且View 本身并没有生命周期,想要跟随Activity的生命周期,只能靠Activity 传递过来或是主动监听Activity 生命周期变化,比较麻烦。
刚好,Fragment 能够满足此种需求。
和View 相比,Fragment 有如下特点:

1、拥有生命周期。
2、将View(UI)与逻辑 封装在Fragment里。
3、其它Activity 可以复用Fragment(UI + 逻辑)。

和Activity 对比

我们常说Activity “重”,View “轻”,这很容易理解,试想一下:启动一个Activity 远比展示一个View 慢很多。
为什么呢?
因为Activity 是受到AMS 管控的,Activity 的生命周期都是由AMS 跨进程通知到App进程,这显然耗费了不少时间。再加上Activity 启动时初始化了许多东西,比如Window、DecorView等,因此从启动Activity 到完全展示它需要一定的时间。
而View 则不同,仅仅只需要new 一个对象,并设置一些属性,最后添加到上层的ViewGroup里进行展示即可,都是在本进程内 *** 作,速度很快。
和View 类似,当向Activity 里添加Fragment 时,实际上主要做了两件事:

1、加入到Fragment栈里,方便管理。
2、将Fragment 所持有的View 添加到ViewTree 某个节点里。

可以看出,以上两步没有涉及进程间通信,也没有初始化许多的组件,因此启动一个Fragment 比启动一个Activity 快得多。

三者关系

用图说明三者的联系:

上图仅仅表示类比关系,Fragment并不是Activity 子类也不是View/ViewGroup 父类或子类。

2、添加Fragment的方式 静态添加方式

了解了Fragment特点,看看如何使用它。与View 类似,View 可以放在xml里作为静态加载,也可以通过代码动态加载。
先说静态加载。
编写静态布局文件:activity_static_fragment.xml




    
    


其中android:name 指定Fragment的全限定类名称。
MyFragment 是自定义的Fragment。
然后在Activity onCreate里加载此布局文件:

setContentView(R.layout.activity_static_fragment);

可以看出,静态添加fragment 与静态添加View 很相似,接着分析其添加的原理。

静态添加原理

1、整体流程
上节有提到过,Fragment 会将布局文件管理起来并添加到ViewTree里。在声明自定义Fragment时需要重写onCreateView(xx)方法:

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {
        TextView textView = new TextView(getContext());
        if (TextUtils.isEmpty(desc))
            desc = "静态fragment";
        textView.setText(desc);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        return textView;
    }

该方法可以理解为Fragment指定其承载的布局,此处构造一个TextView 对象,并返回。

串起来静态加载的流程为:

1、Activity 通过LayoutInflater 加载布局文件。
2、LayoutInflater 寻找"fragment"标签。
3、找到"fragment"标签,根据"android:name"指定的Fragment类的全限定名称反射实例化Fragment。
4、拿到Fragment实例后,调用onCreateView(xx),将返回的View对象与Fragment进行关联。
5、View 对象被添加到"fragment"标签的父布局里。在该例里是MyframeLayout。
6、至此,Fragment关联的View 已经被添加到ViewTree里。

注:Fragment并不是Activity/View 的子类,

2、View 添加到ViewTree
核心代码:

#FragmentManagerImpl.java
    void ensureInflatedFragmentView(Fragment f) {
        if (f.mFromLayout && !f.mPerformedCreateView) {
            //最终执行到Fragment.onCreateView()
            //返回的View 对象赋值给f.mView
            f.performCreateView(f.performGetLayoutInflater(
                    f.mSavedFragmentState), null, f.mSavedFragmentState);
            if (f.mView != null) {
                ...
                //调用onViewCreated(xx)
                f.onViewCreated(f.mView, f.mSavedFragmentState);
            } else {
                f.mInnerView = null;
            }
        }
    }

Fragment 将关联的View 存储在f.mView里,LayoutInflater 加载时将f.mView add 到上层的ViewGroup里,最终f.mView 挂接到ViewTree里。

动态添加方式
    private void addFragment(Fragment fragment) {
//        list.add(fragment);
        //获取Fragment管理对象
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();   // 开启一个事务
        //添加fragment
        transaction.add(R.id.container, fragment);
        //提交动作
        transaction.commit();
    }

封装一个addFragment(xx)方法,传入构造好的Fragment。
然后在Activity的onCreate(xx)里调用此方法

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fragment);
        //直接new 出来
        addFragment(new MyFragment("fragment1"));
    }
动态添加原理

1、获取Fragment 控制器
先看getSupportFragmentManager():

#FragmentActivity.java
    public FragmentManager getSupportFragmentManager() {
        return mFragments.getSupportFragmentManager();
    }

而mFragments 是FragmentActivity.java 的成员变量:

#FragmentActivity.java
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

最终返回的是FragmentManagerImpl 实例。
从这里可以看出,每个直接或间接地继承自FragmentActivity.java 的类都会拥有FragmentController 成员变量,从该变量里获取FragmentManagerImpl 实例就可以控制Fragment的一切活动。

2、Fragment 关联 View
接着看:

transaction.add(R.id.container, fragment);

第一个参数表示要将Fragment挂接到的ViewGroup,第二个参数表示待挂接的Fragment 对象。
而当Fragment.onCreateView(xx)被调用时,返回的View 将会被add到ViewGroup里,也就是R.id.container代表的ViewGroup。
而R.id.container 是Activity 布局文件里某个布局的id。
至此:

Fragment 所关联的View 被添加到ViewTree里。

3、View 添加到ViewTree
核心代码:

#FragmentManagerImpl.java
    void moveToState(Fragment f, int newState, int transit, int transitionStyle,
                     boolean keepActive) {
        ...
        //最终执行Fragment.onCreateView(xx)
        //返回的View 赋值给f.mView,f表示Fragment 对象
        f.performCreateView(f.performGetLayoutInflater(
                f.mSavedFragmentState), container, f.mSavedFragmentState);
        if (f.mView != null) {
            f.mInnerView = f.mView;
            f.mView.setSaveFromParentEnabled(false);
            //container 是ViewGroup
            //transaction.replace(R.id.container, fragment) 方法里的 R.id.container 实例化得来的
            if (container != null) {
                //将Fragment.onCreateView(xx)得到的View 添加到container里,也就是添加到了ViewTree里。
                container.addView(f.mView);
            }
            ...
        } else {
            f.mInnerView = null;
        }
        ...
    }

需要注意的是,在onCreateView(xx)里咱们是动态生成了View,若是通过LayoutInflater加载布局文件:

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        //最后参数为false
        View view = inflater.inflate(R.layout.fragment_layout, container,false);
        return view;
    }

那么最后一个参数必须为false,意思是不将生成的View add到container里,因为在FragmentManagerImpl.moveToState(xx)里也会执行container.addView(view),若是最后参数为true,那么就会报重复添加的错误。

3、Activity 与Fragment 生命周期的联动

通过对静态添加与动态添加的分析,我们已经弄清楚了Fragment 关联的View 如何添加到ViewTree里。接着再来分析静态添加与动态添加时Fragment 生命周期的流转。

Fragment 的生命周期的由来

Fragment 依赖于Activity,因此我们想当然地认为它的生命周期依赖于Activity,事实究竟如何呢?为寻求真相,从源码入手。
以Activity.onResume()为例,探究与Fragment.onResume()关系。
当调用Activity.performResume(xx)时,有如下源码:

    #Activity.java
    final void performResume(boolean followedByPause, String reason) {
        ...
        onPostResume();
        ...
    }

    #FragmentActivity.java
    protected void onPostResume() {
        super.onPostResume();
        onResumeFragments();
    }

    #FragmentActivity.java
    protected void onResumeFragments() {
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        //mFragments 最终控制着Fragment 生命周期
        mFragments.dispatchResume();
    }

可以看出,因为自定义的Activity 直接/间接地继承自FragmentActivity,而FragmentActivity 重写了很多Activity 方法,因此每当调用Activity.xx()方法时都会调用到FragmentActivity重写的对应方法,而重写的方法里会通过mFragments(FragmentController 控制器)最终控制Fragment各个生命周期回调方法。
总而言之:

1、Fragment 生命周期依赖于Activity 生命周期。
2、Activity 生命周期变更回调的方法onCreate/onStart/onResume/onPause/onStop/onDestroy,Fragment都有,Fragment 比Activity 还多一些回调方法,比如onAttach/onCreateView 等。

静态添加Fragment 生命周期

以图示之:

由图可知:

Activity 生命周期变动就会调用Fragment对应方法,因此Fragment 也间接拥有了生命周期。

明显地可以看出,Fragment 生命周期涉及到的方法比Activity 更多。
简单解释涉及的各个方法的用处:

1、onAttach

Fragment 第一次绑定Context。
当使用Fragment.getContext()/Fragment.getActivity()返回的是绑定的FragmentActivity。

2、onCreate

类似Activity onCreate。

3、onCreateView

关联Fragment 与UI,Fragment的展示效果即是通过该UI表现的。

4、onViewCreated

执行到这一步,说明第三步创建的View 已经被添加到ViewTree里。

5、onActivityCreated

表示Activity 与Fragment 完全绑定了。

onDestroyView、onDetach 等是反向 *** 作,不再细说。

动态添加Fragment 生命周期

理论上来说不管静态添加还是动态添加,生命周期都是一样的,为什么要区分呢?
我们之前说的动态添加方式,有个方法重点关注:

transaction.commit();

该方法有个孪生兄弟方法:

transaction.commitNow()

顾名思义,transaction.commitNow() 表示立即添加,生命周期与静态添加一致。
而transaction.commit() 是加入到队列里,延迟执行,此时生命周期如下:

因为延迟执行,并没有在Activity.onCreate(xx)时进行Fragment.onAttach()等一些列 *** 作,而是在Activity.onStart()之后。
除了这点区别,其它都一样。

4、常见的控制Fragment 方法

主要是依赖FragmentTransaction 来控制Fragment。
1、FragmentTransaction.hide(xx)

隐藏Fragment,本质上是将Fragment关联的View进行隐藏:View.setVisibility(GONE)
不会回调Fragment 生命周期中的方法。

2、FragmentTransaction.show(xx)

显示Fragment,本质上是将Fragment关联的View进行展示:View.setVisibility(VISIBLE)
不会回调Fragment 生命周期中的方法。

3、FragmentTransaction.detach(xx)

将Fragment 从Activity 中移除,实际上是将Fragment 关联的View 从ViewTree中移除。Fragment还在栈里。

生命周期变化如下:

4、FragmentTransaction.remove(xx)

除了将Fragment 从Activity 中移除,还将Fragment从回退栈里移除。

生命周期变化如下:

5、FragmentTransaction.replace(xx)

效果同 remove + add。

当前展示fragment1,通过FragmentTransaction.replace(fragment2),
生命周期变动如下:

6、 数据传递
Activity 向Fragment传递数据,实际上就是传递Bundle。
Fragment.setArguments(Bundle)。
在Fragment里通过:
Fragment.getArguments()获取。
当然,引入Jetpack可通过ViewModel共享数据。

最后附上Demo 效果图

Fragment 添加/删除/替换/隐藏 测试代码

本文基于Android 10.0

您若喜欢,请点赞、关注,您的鼓励是我前进的动力 持续更新中,和我一起步步为营系统、深入学习Android

1、Android各种Context的前世今生
2、Android DecorView 必知必会
3、Window/WindowManager 不可不知之事
4、View Measure/Layout/Draw 真明白了
5、Android事件分发全套服务
6、Android invalidate/postInvalidate/requestLayout 彻底厘清
7、Android Window 如何确定大小/onMeasure()多次执行原因
8、Android事件驱动Handler-Message-Looper解析
9、Android 键盘一招搞定
10、Android 各种坐标彻底明了
11、Android Activity/Window/View 的background
12、Android Activity创建到View的显示过
13、Android IPC 系列
14、Android 存储系列
15、Java 并发系列不再疑惑
16、Java 线程池系列
17、Android Jetpack 实践与原理系列

欢迎分享,转载请注明来源:内存溢出

原文地址: https://outofmemory.cn/zaji/5686315.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-12-17
下一篇 2022-12-17

发表评论

登录后才能评论

评论列表(0条)

保存