कस्टम एनिमेशन बनाने के लिए UIViewPropertyAnimator का उपयोग करना

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

IOS में एनीमेशन को लागू करने के कई तरीके हैं। संभवतः सबसे लोकप्रिय तरीका UIView.animate (withDuration: animations :) का उपयोग करना है । आप CABasicAnimation का उपयोग करके एक छवि परत को एनिमेट कर सकते हैं। इसके अलावा, UIKit आपको UIViewControllerTransitioningDelegate का उपयोग करके नियंत्रक को प्रदर्शित करने के लिए कस्टम एनिमेशन को कॉन्फ़िगर करने की अनुमति देता है।

इस लेख में, मैं एक और रोमांचक तरीके पर विचार करने के लिए चर्चा करना चाहता हूं - UIViewPropertyAnimator । यह वर्ग अपने पूर्ववर्ती की तुलना में कई अधिक प्रबंधन कार्य प्रदान करता है, UIView.animat e। अस्थायी, इंटरैक्टिव और बाधित एनिमेशन बनाने के लिए इसका उपयोग करें। इसके अलावा, एनिमेटर को जल्दी से बदलना संभव है।

पेश है UIViewPropertyAnimator

UIViewPropertyAnimator को iOS 10 में पेश किया गया था। यह आपको ऑब्जेक्ट-ओरिएंटेड तरीके से एनिमेशन बनाने की अनुमति देता है। आइए UIViewPropertyAnimator का उपयोग करके बनाए गए एक एनीमेशन का एक उदाहरण देखें ।



यह कैसे है जब यह UIView का उपयोग कर रहा था।

UIView.animate(withDuration: 0.3) { view.frame = view.frame.offsetBy(dx: 100, dy: 0) } 

और यहाँ यह कैसे करना है UIViewPropertyAnimator के साथ:

 let animator = UIViewPropertyAnimator(duration:0.3, curve: .linear) { view.frame = view.frame.offsetBy(dx:100, dy:0) } animator.startAnimation() 

यदि आपको एनीमेशन की जांच करने की आवश्यकता है, तो बस एक खेल का मैदान बनाएं और नीचे दिखाए अनुसार कोड चलाएं। दोनों कोड टुकड़े एक ही परिणाम के लिए नेतृत्व करेंगे।



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

इंटरएक्टिव और बाधित एनीमेशन

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

UIView एनिमेशन एनिमेशन पूरा होने के प्रतिशत को नियंत्रित करने का एक आसान तरीका प्रदान नहीं करते हैं। आप लूप के बीच में एनीमेशन को रोक नहीं सकते हैं और रुकावट के बाद इसका निष्पादन जारी रख सकते हैं।

इस मामले में, हम UIViewPropertyAnimator के बारे में बात करेंगे। अगला, हम देखेंगे कि आप आसानी से कुछ चरणों में पूरी तरह से इंटरैक्टिव, बाधित एनीमेशन और रिवर्स एनीमेशन कैसे बना सकते हैं।

प्रक्षेपण परियोजना की तैयारी

सबसे पहले आपको स्टार्टर प्रोजेक्ट डाउनलोड करना होगा । एक बार जब आप संग्रह खोलते हैं, तो आपको सिटीगाइड एप्लिकेशन मिलेगा जो उपयोगकर्ताओं को अपनी छुट्टियों की योजना बनाने में मदद करता है। उपयोगकर्ता शहरों की सूची के माध्यम से स्क्रॉल कर सकता है, और फिर उस शहर के बारे में विस्तृत जानकारी के साथ एक विस्तृत विवरण खोल सकता है जिसे उसने पसंद किया था।

सुंदर एनिमेशन बनाने से पहले परियोजना के स्रोत कोड पर विचार करें। यहाँ एक परियोजना में आप इसे Xcode में खोलकर क्या पा सकते हैं:

1. ViewController.swift : UICollectionView के साथ मुख्य अनुप्रयोग नियंत्रक जो सिटी ऑब्जेक्ट की एक सरणी प्रदर्शित करता है।
2. CityCollectionViewCell.swift: सिटी प्रदर्शित करने के लिए सेल। वास्तव में, इस लेख में अधिकांश परिवर्तन इस वर्ग पर लागू होंगे। आप देख सकते हैं कि विवरणलेबल और क्लोजबटन पहले से ही कक्षा में परिभाषित हैं। हालांकि, आवेदन शुरू करने के बाद, ये ऑब्जेक्ट छिपाए जाएंगे। चिंता न करें, वे थोड़ी देर बाद दिखाई देंगे। इस वर्ग में संग्रह दृश्य और सूचकांक गुण भी हैं। बाद में उनका उपयोग एनीमेशन के लिए किया जाएगा।
3. CityCollectionViewFlowLayout.swift: यह वर्ग क्षैतिज स्क्रॉलिंग के लिए जिम्मेदार है। हम इसे अभी तक नहीं बदलेंगे।
4. City.swift : मुख्य एप्लिकेशन मॉडल में एक विधि है जिसका उपयोग ViewController में किया गया था।
5. Main.storyboard: वहाँ आप ViewController और CityCollectionViewCell के लिए यूजर इंटरफेस पा सकते हैं।

आइए नमूना आवेदन बनाने और चलाने का प्रयास करें। इसके परिणामस्वरूप, हम निम्नलिखित प्राप्त करते हैं।

तैनाती और पतन एनीमेशन का कार्यान्वयन

आवेदन शुरू करने के बाद, शहरों की एक सूची प्रदर्शित की जाती है। लेकिन उपयोगकर्ता कोशिकाओं के रूप में वस्तुओं के साथ बातचीत नहीं कर सकता है। अब आपको प्रत्येक शहर के लिए जानकारी प्रदर्शित करने की आवश्यकता है जब उपयोगकर्ता किसी एक सेल पर क्लिक करता है। आवेदन के अंतिम संस्करण पर एक नज़र डालें। यहाँ वास्तव में विकसित करने की आवश्यकता है:


एनीमेशन अच्छा लगता है, है ना? लेकिन यहां कुछ खास नहीं है, यह सिर्फ UIViewPropertyAnimator का मूल तर्क है। आइए देखें कि इस प्रकार के एनीमेशन को कैसे लागू किया जाए। एक संग्रह दृश्य विधि बनाएं (_: didSelectItemAt) , ViewController फ़ाइल के अंत में निम्नलिखित कोड टुकड़ा जोड़ें:

 func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) { let selectedCell = collectionView.cellForItem(at: indexPath)! as! CityCollectionViewCell selectedCell.toggle() } 

अब हमें टॉगल विधि को लागू करने की आवश्यकता है। चलिए CityCollectionViewCell.swift पर जाएँ और इस विधि को लागू करें।

सबसे पहले, फ़ाइल के शीर्ष पर स्थित स्टेट एन्यूमरेशन को CityCollectionViewCell वर्ग की घोषणा से ठीक पहले जोड़ें । यह सूची आपको सेल की स्थिति को ट्रैक करने की अनुमति देती है:

 private enum State { case expanded case collapsed var change: State { switch self { case .expanded: return .collapsed case .collapsed: return .expanded } } } 

CityCollectionViewCell वर्ग में एनीमेशन को नियंत्रित करने के लिए कुछ गुण जोड़ें:

 private var initialFrame: CGRect? private var state: State = .collapsed private lazy var animator: UIViewPropertyAnimator = { return UIViewPropertyAnimator(duration: 0.3, curve: .easeInOut) }() 

प्रारंभिकफ्रेम चर का उपयोग सेल फ्रेम को स्टोर करने के लिए किया जाता है जब तक कि एनीमेशन चलता नहीं है । यदि सेल का विस्तार या पतन हुआ है तो ट्रैक करने के लिए राज्य का उपयोग किया जाता है। और एनीमेशन को नियंत्रित करने के लिए एनिमेटर चर का उपयोग किया जाता है।

अब टॉगल विधि जोड़ें और इसे नजदीकी विधि से कॉल करें, उदाहरण के लिए:

 @IBAction func close(_ sender: Any) { toggle() } func toggle() { switch state { case .expanded: collapse() case .collapsed: expand() } } 

फिर हम दो और तरीके जोड़ते हैं: विस्तार () और पतन () । हम उनका कार्यान्वयन जारी रखेंगे। सबसे पहले, हम विस्तार () विधि से शुरू करते हैं:

 private func expand() { guard let collectionView = self.collectionView, let index = self.index else { return } animator.addAnimations { self.initialFrame = self.frame self.descriptionLabel.alpha = 1 self.closeButton.alpha = 1 self.layer.cornerRadius = 0 self.frame = CGRect(x: collectionView.contentOffset.x, y:0, width: collectionView.frame.width, height: collectionView.frame.height) if let leftCell = collectionView.cellForItem(at: IndexPath(row: index - 1, section: 0)) { leftCell.center.x -= 50 } if let rightCell = collectionView.cellForItem(at: IndexPath(row: index + 1, section: 0)) { rightCell.center.x += 50 } self.layoutIfNeeded() } animator.addCompletion { position in switch position { case .end: self.state = self.state.change collectionView.isScrollEnabled = false collectionView.allowsSelection = false default: () } } animator.startAnimation() } 

कितना कोड है? मुझे समझाएं कि कदम से कदम क्या हो रहा है:

1. पहले, देखें कि क्या संग्रह दृश्य और सूचकांक शून्य के बराबर नहीं हैं। अन्यथा, हम एनीमेशन शुरू करने में सक्षम नहीं होंगे।
2. अगला, animator.addAnimations पर कॉल करके एनीमेशन बनाना शुरू करें।
3. इसके बाद, वर्तमान फ़्रेम को सहेजें, जिसका उपयोग कन्वेंशन एनीमेशन में इसे पुनर्स्थापित करने के लिए किया जाता है।
4. फिर हम उन्हें वर्णन करने के लिए विवरणलेबेल और क्लोज़बटन के लिए अल्फा मान सेट करते हैं।
5. अगला, गोल कोने को हटा दें और सेल के लिए एक नया फ्रेम सेट करें। सेल को फुल स्क्रीन में दिखाया जाएगा।
6. अगला हम पड़ोसी कोशिकाओं को स्थानांतरित करते हैं।
7. अब संग्रह छवि के इंटरैक्शन को अक्षम करने के लिए animator.addComplete () विधि को कॉल करें। यह सेल विस्तार के दौरान उपयोगकर्ताओं को इसे स्क्रॉल करने से रोकता है। सेल की वर्तमान स्थिति को भी बदलें। सेल की स्थिति को बदलना महत्वपूर्ण है, और उसके बाद ही एनीमेशन समाप्त होता है।

अब एक कन्वेंशन एनीमेशन जोड़ें। संक्षेप में, यह सिर्फ इतना है कि हम सेल को उसकी पिछली स्थिति में पुनर्स्थापित करते हैं:

 private func collapse() { guard let collectionView = self.collectionView, let index = self.index else { return } animator.addAnimations { self.descriptionLabel.alpha = 0 self.closeButton.alpha = 0 self.layer.cornerRadius = self.cornerRadius self.frame = self.initialFrame! if let leftCell = collectionView.cellForItem(at: IndexPath(row: index - 1, section: 0)) { leftCell.center.x += 50 } if let rightCell = collectionView.cellForItem(at: IndexPath(row: index + 1, section: 0)) { rightCell.center.x -= 50 } self.layoutIfNeeded() } animator.addCompletion { position in switch position { case .end: self.state = self.state.change collectionView.isScrollEnabled = true collectionView.allowsSelection = true default: () } } animator.startAnimation() } 

अब आवेदन को संकलित करने और चलाने का समय है। सेल पर क्लिक करने का प्रयास करें और आप एनीमेशन देखेंगे। छवि को बंद करने के लिए, ऊपरी दाएं कोने में क्रॉस आइकन पर क्लिक करें।

जेस्चर प्रसंस्करण जोड़ना

आप UIView.animate का उपयोग करके समान परिणाम प्राप्त करने का दावा कर सकते हैं। UIViewPropertyAnimator का उपयोग करने का क्या मतलब है ?

खैर, एनीमेशन को इंटरैक्टिव बनाने का समय आ गया है। UIPanGestureRecognizer और popupOffset नामक एक नई प्रॉपर्टी जोड़ें, जिससे पता लगाया जा सके कि सेल को कितना स्थानांतरित किया जा सकता है। चलिए CityCollectionViewCell वर्ग में इन चरों को घोषित करते हैं:

 private let popupOffset: CGFloat = (UIScreen.main.bounds.height - cellSize.height)/2.0 private lazy var panRecognizer: UIPanGestureRecognizer = { let recognizer = UIPanGestureRecognizer() recognizer.addTarget(self, action: #selector(popupViewPanned(recognizer:))) return recognizer }() 

फिर स्वाइप परिभाषा दर्ज करने के लिए निम्न विधि जोड़ें:

 override func awakeFromNib() { self.addGestureRecognizer(panRecognizer) } 

अब आपको स्वाइप जेस्चर को ट्रैक करने के लिए पॉपअप व्यूप्ड विधि को जोड़ने की आवश्यकता है। निम्नलिखित कोड को CityCollectionViewCell में पेस्ट करें:

 @objc func popupViewPanned(recognizer: UIPanGestureRecognizer) { switch recognizer.state { case .began: toggle() animator.pauseAnimation() case .changed: let translation = recognizer.translation(in: collectionView) var fraction = -translation.y / popupOffset if state == .expanded { fraction *= -1 } animator.fractionComplete = fraction case .ended: animator.continueAnimation(withTimingParameters: nil, durationFactor: 0) default: () } } 

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

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

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

ऐसा करने के लिए, आपको एनीमेशन की प्रगति को बचाने की आवश्यकता है और फिर एनीमेशन के पूरा होने के प्रतिशत की गणना करने के लिए इस मूल्य को ध्यान में रखना चाहिए।

सबसे पहले, CityCollectionViewCell में एक नई संपत्ति घोषित करें:

 private var animationProgress: CGFloat = 0 

फिर प्रगति को याद रखने के लिए कोड की निम्नलिखित पंक्ति के साथ पॉपअप व्यू विधि के .began ब्लॉक को अपडेट करें:

 animationProgress = animator.fractionComplete 

पूर्ण ब्लॉक में, आपको पूर्णता के प्रतिशत की सही गणना करने के लिए कोड की निम्नलिखित पंक्ति को अपडेट करना होगा:

 animator.fractionComplete = fraction + animationProgress 

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

एनीमेशन रिवर्स

आप वर्तमान कार्यान्वयन के लिए एक दोष पा सकते हैं। यदि आप सेल को थोड़ा खींचते हैं और फिर उसे उसकी मूल स्थिति में लौटाते हैं, तो आप अपनी उंगली छोड़ते समय सेल का विस्तार करना जारी रखेंगे। इंटरएक्टिव एनीमेशन को और भी बेहतर बनाने के लिए इस समस्या को ठीक करते हैं।
नीचे दिए गए अनुसार, पॉपअप व्यूप्ड विधि के .end ब्लॉक को अपडेट करें:

 let velocity = recognizer.velocity(in: self) let shouldComplete = velocity.y > 0 if velocity.y == 0 { animator.continueAnimation(withTimingParameters: nil, durationFactor: 0) break } switch state { case .expanded: if !shouldComplete && !animator.isReversed { animator.isReversed = !animator.isReversed } if shouldComplete && animator.isReversed { animator.isReversed = !animator.isReversed } case .collapsed: if shouldComplete && !animator.isReversed { animator.isReversed = !animator.isReversed } if !shouldComplete && animator.isReversed { animator.isReversed = !animator.isReversed } } animator.continueAnimation(withTimingParameters: nil, durationFactor: 0) 

अब हम यह निर्धारित करने के लिए इशारे की गति को ध्यान में रखते हैं कि क्या एनीमेशन को उलट दिया जाना चाहिए।

और अंत में, .changed ब्लॉक में कोड की एक और लाइन डालें। इस कोड को animator.fractionComplete गणना के दाईं ओर रखें।

 if animator.isReversed { fraction *= -1 } 

चलिए फिर से एप्लिकेशन चलाते हैं। अब सब कुछ बिना असफल हुए काम करना चाहिए।

पैन जेस्चर को ठीक करें

इसलिए, हमने UIViewPropertyAnimator का उपयोग करके एनीमेशन का कार्यान्वयन पूरा कर लिया है । हालांकि, एक अप्रिय गलती है। आप अनुप्रयोग का परीक्षण करते समय उससे मिले होंगे। समस्या यह है कि सेल को क्षैतिज रूप से स्क्रॉल करना संभव नहीं है। चलो कोशिकाओं के माध्यम से बाएं / दाएं स्वाइप करने की कोशिश करते हैं, और हम समस्या का सामना कर रहे हैं।

मुख्य कारण हमारे द्वारा बनाए गए UIPANGestureRecognizer से संबंधित है। यह एक स्वाइप जेस्चर को भी पकड़ता है, और बिल्ट-इन जेस्चर पहचानकर्ता UICollectionView के साथ टकराव करता है ।

हालाँकि उपयोगकर्ता अभी भी ऊपर / नीचे कक्षों के माध्यम से स्क्रॉल कर सकते हैं या शहरों के माध्यम से स्क्रॉल करने के लिए कक्षों के बीच की जगह, मैं अभी भी इस तरह के एक बुरे उपयोगकर्ता इंटरफ़ेस की तरह नहीं हूं। चलो इसे ठीक करते हैं।

संघर्षों को हल करने के लिए, हमें एक प्रतिनिधि पद्धति को कार्यान्वित करने की आवश्यकता है, जिसे गेस्टरोगनाइज़रशोल्डबिन (_ :) कहा जाता है। यह विधि नियंत्रित करती है कि क्या इशारा पहचानकर्ता को स्पर्श की व्याख्या करना जारी रखना चाहिए। यदि आप विधि में गलत लौटते हैं, तो हावभाव पहचानकर्ता स्पर्श को अनदेखा कर देगा। तो हम जो करने जा रहे हैं, वह हमारे स्वयं के पैनोरमा मान्यता उपकरण को क्षैतिज आंदोलनों को अनदेखा करने की क्षमता देता है।

ऐसा करने के लिए, हमारे पैन पहचानकर्ता के प्रतिनिधि को सेट करते हैं। पैनआरकोगनाइज़र इनिशियलाइज़ेशन में कोड की निम्नलिखित पंक्ति डालें (आप रिटर्न रिकॉइडर के ठीक पहले कोड डाल सकते हैं :

 recognizer.delegate = self 

फिर, हम जेसेरोगेनाइजरशोल्डबिन (_ :) विधि को निम्नानुसार कार्यान्वित करते हैं:

 override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool { return abs((panRecognizer.velocity(in: panRecognizer.view)).y) > abs((panRecognizer.velocity(in: panRecognizer.view)).x) } 

यदि इसकी ऊर्ध्वाधर गति क्षैतिज गति से अधिक है, तो हम खुलेंगे / बंद करेंगे।

वाह! चलो फिर से आवेदन का परीक्षण करें। अब आप कक्षों में बाएँ / दाएँ स्वाइप करके शहरों की सूची में जा सकते हैं।

बोनस: कस्टम सिंक विशेषताएं

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

आमतौर पर, आपको UIView.animation को CabasicAnimation में बदलना चाहिए या इसे CATransaction में लपेटना चाहिए। UIViewPropertyAnimator के साथ, आप आसानी से कस्टम टाइमिंग कार्यों को लागू कर सकते हैं।

टाइमिंग फ़ंक्शंस (या फ़ंक्शंस को कम करना) को एनीमेशन स्पीड फ़ंक्शंस के रूप में समझा जाता है जो एक या किसी अन्य एनिमेटेड संपत्ति के परिवर्तन की दर को प्रभावित करते हैं। वर्तमान में चार प्रकार समर्थित हैं: easInOut, easIn, easOut, रैखिक।

इस समय के कार्यों के साथ एनिमेटर इनिशियलाइज़ेशन को बदलें (अपने स्वयं के बेजियर क्यूबिक वक्र को खींचने की कोशिश करें) निम्नानुसार हैं:

 private lazy var animator: UIViewPropertyAnimator = { let cubicTiming = UICubicTimingParameters(controlPoint1: CGPoint(x: 0.17, y: 0.67), controlPoint2: CGPoint(x: 0.76, y: 1.0)) return UIViewPropertyAnimator(duration: 0.3, timingParameters: cubicTiming) }() 

वैकल्पिक रूप से, घन तुल्यकालन मापदंडों का उपयोग करने के बजाय, आप वसंत तुल्यकालन का उपयोग भी कर सकते हैं, उदाहरण के लिए:

  let springTiming = UISpringTimingParameters(mass: 1.0, stiffness: 2.0, damping: 0.2, initialVelocity: .zero) 

प्रोजेक्ट को फिर से शुरू करने की कोशिश करें और देखें कि क्या होता है।

निष्कर्ष

UIViewPropertyAnimator के माध्यम से, आप इंटरैक्टिव एनिमेशन के माध्यम से स्थिर स्क्रीन और उपयोगकर्ता इंटरैक्शन को बढ़ा सकते हैं।

मुझे पता है कि आप यह महसूस करने के लिए इंतजार नहीं कर सकते कि आपने अपने प्रोजेक्ट में क्या सीखा है। यदि आप अपनी परियोजना में इस दृष्टिकोण को लागू करते हैं, तो यह बहुत अच्छा होगा, मुझे इसके बारे में नीचे टिप्पणी छोड़ कर बताएं।

एक संदर्भ के रूप में, यहां आप अंतिम ड्राफ्ट डाउनलोड कर सकते हैं।

आगे के लिंक

UIKit का उपयोग करने वाले पेशेवर एनिमेशन - https://developer.apple.com/videos/play/wwdc2017/230/

Apple डेवलपर्स के लिए UIViewPropertyAnimator दस्तावेज़ीकरण - https://developer.apple.com/documentation/uikit/uiviewpropertyanimator