Jetpack视图绑定ViewBinding

ViewBinding

ViewBinding是Android官方推出的一种用于简化视图绑定的库。它通过在编译时生成一个绑定类，将布局文件中的视图与代码中的视图进行绑定，从而避免了手动findViewById的繁琐过程。

使用ViewBinding可以提高代码的可读性和可维护性，减少了因为视图ID错误而导致的运行时异常。同时，它还能够减少内存泄漏的风险，因为它使用了弱引用来持有视图。

配置启用ViewBinding

要启用ViewBinding，你需要进行以下步骤：

1. 在项目的build.gradle文件中，确保你的Android Gradle插件版本在4.0.0及以上。如果版本低于4.0.0，你需要升级插件版本。

2. 在app模块的build.gradle文件中，添加以下插件依赖：

android {
    // ...
    viewBinding {
        enabled = true
    }
}

或者

android {
    // ...
    buildFeatures {
      viewBinding true
    } 
}

这样，你就成功启用了ViewBinding，并可以通过binding对象来访问布局中的视图了。

和DataBinding比较

ViewBinding和DataBinding都是Android开发中用于绑定视图和数据的工具，但它们有一些不同之处。

1. 使用方式：

   • ViewBinding是在编译时生成的，通过生成的绑定类来访问视图，不需要运行时的数据绑定表达式。使用ViewBinding时，需要手动为每个布局文件生成对应的绑定类。
   • DataBinding是在运行时进行数据绑定，通过在布局文件中使用表达式来绑定数据。使用DataBinding时，不需要手动为每个布局文件生成绑定类。

2. 性能：

   • ViewBinding在性能方面更加轻量级，因为它是在编译时生成的，不需要运行时的数据绑定表达式。
   • DataBinding在性能方面相对较重，因为它需要在运行时解析和执行数据绑定表达式。

3. 功能：

   • ViewBinding只能用于视图绑定，不能直接绑定数据到视图。
   • DataBinding不仅可以绑定视图，还可以直接绑定数据到视图，同时支持双向绑定。

综上所述，如果只需要简单的视图绑定，可以选择使用ViewBinding，它更加轻量级和高效。如果需要更复杂的数据绑定功能，可以选择使用DataBinding，它支持双向绑定和直接绑定数据到视图。

ViewBinding的使用

ViewBinding是一种用于在Android开发中绑定视图的库。它可以帮助开发者更方便地访问和操作视图，避免了使用findViewById()方法的繁琐过程。

使用ViewBinding的步骤如下：

1. 先编写布局文件，例如：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Hello"/>
LinearLayout>

2. 在Activity或Fragment中使用ViewBinding生成绑定类。例如，在Activity中：

private ActivityMainBinding binding;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    binding = ActivityMainBinding.inflate(getLayoutInflater());
    setContentView(binding.getRoot());

    // 使用binding对象访问和操作视图
    binding.textView.setText("Hello, ViewBinding!");
}

3. 使用生成的绑定类对象来访问和操作视图。例如，可以使用binding对象来访问布局中的TextView：

binding.textView.setText("Hello, ViewBinding!");

在Fragment中使用

在Fragment中使用ViewBinding可以方便地绑定布局文件中的视图，避免了使用findViewById的繁琐操作。下面是
在Fragment中生成ViewBinding类的实例，并使用它来访问布局文件中的视图：

class MyFragment : Fragment() {
    private var _binding: FragmentLayoutBinding? = null
    private val binding get() = _binding!!

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        _binding = FragmentLayoutBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 使用binding访问视图
        binding.textView.text = "Hello, ViewBinding!"
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

在Adapter中使用

在Adapter类中创建一个内部类ViewHolder，用于保存每个列表项的视图绑定对象。例如：

class MyAdapter(private val dataList: List<Data>) : RecyclerView.Adapter<MyAdapter.ViewHolder>() {

    inner class ViewHolder(private val binding: ItemLayoutBinding) : RecyclerView.ViewHolder(binding.root) {
        fun bind(data: Data) {
            binding.textView.text = data.text
            // 绑定其他视图
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val binding = ItemLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return ViewHolder(binding)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val data = dataList[position]
        holder.bind(data)
    }

    override fun getItemCount(): Int {
        return dataList.size
    }
}

1. 在 onCreateViewHolder 方法中，使用 ViewBinding.inflate 方法来创建视图绑定对象。需要传入布局文件的 LayoutInflater、父布局和是否将绑定的视图添加到父布局中。

2. 在 ViewHolder 类中，通过构造函数接收视图绑定对象，并在 bind 方法中设置视图的数据。可以通过视图绑定对象的属性来访问布局文件中的视图。

3. 在 onBindViewHolder 方法中，通过调用 bind 方法来绑定数据到视图。

在Dialog中使用

在Dialog的代码中，使用ViewBinding来绑定布局文件中的视图：

public class MyDialog extends Dialog {
    private DialogLayoutBinding binding;

    public MyDialog(Context context) {
        super(context);
        binding = DialogLayoutBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 可以通过binding对象来访问布局文件中的视图
        binding.textView.setText("Hello World");
    }
}

include标签的使用

在使用ViewBinding时，我们可以通过在布局文件中添加标签来引入其他布局文件的视图，并在代码中使用ViewBinding来访问这些视图。

首先，在主布局文件中添加标签，指定要引入的布局文件：

<include
    layout="@layout/other_layout"
    android:id="@+id/included_layout" />

然后，在代码中使用ViewBinding来访问引入的布局文件中的视图：

val binding = MainLayoutBinding.inflate(layoutInflater)
val includedBinding = IncludedLayoutBinding.bind(binding.includedLayout.root)

// 访问引入布局文件中的视图
includedBinding.textView.text = "Hello World"

注意，IncludedLayoutBinding是根据引入的布局文件名自动生成的，所以请根据实际情况修改。

ViewStub标签的使用

在Android开发中，ViewStub标签是一个轻量级的视图容器，它可以在需要时延迟加载视图，从而提高应用的性能和内存使用效率。使用ViewStub标签可以将一个占位视图（placeholder）添加到布局中，并在需要时动态地替换为实际的视图。

要使用ViewStub标签，首先需要在XML布局文件中定义ViewStub元素，如下所示：

<ViewStub
    android:id="@+id/view_stub"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout="@layout/your_placeholder_layout" />

其中，android:id属性用于标识ViewStub，android:layout属性指定了占位视图的布局文件。

1. 在你的Activity或Fragment中，使用ViewBinding来绑定ViewStub。首先，在你的类中声明一个ViewBinding的变量：

private lateinit var binding: YourLayoutBinding

2. 在你的代码中，找到ViewStub并使用inflate()方法来填充布局并获取绑定的实例：

val viewStub = findViewById<ViewStub>(R.id.viewStub)
binding = YourLayoutBinding.inflate(viewStub.layoutInflater, viewStub, false)
viewStub.setOnInflateListener { _, inflated ->
    binding = YourLayoutBinding.bind(inflated)
}

3. 现在，你可以使用binding变量来访问ViewStub中的视图元素了。例如，你可以使用binding来设置文本或点击事件：

binding.textView.text = "Hello, ViewStub!"
binding.button.setOnClickListener { // 点击事件 }

这样，你就可以在ViewStub中使用ViewBinding了。记得在不需要使用ViewStub时，可以使用setVisibility()方法来隐藏它。

这样，当视图加载完成后，就会触发监听器的回调方法，可以在回调方法中进行相关操作。

总结

总结来说，ViewBinding是一种方便、高效的视图绑定方式，可以减少代码的冗余和错误，并提高开发效率。它是Android开发中的一个很好的工具，值得开发者们去尝试和使用。通过使用ViewBinding，可以减少代码量，提高开发效率，并且避免了因为使用findViewById()方法而可能导致的类型转换错误。