Android弹窗组件工作机制之Dialog、DialogFragment

Myth丶恋晨 2023-06-24 04:49 43阅读 0赞

前言

Android在DialogFragment推出后，就已经不推荐继续使用Dialog，可替换为DialogFragment，其实DialogFragment只不过是对增加一层看不到的Fragment，用于监听生命周期，在Activity退出的时候会自动回收Dialog弹窗

基础概念

  • Activity：活动。控制生命周期和处理事件，统筹视图的添加与显示，控制Window和View的交互
  • Window：窗口。在Android中是个虚拟的概念，不是View，是承载View的载体，具体实现是PhoneWindow，承载着DecorView
  • WindowManager：窗口管理者。管理Window视图的添加或移除等，具体实现是WindowManagerService（wms）
  • DecorView：窗口根视图。本身是FrameLayout，是Window上真正的根布局，其包含两部分，标题和内容
  • TitleView：标题。作为DecorView的子View，其Id为@android:id/content
  • ContentViews：内容。作为DecorView的子View，其Id为@android:id/content
  • ViewRoot：连接wms和DecorView的纽带，View的measure、layout、draw均通过ViewRoot来完成，具体实现是ViewRootImpl

Dialog

在平时中，简单的弹出Dialog只需要这句话

  1. new Dialog(MainActivity.this).show();
  7.    1

一、Dialog的显示

1、Dialog

Dialog的构造方法有多个，但最后都会调用这个构造方法

  1. Dialog(@NonNull Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
  2.     if (createContextThemeWrapper) {
  3.         if (themeResId == 0) {
  4.             //如果没有主题，则使用默认主题
  5.             final TypedValue outValue = new TypedValue();
  6.             context.getTheme().resolveAttribute(R.attr.dialogTheme, outValue, true);
  7.             themeResId = outValue.resourceId;
  8.         }
  9.         //包裹主题的Context
  10.         mContext = new ContextThemeWrapper(context, themeResId);
  11.     } else {
  12.         mContext = context;
  13.     }
  14.     //获取windowManager服务
  15.     mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  16.     //创建新的Window
  17.     final Window w = new PhoneWindow(mContext);
  18.     mWindow = w;
  19.     //设置callback
  20.     w.setCallback(this);
  21.     w.setOnWindowDismissedCallback(this);
  22.     w.setWindowManager(mWindowManager, null, null);
  23.     w.setGravity(Gravity.CENTER);
  24.     mListenersHandler = new ListenersHandler(this);
  25. }

从Dialog的构造方法中可以看出，Dialog实质上是个Window，其显示和隐藏也是借助WindowManager去控制的

2、Dialog.show

  1. public void show() {
  2.     //如果之前已经show过后，就让视图显示即可
  3.     if (mShowing) {        
  4.         if (mDecor != null) {            
  5.             if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {                
  6.                 mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);            
  7.             }            
  8.             mDecor.setVisibility(View.VISIBLE);        
  9.         }        
  10.         return;   
  11.     }    
  12.     mCanceled = false;    
  13.     //如果没有create则会调用dispatchOncreate，该方法最终会调用dialog的onCreate方法
  14.     if (!mCreated) {
  15.         dispatchOnCreate(null);
  16.     }
  17.     //dialog的onstart回调
  18.     onStart();
  19.     //获取decorView
  20.     mDecor = mWindow.getDecorView();
  21.     //如果需要ActionBar，则创建出来
  22.     if (mActionBar == null && mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
  23.         final ApplicationInfo info = mContext.getApplicationInfo();
  24.         mWindow.setDefaultIcon(info.icon);
  25.         mWindow.setDefaultLogo(info.logo);
  26.         mActionBar = new WindowDecorActionBar(this);
  27.     }
  28.     //window参数的设置
  29.     WindowManager.LayoutParams l = mWindow.getAttributes();
  30.     if ((l.softInputMode
  31.             & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
  32.         WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
  33.         nl.copyFrom(l);
  34.         nl.softInputMode |=
  35.                 WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
  36.         l = nl;
  37.     }
  38.     try {
  39.         //windowManager将decorView加入视图
  40.         mWindowManager.addView(mDecor, l);
  41.         mShowing = true;
  42.         sendShowMessage();
  43.     } finally {
  44.     }
  45.  }

show()其实就是走Dialog的生命周期，然后做初始化工作，获取Window上的DecorView后，将DecorView添加到视图上，这里需要注意的是在show()之后才执行onCreate()

3、Dialog.dispatchOnCreate

  1. void dispatchOnCreate(Bundle savedInstanceState) {
  2.     if (!mCreated) {
  3.         onCreate(savedInstanceState); //回调onCreate()
  4.         mCreated = true;
  5.     }
  6. }
  7. protected void onCreate(Bundle savedInstanceState) {
  8.     //由开发者实现
  9. }
  15.    1
  16.    2
  17.    3
  18.    4
  19.    5
  20.    6
  21.    7
  22.    8
  23.    9
  24.    10

Dialog的初始化其实就是让用户去初始化自己的视图，平时我们是这么写的

  1. public class RxDialog extends Dialog {
  2.     @Override
  3.     protected void onCreate(Bundle savedInstanceState) {
  4.         super.onCreate(savedInstanceState);
  5.         //设置视图
  6.         setContentView(mView);
  7.     }
  8. }
  14.    1
  15.    2
  16.    3
  17.    4
  18.    5
  19.    6
  20.    7
  21.    8

具体的逻辑还是回到setContentView()设置Dialog的视图

4、Dialog.setContentView

  1. public void setContentView(View view) {
  2.     //调用mWindow进行视图设置，mWindow实际上就是构造方法中的PhoneWindow
  3.     mWindow.setContentView(view);
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

mWindow则是在构造方法创建的PhoneWindow

5、PhoneWindow.setContentView

  1. @Override
  2. public void setContentView(View view) {
  3.     //默认MATCH_PARENT
  4.     setContentView(view, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
  5. }
  6. @Override
  7. public void setContentView(View view, ViewGroup.LayoutParams params) {
  8.     if (mContentParent == null) {  
  9.         installDecor();  //创建应用程序窗口视图对象
  10.     } else {  
  11.         mContentParent.removeAllViews();  //重新设置应用程序窗口的视图
  12.     }  
  13.     if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
  14.         view.setLayoutParams(params);
  15.         final Scene newScene = new Scene(mContentParent, view);
  16.         transitionTo(newScene);
  17.     } else {
  18.         mContentParent.addView(view, params); //将我们传递进来的view添加布局上
  19.     }
  20.     mContentParent.requestApplyInsets();
  21.     final Callback cb = getCallback();
  22.     if (cb != null && !isDestroyed()) {
  23.         cb.onContentChanged();
  24.     }
  25.     ......
  26. }
  32.    1
  33.    2
  34.    3
  35.    4
  36.    5
  37.    6
  38.    7
  39.    8
  40.    9
  41.    10
  42.    11
  43.    12
  44.    13
  45.    14
  46.    15
  47.    16
  48.    17
  49.    18
  50.    19
  51.    20
  52.    21
  53.    22
  54.    23
  55.    24
  56.    25
  57.    26
  58.    27
  59.    28
  60.    29

PhoneWindow.setContentView()不仅在Dialog中存在，在Activity的setContentView也是走到这里。mContentParent指的是依附于DecorView上的R.id.content中的view。到这里只是将Dialog设置的View加载到PhoneWindow的ContentView上，其实更主要的还是PhoneWindow添加到我们的手机屏幕上，代码回溯到show()的mWindowManager.addView(mDecor, l)

6、WindowManagerImpl.addView

WindowManager本质上是对View进行管理，但是WindowManager显然依然是个接口，其具体实现是WindowManagerImpl，最后还是委托给WindowManagerGlobal实例mGlobal处理

  1. @Override
  2. public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
  3.     applyDefaultToken(params);
  4.     //委托给mGlobal来进行实现
  5.     mGlobal.addView(view, params, mDisplay, mParentWindow);
  6. }
  12.    1
  13.    2
  14.    3
  15.    4
  16.    5
  17.    6

7、WindowManagerGlobal.addView

  1. public void addView(View view, ViewGroup.LayoutParams params,
  2.         Display display, Window parentWindow) {
  3.     ......
  4.     final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
  5.     if (parentWindow != null) {
  6.         parentWindow.adjustLayoutParamsForSubWindow(wparams);
  7.     } else {
  8.         // If there's no parent, then hardware acceleration for this view is
  9.         // set from the application's hardware acceleration setting.
  10.         final Context context = view.getContext();
  11.         if (context != null
  12.                 && (context.getApplicationInfo().flags
  13.                         & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
  14.             wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
  15.         }
  16.     }
  17.     ViewRootImpl root;
  18.     View panelParentView = null;
  19.     synchronized (mLock) {
  20.         // Start watching for system property changes.
  21.         if (mSystemPropertyUpdater == null) {
  22.             mSystemPropertyUpdater = new Runnable() {
  23.                 @Override public void run() {
  24.                     synchronized (mLock) {
  25.                         for (int i = mRoots.size() - 1; i >= 0; --i) {
  26.                             mRoots.get(i).loadSystemProperties();
  27.                         }
  28.                     }
  29.                 }
  30.             };
  31.             SystemProperties.addChangeCallback(mSystemPropertyUpdater);
  32.         }
  33.         int index = findViewLocked(view, false);
  34.         if (index >= 0) {
  35.             if (mDyingViews.contains(view)) {
  36.                 // Don't wait for MSG_DIE to make it's way through root's queue.
  37.                 mRoots.get(index).doDie();
  38.             } else {
  39.                 throw new IllegalStateException("View " + view
  40.                         + " has already been added to the window manager.");
  41.             }
  42.             // The previous removeView() had not completed executing. Now it has.
  43.         }
  44.         // If this is a panel window, then find the window it is being
  45.         // attached to for future reference.
  46.         if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
  47.                 wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
  48.             final int count = mViews.size();
  49.             for (int i = 0; i < count; i++) {
  50.                 if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
  51.                     panelParentView = mViews.get(i);
  52.                 }
  53.             }
  54.         }
  55.         //创建ViewRootImpl，ViewRootImpl是view和window中的连接纽带
  56.         root = new ViewRootImpl(view.getContext(), display);
  57.         view.setLayoutParams(wparams);
  58.         //存储相关View的信息，会在Remove的时候移除，相当于缓存
  59.         mViews.add(view);//mViews：存储的是所有Window对应的View，本质是个List
  60.         mRoots.add(root);//mRoots：存储的是所有Window所对应的ViewRootImpl，本质是个List
  61.         mParams.add(wparams);//mParams：存储所有window对应的布局参数，本质是个List
  62.     }
  63.     // do this last because it fires off messages to start doing things
  64.     try {
  65.         //最终由root去实现最终的视图显示
  66.         root.setView(view, wparams, panelParentView);
  67.     } catch (RuntimeException e) {
  68.         // BadTokenException or InvalidDisplayException, clean up.
  69.         synchronized (mLock) {
  70.             final int index = findViewLocked(view, false);
  71.             if (index >= 0) {
  72.                 removeViewLocked(index, true);
  73.             }
  74.         }
  75.         throw e;
  76.     }
  77. }
  83.    1
  84.    2
  85.    3
  86.    4
  87.    5
  88.    6
  89.    7
  90.    8
  91.    9
  92.    10
  93.    11
  94.    12
  95.    13
  96.    14
  97.    15
  98.    16
  99.    17
  100.    18
  101.    19
  102.    20
  103.    21
  104.    22
  105.    23
  106.    24
  107.    25
  108.    26
  109.    27
  110.    28
  111.    29
  112.    30
  113.    31
  114.    32
  115.    33
  116.    34
  117.    35
  118.    36
  119.    37
  120.    38
  121.    39
  122.    40
  123.    41
  124.    42
  125.    43
  126.    44
  127.    45
  128.    46
  129.    47
  130.    48
  131.    49
  132.    50
  133.    51
  134.    52
  135.    53
  136.    54
  137.    55
  138.    56
  139.    57
  140.    58
  141.    59
  142.    60
  143.    61
  144.    62
  145.    63
  146.    64
  147.    65
  148.    66
  149.    67
  150.    68
  151.    69
  152.    70
  153.    71
  154.    72
  155.    73
  156.    74
  157.    75
  158.    76
  159.    77
  160.    78
  161.    79
  162.    80
  163.    81
  164.    82
  165.    83
  166.    84
  167.    85
  168.    86
  169.    87

将视图添加到窗口上的工作交给root.setView()，root就是ViewRootImpl

8、ViewRootImpl.setView

  1. public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
  2.     synchronized (this) {
  3.         if (mView == null) {
  4.             ......
  5.             requestLayout(); //真正完成视图的异步刷新请求
  6.             ......
  7.             //这里调用了mWindowSession的addToDisplay方法，在WindowManagerService层通过IPC机制完成真正的window添加
  8.             res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
  9.                     getHostVisibility(), mDisplay.getDisplayId(),
  10.                     mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
  11.                     mAttachInfo.mOutsets, mInputChannel);
  12.         }
  13.     }
  14. }
  15. @Override
  16. public void requestLayout() {
  17.     if (!mHandlingLayoutInLayoutRequest) {
  18.         checkThread();
  19.         mLayoutRequested = true;
  20.         scheduleTraversals(); //真正的去走Measure、Layout、Draw
  21.     }
  22. }
  28.    1
  29.    2
  30.    3
  31.    4
  32.    5
  33.    6
  34.    7
  35.    8
  36.    9
  37.    10
  38.    11
  39.    12
  40.    13
  41.    14
  42.    15
  43.    16
  44.    17
  45.    18
  46.    19
  47.    20
  48.    21
  49.    22
  50.    23
  51.    24
  52.    25

在添加view之前，会走requestLayout()，真正实现View绘制的三部曲Measure、Layout、Draw。mWindowSession类型是IWindowSession，它是个Binder对象，真正的实现类是Session，window的添加过程实际上是一次ipc的调用，最后在WindowManagerService层通过IPC机制去实现的

总结

在这读完这里源码后，我们知道Window是个相对虚拟的对象，真正的操作是对Window中的DecorView进行addView()操作，而且在addView()之前，会先走onCreate()、onStart()、setContentView()操作，而在setContentView()过程中，会经过ViewRootImpl对象进行setView，并且在ViewRootImpl对象中会实现View绘制的三步曲，Measure、Layout、Draw操作，最后再将绘制好的view通过IWindowSession的ipc调用添加到界面上

  1. Dialog本质上是个Window，具体是通过Window的DecorView进行显示的
  2. Dialog是在show()之后走的onCreate()、onStart()、setContentView()等回调

在这里插入图片描述

二、Dialog的消失

1、dismiss

  1. private final Runnable mDismissAction = this::dismissDialog;
  2. public void dismiss() {
  3.     if (Looper.myLooper() == mHandler.getLooper()) {
  4.         dismissDialog();
  5.     } else {
  6.         mHandler.post(mDismissAction);
  7.     }
  8. }
  14.    1
  15.    2
  16.    3
  17.    4
  18.    5
  19.    6
  20.    7
  21.    8
  22.    9

保证UI操作都在主线程执行，而且引用了Java8新特性写法this::dismissDialog，最后都会调用dismissDialog()

2、dismissDialog

  1. void dismissDialog() {
  2.     if (mDecor == null || !mShowing) {
  3.         return;
  4.     }
  5.     if (mWindow.isDestroyed()) {
  6.         Log.e(TAG, "Tried to dismissDialog() but the Dialog's window was already destroyed!");
  7.         return;
  8.     }
  9.     try {
  10.         //这里移除DecorView
  11.         mWindowManager.removeViewImmediate(mDecor);
  12.     } finally {
  13.         if (mActionMode != null) {
  14.             mActionMode.finish();
  15.         }
  16.         mDecor = null;
  17.         mWindow.closeAllPanels();
  18.         onStop();
  19.         mShowing = false;
  20.         sendDismissMessage();
  21.     }
  22. }
  28.    1
  29.    2
  30.    3
  31.    4
  32.    5
  33.    6
  34.    7
  35.    8
  36.    9
  37.    10
  38.    11
  39.    12
  40.    13
  41.    14
  42.    15
  43.    16
  44.    17
  45.    18
  46.    19
  47.    20
  48.    21
  49.    22
  50.    23
  51.    24
  52.    25

从show中知道，我们将DecorView加入到WindowManager中去，所以这里移除的是DecorView

3、WindowManagerImpl.removeViewImmediate

  1. public void removeViewImmediate(View view) {
  2.     //委托给mGlobal来进行实现
  3.     mGlobal.removeView(view, true);
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

同样的交给WindowManagerGlobal去处理

4、WindowManagerGlobal.removeView

  1. public void removeView(View view, boolean immediate) {
  2.     if (view == null) {
  3.         throw new IllegalArgumentException("view must not be null");
  4.     }
  5.     synchronized (mLock) {
  6.         //待remove view的索引
  7.         int index = findViewLocked(view, true);
  8.         //mRoots保存着每一个viewRootImpl对象
  9.         View curView = mRoots.get(index).getView();
  10.         //真正对view进行了remove操作
  11.         removeViewLocked(index, immediate);
  12.         if (curView == view) {
  13.             return;
  14.         }
  15.         throw new IllegalStateException("Calling with view " + view
  16.                 + " but the ViewAncestor is attached to " + curView);
  17.     }
  18. }
  24.    1
  25.    2
  26.    3
  27.    4
  28.    5
  29.    6
  30.    7
  31.    8
  32.    9
  33.    10
  34.    11
  35.    12
  36.    13
  37.    14
  38.    15
  39.    16
  40.    17
  41.    18
  42.    19
  43.    20

找到对应要移除的View后进行View逻辑处理工作

5、WindowManagerGlobal.removeViewLocked

  1. private void removeViewLocked(int index, boolean immediate) {
  2.     ViewRootImpl root = mRoots.get(index);
  3.     View view = root.getView();
  4.     if (view != null) {
  5.         InputMethodManager imm = InputMethodManager.getInstance();
  6.         if (imm != null) {
  7.             imm.windowDismissed(mViews.get(index).getWindowToken());
  8.         }
  9.     }
  10.     //重点在ViewRootImpl中的die方法中
  11.     boolean deferred = root.die(immediate);
  12.     if (view != null) {
  13.         view.assignParent(null);
  14.         if (deferred) {
  15.             mDyingViews.add(view);
  16.         }
  17.     }
  18. }
  24.    1
  25.    2
  26.    3
  27.    4
  28.    5
  29.    6
  30.    7
  31.    8
  32.    9
  33.    10
  34.    11
  35.    12
  36.    13
  37.    14
  38.    15
  39.    16
  40.    17
  41.    18
  42.    19

找到对应的ViewRootImpl，进行移除并释放工作

6、ViewRootImpl.die

  1. boolean die(boolean immediate) {
  2.     if (immediate && !mIsInTraversal) {
  3.         //继续跟踪
  4.         doDie();
  5.         return false;
  6.     }
  7.     if (!mIsDrawing) {
  8.         destroyHardwareRenderer();
  9.     } else {
  10.         Log.e(TAG, "Attempting to destroy the window while drawing!\n" +
  11.                 "  window=" + this + ", title=" + mWindowAttributes.getTitle());
  12.     }
  13.     mHandler.sendEmptyMessage(MSG_DIE);
  14.     return true;
  15. }
  21.    1
  22.    2
  23.    3
  24.    4
  25.    5
  26.    6
  27.    7
  28.    8
  29.    9
  30.    10
  31.    11
  32.    12
  33.    13
  34.    14
  35.    15
  36.    16

7、ViewRootImpl.doDie

  1. void doDie() {
  2.     checkThread();
  3.     if (LOCAL_LOGV) Log.v(TAG, "DIE in " + this + " of " + mSurface);
  4.     synchronized (this) {
  5.         if (mRemoved) {
  6.             return;
  7.         }
  8.         mRemoved = true;
  9.         if (mAdded) {
  10.             //这里是真正移除Dialog的View
  11.             dispatchDetachedFromWindow();
  12.         }
  13.         if (mAdded && !mFirst) {
  14.             //硬件渲染destroy
  15.             destroyHardwareRenderer();
  16.             if (mView != null) {
  17.                 int viewVisibility = mView.getVisibility();
  18.                 boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
  19.                 if (mWindowAttributesChanged || viewVisibilityChanged) {
  20.                     // If layout params have been changed, first give them
  21.                     // to the window manager to make sure it has the correct
  22.                     // animation info.
  23.                     try {
  24.                         if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
  25.                                 & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
  26.                             mWindowSession.finishDrawing(mWindow);
  27.                         }
  28.                     } catch (RemoteException e) {
  29.                     }
  30.                 }
  31.                 //Surface的释放
  32.                 mSurface.release();
  33.             }
  34.         }
  35.         mAdded = false;
  36.     }
  37.     //移除之前存储的变量
  38.     WindowManagerGlobal.getInstance().doRemoveView(this);
  39. }
  45.    1
  46.    2
  47.    3
  48.    4
  49.    5
  50.    6
  51.    7
  52.    8
  53.    9
  54.    10
  55.    11
  56.    12
  57.    13
  58.    14
  59.    15
  60.    16
  61.    17
  62.    18
  63.    19
  64.    20
  65.    21
  66.    22
  67.    23
  68.    24
  69.    25
  70.    26
  71.    27
  72.    28
  73.    29
  74.    30
  75.    31
  76.    32
  77.    33
  78.    34
  79.    35
  80.    36
  81.    37
  82.    38
  83.    39
  84.    40
  85.    41
  86.    42

保证线程安全后，做移除和释放工作

8、WindowManagerGlobal.doRemoveView

一般程序最后的工作都是释放工作，移除之前存储的变量

  1. void doRemoveView(ViewRootImpl root) {
  2.     synchronized (mLock) {
  3.         final int index = mRoots.indexOf(root);
  4.         if (index >= 0) {
  5.             //释放工作
  6.             mRoots.remove(index);
  7.             mParams.remove(index);
  8.             final View view = mViews.remove(index);
  9.             mDyingViews.remove(view);
  10.         }
  11.     }
  12.     if (HardwareRenderer.sTrimForeground && HardwareRenderer.isAvailable()) {
  13.         doTrimForeground();
  14.     }
  15. }
  21.    1
  22.    2
  23.    3
  24.    4
  25.    5
  26.    6
  27.    7
  28.    8
  29.    9
  30.    10
  31.    11
  32.    12
  33.    13
  34.    14
  35.    15

9、ViewRootImpl.dispatchDetachedFromWindow

  1. void dispatchDetachedFromWindow() {
  2.     if (mView != null && mView.mAttachInfo != null) {
  3.         mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(false);
  4.         //此方法会回调onDetachedFromWindow方法，会做资源的回收
  5.         mView.dispatchDetachedFromWindow();
  6.     }
  7.     mAccessibilityInteractionConnectionManager.ensureNoConnection();
  8.     mAccessibilityManager.removeAccessibilityStateChangeListener(
  9.             mAccessibilityInteractionConnectionManager);
  10.     mAccessibilityManager.removeHighTextContrastStateChangeListener(
  11.             mHighContrastTextManager);
  12.     removeSendWindowContentChangedCallback()
  13.     destroyHardwareRenderer(); 
  14.     setAccessibilityFocus(null, null); 
  15.     mView.assignParent(null);
  16.     mView = null;
  17.     mAttachInfo.mRootView = null;
  18.     mSurface.release(); 
  19.     if (mInputQueueCallback != null && mInputQueue != null) {
  20.         mInputQueueCallback.onInputQueueDestroyed(mInputQueue);
  21.         mInputQueue.dispose();
  22.         mInputQueueCallback = null;
  23.         mInputQueue = null;
  24.     }
  25.     if (mInputEventReceiver != null) {
  26.         mInputEventReceiver.dispose();
  27.         mInputEventReceiver = null;
  28.     }
  29.     try {
  30.         //这里调用了mWindowSession的remove方法，在WindowManagerService层通过IPC机制完成真正的window删除
  31.        mWindowSession.remove(mWindow);
  32.     } catch (RemoteException e) {
  33.     } 
  34.     // Dispose the input channel after removing the window so the Window Manager
  35.     // doesn't interpret the input channel being closed as an abnormal termination.
  36.     if (mInputChannel != null) {
  37.         mInputChannel.dispose();
  38.         mInputChannel = null;
  39.     } 
  40.     mDisplayManager.unregisterDisplayListener(mDisplayListener); 
  41.     unscheduleTraversals();
  42. }
  48.    1
  49.    2
  50.    3
  51.    4
  52.    5
  53.    6
  54.    7
  55.    8
  56.    9
  57.    10
  58.    11
  59.    12
  60.    13
  61.    14
  62.    15
  63.    16
  64.    17
  65.    18
  66.    19
  67.    20
  68.    21
  69.    22
  70.    23
  71.    24
  72.    25
  73.    26
  74.    27
  75.    28
  76.    29
  77.    30
  78.    31
  79.    32
  80.    33
  81.    34
  82.    35
  83.    36
  84.    37
  85.    38
  86.    39
  87.    40
  88.    41
  89.    42
  90.    43
  91.    44
  92.    45
  93.    46
  94.    47
  95.    48
  96.    49
  97.    50
  98.    51

到最后会和添加View的时候完成闭环，还是通过WindowSession的IPC机制去调用的，最后在WindowManagerService层通过IPC机制去实现的

总结

  1. Dialog的dismiss和show形成闭环，调用的过程是相似的，只不过多了资源的释放环节

在这里插入图片描述

DialogFragment

DialogFragment本身继承自Fragment

  1. public class DialogFragment extends Fragment
  2.         implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener
  8.    1
  9.    2

在平时中，我们需要自定义WeDialogFragment，而且在正式开发中踩过的坑：

  • 需要对参数进行onSaveInstanceState操作，这类操作主要是防止异步吊起DialogFragment报nullPoint的Bug

  • 需要重写show()，对show做一层弹出时候的保护，这类操作主要是防止异步吊起DialogFragment报onSaveInstanceState的Bug

    public class WeDialogFragment extends DialogFragment {

    1. @Override
    2. public void onSaveInstanceState(Bundle outState) {
    3.     super.onSaveInstanceState(outState);
    4.     Bundle bundle = new Bundle();
    5.     bundle.putString(BUNDLE_TITLE, title);
    6. }
    7. @Override
    8. public void onCreate(@Nullable Bundle savedInstanceState) {
    9.     super.onCreate(savedInstanceState);
    10.     setStyle(DialogFragment.STYLE_NO_TITLE, R.style.WeDialog);        
    11.     if (savedInstanceState != null) {
    12.         title = savedInstanceState.getString(BUNDLE_TITLE);
    13.     }
    14. }    
    15. @Override
    16. public Dialog onCreateDialog(Bundle savedInstanceState) {
    17.     Dialog dialog = super.onCreateDialog(savedInstanceState);
    18.     dialog.setCanceledOnTouchOutside(true);
    19.     dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    20.     dialog.getWindow().setWindowAnimations(R.style.DialogAnimation);
    21.     dialog.getWindow().setBackgroundDrawableResource(android.R.color.transparent);
    22.     return dialog;
    23. }
    24. @Nullable
    25. @Override
    26. public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
    27.                          @Nullable Bundle savedInstanceState) {
    28.     return inflater.inflate(R.layout.view_fragment_dialog, container, false);
    29. }    
    30. @Override
    31. public void show(FragmentManager manager, String tag) {
    32.     if (!manager.isStateSaved()) {
    33.         super.show(manager, tag);
    34.     }
    35. }

    }

  1.    1
  2.    2
  3.    3
  4.    4
  5.    5
  6.    6
  7.    7
  8.    8
  9.    9
  10.    10
  11.    11
  12.    12
  13.    13
  14.    14
  15.    15
  16.    16
  17.    17
  18.    18
  19.    19
  20.    20
  21.    21
  22.    22
  23.    23
  24.    24
  25.    25
  26.    26
  27.    27
  28.    28
  29.    29
  30.    30
  31.    31
  32.    32
  33.    33
  34.    34
  35.    35
  36.    36
  37.    37
  38.    38
  39.    39
  40.    40
  41.    41
  42.    42
  43.    43

然后在Activity中弹出DialogFragment

  1. WeDialogFragment weDialogFragment = new WeDialogFragment();
  2. weDialogFragment.show(activity.getSupportFragmentManager(),"weDialogFragment");       
  8.    1
  9.    2

一、DialogFragment的显示

1、DialogFragment.show

  1. public void show(FragmentManager manager, String tag) {
  2.     mDismissed = false;
  3.     mShownByMe = true;
  4.     FragmentTransaction ft = manager.beginTransaction();
  5.     ft.add(this, tag);
  6.     ft.commit();
  7. }
  13.    1
  14.    2
  15.    3
  16.    4
  17.    5
  18.    6
  19.    7

show的方法其实就是对Fragment的处理，将Fragment添加到Fragment栈中

二、DialogFragment的隐藏

1、DialogFragment.dismiss

  1. public void dismiss() {
  2.     dismissInternal(false);
  3. }
  4. public void dismissAllowingStateLoss() {
  5.     dismissInternal(true);
  6. }
  7. void dismissInternal(boolean allowStateLoss) {
  8.     if (mDismissed) {
  9.         return;
  10.     }
  11.     mDismissed = true;
  12.     mShownByMe = false;
  13.     if (mDialog != null) {
  14.         mDialog.dismiss();
  15.     }
  16.     mViewDestroyed = true;
  17.     if (mBackStackId >= 0) {
  18.         getFragmentManager().popBackStack(mBackStackId,
  19.                 FragmentManager.POP_BACK_STACK_INCLUSIVE);
  20.         mBackStackId = -1;
  21.     } else {
  22.         FragmentTransaction ft = getFragmentManager().beginTransaction();
  23.         ft.remove(this);
  24.         if (allowStateLoss) {
  25.             ft.commitAllowingStateLoss();
  26.         } else {
  27.             ft.commit();
  28.         }
  29.     }
  30. }
  36.    1
  37.    2
  38.    3
  39.    4
  40.    5
  41.    6
  42.    7
  43.    8
  44.    9
  45.    10
  46.    11
  47.    12
  48.    13
  49.    14
  50.    15
  51.    16
  52.    17
  53.    18
  54.    19
  55.    20
  56.    21
  57.    22
  58.    23
  59.    24
  60.    25
  61.    26
  62.    27
  63.    28
  64.    29
  65.    30
  66.    31
  67.    32

dismiss的方法也是对Fragment的处理，将Fragment移除到Fragment栈中

三、Dialog的创建

1、DialogFragment.onCreateDialog

  1. @NonNull
  2. public Dialog onCreateDialog(Bundle savedInstanceState) {
  3.     return new Dialog(getActivity(), getTheme());
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

和创建普通的Dialog没什么区别，我们重写该方法，可以自定义弹出AlertDialog等其他自定义Dialog

四、Dialog的视图

1、DialogFragment.onActivityCreated

  1. @Override
  2. public void onActivityCreated(Bundle savedInstanceState) {
  3.     super.onActivityCreated(savedInstanceState);
  4.     if (!mShowsDialog) {
  5.         return;
  6.     }
  7.     //拿到的就是onCreateView返回值的view对象，具体可以在Fragment源码找到
  8.     View view = getView();
  9.     if (view != null) {
  10.         if (view.getParent() != null) {
  11.             throw new IllegalStateException(
  12.                     "DialogFragment can not be attached to a container view");
  13.         }
  14.         //真正设置view
  15.         mDialog.setContentView(view);
  16.     }
  17.     final Activity activity = getActivity();
  18.     if (activity != null) {
  19.         mDialog.setOwnerActivity(activity);
  20.     }
  21.     mDialog.setCancelable(mCancelable);
  22.     mDialog.setOnCancelListener(this);
  23.     mDialog.setOnDismissListener(this);
  24.     if (savedInstanceState != null) {
  25.         Bundle dialogState = savedInstanceState.getBundle(SAVED_DIALOG_STATE_TAG);
  26.         if (dialogState != null) {
  27.             mDialog.onRestoreInstanceState(dialogState);
  28.         }
  29.     }
  30. }
  36.    1
  37.    2
  38.    3
  39.    4
  40.    5
  41.    6
  42.    7
  43.    8
  44.    9
  45.    10
  46.    11
  47.    12
  48.    13
  49.    14
  50.    15
  51.    16
  52.    17
  53.    18
  54.    19
  55.    20
  56.    21
  57.    22
  58.    23
  59.    24
  60.    25
  61.    26
  62.    27
  63.    28
  64.    29
  65.    30
  66.    31
  67.    32

在Activity创建的时候，Fragment的周期会回调onActivityCreated，从而对Dialog设置视图

五、Dialog的显示隐藏

Dialog显示隐藏就简单了，随着Fragment的生命周期显示和隐藏，直接看代码就行了

  1. @Override
  2. public void onStart() {
  3.     super.onStart();
  4.     if (mDialog != null) {
  5.         mViewDestroyed = false;
  6.         mDialog.show();
  7.     }
  8. }
  9. @Override
  10. public void onStop() {
  11.     super.onStop();
  12.     if (mDialog != null) {
  13.         mDialog.hide();
  14.     }
  15. }
  21.    1
  22.    2
  23.    3
  24.    4
  25.    5
  26.    6
  27.    7
  28.    8
  29.    9
  30.    10
  31.    11
  32.    12
  33.    13
  34.    14
  35.    15
  36.    16

总结

DialogFragment = Fragment + Dialog，DialogFragment本身继承Fragment，Fragment只是用来依附在Activity上，可以监听Activity的生命周期，从而去通知Dialog做对应的操作，而Dialog才是我们正在显示在屏幕上的弹窗，而非一个Fragment。这里的Dialog真正显示出来的View是从onCreateView()中获取view后，在源码中调用dialog的setContentView()显示出来的

发表评论

表情：
评论列表 （有 0 条评论，43人围观）

还没有评论，来说两句吧...

相关阅读