format code

Author: 110

iosApp/iosApp/UI/Page/Compose/Haptic/FlareHapticManager.swift

@@ -1,51 +1,49 @@
 
 import CoreHaptics
-import SwiftUI
 import Foundation
+import SwiftUI
 #if canImport(UIKit)
-import UIKit
+    import UIKit
 #endif
 
- @MainActor
+@MainActor
 @Observable
 public final class FlareHapticManager {
-    
-     public static let shared = FlareHapticManager()
-    
+    public static let shared = FlareHapticManager()
 
-     public enum ImpactStyle: String, CaseIterable {
-        case light = "light"
-        case medium = "medium"
-        case heavy = "heavy"
-        case soft = "soft"
-        case rigid = "rigid"
+    public enum ImpactStyle: String, CaseIterable {
+        case light
+        case medium
+        case heavy
+        case soft
+        case rigid
 
         public var displayName: String {
             switch self {
-            case .light: return "Light"
-            case .medium: return "Medium"
-            case .heavy: return "Heavy"
-            case .soft: return "Soft"
-            case .rigid: return "Rigid"
+            case .light: "Light"
+            case .medium: "Medium"
+            case .heavy: "Heavy"
+            case .soft: "Soft"
+            case .rigid: "Rigid"
             }
         }
     }
 
-     public enum NotificationStyle: String, CaseIterable {
-        case success = "success"
-        case warning = "warning"
-        case error = "error"
+    public enum NotificationStyle: String, CaseIterable {
+        case success
+        case warning
+        case error
 
         public var displayName: String {
             switch self {
-            case .success: return "Success"
-            case .warning: return "Warning"
-            case .error: return "Error"
+            case .success: "Success"
+            case .warning: "Warning"
+            case .error: "Error"
             }
         }
     }
 
-     public enum HapticType {
+    public enum HapticType {
         case impact(ImpactStyle)
         case selection
         case notification(NotificationStyle)
@@ -63,170 +61,159 @@ public final class FlareHapticManager {
         public static let warning = HapticType.notification(.warning)
         public static let error = HapticType.notification(.error)
     }
-    
 
     #if !os(visionOS) && canImport(UIKit)
-    private var impactGenerators: [UIImpactFeedbackGenerator.FeedbackStyle: UIImpactFeedbackGenerator] = [:]
-    private let selectionGenerator = UISelectionFeedbackGenerator()
-    private let notificationGenerator = UINotificationFeedbackGenerator()
+        private var impactGenerators: [UIImpactFeedbackGenerator.FeedbackStyle: UIImpactFeedbackGenerator] = [:]
+        private let selectionGenerator = UISelectionFeedbackGenerator()
+        private let notificationGenerator = UINotificationFeedbackGenerator()
     #endif
 
-     private var appSettings: AppSettings {
-        return AppSettings()
+    private var appSettings: AppSettings {
+        AppSettings()
     }
-    
 
     private init() {
         #if !os(visionOS) && canImport(UIKit)
-         selectionGenerator.prepare()
-        notificationGenerator.prepare()
+            selectionGenerator.prepare()
+            notificationGenerator.prepare()
         #endif
     }
-    
 
-
-     public var supportsHaptics: Bool {
+    public var supportsHaptics: Bool {
         #if os(visionOS)
-        return false
+            return false
         #elseif canImport(UIKit)
-        return CHHapticEngine.capabilitiesForHardware().supportsHaptics
+            return CHHapticEngine.capabilitiesForHardware().supportsHaptics
         #else
-        return false
+            return false
         #endif
     }
 
-     public func prepare(_ type: HapticType) {
+    public func prepare(_ type: HapticType) {
         #if !os(visionOS) && canImport(UIKit)
-        guard supportsHaptics else { return }
-
-        switch type {
-        case .impact(let style):
-            impactGenerator(for: uiImpactStyle(from: style)).prepare()
-        case .selection, .tabSelection:
-            selectionGenerator.prepare()
-        case .notification, .buttonPress:
-            notificationGenerator.prepare()
-        case .dataRefresh:
-            impactGenerator(for: .heavy).prepare()
-        }
+            guard supportsHaptics else { return }
+
+            switch type {
+            case let .impact(style):
+                impactGenerator(for: uiImpactStyle(from: style)).prepare()
+            case .selection, .tabSelection:
+                selectionGenerator.prepare()
+            case .notification, .buttonPress:
+                notificationGenerator.prepare()
+            case .dataRefresh:
+                impactGenerator(for: .heavy).prepare()
+            }
         #endif
     }
-    
-     public func generate(_ type: HapticType) {
+
+    public func generate(_ type: HapticType) {
         #if !os(visionOS) && canImport(UIKit)
-        guard supportsHaptics else { return }
+            guard supportsHaptics else { return }
 
-        
-        guard shouldGenerateHaptic(for: type) else { return }
+            guard shouldGenerateHaptic(for: type) else { return }
 
-        switch type {
-        case .impact(let style):
-            impactGenerator(for: uiImpactStyle(from: style)).impactOccurred()
+            switch type {
+            case let .impact(style):
+                impactGenerator(for: uiImpactStyle(from: style)).impactOccurred()
 
-        case .selection:
-            selectionGenerator.selectionChanged()
+            case .selection:
+                selectionGenerator.selectionChanged()
 
-        case .notification(let style):
-            notificationGenerator.notificationOccurred(uiNotificationStyle(from: style))
+            case let .notification(style):
+                notificationGenerator.notificationOccurred(uiNotificationStyle(from: style))
 
-        case .buttonPress:
-            let userIntensity = getUserIntensityStyle()
-            impactGenerator(for: userIntensity).impactOccurred()
+            case .buttonPress:
+                let userIntensity = getUserIntensityStyle()
+                impactGenerator(for: userIntensity).impactOccurred()
 
-        case .tabSelection:
-            selectionGenerator.selectionChanged()
+            case .tabSelection:
+                selectionGenerator.selectionChanged()
 
-        case .dataRefresh(let intensity):
-            let userIntensity = getUserIntensityStyle()
-            impactGenerator(for: userIntensity).impactOccurred(intensity: intensity)
-        }
+            case let .dataRefresh(intensity):
+                let userIntensity = getUserIntensityStyle()
+                impactGenerator(for: userIntensity).impactOccurred(intensity: intensity)
+            }
         #endif
     }
-    
 
-     public func buttonPress() {
+    public func buttonPress() {
         generate(.buttonPress)
     }
 
-     public func tabSelection() {
+    public func tabSelection() {
         generate(.tabSelection)
     }
 
-     public func selection() {
+    public func selection() {
         generate(.selection)
     }
 
-     public func success() {
+    public func success() {
         generate(.success)
     }
 
-     public func warning() {
+    public func warning() {
         generate(.warning)
     }
 
-     public func error() {
+    public func error() {
         generate(.error)
     }
 
-     public func dataRefresh(intensity: CGFloat = 1.0) {
+    public func dataRefresh(intensity: CGFloat = 1.0) {
         generate(.dataRefresh(intensity: intensity))
     }
 }
 
-
 extension FlareHapticManager {
-    
     #if !os(visionOS) && canImport(UIKit)
-     private func impactGenerator(for style: UIImpactFeedbackGenerator.FeedbackStyle) -> UIImpactFeedbackGenerator {
-        if let generator = impactGenerators[style] {
-            return generator
-        } else {
-            let generator = UIImpactFeedbackGenerator(style: style)
-            impactGenerators[style] = generator
-            return generator
+        private func impactGenerator(for style: UIImpactFeedbackGenerator.FeedbackStyle) -> UIImpactFeedbackGenerator {
+            if let generator = impactGenerators[style] {
+                return generator
+            } else {
+                let generator = UIImpactFeedbackGenerator(style: style)
+                impactGenerators[style] = generator
+                return generator
+            }
         }
-    }
 
-  
-    private func uiImpactStyle(from style: ImpactStyle) -> UIImpactFeedbackGenerator.FeedbackStyle {
-        switch style {
-        case .light: return .light
-        case .medium: return .medium
-        case .heavy: return .heavy
-        case .soft: return .soft
-        case .rigid: return .rigid
+        private func uiImpactStyle(from style: ImpactStyle) -> UIImpactFeedbackGenerator.FeedbackStyle {
+            switch style {
+            case .light: .light
+            case .medium: .medium
+            case .heavy: .heavy
+            case .soft: .soft
+            case .rigid: .rigid
+            }
         }
-    }
 
-     private func uiNotificationStyle(from style: NotificationStyle) -> UINotificationFeedbackGenerator.FeedbackType {
-        switch style {
-        case .success: return .success
-        case .warning: return .warning
-        case .error: return .error
+        private func uiNotificationStyle(from style: NotificationStyle) -> UINotificationFeedbackGenerator.FeedbackType {
+            switch style {
+            case .success: .success
+            case .warning: .warning
+            case .error: .error
+            }
         }
-    }
     #endif
 
-     private func shouldGenerateHaptic(for type: HapticType) -> Bool {
-        return appSettings.appearanceSettings.hapticFeedback.isEnabled
+    private func shouldGenerateHaptic(for _: HapticType) -> Bool {
+        appSettings.appearanceSettings.hapticFeedback.isEnabled
     }
 
     #if !os(visionOS) && canImport(UIKit)
-     private func getUserIntensityStyle() -> UIImpactFeedbackGenerator.FeedbackStyle {
-        let userIntensity = appSettings.appearanceSettings.hapticFeedback.intensity
-        switch userIntensity {
-        case .light: return .light
-        case .medium: return .medium
-        case .heavy: return .heavy
+        private func getUserIntensityStyle() -> UIImpactFeedbackGenerator.FeedbackStyle {
+            let userIntensity = appSettings.appearanceSettings.hapticFeedback.intensity
+            switch userIntensity {
+            case .light: return .light
+            case .medium: return .medium
+            case .heavy: return .heavy
+            }
         }
-    }
     #endif
 }
 
-
-extension FlareHapticManager {
-    
-     public struct HapticFeedbackModifier: ViewModifier {
+public extension FlareHapticManager {
+    struct HapticFeedbackModifier: ViewModifier {
         let hapticType: HapticType
 
         public func body(content: Content) -> some View {
@@ -238,17 +225,12 @@ extension FlareHapticManager {
     }
 }
 
- 
-extension View {
-
- 
-    public func hapticFeedback(_ type: FlareHapticManager.HapticType) -> some View {
+public extension View {
+    func hapticFeedback(_ type: FlareHapticManager.HapticType) -> some View {
         modifier(FlareHapticManager.HapticFeedbackModifier(hapticType: type))
     }
 
-     
-    public func hapticButtonPress() -> some View {
+    func hapticButtonPress() -> some View {
         hapticFeedback(.buttonPress)
     }
 }
-

iosApp/iosApp/UI/Page/Home/Model/TimelineExtState.swift

@@ -4,22 +4,17 @@ class TimelineExtState: ObservableObject {
     @Published var scrollToTopTrigger = false
     @Published var showFloatingButton = false
 
-   
-    @Published var tabBarOffset: CGFloat = 0  // TabBar偏移量，0=显示，100=隐藏
+    @Published var tabBarOffset: CGFloat = 0 // TabBar偏移量，0=显示，100=隐藏
     private var lastScrollOffset: CGFloat = 0
 
-    
     func updateTabBarOffset(currentOffset: CGFloat, isHomeTab: Bool) {
-         
         guard isHomeTab else {
-          
             if tabBarOffset != 0 {
                 tabBarOffset = 0
             }
             return
         }
 
-        
         if currentOffset <= 0 {
             if tabBarOffset != 0 {
                 tabBarOffset = 0
@@ -28,19 +23,16 @@ class TimelineExtState: ObservableObject {
             return
         }
 
-      
         let scrollDelta = currentOffset - lastScrollOffset
 
-         
-        if scrollDelta > 30 && tabBarOffset == 0 {
+        if scrollDelta > 30, tabBarOffset == 0 {
             tabBarOffset = 100
         }
-        
-        else if scrollDelta < -30 && tabBarOffset != 0 {
+
+        else if scrollDelta < -30, tabBarOffset != 0 {
             tabBarOffset = 0
         }
 
-         
         lastScrollOffset = currentOffset
     }
 }