Swift中实现定时器按钮功能的完整指南从基础到进阶掌握定时按钮开发技巧解决常见问题提升用户体验打造专业iOS应用

威震华夏关云长

引言

定时器按钮是iOS应用中常见的UI组件，它允许用户启动一个倒计时或正计时功能，并在特定时间间隔执行某些操作。从验证码获取按钮到倒计时器，再到定时任务执行，定时器按钮在各种应用场景中都有广泛的应用。本文将全面介绍如何在Swift中实现定时器按钮功能，从基础概念到高级技巧，帮助开发者掌握这一重要功能，提升应用的专业性和用户体验。

Swift中的定时器基础

在Swift中，我们主要使用Timer类来创建定时器。Timer是Foundation框架中的一个类，它可以在指定的时间间隔后触发一个事件，或者重复触发事件。

Timer的基本用法

2. // 创建一个一次性定时器
3. let timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: false) { timer in
4.     print("定时器触发")
5. }
7. // 创建一个重复性定时器
8. let repeatingTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
9.     print("定时器重复触发")
10. }

复制代码

Timer的主要属性和方法

2. // 使定时器失效
3. timer.invalidate()
5. // 检查定时器是否有效
6. if timer.isValid {
7.     print("定时器有效")
8. }
10. // 获取定时器的触发时间间隔
11. let timeInterval = timer.timeInterval
13. // 获取定时器的触发日期
14. let fireDate = timer.fireDate

复制代码

RunLoop与Timer

定时器需要添加到RunLoop中才能正常工作。当我们使用scheduledTimer方法创建定时器时，它会自动被添加到当前线程的RunLoop中。如果我们需要手动控制定时器的RunLoop，可以使用以下方法：

2. // 创建定时器但不自动添加到RunLoop
3. let timer = Timer(timeInterval: 1.0, target: self, selector: #selector(timerAction), userInfo: nil, repeats: true)
5. // 将定时器添加到RunLoop
6. RunLoop.current.add(timer, forMode: .common)

复制代码

实现简单的定时器按钮

让我们从实现一个简单的定时器按钮开始，这个按钮在点击后开始倒计时，并在倒计时期间禁用。

基本实现

首先，创建一个基本的定时器按钮类：

2. import UIKit
4. class TimerButton: UIButton {
5.    
6.     // 定时器
7.     private var timer: Timer?
8.     // 剩余时间
9.     private var remainingTime: Int = 0
10.     // 总时间
11.     private var totalTime: Int = 60
12.    
13.     // 初始化方法
14.     init(frame: CGRect, totalTime: Int = 60) {
15.         super.init(frame: frame)
16.         self.totalTime = totalTime
17.         setupButton()
18.     }
19.    
20.     required init?(coder: NSCoder) {
21.         super.init(coder: coder)
22.         setupButton()
23.     }
24.    
25.     // 设置按钮样式
26.     private func setupButton() {
27.         setTitle("获取验证码", for: .normal)
28.         backgroundColor = .systemBlue
29.         setTitleColor(.white, for: .normal)
30.         layer.cornerRadius = 5
31.         addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
32.     }
33.    
34.     // 按钮点击事件
35.     @objc private func buttonTapped() {
36.         startTimer()
37.     }
38.    
39.     // 开始定时器
40.     private func startTimer() {
41.         remainingTime = totalTime
42.         isEnabled = false
43.         updateButtonTitle()
44.         
45.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
46.             self?.remainingTime -= 1
47.             self?.updateButtonTitle()
48.             
49.             if self?.remainingTime == 0 {
50.                 self?.stopTimer()
51.             }
52.         }
53.     }
54.    
55.     // 停止定时器
56.     private func stopTimer() {
57.         timer?.invalidate()
58.         timer = nil
59.         isEnabled = true
60.         setTitle("重新获取", for: .normal)
61.     }
62.    
63.     // 更新按钮标题
64.     private func updateButtonTitle() {
65.         setTitle("\(remainingTime)秒后重试", for: .disabled)
66.     }
67.    
68.     // 销毁定时器
69.     deinit {
70.         timer?.invalidate()
71.     }
72. }

复制代码

使用示例

在ViewController中使用这个定时器按钮：

2. import UIKit
4. class ViewController: UIViewController {
5.    
6.     override func viewDidLoad() {
7.         super.viewDidLoad()
8.         
9.         let timerButton = TimerButton(frame: CGRect(x: 50, y: 100, width: 200, height: 50))
10.         view.addSubview(timerButton)
11.         
12.         // 设置按钮居中
13.         timerButton.center.x = view.center.x
14.     }
15. }

复制代码

这个简单的定时器按钮实现了基本的功能：点击后开始倒计时，倒计时期间按钮禁用，倒计时结束后按钮恢复可用状态。

进阶功能 - 自定义定时器按钮

现在，让我们扩展定时器按钮的功能，使其更加灵活和可定制。

可配置的定时器按钮

2. import UIKit
4. class AdvancedTimerButton: UIButton {
5.    
6.     // MARK: - 公开属性
7.     var countdownDuration: Int = 60 {
8.         didSet {
9.             resetButton()
10.         }
11.     }
12.    
13.     var normalTitle: String = "获取验证码" {
14.         didSet {
15.             resetButton()
16.         }
17.     }
18.    
19.     var countingFormat: String = "%d秒后重试" {
20.         didSet {
21.             updateButtonTitle()
22.         }
23.     }
24.    
25.     var finishedTitle: String = "重新获取" {
26.         didSet {
27.             resetButton()
28.         }
29.     }
30.    
31.     var normalBackgroundColor: UIColor = .systemBlue {
32.         didSet {
33.             resetButton()
34.         }
35.     }
36.    
37.     var disabledBackgroundColor: UIColor = .systemGray {
38.         didSet {
39.             updateButtonAppearance()
40.         }
41.     }
42.    
43.     var normalTitleColor: UIColor = .white {
44.         didSet {
45.             resetButton()
46.         }
47.     }
48.    
49.     var disabledTitleColor: UIColor = .white {
50.         didSet {
51.             updateButtonAppearance()
52.         }
53.     }
54.    
55.     // MARK: - 私有属性
56.     private var timer: Timer?
57.     private var remainingTime: Int = 0
58.     private var isCountingDown: Bool = false
59.    
60.     // MARK: - 回调闭包
61.     var onStartCountdown: (() -> Void)?
62.     var onTick: ((Int) -> Void)?
63.     var onFinishCountdown: (() -> Void)?
64.    
65.     // MARK: - 初始化
66.     init(frame: CGRect, countdownDuration: Int = 60) {
67.         self.countdownDuration = countdownDuration
68.         super.init(frame: frame)
69.         setupButton()
70.     }
71.    
72.     required init?(coder: NSCoder) {
73.         super.init(coder: coder)
74.         setupButton()
75.     }
76.    
77.     // MARK: - 设置按钮
78.     private func setupButton() {
79.         resetButton()
80.         addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
81.     }
82.    
83.     // MARK: - 重置按钮
84.     private func resetButton() {
85.         isCountingDown = false
86.         isEnabled = true
87.         setTitle(normalTitle, for: .normal)
88.         backgroundColor = normalBackgroundColor
89.         setTitleColor(normalTitleColor, for: .normal)
90.     }
91.    
92.     // MARK: - 按钮点击事件
93.     @objc private func buttonTapped() {
94.         startCountdown()
95.     }
96.    
97.     // MARK: - 开始倒计时
98.     public func startCountdown() {
99.         guard !isCountingDown else { return }
100.         
101.         isCountingDown = true
102.         remainingTime = countdownDuration
103.         isEnabled = false
104.         updateButtonAppearance()
105.         
106.         onStartCountdown?()
107.         
108.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
109.             guard let self = self else { return }
110.             
111.             self.remainingTime -= 1
112.             self.updateButtonAppearance()
113.             self.onTick?(self.remainingTime)
114.             
115.             if self.remainingTime == 0 {
116.                 self.stopCountdown()
117.             }
118.         }
119.     }
120.    
121.     // MARK: - 停止倒计时
122.     public func stopCountdown() {
123.         guard isCountingDown else { return }
124.         
125.         timer?.invalidate()
126.         timer = nil
127.         isCountingDown = false
128.         isEnabled = true
129.         setTitle(finishedTitle, for: .normal)
130.         backgroundColor = normalBackgroundColor
131.         setTitleColor(normalTitleColor, for: .normal)
132.         
133.         onFinishCountdown?()
134.     }
135.    
136.     // MARK: - 更新按钮外观
137.     private func updateButtonAppearance() {
138.         let formattedTitle = String(format: countingFormat, remainingTime)
139.         setTitle(formattedTitle, for: .disabled)
140.         backgroundColor = disabledBackgroundColor
141.         setTitleColor(disabledTitleColor, for: .disabled)
142.     }
143.    
144.     // MARK: - 销毁定时器
145.     deinit {
146.         timer?.invalidate()
147.     }
148. }

复制代码

使用示例

2. import UIKit
4. class ViewController: UIViewController {
5.    
6.     override func viewDidLoad() {
7.         super.viewDidLoad()
8.         
9.         let timerButton = AdvancedTimerButton(frame: CGRect(x: 50, y: 100, width: 200, height: 50))
10.         
11.         // 配置按钮属性
12.         timerButton.countdownDuration = 10
13.         timerButton.normalTitle = "发送验证码"
14.         timerButton.countingFormat = "剩余%d秒"
15.         timerButton.finishedTitle = "再次发送"
16.         timerButton.normalBackgroundColor = .systemGreen
17.         timerButton.disabledBackgroundColor = .systemGray4
18.         
19.         // 设置回调
20.         timerButton.onStartCountdown = {
21.             print("开始倒计时")
22.         }
23.         
24.         timerButton.onTick = { remainingTime in
25.             print("剩余时间: \(remainingTime)秒")
26.         }
27.         
28.         timerButton.onFinishCountdown = {
29.             print("倒计时结束")
30.         }
31.         
32.         view.addSubview(timerButton)
33.         timerButton.center.x = view.center.x
34.     }
35. }

复制代码

支持多种定时器模式

让我们进一步扩展定时器按钮，使其支持多种定时器模式，如倒计时、正计时和一次性执行等。

2. import UIKit
4. enum TimerMode {
5.     case countdown(totalTime: Int)  // 倒计时模式
6.     case countup                   // 正计时模式
7.     case singleShot(timeInterval: TimeInterval) // 一次性执行模式
8. }
10. class MultiModeTimerButton: UIButton {
11.    
12.     // MARK: - 公开属性
13.     var timerMode: TimerMode = .countdown(totalTime: 60) {
14.         didSet {
15.             resetButton()
16.         }
17.     }
18.    
19.     var normalTitle: String = "开始计时" {
20.         didSet {
21.             resetButton()
22.         }
23.     }
24.    
25.     var countingFormat: String = "%d" {
26.         didSet {
27.             updateButtonTitle()
28.         }
29.     }
30.    
31.     var finishedTitle: String = "完成" {
32.         didSet {
33.             resetButton()
34.         }
35.     }
36.    
37.     var normalBackgroundColor: UIColor = .systemBlue {
38.         didSet {
39.             resetButton()
40.         }
41.     }
42.    
43.     var activeBackgroundColor: UIColor = .systemGreen {
44.         didSet {
45.             updateButtonAppearance()
46.         }
47.     }
48.    
49.     var normalTitleColor: UIColor = .white {
50.         didSet {
51.             resetButton()
52.         }
53.     }
54.    
55.     var activeTitleColor: UIColor = .white {
56.         didSet {
57.             updateButtonAppearance()
58.         }
59.     }
60.    
61.     // MARK: - 私有属性
62.     private var timer: Timer?
63.     private var elapsedTime: TimeInterval = 0
64.     private var remainingTime: Int = 0
65.     private var isActive: Bool = false
66.    
67.     // MARK: - 回调闭包
68.     var onStart: (() -> Void)?
69.     var onTick: ((TimeInterval) -> Void)?
70.     var onFinish: (() -> Void)?
71.     var onSingleShot: (() -> Void)?
72.    
73.     // MARK: - 初始化
74.     init(frame: CGRect, timerMode: TimerMode = .countdown(totalTime: 60)) {
75.         self.timerMode = timerMode
76.         super.init(frame: frame)
77.         setupButton()
78.     }
79.    
80.     required init?(coder: NSCoder) {
81.         super.init(coder: coder)
82.         setupButton()
83.     }
84.    
85.     // MARK: - 设置按钮
86.     private func setupButton() {
87.         resetButton()
88.         addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
89.     }
90.    
91.     // MARK: - 重置按钮
92.     private func resetButton() {
93.         isActive = false
94.         isEnabled = true
95.         elapsedTime = 0
96.         
97.         switch timerMode {
98.         case .countdown(let totalTime):
99.             remainingTime = totalTime
100.             setTitle(normalTitle, for: .normal)
101.         case .countup:
102.             setTitle(normalTitle, for: .normal)
103.         case .singleShot:
104.             setTitle(normalTitle, for: .normal)
105.         }
106.         
107.         backgroundColor = normalBackgroundColor
108.         setTitleColor(normalTitleColor, for: .normal)
109.     }
110.    
111.     // MARK: - 按钮点击事件
112.     @objc private func buttonTapped() {
113.         if isActive {
114.             stopTimer()
115.         } else {
116.             startTimer()
117.         }
118.     }
119.    
120.     // MARK: - 开始定时器
121.     public func startTimer() {
122.         guard !isActive else { return }
123.         
124.         isActive = true
125.         updateButtonAppearance()
126.         onStart?()
127.         
128.         switch timerMode {
129.         case .countdown:
130.             timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
131.                 self?.handleCountdownTick()
132.             }
133.         case .countup:
134.             timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
135.                 self?.handleCountupTick()
136.             }
137.         case .singleShot(let timeInterval):
138.             timer = Timer.scheduledTimer(withTimeInterval: timeInterval, repeats: false) { [weak self] _ in
139.                 self?.handleSingleShot()
140.             }
141.         }
142.     }
143.    
144.     // MARK: - 停止定时器
145.     public func stopTimer() {
146.         guard isActive else { return }
147.         
148.         timer?.invalidate()
149.         timer = nil
150.         isActive = false
151.         isEnabled = true
152.         setTitle(finishedTitle, for: .normal)
153.         backgroundColor = normalBackgroundColor
154.         setTitleColor(normalTitleColor, for: .normal)
155.         
156.         onFinish?()
157.     }
158.    
159.     // MARK: - 处理倒计时
160.     private func handleCountdownTick() {
161.         remainingTime -= 1
162.         updateButtonAppearance()
163.         onTick?(TimeInterval(remainingTime))
164.         
165.         if remainingTime == 0 {
166.             stopTimer()
167.         }
168.     }
169.    
170.     // MARK: - 处理正计时
171.     private func handleCountupTick() {
172.         elapsedTime += 0.1
173.         updateButtonAppearance()
174.         onTick?(elapsedTime)
175.     }
176.    
177.     // MARK: - 处理一次性执行
178.     private func handleSingleShot() {
179.         timer?.invalidate()
180.         timer = nil
181.         isActive = false
182.         isEnabled = true
183.         setTitle(finishedTitle, for: .normal)
184.         backgroundColor = normalBackgroundColor
185.         setTitleColor(normalTitleColor, for: .normal)
186.         
187.         onSingleShot?()
188.         onFinish?()
189.     }
190.    
191.     // MARK: - 更新按钮外观
192.     private func updateButtonAppearance() {
193.         switch timerMode {
194.         case .countdown:
195.             let formattedTitle = String(format: countingFormat, remainingTime)
196.             setTitle(formattedTitle, for: .disabled)
197.         case .countup:
198.             let formattedTitle = String(format: "%.1f", elapsedTime)
199.             setTitle(formattedTitle, for: .disabled)
200.         case .singleShot:
201.             setTitle("执行中...", for: .disabled)
202.         }
203.         
204.         backgroundColor = activeBackgroundColor
205.         setTitleColor(activeTitleColor, for: .disabled)
206.     }
207.    
208.     // MARK: - 销毁定时器
209.     deinit {
210.         timer?.invalidate()
211.     }
212. }

复制代码

使用示例

2. import UIKit
4. class ViewController: UIViewController {
5.    
6.     override func viewDidLoad() {
7.         super.viewDidLoad()
8.         
9.         setupCountdownButton()
10.         setupCountupButton()
11.         setupSingleShotButton()
12.     }
13.    
14.     private func setupCountdownButton() {
15.         let countdownButton = MultiModeTimerButton(
16.             frame: CGRect(x: 50, y: 100, width: 200, height: 50),
17.             timerMode: .countdown(totalTime: 10)
18.         )
19.         
20.         countdownButton.normalTitle = "开始倒计时"
21.         countdownButton.countingFormat = "剩余%d秒"
22.         countdownButton.finishedTitle = "倒计时结束"
23.         
24.         countdownButton.onStart = {
25.             print("倒计时开始")
26.         }
27.         
28.         countdownButton.onTick = { time in
29.             print("倒计时剩余: \(Int(time))秒")
30.         }
31.         
32.         countdownButton.onFinish = {
33.             print("倒计时结束")
34.         }
35.         
36.         view.addSubview(countdownButton)
37.         countdownButton.center.x = view.center.x
38.     }
39.    
40.     private func setupCountupButton() {
41.         let countupButton = MultiModeTimerButton(
42.             frame: CGRect(x: 50, y: 170, width: 200, height: 50),
43.             timerMode: .countup
44.         )
45.         
46.         countupButton.normalTitle = "开始计时"
47.         countupButton.countingFormat = "%.1f秒"
48.         countupButton.finishedTitle = "停止计时"
49.         
50.         countupButton.onStart = {
51.             print("正计时开始")
52.         }
53.         
54.         countupButton.onTick = { time in
55.             print("已计时: \(time)秒")
56.         }
57.         
58.         countupButton.onFinish = {
59.             print("正计时结束")
60.         }
61.         
62.         view.addSubview(countupButton)
63.         countupButton.center.x = view.center.x
64.     }
65.    
66.     private func setupSingleShotButton() {
67.         let singleShotButton = MultiModeTimerButton(
68.             frame: CGRect(x: 50, y: 240, width: 200, height: 50),
69.             timerMode: .singleShot(timeInterval: 3.0)
70.         )
71.         
72.         singleShotButton.normalTitle = "3秒后执行"
73.         singleShotButton.finishedTitle = "执行完成"
74.         
75.         singleShotButton.onStart = {
76.             print("一次性定时器启动")
77.         }
78.         
79.         singleShotButton.onSingleShot = {
80.             print("一次性任务执行")
81.         }
82.         
83.         singleShotButton.onFinish = {
84.             print("一次性定时器结束")
85.         }
86.         
87.         view.addSubview(singleShotButton)
88.         singleShotButton.center.x = view.center.x
89.     }
90. }

复制代码

常见问题及解决方案

在实现定时器按钮功能时，开发者可能会遇到一些常见问题。下面我们将讨论这些问题及其解决方案。

1. 定时器与RunLoop的问题

问题描述：定时器在某些情况下可能不会按预期工作，例如在滚动视图时定时器暂停。

原因分析：这是因为定时器默认运行在RunLoop的.default模式下，当用户滚动视图时，RunLoop会切换到.tracking模式，导致定时器暂停。

解决方案：将定时器添加到RunLoop的.common模式中，这样定时器会在所有常见的RunLoop模式下运行。

2. // 创建定时器
3. let timer = Timer(timeInterval: 1.0, target: self, selector: #selector(timerAction), userInfo: nil, repeats: true)
5. // 将定时器添加到RunLoop的.common模式
6. RunLoop.current.add(timer, forMode: .common)

复制代码

2. 循环引用问题

问题描述：在使用闭包创建定时器时，可能会出现循环引用，导致内存泄漏。

原因分析：当定时器的闭包中强引用了self，而self又强引用了定时器时，就会形成循环引用。

解决方案：在闭包中使用[weak self]来避免循环引用。

2. timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
3.     guard let self = self else { return }
4.     // 使用self
5.     self.updateButtonTitle()
6. }

复制代码

3. 定时器精度问题

问题描述：定时器的实际触发时间可能与指定的时间间隔有偏差，特别是在需要高精度计时的场景中。

原因分析：Timer不是实时系统，它的精度受到系统负载、RunLoop模式等多种因素的影响。

解决方案：对于需要高精度的场景，可以考虑使用DispatchSourceTimer（GCD定时器）代替Timer。

2. import Dispatch
4. class GCDTimerButton: UIButton {
5.    
6.     private var timer: DispatchSourceTimer?
7.     private var remainingTime: Int = 0
8.     private var totalTime: Int = 60
9.    
10.     // ... 其他代码 ...
11.    
12.     private func startGCDTimer() {
13.         remainingTime = totalTime
14.         isEnabled = false
15.         updateButtonTitle()
16.         
17.         // 创建GCD定时器
18.         timer = DispatchSource.makeTimerSource()
19.         
20.         // 设置定时器
21.         timer?.schedule(deadline: .now(), repeating: .seconds(1))
22.         
23.         // 设置事件处理器
24.         timer?.setEventHandler { [weak self] in
25.             DispatchQueue.main.async {
26.                 self?.remainingTime -= 1
27.                 self?.updateButtonTitle()
28.                
29.                 if self?.remainingTime == 0 {
30.                     self?.stopGCDTimer()
31.                 }
32.             }
33.         }
34.         
35.         // 启动定时器
36.         timer?.resume()
37.     }
38.    
39.     private func stopGCDTimer() {
40.         timer?.cancel()
41.         timer = nil
42.         isEnabled = true
43.         setTitle("重新获取", for: .normal)
44.     }
45.    
46.     // ... 其他代码 ...
47. }

复制代码

4. 后台运行问题

问题描述：当应用进入后台时，定时器可能会暂停工作。

原因分析：iOS系统为了节省电量，会在应用进入后台时限制其活动，包括暂停定时器。

解决方案：如果需要在应用进入后台时继续运行定时器，可以使用beginBackgroundTask(withName:expirationHandler:)方法申请后台执行时间。

2. var backgroundTask: UIBackgroundTaskIdentifier = .invalid
4. func startTimer() {
5.     // 注册后台任务
6.     backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "TimerBackgroundTask") {
7.         // 后台任务即将过期时调用
8.         self.endBackgroundTask()
9.     }
10.    
11.     // 启动定时器
12.     timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
13.         guard let self = self else { return }
14.         
15.         // 更新UI
16.         self.remainingTime -= 1
17.         self.updateButtonTitle()
18.         
19.         if self.remainingTime == 0 {
20.             self.stopTimer()
21.         }
22.         
23.         // 检查后台时间是否即将用完
24.         if UIApplication.shared.backgroundTimeRemaining < 10 {
25.             self.endBackgroundTask()
26.         }
27.     }
28. }
30. func endBackgroundTask() {
31.     if backgroundTask != .invalid {
32.         UIApplication.shared.endBackgroundTask(backgroundTask)
33.         backgroundTask = .invalid
34.     }
35. }
37. func stopTimer() {
38.     timer?.invalidate()
39.     timer = nil
40.     isEnabled = true
41.     setTitle("重新获取", for: .normal)
42.     endBackgroundTask()
43. }

复制代码

5. 多定时器管理问题

问题描述：在一个界面中有多个定时器按钮时，如何有效管理它们，避免冲突和资源浪费。

原因分析：每个定时器按钮都有自己的定时器实例，如果没有统一管理，可能会导致多个定时器同时运行，浪费系统资源。

解决方案：创建一个定时器管理器，统一管理所有的定时器。

2. import UIKit
4. class TimerManager {
5.    
6.     static let shared = TimerManager()
7.    
8.     private var timers: [String: Timer] = [:]
9.    
10.     private init() {}
11.    
12.     func addTimer(id: String, timer: Timer) {
13.         // 如果已存在相同ID的定时器，先移除
14.         removeTimer(id: id)
15.         
16.         // 添加新定时器
17.         timers[id] = timer
18.     }
19.    
20.     func removeTimer(id: String) {
21.         if let timer = timers[id] {
22.             timer.invalidate()
23.             timers.removeValue(forKey: id)
24.         }
25.     }
26.    
27.     func removeAllTimers() {
28.         for (_, timer) in timers {
29.             timer.invalidate()
30.         }
31.         timers.removeAll()
32.     }
33.    
34.     func isTimerActive(id: String) -> Bool {
35.         return timers[id] != nil
36.     }
37. }
39. class ManagedTimerButton: UIButton {
40.    
41.     private var timerId: String
42.     private var remainingTime: Int = 0
43.     private var totalTime: Int = 60
44.    
45.     init(frame: CGRect, timerId: String, totalTime: Int = 60) {
46.         self.timerId = timerId
47.         self.totalTime = totalTime
48.         super.init(frame: frame)
49.         setupButton()
50.     }
51.    
52.     required init?(coder: NSCoder) {
53.         fatalError("init(coder:) has not been implemented")
54.     }
55.    
56.     private func setupButton() {
57.         setTitle("获取验证码", for: .normal)
58.         backgroundColor = .systemBlue
59.         setTitleColor(.white, for: .normal)
60.         layer.cornerRadius = 5
61.         addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
62.     }
63.    
64.     @objc private func buttonTapped() {
65.         // 检查定时器是否已在运行
66.         if TimerManager.shared.isTimerActive(id: timerId) {
67.             return
68.         }
69.         
70.         startTimer()
71.     }
72.    
73.     private func startTimer() {
74.         remainingTime = totalTime
75.         isEnabled = false
76.         updateButtonTitle()
77.         
78.         let timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
79.             guard let self = self else { return }
80.             
81.             self.remainingTime -= 1
82.             self.updateButtonTitle()
83.             
84.             if self.remainingTime == 0 {
85.                 self.stopTimer()
86.             }
87.         }
88.         
89.         // 将定时器添加到管理器
90.         TimerManager.shared.addTimer(id: timerId, timer: timer)
91.     }
92.    
93.     private func stopTimer() {
94.         TimerManager.shared.removeTimer(id: timerId)
95.         isEnabled = true
96.         setTitle("重新获取", for: .normal)
97.     }
98.    
99.     private func updateButtonTitle() {
100.         setTitle("\(remainingTime)秒后重试", for: .disabled)
101.     }
102.    
103.     deinit {
104.         TimerManager.shared.removeTimer(id: timerId)
105.     }
106. }

复制代码

提升用户体验的技巧

定时器按钮不仅仅是功能的实现，还需要考虑用户体验。下面是一些提升用户体验的技巧。

1. 视觉反馈

为定时器按钮添加视觉反馈，可以帮助用户更好地理解当前状态。

2. class VisualFeedbackTimerButton: UIButton {
3.    
4.     // ... 其他代码 ...
5.    
6.     private func updateButtonAppearance() {
7.         // 更新标题
8.         let formattedTitle = String(format: countingFormat, remainingTime)
9.         setTitle(formattedTitle, for: .disabled)
10.         
11.         // 根据剩余时间改变颜色
12.         let progress = Double(remainingTime) / Double(totalTime)
13.         
14.         if progress > 0.5 {
15.             backgroundColor = normalBackgroundColor
16.         } else if progress > 0.2 {
17.             backgroundColor = .systemOrange
18.         } else {
19.             backgroundColor = .systemRed
20.         }
21.         
22.         // 添加脉冲动画
23.         pulseAnimation()
24.     }
25.    
26.     private func pulseAnimation() {
27.         let pulse = CABasicAnimation(keyPath: "transform.scale")
28.         pulse.duration = 0.5
29.         pulse.fromValue = 1.0
30.         pulse.toValue = 1.05
31.         pulse.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
32.         pulse.autoreverses = true
33.         pulse.repeatCount = 1
34.         
35.         layer.add(pulse, forKey: "pulse")
36.     }
37.    
38.     // ... 其他代码 ...
39. }

复制代码

2. 声音反馈

在定时器开始和结束时添加声音反馈，可以增强用户体验。

2. import AVFoundation
4. class SoundFeedbackTimerButton: UIButton {
5.    
6.     private var audioPlayer: AVAudioPlayer?
7.    
8.     // ... 其他代码 ...
9.    
10.     private func setupAudioPlayer() {
11.         guard let soundURL = Bundle.main.url(forResource: "tick", withExtension: "mp3") else {
12.             print("声音文件未找到")
13.             return
14.         }
15.         
16.         do {
17.             audioPlayer = try AVAudioPlayer(contentsOf: soundURL)
18.             audioPlayer?.prepareToPlay()
19.         } catch {
20.             print("音频播放器初始化失败: \(error)")
21.         }
22.     }
23.    
24.     private func startTimer() {
25.         // ... 其他代码 ...
26.         
27.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
28.             guard let self = self else { return }
29.             
30.             self.remainingTime -= 1
31.             self.updateButtonTitle()
32.             
33.             // 播放滴答声
34.             self.playTickSound()
35.             
36.             if self.remainingTime == 0 {
37.                 self.stopTimer()
38.                 // 播放完成声音
39.                 self.playFinishSound()
40.             }
41.         }
42.     }
43.    
44.     private func playTickSound() {
45.         // 如果剩余时间小于等于5秒，播放滴答声
46.         if remainingTime <= 5 {
47.             audioPlayer?.play()
48.         }
49.     }
50.    
51.     private func playFinishSound() {
52.         // 这里可以播放不同的完成声音
53.         // 为了简单起见，我们使用相同的音频文件
54.         audioPlayer?.play()
55.     }
56.    
57.     // ... 其他代码 ...
58. }

复制代码

3. 震动反馈

在定时器开始和结束时添加震动反馈，可以提供触觉反馈。

2. import UIKit
4. class HapticFeedbackTimerButton: UIButton {
5.    
6.     // ... 其他代码 ...
7.    
8.     private func startTimer() {
9.         // ... 其他代码 ...
10.         
11.         // 开始震动反馈
12.         triggerHapticFeedback(style: .medium)
13.         
14.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
15.             guard let self = self else { return }
16.             
17.             self.remainingTime -= 1
18.             self.updateButtonTitle()
19.             
20.             if self.remainingTime == 0 {
21.                 self.stopTimer()
22.                 // 结束震动反馈
23.                 self.triggerHapticFeedback(style: .heavy)
24.             }
25.         }
26.     }
27.    
28.     private func triggerHapticFeedback(style: UIImpactFeedbackGenerator.FeedbackStyle) {
29.         let generator = UIImpactFeedbackGenerator(style: style)
30.         generator.impactOccurred()
31.     }
32.    
33.     // ... 其他代码 ...
34. }

复制代码

4. 进度指示

为定时器按钮添加进度指示，可以直观地展示剩余时间。

2. import UIKit
4. class ProgressTimerButton: UIButton {
5.    
6.     private var progressLayer = CAShapeLayer()
7.     private var progressBackgroundLayer = CAShapeLayer()
8.    
9.     // ... 其他代码 ...
10.    
11.     private func setupProgressLayers() {
12.         // 创建背景层
13.         progressBackgroundLayer.path = UIBezierPath(roundedRect: bounds, cornerRadius: layer.cornerRadius).cgPath
14.         progressBackgroundLayer.fillColor = UIColor.clear.cgColor
15.         progressBackgroundLayer.strokeColor = UIColor.systemGray5.cgColor
16.         progressBackgroundLayer.lineWidth = 3.0
17.         layer.addSublayer(progressBackgroundLayer)
18.         
19.         // 创建进度层
20.         progressLayer.path = UIBezierPath(roundedRect: bounds, cornerRadius: layer.cornerRadius).cgPath
21.         progressLayer.fillColor = UIColor.clear.cgColor
22.         progressLayer.strokeColor = tintColor.cgColor
23.         progressLayer.lineWidth = 3.0
24.         progressLayer.strokeEnd = 1.0
25.         progressLayer.lineCap = .round
26.         layer.addSublayer(progressLayer)
27.     }
28.    
29.     private func updateProgress() {
30.         let progress = Double(remainingTime) / Double(totalTime)
31.         
32.         CATransaction.begin()
33.         CATransaction.setDisableActions(true)
34.         progressLayer.strokeEnd = CGFloat(progress)
35.         CATransaction.commit()
36.         
37.         // 根据进度改变颜色
38.         if progress > 0.5 {
39.             progressLayer.strokeColor = normalBackgroundColor.cgColor
40.         } else if progress > 0.2 {
41.             progressLayer.strokeColor = UIColor.systemOrange.cgColor
42.         } else {
43.             progressLayer.strokeColor = UIColor.systemRed.cgColor
44.         }
45.     }
46.    
47.     private func startTimer() {
48.         // ... 其他代码 ...
49.         
50.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
51.             guard let self = self else { return }
52.             
53.             self.remainingTime -= 1
54.             self.updateButtonTitle()
55.             self.updateProgress()
56.             
57.             if self.remainingTime == 0 {
58.                 self.stopTimer()
59.             }
60.         }
61.     }
62.    
63.     private func stopTimer() {
64.         // ... 其他代码 ...
65.         
66.         // 重置进度
67.         CATransaction.begin()
68.         CATransaction.setDisableActions(true)
69.         progressLayer.strokeEnd = 1.0
70.         CATransaction.commit()
71.     }
72.    
73.     override func layoutSubviews() {
74.         super.layoutSubviews()
75.         
76.         // 更新进度层路径
77.         progressBackgroundLayer.path = UIBezierPath(roundedRect: bounds, cornerRadius: layer.cornerRadius).cgPath
78.         progressLayer.path = UIBezierPath(roundedRect: bounds, cornerRadius: layer.cornerRadius).cgPath
79.     }
80.    
81.     // ... 其他代码 ...
82. }

复制代码

5. 动画效果

为定时器按钮添加动画效果，可以增强用户体验。

2. import UIKit
4. class AnimatedTimerButton: UIButton {
5.    
6.     // ... 其他代码 ...
7.    
8.     private func startTimer() {
9.         // ... 其他代码 ...
10.         
11.         // 添加开始动画
12.         animateStart()
13.         
14.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
15.             guard let self = self else { return }
16.             
17.             self.remainingTime -= 1
18.             self.updateButtonTitle()
19.             
20.             // 添加滴答动画
21.             self.animateTick()
22.             
23.             if self.remainingTime == 0 {
24.                 self.stopTimer()
25.                 // 添加完成动画
26.                 self.animateFinish()
27.             }
28.         }
29.     }
30.    
31.     private func animateStart() {
32.         let scaleAnimation = CABasicAnimation(keyPath: "transform.scale")
33.         scaleAnimation.duration = 0.2
34.         scaleAnimation.fromValue = 1.0
35.         scaleAnimation.toValue = 0.95
36.         scaleAnimation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
37.         scaleAnimation.autoreverses = true
38.         scaleAnimation.repeatCount = 1
39.         
40.         layer.add(scaleAnimation, forKey: "startScale")
41.     }
42.    
43.     private func animateTick() {
44.         // 如果剩余时间小于等于5秒，添加更明显的动画
45.         if remainingTime <= 5 {
46.             let shakeAnimation = CAKeyframeAnimation(keyPath: "transform.translation.x")
47.             shakeAnimation.timingFunction = CAMediaTimingFunction(name: .linear)
48.             shakeAnimation.duration = 0.5
49.             shakeAnimation.values = [-5.0, 5.0, -5.0, 5.0, 0.0]
50.             
51.             layer.add(shakeAnimation, forKey: "shake")
52.         }
53.     }
54.    
55.     private func animateFinish() {
56.         let bounceAnimation = CAKeyframeAnimation(keyPath: "transform.scale")
57.         bounceAnimation.duration = 0.5
58.         bounceAnimation.values = [1.0, 1.2, 0.9, 1.1, 1.0]
59.         bounceAnimation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
60.         
61.         layer.add(bounceAnimation, forKey: "finishBounce")
62.     }
63.    
64.     // ... 其他代码 ...
65. }

复制代码

打造专业iOS应用的最佳实践

在开发专业的iOS应用时，定时器按钮的实现需要遵循一些最佳实践，以确保代码的可维护性、可扩展性和性能。

1. 使用协议和委托模式

使用协议和委托模式可以使定时器按钮更加灵活，便于与其他组件交互。

2. import UIKit
4. // 定义定时器按钮的协议
5. protocol TimerButtonDelegate: AnyObject {
6.     func timerButtonDidStartCountdown(_ button: TimerButton)
7.     func timerButton(_ button: TimerButton, didUpdateRemainingTime time: Int)
8.     func timerButtonDidFinishCountdown(_ button: TimerButton)
9. }
11. // 实现协议的定时器按钮
12. class ProtocolTimerButton: UIButton {
13.    
14.     weak var delegate: TimerButtonDelegate?
15.    
16.     private var timer: Timer?
17.     private var remainingTime: Int = 0
18.     private var totalTime: Int = 60
19.    
20.     // ... 其他代码 ...
21.    
22.     private func startTimer() {
23.         remainingTime = totalTime
24.         isEnabled = false
25.         updateButtonTitle()
26.         
27.         // 通知委托
28.         delegate?.timerButtonDidStartCountdown(self)
29.         
30.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
31.             guard let self = self else { return }
32.             
33.             self.remainingTime -= 1
34.             self.updateButtonTitle()
35.             
36.             // 通知委托
37.             self.delegate?.timerButton(self, didUpdateRemainingTime: self.remainingTime)
38.             
39.             if self.remainingTime == 0 {
40.                 self.stopTimer()
41.             }
42.         }
43.     }
44.    
45.     private func stopTimer() {
46.         timer?.invalidate()
47.         timer = nil
48.         isEnabled = true
49.         setTitle("重新获取", for: .normal)
50.         
51.         // 通知委托
52.         delegate?.timerButtonDidFinishCountdown(self)
53.     }
54.    
55.     // ... 其他代码 ...
56. }
58. // 使用示例
59. class ViewController: UIViewController, TimerButtonDelegate {
60.    
61.     override func viewDidLoad() {
62.         super.viewDidLoad()
63.         
64.         let timerButton = ProtocolTimerButton(frame: CGRect(x: 50, y: 100, width: 200, height: 50))
65.         timerButton.delegate = self
66.         view.addSubview(timerButton)
67.         timerButton.center.x = view.center.x
68.     }
69.    
70.     // MARK: - TimerButtonDelegate
71.    
72.     func timerButtonDidStartCountdown(_ button: TimerButton) {
73.         print("定时器开始倒计时")
74.     }
75.    
76.     func timerButton(_ button: TimerButton, didUpdateRemainingTime time: Int) {
77.         print("剩余时间: \(time)秒")
78.     }
79.    
80.     func timerButtonDidFinishCountdown(_ button: TimerButton) {
81.         print("定时器倒计时结束")
82.     }
83. }

复制代码

2. 使用响应式编程

使用响应式编程（如Combine或RxSwift）可以简化定时器按钮的事件处理。

2. import UIKit
3. import Combine
5. class ReactiveTimerButton: UIButton {
6.    
7.     private var timer: Timer?
8.     private var remainingTime: Int = 0
9.     private var totalTime: Int = 60
10.    
11.     // 使用Combine发布者
12.     private var cancellables = Set<AnyCancellable>()
13.    
14.     // 定义事件发布者
15.     let didStartCountdown = PassthroughSubject<Void, Never>()
16.     let didUpdateRemainingTime = PassthroughSubject<Int, Never>()
17.     let didFinishCountdown = PassthroughSubject<Void, Never>()
18.    
19.     // ... 其他代码 ...
20.    
21.     private func startTimer() {
22.         remainingTime = totalTime
23.         isEnabled = false
24.         updateButtonTitle()
25.         
26.         // 发送开始事件
27.         didStartCountdown.send()
28.         
29.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
30.             guard let self = self else { return }
31.             
32.             self.remainingTime -= 1
33.             self.updateButtonTitle()
34.             
35.             // 发送更新事件
36.             self.didUpdateRemainingTime.send(self.remainingTime)
37.             
38.             if self.remainingTime == 0 {
39.                 self.stopTimer()
40.             }
41.         }
42.     }
43.    
44.     private func stopTimer() {
45.         timer?.invalidate()
46.         timer = nil
47.         isEnabled = true
48.         setTitle("重新获取", for: .normal)
49.         
50.         // 发送完成事件
51.         didFinishCountdown.send()
52.     }
53.    
54.     // ... 其他代码 ...
55. }
57. // 使用示例
58. class ViewController: UIViewController {
59.    
60.     override func viewDidLoad() {
61.         super.viewDidLoad()
62.         
63.         let timerButton = ReactiveTimerButton(frame: CGRect(x: 50, y: 100, width: 200, height: 50))
64.         view.addSubview(timerButton)
65.         timerButton.center.x = view.center.x
66.         
67.         // 订阅事件
68.         timerButton.didStartCountdown
69.             .sink { _ in
70.                 print("定时器开始倒计时")
71.             }
72.             .store(in: &timerButton.cancellables)
73.         
74.         timerButton.didUpdateRemainingTime
75.             .sink { time in
76.                 print("剩余时间: \(time)秒")
77.             }
78.             .store(in: &timerButton.cancellables)
79.         
80.         timerButton.didFinishCountdown
81.             .sink { _ in
82.                 print("定时器倒计时结束")
83.             }
84.             .store(in: &timerButton.cancellables)
85.     }
86. }

复制代码

3. 使用SwiftUI实现定时器按钮

对于使用SwiftUI开发的应用，可以使用SwiftUI的方式实现定时器按钮。

2. import SwiftUI
4. struct SwiftUIButton: View {
5.    
6.     @State private var remainingTime: Int = 0
7.     @State private var isCountingDown: Bool = false
8.     @State private var timer: Timer?
9.    
10.     let totalTime: Int
11.     let normalTitle: String
12.     let countingFormat: String
13.     let finishedTitle: String
14.     let action: () -> Void
15.    
16.     init(
17.         totalTime: Int = 60,
18.         normalTitle: String = "获取验证码",
19.         countingFormat: String = "%d秒后重试",
20.         finishedTitle: String = "重新获取",
21.         action: @escaping () -> Void = {}
22.     ) {
23.         self.totalTime = totalTime
24.         self.normalTitle = normalTitle
25.         self.countingFormat = countingFormat
26.         self.finishedTitle = finishedTitle
27.         self.action = action
28.     }
29.    
30.     var body: some View {
31.         Button(action: {
32.             if !isCountingDown {
33.                 startCountdown()
34.                 action()
35.             }
36.         }) {
37.             Text(buttonTitle)
38.                 .font(.headline)
39.                 .foregroundColor(.white)
40.                 .frame(maxWidth: .infinity)
41.                 .padding()
42.                 .background(buttonColor)
43.                 .cornerRadius(10)
44.         }
45.         .disabled(isCountingDown)
46.         .onDisappear {
47.             stopCountdown()
48.         }
49.     }
50.    
51.     private var buttonTitle: String {
52.         if isCountingDown {
53.             return String(format: countingFormat, remainingTime)
54.         } else if remainingTime == 0 {
55.             return finishedTitle
56.         } else {
57.             return normalTitle
58.         }
59.     }
60.    
61.     private var buttonColor: Color {
62.         if isCountingDown {
63.             let progress = Double(remainingTime) / Double(totalTime)
64.             if progress > 0.5 {
65.                 return .blue
66.             } else if progress > 0.2 {
67.                 return .orange
68.             } else {
69.                 return .red
70.             }
71.         } else {
72.             return .blue
73.         }
74.     }
75.    
76.     private func startCountdown() {
77.         isCountingDown = true
78.         remainingTime = totalTime
79.         
80.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
81.             if self.remainingTime > 0 {
82.                 self.remainingTime -= 1
83.             } else {
84.                 self.stopCountdown()
85.             }
86.         }
87.     }
88.    
89.     private func stopCountdown() {
90.         timer?.invalidate()
91.         timer = nil
92.         isCountingDown = false
93.     }
94. }
96. // 使用示例
97. struct ContentView: View {
98.     var body: some View {
99.         VStack(spacing: 20) {
100.             SwiftUIButton(
101.                 totalTime: 10,
102.                 normalTitle: "发送验证码",
103.                 countingFormat: "剩余%d秒",
104.                 finishedTitle: "再次发送"
105.             ) {
106.                 print("验证码已发送")
107.             }
108.             .padding(.horizontal)
109.             
110.             SwiftUIButton(
111.                 totalTime: 5,
112.                 normalTitle: "开始计时",
113.                 countingFormat: "计时中: %d",
114.                 finishedTitle: "计时完成"
115.             ) {
116.                 print("计时开始")
117.             }
118.             .padding(.horizontal)
119.         }
120.     }
121. }

复制代码

4. 使用MVVM架构

使用MVVM（Model-View-ViewModel）架构可以使定时器按钮的代码更加结构化和可测试。

2. import UIKit
4. // Model
5. struct TimerModel {
6.     var totalTime: Int
7.     var remainingTime: Int
8.     var isActive: Bool
9. }
11. // ViewModel
12. class TimerButtonViewModel {
13.    
14.     // 使用@Published属性，以便视图可以订阅它们的变化
15.     @Published var model: TimerModel
16.    
17.     // 定义事件
18.     let didStart = PassthroughSubject<Void, Never>()
19.     let didTick = PassthroughSubject<Int, Never>()
20.     let didFinish = PassthroughSubject<Void, Never>()
21.    
22.     private var timer: Timer?
23.     private var cancellables = Set<AnyCancellable>()
24.    
25.     init(totalTime: Int = 60) {
26.         model = TimerModel(totalTime: totalTime, remainingTime: totalTime, isActive: false)
27.     }
28.    
29.     func startTimer() {
30.         guard !model.isActive else { return }
31.         
32.         model.isActive = true
33.         model.remainingTime = model.totalTime
34.         
35.         didStart.send()
36.         
37.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
38.             guard let self = self else { return }
39.             
40.             self.model.remainingTime -= 1
41.             self.didTick.send(self.model.remainingTime)
42.             
43.             if self.model.remainingTime == 0 {
44.                 self.stopTimer()
45.             }
46.         }
47.     }
48.    
49.     func stopTimer() {
50.         guard model.isActive else { return }
51.         
52.         timer?.invalidate()
53.         timer = nil
54.         model.isActive = false
55.         
56.         didFinish.send()
57.     }
58.    
59.     func resetTimer() {
60.         stopTimer()
61.         model.remainingTime = model.totalTime
62.     }
63. }
65. // View
66. class MVVMTimerButton: UIButton {
67.    
68.     private var viewModel: TimerButtonViewModel
69.     private var cancellables = Set<AnyCancellable>()
70.    
71.     init(frame: CGRect, viewModel: TimerButtonViewModel) {
72.         self.viewModel = viewModel
73.         super.init(frame: frame)
74.         setupButton()
75.         setupBindings()
76.     }
77.    
78.     required init?(coder: NSCoder) {
79.         fatalError("init(coder:) has not been implemented")
80.     }
81.    
82.     private func setupButton() {
83.         addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
84.         updateButtonAppearance()
85.     }
86.    
87.     private func setupBindings() {
88.         // 订阅模型变化
89.         viewModel.$model
90.             .receive(on: RunLoop.main)
91.             .sink { [weak self] model in
92.                 self?.updateButtonAppearance()
93.             }
94.             .store(in: &cancellables)
95.         
96.         // 订阅事件
97.         viewModel.didStart
98.             .receive(on: RunLoop.main)
99.             .sink { [weak self] _ in
100.                 print("定时器开始")
101.             }
102.             .store(in: &cancellables)
103.         
104.         viewModel.didTick
105.             .receive(on: RunLoop.main)
106.             .sink { time in
107.                 print("剩余时间: \(time)秒")
108.             }
109.             .store(in: &cancellables)
110.         
111.         viewModel.didFinish
112.             .receive(on: RunLoop.main)
113.             .sink { [weak self] _ in
114.                 print("定时器结束")
115.             }
116.             .store(in: &cancellables)
117.     }
118.    
119.     @objc private func buttonTapped() {
120.         if viewModel.model.isActive {
121.             viewModel.stopTimer()
122.         } else {
123.             viewModel.startTimer()
124.         }
125.     }
126.    
127.     private func updateButtonAppearance() {
128.         isEnabled = !viewModel.model.isActive
129.         
130.         if viewModel.model.isActive {
131.             let formattedTitle = String(format: "%d秒后重试", viewModel.model.remainingTime)
132.             setTitle(formattedTitle, for: .disabled)
133.             backgroundColor = .systemGray
134.         } else if viewModel.model.remainingTime == 0 {
135.             setTitle("重新获取", for: .normal)
136.             backgroundColor = .systemBlue
137.         } else {
138.             setTitle("获取验证码", for: .normal)
139.             backgroundColor = .systemBlue
140.         }
141.     }
142.    
143.     deinit {
144.         viewModel.stopTimer()
145.     }
146. }
148. // 使用示例
149. class ViewController: UIViewController {
150.    
151.     override func viewDidLoad() {
152.         super.viewDidLoad()
153.         
154.         let viewModel = TimerButtonViewModel(totalTime: 10)
155.         let timerButton = MVVMTimerButton(frame: CGRect(x: 50, y: 100, width: 200, height: 50), viewModel: viewModel)
156.         
157.         view.addSubview(timerButton)
158.         timerButton.center.x = view.center.x
159.     }
160. }

复制代码

5. 性能优化

在实现定时器按钮时，需要注意性能优化，特别是在有多个定时器按钮的场景中。

2. import UIKit
4. class OptimizedTimerButton: UIButton {
5.    
6.     // 使用轻量级的GCD定时器代替Timer
7.     private var timer: DispatchSourceTimer?
8.     private var remainingTime: Int = 0
9.     private var totalTime: Int = 60
10.    
11.     // 使用静态的定时器队列，避免创建多个队列
12.     private static let timerQueue = DispatchQueue(label: "com.example.timerbutton.queue", attributes: .concurrent)
13.    
14.     // 使用弱引用避免循环引用
15.     private weak var weakSelf: OptimizedTimerButton?
16.    
17.     // ... 其他代码 ...
18.    
19.     private func startTimer() {
20.         // 停止现有定时器
21.         stopTimer()
22.         
23.         remainingTime = totalTime
24.         isEnabled = false
25.         updateButtonTitle()
26.         
27.         // 保存弱引用
28.         weakSelf = self
29.         
30.         // 创建GCD定时器
31.         timer = DispatchSource.makeTimerSource(queue: OptimizedTimerButton.timerQueue)
32.         
33.         // 设置定时器
34.         timer?.schedule(deadline: .now(), repeating: .seconds(1))
35.         
36.         // 设置事件处理器
37.         timer?.setEventHandler { [weak self] in
38.             guard let self = self else { return }
39.             
40.             // 在主线程更新UI
41.             DispatchQueue.main.async {
42.                 self.remainingTime -= 1
43.                 self.updateButtonTitle()
44.                
45.                 if self.remainingTime == 0 {
46.                     self.stopTimer()
47.                 }
48.             }
49.         }
50.         
51.         // 启动定时器
52.         timer?.resume()
53.     }
54.    
55.     private func stopTimer() {
56.         timer?.cancel()
57.         timer = nil
58.         isEnabled = true
59.         setTitle("重新获取", for: .normal)
60.     }
61.    
62.     // ... 其他代码 ...
63.    
64.     deinit {
65.         stopTimer()
66.     }
67. }

复制代码

总结

本文全面介绍了在Swift中实现定时器按钮功能的方法，从基础概念到高级技巧，帮助开发者掌握这一重要功能，提升应用的专业性和用户体验。

我们首先介绍了Swift中Timer的基础知识，包括Timer的基本用法、主要属性和方法，以及RunLoop与Timer的关系。然后，我们逐步实现了从简单的定时器按钮到支持多种定时器模式的高级定时器按钮。

接着，我们讨论了在实现定时器按钮时可能遇到的常见问题及其解决方案，包括定时器与RunLoop的问题、循环引用问题、定时器精度问题、后台运行问题和多定时器管理问题。

为了提升用户体验，我们介绍了一些技巧，包括视觉反馈、声音反馈、震动反馈、进度指示和动画效果。这些技巧可以使定时器按钮更加直观、生动和用户友好。

最后，我们探讨了打造专业iOS应用的最佳实践，包括使用协议和委托模式、使用响应式编程、使用SwiftUI实现定时器按钮、使用MVVM架构和性能优化。这些实践可以帮助开发者编写更加结构化、可维护和高性能的代码。

通过本文的学习，开发者应该能够掌握在Swift中实现定时器按钮的全面技能，并能够根据具体需求选择合适的实现方式，打造出专业、高效且用户友好的iOS应用。

版权声明

1、转载或引用本网站内容(Swift中实现定时器按钮功能的完整指南从基础到进阶掌握定时按钮开发技巧解决常见问题提升用户体验打造专业iOS应用)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://pixtech.org/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.org/thread-36729-1-1.html