探索 SwiftUI 基本手势

前言

在 SwiftUI 中，我们可以通过添加不同的交互来使我们的应用程序更具交互性，这些交互可以响应我们的点击，点击和滑动。

今天，我们将回顾SwiftUI基本手势：

• TapGesture
• 长按手势
• 拖动手势
• 放大手势
• 旋转手势

TapGesture

轻击手势使我们能够识别 View 上的一个或多个轻击。我们有几种方法可以添加点击手势。

第一个是直接使用 .onTapGesture 修饰符。

1. Circle() 
2.   .onTapGesture { 
3.     // Respond to Tap Gesture  
4.   } 

SwiftUI 文档中使用的其他选项是通过创建手势并将其配置为属性，然后将其与 .gesture(_：include :) 修饰符一起使用。

注意： 为了执行某项操作或响应轻击，我们需要使用 .onEnded 操作关闭，该操作在手势结束时触发。

1. struct SingleTapGestureView: View { 
2.   var singleTap: some Gesture { 
3.       TapGesture() 
4.           .onEnded { _ in 
5.               // Respond to Tap Gesture 
6.           } 
7.   } 
8.  
9.   var body: some View { 
10.       Circle() 
11.           .gesture(singleTap) 
12.   } 
13. } 

实际上，我更喜欢第二种方法，因为这样我们可以创建不同的手势并通过我们的代码重复使用它们。

因此，如果我们将代码放在一起，就可以开始编写类似的东西。

1. struct TapGestureView: View { 
2.     @State private var isAnimating = false 
3.     @State private var tapped1x = 0 
4.  
5.     var singleTap: some Gesture { 
6.         TapGesture() 
7.             .onEnded { _ in 
8.                 tapped1x += 1 
9.  
10.                 withAnimation(Animation.easeOut(duration: 0.5)) { 
11.                     self.isAnimating = true 
12.                 } 
13.  
14.                 DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { 
15.                     self.isAnimating = false 
16.                 } 
17.             } 
18.     } 
19.  
20.     var body: some View { 
21.         VStack { 
22.             Text("Tapped 1X: \(tapped1x) times") 
23.                 .font(.caption) 
24.  
25.             Circle() 
26.                 .frame(width: 80, height: 80) 
27.                 .foregroundColor(.orange) 
28.                 .overlay( 
29.                     Text("1X") 
30.                         .fontWeight(.medium) 
31.                 ) 
32.                 .background( 
33.                     Circle() 
34.                         .strokeBorder(Color.blue, lineWidth: 3) 
35.                         .scaleEffect(isAnimating ? 1.5 : 1) 
36.                         .opacity(isAnimating ? 0 : 1) 
37.                 ) 
38.                 .gesture(singleTap) 
39.         } 
40.     } 
41. } 

类似地，我们只需使用 TapGesture(count：Int) 初始化程序就可以控制要响应的数量。

在这种情况下，您需要点击3次才能触发 .onEnded 操作关闭。

1. struct TapGesture3xView: View { 
2.     @State private var isAnimating = false 
3.     @State private var tapped3x = 0 
4.  
5.     var multipleTap: some Gesture { 
6.         TapGesture(count: 3) 
7.             .onEnded { _ in 
8.                 tapped3x += 1 
9.  
10.                 withAnimation(Animation.easeOut(duration: 0.5)) { 
11.                     self.isAnimating = true 
12.                 } 
13.  
14.                 DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { 
15.                     self.isAnimating = false 
16.                 } 
17.             } 
18.     } 
19.  
20.     var body: some View { 
21.         VStack { 
22.             Text("Tapped 3X: \(tapped3x) times") 
23.                 .font(.caption) 
24.  
25.             Circle() 
26.                 .frame(width: 80, height: 80) 
27.                 .foregroundColor(.orange) 
28.                 .overlay( 
29.                     Text("3X") 
30.                         .fontWeight(.medium) 
31.                 ) 
32.                 .background( 
33.                     Circle() 
34.                         .strokeBorder(Color.blue, lineWidth: 3) 
35.                         .scaleEffect(isAnimating ? 1.5 : 1) 
36.                         .opacity(isAnimating ? 0 : 1) 
37.                 ) 
38.                 .gesture(multipleTap) 
39.         } 
40.     } 
41. } 

长按手势

长按手势可让我们在用户长按定义的时间后以及在用户长按的时间内执行操作。

我们可以设置一个最小持续时间，以识别我们的长按手势。可以在 LongPressGesture 初始化程序中进行设置。

1. LongPressGesture(minimumDuration: 2) 

然后，我们可以使用 .updating 方法在长按期间执行操作，并使用 .onEnded 在识别到我们的手势时执行操作。

在此示例中，我将在长按操作期间更新 Circle() 的大小和颜色，并且当识别出手势时，我将显示“文本已完成”。

另外，我在这里使用的是 GestureState 属性包装器，该包装器在长按期间设置为 true ，在手势结束时设置为 false 。我正在将此属性包装器用于示例动画。

1. struct LongPressGestureView: View { 
2.     @GestureState private var isLongPressDetected = false 
3.     @State private var isDone = false 
4.  
5.     var longPress: some Gesture { 
6.         LongPressGesture(minimumDuration: 2) 
7.             .updating($isLongPressDetected) { currentState, gestureState, transaction in 
8.                 DispatchQueue.main.async { 
9.                     isDone = false 
10.                 } 
11.                 gestureState = currentState 
12.                 transaction.animation = Animation.easeIn(duration: 2) 
13.             } 
14.             .onEnded { done in 
15.                 isDone = done 
16.             } 
17.     } 
18.  
19.     var body: some View { 
20.         VStack { 
21.             Spacer() 
22.  
23.             Circle() 
24.                 .frame(width: 10, height: 10) 
25.                 .foregroundColor(isLongPressDetected ? .orange : .primary) 
26.                 .scaleEffect(CGSize( 
27.                                 width: isLongPressDetected ? 10 : 1, 
28.                                 height: isLongPressDetected ? 10 : 1)) 
29.  
30.             Spacer() 
31.             if isLongPressDetected { 
32.                 Text("Updating...") 
33.             } 
34.  
35.             if isDone { 
36.                 Text("Done") 
37.             } 
38.  
39.             Spacer() 
40.  
41.             Text("Long Press 2 sec") 
42.                 .padding() 
43.                 .background(isLongPressDetected ? Color.green : Color.orange) 
44.                 .cornerRadius(16) 
45.                 .gesture(longPress) 
46.         } 
47.     } 
48. } 

 拖动手势

拖动手势允许我们在拖动视图时执行操作。

我们可以利用并使用 .onChanged 和 .onEnded 关闭方法来执行某些操作。这两种方法都为我们提供了出色的属性 DragGesture.Value，该属性存储以下拖动动作信息：

location

predictedEndLocation

predictedEndTranslation

startLocation

time

translation

我们可以使用该属性来创建可移动视图。在当前示例中，我使用 .onChanged 方法更新 Circle() 位置坐标。

1. struct DragGestureView: View { 
2.     @State private var location: CGPoint = CGPoint(x: 100, y: 100) 
3.  
4.     var drag: some Gesture { 
5.         DragGesture(minimumDistance: 1, coordinateSpace: .local) 
6.             .onChanged { value in 
7.                 location = value.location 
8.             } 
9.     } 
10.  
11.     var body: some View { 
12.         Circle() 
13.             .frame(width: 100, height: 100) 
14.             .foregroundColor(.orange) 
15.             .position(location) 
16.             .gesture(drag) 
17.     } 
18. } 

在这里，添加了 .onEnded 方法，以在拖动结束后重置 Circle() 位置坐标。

1. struct DragGestureView: View { 
2.     @State private var location: CGPoint = CGPoint(x: 100, y: 100) 
3.  
4.     var drag: some Gesture { 
5.         DragGesture(minimumDistance: 1, coordinateSpace: .local) 
6.             .onChanged { value in 
7.                 location = value.location 
8.             } 
9.             .onEnded { value in 
10.                 withAnimation(.easeOut) { 
11.                     location = CGPoint(x: 100, y: 100) 
12.                 } 
13.             } 
14.     } 
15.  
16.     var body: some View { 
17.         Circle() 
18.             .frame(width: 100, height: 100) 
19.             .foregroundColor(.orange) 
20.             .position(location) 
21.             .gesture(drag) 
22.     } 
23. } 

放大手势

当我们在View上应用放大动作时，放大手势允许做出一些动作。

在这里，还有 .onChanged 和 .onEnded 闭包，我们可以使用它们来在放大动作期间或结束时进行响应。作为属性，接收到的是 CGFloat 的 MagnificationGesture.Value 。我们可以以此为例来更改视图大小。

1. struct MagnificationGestureView: View { 
2.     @State var magnifiedValue: CGFloat = 1.0 
3.  
4.     var magnification: some Gesture { 
5.         MagnificationGesture() 
6.             .onChanged { value in 
7.                 magnifiedValue = value 
8.             } 
9.             .onEnded { value in 
10.                 magnifiedValue = 1.0 
11.             } 
12.     } 
13.  
14.     var body: some View { 
15.         Circle() 
16.             .frame(width: 100 * magnifiedValue, height: 100 * magnifiedValue) 
17.             .foregroundColor(.orange) 
18.             .gesture(magnification) 
19.             .animation(.easeOut) 
20.     } 
21. } 

旋转手势

旋转手势允许旋转视图，并在旋转过程中和旋转结束时以某些动作做出响应。

它还为我们提供了 .onChanged 和 .onEnded 闭包，这些闭包为我们提供了 RotationGesture.Value，它表示手势 Angle 值。我们可以使用该值旋转视图。

1. struct RotationGestureView: View { 
2.     @State private var angle = Angle(degrees: 0.0) 
3.     @State private var backgroundAngle = Angle(degrees: 0.0) 
4.  
5.     var rotation: some Gesture { 
6.         RotationGesture() 
7.             .onChanged { angle in 
8.                 self.angle = angle 
9.             } 
10.             .onEnded { angle in 
11.                 withAnimation(Animation.spring()) { 
12.                     self.backgroundAngle = angle 
13.                 } 
14.             } 
15.     } 
16.  
17.     var body: some View { 
18.         Rectangle() 
19.             .frame(width: 150, height: 150, alignment: .center) 
20.             .foregroundColor(.orange) 
21.             .rotationEffect(self.angle) 
22.             .gesture(rotation) 
23.             .background( 
24.                 Rectangle() 
25.                     .shadow(color: .primary, radius: 10, x: 0.0, y: 0.01) 
26.                     .foregroundColor(.secondary) 
27.                     .rotationEffect(backgroundAngle) 
28.             ) 
29.     } 
30. } 

总结

上面是对 SwiftUI 基本手势的总结。我们可以实现更多的交互使我们的 App 变得更生动。

对于高级的使用，可以将手势组合或者同时使用以做出响应，或者可以实现自己的自定义手势。

原文链接：https://mp.weixin.qq.com/s/r53xNP6GRWRV9cU97LIEKA