DataBind原理篇

深藏阁楼爱情的钟 2022-09-12 09:49 310阅读 0赞

## 1、APT预编译 ##

> APT(Annotation Processing Tool)即注解处理器，是一种处理注解的工具，确切的说它是javac的一个工具，它用来在编译时扫描和处理注解。注解处理器以Java代码(或者编译过的字节码)作为输入，生成.java文件作为输出。简单来说就是在编译期，通过注解生成.java文件。当你的xml用DataBinding规定的格式去书写的时候，DataBinding就能够通过APT的技术，帮你生成对应的类文件。

### 两个xml文件 ###

**在编译时，DataBinding会处理布局文件，重新生成两个全新的布局文件。一个与原文件同名，另一个是在原文件名加-layout， xxxxx-layout.xml。**

--------------------

**与原文件同名的xml**

可以看出，新的xml与不用DataBinding前的布局文件差不多，唯一的区别是加了tag标记,这个tag后序代码分析的时候会用到，并且布局中的控件如果使用了@\{\}来进行操作的，相应的控件也会生成一个tag 。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

**加-layout的xml文件**  
生成的activity\_main-layout.xml文件，是DataBinding生成的配置文件，包含了数据绑定相关的信息。Variables与Imports和布局文件中的variable与import标签对应，Targets标签则告诉VM变化时对应的V、绑定关系是单向还是双向的以及DataBinding的表达式Expressions。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

### DataBinderMapperImpl类 ###

**当我们使用了Databinding，编译时，Databinding会通过APT(Annotation Processing Tool注解处理器)在build目录下生成以一些文件:**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

## 2 代码分析 ##

### 2.1 绑定过程 ###

**获取ViewDataBinding对象的入口方法**

protected void onCreate(@Nullable Bundle savedInstanceState) { 
            dataBinding = DataBindingUtil.setContentView(this,R.layout.activity_databinding);
    }

**往下走会调用DataBindingUtil类中的setContentView方法，获取到加载页面布局的容器content，并执行bindToAddedViews方法来生成ViewDataBinding对象**

public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
                int layoutId, @Nullable DataBindingComponent bindingComponent) { 
            activity.setContentView(layoutId);
            View decorView = activity.getWindow().getDecorView();
            ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
            return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
        }

**bindToAddedViews方法中调用sMapper对象的getDataBinder方法**

static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View root,
                int layoutId) { 
            return (T) sMapper.getDataBinder(bindingComponent, root, layoutId);
        }

**sMapper对像的类型是DataBinderMapperImpl它又继承了MergedDataBinderMapper，并且在构造方法中调用了父类的addMapper方法**

public class DataBindingUtil { 
        private static DataBinderMapper sMapper = new DataBinderMapperImpl();
    }

public class DataBinderMapperImpl extends MergedDataBinderMapper { 
      DataBinderMapperImpl() { 
        addMapper(new com.example.myapplication.DataBinderMapperImpl());
      }
    }

**MergedDataBinderMapper的addMapper方法就将将提供的mapper添加到mappers列表中**

private Set<Class<? extends DataBinderMapper>> mExistingMappers = new HashSet<>();
        private List<DataBinderMapper> mMappers = new CopyOnWriteArrayList<>();
    
        public void addMapper(DataBinderMapper mapper) { 
            Class<? extends DataBinderMapper> mapperClass = mapper.getClass();
            if (mExistingMappers.add(mapperClass)) { 
                mMappers.add(mapper);
                final List<DataBinderMapper> dependencies = mapper.collectDependencies();
                for(DataBinderMapper dependency : dependencies) { 
                    addMapper(dependency);
                }
            }
        }

**所以最终sMapper调用getDataBinder方法实际上调用的是MergedDataBinderMapper中的getDataBinder，MergedDataBinderMapper中的getDataBinder方法只是把数组中的mapper对象遍历一下，然后分别调用各自mapper的getDataBinder方法**

@Override
        public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
                int layoutId) { 
            for(DataBinderMapper mapper : mMappers) { 
                ViewDataBinding result = mapper.getDataBinder(bindingComponent, view, layoutId);
                if (result != null) { 
                    return result;
                }
            }
            if (loadFeatures()) { 
                return getDataBinder(bindingComponent, view, layoutId);
            }
            return null;
        }

**所以上面的sMapper调用getDataBinder方法最终调用的是DataBinderMapperImpl中的getDataBinder方法，最后返回了一个xxxxBindingImpl对象，这两个类我们上面看过是DataBinding通过Apt在编译的时候生成的类**

public class DataBinderMapperImpl extends DataBinderMapper { 
      private static final int LAYOUT_ACTIVITYDATABINDING = 1;
      private static final SparseIntArray INTERNAL_LAYOUT_ID_LOOKUP = new SparseIntArray(4);
    
      static { 
      INTERNAL_LAYOUT_ID_LOOKUP.put(com.example.myapplication.R.layout.activity_databinding, LAYOUT_ACTIVITYDATABINDING);
      }
    
      @Override
      public ViewDataBinding getDataBinder(DataBindingComponent component, View view, int layoutId) { 
        int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
        if(localizedLayoutId > 0) { 
          final Object tag = view.getTag();
          if(tag == null) { 
            throw new RuntimeException("view must have a tag");
          }
          switch(localizedLayoutId) { 
            case  LAYOUT_ACTIVITYDATABINDING: { 
              if ("layout/activity_databinding_0".equals(tag)) { 
                return new ActivityDatabindingBindingImpl(component, view);
              }
              throw new IllegalArgumentException("The tag for activity_databinding is invalid. Received: " + tag);
            }
            
          }
        }
        return null;
      }
    }

**我们在看一下xxxxBindingImpl类，这里我xml文件名字对应生成的是ActivityDatabindingBindingImpl类,它是生成ViewDataBinding的功能类，它的父类xxxxxBinding的也就是ActivityDatabindingBinding是个抽象类是ViewDataBinding的子类**

**1 、公共的构造方法中通过mpaBinds方法来生成了一个对象数据，其实就是创建我们在xml中中写了id的或者用@\{\}操作的控件**

public class ActivityDatabindingBindingImpl extends ActivityDatabindingBinding implements com.example.myapplication.generated.callback.OnClickListener.Listener, com.example.myapplication.generated.callback.AfterTextChanged.Listener { 
     public ActivityDatabindingBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) { 
            this(bindingComponent, root, mapBindings(bindingComponent, root, 8, sIncludes, sViewsWithIds));
        }
    }

**2、mpaBinds方法，从根节点一个一个解析保存到bindings数组里面。根据tag信息字段对应节点是什么控件**

protected static Object[] mapBindings(DataBindingComponent bindingComponent, View[] roots,
                int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) { 
            Object[] bindings = new Object[numBindings];
            for (int i = 0; i < roots.length; i++) { 
                mapBindings(bindingComponent, roots[i], bindings, includes, viewsWithIds, true);
            }
            return bindings;
        }

private static void mapBindings(DataBindingComponent bindingComponent, View view,
                Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
                boolean isRoot) { 
            final int indexInIncludes;
            //根据tag查看是否存在
            final ViewDataBinding existingBinding = getBinding(view);
            if (existingBinding != null) { 
                return;
            }
            Object objTag = view.getTag();
            final String tag = (objTag instanceof String) ? (String) objTag : null;
            boolean isBound = false;
            // 如果是根view，则判断根view的tag是否以layout开头
            if (isRoot && tag != null && tag.startsWith("layout")) { 
                final int underscoreIndex = tag.lastIndexOf('_');
                //解析根view的tag，将view放到数组的指定位置(位置由xml中的tag后缀数字确定)
                if (underscoreIndex > 0 && isNumeric(tag, underscoreIndex + 1)) { 
                    final int index = parseTagInt(tag, underscoreIndex + 1);
                    if (bindings[index] == null) { 
                        bindings[index] = view;
                    }
                    // 确定绑定布局文件存在include元素布局所在位置
                    indexInIncludes = includes == null ? -1 : index;
                    isBound = true;
                } else { 
                    indexInIncludes = -1;
                }
            } else if (tag != null && tag.startsWith(BINDING_TAG_PREFIX)) { 
            	// 如果tag以binding_开头，说明需要绑定类持有，所以赋值
                int tagIndex = parseTagInt(tag, BINDING_NUMBER_START);
                if (bindings[tagIndex] == null) { 
                    bindings[tagIndex] = view;
                }
                isBound = true;
                indexInIncludes = includes == null ? -1 : tagIndex;
            } else { 
                // Not a bound view
                indexInIncludes = -1;
            }
            if (!isBound) { 
                final int id = view.getId();
                if (id > 0) { 
                    int index;
                    // 如果xml中view声明了id，绑定类也是需要持有该view
                    if (viewsWithIds != null && (index = viewsWithIds.get(id, -1)) >= 0 &&
                            bindings[index] == null) { 
                        bindings[index] = view;
                    }
                }
            }
    		// 下面的依次递归遍历，逻辑和上面类似
            if (view instanceof  ViewGroup) { 
                final ViewGroup viewGroup = (ViewGroup) view;
                final int count = viewGroup.getChildCount();
                int minInclude = 0;
                for (int i = 0; i < count; i++) { 
                    final View child = viewGroup.getChildAt(i);
                    boolean isInclude = false;
                    if (indexInIncludes >= 0 && child.getTag() instanceof String) { 
                        String childTag = (String) child.getTag();
                        // include布局根view的tag格式:layout/${layout_name}_0
                        if (childTag.endsWith("_0") &&
                                childTag.startsWith("layout") && childTag.indexOf('/') > 0) { 
                            // This *could* be an include. Test against the expected includes.
                            int includeIndex = findIncludeIndex(childTag, minInclude,
                                    includes, indexInIncludes);
                            if (includeIndex >= 0) { 
                                isInclude = true;
                                minInclude = includeIndex + 1;
                                final int index = includes.indexes[indexInIncludes][includeIndex];
                                final int layoutId = includes.layoutIds[indexInIncludes][includeIndex];
                                int lastMatchingIndex = findLastMatching(viewGroup, i);
                                if (lastMatchingIndex == i) { 
                                    bindings[index] = DataBindingUtil.bind(bindingComponent, child,
                                            layoutId);
                                } else { 
                                    final int includeCount =  lastMatchingIndex - i + 1;
                                    final View[] included = new View[includeCount];
                                    for (int j = 0; j < includeCount; j++) { 
                                        included[j] = viewGroup.getChildAt(i + j);
                                    }
                                    bindings[index] = DataBindingUtil.bind(bindingComponent, included,
                                            layoutId);
                                    i += includeCount - 1;
                                }
                            }
                        }
                    }
                    if (!isInclude) { 
                        mapBindings(bindingComponent, child, bindings, includes, viewsWithIds, false);
                    }
                }
            }
        }

**3、在通过super()父类的构造方法给各个控件赋值，没有使用我们熟悉的findViewByid操作**

private ActivityDatabindingBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) { 
            super(bindingComponent, root, 4
                , (android.widget.Button) bindings[3]
                , (android.widget.EditText) bindings[1]
                , (android.widget.EditText) bindings[2]
                , (android.widget.TextView) bindings[6]
                , (android.widget.TextView) bindings[7]
                , (android.widget.TextView) bindings[4]
                , (android.widget.TextView) bindings[5]
                );
            this.btnLogin.setTag(null);
            this.etUserName.setTag(null);
            this.etUserPsw.setTag(null);
            this.mboundView0 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[0];
            this.mboundView0.setTag(null);
            setRootTag(root);
            // listeners
            mCallback2 = new com.example.myapplication.generated.callback.OnClickListener(this, 2);
            mCallback1 = new com.example.myapplication.generated.callback.AfterTextChanged(this, 1);
            invalidateAll();
        }

**4、具体给控件赋值是在ActivityDatabindingBinding中**

public abstract class ActivityDatabindingBinding extends ViewDataBinding { 
      @NonNull
      public final Button btnLogin;
    
      @NonNull
      public final EditText etUserName;
    
      @NonNull
      public final EditText etUserPsw;
    
      @NonNull
      public final TextView tvChangeName;
    
      @NonNull
      public final TextView tvChangePsw;
    
      @NonNull
      public final TextView tvUserName;
    
      @NonNull
      public final TextView tvUserPsw;
    
      @Bindable
      protected ObservableList<String> mList;
    
      @Bindable
      protected ObservableMap<String, String> mMap;
    
      @Bindable
      protected User mUserBean;
    
      @Bindable
      protected TestDataBinding.Listenter mListener;
    
      @Bindable
      protected View.OnClickListener mClickListener;
    
      protected ActivityDatabindingBinding(Object _bindingComponent, View _root, int _localFieldCount,
          Button btnLogin, EditText etUserName, EditText etUserPsw, TextView tvChangeName,
          TextView tvChangePsw, TextView tvUserName, TextView tvUserPsw) { 
        super(_bindingComponent, _root, _localFieldCount);
        this.btnLogin = btnLogin;
        this.etUserName = etUserName;
        this.etUserPsw = etUserPsw;
        this.tvChangeName = tvChangeName;
        this.tvChangePsw = tvChangePsw;
        this.tvUserName = tvUserName;
        this.tvUserPsw = tvUserPsw;
      }

**6、然后，我们在回来，赋值成功后对于子view擦除tag，对于根view则将绑定类绑定到tag中，创建设置的点击事件和其他交互事件，后面是对view的重绘了，调用了 invalidateAll()方法**

**7、 invalidateAll()**

@Override
        public void invalidateAll() { 
            synchronized(this) { 
                    mDirtyFlags = 0x80L;
            }
            requestRebind();
        }

**8、ViewDataBinding类中 requestRebind()**

private static final boolean USE_CHOREOGRAPHER = SDK_INT >= 16;
    
    
      protected void requestRebind() { 
            if (mContainingBinding != null) { 
                mContainingBinding.requestRebind();
            } else { 
                final LifecycleOwner owner = this.mLifecycleOwner;
                if (owner != null) { 
                    Lifecycle.State state = owner.getLifecycle().getCurrentState();
                    if (!state.isAtLeast(Lifecycle.State.STARTED)) { 
                        return; // wait until lifecycle owner is started
                    }
                }
                synchronized (this) { 
                    if (mPendingRebind) { 
                        return;
                    }
                    mPendingRebind = true;
                }
                // 如果设备系统 SDK 版本高于 16就用 mChoreographer 来渲染
                if (USE_CHOREOGRAPHER) { 
                    mChoreographer.postFrameCallback(mFrameCallback);
                } else { 
                	// 使用 UI主线程的 Handler 来运行 Runnable
                    mUIThreadHandler.post(mRebindRunnable);
                }
            }
        }

**8、 这里我们只看SDK大于16的方式，mChoreographer.postFrameCallback()**

mChoreographer.postFrameCallback(mFrameCallback);

public void postFrameCallback(FrameCallback callback) { 
            postFrameCallbackDelayed(callback, 0);
        }

**9、我们看一下参数FrameCallback ，发现是在ViewDataBinding类的构造方式中实现的,FrameCallback是Choreographer类中的一个接口，声明了一个doFrame方法，这里doFrame方法中执行了一个mRebindRunnable的run方法**

protected ViewDataBinding(DataBindingComponent bindingComponent, View root, int localFieldCount) { 
        	...
            if (USE_CHOREOGRAPHER) { 
                mChoreographer = Choreographer.getInstance();
                mFrameCallback = new Choreographer.FrameCallback() { 
                    @Override
                    public void doFrame(long frameTimeNanos) { 
                        mRebindRunnable.run();
                    }
                };
            } else { 
                mFrameCallback = null;
                mUIThreadHandler = new Handler(Looper.myLooper());
            }
        }

**10、看一下ViewDataBinding类中mRebindRunnable的具体实现**

private final Runnable mRebindRunnable = new Runnable() { 
            @Override
            public void run() { 
                synchronized (this) { 
                    mPendingRebind = false;
                }
                processReferenceQueue();
    
                if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) { 
                    // Nested so that we don't get a lint warning in IntelliJ
                    if (!mRoot.isAttachedToWindow()) { 
                        // Don't execute the pending bindings until the View
                        // is attached again.
                        mRoot.removeOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
                        mRoot.addOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
                        return;
                    }
                }
                executePendingBindings();
            }
        };

**11. 了解了这个callback 和 Runnable后，继续看第8步中逻辑，之后逻辑就是把callback赋值给CallbackQueue 对象中 CallbackRecord 对象 mHead，然后通过handler 找到对应的CallbackRecord对象并调用其run方法，也就是callback的doframe方法**

public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis) { 
          ...
            postCallbackDelayedInternal(CALLBACK_ANIMATION,
                    callback, FRAME_CALLBACK_TOKEN, delayMillis);
        }

private void postCallbackDelayedInternal(int callbackType,
                Object action, Object token, long delayMillis) { 
           ...
            synchronized (mLock) { 
                final long now = SystemClock.uptimeMillis();
                final long dueTime = now + delayMillis;
                //把callback赋值给CallbackQueue 对象中 CallbackRecord 对象 mHead
                mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
    			//下面最终都会功过handler去回掉callback中的的doFrame方法，也就是上面第9和10步
    			//最终会调用ViewDataBinding类中mRebindRunnable的run方法
                if (dueTime <= now) { 
                    scheduleFrameLocked(now);
                } else { 
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                    msg.arg1 = callbackType;
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtTime(msg, dueTime);
                }
            }
        }

**12 我们在看一下 上一步中是如何通过handler来调用FrameCallback的doFrame方法的**

if (dueTime <= now) { 
                    scheduleFrameLocked(now);
                } else { 
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                    msg.arg1 = callbackType;
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtTime(msg, dueTime);
                }

**上一步中的这个if判断最终都会通过handler走到最后处理callback回掉的地方，具体调用逻辑自己点击看一下。**

private final class FrameHandler extends Handler { 
            public FrameHandler(Looper looper) { 
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) { 
                switch (msg.what) { 
                	//上一步的if判段为true会调用doFrame（）方法
                    case MSG_DO_FRAME:
                        doFrame(System.nanoTime(), 0);
                        break;
                    case MSG_DO_SCHEDULE_VSYNC:
                        doScheduleVsync();
                        break;
                     //上一步的if判断为false会调用doScheduleCallback(msg.arg1);
                    case MSG_DO_SCHEDULE_CALLBACK:
                        doScheduleCallback(msg.arg1);
                        break;
                }
            }
        }

**最有都会走到doFrame(System.nanoTime(), 0)方法中**  
**doFrame()方法之后会调用doCallbacks方法，最后调用CallbackRecord重的run方法，来调用callback接口的doframe方法**

void doCallbacks(int callbackType, long frameTimeNanos) { 
    ...
    //这个c就是CallbackRecord对象，上面我们看过，他会持有callback对象
    c.run(frameTimeNanos);
    ...
    }

private static final class CallbackRecord { 
            public CallbackRecord next;
            public long dueTime;
            public Object action; // Runnable or FrameCallback
            public Object token;
    
            @UnsupportedAppUsage
            public void run(long frameTimeNanos) { 
                if (token == FRAME_CALLBACK_TOKEN) { 
                    ((FrameCallback)action).doFrame(frameTimeNanos);
                } else { 
                    ((Runnable)action).run();
                }
            }
        }

**13、所以最后还是会调用ViewDataBinding类中mRebindRunnable的run方法中**

private final Runnable mRebindRunnable = new Runnable() { 
            @Override
            public void run() { 
            	...
                executePendingBindings();
            }
        };

public void executePendingBindings() { 
            if (mContainingBinding == null) { 
                executeBindingsInternal();
            } else { 
                mContainingBinding.executePendingBindings();
            }
        }

**14、executeBindingsInternal方法最后会调用executeBindings(),他是一个抽象方法，最有会在APT生成的xxxxxBindingImpl子类中实现这个方法**

private void executeBindingsInternal() { 
    		...
            if (!mRebindHalted) { 
                executeBindings();
                ...
            }
            ....
        }

protected abstract void executeBindings();

**15、最终在xxxxxBindingImpl的executeBindings方法中进行实际的绑定操作**

protected void executeBindings() { 
     		...
            com.example.myapplication.model.User userBean = mUserBean;
            com.example.myapplication.TestDataBinding.Listenter listener = mListener;
            java.lang.String userBeanNameGet = null;
            java.lang.String userBeanPasswordGet = null;
            androidx.databinding.ObservableField<java.lang.String> userBeanName = null;
            java.lang.String listenerPsw = null;
            androidx.databinding.ObservableField<java.lang.String> userBeanPassword = null;
    
            if ((dirtyFlags & 0x96L) != 0) { 
                if ((dirtyFlags & 0x92L) != 0) { 
                        if (userBean != null) { 
                            //绑定数据
                            userBeanName = userBean.getName();
                        }
                        //注册监听
                        updateRegistration(1, userBeanName);
                        if (userBeanName != null) { 
                            userBeanNameGet = userBeanName.get();
                        }
                }
                if ((dirtyFlags & 0x94L) != 0) { 
                        if (userBean != null) { 
                            // read userBean.password
                            userBeanPassword = userBean.getPassword();
                        }
                        updateRegistration(2, userBeanPassword);
                        if (userBeanPassword != null) { 
                            // read userBean.password.get()
                            userBeanPasswordGet = userBeanPassword.get();
                        }
                }
            }
            if ((dirtyFlags & 0xa0L) != 0) { 
                    if (listener != null) { 
                        // read listener.psw
                        listenerPsw = listener.getPsw();
                    }
            }
            // batch finished
            if ((dirtyFlags & 0xa0L) != 0) { 
                // api target 1
                            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.btnLogin, listenerPsw);
            }
            if ((dirtyFlags & 0x80L) != 0) { 
                // api target 1
                this.btnLogin.setOnClickListener(mCallback2);
                //如果使用了双向绑定，还有为控件设置TextWatcher监听，这让view发生变化后就能去更
                //新对应的model了
                androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.etUserName, (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, etUserNameandroidTextAttrChanged);
                androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.etUserPsw, (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, mCallback1, etUserPswandroidTextAttrChanged);
            }
            if ((dirtyFlags & 0x92L) != 0) { 
                // api target 1
                androidx.databinding.adapters.TextViewBindingAdapter.setText(this.etUserName, userBeanNameGet);
            }
            if ((dirtyFlags & 0x94L) != 0) { 
                // api target 1
                androidx.databinding.adapters.TextViewBindingAdapter.setText(this.etUserPsw, userBeanPasswordGet);
            }
        }

### 2.2 单项绑定时，数据变化后如何通知View ###

1、从开始的使用方式中我们知道，要达到model变化时自动绑定到View上，要实现BaseObservable接口并在字段的setter方法里调用更新的方法notifyPropertyChanged(BR.xxx)或者直接使用ObservableField类型的属性，这两种方式最终都会调用BaseObservable 中的notifyPropertyChanged方法和notifyChange方法，但是最后都会执行到mCallbacks.notifyCallbacks(this, 0, null);

public class BaseObservable implements Observable { 
    	public void notifyChange() { 
            synchronized (this) { 
                if (mCallbacks == null) { 
                    return;
                }
            }
            mCallbacks.notifyCallbacks(this, 0, null);
        }
        
         public void notifyPropertyChanged(int fieldId) { 
            synchronized (this) { 
                if (mCallbacks == null) { 
                    return;
                }
            }
            mCallbacks.notifyCallbacks(this, fieldId, null);
        }
    }

2、mCallback 是通过BaseObservable的addOnPropertyChangedCallback方法把OnPropertyChangedCallback 添加进来的，我们继续看一下是什么时候调用的这个添加方法

@Override
        public void addOnPropertyChangedCallback(@NonNull OnPropertyChangedCallback callback) { 
            synchronized (this) { 
                if (mCallbacks == null) { 
                    mCallbacks = new PropertyChangeRegistry();
                }
            }
            mCallbacks.add(callback);
        }

3、在上面绑定过程分析的时候，最后对走到 xxxxxBindingImpl的executeBindings方法中

protected void executeBindings() { 
     		...
     		androidx.databinding.ObservableField<java.lang.String> userBeanName = null;
    	    userBeanName = userBean.getName();
     		//除了进行数据绑定，还会调用updateRegistration方法来对model进行监听
            updateRegistration(1, userBeanName);
    }

4、看一下ViewDataBinding类中updateRegistration方法具体的注册监听的过程

protected boolean updateRegistration(int localFieldId, Observable observable) { 
            return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
        }

5、updateRegistration第三个参数传了CREATE\_PROPERTY\_LISTENER，我们先看看CREATE\_PROPERTY\_LISTENER是什么，再分析updateRegistration方法。

private static final CreateWeakListener CREATE_PROPERTY_LISTENER = new CreateWeakListener() { 
            @Override
            public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) { 
                return new WeakPropertyListener(viewDataBinding, localFieldId).getListener();
            }
        };

private static class WeakPropertyListener extends Observable.OnPropertyChangedCallback
                implements ObservableReference<Observable> { 
            final WeakListener<Observable> mListener;
    
            public WeakPropertyListener(ViewDataBinding binder, int localFieldId) { 
                mListener = new WeakListener<Observable>(binder, localFieldId, this);
            }
            ...
            @Override
            public void onPropertyChanged(Observable sender, int propertyId) { 
                ViewDataBinding binder = mListener.getBinder();
                if (binder == null) { 
                    return;
                }
                Observable obj = mListener.getTarget();
                if (obj != sender) { 
                    return; // notification from the wrong object?
                }
                binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);
            }
        }

private static class WeakListener<T> extends WeakReference<ViewDataBinding> { 
            private final ObservableReference<T> mObservable;
            protected final int mLocalFieldId;
            private T mTarget;
    
            public WeakListener(ViewDataBinding binder, int localFieldId,
                    ObservableReference<T> observable) { 
                super(binder, sReferenceQueue);
                mLocalFieldId = localFieldId;
                mObservable = observable;
            }
            ...
            protected ViewDataBinding getBinder() { 
                ViewDataBinding binder = get();
                if (binder == null) { 
                    unregister(); // The binder is dead
                }
                return binder;
            }
        }

从上面知道CREATE\_PROPERTY\_LISTENER是一个CreateWeakListener对象，CreateWeakListener.create()能得到WeakPropertyListener，WeakPropertyListener内有变量WeakListener，WeakListener是个弱引用，持有ViewDataBinding以及mTarget(泛型T即VM)。

6、我们接着上面看看updateRegistration里面的事情

private boolean updateRegistration(int localFieldId, Object observable,
                CreateWeakListener listenerCreator) { 
            if (observable == null) { 
                return unregisterFrom(localFieldId);
            }
            WeakListener listener = mLocalFieldObservers[localFieldId];
            if (listener == null) { 
                registerTo(localFieldId, observable, listenerCreator);
                return true;
            }
            if (listener.getTarget() == observable) { 
                return false;//nothing to do, same object
            }
            unregisterFrom(localFieldId);
            registerTo(localFieldId, observable, listenerCreator);
            return true;
        }

mLocalFieldObservers维持了从localFieldId到WeakListener的映射。先从mLocalFieldObservers取localFieldId对应的WeakListener，如果为null的话，就调用registerTo进行注册；如果不为空，而且与之前注册过的不一致的话，则重新注册

7、registerTo进行注册，通过CreateWeakListener.create()得到WeakListener之后，registerTo将WeakListener存储在mLocalFieldObservers中。然后调用WeakListener的setTarget方法。

protected void registerTo(int localFieldId, Object observable,
                CreateWeakListener listenerCreator) { 
            if (observable == null) { 
                return;
            }
            WeakListener listener = mLocalFieldObservers[localFieldId];
            if (listener == null) { 
                listener = listenerCreator.create(this, localFieldId);
                mLocalFieldObservers[localFieldId] = listener;
                if (mLifecycleOwner != null) { 
                    listener.setLifecycleOwner(mLifecycleOwner);
                }
            }
            listener.setTarget(observable);
        }

8、WeakListener的setTarget方法

private static class WeakListener<T> extends WeakReference<ViewDataBinding> { 
    
        private final ObservableReference<T> mObservable;
        ...
    
        public WeakListener(ViewDataBinding binder, int localFieldId,
                ObservableReference<T> observable) { 
            super(binder, sReferenceQueue);
            mLocalFieldId = localFieldId;
            mObservable = observable;
        }
    
        public void setTarget(T object) { 
            unregister();
            mTarget = object;
            if (mTarget != null) { 
                mObservable.addListener(mTarget);
            }
        }
        ...
    }

9、然后调用mObservable的addListener方法，mObservable就是在构造WeakListener传入的第三个参数。根据下面的代码，WeakPropertyListener在构造函数里构造WeakListener是传入的是this，因此mObservable其实就是WeakPropertyListener它自身实了ObservableReference接口。

10、在addListener里，调用Observable的addOnPropertyChangedCallback，参数为this。BaseObservable实现了接口Observable，在addOnPropertyChangedCallback里，将WeakPropertyListener加入到了mCallbacks(PropertyChangeRegistry)里面

@Override
    public void addOnPropertyChangedCallback(OnPropertyChangedCallback callback) { 
        synchronized (this) { 
            if (mCallbacks == null) { 
                mCallbacks = new PropertyChangeRegistry();
            }
        }
        mCallbacks.add(callback);
    }

这样view和model的联系就通过ViewDatabinding建立起来了。Activity内有ViewDatabinding，而ViewDatabinding里持有各个V(布局中的元素)的引用。ViewDataBinding有model的变量，而model内的PropertyChangeRegistry对象监听实则为WeakPropertyListener，WeakPropertyListener得到的WeakListener能获取到ViewDatabinding的引用

11、所以最后我们就清楚了，当model的属性变化后调用BaseObservable 中mCallbacks.notifyCallbacks来通知View刷新，最后会调用WeakPropertyListener的onPropertyChanged方法。

private static class WeakPropertyListener extends Observable.OnPropertyChangedCallback
                implements ObservableReference<Observable> { 
          
            @Override
            public void onPropertyChanged(Observable sender, int propertyId) { 
                ViewDataBinding binder = mListener.getBinder();
                if (binder == null) { 
                    return;
                }
                Observable obj = mListener.getTarget();
                if (obj != sender) { 
                    return; // notification from the wrong object?
                }
                binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);
            }
        }

最后通过ViewDataBinding的handleFieldChange方法来进行重新绘制。

private void handleFieldChange(int mLocalFieldId, Object object, int fieldId) { 
    		  //到这就熟悉了吧
              requestRebind();
    }

### 2.3 双向绑定时，View数据变化如何更新model ###

1、双向绑定，在xml中使用@=\{\}后，在xxxxxBindingImpl的绑定方法中绑定会，会通过下面这种方式来进行绑定：

protected void executeBindings() { 
     androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(
     this.etUserName, 
     (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)
     null, 
     (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged)
     null, 
     (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)
     null, 
     etUserNameandroidTextAttrChanged);
    }

2、TextViewBindingAdapter中setTextWatcher方法参数重要是 view 和 InverseBindingListener ，逻辑就是 给view设置一个TextWatcher监听，当view变化后，回掉onTextChanged方法，然后是调用InverseBindingListener的 onchange方法

@BindingAdapter(value = { "android:beforeTextChanged", "android:onTextChanged",
                "android:afterTextChanged", "android:textAttrChanged"}, requireAll = false)
        public static void setTextWatcher(TextView view, final BeforeTextChanged before,
                final OnTextChanged on, final AfterTextChanged after,
                final InverseBindingListener textAttrChanged) { 
            final TextWatcher newValue;
            if (before == null && after == null && on == null && textAttrChanged == null) { 
                newValue = null;
            } else { 
                newValue = new TextWatcher() { 
                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) { 
                        if (before != null) { 
                            before.beforeTextChanged(s, start, count, after);
                        }
                    }
    
                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) { 
                        if (on != null) { 
                            on.onTextChanged(s, start, before, count);
                        }
                        if (textAttrChanged != null) { 
                            textAttrChanged.onChange();
                        }
                    }
    
                    @Override
                    public void afterTextChanged(Editable s) { 
                        if (after != null) { 
                            after.afterTextChanged(s);
                        }
                    }
                };
            }
            final TextWatcher oldValue = ListenerUtil.trackListener(view, newValue, R.id.textWatcher);
            if (oldValue != null) { 
                view.removeTextChangedListener(oldValue);
            }
            if (newValue != null) { 
                view.addTextChangedListener(newValue);
            }
        }

3、InverseBindingListener 来更新数据，就是根据view，拿到view的数据，把数据set到model对应的属性中。

private androidx.databinding.InverseBindingListener etUserPswandroidTextAttrChanged = new androidx.databinding.InverseBindingListener() { 
            @Override
            public void onChange() { 
                // Inverse of userBean.password.get()
                // is userBean.password.set((java.lang.String) callbackArg_0)
                java.lang.String callbackArg_0 = androidx.databinding.adapters.TextViewBindingAdapter.getTextString(etUserPsw);
                // localize variables for thread safety
                // userBean
                com.example.myapplication.model.User userBean = mUserBean;
                // userBean.password
                androidx.databinding.ObservableField<java.lang.String> userBeanPassword = null;
                // userBean.password.get()
                java.lang.String userBeanPasswordGet = null;
                // userBean.password != null
                boolean userBeanPasswordJavaLangObjectNull = false;
                // userBean != null
                boolean userBeanJavaLangObjectNull = false;
    
    
    
                userBeanJavaLangObjectNull = (userBean) != (null);
                if (userBeanJavaLangObjectNull) { 
    
    
                    userBeanPassword = userBean.getPassword();
    
                    userBeanPasswordJavaLangObjectNull = (userBeanPassword) != (null);
                    if (userBeanPasswordJavaLangObjectNull) { 
    
    
    
    
                        userBeanPassword.set(((java.lang.String) (callbackArg_0)));
                    }
                }
            }
        };

--------------------

**到这，Databinding的绑定流程和数据更新就分析完了，比较粗糙，具体细节还需要自己看代码**

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220828/1d82f81c6d864fcc8fbb087e969a2c2a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220828/6483b595592343edb4dff1d71a309ff3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWUFNZ29kZGVzcw_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: /images/20220828/4f4ffbf928384e3f91bfb0d8faa7be33.png