Android DataBinding：长按、滑动等复杂事件绑定原理(15)

一、复杂事件绑定概述

1.1 复杂事件绑定的意义

在 Android 应用开发中，用户与界面的交互不仅局限于简单的点击操作，长按、滑动等复杂事件在提升用户体验、实现丰富功能方面起着关键作用。Android DataBinding 作为强大的数据绑定框架，若能有效支持复杂事件绑定，可将视图交互逻辑与数据紧密结合，减少样板代码，提升开发效率，同时使代码结构更加清晰，便于维护和扩展。

1.2 常见复杂事件类型

1. 长按事件：常用于触发菜单、删除确认等操作，例如在列表项上长按弹出删除或编辑菜单。
2. 滑动事件：常见于滑动列表、滑动切换页面（如 ViewPager 的滑动）、手势滑动操作（如侧滑返回）等场景。
3. 多点触控事件：在一些绘图、游戏等应用中，需要处理多点触控的复杂交互，如捏合缩放、旋转等。

1.3 传统处理方式的局限

在未使用 DataBinding 进行复杂事件处理时，通常需要在 Java 或 Kotlin 代码中手动设置各种监听器，如 OnLongClickListener、OnTouchListener 等。这种方式存在诸多问题：

1. 代码冗长：大量的监听器设置和事件处理逻辑分散在不同的代码文件中，导致代码结构混乱。
2. 耦合度高：视图与事件处理逻辑紧密耦合，不利于代码的复用和维护。
3. 可读性差：复杂的事件处理代码使得代码的可读性降低，增加了后续开发和调试的难度。

二、DataBinding 基础回顾

2.1 DataBinding 核心组件

1. Binding 类：由 DataBinding 编译器为每个布局文件生成，负责将布局中的视图与数据进行绑定，是实现数据与视图交互的核心类。
2. DataBinderMapper：用于映射布局文件与对应的 Binding 类，在运行时根据布局资源 ID 找到并实例化相应的 Binding 类。
3. Observable 数据类：实现了 Observable 接口的数据类，当数据发生变化时，能够通知与之绑定的视图进行更新，保证数据与视图的一致性。
4. LiveData：具有生命周期感知能力的可观察数据持有者类，常用于在 ViewModel 中存储和管理与 UI 相关的数据，确保数据更新与界面生命周期相匹配。
5. ViewModel：负责存储和管理与 UI 相关的数据和逻辑，与 Activity 或 Fragment 分离，通过 DataBinding 与视图进行交互，提升代码的可维护性和可测试性。

2.2 DataBinding 工作流程

1. 编译时处理：DataBinding 编译器解析布局文件，识别其中的变量声明、数据绑定表达式以及事件绑定信息，生成对应的 Binding 类代码。在这个过程中，编译器会对复杂事件绑定的相关信息进行分析和处理，生成相应的代码逻辑。
2. 运行时初始化：在 Activity 或 Fragment 中，通过 DataBindingUtil 类加载布局并获取 Binding 实例。然后将数据对象（如 ViewModel）设置到 Binding 实例中，完成数据与视图的绑定。此时，Binding 类中的复杂事件绑定逻辑也会被初始化，使视图能够响应相应的复杂事件。

2.3 事件绑定在 DataBinding 中的位置

事件绑定是 DataBinding 实现视图与数据交互的重要组成部分。对于复杂事件绑定，它通过在布局文件中声明相关属性和表达式，将视图的复杂交互行为与数据对象中的方法或逻辑关联起来。在运行时，Binding 类根据这些绑定信息，为视图设置相应的监听器，并在事件触发时调用数据对象中的处理方法，从而实现复杂事件的处理。

三、长按事件绑定

3.1 布局文件中的声明方式

在 DataBinding 中，长按事件绑定通过在布局文件的视图标签中使用 android:onLongClick 属性来实现。基本语法如下：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <!-- 声明一个 ViewModel 类型的变量 -->
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="长按我"
        <!-- 绑定 ViewModel 中的长按处理方法 -->
        android:onLongClick="@{() -> viewModel.onLongClick()}" />
</layout>

在上述代码中，android:onLongClick 属性通过 @{} 语法绑定了 viewModel 中的 onLongClick 方法，当 TextView 被长按超过一定时间时，该方法将被调用。

3.2 编译器的处理过程

在编译阶段，DataBinding 编译器对布局文件进行解析，识别 android:onLongClick 属性及其绑定的表达式。解析过程主要涉及以下关键步骤：

1. 布局文件解析：编译器使用 LayoutFileParser 类解析布局文件的 XML 文档。

// LayoutFileParser.java (DataBinding 编译器内部类)
public class LayoutFileParser {
    public ProcessedResource parseResourceFile(ResourceFile resourceFile) {
        // 解析 XML 文档
        Document document = XmlUtils.parseXml(resourceFile.getInputStream());
        Element rootElement = document.getDocumentElement();
        
        // 遍历根元素下的所有子元素
        NodeList childNodes = rootElement.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node node = childNodes.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                Element element = (Element) node;
                // 处理视图标签
                if (isViewTag(element)) {
                    processViewTag(element);
                }
            }
        }
        
        return new ProcessedResource(resourceFile, mLayoutInfo);
    }
    
    private void processViewTag(Element element) {
        // 获取视图标签的属性集合
        NamedNodeMap attributes = element.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node attribute = attributes.item(i);
            String attrName = attribute.getNodeName();
            String attrValue = attribute.getNodeValue();
            
            // 检查是否是长按事件绑定属性
            if ("android:onLongClick".equals(attrName)) {
                // 处理长按事件绑定
                processOnLongClickAttribute(element, attrValue);
            }
        }
    }
    
    private void processOnLongClickAttribute(Element element, String attrValue) {
        // 解析长按事件表达式
        Expression expression = parseExpression(attrValue);
        
        // 创建长按事件绑定信息
        LongClickBinding longClickBinding = new LongClickBinding(expression);
        
        // 将长按事件绑定信息添加到视图信息中
        mLayoutInfo.addLongClickBinding(element, longClickBinding);
    }
}

在上述代码中，LayoutFileParser 类遍历视图标签的属性，当发现 android:onLongClick 属性时，解析其表达式并创建 LongClickBinding 对象，记录长按事件绑定信息。

2. 代码生成：编译器根据解析得到的长按事件绑定信息，生成对应的 Binding 类代码。在 BindingClass 类中，负责生成长按事件绑定相关代码。

// BindingClass.java (DataBinding 编译器内部类)
public class BindingClass {
    public void generateCode() {
        // 生成长按事件绑定代码
        generateLongClickBindingCode();
        
        // 生成其他绑定代码...
    }
    
    private void generateLongClickBindingCode() {
        // 遍历所有长按事件绑定信息
        for (LongClickBinding longClickBinding : mLongClickBindings) {
            Element viewElement = longClickBinding.getViewElement();
            Expression expression = longClickBinding.getExpression();
            
            // 获取视图的 ID
            String viewId = viewElement.getAttribute("android:id");
            int viewIdRes = getIdRes(viewId);
            
            // 生成长按事件处理代码
            generateLongClickHandlerCode(viewIdRes, expression);
        }
    }
    
    private void generateLongClickHandlerCode(int viewIdRes, Expression expression) {
        // 获取视图变量名
        String viewVariableName = getViewVariableName(viewIdRes);
        
        // 生成长按事件监听器设置代码
        code.append(viewVariableName + ".setOnLongClickListener(new View.OnLongClickListener() {\n");
        code.append("    @Override\n");
        code.append("    public boolean onLongClick(View v) {\n");
        
        // 生成长按事件表达式执行代码
        code.append(expression.generateCode() + ";\n");
        code.append("    return true;\n");
        code.append("    }\n");
        code.append("});\n");
    }
}

在 generateLongClickBindingCode 方法中，编译器遍历长按事件绑定信息，根据视图 ID 生成设置长按事件监听器的代码，并将长按事件表达式嵌入到监听器的 onLongClick 方法中。

3.3 运行时的绑定与触发

1. Binding 类初始化：在运行时，当通过 DataBindingUtil.inflate() 或 DataBindingUtil.setContentView() 方法加载布局时，生成的 Binding 类被实例化。在 Binding 类的构造函数中，会执行长按事件监听器的设置操作。

// ActivityMainBindingImpl.java (生成的 Binding 类)
public class ActivityMainBindingImpl extends ActivityMainBinding {
    public ActivityMainBindingImpl(LayoutInflater inflater, ViewGroup root, boolean attachToParent) {
        super(inflater, root, attachToParent);
        
        // 初始化视图绑定
        this.textView = root.findViewById(R.id.textView);
        
        // 获取数据对象
        final ViewModel viewModel = getViewModel();
        
        // 设置长按事件监听器
        this.textView.setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                // 调用 ViewModel 中的长按处理方法
                viewModel.onLongClick();
                return true;
            }
        });
    }
}

在上述代码中，Binding 类通过 findViewById 方法获取视图实例，然后为其设置长按事件监听器，并在监听器的 onLongClick 方法中调用 viewModel 的 onLongClick 方法。

2. 事件触发与处理：当用户在视图上长按超过系统默认的长按时间阈值（通常为 500 毫秒左右）时，视图的长按事件监听器的 onLongClick 方法被触发。在该方法中，调用 viewModel 中对应的长按处理方法，执行具体的业务逻辑，如弹出菜单、执行删除操作等。

四、滑动事件绑定

4.1 滑动事件的类型与应用场景

1. 水平滑动：常见于 ViewPager、RecyclerView 的横向滑动，用于切换页面或浏览列表项。
2. 垂直滑动：如 RecyclerView 的纵向滑动浏览列表、ScrollView 的垂直滚动等。
3. 自定义滑动手势：在一些应用中，可能需要识别用户从左到右、从右到左、从上到下、从下到上的滑动手势，以实现特定功能，如侧滑返回、下拉刷新等。

4.2 基于 OnTouchListener 的滑动事件绑定

在 DataBinding 中，对于滑动事件，通常通过自定义 OnTouchListener 并在布局文件中进行绑定来实现。

1. 布局文件声明：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        <!-- 绑定自定义的 OnTouchListener 方法 -->
        android:onTouch="@{viewModel::onTouch}" />
</layout>

在上述代码中，android:onTouch 属性绑定了 viewModel 中的 onTouch 方法，该方法将用于处理滑动事件。

2. ViewModel 中的处理方法：

// ViewModel.java
public class ViewModel {
    private static final int SWIPE_MIN_DISTANCE = 120;
    private static final int SWIPE_MAX_OFF_PATH = 250;
    private static final int SWIPE_THRESHOLD_VELOCITY = 200;

    private float downX, downY;

    public boolean onTouch(View view, MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                // 记录按下时的坐标
                downX = event.getX();
                downY = event.getY();
                return true;
            case MotionEvent.ACTION_UP:
                float upX = event.getX();
                float upY = event.getY();

                // 计算水平和垂直方向的滑动距离
                float deltaX = upX - downX;
                float deltaY = upY - downY;

                // 检查是否是有效的滑动（水平方向）
                if (Math.abs(deltaX) > Math.abs(deltaY) && Math.abs(deltaX) > SWIPE_MIN_DISTANCE &&
                        Math.abs(deltaY) < SWIPE_MAX_OFF_PATH && Math.abs(deltaX) > SWIPE_THRESHOLD_VELOCITY) {
                    if (deltaX > 0) {
                        // 右滑事件处理
                        onRightSwipe();
                    } else {
                        // 左滑事件处理
                        onLeftSwipe();
                    }
                    return true;
                }

                // 检查是否是有效的滑动（垂直方向）
                if (Math.abs(deltaY) > Math.abs(deltaX) && Math.abs(deltaY) > SWIPE_MIN_DISTANCE &&
                        Math.abs(deltaX) < SWIPE_MAX_OFF_PATH && Math.abs(deltaY) > SWIPE_THRESHOLD_VELOCITY) {
                    if (deltaY > 0) {
                        // 下滑事件处理
                        onDownSwipe();
                    } else {
                        // 上滑事件处理
                        onUpSwipe();
                    }
                    return true;
                }
                break;
        }
        return false;
    }

    public void onRightSwipe() {
        // 右滑事件处理逻辑
        Log.d("ViewModel", "Right swipe detected");
    }

    public void onLeftSwipe() {
        // 左滑事件处理逻辑
        Log.d("ViewModel", "Left swipe detected");
    }

    public void onDownSwipe() {
        // 下滑事件处理逻辑
        Log.d("ViewModel", "Down swipe detected");
    }

    public void onUpSwipe() {
        // 上滑事件处理逻辑
        Log.d("ViewModel", "Up swipe detected");
    }
}

在 onTouch 方法中，通过记录手指按下和抬起时的坐标，计算滑动距离和速度，判断是否满足滑动事件的条件，并根据滑动方向调用相应的处理方法。

3. 编译器与运行时处理：编译器在解析布局文件时，会处理 android:onTouch 属性的绑定信息，生成 Binding 类中设置 OnTouchListener 的代码。在运行时，Binding 类实例化后，为视图设置 OnTouchListener，当用户在视图上进行滑动操作时，onTouch 方法被调用，从而执行滑动事件的处理逻辑。

4.3 RecyclerView 的滑动事件绑定特殊处理

对于 RecyclerView 的滑动事件，除了上述通用的 OnTouchListener 方式，还可以利用其自身的滑动监听器进行更方便的处理。

1. 布局文件声明：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:adapter="@{viewModel.adapter}"
        <!-- 绑定 RecyclerView 的滑动监听器方法 -->
        app:onScroll="@{viewModel::onRecyclerViewScroll}" />
</layout>

在上述代码中，app:onScroll 属性绑定了 viewModel 中的 onRecyclerViewScroll 方法，用于处理 RecyclerView 的滑动事件。

2. ViewModel 中的处理方法：

// ViewModel.java
import androidx.recyclerview.widget.RecyclerView;

public class ViewModel {
    private RecyclerView.Adapter adapter;

    public RecyclerView.Adapter getAdapter() {
        return adapter;
    }

    public void setAdapter(RecyclerView.Adapter adapter) {
        this.adapter = adapter;
    }

    public void onRecyclerViewScroll(RecyclerView recyclerView, int dx, int dy) {
        if (dy > 0) {
            // 向下滑动
            Log.d("ViewModel", "RecyclerView is scrolling down");
        } else if (dy < 0) {
            // 向上滑动
            Log.d("ViewModel", "RecyclerView is scrolling up");
        }

        if (dx > 0) {
            // 向右滑动
            Log.d("ViewModel", "RecyclerView is scrolling right");
        } else if (dx < 0) {
            // 向左滑动
            Log.d("ViewModel", "RecyclerView is scrolling left");
        }
    }
}

在 onRecyclerViewScroll 方法中

// ViewModel.java
import androidx.recyclerview.widget.RecyclerView;

public class ViewModel {
    private RecyclerView.Adapter adapter;

    public RecyclerView.Adapter getAdapter() {
        return adapter;
    }

    public void setAdapter(RecyclerView.Adapter adapter) {
        this.adapter = adapter;
    }

    public void onRecyclerViewScroll(RecyclerView recyclerView, int dx, int dy) {
        if (dy > 0) {
            // 向下滑动
            Log.d("ViewModel", "RecyclerView is scrolling down");
        } else if (dy < 0) {
            // 向上滑动
            Log.d("ViewModel", "RecyclerView is scrolling up");
        }

        if (dx > 0) {
            // 向右滑动
            Log.d("ViewModel", "RecyclerView is scrolling right");
        } else if (dx < 0) {
            // 向左滑动
            Log.d("ViewModel", "RecyclerView is scrolling left");
        }
    }
}

在onRecyclerViewScroll方法中，根据dx和dy的值判断RecyclerView的滑动方向，并进行相应的处理。其中，dy表示垂直方向的滑动距离，正值表示向下滑动，负值表示向上滑动；dx表示水平方向的滑动距离，正值表示向右滑动，负值表示向左滑动。

3. 自定义BindingAdapter实现RecyclerView滑动监听： 要使app:onScroll属性生效，需要创建一个自定义的BindingAdapter。以下是实现代码：

// RecyclerViewBindingAdapters.java
import androidx.databinding.BindingAdapter;
import androidx.recyclerview.widget.RecyclerView;

public class RecyclerViewBindingAdapters {
    // 自定义BindingAdapter，用于设置RecyclerView的滑动监听器
    @BindingAdapter("onScroll")
    public static void setOnScrollListener(RecyclerView recyclerView, final RecyclerViewScrollListener listener) {
        // 如果传入的监听器为空，则不设置
        if (listener == null) {
            recyclerView.clearOnScrollListeners();
            return;
        }
        
        // 添加RecyclerView的滑动监听器
        recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            @Override
            public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                // 调用传入的监听器的方法，传递滑动距离参数
                listener.onScrolled(recyclerView, dx, dy);
            }
            
            @Override
            public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
                // 调用传入的监听器的方法，传递滑动状态参数
                listener.onScrollStateChanged(recyclerView, newState);
            }
        });
    }
    
    // 定义一个接口，用于传递RecyclerView的滑动事件
    public interface RecyclerViewScrollListener {
        void onScrolled(RecyclerView recyclerView, int dx, int dy);
        void onScrollStateChanged(RecyclerView recyclerView, int newState);
    }
}

在上述代码中，@BindingAdapter("onScroll")注解声明了一个名为onScroll的自定义BindingAdapter。当布局文件中使用app:onScroll属性时，会调用这个方法来设置RecyclerView的滑动监听器。

4. Binding类的生成与运行时处理： 编译器在处理布局文件时，会识别app:onScroll属性并调用对应的BindingAdapter。生成的Binding类代码如下：

// ActivityMainBindingImpl.java (生成的Binding类)
public class ActivityMainBindingImpl extends ActivityMainBinding {
    public ActivityMainBindingImpl(LayoutInflater inflater, ViewGroup root, boolean attachToParent) {
        super(inflater, root, attachToParent);
        
        // 初始化RecyclerView
        this.recyclerView = root.findViewById(R.id.recyclerView);
        
        // 获取ViewModel
        final ViewModel viewModel = getViewModel();
        
        // 设置RecyclerView的适配器
        if (viewModel.getAdapter() != null) {
            this.recyclerView.setAdapter(viewModel.getAdapter());
        }
        
        // 设置RecyclerView的滑动监听器
        RecyclerViewBindingAdapters.setOnScrollListener(this.recyclerView, new RecyclerViewBindingAdapters.RecyclerViewScrollListener() {
            @Override
            public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                // 调用ViewModel中的滑动处理方法
                viewModel.onRecyclerViewScroll(recyclerView, dx, dy);
            }
            
            @Override
            public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
                // 可以在这里处理滑动状态变化的逻辑
            }
        });
    }
}

在运行时，当RecyclerView发生滑动时，会触发RecyclerView.OnScrollListener的回调方法，进而调用ViewModel中的onRecyclerViewScroll方法，实现对RecyclerView滑动事件的处理。

4.4 ViewPager的滑动事件绑定

ViewPager的滑动事件绑定与RecyclerView类似，但也有其特殊性。ViewPager的滑动事件主要通过ViewPager.OnPageChangeListener来监听。

1. 布局文件声明：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <androidx.viewpager.widget.ViewPager
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:adapter="@{viewModel.pagerAdapter}"
        <!-- 绑定ViewPager的页面变化监听器 -->
        app:onPageChange="@{viewModel::onPageChanged}" />
</layout>

在上述代码中，app:onPageChange属性绑定了viewModel中的onPageChanged方法，用于处理ViewPager的页面变化事件。

2. ViewModel中的处理方法：

// ViewModel.java
import androidx.viewpager.widget.ViewPager;

public class ViewModel {
    private PagerAdapter pagerAdapter;

    public PagerAdapter getPagerAdapter() {
        return pagerAdapter;
    }

    public void setPagerAdapter(PagerAdapter pagerAdapter) {
        this.pagerAdapter = pagerAdapter;
    }

    public void onPageChanged(int position) {
        // 页面切换后的处理逻辑
        Log.d("ViewModel", "Current page position: " + position);
    }

    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        // 页面滚动中的处理逻辑
        Log.d("ViewModel", "Page scrolled: position=" + position + 
                ", positionOffset=" + positionOffset + 
                ", positionOffsetPixels=" + positionOffsetPixels);
    }

    public void onPageScrollStateChanged(int state) {
        // 页面滚动状态变化的处理逻辑
        String stateString;
        switch (state) {
            case ViewPager.SCROLL_STATE_IDLE:
                stateString = "IDLE";
                break;
            case ViewPager.SCROLL_STATE_DRAGGING:
                stateString = "DRAGGING";
                break;
            case ViewPager.SCROLL_STATE_SETTLING:
                stateString = "SETTLING";
                break;
            default:
                stateString = "UNKNOWN";
        }
        Log.d("ViewModel", "Page scroll state changed: " + stateString);
    }
}

在上述代码中，onPageChanged方法处理页面切换完成后的事件，onPageScrolled方法处理页面滚动过程中的事件，onPageScrollStateChanged方法处理页面滚动状态变化的事件。

3. 自定义BindingAdapter实现ViewPager监听： 要使app:onPageChange属性生效，需要创建一个自定义的BindingAdapter：

// ViewPagerBindingAdapters.java
import androidx.databinding.BindingAdapter;
import androidx.viewpager.widget.ViewPager;

public class ViewPagerBindingAdapters {
    // 自定义BindingAdapter，用于设置ViewPager的页面变化监听器
    @BindingAdapter("onPageChange")
    public static void setOnPageChangeListener(ViewPager viewPager, final ViewPagerPageChangeListener listener) {
        // 如果传入的监听器为空，则不设置
        if (listener == null) {
            viewPager.clearOnPageChangeListeners();
            return;
        }
        
        // 添加ViewPager的页面变化监听器
        viewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
                // 调用传入的监听器的方法，传递页面滚动信息
                listener.onPageScrolled(position, positionOffset, positionOffsetPixels);
            }
            
            @Override
            public void onPageSelected(int position) {
                // 调用传入的监听器的方法，传递选中的页面位置
                listener.onPageSelected(position);
            }
            
            @Override
            public void onPageScrollStateChanged(int state) {
                // 调用传入的监听器的方法，传递页面滚动状态
                listener.onPageScrollStateChanged(state);
            }
        });
    }
    
    // 定义一个接口，用于传递ViewPager的页面变化事件
    public interface ViewPagerPageChangeListener {
        void onPageScrolled(int position, float positionOffset, int positionOffsetPixels);
        void onPageSelected(int position);
        void onPageScrollStateChanged(int state);
    }
}

在上述代码中，@BindingAdapter("onPageChange")注解声明了一个名为onPageChange的自定义BindingAdapter。当布局文件中使用app:onPageChange属性时，会调用这个方法来设置ViewPager的页面变化监听器。

4. Binding类的生成与运行时处理： 编译器在处理布局文件时，会识别app:onPageChange属性并调用对应的BindingAdapter。生成的Binding类代码如下：

// ActivityMainBindingImpl.java (生成的Binding类)
public class ActivityMainBindingImpl extends ActivityMainBinding {
    public ActivityMainBindingImpl(LayoutInflater inflater, ViewGroup root, boolean attachToParent) {
        super(inflater, root, attachToParent);
        
        // 初始化ViewPager
        this.viewPager = root.findViewById(R.id.viewPager);
        
        // 获取ViewModel
        final ViewModel viewModel = getViewModel();
        
        // 设置ViewPager的适配器
        if (viewModel.getPagerAdapter() != null) {
            this.viewPager.setAdapter(viewModel.getPagerAdapter());
        }
        
        // 设置ViewPager的页面变化监听器
        ViewPagerBindingAdapters.setOnPageChangeListener(this.viewPager, new ViewPagerBindingAdapters.ViewPagerPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
                // 调用ViewModel中的页面滚动处理方法
                viewModel.onPageScrolled(position, positionOffset, positionOffsetPixels);
            }
            
            @Override
            public void onPageSelected(int position) {
                // 调用ViewModel中的页面选中处理方法
                viewModel.onPageChanged(position);
            }
            
            @Override
            public void onPageScrollStateChanged(int state) {
                // 调用ViewModel中的页面滚动状态变化处理方法
                viewModel.onPageScrollStateChanged(state);
            }
        });
    }
}

在运行时，当ViewPager的页面发生变化时，会触发ViewPager.OnPageChangeListener的回调方法，进而调用ViewModel中的相应方法，实现对ViewPager滑动事件的处理。

五、多点触控事件绑定

5.1 多点触控事件概述

多点触控是指触摸屏设备能够同时检测到多个触摸点的技术。在Android开发中，多点触控事件可以实现捏合缩放、旋转、多手指滑动等复杂操作，为应用提供更加丰富的交互体验。

5.2 多点触控事件的处理原理

Android中的多点触控事件由MotionEvent类处理，通过getActionMasked()方法获取事件类型，通过getPointerCount()方法获取触摸点的数量，通过getPointerId()和getX(int pointerIndex)、getY(int pointerIndex)方法获取每个触摸点的ID和坐标。

多点触控事件的主要类型包括：

• MotionEvent.ACTION_DOWN：第一个手指按下
• MotionEvent.ACTION_POINTER_DOWN：额外的手指按下
• MotionEvent.ACTION_MOVE：手指移动
• MotionEvent.ACTION_POINTER_UP：非最后一个手指抬起
• MotionEvent.ACTION_UP：最后一个手指抬起
• MotionEvent.ACTION_CANCEL：事件取消

5.3 基于DataBinding的多点触控事件绑定实现

要在DataBinding中处理多点触控事件，同样需要通过自定义OnTouchListener并在布局文件中进行绑定。

1. 布局文件声明：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <ImageView
        android:id="@+id/imageView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:src="@drawable/sample_image"
        <!-- 绑定自定义的OnTouchListener方法 -->
        android:onTouch="@{viewModel::onMultiTouch}" />
</layout>

在上述代码中，android:onTouch属性绑定了viewModel中的onMultiTouch方法，用于处理多点触控事件。

2. ViewModel中的处理方法：

// ViewModel.java
import android.view.MotionEvent;
import android.view.View;
import android.widget.ImageView;

public class ViewModel {
    private static final int NONE = 0;
    private static final int DRAG = 1;
    private static final int ZOOM = 2;
    
    private int mode = NONE;
    private float oldDist = 1f;
    private float scale = 1f;
    
    public boolean onMultiTouch(View view, MotionEvent event) {
        ImageView imageView = (ImageView) view;
        
        switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
                // 第一个手指按下
                mode = DRAG;
                return true;
                
            case MotionEvent.ACTION_POINTER_DOWN:
                // 额外的手指按下
                if (event.getPointerCount() >= 2) {
                    // 计算两个手指之间的距离
                    oldDist = spacing(event);
                    if (oldDist > 10f) {
                        mode = ZOOM;
                    }
                }
                return true;
                
            case MotionEvent.ACTION_MOVE:
                // 手指移动
                if (mode == DRAG) {
                    // 单指拖动
                    float dx = event.getX() - event.getRawX();
                    float dy = event.getY() - event.getRawY();
                    imageView.setTranslationX(imageView.getTranslationX() + dx);
                    imageView.setTranslationY(imageView.getTranslationY() + dy);
                } else if (mode == ZOOM && event.getPointerCount() >= 2) {
                    // 双指缩放
                    float newDist = spacing(event);
                    if (newDist > 10f) {
                        scale = newDist / oldDist;
                        imageView.setScaleX(imageView.getScaleX() * scale);
                        imageView.setScaleY(imageView.getScaleY() * scale);
                        oldDist = newDist;
                    }
                }
                return true;
                
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                // 手指抬起
                mode = NONE;
                return true;
        }
        
        return false;
    }
    
    // 计算两个手指之间的距离
    private float spacing(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }
}

在onMultiTouch方法中，根据不同的事件类型和触摸点数量，实现了单指拖动和双指缩放的功能。通过MotionEvent.getPointerCount()获取触摸点数量，通过spacing方法计算两个手指之间的距离，从而实现缩放操作。

3. Binding类的生成与运行时处理： 编译器在处理布局文件时，会生成设置OnTouchListener的代码，与前面的长按、滑动事件类似。在运行时，当用户在ImageView上进行多点触控操作时，onMultiTouch方法会被调用，从而实现对多点触控事件的处理。

六、复杂事件绑定的高级应用

6.1 自定义事件绑定

在某些情况下，系统提供的事件绑定可能无法满足需求，此时可以通过自定义BindingAdapter来实现特定的事件绑定。

1. 自定义双击事件绑定：

// CustomBindingAdapters.java
import android.view.View;
import androidx.databinding.BindingAdapter;

public class CustomBindingAdapters {
    private static final long DOUBLE_CLICK_TIME_DELTA = 300; // 双击间隔时间
    
    @BindingAdapter("onDoubleClick")
    public static void setOnDoubleClickListener(final View view, final View.OnClickListener listener) {
        view.setOnClickListener(new View.OnClickListener() {
            private long lastClickTime = 0;
            
            @Override
            public void onClick(View v) {
                long clickTime = System.currentTimeMillis();
                if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA) {
                    // 双击事件
                    if (listener != null) {
                        listener.onClick(v);
                    }
                    lastClickTime = 0;
                } else {
                    // 单次点击事件
                    lastClickTime = clickTime;
                }
            }
        });
    }
}

在上述代码中，通过自定义BindingAdapter实现了双击事件的绑定。在布局文件中可以这样使用：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="双击我"
    app:onDoubleClick="@{() -> viewModel.onDoubleClick()}" />

2. 自定义长按滑动事件绑定： 有时候需要在长按之后进行滑动操作，这可以通过自定义BindingAdapter来实现：

// CustomBindingAdapters.java
import android.view.MotionEvent;
import android.view.View;
import androidx.databinding.BindingAdapter;

public class CustomBindingAdapters {
    @BindingAdapter("onLongPressDrag")
    public static void setOnLongPressDragListener(final View view, final OnLongPressDragListener listener) {
        if (listener == null) {
            view.setOnTouchListener(null);
            return;
        }
        
        view.setOnTouchListener(new View.OnTouchListener() {
            private boolean isLongPressed = false;
            private float startX, startY;
            
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        startX = event.getX();
                        startY = event.getY();
                        isLongPressed = false;
                        // 发送长按事件
                        view.postDelayed(new Runnable() {
                            @Override
                            public void run() {
                                if (!isLongPressed) {
                                    isLongPressed = true;
                                    listener.onLongPress(v);
                                }
                            }
                        }, 500); // 长按时间阈值
                        return true;
                        
                    case MotionEvent.ACTION_MOVE:
                        if (isLongPressed) {
                            float dx = event.getX() - startX;
                            float dy = event.getY() - startY;
                            listener.onDrag(v, dx, dy);
                        }
                        return true;
                        
                    case MotionEvent.ACTION_UP:
                    case MotionEvent.ACTION_CANCEL:
                        isLongPressed = false;
                        return true;
                }
                return false;
            }
        });
    }
    
    public interface OnLongPressDragListener {
        void onLongPress(View view);
        void onDrag(View view, float dx, float dy);
    }
}

在布局文件中可以这样使用：

<View
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:onLongPressDrag="@{viewModel::onLongPressDrag}" />

6.2 事件绑定的参数传递

在事件绑定中，有时候需要传递额外的参数给处理方法。DataBinding支持在事件绑定表达式中传递参数。

1. 传递基本类型参数：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="传递参数"
    android:onClick="@{() -> viewModel.onButtonClick(123, &quot;Hello&quot;)}" />

在ViewModel中对应的方法：

public void onButtonClick(int id, String message) {
    // 处理带参数的点击事件
    Log.d("ViewModel", "Received: id=" + id + ", message=" + message);
}

2. 传递View对象参数：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="传递View"
    android:onClick="@{(view) -> viewModel.onButtonClick(view)}" />

在ViewModel中对应的方法：

public void onButtonClick(View view) {
    // 处理带View参数的点击事件
    Log.d("ViewModel", "Button clicked: " + view.getId());
}

3. 传递事件对象参数：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="传递事件"
    android:onClick="@{(view, event) -> viewModel.onButtonClick(view, event)}" />

在ViewModel中对应的方法：

public void onButtonClick(View view, MotionEvent event) {
    // 处理带事件参数的点击事件
    Log.d("ViewModel", "Button clicked at: " + event.getX() + ", " + event.getY());
}

6.3 事件绑定的条件处理

在某些情况下，可能需要根据条件来决定是否执行事件处理方法。DataBinding支持在事件绑定表达式中使用条件判断。

1. 简单条件判断：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="条件点击"
    android:onClick="@{isEnabled ? () -> viewModel.onButtonClick() : null}" />

在上述代码中，只有当isEnabled为true时，点击事件才会调用viewModel.onButtonClick()方法，否则不执行任何操作。

2. 复杂条件判断：

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="复杂条件"
    android:onClick="@{(user != null && user.isLoggedIn()) ? () -> viewModel.onButtonClick() : () -> viewModel.onLoginRequired()}" />

在上述代码中，如果用户已登录（user != null && user.isLoggedIn()），则点击事件调用viewModel.onButtonClick()方法；否则调用viewModel.onLoginRequired()方法。

七、性能优化与注意事项

7.1 事件绑定的性能考虑

1. 避免频繁创建监听器：在布局文件中使用事件绑定表达式时，要避免每次都创建新的对象。例如：

<!-- 不推荐：每次都会创建新的Runnable对象 -->
android:onClick="@{() -> new Runnable() { @Override public void run() { /* 执行代码 */ } }.run()}"

<!-- 推荐：使用ViewModel中的方法 -->
android:onClick="@{() -> viewModel.doSomething()}"

2. 避免在事件处理方法中执行耗时操作：事件处理方法通常在主线程中执行，如果执行耗时操作，会导致UI卡顿。对于耗时操作，应使用异步线程处理。

3. 合理使用弱引用：在某些情况下，特别是在自定义BindingAdapter中，如果需要持有View或Activity的引用，应使用弱引用，避免内存泄漏。

7.2 常见问题与解决方案

1. 事件冲突问题：当多个事件监听器同时存在时，可能会发生事件冲突。例如，同时设置了onClick和onLongClick监听器，长按事件可能会阻止点击事件的触发。解决方案是根据实际需求合理设计事件处理逻辑，或者在事件处理方法中返回适当的值。

2. 滑动冲突问题：在嵌套滑动的场景中，可能会出现滑动冲突。例如，在RecyclerView中嵌套ViewPager，或者在ScrollView中嵌套RecyclerView等。解决方案是通过自定义onInterceptTouchEvent方法或使用Android提供的NestedScrolling机制来处理滑动冲突。

3. 内存泄漏问题：如果在事件监听器中持有Activity或Fragment的引用，可能会导致内存泄漏。特别是在使用内部类或匿名内部类时，要注意避免隐式持有外部类的引用。解决方案是使用静态内部类或弱引用来持有Activity或Fragment的引用。

7.3 最佳实践

1. 保持事件处理逻辑简单：事件处理方法应尽量简洁，避免包含过多的业务逻辑。复杂的业务逻辑应放在ViewModel或其他专门的类中处理。

2. 使用命名方法而非Lambda表达式：在布局文件中使用命名方法而非Lambda表达式，这样可以提高代码的可读性和可维护性。例如：

<!-- 推荐：使用命名方法 -->
android:onClick="@{viewModel::onButtonClick}"

<!-- 不推荐：使用Lambda表达式 -->
android:onClick="@{() -> viewModel.onButtonClick()}"

3. 遵循单一职责原则：每个事件处理方法应只负责一项明确的任务，遵循单一职责原则，提高代码的可测试性和可维护性。

4. 合理使用自定义BindingAdapter：对于复杂的事件绑定需求，应使用自定义BindingAdapter来实现，而不是在布局文件中编写复杂的表达式。

八、与其他架构组件的集成

8.1 与ViewModel的集成

DataBinding与ViewModel的集成是Android应用开发中的常见模式。ViewModel负责处理UI相关的数据和逻辑，而DataBinding则负责将这些数据和逻辑绑定到视图上。

1. 在ViewModel中定义事件处理方法：

// ViewModel.java
public class ViewModel extends ViewModel {
    private MutableLiveData<String> message = new MutableLiveData<>();
    
    public LiveData<String> getMessage() {
        return message;
    }
    
    public void onButtonClick() {
        message.setValue("Button clicked!");
    }
    
    public void onLongClick() {
        message.setValue("Long click detected!");
    }
    
    public void onSwipe() {
        message.setValue("Swipe detected!");
    }
}

2. 在布局文件中绑定事件处理方法：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="点击我"
            android:onClick="@{viewModel::onButtonClick}" />
            
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="长按我"
            android:onLongClick="@{viewModel::onLongClick}" />
            
        <View
            android:layout_width="match_parent"
            android:layout_height="200dp"
            android:background="#CCCCCC"
            android:onTouch="@{viewModel::onTouch}" />
            
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{viewModel.message}" />
    </LinearLayout>
</layout>

3. 在Activity中设置ViewModel和DataBinding：

// MainActivity.java
public class MainActivity extends AppCompatActivity {
    private ActivityMainBinding binding;
    private ViewModel viewModel;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // 初始化DataBinding
        binding = ActivityMainBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        
        // 初始化ViewModel
        viewModel = new ViewModelProvider(this).get(ViewModel.class);
        
        // 设置ViewModel到DataBinding
        binding.setViewModel(viewModel);
        
        // 设置生命周期所有者
        binding.setLifecycleOwner(this);
    }
}

8.2 与LiveData的集成

LiveData是一种具有生命周期感知能力的可观察数据持有者类，与DataBinding结合使用可以实现数据的自动更新。

1. 在ViewModel中使用LiveData：

// ViewModel.java
public class ViewModel extends ViewModel {
    private MutableLiveData<Boolean> isLoading = new MutableLiveData<>();
    private MutableLiveData<List<String>> items = new MutableLiveData<>();
    
    public LiveData<Boolean> getIsLoading() {
        return isLoading;
    }
    
    public LiveData<List<String>> getItems() {
        return items;
    }
    
    public void loadData() {
        isLoading.setValue(true);
        
        // 模拟加载数据
        new Handler(Looper.getMainLooper()).postDelayed(() -> {
            List<String> data = new ArrayList<>();
            data.add("Item 1");
            data.add("Item 2");
            data.add("Item 3");
            items.setValue(data);
            isLoading.setValue(false);
        }, 2000);
    }
    
    public void onRefresh() {
        loadData();
    }
}

2. 在布局文件中绑定LiveData：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        
        <androidx.swiperefreshlayout.widget.SwipeRefreshLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:onRefresh="@{viewModel::onRefresh}"
            android:refreshing="@{viewModel.isLoading}">
            
            <androidx.recyclerview.widget.RecyclerView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                app:items="@{viewModel.items}" />
        </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
    </LinearLayout>
</layout>

8.3 与Room的集成

Room是Android官方的持久化库，与DataBinding结合使用可以实现数据库数据的自动更新到UI。

1. 定义Entity和DAO：

// User.java
@Entity(tableName = "users")
public class User {
    @PrimaryKey(autoGenerate = true)
    private int id;
    
    private String name;
    private int age;
    
    // 构造方法、Getter和Setter方法
}

// UserDao.java
@Dao
public interface UserDao {
    @Query("SELECT * FROM users")
    LiveData<List<User>> getAllUsers();
    
    @Insert
    void insert(User user);
}

2. 定义ViewModel：

// UserViewModel.java
public class UserViewModel extends ViewModel {
    private LiveData<List<User>> users;
    private UserRepository repository;
    
    public UserViewModel(Application application) {
        super();
        repository = new UserRepository(application);
        users = repository.getAllUsers();
    }
    
    public LiveData<List<User>> getUsers() {
        return users;
    }
    
    public void addUser(User user) {
        repository.insert(user);
    }
}

3. 在布局文件中绑定数据：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.UserViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        
        <androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:items="@{viewModel.users}" />
    </LinearLayout>
</layout>

九、实际案例分析

9.1 案例一：实现图片缩放与拖拽功能

在这个案例中，我们将使用DataBinding实现一个可以缩放和拖拽的图片查看器。

1. 布局文件：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ImageViewModel" />
    </data>
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        
        <ImageView
            android:id="@+id/imageView"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="matrix"
            android:src="@drawable/sample_image"
            android:onTouch="@{viewModel::onTouch}" />
            
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"
            android:text="重置"
            android:onClick="@{viewModel::resetImage}" />
    </RelativeLayout>
</layout>

2. ViewModel：

// ImageViewModel.java
public class ImageViewModel {
    private static final int NONE = 0;
    private static final int DRAG = 1;
    private static final int ZOOM = 2;
    
    private int mode = NONE;
    private float scale = 1f;
    private Matrix matrix = new Matrix();
    private Matrix savedMatrix = new Matrix();
    private PointF start = new PointF();
    private PointF mid = new PointF();
    private float oldDist = 1f;
    
    public boolean onTouch(View v, MotionEvent event) {
        ImageView view = (ImageView) v;
        
        switch (event.getAction() & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                savedMatrix.set(matrix);
                start.set(event.getX(), event.getY());
                mode = DRAG;
                break;
                
            case MotionEvent.ACTION_POINTER_DOWN:
                oldDist = spacing(event);
                if (oldDist > 10f) {
                    savedMatrix.set(matrix);
                    midPoint(mid, event);
                    mode = ZOOM;
                }
                break;
                
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                mode = NONE;
                break;
                
            case MotionEvent.ACTION_MOVE:
                if (mode == DRAG) {
                    matrix.set(savedMatrix);
                    matrix.postTranslate(event.getX() - start.x, event.getY() - start.y);
                } else if (mode == ZOOM) {
                    float newDist = spacing(event);
                    if (newDist > 10f) {
                        matrix.set(savedMatrix);
                        float scale = newDist / oldDist;
                        matrix.postScale(scale, scale, mid.x, mid.y);
                    }
                }
                break;
        }
        
        view.setImageMatrix(matrix);
        return true;
    }
    
    private float spacing(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }
    
    private void midPoint(PointF point, MotionEvent event) {
        float x = event.getX(0) + event.getX(1);
        float y = event.getY(0) + event.getY(1);
        point.set(x / 2, y / 2);
    }
    
    public void resetImage() {
        matrix.reset();
        scale = 1f;
        // 更新ImageView的Matrix
        // 这里需要通过某种方式通知ImageView更新
        // 可以使用LiveData或回调接口
    }
}

9.2 案例二：实现滑动删除的RecyclerView

在这个案例中，我们将使用DataBinding实现一个支持滑动删除的RecyclerView。

1. 布局文件：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.demo.ListViewModel" />
    </data>
    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:adapter="@{viewModel.adapter}"
        app:onScroll="@{viewModel::onScroll}" />
</layout>

2. ViewModel：

// ListViewModel.java
public class ListViewModel extends ViewModel {
    private ObservableArrayList<String> items = new ObservableArrayList<>();
    private ItemAdapter adapter;
    
    public ListViewModel() {
        // 初始化数据
        for (int i = 0; i < 20; i++) {
            items.add("Item " + i);
        }
        
        // 初始化适配器
        adapter = new ItemAdapter(items);
    }
    
    public ItemAdapter getAdapter() {
        return adapter;
    }
    
    public void onScroll(RecyclerView recyclerView, int dx, int dy) {
        // 处理滚动事件
    }
    
    public void deleteItem(int position) {
        items.remove(position);
    }
}

3. 适配器：

// ItemAdapter.java
public class ItemAdapter extends RecyclerView.Adapter<ItemAdapter.ItemViewHolder> {
    private List<String> items;
    
    public ItemAdapter(List<String> items) {
        this.items = items;
    }
    
    @NonNull
    @Override
    public ItemViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        ItemBinding binding = ItemBinding.inflate(inflater, parent, false);
        return new ItemViewHolder(binding);
    }
    
    @Override
    public void onBindViewHolder(@NonNull ItemViewHolder holder, int position) {
        String item = items.get(position);
        holder.binding.setItem(item);
        holder.binding.setPosition(position);
        holder.binding.setViewModel(new ItemViewModel());
    }
    
    @Override
    public int getItemCount() {
        return items.size();
    }
    
    public static class ItemViewHolder extends RecyclerView.ViewHolder {
        private ItemBinding binding;
        
        public ItemViewHolder(ItemBinding binding) {
            super(binding.getRoot());
            this.binding = binding;
        }
    }
}

4. 子项ViewModel：

// ItemViewModel.java
public class ItemViewModel {
    public void onSwipe(int position) {
        // 通知父ViewModel删除该项
        // 可以通过接口回调或LiveData实现
    }
}

5. 子项布局文件：

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="item"
            type="java.lang.String" />
        <variable
            name="position"
            type="int" />
        <variable
            name="viewModel"
            type="com.example.demo.ItemViewModel" />
    </data>
    <androidx.cardview.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="8dp"
        android:onTouch="@{(view, event) -> viewModel.onTouch(view, event, position)}">
        
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:padding="16dp"
            android:text="@{item}" />
    </androidx.cardview.widget.CardView>
</layout>