ios - तालिका दृश्य सेल प्रति एक टाइमर



swift uitableview (1)

मैं टेबल सेल पर टैप करना चाहता हूं और टाइमर शुरू करना चाहता हूं। हर सेल का अपना टाइमर होना चाहिए। मैं टाइमर सेट करने में कामयाब रहा, लेकिन स्वतंत्र रूप से नहीं, जब मैंने एक सेट किया तो सभी सेल सेट हो गए।

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {

    let currentCell = tableView.cellForRow(at: indexPath) as! StaffTableViewCell

    if isRunning == false {



        currentCell.cellImageView.image = UIImage(data: UIImagePNGRepresentation(#imageLiteral(resourceName: "greendot"))!)


        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in

            counter += 1
            let hourPortion = String(format: "%02d", counter / 3600)
            let minutesPortion = String(format: "%02d", counter / 60)
            let secondsPortion = String(format: "%02d", counter % 60)
            //print("\(hourPortion):\(minutesPortion):\(secondsPortion)")

            timeTotal = "\(hourPortion):\(minutesPortion):\(secondsPortion)"

            currentCell.timerLabel.text = timeTotal


            isRunning = true

        }


    }

    tableView.reloadData()


}

func tableView(_ tableView: UITableView, didDeselectRowAt indexPath: IndexPath) {

    timer.invalidate()
    isRunning = false

    let currentCell = tableView.cellForRow(at: indexPath) as! StaffTableViewCell

    if let data = UIImagePNGRepresentation(#imageLiteral(resourceName: "reddot")) {
        currentCell.cellImageView.image = UIImage(data: data)
    }



    tableView.reloadData()
}

यह है कि मैं यह कैसे करेंगे:

  • प्रारंभ समय वाले प्रत्येक पंक्ति का प्रतिनिधित्व करने के लिए एक संरचना बनाएँ और क्या वह पंक्ति वर्तमान में चल रही है
  • टाइमर में घबराना के लिए 0.5 सेकंड के लिए दोहराए जाने वाले टाइमर को शेड्यूल करें
  • हर बार टाइमर में आग लगने पर, दिखाई देने वाली पंक्तियों को अपडेट करें, जिनमें "रनिंग" टाइमर्स हों

import UIKit

struct TimerModel {
    private var startTime: Date?
    private var offset: TimeInterval = 0

    var elapsed : TimeInterval {
        get {
            return self.elapsed(since:Date())
        }
    }

    var isRunning = false {
        didSet {
            if isRunning  {
                self.startTime = Date()
            } else {
                if self.startTime != nil{
                    self.offset = self.elapsed
                    self.startTime = nil
                }
            }
        }
    }

    func elapsed(since: Date) -> TimeInterval {
        var elapsed = offset
        if let startTime = self.startTime {
            elapsed += -startTime.timeIntervalSince(since)
        }
        return elapsed
    }
}

class ViewController: UIViewController {

    @IBOutlet weak var tableview: UITableView!

    var timer: Timer?
    var timersActive = 0

    let formatter: DateComponentsFormatter = {
        let formatter = DateComponentsFormatter()
        formatter.zeroFormattingBehavior = .pad
        formatter.allowedUnits = [.hour, .minute, .second]
        return formatter
    }()

    var timers = [TimerModel](repeating:TimerModel(), count:30)


    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view, typically from a nib.
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    func elapsedTimeSince(_ startTime: Date) -> String {
        let elapsed = -startTime.timeIntervalSinceNow

        return self.formatter.string(from: elapsed) ?? "0:00:00"
    }

    func startTimer() {
        self.timersActive += 1
        guard self.timer == nil else {
            return
        }

        self.timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true, block: { [weak self] (timer) in
           if let me = self {
            for indexPath in me.tableview.indexPathsForVisibleRows ?? [] {
                let timer = me.timers[indexPath.row]
                if timer.isRunning {
                    if let cell = me.tableview.cellForRow(at: indexPath) {
                        cell.textLabel?.text = me.formatter.string(from: timer.elapsed) ?? "0:00:00"
                    }
                }
            }
           }
        })
    }

    func stopTimer() {
        self.timersActive -= 1
        if self.timersActive == 0 {
            self.timer?.invalidate()
            self.timer = nil
        }
    }

}

extension ViewController: UITableViewDataSource {
    func numberOfSections(in tableView: UITableView) -> Int {
        return 1
    }

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.timers.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
        let timer = self.timers[indexPath.row]

        cell.imageView?.image = timer.isRunning ? #imageLiteral(resourceName: "GreenDot") : #imageLiteral(resourceName: "RedDot")
        cell.textLabel?.text = self.formatter.string(from: timer.elapsed) ?? "0:00:00"

        return cell
    }
}

extension ViewController: UITableViewDelegate {
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        self.timers[indexPath.row].isRunning = !self.timers[indexPath.row].isRunning
        self.tableview.reloadRows(at: [indexPath], with: .none)
        if self.timers[indexPath.row].isRunning {
            self.startTimer()
        } else {
            self.stopTimer()
        }
    }
}




cocoa-touch