阅读 994

Fragment原理分析

基于AndroidX源码分析

Activity与Fragment 之间的关系

  • Fragment是Activity界面的一部分，Fragment是依附于Activity之上的；
  • Activity是Fragment的基础，Fragment是Activity的延续和发展
  • 一个Activity可以有多个Fragment，一个Fragment也可以被多个Activity重复使用；
  • 一个Fragment除了Activity处于onResume状态下，他可以自己灵活的控制自己的生命周期，其他状态下，其生命周期都是由Activity所决定的；
  • Fragment的出现增强了UI界面布局的灵活性，可以实现动态的改变UI布局；

Fragment生命周期

Activity fragment_lifecycle

这是一张google官方提供的一张Fragment生命周期的图片，Fragment的生命周期又依赖与Activity

我们通过上面图开始进入我们的源码的分析

一、FragmentController 创建

在FragmentActivity中有个变量mFragments，在一开始就初始化完成

final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
复制代码

整个类图结构图如上所示，里面的细节会在后续流程会讲到。

二、生命周期分发

我们Fragment的生命周期会跟随Activity的生命周期进行变化，所以我们看几个生命周期的调用。

protected void onCreate(@Nullable Bundle savedInstanceState) {
  	//调用attach
    mFragments.attachHost(null /*parent*/);

    if (savedInstanceState != null) {
        //... 数据保存相关
    }
		
  	//...
    super.onCreate(savedInstanceState);
  	//分发create
    mFragments.dispatchCreate();
}

protected void onPostResume() {
    super.onPostResume();
  	//分发Resume，会在onResume之前执行
    mFragments.dispatchResume();
}

protected void onPause() {
    super.onPause();
    mResumed = false;
  	//分发Pause
    mFragments.dispatchPause();
}
复制代码

上面的代码可以看到随着Activity生命周期的变化会调用FragmentManagerImpl.dispatchXXX()通知。跟踪代码我们会发现FragmentManagerImpl.dispatchXXX()最终都会调用FragmentManagerImpl.dispatchStateChange(int nextState)

Fragment状态

Fragment有多个状态值来标示当前自己生命周期所处的状态

static final int INITIALIZING = 0;     // Not yet created.
static final int CREATED = 1;          // Created.
static final int ACTIVITY_CREATED = 2; // Fully created, not started.
static final int STARTED = 3;          // Created and started, not resumed.
static final int RESUMED = 4;          // Created started and resumed.
//Fragment 默认的状态是 INITIALIZING，也是代表当前的生命周期状态
int mState = INITIALIZING;
复制代码

FragmentManagerImpl.dispatchStateChange

//nextState 顾名思义，就是想要Fragment进入的下一个状态
private void dispatchStateChange(int nextState) {
    try {
      	//这个标志位是为了防止
        mExecutingActions = true;
      	//1.变化到下一个状态
        moveToState(nextState, false);
    } finally {
        mExecutingActions = false;
    }
  	//执行未执行的操作事务管理会讲到
    execPendingActions();
}
复制代码

三、生命周期变化 moveToState

第1步

void moveToState(int newState, boolean always) {
    if (mHost == null && newState != Fragment.INITIALIZING) {
        throw new IllegalStateException("No activity");
    }
		//如果状态相同，返回
    if (!always && newState == mCurState) {
        return;
    }
		
    mCurState = newState;

    // Must add them in the proper order. mActive fragments may be out of order
    final int numAdded = mAdded.size();
    for (int i = 0; i < numAdded; i++) {
        Fragment f = mAdded.get(i);
      	//【1-1】所有的Fragment都会调用这个方法，但不会真的更新状态看【2-1】
        moveFragmentToExpectedState(f);
    }

    // Now iterate through all active fragments. These will include those that are removed
    // and detached.
  	//一些特殊的情况，比如被回收了 remove 和 detached 不会再mAdded列表里面
    for (Fragment f : mActive.values()) {
        if (f != null && (f.mRemoving || f.mDetached) && !f.mIsNewlyAdded) {
          	//【1-2】被回收的再执行生命周期变化
            moveFragmentToExpectedState(f);
        }
    }
		//比如有些Fragment 需要等到其他Fragment执行完毕之后在执行自己的生命周期变化，比如说用户不可见的，需要让用户可见的先执行生命周期，再轮到自己。这也是google优化的思路，那么什么时候延迟 todo
  	//【1-3】开始执行延迟的Fragment 生命周期变化【3-1】
    startPendingDeferredFragments();
		//。。。
}
复制代码

【1-3】 startPendingDeferredFragments => performPendingDeferredStart

public void performPendingDeferredStart(Fragment f) {
    if (f.mDeferStart) {
        if (mExecutingActions) {
            mHavePendingDeferredStart = true;
            return;
        }
      	//把延迟加载标记清空
        f.mDeferStart = false;
      	//接着走后面的生命周期 到第三步
        moveToState(f, mCurState, 0, 0, false);
    }
}
复制代码

第2步

void moveFragmentToExpectedState(Fragment f) {
    if (f == null) {
        return;
    }
  	//【2-1】.mActive存在key 才能继续执行
    if (!mActive.containsKey(f.mWho)) {
        return;
    }
    int nextState = mCurState;
    if (f.mRemoving) {
      	//如果被移出 控制他的生命周期nextState不能超过预期
        if (f.isInBackStack()) {
            nextState = Math.min(nextState, Fragment.CREATED);
        } else {
            nextState = Math.min(nextState, Fragment.INITIALIZING);
        }
    }
  	//【2-2】进入真正的状态
    moveToState(f, nextState, f.getNextTransition(), f.getNextTransitionStyle(), false);
		//...
}
复制代码

第3步

void moveToState(Fragment f, int newState, int transit, int transitionStyle,
                 boolean keepActive) {
 		//未添加或detached了先走oncreate
    if ((!f.mAdded || f.mDetached) && newState > Fragment.CREATED) {
        newState = Fragment.CREATED;
    }
  	//在此控制newState 如果被移出 控制他的生命周期nextState不能超过预期
    if (f.mRemoving && newState > f.mState) {
        if (f.mState == Fragment.INITIALIZING && f.isInBackStack()) {
            // Allow the fragment to be created so that it can be saved later.
            newState = Fragment.CREATED;
        } else {
            // While removing a fragment, we can't change it to a higher state.
            newState = f.mState;
        }
    }
  	//延迟加载则将newState 直接赋值为 Fragment.ACTIVITY_CREATED ， 他将不会执行 CREATED 和 INITIALIZING，而直接跳过本次的生命周期
    if (f.mDeferStart && f.mState < Fragment.STARTED && newState > Fragment.ACTIVITY_CREATED) {
        newState = Fragment.ACTIVITY_CREATED;
    }
  	//控制Fragment 最大生命周期执行到哪一步，在ViewPager2 用的比较多
    if (f.mMaxState == Lifecycle.State.CREATED) {
        newState = Math.min(newState, Fragment.CREATED);
    } else {
        newState = Math.min(newState, f.mMaxState.ordinal());
    }
    if (f.mState <= newState) {
				//...
      	//switch 当前状态
        switch (f.mState) {
            case Fragment.INITIALIZING:
                if (newState > Fragment.INITIALIZING) {//执行这里面说明要走到CREATE生命周期状态
                    if (f.mSavedFragmentState != null) {
                        //...状态恢复
                      	//【3-1】如果Fragment用户不可见不让他走到START，等所有执行完再走【1-3】
                        if (!f.mUserVisibleHint) {
                            f.mDeferStart = true;
                            if (newState > Fragment.ACTIVITY_CREATED) {
                                newState = Fragment.ACTIVITY_CREATED;
                            }
                        }
                    }

                    f.mHost = mHost;
                    f.mParentFragment = mParent;
                    f.mFragmentManager = mParent != null
                            ? mParent.mChildFragmentManager : mHost.mFragmentManager;

                    //优先执行Childfragment依赖的ParentFragment
                    if (f.mTarget != null) {
                        if (f.mTarget.mState < Fragment.CREATED) {
                            moveToState(f.mTarget, Fragment.CREATED, 0, 0, true);
                        }
                        f.mTargetWho = f.mTarget.mWho;
                        f.mTarget = null;
                    }
                    if (f.mTargetWho != null) {
                        Fragment target = mActive.get(f.mTargetWho);
                        if (target.mState < Fragment.CREATED) {
                            moveToState(target, Fragment.CREATED, 0, 0, true);
                        }
                    }
										
                  	//生命周期的回调和分发
                    dispatchOnFragmentPreAttached(f, mHost.getContext(), false);
                  	//fragment attach
                    f.performAttach();
                    if (f.mParentFragment == null) {
                        mHost.onAttachFragment(f);
                    } else {
                        f.mParentFragment.onAttachFragment(f);
                    }
                    dispatchOnFragmentAttached(f, mHost.getContext(), false);
										//f.mState 标记为 CREATED
                    if (!f.mIsCreated) {
                        dispatchOnFragmentPreCreated(f, f.mSavedFragmentState, false);
                        f.performCreate(f.mSavedFragmentState);
                        dispatchOnFragmentCreated(f, f.mSavedFragmentState, false);
                    } else {
                        f.restoreChildFragmentState(f.mSavedFragmentState);
                        f.mState = Fragment.CREATED;
                    }
                }
            case Fragment.CREATED:
                if (newState > Fragment.INITIALIZING) {
                  	//创建FragmentView
                    ensureInflatedFragmentView(f);
                }

                if (newState > Fragment.CREATED) {//执行这里面说明要走到ACTIVITY_CREATE生命周期状态
                    if (!f.mFromLayout) {
                       //...把Fragment的 View 添加到 Activity View容器
                    }
										//f.mState 标记为 ACTIVITY_CREATED
                    f.performActivityCreated(f.mSavedFragmentState);
                    dispatchOnFragmentActivityCreated(f, f.mSavedFragmentState, false);
                    if (f.mView != null) {
                        f.restoreViewState(f.mSavedFragmentState);
                    }
                    f.mSavedFragmentState = null;
                }
            case Fragment.ACTIVITY_CREATED:
                if (newState > Fragment.ACTIVITY_CREATED) {//执行这里面说明要走到START生命周期状态
                    f.performStart();
                    dispatchOnFragmentStarted(f, false);
                }
            case Fragment.STARTED:
                if (newState > Fragment.STARTED) {//执行这里面说明要走到RESUME生命周期状态
                  	//执行Fragment Resume
                    f.performResume();
                  	//分发生命周期监听的回调
                    dispatchOnFragmentResumed(f, false);
                    f.mSavedFragmentState = null;
                    f.mSavedViewState = null;
                }
        }
    } else if (f.mState > newState) {
        // 省略反向从 RESUME =》 INITIALIZING 大家可以自己分析，比正向的简单
    }
		//设置fragment 当前state
    if (f.mState != newState) {
        f.mState = newState;
    }
}
复制代码

事务管理

将一个Fragment添加到Activity布局有两种方式。

  • 通过fragment标签加入（静态加入）
  • 通过代码动态的加入（动态加入）

而这里要讲的就是第二种方式。

事务的action

static final int OP_NULL = 0;
static final int OP_ADD = 1;
static final int OP_REPLACE = 2;
static final int OP_REMOVE = 3;
static final int OP_HIDE = 4;
static final int OP_SHOW = 5;
static final int OP_DETACH = 6;
static final int OP_ATTACH = 7;
static final int OP_SET_PRIMARY_NAV = 8;
static final int OP_UNSET_PRIMARY_NAV = 9;
static final int OP_SET_MAX_LIFECYCLE = 10;
复制代码

事务添加的流程

事务四种Commit的区别

www.cnblogs.com/mengdd/p/58…

在 Fragment 之间传递数据

为了重复使用 Fragment 界面组件，您应将每个组件构建为一个完全独立的模块化组件，定义它自己的布局和行为。定义这些可重用的 Fragment 后，您可以将它们与 Activity 相关联，并将其与应用逻辑相关联以实现整个复合界面。

在AndroidX Fragment版本是 1.3.0-alpha04开始，每个 FragmentManager 都会实现 FragmentResultOwner。我们实现Fragment之间的通信。

我们可以看到 上面通信条件必须是在同一个Activity下面，如果跨越Acitivty的话那就是生命周期大于Acitivity 全局的观察着设计模式了，有RxJava， EventBus、LiveDataBus 这些比较成熟的线程间的通信开源组件了。

状态保存和恢复

状态保存

当Activity在后台被回收或者App的进程处于Sleep状态等特殊情况时候会调用ActivityThread.callActivityOnSaveInstanceState => Instrumentation.callActivityOnSaveInstanceState => Activity.performSaveInstanceState => Activity.onSaveInstanceState => FragmentActivity.onSaveInstanceState 来保存数据

FragmentActivity.onSaveInstanceState

protected void onSaveInstanceState(@NonNull Bundle outState) {
    super.onSaveInstanceState(outState);
  	//将Fragment的状态变更为CREATE
    markFragmentsCreated();
    mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
  	//1.封装所有fragment需要保存的状态数据
    Parcelable p = mFragments.saveAllState();
    if (p != null) {
      	//2.把数据保存到bundle中
        outState.putParcelable(FRAGMENTS_TAG, p);
    }
    if (mPendingFragmentActivityResults.size() > 0) {
        outState.putInt(NEXT_CANDIDATE_REQUEST_INDEX_TAG, mNextCandidateRequestIndex);

        int[] requestCodes = new int[mPendingFragmentActivityResults.size()];
        String[] fragmentWhos = new String[mPendingFragmentActivityResults.size()];
        for (int i = 0; i < mPendingFragmentActivityResults.size(); i++) {
            requestCodes[i] = mPendingFragmentActivityResults.keyAt(i);
            fragmentWhos[i] = mPendingFragmentActivityResults.valueAt(i);
        }
        outState.putIntArray(ALLOCATED_REQUEST_INDICIES_TAG, requestCodes);
        outState.putStringArray(REQUEST_FRAGMENT_WHO_TAG, fragmentWhos);
    }
}
复制代码

第一步方法执行之后mFragments.saveAllState => FragmentController.saveAllState => FragmentManagerImpl.saveAllState

最总进入FragmentManagerImpl.saveAllState

FragmentManagerImpl.saveAllState

Parcelable saveAllState() {
  	//确保所有等待操作的都已处理完，再进入保存数据
    forcePostponedTransactions();
    endAnimatingAwayFragments();
    execPendingActions();
  
		//1.标志位置为true，在mStateSaved == true 的时候commit会抛出异常
    mStateSaved = true;

  	//fragment 为空，也就是没有Fragment 添加到 FragmentManager
    if (mActive.isEmpty()) {
        return null;
    }

    // First collect all active fragments.
    int size = mActive.size();
    ArrayList<FragmentState> active = new ArrayList<>(size);
    boolean haveFragments = false;
  	//遍历所有活跃的fragment
    for (Fragment f : mActive.values()) {
        if (f != null) {
            if (f.mFragmentManager != this) {
                throwException(new IllegalStateException(
                        "Failure saving state: active " + f
                                + " was removed from the FragmentManager"));
            }

            haveFragments = true;
						//2.用于保存fragment的成员变量，并添加到 active，用于数据恢复
            FragmentState fs = new FragmentState(f);
            active.add(fs);

            if (f.mState > Fragment.INITIALIZING && fs.mSavedFragmentState == null) {
              	//保存基本状态
                fs.mSavedFragmentState = saveFragmentBasicState(f);
								
                if (f.mTargetWho != null) {
                    Fragment target = mActive.get(f.mTargetWho);
                    if (fs.mSavedFragmentState == null) {
                        fs.mSavedFragmentState = new Bundle();
                    }
                    putFragment(fs.mSavedFragmentState,
                            FragmentManagerImpl.TARGET_STATE_TAG, target);
                    if (f.mTargetRequestCode != 0) {
                        fs.mSavedFragmentState.putInt(
                                FragmentManagerImpl.TARGET_REQUEST_CODE_STATE_TAG,
                                f.mTargetRequestCode);
                    }
                }

            } else {
                fs.mSavedFragmentState = f.mSavedFragmentState;
            }
        }
    }

    if (!haveFragments) {
        return null;
    }

    ArrayList<String> added = null;
    BackStackState[] backStack = null;

    // Build list of currently added fragments.
    size = mAdded.size();
    if (size > 0) {
      	//遍历所有添加到FragmentManager的Fragment
        added = new ArrayList<>(size);
        for (Fragment f : mAdded) {
          	//f.mWho fragment 唯一标识
            added.add(f.mWho);
        }
    }

  	//保存回退栈
    // Now save back stack.
    if (mBackStack != null) {
        size = mBackStack.size();
        if (size > 0) {
            backStack = new BackStackState[size];
            for (int i = 0; i < size; i++) {
                backStack[i] = new BackStackState(mBackStack.get(i));
            }
        }
    }

  	//3。保存FragmentManagerImpl的整体信息
    FragmentManagerState fms = new FragmentManagerState();
    fms.mActive = active;
    fms.mAdded = added;
    fms.mBackStack = backStack;
    if (mPrimaryNav != null) {
        fms.mPrimaryNavActiveWho = mPrimaryNav.mWho;
    }
    fms.mNextFragmentIndex = mNextFragmentIndex;
    return fms;
}
复制代码

通过上面几个步骤最终将我们的数据保存到ActivityClienttRecord的成员变量 state 中

状态恢复

当Activity恢复的时候会创建一个新的Activity，并走一遍Activity的生命周期方法。

FragmentActivity.onCreate

  1. => FragmentController.restoreSaveState => FragmentManagerImpl.restoreSaveState 恢复数据
  2. => FragmentController.dispatchCreate => FragmentManagerImpl.dispatchCreate 重走Fragment的生命周期

FragmentManagerImpl.restoreSaveState

void restoreSaveState(Parcelable state) {
    // If there is no saved state at all, then there's nothing else to do
    if (state == null) return;
    FragmentManagerState fms = (FragmentManagerState)state;
    if (fms.mActive == null) return;

    // First re-attach any non-config instances we are retaining back
    // to their saved state, so we don't try to instantiate them again.
    for (Fragment f : mNonConfig.getRetainedFragments()) {
        FragmentState fs = null;
        for (FragmentState fragmentState : fms.mActive) {
            if (fragmentState.mWho.equals(f.mWho)) {
                fs = fragmentState;
                break;
            }
        }
        if (fs == null) {
            // We need to ensure that onDestroy and any other clean up is done
            // so move the Fragment up to CREATED, then mark it as being removed, then
            // destroy it.
            moveToState(f, Fragment.CREATED, 0, 0, false);
            f.mRemoving = true;
            moveToState(f, Fragment.INITIALIZING, 0, 0, false);
            continue;
        }
        fs.mInstance = f;
        f.mSavedViewState = null;
        f.mBackStackNesting = 0;
        f.mInLayout = false;
        f.mAdded = false;
        f.mTargetWho = f.mTarget != null ? f.mTarget.mWho : null;
        f.mTarget = null;
        if (fs.mSavedFragmentState != null) {
            fs.mSavedFragmentState.setClassLoader(mHost.getContext().getClassLoader());
            f.mSavedViewState = fs.mSavedFragmentState.getSparseParcelableArray(
                    FragmentManagerImpl.VIEW_STATE_TAG);
            f.mSavedFragmentState = fs.mSavedFragmentState;
        }
    }

  	//先清空活跃的Fragment
    mActive.clear();
  	//从缓存中取出FragmentState 恢复活跃的Fragment并添加到mActive中
    for (FragmentState fs : fms.mActive) {
        if (fs != null) {
            Fragment f = fs.instantiate(mHost.getContext().getClassLoader(),
                    getFragmentFactory());
            f.mFragmentManager = this;
            if (DEBUG) Log.v(TAG, "restoreSaveState: active (" + f.mWho + "): " + f);
            mActive.put(f.mWho, f);
            fs.mInstance = null;
        }
    }

    // Build the list of currently added fragments.
  	//同理恢复add的Fragment
    mAdded.clear();
    if (fms.mAdded != null) {
        for (String who : fms.mAdded) {
            Fragment f = mActive.get(who);
            if (f == null) {
                throwException(new IllegalStateException(
                        "No instantiated fragment for (" + who + ")"));
            }
            f.mAdded = true;
            if (mAdded.contains(f)) {
                throw new IllegalStateException("Already added " + f);
            }
            synchronized (mAdded) {
                mAdded.add(f);
            }
        }
    }

    // Build the back stack.
    if (fms.mBackStack != null) {
        mBackStack = new ArrayList<BackStackRecord>(fms.mBackStack.length);
        for (int i=0; i<fms.mBackStack.length; i++) {
            BackStackRecord bse = fms.mBackStack[i].instantiate(this);
            mBackStack.add(bse);
            if (bse.mIndex >= 0) {
                setBackStackIndex(bse.mIndex, bse);
            }
        }
    } else {
        mBackStack = null;
    }

    if (fms.mPrimaryNavActiveWho != null) {
        mPrimaryNav = mActive.get(fms.mPrimaryNavActiveWho);
        dispatchParentPrimaryNavigationFragmentChanged(mPrimaryNav);
    }
    this.mNextFragmentIndex = fms.mNextFragmentIndex;
}
复制代码
文章分类
Android
文章标签
笔记
相关推荐
  • Stven_King
    6月前
    Android
    ViewPager2+Fragment操作笔记
    ViewPage2+Fragment+左右滑动+横滑+竖滑+上划吸顶+数据懒加载+缓存优化中遇到的问题及决定方法。
    • 1433
    • 1
    ViewPager2+Fragment操作笔记
  • 敲代码的鱼
    4月前
    Android
    FragmentPagerAdapter、FragmentStatePagerAdapter和FragmentStateAdapter的区别你知道嘛
    前段时间在给公司项目做优化，换用了ViewPager，可以左右切换页面，交互更顺滑，改完之后发现Fragment总是不复用，每次切换回来会重复走onCreateView()和onDestroyView
    • 582
    • 评论
  • 小松漫步
    1月前
    面试
    翻车了，字节一道 Fragment面试题
    一道面试题 前段时间面试，面试官先问了一下fragment的生命周期，我一看这简单呀，直接按照下图回答 面试官点点头，然后问，如果Activity里面有一个fragment，那么启动他们时，他们的生命
    • 7412
    • 31
  • 潜心
    6月前
    Android
    记录一个谷歌的坑，多Fragment中fitsSystemWindows只有第一个Fragment生效
    第一个坑，多Fragment嵌套ViewPager2，偶尔会奔溃，报错信息 解决办法 但是你可能发现切换界面每次会重新创建一个fragment 解决办法 然后如果你的多个fragment 中fitsS
    • 849
    • 2
  • 夜远曦白
    3月前
    Android
    《Android编程权威指南》之UI fragment与fragment管理器
    这是我参与8月更文挑战的第19天，活动详情查看：8月更文挑战 开始开发 CriminalIntent 应用啦！
    • 298
    • 评论
    《Android编程权威指南》之UI fragment与fragment管理器
  • 崔庆才丨静觅
    5月前
    笔记
    分享一个不错的笔记软件
    大家知道我平时会写一些文章，有的朋友也会经常问我：你是用的什么软件写作的？用什么软件管理这些文章的？ 我之前其实有介绍过我正在使用的支持跨平台写作的解决方案，是基于苹果的 iCloud Drive 来
    • 1751
    • 1
  • PeakSong
    2月前
    Spring Boot 后端 笔记
    我给SpringBoot提了个issue，被采纳了…
    我给SpringBoot提了个issue，被采纳了… 起因只是因为我想配置redis密码从远程获取，结尾竟然是出于对于单身狗的保护。
    • 2910
    • 6
    我给SpringBoot提了个issue，被采纳了…
  • Andme
    1年前
    Android
    Fragment监听返回键的一种合理方式
    产品经理：“小罗，这个信息发送界面，如果用户输入了内容，点击返回键的时候，要先询问用户是否保存草稿箱哈”。 小罗：“收到，这问题简单。” 说完小罗就准备着手处理，然后却发现信息编辑界面是一个Fragment，然而Fragment并没有提供返回键点击的直接处理；小罗虽菜，但是摸鱼…
    • 3320
    • 15
  • BUG君
    1年前
    源码
    Fragment源码解析(一): Activity与 FragmentManager是如何关联的呢?
    在平时的开发过程中, Fragment 是我们使用频率非常高的组件, 它可以让我们在 Activity 中更加灵活的实现多个界面的功能, 这在某些场景下是非常有用的, 尤其是大屏设备上, 比如 pad 端,车载等. 那么 FragmentManager 是什么呢? 它跟 Act…
    • 1344
    • 评论
  • fundroid
    1月前
    Android Android Jetpack RxJava
    实现一个 Coroutine 版 DialogFragment
    Android 对话框有多种实现方法，目前比较推荐的是 DialogFragment，先比较与直接使用 AlertDialog，可以避免屏幕旋转等配置变化造成消失。但是其 API 建立在回调的基础上使
    • 1331
    • 14
    实现一个 Coroutine 版 DialogFragment
  • YK菌
    3月前
    HTML 笔记 浏览器
    【青训营】HTML基础 - 语义化标签 - 浏览器渲染过程 - 笔记及拓展
    趁着字节跳动青训营的活动，就再学习一遍HTML。一小时的课程，巩固了之前的一些知识，也学到了很多新知识。我把这次课程的内容与我这一年来学习前端的经验相结合，重新整理了字节老师上课的内容，产出这篇博客~
    • 1295
    • 6
    【青训营】HTML基础 - 语义化标签 - 浏览器渲染过程 - 笔记及拓展
  • 一尾流莺
    5月前
    JavaScript 笔记
    【设计模式】学习JS设计模式?先掌握面向对象!
    一个模式就是一个可重用的方案，可应用于在软件设计中的常见问题，另一种解释就是一个我们如何解决问题的模板 - 那些可以在许多不同的情况里使用的模板。--w3cschool
    • 518
    • 2
    【设计模式】学习JS设计模式?先掌握面向对象!
  • 伤心的猪大肠
    1年前
    源码
    Fragment灵魂拷问：Fragment是如何进行事务管理的？
    如果要是有面试官问你，Fragment是如何进行事务管理的？相信很多人可能都回答不出来，很多人可能觉得问题这个还不如问如何进行Fragment预/懒加载，生命周期，返回栈，状态保存等来的有水平。其实我觉得这个问题其实问的挺有深度，如果你想要了解Fragment的事务管理，需要对…
    • 1750
    • 评论
  • Lance_小超
    2年前
    Android
    Fragment重影（重叠）白屏等问题原理解析，以及解决方案
    Activity在非正常退出（点返回等属于正常退出）会调用 onSaveInstanceState 方法来保存数据，其中就包括视图层（View Hierarchy）,当该Activity在此被重建时，会调用onRestoreInstanceState方法，之前被实例化过的 Fr…
    • 4081
    • 3
    Fragment重影（重叠）白屏等问题原理解析，以及解决方案
  • sydMobile
    1年前
    Android
    再谈Fragment
    Fragment 就是一个 Activity 布局的一部分，可以把 Activity 的一部分布局抽离出来到 Fragment 中，并且 Fragment 也可以执行逻辑。就是把 Activity 复杂的内容抽离成几个碎片，然后拼凑起来，在 Activity 布局中，只需要引入…
    • 1496
    • 3
  • 云影同学
    2年前
    笔记
    请查收，掘金前 1000 篇优质文章
    (78)[👍 1836][📌 面试][根号三] 面试遇到了算法题？看这篇就够啦。 (120)[👍 1622][📌 JavaScript][Vincent Ko] 可能是最好的正则表达式的教程笔记了吧... (287)[👍 1169][📌 HTML][Jiyr] 送给…
    • 4339
    • 15
  • 云端上的猫
    5月前
    Android
    使用 Fragment 处理 onActivityResult
    前言 对Activity和Fragment之间的跳转封装处理，在Activity/Framgent中用法基本一样。每个函数基本上都对应着一个扩展函数，方便调用。 常规跳转startActivity，没
    • 541
    • 2
    使用 Fragment 处理 onActivityResult
  • madroid
    4年前
    Android API HTTPS
    Android基础：Fragment，看这篇就够了
    下文中FragmentDemo的源代码地址：https://github.com/xiazdong/FragmentDemo基本概念Fragment，简称碎片，是Android3.0（API11）提出
    • 1801
    • 4
  • YK菌
    3月前
    笔记 JavaScript
    【青训营】月影老师告诉我写好JavaScript的四大技巧——妙用特性
    我们平时在刷题或者网上找资料的时候，得到的很多答案可能都不是用JavaScript实现的，我们就直接照搬翻译成JavaScript过来了，其实JavaScript有很多自己的特性，用的好的话直接起飞
    • 1231
    • 2
    【青训营】月影老师告诉我写好JavaScript的四大技巧——妙用特性
  • Flywith24
    1年前
    Android Jetpack
    【译】2020 年 Fragment 最新文档（下），该更新知识库啦
    很高兴见到你 👋，我是 Flywith24 。 最近 Android 官方针对 Fragment 文档进行了重新编写，使其适应 2020 年最佳实践的快速发展。 Fragment 的确是一个让开发者头疼的组件，它是一个很好的设计，但一直处于可改进的状态，随着 AndroidX…
    • 3105
    • 4
    【译】2020 年 Fragment 最新文档（下），该更新知识库啦
    • 关于作者
    android
    获得点赞150
    文章被阅读15,444
    下载手机APP
    一个帮助开发者成长的社区
    相关文章
    你真的懂 Fragment 吗？—— AndroidX Fragment 核心原理分析
    130
    16
    一文读懂 Fragment 的方方面面
    90
    14
    Android UI 面试常客：谈谈 Fragment 的原理
    260
    2
    【背上Jetpack之Fragment】你真的会用Fragment吗？Fragment常见问题以及androidx下Fragment的使用新姿势
    123
    14
    Android Fragment 使用解析
    56
    5