[Practical] Android Data Binding from resistance to love

1 Introduction

How to implement the following interface efficiently?

Login/Not logged in

I have several years of experience in findViewById, so I don't think it's difficult.

1. First define a User Model class, the data comes from JSON parsing;

2. Create an xml, then lay out all the views in the xml, and give an id to the avatar, title, points, and login button;

3. In the Activity, use findViewById to get the avatar ImageView, title TextView, points TextView, and login Button, then set a listener for the Button, and then display the corresponding data according to the login status;

The implementation is as follows:

• User.java

• activity_detail.xml

• DetailActivity

2 Remove the annoying findViewById (View injection)

As you can see, the definition, finding, and empty judgment of View in Activity occupy a lot of space, and we need a more elegant implementation.

2.1 ButterKnife

You may have heard of Jake Wharton's ButterKnife. This library only needs to pass in the corresponding id through annotation when defining the View variable, and then call ButterKnife.bind(this) in onCreate to complete the view injection. The example is as follows:

2.2 Android Data Binding

If Android Data Binding is used, then the definition, find, and empty judgment of View do not need to be written. How to do it?

2.2.1 Preparation

First, you need to meet a condition: your Android Plugin for Gradle version must be equal to or higher than version 1.5.0-alpha1, which is located in the root directory build.gradle. The example is as follows:

 buildscript {
 repositories {
 jcenter()
 }
 dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0-rc1'  
 }
 }

Next, you must tell the compiler to enable Data Binding, which is usually located in the android tag of app:build.gradle, as shown below:

 android {
 compileSdkVersion 23
    buildToolsVersion "23.0.2"   
 
 dataBinding {
 enabled true  
 }
 ...
 }

2.2.2 Modify layout.xml

Taking activity_detail.xml as an example, the original root node is LinearLayout, as shown below:

2.2.3 Let the fun begin!

After the above operations are completed, the compiler will automatically generate

com.asha.demo.databinding.ActivityDetail2Binding.java class. The command format of this class is: package name + databinding + activity_detail2 camel case naming format + Binding.java. Then, the code of DetailActivity2.java using this activity_detail2 can be simplified to:

 public class DetailActivity2 extends AppCompatActivity { 
 
    ActivityDetail2Binding binding; @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this,R.layout.activity_detail2); 
 
 login();
    } private void login(){ fill( User .newInstance()); } private void logout(){ fill( null ); } private void fill(final User   user ){ final int visibility = user != null ? View .VISIBLE : View .GONE; if ( user != null ){
            binding.detailAvatar.setImageDrawable(ContextCompat.getDrawable(this, user .getAvatar()));
            binding.detailName.setText( user .getName());
 binding.detailDesc.setText(String.format( "Points: %d Level: %d" , user .getScore(), user .getLevel()));
 } 
 
        binding.detailAvatar.setVisibility(visibility);
        binding.detailName.setVisibility(visibility);
        binding.detailDesc.setVisibility(visibility);
        binding.detailActionButton.setOnClickListener(new View .OnClickListener() { @Override
 public void onClick( View v) { if ( user == null ) login(); else logout();
 }
 });
 binding.detailActionButton.setText( user == null ? "Login" : "Logout" );
 }
 }

Yes, all the View definitions, finds, and empty judgments are gone. All these operations are completed in ActivityDetail2Binding.java generated by the compiler for us. You only need to call the following code to setContentView during onCreate to implement it.

binding = DataBindingUtil.setContentView(this,R.layout.activity_detail2);

Oh my god

2.2.4 Analysis of code related to View injection in ActivityDetail2Binding

You can easily view the class automatically generated by the compiler in as. This class is located in /app/build/intermediates/classes/debug/com/asha/demo/databinding/ActivityDetail2Binding.class. The code after reducing the Binding logic is as follows:

The global static SparseIntArray array contains four numbers, which are the IDs of the corresponding Views generated in R.java.

 public final class R {
 ... public   static final class id {
 ... public   static final int detail_action_button = 2131492951; public   static final int detail_avatar = 2131492948; public   static final int detail_desc = 2131492950; public   static final int detail_name = 2131492949;
 ...
 }
 ...
 }

When the ActvityDetail2Binding instance is constructed, mapBindings is called to solve the search of all Views at once. The mapBindings function is implemented in the ViewDataBinding parent class of ActvityDetail2Binding.

3 Use expressions to fill model data in layout.xml

There are still a lot of View control and data filling codes in ActivityDetail2.java. How to hand these codes over to layout.xml?

3.1 ModelAdapter Class

In Section 2, the User.java class has been defined as the Model class, but we often encounter inconsistencies between the Model class and the actual View display. In this example, a ModelAdapter class is defined to complete the adaptation of the Model data to the display data. The sample code is an inner class of ActivityDetail3.java, and the functions in ActivityDetail3.java can be called. The code definition is as follows:

3.2 Using model in activity_detail3.xml

Similarly, copy activity_detail2.xml to activity_detail3.xml, add a <data> node to the <layout> node, and define the model class you need to use (such as ModelAdapter adapter), of course, it can also be a basic type variable (such as int visibility);

Then, you can use the expression in the following view. The entire layout file is as follows:

 <?xml version= "1.0" encoding= "utf-8" ?><layout xmlns:android= "http://schemas.android.com/apk/res/android" >
 <data>
        <variable name = "adapter" type= "com.asha.demo.DetailActivity3.ModelAdapter" />
        <variable name = "visibility" type= "int" />
 </data>
 <LinearLayout
        android:orientation= "vertical" android:layout_width= "match_parent"  
        android:layout_height= "match_parent" >
 < View  
            android:background= "@color/detail_background"  
            android:layout_width= "match_parent"  
            android:layout_height= "66dp" >
 </ View >
 <ImageView
            android:src= "@{adapter.avatar}"  
            android:visibility= "@{visibility}"  
            android:id= "@+id/detail_avatar"  
            android:layout_gravity= "center"  
            android:layout_marginTop= "-33dp"  
            android:layout_width= "66dp"  
            android:layout_height= "66dp" />
 <TextView
            android:visibility= "@{visibility}"  
            android:text= "@{adapter.name}"  
            android:id= "@+id/detail_name"  
            android:textSize= "17sp"  
            android:textColor= "@color/textColorPrimary"  
            android:layout_marginTop= "15dp"  
            android:layout_gravity= "center"  
            android:layout_width= "wrap_content"  
            android:layout_height= "wrap_content" />
 <TextView
            android:visibility= "@{visibility}"  
            android:text= "@{adapter.desc}"  
            android:id= "@+id/detail_desc"  
            android:layout_marginTop= "15dp"  
            android:textSize= "13sp"  
            android:layout_gravity= "center"  
            android:layout_width= "wrap_content"  
            android:layout_height= "wrap_content" />
 <Button
            android:text= "@{adapter.actionText}"  
            android:onClick= "@{adapter.clickHandler}"  
            android:id= "@+id/detail_action_button"  
            android:layout_marginTop= "15dp"  
            android:layout_gravity= "center"  
            android:textColor= "@color/white"  
            android:background= "@drawable/selector_g_button"  
            android:layout_width= "220dp"  
            android:layout_height= "wrap_content" />
 </LinearLayout></layout>

3.3 Calling Fill in DetailActivity3.java

As shown in the following code, you only need to set the required adatper and visibility values ​​for viewDataBinding when the login status changes to complete the data filling.

3.4 Analysis of filling-related code in ActivityDetail3Binding

Similarly, in ActivityDetail3Binding, the compiler automatically generates codes such as setAdapter and setVisibility based on the <data> tag in activity_detail3.xml. The relevant codes of setAdapter are as follows:

Very simple, getter and setter are automatically generated. After the set operation is completed, call notifyPropertyChanged and super.requestRebind()

• notifyPropertyChanged

ViewDataBinding itself is a BaseObservable. When registering to ViewDataBinding to observe the change of a certain property, if the change of mAdapter is registered, the corresponding observer will receive a callback. The relevant logic is related to the reverse Binding. Google has not yet provided relevant usage documents, so we will not analyze it in depth.

• super.requestRebind()

1. This function is a function in ViewDataBinding. Its specific implementation is to determine whether there is a Rebind request now. If yes, return; if not, it is handed over to the handler or choreographer according to the runtime SDK version and inserted into the next frame to execute mRebindRunnable.

2. In mRebindRunnable, depending on the current SDK version, if it is greater than or equal to KITKAT, you need to execute executePendingBindings after onAttachToWindow; otherwise, executePendingBindings is executed directly.

3. After some judgment in the parent class ViewDataBinding, call executeBindings in ActivityDetail3Binding, and perform different View attribute assignments according to dirtyFlags in executeBindings. All the following ActivityDetail3Binding related codes are automatically generated by the compiler

 public class ActivityDetail3Binding extends ViewDataBinding{
  ... protected void executeBindings() { long dirtyFlags = 0L; synchronized(this) {
          dirtyFlags = this.mDirtyFlags; this.mDirtyFlags = 0L;
 } 
 
      Drawable avatarAdapter = null ;
      ModelAdapter adapter = this.mAdapter;
      String descAdapter = null ;
      String nameAdapter = null ;
      ActivityDetail3Binding.OnClickListenerImpl androidViewViewOnCli = null ;
      String actionTextAdapter = null ; int visibility = this.mVisibility; if((dirtyFlags & 5L) != 0L && adapter != null ) {
          avatarAdapter = adapter.getAvatar();
          descAdapter = adapter.getDesc();
          nameAdapter = adapter.getName();
          androidViewViewOnCli = (this.mAndroidViewViewOnCl == null ?(this.mAndroidViewViewOnCl = new ActivityDetail3Binding.OnClickListenerImpl()):this.mAndroidViewViewOnCl).setValue(adapter);
          actionTextAdapter = adapter.actionText();
      } if((dirtyFlags & 6L) != 0L) {
 ;
      } if((dirtyFlags & 5L) != 0L) {
          TextViewBindingAdapter.setText(this.detailActionButton, actionTextAdapter); this.detailActionButton.setOnClickListener(androidViewViewOnCli);
          ImageViewBindingAdapter.setImageDrawable(this.detailAvatar, avatarAdapter);
          TextViewBindingAdapter.setText(this.detailDesc, descAdapter);
          TextViewBindingAdapter.setText(this.detailName, nameAdapter);
      } if((dirtyFlags & 6L) != 0L) { this.detailAvatar.setVisibility(visibility); this.detailDesc.setVisibility(visibility); this.detailName.setVisibility(visibility);
 } 
 
 }
 ...
 }

At this point, the filling analysis of View data is completed.

4 Binding

The automatically generated ViewDataBinding class (such as ActivityDetail3Binding) contains Model + View, which is the concept of MV in MVVM.

The View injection in Chapter 2 and the View assignment in Chapter 3 are all preparations, and they all serve the Binding operation in the end. Currently, Google already supports two-way Binding, but as mentioned above, there is little information available. This article only focuses on one-way Binding, that is, changes in the Model are automatically synchronized to the View.

4.1 Using ObservableField

The currently provided ObservableFields are:

This article uses a simple ObservableInt as an example to solve the single-item binding problem of visibility.

• Modify activity_detail4.xml: define a variable of type ObservableInt with name visibility, and then assign it to android:visibility of ImageView. The example is as follows:

 <layout xmlns:android= "http://schemas.android.com/apk/res/android" >
 <data>
      <variable name = "visibility" type= "android.databinding.ObservableInt" />
 </data>
 <LinearLayout
      android:orientation= "vertical" android:layout_width= "match_parent"  
      android:layout_height= "match_parent" >
 ... <ImageView
          android:visibility= "@{visibility.get()}"  
          android:id= "@+id/detail_avatar"  
          android:layout_gravity= "center"  
          android:layout_marginTop= "-33dp"  
          android:layout_width= "66dp"  
          android:layout_height= "66dp" />
      ... </LinearLayout></layout>

• To modify DetailActivity4.java, you only need to assign visibility to binding (ActivityDetail4Binding) during onCreate. Subsequent operations on visibility will be updated to the view. The sample code is as follows:

 public class DetailActivity4 extends AppCompatActivity {
  ActivityDetail4Binding binding;
  ObservableInt visibility = new ObservableInt(); @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState);
      binding = DataBindingUtil.setContentView(this,R.layout.activity_detail4,new MyComponent());
      binding.setVisibility(visibility);
 login();
  } private void login(){ fill( User .newInstance()); } private void logout(){ fill( null ); } private void fill(final User   user ){
      visibility.set ( user != null ? View .VISIBLE : View .GONE);
 ....
 }
 ....
 }

4.2 Code analysis related to one-way binding in ActivityDetail4Binding

Different from setting pure Model directly to ActivityDetail4Binding, all ObservableFields implement the Observable interface. As long as the Observable interface is implemented, it is a one-way Binding type. Therefore, an extra line of code is added to setVisibility in ActivityDetail4Binding: this.updateRegistration(1, visibility), where 1 is propertyId. Currently, 2 are automatically generated, 0 for adatper and 1 for visibility. The code is as follows:

 public class ActivityDetail4Binding extends ViewDataBinding {
    ... public void setVisibility(ObservableInt visibility) { this.updateRegistration(1, visibility); this.mVisibility = visibility; synchronized(this) { this.mDirtyFlags |= 2L;
        } this.notifyPropertyChanged(3); super.requestRebind();
 }
 ...
 }

The updateRegistration function is a function in ViewDataBinding. It will create corresponding Listeners according to the three types of Observable, ObservableList, and ObservableMap. ObservableInt is Observable, so CREATE_PROPERTY_LISTENER will be used to create a WeakPropertyListener in the registerTo function.

The code is as follows:

 public abstract class ViewDataBinding extends BaseObservable {
    ... 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 ;
 }
 ...
 }

There is a setTarget function in mListener of WeakPropertyListener, which registers a listener with mObservable (i.e., the visibility passed in from outside). If the visibility value changes, the listener will be notified and called back to onPropertyChanged of WeakPropertyListener, and then notified to handleFieldChange of binding (ActivityDetail4Binding). The onFieldChange function of ActivityDetail4Binding is called in handleFieldChange. If the return value is true, requestRebind() is called in handleFieldChange to notify View to assign values ​​and update the interface. The relevant code of onFieldChange is as follows:

 public abstract class ViewDataBinding extends BaseObservable {
    ... private void handleFieldChange( int mLocalFieldId, Object object, int fieldId) { boolean result = onFieldChange(mLocalFieldId, object, fieldId); if (result) {
 requestRebind();
 }
 }
 ...
 }

 public class ActivityDetail4Binding extends ViewDataBinding {
    ... protected boolean onFieldChange( int localFieldId, Object object, int fieldId) { switch(localFieldId) { case 0: return this.onChangeAdapter((ModelAdapter)object, fieldId); case 1: return this.onChangeVisibility((ObservableInt)object, fieldId); default : return   false ;
 }
 }
 ...
 }

4.3 Observable Objects

Similar to 4.1 ObservableField, you can modify ModelAdapter: add @Bindable annotation to getter method, and add notifyPropertyChanged(com.asha.demo.BR.name) notification to setter method. BR is a class automatically generated based on @Bindalbe. After adding @Bindable annotation to getter method, BR file will automatically generate an integer name. The modified code is as follows:

 public class DetailActivity4 extends AppCompatActivity { 
 
    ActivityDetail4Binding binding;
    ObservableInt visibility = new ObservableInt(); public class ModelAdapter extends BaseObservable{ private User   user ; public ModelAdapter( User   user ) { this. user = user ;
 }
 ... @Bindable
 public String getName(){ return   user != null ? user .getName() : null ;
        } public void setName(String name ){ if ( user != null ) user .setName( name );
            notifyPropertyChanged(com.asha.demo.BR. name );
 }
 ...
 }
 ...
 }

Then, call the test code in DetailActivity4.java. After execution, the name value on the adapter will be changed after 1 second and synchronized to the View. The test code is as follows:

 binding.detailActionButton.postDelayed(new Runnable() { @Override
 public void run() {
        adapter.setName( "haha" );
 }
 },1000);

The specific principle is similar to that in 4.1 and will not be described in detail.

5 Setters for View attributes in layout.xml

In the following example, if the detail_name TextView wants to assign adapter.name to its own text attribute, it needs to call the textView.setText(String) method, which is the setter method of the View attribute.

 <TextView
    android:text= "@{adapter.name}"  
    android:id= "@+id/detail_name"  
    android:layout_width= "wrap_content"  
    android:layout_height= "wrap_content" />

5.1 @BindingAdapter

For the above setter methods, the Data Binding library helps us implement most of the default methods. For specific methods, see the classes under the android.databinding.adapters package. The following figure shows the specific implementation of ViewBindingAdatper.

ViewBindingAdapter

The setter methods are all static methods, the first parameter is the instance of itself, followed by the parameters passed in xml. As long as the @BindingAdapter annotation is added, the compiler will search globally and save it in a temp file, and find the required setter method in the process of generating ActivityDetail4Binding. If you need to customize it, you only need to define @BindingAdapter in any app code, for example:

 public class DetailActivity4 extends AppCompatActivity { @BindingAdapter( "android:alpha" ) public   static void globalSetAlpha( View   view , float alpha) {
 view .setAlpha(alpha);
 }
 }

5.2 DataBindingComponent

In many cases, only a certain Binding file (such as ActivityDetail4Binding) needs a custom setter method. In this case, you need to use DataBindingComponent.

• First, define a MyComponent.

 public class MyComponent implements android.databinding.DataBindingComponent { @BindingAdapter( "android:alpha" ) public void setAlpha( View   view , float alpha) {
 view .setAlpha(0.5f);
 } @Override
 public MyComponent getMyComponent() { return new MyComponent();
 }
 }

• Next, pass in this DataBindingComponent instance when generating the Binding object. The code is as follows:

 @Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState);
  binding = DataBindingUtil.setContentView(this,R.layout.activity_detail4,new MyComponent());
 ...
 }

After completion, all setter functions that assign alpha using android:alpha="@{foo}" within the scope of this ActivityDetail4Binding will use MyComponent#setAlpha.

5.3 @BindingConversion

Sometimes you may encounter type mismatch problems. For example, R.color.white is int, but after assigning it to the android:background attribute through Data Binding, you need to convert the int to ColorDrawable. The implementation is as follows:

• 1. Define a static function and put it in any class of the project.

 @BindingConversionpublic static Drawable convertColorToDrawable( int drawable) { return new ColorDrawable(drawable);
 }

• 2. Use Data Binding in layout.xml, such as:

 <Viewandroid:background= "@{adapter.avatar != null ? @color/detail_background : @color/colorAccent }" android:layout_width= "match_parent" android:layout_height= "66dp" >

The corresponding code generated in ActivityDetail4Binding.java is as follows, where AvatarAdapterObjectn1 is of int type:

 ViewBindingAdapter.setBackground(this.mboundView1, DetailActivity4.convertColorToDrawable(AvatarAdapterObjectn1));

5.4 @BindingMethod

For example, the android:onClick attribute in layout.xml corresponds to the setOnClickListener method when the setter is actually used in Binding.

 @BindingMethod(type = View .class, attribute = "android:onClick" , method = "setOnClickListener" ),

6 Data Binding uses what the compiler does behind the scenes

The jar package related to Data Binding consists of four parts:

• 1.baseLibrary-2.1.0-rc1.jar

It is packaged into APK as a runtime library;

• 2.DataBinderPlugin(gradle plugin)

Used during compilation, gradle-api (formerly called transform-api, 1.5, renamed 2.0) is used to process the XML file and generate DataBindingInfo.java;

• 3.compiler-2.1.0-rc1.jar

When used in the compiler, the entry class inherits from AbstractProcessor, which is used to process annotations and generate Binding classes, DataBindingCompoent.java, and DataBinderMapper.java classes;

• 4.compilerCommon-2.1.0-rc1.jar

Depends on DataBinderPlugin and compiler-2.1.0-rc1.jar

In order to improve runtime efficiency, Data Binding does a lot of work behind the scenes. The following figure is the compilation process I organized, as shown in the figure:

Data Binding compilation process

6.1 Introduction to related objects

• The white part is the input, including

1.res/layout;

2. Annotations in source code;

• The yellow part is the compiler processing class, including

1.aapt is processed during compilation, and the entry class name is MakeCopy.java;

2.gradle-api processing, the entry class name is DataBinderPlugin.java;

3.AbstractProcessor processing, the entry class name is ProcessDataBinding.java;

• The blue part is the intermediate product, including

1. The data-binding-info folder contains the basic information of the layout, imported variables, expressions in the View tag, the location index of the tag, etc., as shown below: data-binding-info/activity_detail3-layout.xml:

2.setter_store.bin, contains all setter related information;

3. layoutinfo.bin, contains all layout related information;

4.br.bin, contains all BR related information;

The above bin files are serialized to disk in Serializable mode and deserialized when needed;

• The green part is the final product, including

1. data-binding-layout-out (finally output to res/layout), that is, remove the root node <layout> and the node <data>, which is consistent with the layout when Data Binding is not used, for example, data-binding-layout-out/activity_detail2.xml:

 <?xml version= "1.0" encoding= "utf-8" ?>
 <LinearLayout
  android:orientation= "vertical" android:layout_width= "match_parent"  
  android:layout_height= "match_parent" android:tag= "layout/activity_detail2_0" xmlns:android= "http://schemas.android.com/apk/res/android" >
 < View  
      android:background= "@color/detail_background"  
      android:layout_width= "match_parent"  
      android:layout_height= "66dp" >
 </ View >
 ...
 </LinearLayout>

2. DataBindingInfo.class, a seemingly empty class, but contains a @BindingBuildInfo annotation in the SOURCE phase, which contains the basic information of basic DataBinding. The code is as follows:

 // DataBindingInfo.classpublic class DataBindingInfo { public DataBindingInfo() {
 }
 }// @BindingBuildInfo@Target({ElementType.TYPE})@Retention(RetentionPolicy.SOURCE) public @interface BindingBuildInfo { String buildId(); String modulePackage(); String sdkRoot(); int minSdk(); String layoutInfoDir(); String exportClassListTo(); boolean isLibrary(); boolean enableDebugLogs() default   false ; boolean printEncodedError() default   false ;
 }

3.DataBindingComponent.class will automatically generate the corresponding instantiation method according to the custom DataBindingComponent, for example:

 public interface DataBindingComponent { MyComponent getMyComponent(); 
 
 }

4. Subclasses of ViewDataBinding.class (ActivityDetail2Binding.class, etc.)

5.BR.class, Bindable attribute index table, for example:

 public class BR { public   static final int _all = 0; public   static final int adapter = 1; public   static final int   name = 2; public   static final int visibility = 3; public BR() {
 }
 }

6.DataBindingMapper.class, Mapper, is used to find the ViewDataBinding class corresponding to a layout.xml, for example:

 class DataBinderMapper { static final int TARGET_MIN_SDK = 16; public DataBinderMapper() {
  } public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View   view , int layoutId) { switch(layoutId) { case 2130968602: return ActivityDetail2Binding.bind( view , bindingComponent); case 2130968603: return ActivityDetail3Binding.bind( view , bindingComponent);
 .... default : return   null ;
 }
  } ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View [] views, int layoutId) { return   null ;
  } int getLayoutId(String tag) { if(tag == null ) { return 0;
      } else { int code = tag.hashCode(); switch(code) { case -600937657: if(tag.equals( "layout/activity_detail2_0" )) { return 2130968602;
              } break; case -600936696: if(tag.equals( "layout/activity_detail3_0" )) { return 2130968603;
              } break;
 .... return 0;
 }
  } String convertBrIdToString( int id) { return id >= 0 && id < DataBinderMapper.InnerBrLookup.sKeys.length?DataBinderMapper.InnerBrLookup.sKeys[id]: null ;
  } private static class InnerBrLookup { static String[] sKeys = new String[]{ "_all" , "adapter" , "name" , "visibility" }; private InnerBrLookup() {
 }
 }
 }

6.2 Related compilation process

• STEP1 Resource processing

When aapt or gradle is executed, resource processing will be triggered. During the resource processing, DataBinding will scan the existing resources and generate data-binding-layout-out that does not contain <layout> and data-binding-info required by DataBinding;

• STEP2 DataBindingInfo.class generation

After completing resource processing, aapt or gradle-api will perform the DataBindingInfo.class generation operation and write the relevant information into the @BindingBuildInfo annotation of DataBindingInfo.class;

• STEP3 Monitor annotation changes

When the @BindingBuildInfo annotation is generated or a new annotation is written in the code, the AbstractProcessor annotation processor starts to perform annotation processing. There is a ProcessDataBinding.java class in DataBinding that is specifically used to process DataBinding related annotations;

• STEP4 ProcessDataBinding handles annotations and generates bin

Processing annotations in ProcessDataBinding will always be executed in three steps: ProcessMethodAdapter, ProcessExpressions, and ProcessBindable. Each execution will deserialize the corresponding bin file from disk, then write a new one into the bin, and then serialize it to disk after completion;

• STEP5 Generate the final product

Execute ProcessMethodAdapter to generate DataBindingComponents.class; execute ProcessExpressions to generate ViewDataBinding.class subclass (ActivityDetail2Binding.class), and trigger DataBindingMapper.class update; execute ProcessBindable to generate BR.class, and trigger DataBindingMapper.class update;

7 Details Supplement - Use of View Tag

Chapter 2 talked about how View is injected. In fact, there are two situations:

• 1. If there is only id in the View tag attribute and no other "@{expression}" form, search directly by id as mentioned in Chapter 2;
• 2. If the View tag attribute contains a value in the form of "@{expression}", the compiler will automatically add an android:tag="binding_{N}" to the View, where {N} increases in sequence from 0, such as android:tag="binding_0". When ViewDataBinding#mapBindings is executed to inject the View, it will find a View with a tag starting with binding_ and then perform the View injection;

In addition, if the View tag originally has an android:tag value, the compiler will first save the original value information and write android:tag="binding_{N}". After the view injection is completed, the original value is assigned to android:tag. Note that if the original android:tag value is "binding_0", confusion will occur during View injection.

After completing the View injection, ActivityDetail3Binding will execute this.setRootTag(root). The code is as follows:

This is similar to the implementation of ViewHoloder in ListView, so if DataBinding is applied to ViewHolder of ListView, there is no need to generate an extra ViewHolder. You can directly use this ViewDataBinding class, such as ListAdapter implementation:

8 Conclusion

• The DataBinding library is very small

Currently, Android Data Binding has only 632 methods in the runtime class library. Including the ViewDataBinding subclasses automatically generated by each layout.xml (each class in the demo has no more than 20 methods), the total number of methods is also very limited.

Number of Data Binding Methods

• DataBinding runs without any extra performance loss

All View injection, View assignment, and Binding of DataBinding are codes automatically generated by the compiler. These repetitive manual labors need to be done, but they are handed over to the compiler to complete, so there is no extra performance loss during runtime.

• DataBinding can reduce the error rate

Since View injection, View assignment, and Binding are all automatically completed by the compiler, as long as they are used correctly, there is a 100% guarantee of no low-level errors, which can improve code quality and make developers happy.

• The impact of DataBinding on compile time

It has not yet been actually applied to the production environment, so there will definitely be some extension, but the specific magnitude is still unknown.