基于Android8.0分析源码的ViewStub源码解析

源码基于安卓8.0分析结果

创新互联公司基于分布式IDC数据中心构建的平台为众多户提供成都西云数据中心 四川大带宽租用 成都机柜租用 成都服务器租用。

ViewStub是一种不可见的并且大小为0的试图，它可以延迟到运行时才填充inflate 布局资源，当Viewstub设为可见或者是inflate的时候，就会填充布局资源，这个布局和普通的试图就基本上没有任何区别，比如说，加载网络失败，或者是一个比较消耗性能的功能，需要用户去点击才可以加载!从而这样更加的节约了性能。对安卓布局很友好!

ViewStub用法

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2.     android:padding="10dp"
    3. 
  
  
  
  
  3.     android:background="@color/colorPrimary"
    4. 
  
  
  
  
  4.     android:layout_gravity="center"
    5. 
  
  
  
  
  5.     android:inflatedId="@+id/view_stub_inflateid"
    6. 
  
  
  
  
  6.     android:id="@+id/view_stub"
    7. 
  
  
  
  
  7.     android:layout="@layout/view_stub_imageview"
    8. 
  
  
  
  
  8.     android:layout_width="wrap_content"
    9. 
  
  
  
  
  9.     android:layout_height="wrap_content" />
    10.

这篇文章安卓代码、图片、布局、网络和电量优化说如果这个根布局是个View，比如说是个ImagView，那么找出来的id为null，得必须注意这一点 -----2018.6.7修正这个说法，以前我说的是错误的，根本上的原因是ViewStub设置了 inflateid ，这才是更本身的原因

在这里记住一点，如果在 ViewStub标签中设置了android:inflatedId="@+id/view_stub_inflateid",在layout布局中的根布局在设置android:id="@+id/view_stub_layout",这个id永远找出来都是为null的，原因会在下面说明

 
 
 
 
    
  
  
  
  
    2. 
  
  
  
  
  2. 
  
  
  
  
  3.     android:padding="10dp"
    4. 
  
  
  
  
  4.     android:id="@+id/view_stub_layout"
    5. 
  
  
  
  
  5.     android:src="@drawable/ic_launcher_background"
    6. 
  
  
  
  
  6.     android:layout_width="match_parent"
    7. 
  
  
  
  
  7.     android:layout_height="match_parent">
    8. 
  
  
  
  
  8.     
  
  
  
  
  9.         android:text="如果这个根布局是个View，比如说是个ImagView，那么找出来的id为null，得必须注意这一点  -----2018.6.7修正这个说法，以前我说的是错误的，根本上的原因是ViewStub设置了 inflateid ，这才是更本身的原因"
    10. 
  
  
  
  
  10.         android:layout_width="wrap_content"
    11. 
  
  
  
  
  11.         android:layout_height="wrap_content" />
    12. 
  
  
  
  
  12.     
  
  
  
  
  13.         android:layout_marginTop="20dp"
    14. 
  
  
  
  
  14.         android:id="@+id/imageview"
    15. 
  
  
  
  
  15.         android:padding="10dp"
    16. 
  
  
  
  
  16.         android:src="@drawable/ic_launcher_background"
    17. 
  
  
  
  
  17.         android:layout_width="match_parent"
    18. 
  
  
  
  
  18.         android:layout_height="match_parent"/>
    19. 
  
  
  
  
  19.

在activity或者是fragment中的使用,mViewStub.getParent()==null就是说明没有被填充，需要填充，如果填充了，那么它的parent不会为null，具体的骚操作，后续我介绍View的绘制流程的时候在详细说明。

第一种使用的方法

 
 
 
 
    
  
  
  
  
  1.  mViewStub = findViewById(R.id.view_stub);
    2. 
  
  
  
  
  2.  if (null!=mViewStub.getParent()){
    3. 
  
  
  
  
  3.  View inflate = mViewStub.inflate();
    4. 
  
  
  
  
  4.  ....
    5. 
  
  
  
  
  5. }
    6.

第二种方式:mViewStub.setVisibility(View.VISIBLE);和inflate()方法一样。

 
 
 
 
    
  
  
  
  
  1.  mViewStub = findViewById(R.id.view_stub);
    2. 
  
  
  
  
  2.  if (null!=mViewStub.getParent()){
    3. 
  
  
  
  
  3.    mViewStub.setVisibility(View.VISIBLE);
    4. 
  
  
  
  
  4.  ....
    5. 
  
  
  
  
  5. }
    6.

第三种方式,my_title_parent_id是layout的根布局的id

 
 
 
 
    
  
  
  
  
  1. mViewStub = findViewById(R.id.view_stub);
    2. 
  
  
  
  
  2.  // 成员变量commLv2为空则代表未加载 commLv2 的id为ViewStub中的根布局的id
    3. 
  
  
  
  
  3.  View commLv2=findViewById(R.id.my_title_parent_id);
    4. 
  
  
  
  
  4. if ( commLv2 == null ) {
    5. 
  
  
  
  
  5.    // 加载评论列表布局, 并且获取评论ListView,inflate函数直接返回ListView对象
    6. 
  
  
  
  
  6.      commLv2 = (View)mViewStub.inflate();
    7. 
  
  
  
  
  7.    } else {
    8. 
  
  
  
  
  8.       // ViewStub已经加载
    9. 
  
  
  
  
  9.   }
    10.

ViewStub构造方法,注意获取了几个值mInflatedId就是android:inflatedId="@+id/find_view_stub"这个值， mLayoutResource就是layout的resId，ViewStub的 mIDid。可以看出ViewStub是View的子类.

 
 
 
 
    
  
  
  
  
  1. public final class ViewStub extends View {
    2. 
  
  
  
  
  2.  public ViewStub(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    3. 
  
  
  
  
  3.         super(context);
    4. 
  
  
  
  
  4.         final TypedArray a = context.obtainStyledAttributes(attrs,
    5. 
  
  
  
  
  5.                 R.styleable.ViewStub, defStyleAttr, defStyleRes);
    6. 
  
  
  
  
  6.         // TODO: 2018/5/23  ViewStub 中设置的标签id 如果设置了 这里就一定有值 mInflatedId！=NO_Id
    7. 
  
  
  
  
  7.         mInflatedId = a.getResourceId(R.styleable.ViewStub_inflatedId, NO_ID);
    8. 
  
  
  
  
  8.         mLayoutResource = a.getResourceId(R.styleable.ViewStub_layout, 0);
    9. 
  
  
  
  
  9.         mID = a.getResourceId(R.styleable.ViewStub_id, NO_ID);
    10. 
  
  
  
  
  10.         a.recycle();
    11. 
  
  
  
  
  11.         //不可见
    12. 
  
  
  
  
  12.         setVisibility(GONE);
    13. 
  
  
  
  
  13.         // 设置不绘制
    14. 
  
  
  
  
  14.         setWillNotDraw(true);
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16. }
    17.

在构造方法中:同时注意不可见 setVisibility(GONE); ,设置不绘制setWillNotDraw(true);,同时通过下面的方法看出，ViewStub 是一个大小为0的视图。

 
 
 
 
    
  
  
  
  
  1. @Override
    2. 
  
  
  
  
  2.   protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    3. 
  
  
  
  
  3.       // 宽高都为0   onMeasure的时候 宽高都为0
    4. 
  
  
  
  
  4.       setMeasuredDimension(0, 0);
    5. 
  
  
  
  
  5.   }
    6. 
  
  
  
  
  6.   //todo 为啥这个控件 是个大小为0的控件 ，那是因为他妈的这里更不就没有画
    7. 
  
  
  
  
  7.   @Override
    8. 
  
  
  
  
  8.   public void draw(Canvas canvas) {
    9. 
  
  
  
  
  9.   }
    10. 
  
  
  
  
  10. 
  
  
  
  
  11.   @Override
    12. 
  
  
  
  
  12.   protected void dispatchDraw(Canvas canvas) {
    13. 
  
  
  
  
  13.   }
    14.

关于inflate()方法

 
 
 
 
    
  
  
  
  
  1. public View inflate() {
    2. 
  
  
  
  
  2.       // 1、获取ViewStub的parent view，也是目标布局根元素的parent view
    3. 
  
  
  
  
  3.       final ViewParent viewParent = getParent();
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.       if (viewParent != null && viewParent instanceof ViewGroup) {
    6. 
  
  
  
  
  6.           if (mLayoutResource != 0) {
    7. 
  
  
  
  
  7.               final ViewGroup parent = (ViewGroup) viewParent;
    8. 
  
  
  
  
  8.               /// 2、加载目标布局  牛逼的方法
    9. 
  
  
  
  
  9.               final View view = inflateViewNoAdd(parent);
    10. 
  
  
  
  
  10.               // 3、将ViewStub自身从parent中移除
    11. 
  
  
  
  
  11.               replaceSelfWithView(view, parent);
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.               mInflatedViewRef = new WeakReference<>(view);
    14. 
  
  
  
  
  14.               if (mInflateListener != null) {
    15. 
  
  
  
  
  15.                   mInflateListener.onInflate(this, view);
    16. 
  
  
  
  
  16.               }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.               return view;
    19. 
  
  
  
  
  19.           } else {
    20. 
  
  
  
  
  20.               // TODO: 2018/5/23 必须设置布局的文件
    21. 
  
  
  
  
  21.               throw new IllegalArgumentException("ViewStub must have a valid layoutResource");
    22. 
  
  
  
  
  22.           }
    23. 
  
  
  
  
  23.       } else {
    24. 
  
  
  
  
  24.           // TODO: 2018/5/23 iewParent instanceof ViewGroup 不属于的话，就好比在一个TextView创建一个ViewStub直接爆炸
    25. 
  
  
  
  
  25.           throw new IllegalStateException("ViewStub must have a non-null ViewGroup viewParent");
    26. 
  
  
  
  
  26.       }
    27. 
  
  
  
  
  27.   }
    28.
  • 第一点，ViewStup也只能在ViewGroup中使用，不能在View中去使用，要不然会抛出异常IllegalStateException("ViewStub must have a non-null ViewGroup viewParent");
  • 第二点，也必须设置layout属性，要不然也会抛出异常throw new IllegalArgumentException("ViewStub must have a valid layoutResource");;

关于方法inflateViewNoAdd(parent);

 
 
 
 
    
  
  
  
  
  1. private View inflateViewNoAdd(ViewGroup parent) {
    2. 
  
  
  
  
  2.       final LayoutInflater factory;
    3. 
  
  
  
  
  3.       if (mInflater != null) {
    4. 
  
  
  
  
  4.           factory = mInflater;
    5. 
  
  
  
  
  5.       } else {
    6. 
  
  
  
  
  6.           factory = LayoutInflater.from(mContext);
    7. 
  
  
  
  
  7.       }
    8. 
  
  
  
  
  8.       final View view = factory.inflate(mLayoutResource, parent, false);
    9. 
  
  
  
  
  9.       //和 LayoutInflater一个道理，设置了，ViewStub 引用进来的根布局的id找出来为null  非常有些意思
    10. 
  
  
  
  
  10.       if (mInflatedId != NO_ID) {
    11. 
  
  
  
  
  11.           view.setId(mInflatedId);
    12. 
  
  
  
  
  12.       }
    13. 
  
  
  
  
  13.       return view;
    14. 
  
  
  
  
  14.   }
    15.
  • 第一点，底层调用的还是LayoutInflater.from(mContext).inflate(mLayoutResource, parent, false);
  • 第二点，又看到这个方法，似曾相识，对，这也是为什么ViewStub找不到根布局id的原因，因为mInflatedId != NO_ID,就会view.setId(mInflatedId);
 
 
 
 
    
  
  
  
  
  1.  if (mInflatedId != NO_ID) {
    2. 
  
  
  
  
  2.         view.setId(mInflatedId);
    3. 
  
  
  
  
  3. }
    4.

将ViewStub自身从parent中移除replaceSelfWithView(view, parent);,具体的原因，这里不做分析，因为有点小复杂，这里就大概明白就行，对于理解这个ViewStub不困难，哈哈

 
 
 
 
    
  
  
  
  
  1. private void replaceSelfWithView(View view, ViewGroup parent) {
    2. 
  
  
  
  
  2.      final int index = parent.indexOfChild(this);
    3. 
  
  
  
  
  3.      // 3、将ViewStub自身从parent中移除
    4. 
  
  
  
  
  4.      parent.removeViewInLayout(this);
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.      final ViewGroup.LayoutParams layoutParams = getLayoutParams();
    7. 
  
  
  
  
  7.      if (layoutParams != null) {
    8. 
  
  
  
  
  8.          // 4、将目标布局的根元素添加到parent中，有参数
    9. 
  
  
  
  
  9.          parent.addView(view, index, layoutParams);
    10. 
  
  
  
  
  10.      } else {
    11. 
  
  
  
  
  11.         // 5、将目标布局的根元素添加到parent中
    12. 
  
  
  
  
  12.          parent.addView(view, index);
    13. 
  
  
  
  
  13.      }
    14. 
  
  
  
  
  14.  }
    15.

这里使用到了弱引用，只有弱引用指向的对象的生命周期更短，当垃圾回收器扫描到只有具有弱引用的对象的时候，不论当前空间是否不足，都会对弱引用对象进行回收，当然弱引用也可以和一个队列配合着使用，为了更好地释放内存，安卓代码、图片、布局、网络和电量优化这篇文章有很好的解释，而且这个mInflatedViewRef只在这里初始化，如果说没有调用inflate的方法的话，这个对象一定为null;

 
 
 
 
    
  
  
  
  
  1. //更好的释放内存
    2. 
  
  
  
  
  2.  private WeakReference mInflatedViewRef;
    3. 
  
  
  
  
  3.  mInflatedViewRef = new WeakReference<>(view);
    4. 
  
  
  
  
  4.                if (mInflateListener != null) {
    5. 
  
  
  
  
  5.               mInflateListener.onInflate(this, view)
    6. 
  
  
  
  
  6.  }
    7.

为啥setVisibility(View.VISIBLE)等同于inflate,原因是ViewStub进行了重写。可以看出代码的逻辑，只要没有调用过，inflate()方法，setVisibility(VISIBLE )和setVisibility(INVISIBLE)这个两个参数走的方法一样，只不过，一个看不到，实际上的位置已经确定了(INVISIBLE)。但是如果调用多次的话setVisibility()记得也得判断下null!=mViewStub.getParent()

 
 
 
 
    
  
  
  
  
  1. @Override
    2. 
  
  
  
  
  2.     @android.view.RemotableViewMethod(asyncImpl = "setVisibilityAsync")
    3. 
  
  
  
  
  3.     public void setVisibility(int visibility) {
    4. 
  
  
  
  
  4.         // TODO: 2018/5/23  弱引用的使用
    5. 
  
  
  
  
  5.         //如果已经加载过则只设置Visibility属性
    6. 
  
  
  
  
  6.         if (mInflatedViewRef != null) {
    7. 
  
  
  
  
  7.             View view = mInflatedViewRef.get();
    8. 
  
  
  
  
  8.             if (view != null) {
    9. 
  
  
  
  
  9.                 view.setVisibility(visibility);
    10. 
  
  
  
  
  10.             } else {
    11. 
  
  
  
  
  11.                 throw new IllegalStateException("setVisibility called on un-referenced view");
    12. 
  
  
  
  
  12.             }
    13. 
  
  
  
  
  13.         } else {
    14. 
  
  
  
  
  14.             // 如果未加载,这加载目标布局
    15. 
  
  
  
  
  15.             super.setVisibility(visibility);
    16. 
  
  
  
  
  16.             if (visibility == VISIBLE || visibility == INVISIBLE) {
    17. 
  
  
  
  
  17.                 inflate();// 调用inflate来加载目标布局
    18. 
  
  
  
  
  18.             }
    19. 
  
  
  
  
  19.         }
    20. 
  
  
  
  
  20.     }
    21.

贴出全部的代码，有空的话，可以研究下。

 
 
 
 
    
  
  
  
  
  1. @RemoteView
    2. 
  
  
  
  
  2. public final class ViewStub extends View {
    3. 
  
  
  
  
  3.     private int mInflatedId;
    4. 
  
  
  
  
  4.     private int mLayoutResource;
    5. 
  
  
  
  
  5.     // TODO: 2018/5/23 弱引用：弱引用是比软引用更弱的一种的引用的类型，
    6. 
  
  
  
  
  6.     // 只有弱引用指向的对象的生命周期更短，当垃圾回收器扫描到只有具有弱引用的对象的时候，
    7. 
  
  
  
  
  7.     // 不敢当前空间是否不足，都会对弱引用对象进行回收，当然弱引用也可以和一个队列配合着使用
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     //更好的释放内存
    10. 
  
  
  
  
  10.     private WeakReference mInflatedViewRef;
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     private LayoutInflater mInflater;
    13. 
  
  
  
  
  13.     private OnInflateListener mInflateListener;
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     public ViewStub(Context context) {
    16. 
  
  
  
  
  16.         this(context, 0);
    17. 
  
  
  
  
  17.     }
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.     /**
    20. 
  
  
  
  
  20.      * Creates a new ViewStub with the specified layout resource.
    21. 
  
  
  
  
  21.      *
    22. 
  
  
  
  
  22.      * @param context The application's environment.
    23. 
  
  
  
  
  23.      * @param layoutResource The reference to a layout resource that will be inflated.
    24. 
  
  
  
  
  24.      */
    25. 
  
  
  
  
  25.     public ViewStub(Context context, @LayoutRes int layoutResource) {
    26. 
  
  
  
  
  26.         this(context, null);
    27. 
  
  
  
  
  27. 
  
  
  
  
  28.         mLayoutResource = layoutResource;
    29. 
  
  
  
  
  29.     }
    30. 
  
  
  
  
  30. 
  
  
  
  
  31.     public ViewStub(Context context, AttributeSet attrs) {
    32. 
  
  
  
  
  32.         this(context, attrs, 0);
    33. 
  
  
  
  
  33.     }
    34. 
  
  
  
  
  34. 
  
  
  
  
  35.     public ViewStub(Context context, AttributeSet attrs, int defStyleAttr) {
    36. 
  
  
  
  
  36.         this(context, attrs, defStyleAttr, 0);
    37. 
  
  
  
  
  37.     }
    38. 
  
  
  
  
  38. 
  
  
  
  
  39.     public ViewStub(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    40. 
  
  
  
  
  40.         super(context);
    41. 
  
  
  
  
  41. 
  
  
  
  
  42.         final TypedArray a = context.obtainStyledAttributes(attrs,
    43. 
  
  
  
  
  43.                 R.styleable.ViewStub, defStyleAttr, defStyleRes);
    44. 
  
  
  
  
  44.         // TODO: 2018/5/23  ViewStub 中设置的标签id 如果设置了 这里就一定有值 mInflatedId！=NO_Id
    45. 
  
  
  
  
  45.         mInflatedId = a.getResourceId(R.styleable.ViewStub_inflatedId, NO_ID);
    46. 
  
  
  
  
  46.         mLayoutResource = a.getResourceId(R.styleable.ViewStub_layout, 0);
    47. 
  
  
  
  
  47.         mID = a.getResourceId(R.styleable.ViewStub_id, NO_ID);
    48. 
  
  
  
  
  48.         a.recycle();
    49. 
  
  
  
  
  49.         //不可见
    50. 
  
  
  
  
  50.         setVisibility(GONE);
    51. 
  
  
  
  
  51.         // 设置不绘制
    52. 
  
  
  
  
  52.         setWillNotDraw(true);
    53. 
  
  
  
  
  53.     }
    54. 
  
  
  
  
  54. 
  
  
  
  
  55.     /**
    56. 
  
  
  
  
  56.      * Returns the id taken by the inflated view. If the inflated id is
    57. 
  
  
  
  
  57.      * {@link View#NO_ID}, the inflated view keeps its original id.
    58. 
  
  
  
  
  58.      *
    59. 
  
  
  
  
  59.      * @return A positive integer used to identify the inflated view or
    60. 
  
  
  
  
  60.      *         {@link #NO_ID} if the inflated view should keep its id.
    61. 
  
  
  
  
  61.      *
    62. 
  
  
  
  
  62.      * @see #setInflatedId(int)
    63. 
  
  
  
  
  63.      * @attr ref android.R.styleable#ViewStub_inflatedId
    64. 
  
  
  
  
  64.      */
    65. 
  
  
  
  
  65.     @IdRes
    66. 
  
  
  
  
  66.     public int getInflatedId() {
    67. 
  
  
  
  
  67.         return mInflatedId;
    68. 
  
  
  
  
  68.     }
    69. 
  
  
  
  
  69. 
  
  
  
  
  70.     /**
    71. 
  
  
  
  
  71.      * Defines the id taken by the inflated view. If the inflated id is
    72. 
  
  
  
  
  72.      * {@link View#NO_ID}, the inflated view keeps its original id.
    73. 
  
  
  
  
  73.      *
    74. 
  
  
  
  
  74.      * @param inflatedId A positive integer used to identify the inflated view or
    75. 
  
  
  
  
  75.      *                   {@link #NO_ID} if the inflated view should keep its id.
    76. 
  
  
  
  
  76.      *
    77. 
  
  
  
  
  77.      * @see #getInflatedId()
    78. 
  
  
  
  
  78.      * @attr ref android.R.styleable#ViewStub_inflatedId
    79. 
  
  
  
  
  79.      */
    80. 
  
  
  
  
  80.     @android.view.RemotableViewMethod(asyncImpl = "setInflatedIdAsync")
    81. 
  
  
  
  
  81.     public void setInflatedId(@IdRes int inflatedId) {
    82. 
  
  
  
  
  82.         mInflatedId = inflatedId;
    83. 
  
  
  
  
  83.     }
    84. 
  
  
  
  
  84. 
  
  
  
  
  85.     /** @hide **/
    86. 
  
  
  
  
  86.     public Runnable setInflatedIdAsync(@IdRes int inflatedId) {
    87. 
  
  
  
  
  87.         mInflatedId = inflatedId;
    88. 
  
  
  
  
  88.         return null;
    89. 
  
  
  
  
  89.     }
    90. 
  
  
  
  
  90. 
  
  
  
  
  91.     /**
    92. 
  
  
  
  
  92.      * Returns the layout resource that will be used by {@link #setVisibility(int)} or
    93. 
  
  
  
  
  93.      * {@link #inflate()} to replace this StubbedView
    94. 
  
  
  
  
  94.      * in its parent by another view.
    95. 
  
  
  
  
  95.      *
    96. 
  
  
  
  
  96.      * @return The layout resource identifier used to inflate the new View.
    97. 
  
  
  
  
  97.      *
    98. 
  
  
  
  
  98.      * @see #setLayoutResource(int)
    99. 
  
  
  
  
  99.      * @see #setVisibility(int)
    100. 
  
  
  
  
  100.      * @see #inflate()
    101. 
  
  
  
  
  101.      * @attr ref android.R.styleable#ViewStub_layout
    102. 
  
  
  
  
  102.      */
    103. 
  
  
  
  
  103.     @LayoutRes
    104. 
  
  
  
  
  104.     public int getLayoutResource() {
    105. 
  
  
  
  
  105.         return mLayoutResource;
    106. 
  
  
  
  
  106.     }
    107. 
  
  
  
  
  107. 
  
  
  
  
  108.     /**
    109. 
  
  
  
  
  109.      * Specifies the layout resource to inflate when this StubbedView becomes visible or invisible
    110. 
  
  
  
  
  110.      * or when {@link #inflate()} is invoked. The View created by inflating the layout resource is
    111. 
  
  
  
  
  111.      * used to replace this StubbedView in its parent.
    112. 
  
  
  
  
  112.      *
    113. 
  
  
  
  
  113.      * @param layoutResource A valid layout resource identifier (different from 0.)
    114. 
  
  
  
  
  114.      *
    115. 
  
  
  
  
  115.      * @see #getLayoutResource()
    116. 
  
  
  
  
  116.      * @see #setVisibility(int)
    117. 
  
  
  
  
  117.      * @see #inflate()
    118. 
  
  
  
  
  118.      * @attr ref android.R.styleable#ViewStub_layout
    119. 
  
  
  
  
  119.      */
    120. 
  
  
  
  
  120.     @android.view.RemotableViewMethod(asyncImpl = "setLayoutResourceAsync")
    121. 
  
  
  
  
  121.     public void setLayoutResource(@LayoutRes int layoutResource) {
    122. 
  
  
  
  
  122.         mLayoutResource = layoutResource;
    123. 
  
  
  
  
  123.     }
    124. 
  
  
  
  
  124. 
  
  
  
  
  125.     /** @hide **/
    126. 
  
  
  
  
  126.     public Runnable setLayoutResourceAsync(@LayoutRes int layoutResource) {
    127. 
  
  
  
  
  127.         mLayoutResource = layoutResource;
    128. 
  
  
  
  
  128.         return null;
    129. 
  
  
  
  
  129.     }
    130. 
  
  
  
  
  130. 
  
  
  
  
  131.     /**
    132. 
  
  
  
  
  132.      * Set {@link LayoutInflater} to use in {@link #inflate()}, or {@code null}
    133. 
  
  
  
  
  133.      * to use the default.
    134. 
  
  
  
  
  134.      */
    135. 
  
  
  
  
  135.     public void setLayoutInflater(LayoutInflater inflater) {
    136. 
  
  
  
  
  136.         mInflater = inflater;
    137. 
  
  
  
  
  137.     }
    138. 
  
  
  
  
  138. 
  
  
  
  
  139.     /**
    140. 
  
  
  
  
  140.      * Get current {@link LayoutInflater} used in {@link #inflate()}.
    141. 
  
  
  
  
  141.      */
    142. 
  
  
  
  
  142.     public LayoutInflater getLayoutInflater() {
    143. 
  
  
  
  
  143.         return mInflater;
    144. 
  
  
  
  
  144.     }
    145. 
  
  
  
  
  145. 
  
  
  
  
  146.     @Override
    147. 
  
  
  
  
  147.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    148. 
  
  
  
  
  148.         // 宽高都为0   onMeasure的时候 宽高都为0
    149. 
  
  
  
  
  149.         setMeasuredDimension(0, 0);
    150. 
  
  
  
  
  150.     }
    151. 
  
  
  
  
  151.     //todo 为啥这个控件 是个大小为0的控件 ，那是因为他妈的这里更不就没有画
    152. 
  
  
  
  
  152.     @Override
    153. 
  
  
  
  
  153.     public void draw(Canvas canvas) {
    154. 
  
  
  
  
  154.     }
    155. 
  
  
  
  
  155. 
  
  
  
  
  156.     @Override
    157. 
  
  
  
  
  157.     protected void dispatchDraw(Canvas canvas) {
    158. 
  
  
  
  
  158.     }
    159. 
  
  
  
  
  159. 
  
  
  
  
  160.     /**
    161. 
  
  
  
  
  161.      * When visibility is set to {@link #VISIBLE} or {@link #INVISIBLE},
    162. 
  
  
  
  
  162.      * {@link #inflate()} is invoked and this StubbedView is replaced in its parent
    163. 
  
  
  
  
  163.      * by the inflated layout resource. After that calls to this function are passed
    164. 
  
  
  
  
  164.      * through to the inflated view.
    165. 
  
  
  
  
  165.      *
    166. 
  
  
  
  
  166.      * @param visibility One of {@link #VISIBLE}, {@link #INVISIBLE}, or {@link #GONE}.
    167. 
  
  
  
  
  167.      *
    168. 
  
  
  
  
  168.      * @see #inflate()
    169. 
  
  
  
  
  169.      */
    170. 
  
  
  
  
  170.     @Override
    171. 
  
  
  
  
  171.     @android.view.RemotableViewMethod(asyncImpl = "setVisibilityAsync")
    172. 
  
  
  
  
  172.     public void setVisibility(int visibility) {
    173. 
  
  
  
  
  173.         // TODO: 2018/5/23  弱引用的使用
    174. 
  
  
  
  
  174.         //如果已经加载过则只设置Visibility属性
    175. 
  
  
  
  
  175.         if (mInflatedViewRef != null) {
    176. 
  
  
  
  
  176.             View view = mInflatedViewRef.get();
    177. 
  
  
  
  
  177.             if (view != null) {
    178. 
  
  
  
  
  178.                 view.setVisibility(visibility);
    179. 
  
  
  
  
  179.             } else {
    180. 
  
  
  
  
  180.                 throw new IllegalStateException("setVisibility called on un-referenced view");
    181. 
  
  
  
  
  181.             }
    182. 
  
  
  
  
  182.         } else {
    183. 
  
  
  
  
  183.             // 如果未加载,这加载目标布局
    184. 
  
  
  
  
  184.             super.setVisibility(visibility);
    185. 
  
  
  
  
  185.             if (visibility == VISIBLE || visibility == INVISIBLE) {
    186. 
  
  
  
  
  186.                 inflate();// 调用inflate来加载目标布局
    187. 
  
  
  
  
  187.             }
    188. 
  
  
  
  
  188.         }
    189. 
  
  
  
  
  189.     }
    190. 
  
  
  
  
  190. 
  
  
  
  
  191.     /** @hide **/
    192. 
  
  
  
  
  192.     public Runnable setVisibilityAsync(int visibility) {
    193. 
  
  
  
  
  193.         if (visibility == VISIBLE || visibility == INVISIBLE) {
    194. 
  
  
  
  
  194.             ViewGroup parent = (ViewGroup) getParent();
    195. 
  
  
  
  
  195.             return new ViewReplaceRunnable(inflateViewNoAdd(parent));
    196. 
  
  
  
  
  196.         } else {
    197. 
  
  
  
  
  197.             return null;
    198. 
  
  
  
  
  198.         }
    199. 
  
  
  
  
  199.     }
    200. 
  
  
  
  
  200. 
  
  
  
  
  201.     private View inflateViewNoAdd(ViewGroup parent) {
    202. 
  
  
  
  
  202.         final LayoutInflater factory;
    203. 
  
  
  
  
  203.         if (mInflater != null) {
    204. 
  
  
  
  
  204.             factory = mInflater;
    205. 
  
  
  
  
  205.         } else {
    206. 
  
  
  
  
  206.             factory = LayoutInflater.from(mContext);
    207. 
  
  
  
  
  207.         }
    208. 
  
  
  
  
  208.         final View view = factory.inflate(mLayoutResource, parent, false);
    209. 
  
  
  
  
  209.         //和 LayoutInflater一个道理，设置了，ViewStub 引用进来的根布局的id找出来为null  非常有些意思
    210. 
  
  
  
  
  210.         if (mInflatedId != NO_ID) {
    211. 
  
  
  
  
  211.             view.setId(mInflatedId);
    212. 
  
  
  
  
  212.         }
    213. 
  
  
  
  
  213.         return view;
    214. 
  
  
  
  
  214.     }
    215. 
  
  
  
  
  215. 
  
  
  
  
  216.     // TODO: 2018/5/23 关注他
    217. 
  
  
  
  
  217.     private void replaceSelfWithView(View view, ViewGroup parent) {
    218. 
  
  
  
  
  218.         final int index = parent.indexOfChild(this);
    219. 
  
  
  
  
  219.         // 3、将ViewStub自身从parent中移除
    220. 
  
  
  
  
  220.         parent.removeViewInLayout(this);
    221. 
  
  
  
  
  221. 
  
  
  
  
  222.         final ViewGroup.LayoutParams layoutParams = getLayoutParams();
    223. 
  
  
  
  
  223.         if (layoutParams != null) {
    224. 
  
  
  
  
  224.             // 4、将目标布局的根元素添加到parent中，有参数
    225. 
  
  
  
  
  225.             parent.addView(view, index, layoutParams);
    226. 
  
  
  
  
  226.         } else {
    227. 
  
  
  
  
  227.            // 5、将目标布局的根元素添加到parent中
    228. 
  
  
  
  
  228.             parent.addView(view, index);
    229. 
  
  
  
  
  229.         }
    230. 
  
  
  
  
  230.     }
    231. 
  
  
  
  
  231. 
  
  
  
  
  232.     /**
    233. 
  
  
  
  
  233.      * Inflates the layout resource identified by {@link #getLayoutResource()}
    234. 
  
  
  
  
  234.      * and replaces this StubbedView in its parent by the inflated layout resource.
    235. 
  
  
  
  
  235.      *
    236. 
  
  
  
  
  236.      * @return The inflated layout resource.
    237. 
  
  
  
  
  237.      *
    238. 
  
  
  
  
  238.      */
    239. 
  
  
  
  
  239.     public View inflate() {
    240. 
  
  
  
  
  240.         // 1、获取ViewStub的parent view，也是目标布局根元素的parent view
    241. 
  
  
  
  
  241.         final ViewParent viewParent = getParent();
    242. 
  
  
  
  
  242. 
  
  
  
  
  243.         if (viewParent != null && viewParent instanceof ViewGroup) {
    244. 
  
  
  
  
  244.             if (mLayoutResource != 0) {
    245. 
  
  
  
  
  245.                 final ViewGroup parent = (ViewGroup) viewParent;
    246. 
  
  
  
  
  246.                 /// 2、加载目标布局  牛逼的方法
    247. 
  
  
  
  
  247.                 final View view = inflateViewNoAdd(parent);
    248. 
  
  
  
  
  248.                 // 3、将ViewStub自身从parent中移除
    249. 
  
  
  
  
  249.                 replaceSelfWithView(view, parent);
    250. 
  
  
  
  
  250. 
  
  
  
  
  251.                 mInflatedViewRef = new WeakReference<>(view);
    252. 
  
  
  
  
  252.                 if (mInflateListener != null) {
    253. 
  
  
  
  
  253.                     mInflateListener.onInflate(this, view);
    254. 
  
  
  
  
  254.                 }
    255. 
  
  
  
  
  255. 
  
  
  
  
  256.                 return view;
    257. 
  
  
  
  
  257.             } else {
    258. 
  
  
  
  
  258.                 // TODO: 2018/5/23 必须设置布局的文件
    259. 
  
  
  
  
  259.                 throw new IllegalArgumentException("ViewStub must have a valid layoutResource");
    260. 
  
  
  
  
  260.             }
    261. 
  
  
  
  
  261.         } else {
    262. 
  
  
  
  
  262.             // TODO: 2018/5/23 iewParent instanceof ViewGroup 不属于的话，就好比在一个TextView创建一个ViewStub直接爆炸
    263. 
  
  
  
  
  263.             throw new IllegalStateException("ViewStub must have a non-null ViewGroup viewParent");
    264. 
  
  
  
  
  264.         }
    265. 
  
  
  
  
  265.     }
    266. 
  
  
  
  
  266. 
  
  
  
  
  267.     /**
    268. 
  
  
  
  
  268.      * Specifies the inflate listener to be notified after this ViewStub successfully
    269. 
  
  
  
  
  269.      * inflated its layout resource.
    270. 
  
  
  
  
  270.      *
    271. 
  
  
  
  
  271.      * @param inflateListener The OnInflateListener to notify of successful inflation.
    272. 
  
  
  
  
  272.      *
    273. 
  
  
  
  
  273.      * @see ViewStub.OnInflateListener
    274. 
  
  
  
  
  274.      */
    275. 
  
  
  
  
  275.     public void setOnInflateListener(OnInflateListener inflateListener) {
    276. 
  
  
  
  
  276.         mInflateListener = inflateListener;
    277. 
  
  
  
  
  277.     }
    278. 
  
  
  
  
  278. 
  
  
  
  
  279.     /**
    280. 
  
  
  
  
  280.      * Listener used to receive a notification after a ViewStub has successfully
    281. 
  
  
  
  
  281.      * inflated its layout resource.
    282. 
  
  
  
  
  282.      *
    283. 
  
  
  
  
  283.      * @see ViewStub#setOnInflateListener(ViewStub.OnInflateListener)
    284. 
  
  
  
  
  284.      */
    285. 
  
  
  
  
  285.     public static interface OnInflateListener {
    286. 
  
  
  
  
  286.         /**
    287. 
  
  
  
  
  287.          * Invoked after a ViewStub successfully inflated its layout resource. 
                分享文章：基于Android8.0分析源码的ViewStub源码解析
                
    
                转载来源：http://www.hantingmc.com/qtweb/news27/218077.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

App设计知识

各行业网站

seo优化　　 　中国西部信息中心　　 　成都广告招牌　　 　成都网站设计　　 　成都网站安全运维　　 　泸州做网站　　 　渠县网站建设　　 　广汉锦华橡塑　　 　移动网站建设　　 　做网站公司　　 　成都服务器租用　　 　遂宁海缘科技　　 　成都网站推广　　 　香港虚拟主机空间　　 　成都网页设计　　 　四川电信高防服务器托管　　 　梦港之夜　　 　华川商务　　 　眉山电信机房　　 　网站推广