आईओएस टाइमर

कल्पना करें कि आप एक ऐसे अनुप्रयोग पर काम कर रहे हैं जिसमें आपको समय-समय पर कुछ क्रियाएं करने की आवश्यकता होती है। यह वही है जो स्विफ्ट के लिए टाइमर वर्ग का उपयोग करता है।

टाइमर का उपयोग एप्लिकेशन में कार्यों की योजना बनाने के लिए किया जाता है। यह एक बार की कार्रवाई या दोहराने की प्रक्रिया हो सकती है।

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

एक परीक्षण साइट के रूप में, हम एप्लिकेशन का उपयोग करेंगे - एक आदिम कार्य अनुसूचक।

शुरुआत हो रही है

स्रोत प्रोजेक्ट डाउनलोड करें । इसे Xcode में खोलें, इसकी संरचना को देखें, संकलित करें और निष्पादित करें। आप सबसे सरल कार्य शेड्यूलर देखेंगे:



इसमें एक नया कार्य जोड़ें। + आइकन पर टैप करें, कार्य का नाम दर्ज करें, ठीक टैप करें।

जोड़े गए कार्यों में टाइमस्टैम्प होता है। आपके द्वारा अभी बनाया गया नया कार्य शून्य सेकंड के साथ चिह्नित किया गया है। जैसा कि आप देख सकते हैं, यह मान नहीं बढ़ता है।

प्रत्येक कार्य को पूर्ण के रूप में चिह्नित किया जा सकता है। कार्य पर टैप करें। कार्य नाम को पार कर लिया जाएगा और इसे पूर्ण के रूप में चिह्नित किया जाएगा।

हमारा पहला टाइमर बनाएँ

आइए हमारे एप्लिकेशन का मुख्य टाइमर बनाएं। टाइमर वर्ग, जिसे NSTimer के रूप में भी जाना जाता है , एक विशिष्ट क्षण, दोनों एकल और आवधिक के लिए एक क्रिया को शेड्यूल करने का एक सुविधाजनक तरीका है।

TaskListViewController.swift खोलें और इस चर को TaskListViewController में जोड़ें:

var timer: Timer? 

फिर वहां एक्सटेंशन जोड़ें:

 // MARK: - Timer extension TaskListViewController { } 

और इस कोड को एक्सटेंशन में पेस्ट करें:

 @objc func updateTimer() { // 1 guard let visibleRowsIndexPaths = tableView.indexPathsForVisibleRows else { return } for indexPath in visibleRowsIndexPaths { // 2 if let cell = tableView.cellForRow(at: indexPath) as? TaskTableViewCell { cell.updateTime() } } } 

इस विधि में, हम:

1. जांचें कि क्या कार्य तालिका में दृश्य पंक्तियां हैं।
2. प्रत्येक दृश्यमान सेल के लिए अपडेट टाइमटाइम पर कॉल करें। यह विधि सेल में टाइमस्टैम्प को अपडेट करती है (देखें TaskTableViewCell.swift )।

फिर इस कोड को एक्सटेंशन में जोड़ें:

 func createTimer() { // 1 if timer == nil { // 2 timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(updateTimer), userInfo: nil, repeats: true) } } 

यहाँ हम हैं:

1. जांचें कि क्या टाइमर में टाइमर क्लास का एक उदाहरण है।
2. यदि नहीं, तो हर सेकंड में अपडेट टाइमर () कॉल करने वाला टाइमर बनाएं।

फिर जैसे ही उपयोगकर्ता पहला कार्य जोड़ता है, हमें एक टाइमर बनाने की आवश्यकता होती है। PresentAlertController (_ :) विधि की शुरुआत में createTimer () जोड़ें।

एप्लिकेशन लॉन्च करें और कुछ नए कार्य बनाएं। आप देखेंगे कि प्रत्येक कार्य के लिए समय की मोहर प्रत्येक सेकंड में बदल जाती है।

टाइमर सहिष्णुता जोड़ें

यूआई की बदतर स्थिति और अधिक बैटरी खपत के कारण टाइमर की संख्या बढ़ जाती है। प्रत्येक टाइमर इसे आवंटित समय पर बिल्कुल निष्पादित करने की कोशिश करता है, क्योंकि डिफ़ॉल्ट रूप से इसकी सहनशीलता शून्य है।

ऊर्जा की खपत को कम करने के लिए टाइमर सहिष्णुता जोड़ना एक आसान तरीका है। यह सिस्टम को नियत समय और नियत समय और सहिष्णुता समय के बीच टाइमर क्रिया करने की अनुमति देता है - लेकिन निर्धारित अंतराल से पहले कभी नहीं।

केवल एक बार चलने वाले टाइमर के लिए, सहिष्णुता मान को अनदेखा किया जाता है।

CreateTimer () विधि में, टाइमर असाइनमेंट के तुरंत बाद, इस लाइन को जोड़ें:

 timer?.tolerance = 0.1 

ऐप लॉन्च करें। इस विशेष मामले में, प्रभाव स्पष्ट नहीं होगा (हमारे पास केवल एक टाइमर है), हालांकि, कई टाइमर की वास्तविक स्थिति में, आपके उपयोगकर्ताओं को अधिक उत्तरदायी इंटरफ़ेस मिलेगा और एप्लिकेशन अधिक ऊर्जा कुशल होगा।

पृष्ठभूमि में टाइमर

दिलचस्प बात यह है कि जब कोई एप्लिकेशन बैकग्राउंड में जाता है तो टाइमर का क्या होता है? इससे निपटने के लिए, इस कोड को अपडेटमिटर () विधि की शुरुआत में जोड़ें:

 if let fireDateDescription = timer?.fireDate.description { print(fireDateDescription) } 

यह हमें कंसोल में टाइमर घटनाओं को ट्रैक करने की अनुमति देगा।

एप्लिकेशन चलाएँ, कार्य जोड़ें। अब अपने डिवाइस पर होम बटन दबाएं, और फिर हमारे आवेदन पर वापस लौटें।

कंसोल में, आपको कुछ इस तरह दिखाई देगा:



जैसा कि आप देख सकते हैं, जब एप्लिकेशन पृष्ठभूमि में जाता है, तो iOS सभी रनिंग एप्लिकेशन टाइमर को रोक देता है। जब एप्लिकेशन सक्रिय हो जाता है, तो iOS टाइमर को फिर से शुरू करता है।

रन लूप्स को समझना

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

हर बार जब आप एप्लिकेशन लॉन्च करते हैं, तो सिस्टम एप्लिकेशन का मुख्य धागा बनाता है, प्रत्येक थ्रेड में स्वचालित रूप से इसके लिए निष्पादन लूप होता है।

लेकिन यह सारी जानकारी अब आपके लिए महत्वपूर्ण क्यों है? अब प्रत्येक टाइमर मुख्य धागे में शुरू होता है और निष्पादन लूप में शामिल होता है। आप शायद जानते हैं कि मुख्य धागा उपयोगकर्ता इंटरफ़ेस, प्रसंस्करण स्पर्श, और इसी तरह प्रदान करने में लगा हुआ है। यदि मुख्य धागा कुछ के साथ व्यस्त है, तो आपके एप्लिकेशन का इंटरफ़ेस "अप्रतिसादी" (हैंग) हो सकता है।

क्या आपने देखा कि जब आप तालिका दृश्य को खींचते हैं तो सेल में टाइमस्टैम्प अपडेट नहीं होता है?



आप एक अलग मोड में टाइमर शुरू करने के लिए रन चक्र बताकर इस समस्या को हल कर सकते हैं।

रन साइकिल मोड को समझना

निष्पादन चक्र मोड इनपुट स्रोतों का एक सेट है, जैसे स्क्रीन को छूना या माउस को क्लिक करना, जिसे मॉनिटर करने के लिए सेट किया जा सकता है और "पर्यवेक्षकों" का एक सेट जो सूचनाएं प्राप्त करता है।

IOS में तीन रनटाइम मोड हैं:

डिफ़ॉल्ट : इनपुट स्रोत जो NSConnectionObjects नहीं हैं संसाधित होते हैं।
आम : इनपुट चक्रों का एक सेट संसाधित किया जा रहा है, जिसके लिए आप इनपुट स्रोतों, टाइमर, "पर्यवेक्षकों" के एक सेट को परिभाषित कर सकते हैं।
ट्रैकिंग : अनुप्रयोग UI संसाधित किया जा रहा है।

हमारे आवेदन के लिए, सबसे उपयुक्त मोड आम है । इसका उपयोग करने के लिए, createTimer () विधि की सामग्री को निम्न के साथ बदलें :

 if timer == nil { let timer = Timer(timeInterval: 1.0, target: self, selector: #selector(updateTimer), userInfo: nil, repeats: true) RunLoop.current.add(timer, forMode: .common) timer.tolerance = 0.1 self.timer = timer } 

पिछले कोड से मुख्य अंतर यह है कि TaskListViewController को टाइमर असाइन करने से पहले, हम इस टाइमर को सामान्य मोड में रन लूप में जोड़ते हैं।

एप्लिकेशन को संकलित करें और चलाएं।



अब टेबल को स्क्रॉल करने पर भी सेल के टाइमस्टैम्प अपडेट किए जाते हैं।

सभी कार्यों को पूरा करने के लिए एनीमेशन जोड़ें

अब हम उपयोगकर्ता को सभी कार्यों को पूरा करने के लिए एक बधाई एनीमेशन जोड़ते हैं - गेंद स्क्रीन के नीचे से बहुत ऊपर तक उठेगी।

TaskListViewController की शुरुआत में इन चर जोड़ें:

 // 1 var animationTimer: Timer? // 2 var startTime: TimeInterval?, endTime: TimeInterval? // 3 let animationDuration = 3.0 // 4 var height: CGFloat = 0 

इन चरों का उद्देश्य है:

1. एनीमेशन टाइमर भंडारण।
2. शुरुआत और एनीमेशन के अंत के समय का भंडारण।
3. एनीमेशन की अवधि।
4. एनीमेशन ऊंचाई।

अब TaskListViewController.swift फ़ाइल के अंत में निम्नलिखित TaskListViewController एक्सटेंशन जोड़ें:

 // MARK: - Animation extension TaskListViewController { func showCongratulationAnimation() { // 1 height = UIScreen.main.bounds.height + balloon.frame.size.height // 2 balloon.center = CGPoint(x: UIScreen.main.bounds.width / 2, y: height + balloon.frame.size.height / 2) balloon.isHidden = false // 3 startTime = Date().timeIntervalSince1970 endTime = animationDuration + startTime! // 4 animationTimer = Timer.scheduledTimer(withTimeInterval: 1 / 60, repeats: true) { timer in // TODO: Animation here } } } 

यहाँ हम निम्नलिखित करते हैं:

• डिवाइस स्क्रीन की ऊंचाई प्राप्त करते हुए, एनीमेशन की ऊंचाई की गणना करें
• गेंद को स्क्रीन के बाहर केन्द्रित करें और इसकी दृश्यता निर्धारित करें
• एनीमेशन का प्रारंभ और समाप्ति समय असाइन करें
• हम एनीमेशन टाइमर शुरू करते हैं और प्रति सेकंड 60 बार एनीमेशन अपडेट करते हैं

अब हमें बधाई एनीमेशन को अपडेट करने के लिए वास्तविक तर्क बनाने की आवश्यकता है। ShowCongratulationAnimation () के बाद इस कोड को जोड़ें:

 func updateAnimation() { // 1 guard let endTime = endTime, let startTime = startTime else { return } // 2 let now = Date().timeIntervalSince1970 // 3 if now >= endTime { animationTimer?.invalidate() balloon.isHidden = true } // 4 let percentage = (now - startTime) * 100 / animationDuration let y = height - ((height + balloon.frame.height / 2) / 100 * CGFloat(percentage)) // 5 balloon.center = CGPoint(x: balloon.center.x + CGFloat.random(in: -0.5...0.5), y: y) } 

हम क्या करते हैं:

1. जाँच करें कि एंडटाइम और स्टार्टटाइम असाइन किए गए हैं
2. निरंतर समय बचाओ
3. हम यह सुनिश्चित करते हैं कि अंतिम समय अभी तक नहीं आया है। यदि यह पहले ही आ चुका है, तो टाइमर को अपडेट करें और हमारी गेंद को छिपाएं
4. गेंद के नए y- समन्वय की गणना करें
5. गेंद की क्षैतिज स्थिति की गणना पिछली स्थिति के सापेक्ष की जाती है

अब // TODO को प्रतिस्थापित करें: इस कोड के साथ यहां showCongratulationAnimation () में एनिमेशन :

 self.updateAnimation() 

जब भी टाइमर की घटना होती है तो अब अपडेटनेम () कहा जाता है।

हुर्रे, हमने एक एनीमेशन बनाया। हालाँकि, जब अनुप्रयोग शुरू होता है, तो कुछ भी नया नहीं होता है ...

एनीमेशन दिखा रहा है

जैसा कि आपने शायद अनुमान लगाया था, हमारे नए एनीमेशन को "लॉन्च" करने के लिए कुछ भी नहीं है। ऐसा करने के लिए, हमें एक और विधि की आवश्यकता है। इस कोड को TaskListViewController एनीमेशन एक्सटेंशन में जोड़ें :

 func showCongratulationsIfNeeded() { if taskList.filter({ !$0.completed }).count == 0 { showCongratulationAnimation() } } 

हम इस विधि को कॉल करेंगे जब भी उपयोगकर्ता कार्य को पूरा करता है, तो वह जांचता है कि सभी कार्य पूरे हो गए हैं या नहीं। यदि हां, तो यह showCongratulationAnimation () कहेगा ।

अंत में, tableView के अंत में इस विधि में एक कॉल जोड़ें (_: didSelectRowAt :) :

 showCongratulationsIfNeeded() 

एप्लिकेशन लॉन्च करें, कुछ कार्यों को बनाएं, उन्हें पूरा होने के रूप में चिह्नित करें - और आप हमारे एनीमेशन देखेंगे!

हम टाइमर बंद कर देते हैं

यदि आप कंसोल को देखते हैं, तो आप देखेंगे कि यद्यपि उपयोगकर्ता ने सभी कार्यों को पूरा कर लिया है, टाइमर काम करना जारी रखता है। यह पूरी तरह से व्यर्थ है, इसलिए यह टाइमर को बंद करने के लिए समझ में आता है जब इसकी आवश्यकता नहीं होती है।

सबसे पहले, टाइमर को रोकने के लिए एक नई विधि बनाएं:

 func cancelTimer() { timer?.invalidate() timer = nil } 

यह टाइमर को अपडेट करेगा और इसे शून्य पर रीसेट करेगा ताकि हम इसे बाद में फिर से सही ढंग से बना सकें। अमान्य () टाइमर को रन लूप से निकालने का एकमात्र तरीका है। रन लूप अमान्य टाइमर () या थोड़ी देर बाद कॉल करने के तुरंत बाद मजबूत टाइमर संदर्भ को हटा देगा।

अब showCongratulationsIfNeeded () विधि को निम्नानुसार बदलें:

 func showCongratulationsIfNeeded() { if taskList.filter({ !$0.completed }).count == 0 { cancelTimer() showCongratulationAnimation() } else { createTimer() } } 

अब, यदि उपयोगकर्ता सभी कार्यों को पूरा करता है, तो एप्लिकेशन पहले टाइमर को रीसेट करेगा और फिर एनीमेशन दिखाएगा, अन्यथा यह नया टाइमर बनाने की कोशिश करेगा यदि यह पहले से ही नहीं है।

ऐप लॉन्च करें।



अब टाइमर बंद हो जाता है और इसे फिर से चालू करना चाहिए।

चिकनी एनीमेशन के लिए कैडिसप्लेलिंक

एनीमेशन को नियंत्रित करने के लिए टाइमर एक आदर्श विकल्प नहीं है। आपने एनिमेशन पर कुछ फ्रेम स्किप करने वाले एनीमेशन देखे होंगे, खासकर यदि आप सिम्युलेटर में एप्लिकेशन चलाते हैं।

हमने टाइमर को 60Hz पर सेट किया है। इस प्रकार, टाइमर हर 16 एमएस में एनीमेशन को अपडेट करता है। स्थिति पर अधिक बारीकी से विचार करें:



टाइमर का उपयोग करते समय , हमें नहीं पता कि कार्रवाई शुरू होने का सही समय क्या है। यह या तो शुरुआत में या फ्रेम के अंत में हो सकता है। मान लें कि टाइमर प्रत्येक फ्रेम के बीच में चलता है (चित्र में नीले डॉट्स)। केवल एक चीज जो हम निश्चित रूप से जानते हैं, वह यह है कि कॉल प्रत्येक 16 एमएस में होगी।

अब हमारे पास एनीमेशन को निष्पादित करने के लिए केवल 8 एमएस हैं, और यह हमारे एनीमेशन के लिए पर्याप्त नहीं हो सकता है। आइए आकृति में दूसरे फ्रेम को देखें। दूसरे फ्रेम को आवंटित समय में पूरा नहीं किया जा सकता है, इसलिए एप्लिकेशन एनीमेशन के दूसरे फ्रेम को रीसेट कर देगा।

कैडिसप्लेलिंक हमारी मदद करेगा

CADisplayLink को प्रति फ्रेम एक बार कहा जाता है और यथासंभव वास्तविक एनीमेशन फ्रेम को सिंक्रनाइज़ करने का प्रयास करता है। अब आपके पास अपने निपटान में सभी 16 एमएस होंगे और आईओएस एक फ्रेम को नहीं गिराएगा।

कैडिसप्लेलिंक का उपयोग करने के लिए, आपको एनीमेशन टाइपर को एक नए प्रकार से बदलने की आवश्यकता है।

इस कोड को बदलें

 var animationTimer: Timer? 

इस एक पर:

 var displayLink: CADisplayLink? 

आपने CADisplayLink के साथ टाइमर को बदल दिया है। कैडिसप्लेलिंक एक टाइमर दृश्य है जो डिस्प्ले के वर्टिकल स्कैन से बंधा होता है। इसका मतलब है कि डिवाइस का GPU तब तक विराम देगा जब तक स्क्रीन GPU कमांड को प्रोसेस करना जारी रख सकती है। इस तरह हमें चिकनी एनीमेशन मिलता है।

इस कोड को बदलें

 var startTime: TimeInterval?, endTime: TimeInterval? 

इस एक पर:

 var startTime: CFTimeInterval?, endTime: CFTimeInterval? 

आपने CFTimeInterval के साथ TimeInterval को बदल दिया, जो CADisplayLink के साथ काम करने के लिए आवश्यक है।

ShowCongratulationAnimation () विधि के पाठ को इसके साथ बदलें:

 func showCongratulationAnimation() { // 1 height = UIScreen.main.bounds.height + balloon.frame.size.height balloon.center = CGPoint(x: UIScreen.main.bounds.width / 2, y: height + balloon.frame.size.height / 2) balloon.isHidden = false // 2 startTime = CACurrentMediaTime() endTime = animationDuration + startTime! // 3 displayLink = CADisplayLink(target: self, selector: #selector(updateAnimation)) displayLink?.add(to: RunLoop.main, forMode: .common) } 

हम यहाँ क्या कर रहे हैं:

1. एनीमेशन की ऊंचाई सेट करें, गेंद और दृश्यता के निर्देशांक - लगभग उसी तरह जैसे उन्होंने पहले किया था।
2. आरंभिक समय CACurrentMediaTime () (दिनांक () के बजाय ) के साथ प्रारंभ करें)
3. हम कैडिसप्लेलिंक क्लास का एक उदाहरण बनाते हैं और इसे सामान्य मोड में रन लूप में जोड़ते हैं।

अब निम्नलिखित कोड से updateAnimation () को बदलें:

 // 1 @objc func updateAnimation() { guard let endTime = endTime, let startTime = startTime else { return } // 2 let now = CACurrentMediaTime() if now >= endTime { // 3 displayLink?.isPaused = true displayLink?.invalidate() balloon.isHidden = true } let percentage = (now - startTime) * 100 / animationDuration let y = height - ((height + balloon.frame.height / 2) / 100 * CGFloat(percentage)) balloon.center = CGPoint(x: balloon.center.x + CGFloat.random(in: -0.5...0.5), y: y) } 

1. विधि हस्ताक्षर में objc जोड़ें (कैडिसप्लेलिंक के लिए, चयनकर्ता पैरामीटर को इस तरह के हस्ताक्षर की आवश्यकता होती है)।
2. CoreAnimation की तारीख को आरंभ करने के लिए दिनांक () के साथ आरंभीकरण बदलें।
3. CADTplayLink के एक ठहराव और अमान्य के साथ animTimer.invalidate () कॉल को बदलें। यह कैडिसप्लेलिंक को रन लूप से भी हटा देगा।

एप्लिकेशन लॉन्च करें!


वाह! हमने सफलतापूर्वक टाइमर आधारित एनीमेशन को एक अधिक उपयुक्त कैडिसप्लेलिंक के साथ बदल दिया - और बिना जर्क किए एनीमेशन एनीमेशन को प्राप्त किया।

निष्कर्ष

इस मार्गदर्शिका में, आपको पता चला कि iOS में टाइमर क्लास कैसे काम करता है, निष्पादन चक्र क्या है और यह आपके एप्लिकेशन को इंटरफ़ेस के संदर्भ में अधिक उत्तरदायी कैसे बना सकता है, और सुचारू एनीमेशन के लिए टाइमर के बजाय कैडिसप्लेलिंक का उपयोग कैसे करें।