# List组件通过拖拽改变排序

#### 问题现象

如何通过List列表实现拖拽改变排序的功能？以及能否做到拖拽排序功能可开关？

#### 效果预览

#### 背景知识

*   通用属性draggable能够设置组件是否允许进行拖拽，能够通过draggable控制拖拽排序功能的开关。
*   在绑定手势方法中，gesture属性能够给组件绑定手势方法，手势识别成功后可以通过事件回调通知组件。还可以通过组合手势的方法将多种手势组合为复合手势，支持连续识别、并行识别和互斥识别。
*   显式动画组件animateTo能够插入自定义过渡动效，在组件出现和消失时，可以通过组件内转场添加动画效果。

#### 解决方案

实现拖拽功能的方法与示例代码如下：

1.  定义scaleSelect方法，能够根据当前缩放的列表项和相邻项目返回缩放比例。如果当前列表项正在缩放，返回1.05；如果当前列表项是相邻项目，返回预设的缩放比例；否则返回1。
    
    ```
    scaleSelect(item: number): number {
      if (this.scaleItem === item) {
        return 1.05;
      } else if (this.neighborItem === item) {
        return this.neighborScale;
      } else {
        return 1;
      }
    }
    ```
    

2.  定义itemMove方法，该方法通过splice在数组中移动项目位置，改变项目排序。
    
    ```
    itemMove(index: number, newIndex: number): void {
      let tmp = this.arr.splice(index, 1);
      this.arr.splice(newIndex, 0, tmp[0]);
    }
    ```
    
3.  使用长按手势和滑动手势组成顺序识别组合手势。长按手势用于触发缩放效果，拖动手势用于拖动项目改变排序。通过animateTo设置显示动画。在拖动过程中，根据拖动的位移计算相邻项目的缩放比例，并且使用Curves.initCurve和interpolate方法实现平滑的缩放效果。
    
    ```
    // 添加手势
    .gesture(
      // 以下组合手势为顺序识别，当长按手势事件未正常触发时则不会触发拖动手势事件
      GestureGroup(GestureMode.Sequence,
        // 长按手势识别
        LongPressGesture({ repeat: true })
          .onAction(() => { // 长按手势识别成功回调
            // 设置显示动画为阻尼曲线，持续时间为300毫秒
            this.uiContext.animateTo({ curve: Curve.Friction, duration: 300 }, () => {
              this.scaleItem = item;
            });
          })
          // 长按手势识别成功，最后一根手指抬起后触发回调
          .onActionEnd(() => {
            // 设置显示动画为阻尼曲线，持续时间为300毫秒
            this.uiContext.animateTo({ curve: Curve.Friction, duration: 300 }, () => {
              this.scaleItem = -1;
            });
          }),
        // 设置滑动手势事件，任意滑动方向都能够触发事件，触发滑动手势事件的最小滑动距离为0
        PanGesture({ fingers: 1, direction: null, distance: 0 })
        // 滑动手势识别成功回调
          .onActionStart(() => {
            this.dragItem = item;
            this.dragRefOffset = 0;
          })
          // 滑动手势移动过程中回调
          .onActionUpdate((event: GestureEvent) => {
            this.offsetY = event.offsetY - this.dragRefOffset;
            this.neighborItem = -1;
            let index = this.arr.indexOf(item);
            let curveValue: ICurve = curves.initCurve(Curve.Sharp);
            let value: number = 0;
            // 根据位移计算相邻项的缩放
            if (this.offsetY < 0) {
              value = curveValue.interpolate(-this.offsetY / this.itemIntv);
              this.neighborItem = this.arr[index - 1];
              this.neighborScale = 1 - value / 20;
              console.info('neighborScale:' + this.neighborScale.toString());
            } else if (this.offsetY > 0) {
              value = curveValue.interpolate(this.offsetY / this.itemIntv);
              this.neighborItem = this.arr[index + 1];
              this.neighborScale = 1 - value / 20;
            }
            // 根据位移交换排序
            if (this.offsetY > this.itemIntv / 2) {
              // 设置显式动画曲线，
              this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                this.offsetY -= this.itemIntv;
                this.dragRefOffset += this.itemIntv;
                this.itemMove(index, index + 1);
              });
            } else if (this.offsetY < -this.itemIntv / 2) {
              this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                this.offsetY += this.itemIntv;
                this.dragRefOffset -= this.itemIntv;
                this.itemMove(index, index - 1);
              });
            }
          })
          // 滑动手势识别成功，手指抬起后触发回调
          .onActionEnd(() => {
            console.info(this.arr.toString());
            this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
              this.dragItem = -1;
              this.neighborItem = -1;
            });
            this.uiContext.animateTo({
              curve: curves.interpolatingSpring(14, 1, 170, 17), delay: 150
            }, () => {
              this.scaleItem = -1;
            });
          })
      )
      // 滑动手势识别成功，接收到触摸取消事件触发回调
        .onCancel(() => {
          this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
            this.dragItem = -1;
            this.neighborItem = -1;
          });
          this.uiContext.animateTo({
            curve: curves.interpolatingSpring(14, 1, 170, 17), delay: 150
          }, () => {
            this.scaleItem = -1;
          });
        })
    );
    ```
    

完整示例参考如下：

```
import { curves } from '@kit.ArkUI';

@Entry
@Component
struct ListDrag {
  @State private arr: number[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  @State dragItem: number = -1; // 当前拖拽的项目
  @State scaleItem: number = -1; // 当前缩放的项目
  @State neighborItem: number = -1; // 相邻项目
  @State neighborScale: number = -1; // 相邻项目的缩放比例
  private dragRefOffset: number = 0; // 拖拽参考偏移
  offsetX: number = 0; // 偏移量
  @State offsetY: number = 0;
  private itemIntv: number = 120; // 项目间隔
  @State moveControls: boolean = false; // 控制拖拽功能
  private uiContext: UIContext = this.getUIContext();

  aboutToAppear() {
    this.uiContext = this.getUIContext();
  }

  scaleSelect(item: number): number {
    if (this.scaleItem === item) {
      return 1.05;
    } else if (this.neighborItem === item) {
      return this.neighborScale;
    } else {
      return 1;
    }
  }

  itemMove(index: number, newIndex: number): void {
    let tmp = this.arr.splice(index, 1);
    this.arr.splice(newIndex, 0, tmp[0]);
  }

  build() {
    Stack() {
      Column() {
        Button('moveControls:' + !this.moveControls)
          .width(200)
          .margin(20)
          .onClick(() => {
            this.moveControls = !this.moveControls;
          });
        List({ space: 20, initialIndex: 0 }) {
          ForEach(this.arr, (item: number) => {
            ListItem() {
              Text('' + item)
                .width('100%')
                .height(100)
                .fontSize(16)
                .textAlign(TextAlign.Center)
                .borderRadius(10)
                .backgroundColor('#f1f3f5')
                // 通过状态变量scaleItem判断是否为组件添加阴影效果
                .shadow(this.scaleItem === item ? {
                  radius: 70,
                  color: '#15000000',
                  offsetX: 0,
                  offsetY: 0
                } :
                  {
                    radius: 0,
                    // 阴影半径为0，相当于没有阴影
                    color: '#15000000',
                    offsetX: 0,
                    offsetY: 0
                  })
                // 设置锐利曲线动画，持续时间为300毫秒
                .animation({ curve: Curve.Sharp, duration: 300 });
            }
            .draggable(this.moveControls)
            .margin({ left: 12, right: 12 })
            // 增加x轴、y轴缩放效果
            .scale({ x: this.scaleSelect(item), y: this.scaleSelect(item) })
            // 设置组件的堆叠顺序，实现拖拽过程中被拖拽组件覆盖其他组件的效果
            .zIndex(this.dragItem === item ? 1 : 0)
            // 设置页面转场时的纵向的平移距离
            .translate(this.dragItem === item ? { y: this.offsetY } : { y: 0 })
            // 添加手势
            .gesture(
              // 以下组合手势为顺序识别，当长按手势事件未正常触发时则不会触发拖动手势事件
              GestureGroup(GestureMode.Sequence,
                // 长按手势识别
                LongPressGesture({ repeat: true })
                  .onAction(() => { // 长按手势识别成功回调
                    // 设置显示动画为阻尼曲线，持续时间为300毫秒
                    this.uiContext.animateTo({ curve: Curve.Friction, duration: 300 }, () => {
                      this.scaleItem = item;
                    });
                  })
                  // 长按手势识别成功，最后一根手指抬起后触发回调
                  .onActionEnd(() => {
                    // 设置显示动画为阻尼曲线，持续时间为300毫秒
                    this.uiContext.animateTo({ curve: Curve.Friction, duration: 300 }, () => {
                      this.scaleItem = -1;
                    });
                  }),
                // 设置滑动手势事件，任意滑动方向都能够触发事件，触发滑动手势事件的最小滑动距离为0
                PanGesture({ fingers: 1, direction: null, distance: 0 })
                // 滑动手势识别成功回调
                  .onActionStart(() => {
                    this.dragItem = item;
                    this.dragRefOffset = 0;
                  })
                  // 滑动手势移动过程中回调
                  .onActionUpdate((event: GestureEvent) => {
                    this.offsetY = event.offsetY - this.dragRefOffset;
                    this.neighborItem = -1;
                    let index = this.arr.indexOf(item);
                    let curveValue: ICurve = curves.initCurve(Curve.Sharp);
                    let value: number = 0;
                    // 根据位移计算相邻项的缩放
                    if (this.offsetY < 0) {
                      value = curveValue.interpolate(-this.offsetY / this.itemIntv);
                      this.neighborItem = this.arr[index - 1];
                      this.neighborScale = 1 - value / 20;
                      console.info('neighborScale:' + this.neighborScale.toString());
                    } else if (this.offsetY > 0) {
                      value = curveValue.interpolate(this.offsetY / this.itemIntv);
                      this.neighborItem = this.arr[index + 1];
                      this.neighborScale = 1 - value / 20;
                    }
                    // 根据位移交换排序
                    if (this.offsetY > this.itemIntv / 2) {
                      // 设置显式动画曲线，
                      this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                        this.offsetY -= this.itemIntv;
                        this.dragRefOffset += this.itemIntv;
                        this.itemMove(index, index + 1);
                      });
                    } else if (this.offsetY < -this.itemIntv / 2) {
                      this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                        this.offsetY += this.itemIntv;
                        this.dragRefOffset -= this.itemIntv;
                        this.itemMove(index, index - 1);
                      });
                    }
                  })
                  // 滑动手势识别成功，手指抬起后触发回调
                  .onActionEnd(() => {
                    console.info(this.arr.toString());
                    this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                      this.dragItem = -1;
                      this.neighborItem = -1;
                    });
                    this.uiContext.animateTo({
                      curve: curves.interpolatingSpring(14, 1, 170, 17), delay: 150
                    }, () => {
                      this.scaleItem = -1;
                    });
                  })
              )
              // 滑动手势识别成功，接收到触摸取消事件触发回调
                .onCancel(() => {
                  this.uiContext.animateTo({ curve: curves.interpolatingSpring(0, 1, 400, 38) }, () => {
                    this.dragItem = -1;
                    this.neighborItem = -1;
                  });
                  this.uiContext.animateTo({
                    curve: curves.interpolatingSpring(14, 1, 170, 17), delay: 150
                  }, () => {
                    this.scaleItem = -1;
                  });
                })
            );
          }, (item: number) => item.toString());
        };
      }
      .width('100%')
      .height('100%')
      .padding({ top: 5 });
    };
  }
}
```

#### 常见FAQ

Q：二级嵌套List中使用什么方法触发拖拽回调？

A：使用onDragStart作为在拖拽开始时触发的回调；拖拽结束时的回调函数使用List组件的方法onItemDrop绑定列表元素作为拖拽释放目标，当在列表元素内停止拖拽时触发。

Q：通过onItemDrag实现拖拽改变排序，拖拽开始时，手指放在子组件的左侧或右侧，被拖拽的子组件就会偏左侧或偏右，如何解决？

A：基于onItemDrag实现的拖拽，拖拽的小窗是基于手指位置居中的，改用手势实现拖拽即可。

Q：在分组外添加了分组标题如：“分组一”，如何让标题参与到拖拽排序中？

A：可以将标题用ListItem包裹，参与List排序。

Q：Grid能够使用supportAnimation设置动画属性实现拖拽动画，List如何实现拖拽动画？

A：List组件不支持设置supportAnimation属性，但是可以通过使用onMove方法实现拖拽动画，也可以结合拖拽事件、组合手势、动画效果来实现拖拽动画效果，具体实现可参考解决方案。