Flutter में ऐनिमेशन

1. परिचय

ऐनिमेशन, आपके ऐप्लिकेशन के उपयोगकर्ता अनुभव को बेहतर बनाने, उपयोगकर्ता को ज़रूरी जानकारी देने, और आपके ऐप्लिकेशन को ज़्यादा बेहतर और इस्तेमाल करने में मज़ेदार बनाने का एक शानदार तरीका है.

आपको क्या बनाना होगा

इस कोडलैब में, आपको Google Antigravity के साथ मिलकर, जवाबों के कई विकल्पों वाला क्विज़ गेम बनाने का मौका मिलेगा. इसमें Flutter के अलग-अलग तरह के ऐनिमेशन इफ़ेक्ट और तकनीकें शामिल होंगी.

Flutter Quiz ऐप्लिकेशन की ऐनिमेटेड रिकॉर्डिंग. इसमें ऐनिमेटेड स्कोरबोर्ड स्टार, स्लाइड होने वाले सवाल कार्ड, 3D फ़्लिपिंग जवाब कार्ड, और कंटेनर ट्रांज़िशन दिखाए गए हैं.

Antigravity का इस्तेमाल करके, एजेंट को बार-बार प्रॉम्प्ट देकर ये काम किए जा सकते हैं:

  • एक ऐसा स्कोरबोर्ड विजेट बनाएं जो इंप्लिसिट ऐनिमेशन, ट्वीन, और ईज़िंग कर्व का इस्तेमाल करके, अपने साइज़ और रंग को ऐनिमेट करता हो.
  • AnimatedSwitcher में साफ़ तौर पर दिखने वाले SlideTransition और FadeTransition इफ़ेक्ट के साथ, सवालों के ट्रांज़िशन को ऐनिमेट करें.
  • AnimationController से ट्रिगर होने वाला और TweenSequence से स्टैगर होने वाला, कस्टम 3D कार्ड फ़्लिप इफ़ेक्ट बनाएं.
  • animations पैकेज से, पहले से बने Material मोशन ट्रांज़िशन (FadeThroughTransition और OpenContainer) का इस्तेमाल करें. साथ ही, Android के पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा जोड़ें.

Flutter के ऐनिमेशन फ़्रेमवर्क की खास जानकारी

Flutter, हर फ़्रेम पर विजेट ट्री के एक हिस्से को फिर से बनाकर, ऐनिमेशन इफ़ेक्ट दिखाता है. इसमें पहले से मौजूद ऐनिमेशन इफ़ेक्ट और कंपोज़ेबल एपीआई मिलते हैं. इनकी मदद से, ऐनिमेशन बनाना और उन्हें मैनेज करना आसान हो जाता है:

  • इंप्लिसिट ऐनिमेशन, पहले से बने ऐनिमेशन इफ़ेक्ट होते हैं. ये पूरे ऐनिमेशन को अपने-आप चलाते हैं. जब ऐनिमेशन की टारगेट वैल्यू बदलती है, तो विजेट मौजूदा वैल्यू से टारगेट वैल्यू तक आसानी से ऐनिमेट होता है. साथ ही, बीच की हर वैल्यू को दिखाता है. उदाहरण के लिए, AnimatedSize, AnimatedScale, और AnimatedPositioned.
  • एक्सप्लिसिट ऐनिमेशन, पहले से बने ऐनिमेशन इफ़ेक्ट होते हैं. ये अपनी प्रोग्रेस को आगे बढ़ाने के लिए, Animation ऑब्जेक्ट का इस्तेमाल करते हैं. उदाहरण के लिए, SizeTransition, ScaleTransition, SlideTransition, और FadeTransition.
  • Animation एक क्लास है, जो चल रहे या रोके गए ऐनिमेशन को दिखाती है. यह मौजूदा वैल्यू और स्टेटस दिखाता है, Listenable को एक्सटेंड करता है, और एनिमेशन के आगे बढ़ने पर अपने लिसनर को सूचना देता है.
  • AnimationController, Animation बनाता है और इसकी लाइफ़साइकल को कंट्रोल करता है. forward(), reset(), stop(), और repeat() जैसे तरीके, रेंडर किए जा रहे विज़ुअल इफ़ेक्ट से अलग, प्लेबैक को कंट्रोल करते हैं.
  • ट्वीन, begin और end वैल्यू के बीच की वैल्यू को इंटरपोलेट करते हैं. साथ ही, ये किसी भी टाइप को दिखा सकते हैं, जैसे कि double, Offset या Color.
  • Curves, समय के साथ किसी पैरामीटर में होने वाले बदलाव की दर को अडजस्ट करते हैं. ईज़िंग कर्व लागू करने से, ऐनिमेशन की रफ़्तार नैचुरल तरीके से बढ़ती या घटती है. कर्व, 0.0 और 1.0 के बीच की इनपुट वैल्यू को आउटपुट वैल्यू पर मैप करते हैं.

सीखने का आपका सफ़र

इस कोडलैब में, क्विज़ ऐप्लिकेशन बनाने और उसे ऐनिमेट करने का तरीका सिलसिलेवार तरीके से बताया गया है:

  1. अपना Flutter एनवायरमेंट सेट अप करना - अपने टारगेट प्लैटफ़ॉर्म के लिए, Flutter SDK और Google Antigravity को कॉन्फ़िगर करें.
  2. कोई प्रोजेक्ट बनाएं - Antigravity को मॉडल-व्यू-व्यूमॉडल (एमवीवीएम) पैटर्न के साथ स्ट्रक्चर किए गए, जवाबों के कई विकल्पों वाले क्विज़ ऐप्लिकेशन को स्कैफ़ोल्ड करने के लिए कहें.
  3. इंप्लिसिट ऐनिमेशन इफ़ेक्ट का इस्तेमाल करना - स्टार-आधारित Scoreboard जोड़ें, जो AnimatedScale, TweenAnimationBuilder, और Curves.elasticOut के साथ स्केल और रंग को ऐनिमेट करता है.
  4. साफ़ तौर पर दिखने वाले ऐनिमेशन इफ़ेक्ट इस्तेमाल करना - AnimatedSwitcher, SlideTransition, FadeTransition, और पसंद के मुताबिक बनाए गए layoutBuilder का इस्तेमाल करके, सवालों के आने और जाने के लिए ऐनिमेशन बनाएं.
  5. ऐनिमेशन की स्थिति को कंट्रोल करना - AnimationController, AnimatedBuilder, Transform, और स्टैगर्ड TweenSequence का इस्तेमाल करके, पसंद के मुताबिक 3D CardFlipEffect बनाएं.
  6. कस्टम नेविगेशन ट्रांज़िशन का इस्तेमाल करना - PredictiveBackPageTransitionsBuilder की मदद से PageTransitionsTheme जोड़ें, PageTransitionSwitcher और FadeThroughTransition की मदद से सवाल बदलें, और OpenContainer की मदद से गेम ओवर स्क्रीन को बड़ा करें.

आपको क्या सीखने को मिलेगा

  • Google Antigravity के साथ मिलकर, Flutter ऐप्लिकेशन को बार-बार बनाने और उसे शानदार ऐनिमेशन के साथ पसंद के मुताबिक बनाने का तरीका.
  • कम से कम कोड का इस्तेमाल करके, बेहतर ऐनिमेशन बनाने के लिए, इंप्लिसिट ऐनिमेशन वाले विजेट (AnimatedScale और TweenAnimationBuilder) इस्तेमाल करने का तरीका.
  • Animation ऑब्जेक्ट से चलने वाले साफ़ तौर पर ऐनिमेट किए गए विजेट (SlideTransition और FadeTransition) को कंपोज़ करने का तरीका.
  • स्टैगर्ड 3D विजेट ट्रांज़िशन बनाने के लिए, AnimationController और TweenSequence का इस्तेमाल करने का तरीका.
  • Material Motion और Android पर पीछे जाने पर झलक दिखाने वाले ट्रांज़िशन डिलीवर करने के लिए, animations पैकेज और PredictiveBackPageTransitionsBuilder का इस्तेमाल करने का तरीका.

ज़रूरी शर्तें

  • Flutter विजेट और Dart सिंटैक्स के बारे में बुनियादी जानकारी.

2. अपना Flutter एनवायरमेंट सेट अप करना

संपादक

इस कोडलैब में, Google Antigravity का इस्तेमाल एआई-फ़र्स्ट डेवलपमेंट एनवायरमेंट के तौर पर किया जाता है. हर चरण में, Antigravity को अपने ऐप्लिकेशन के कॉम्पोनेंट जनरेट करने या उन्हें बेहतर बनाने के लिए प्रॉम्प्ट दें. साथ ही, जनरेट किए गए कोड में Flutter ऐनिमेशन के मुख्य कॉन्सेप्ट की समीक्षा करें. इसके अलावा, क्रिएटिव वैरिएशन भी एक्सप्लोर करें.

डेवलपमेंट टारगेट चुनना

इस कोडलैब को इनमें से किसी भी टारगेट प्लैटफ़ॉर्म पर चलाया जा सकता है:

  • कोई Android फ़िज़िकल डिवाइस या एम्युलेटर (नेविगेशन ट्रांज़िशन वाले चरण में, पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की जांच करने के लिए इसका सुझाव दिया जाता है).
  • कोई iOS फ़िज़िकल डिवाइस या iOS सिम्युलेटर (इसके लिए, macOS पर Xcode की ज़रूरत होती है).
  • Chrome जैसा कोई वेब ब्राउज़र.
  • Windows, macOS या Linux डेस्कटॉप टारगेट.

Flutter इंस्टॉल करना

Flutter SDK टूल को इंस्टॉल करने के बारे में अप-टू-डेट निर्देश, हमेशा docs.flutter.dev पर उपलब्ध होते हैं.

Flutter की वेबसाइट पर दिए गए निर्देशों में, एसडीके टूल, प्लैटफ़ॉर्म के हिसाब से टूल, और एडिटर प्लगिन इंस्टॉल करने के बारे में बताया गया है. इस कोडलैब के लिए, यह सॉफ़्टवेयर इंस्टॉल करें:

  1. Flutter SDK
  2. Google Antigravity में Dart और Flutter का आधिकारिक प्लगइन चालू होना चाहिए. यह प्लगइन, प्लगइन Marketplace में Build with Google सेक्शन में उपलब्ध है.
  3. आपके चुने गए डेवलपमेंट टारगेट के लिए कंपाइलर सॉफ़्टवेयर. उदाहरण के लिए, Android को टारगेट करने के लिए Android Studio, Windows को टारगेट करने के लिए Visual Studio या macOS या iOS को टारगेट करने के लिए Xcode.

अगले चरण में, Antigravity को अपना Flutter प्रोजेक्ट बनाने और क्विज़ स्टार्टर ऐप्लिकेशन को स्कैफ़ोल्ड करने के लिए प्रॉम्प्ट दें.

3. प्रोजेक्ट बनाना

प्रोजेक्ट बनाने के लिए, Antigravity को प्रॉम्प्ट दें

  1. Google Antigravity लॉन्च करें और वह खाली डायरेक्ट्री खोलें जहां आपको अपना प्रोजेक्ट बनाना है. ऐसा पाथ चुनें जिसके लिए खास सुविधाओं के ऐक्सेस की ज़रूरत न हो या जिसमें स्पेस न हों. जैसे, आपकी होम डायरेक्ट्री या C:\src\ में मौजूद कोई फ़ोल्डर.
  2. Antigravity एजेंट के चैट पैनल में, Flutter प्रोजेक्ट बनाने, animations और material_ui डिपेंडेंसी जोड़ने, और एमवीवीएम क्विज़ ऐप्लिकेशन को स्कैफ़ोल्ड करने के लिए, यह प्रॉम्प्ट भेजें:
Create a new empty Flutter project named `quiz` for a multiple-choice Flutter animations quiz game and add the `animations` and `material_ui` packages. Using `package:material_ui/material_ui.dart`, create `lib/model.dart` with `Question` (`question`, `possibleAnswers`, `correctAnswer`) and `QuestionBank` (`hasNextQuestion`, `remainingQuestions`, `getRandomQuestion()`) populated with three multiple-choice questions about Flutter animations. Create `lib/view_model.dart` with `QuizViewModel extends ChangeNotifier` (`onGameOver` callback, `totalQuestions`, `currentQuestion`, `answeredQuestionCount`, `score`, `didAnswerQuestion`, `hasNextQuestion`, `getNextQuestion()`, and `checkAnswer(int)`). Create `lib/home_screen.dart` (`HomeScreen` with a "New Game" button that pushes `QuestionScreen`), `lib/question_screen.dart` (`QuestionScreen` listening to `QuizViewModel` using `ListenableBuilder`, showing a game-over `AlertDialog` that pops to the first route, plus `QuestionCard`, a 2-column `AnswerCards` grid using `Card.filled` with `ValueKey(answers[index])` that highlights the `correctAnswer` in `tertiaryContainer`, and `StatusBar`), and wire `HomeScreen` up in `lib/main.dart` inside `MainApp` with a blue Material 3 `ColorScheme.fromSeed`.

जनरेट किए गए कोड को समझना

Antigravity, जवाबों के कई विकल्पों वाले क्विज़ गेम को स्कैफ़ोल्ड करता है. इसमें दो स्क्रीन होती हैं, जिन्हें मॉडल-व्यू-व्यूमॉडल (एमवीवीएम) पैटर्न के साथ स्ट्रक्चर किया जाता है:

  • lib/main.dart - यह Material 3 थीमिंग (package:material_ui/material_ui.dart) के साथ MaterialApp को कॉन्फ़िगर करता है और HomeScreen को लॉन्च करता है.
  • lib/home_screen.dart - यह टाइटल स्क्रीन को नया गेम बटन के साथ दिखाता है. इस बटन पर क्लिक करने से, QuestionScreen पर पहुंचा जा सकता है.
  • lib/model.dart - यह Question डेटा क्लास और QuestionBank को तय करता है. यह बैंक के खाली होने तक, रैंडम सवाल चुनता है.
  • lib/view_model.dart - QuizViewModel को तय करता है. यह एक ChangeNotifier है, जो मौजूदा सवाल, खिलाड़ी के स्कोर, और गेम-ओवर की स्थिति को ट्रैक करता है.
  • lib/question_screen.dart - QuestionScreen (व्यू) को रेंडर करता है. यह QuizViewModel को सुनता है और QuestionCard, AnswerCards, और StatusBar को कंपोज़ करता है.

QuizViewModel और ListenableBuilder के साथ प्रतिक्रिया देने की स्थिति

lib/view_model.dart में, QuizViewModel ChangeNotifier को एक्सटेंड करता है और जब भी उपयोगकर्ता कोई जवाब चुनता है या अगले सवाल पर जाता है, तब notifyListeners() को कॉल करता है:

class QuizViewModel extends ChangeNotifier {
  final QuestionBank _questionBank = QuestionBank();
  final VoidCallback onGameOver;
  late final int totalQuestions;
  Question? currentQuestion;
  int answeredQuestionCount = 0;
  int score = 0;
  bool didAnswerQuestion = false;
  bool get hasNextQuestion => answeredQuestionCount < totalQuestions;
  // ...

lib/question_screen.dart में, QuestionScreen अपने Scaffold को ListenableBuilder में रैप करता है, ताकि जब भी viewModel अपने लिसनर को सूचना दे, तो यूज़र इंटरफ़ेस अपने-आप फिर से बन जाए:

@override
Widget build(BuildContext context) {
  return ListenableBuilder(
    listenable: viewModel,
    builder: (context, child) {
      return Scaffold(
        // ...

ऐप्लिकेशन को चलाना और टेस्ट करना

अपने चुने गए टारगेट डिवाइस पर ऐप्लिकेशन चलाएं, ताकि यह पुष्टि की जा सके कि स्टार्टर प्रोजेक्ट उम्मीद के मुताबिक काम कर रहा है.

स्टार्टर Flutter क्विज़ ऐप्लिकेशन, जिसमें होम स्क्रीन और सवाल वाली स्क्रीन को साथ-साथ दिखाया गया है

नया गेम पर टैप करें और कुछ सवालों के जवाब दें. फ़िलहाल, ऐप्लिकेशन बिना किसी ऐनिमेशन इफ़ेक्ट के, स्कोर टेक्स्ट, सवाल कार्ड, और जवाब कार्ड को तुरंत अपडेट करता है. हालांकि, इसमें Navigator का डिफ़ॉल्ट रूट ट्रांज़िशन शामिल है. अगले चरण में, स्कोरबोर्ड में इंप्लिसिट ऐनिमेशन जोड़े जाएंगे.

4. इंप्लिसिट ऐनिमेशन इफ़ेक्ट इस्तेमाल करना

इंप्लिसिट ऐनिमेशन, Flutter ऐप्लिकेशन में मोशन जोड़ने का सबसे तेज़ तरीका है. इसकी वजह यह है कि ये अपने इंटरनल ऐनिमेशन की स्थिति को अपने-आप मैनेज करते हैं. जब भी किसी टारगेट प्रॉपर्टी (जैसे, scale, opacity या padding) में बदलाव होता है, तो ImplicitlyAnimatedWidget तय किए गए duration में पुरानी वैल्यू से नई वैल्यू में आसानी से बदल जाता है.

इस चरण में, सादे टेक्स्ट वाले स्टेटस बार को स्टार-आधारित Scoreboard से बदल दिया जाएगा. यह , खिलाड़ी के पॉइंट स्कोर करने पर, हर स्टार के स्केल और रंग, दोनों को ऐनिमेट करता है.

ऐनिमेट किया गया GIF, जिसमें स्कोरबोर्ड के स्टार उछलते हुए और स्लेटी से पीले रंग में बदलते हुए दिख रहे हैं

Antigravity को ऐनिमेटेड स्टार स्कोरबोर्ड जोड़ने के लिए कहें

lib/scoreboard.dart बनाने और उसे StatusBar में इंटिग्रेट करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:

Create `lib/scoreboard.dart` (importing `package:material_ui/material_ui.dart`) with a `Scoreboard` widget (`score` and `totalQuestions`) that renders a row of `AnimatedStar` widgets (`isActive: score > i`), and replace the text children in `StatusBar` (`lib/question_screen.dart`) with `Scoreboard`. In `AnimatedStar`, animate each 50px `Icons.star` over 1000ms using `Curves.elasticOut`: wrap the icon in an `AnimatedScale` (scaling from `0.5` when inactive to `1.0` when active) and a `TweenAnimationBuilder<Color?>` using a `ColorTween` from `Colors.grey.shade400` to `Colors.yellow.shade700` when active.

जनरेट किए गए कोड को समझना

AnimatedScale के साथ इंप्लिसिट स्केलिंग

lib/scoreboard.dart में, Scoreboard क्विज़ के हर सवाल के लिए एक AnimatedStar दिखाता है. साथ ही, isActive: score > i को पास करता है. AnimatedStar में, AnimatedScale अपने चाइल्ड को 0.5 से 1.0 तक स्केल करता है. ऐसा तब होता है, जब isActive, true हो जाता है:

return AnimatedScale(
  scale: isActive ? 1.0 : 0.5,
  curve: _curve,
  duration: _duration,
  // ...

अगर आपने स्टैटिक Icon रंग के साथ सिर्फ़ AnimatedScale का इस्तेमाल किया है, तो स्टार का साइज़ आसानी से ऐनिमेट होगा. हालांकि, उसका रंग तुरंत धूसर से पीला हो जाएगा:

ऐनिमेट किया गया GIF, जिसमें स्टार का साइज़ आसानी से बदल रहा है और उसका रंग तुरंत बदल रहा है

TweenAnimationBuilder और ColorTween के साथ रंगों को इंटरपोलेट करना

स्टार के साइज़ के साथ-साथ उसके रंग को ऐनिमेट करने के लिए, AnimatedContainer (जो कंटेनर की सजावट को ऐनिमेट करता है) या AnimatedIcon (जो AnimatedIcons में पहले से तय आइकॉन पेयर के बीच मॉर्फ़ करता है) का इस्तेमाल किया जा सकता है. हालांकि, इनमें से कोई भी स्टैंडर्ड Icons.star विजेट के रंग को ऐनिमेट नहीं करता.

इसके बजाय, जनरेट किया गया कोड TweenAnimationBuilder का इस्तेमाल करता है. यह एक ऐसा ImplicitlyAnimatedWidget है जो Tween का इस्तेमाल करके, किसी भी प्रॉपर्टी को ऐनिमेट करता है. Tween, begin और end वैल्यू लेता है. साथ ही, ऐनिमेशन की टाइमलाइन में इंटरमीडिएट वैल्यू का हिसाब लगाता है. यहां, ColorTween इनऐक्टिव ग्रे और ऐक्टिव पीले रंगों के बीच इंटरपोलेट करता है:

child: TweenAnimationBuilder(
  curve: _curve,
  duration: _duration,
  tween: ColorTween(
    begin: _deactivatedColor,
    end: isActive ? _activatedColor : _deactivatedColor,
  ),
  builder: (context, value, child) {
    return Icon(Icons.star, size: 50, color: value);
  },
),

जब भी isActive के आधार पर Tween.end में बदलाव होता है, तो TweenAnimationBuilder अपनी मौजूदा वैल्यू से नई end वैल्यू में अपने-आप ऐनिमेट हो जाता है. भले ही, ऐनिमेशन के दौरान isActive में बदलाव हो:

ऐनिमेट किया गया GIF, जिसमें स्टार के स्केल और रंग को आसानी से ऐनिमेट होते हुए दिखाया गया है

Curves.elasticOut की मदद से ईज़िंग कर्व लागू करना

एक जैसी लीनियर रेट पर चलने वाले ऐनिमेशन, मैकेनिकल लग सकते हैं. Curve, ईज़िंग फ़ंक्शन लागू करता है. यह फ़ंक्शन, समय के साथ बदलाव की दर को बदलता है. साथ ही, 0.0 और 1.0 (X-ऐक्सिस पर) के बीच की इनपुट प्रोग्रेस वैल्यू को आउटपुट वैल्यू (Y-ऐक्सिस पर) से मैप करता है. Flutter में, Curves क्लास में पहले से बने कर्व का एक बड़ा कैटलॉग शामिल है. जैसे, Curves.easeIn और Curves.easeOut:

Curves.easeIn ईज़िंग फ़ंक्शन का ग्राफ़, जिसमें शुरुआत में धीमी प्रोग्रेस दिख रही है. यह प्रोग्रेस 1.0 की ओर बढ़ते हुए तेज़ हो जाती है.Curves.easeOut ईज़िंग फ़ंक्शन का ग्राफ़, जिसमें शुरुआत में तेज़ी से आगे बढ़ने और फिर 1.0 की ओर धीमे होने की प्रोसेस दिखाई गई है.

AnimatedScale और TweenAnimationBuilder, दोनों को Curves.elasticOut पास करने पर, एक एनर्जेटिक स्प्रिंग इफ़ेक्ट बनता है. यह इफ़ेक्ट, आखिर में ओवरशूट और सेटल हो जाता है:

Curves.elasticOut ईज़िंग फ़ंक्शन का ग्राफ़. इसमें ऑसिलेटिंग स्प्रिंग कर्व को 1.0 पर सेट होते हुए दिखाया गया है.

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें और किसी सवाल का सही जवाब दें. इसके बाद, StatusBar में स्टार को उछलते और सुनहरे रंग में चमकते हुए देखें.

धीमे ऐनिमेशन की जांच करने के लिए DevTools का इस्तेमाल करना

तेज़ ऐनिमेशन को फ़्रेम दर फ़्रेम जांचने के लिए, Flutter DevTools में धीमे ऐनिमेशन वाला टॉगल दिया गया है. इससे आपके ऐप्लिकेशन में सभी ऐनिमेशन की रफ़्तार पांच गुना कम हो जाती है. डीबग मोड में, DevTools में Flutter Inspector खोलें. इसके बाद, टूलबार में मौजूद Slow animations बटन पर क्लिक करें:

Flutter DevTools विजेट इंस्पेक्टर टूलबार में, स्लो ऐनिमेशन बटन को हाइलाइट किया गया है

5. एक्सप्लिसिट ऐनिमेशन इफ़ेक्ट इस्तेमाल करना

इंप्लिसिट ऐनिमेशन की तरह, एक्सप्लिसिट ऐनिमेशन भी पहले से बने ऐनिमेशन विजेट होते हैं. हालांकि, ये टारगेट वैल्यू के बजाय, पैरामीटर के तौर पर Animation ऑब्जेक्ट लेते हैं. इस वजह से, ये तब सबसे सही होते हैं, जब पैरंट विजेट से Animation दिया जाता है. जैसे, AnimatedSwitcher, रूट ट्रांज़िशन या आपका AnimationController. साथ ही, जब आपको एक साथ कई ट्रांज़िशन कंपोज़ करने हों.

इस चरण में, QuestionCard को ऐनिमेट किया जाएगा, ताकि नए सवाल लेआउट में जंप किए बिना, आसानी से स्लाइड और फ़ेड इन हो सकें.

सवालों के ट्रांज़िशन को ऐनिमेट करने के लिए, Antigravity को प्रॉम्प्ट देना

lib/question_screen.dart में QuestionCard को अपडेट करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:

Update `QuestionCard` in `lib/question_screen.dart` to wrap its `Card` (keyed by `ValueKey(question)`) in an `AnimatedSwitcher` with a 300ms duration. Configure `transitionBuilder` to apply `Curves.easeInCubic` using `CurveTween` and compose a `FadeTransition` with a `SlideTransition` that slides from `Offset(-0.1, 0.0)` to `Offset.zero`. Override `layoutBuilder` to return a `Stack` aligned to `Alignment.topCenter` so the card doesn't jump vertically when switching questions.

जनरेट किए गए कोड को समझना

AnimatedSwitcher में SlideTransition और FadeTransition को कंपोज़ करना

जब भी AnimatedSwitcher के child को किसी अलग Key वाले विजेट में बदला जाता है, तो यह अपने-आप ट्रांज़िशन करता है.

डिफ़ॉल्ट रूप से, AnimatedSwitcher पुराने और नए चाइल्ड विजेट के बीच क्रॉस-फ़ेड करता है. हालांकि, इसका transitionBuilder कॉलबैक आपको इनकमिंग और आउटगोइंग child विजेट और एक Animation देता है, ताकि आप कस्टम ऐनिमेशन बना सकें.

lib/question_screen.dart में, जनरेट किया गया transitionBuilder, FadeTransition में रैप किए गए SlideTransition का इस्तेमाल करता है. इसके लिए, Animation की ज़रूरत होती है:

transitionBuilder: (child, animation) {
  final curveAnimation = CurveTween(
    curve: Curves.easeInCubic,
  ).animate(animation);
  final offsetAnimation = Tween<Offset>(
    begin: const Offset(-0.1, 0.0),
    end: Offset.zero,
  ).animate(curveAnimation);
  final fadeInAnimation = curveAnimation;
  return FadeTransition(
    opacity: fadeInAnimation,
    child: SlideTransition(position: offsetAnimation, child: child),
  );
},

हर Tween, animate() मेथड उपलब्ध कराता है. यह मेथड, इनपुट Animation को नए Animation में बदल देता है. इसके लिए, वह Tween का इस्तेमाल करता है. Animation.drive() का इस्तेमाल करके, ट्वीन को कम शब्दों में भी चेन किया जा सकता है:

final offsetAnimation = animation
    .drive(CurveTween(curve: Curves.easeInCubic))
    .drive(Tween<Offset>(begin: const Offset(-0.1, 0.0), end: Offset.zero));

layoutBuilder की मदद से, लेआउट जंप को रोकना

कस्टम layoutBuilder के बिना, AnimatedSwitcher ट्रांज़िशन के दौरान अपने चाइल्ड एलिमेंट को Stack में सेंटर करता है. इसके बाद, ऐनिमेशन खत्म होने पर कार्ड को उपलब्ध स्पेस में सबसे ऊपर वापस स्नैप करता है:

ऐनिमेट किया गया GIF, जिसमें ट्रांज़िशन खत्म होने पर QuestionCard, स्टैक के बीच से सबसे ऊपर जंप करता हुआ दिख रहा है

layoutBuilder को बदलकर Alignment.topCenter का इस्तेमाल करने से, ट्रांज़िशन के दौरान इनकमिंग और आउटगोइंग कार्ड सबसे ऊपर अलाइन रहते हैं. AnimatedSwitcher.defaultLayoutBuilder, Alignment.center का इस्तेमाल करता है:

layoutBuilder: (currentChild, previousChildren) {
  return Stack(
    alignment: Alignment.topCenter,
    children: <Widget>[
      ...previousChildren,
      ?currentChild,
    ],
  );
},

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें, किसी सवाल का जवाब दें, और Next पर टैप करें. इससे यह पुष्टि की जा सकेगी कि नया QuestionCard, स्क्रीन पर सबसे ऊपर आसानी से स्लाइड और फ़ेड हो रहा है.

सीखे गए मुख्य कॉन्सेप्ट

  • एक्सप्लिसिट ऐनिमेशन विजेट, किसी एक टारगेट वैल्यू और अवधि के बजाय, Animation ऑब्जेक्ट लेते हैं.
  • Animation क्लास, समय के साथ ऐनिमेशन की प्रोग्रेस को दिखाती है. हालांकि, यह किसी खास विज़ुअल प्रॉपर्टी से नहीं जुड़ी होती.
  • Tween.animate() और Animation.drive(), CurveTween को ट्रांसफ़ॉर्म करके Animation पर लागू करते हैं.
  • AnimatedSwitcher.layoutBuilder, ट्रांज़िशन के दौरान इनकमिंग और आउटगोइंग चाइल्ड व्यू को अलाइन करने के तरीके को पसंद के मुताबिक बनाता है.

6. किसी ऐनिमेशन की स्थिति को कंट्रोल करना

अब तक, Flutter ने आपके लिए हर ऐनिमेशन के प्लेबैक को मैनेज किया है. जब आपको इस बात पर पूरा कंट्रोल चाहिए कि कोई ऐनिमेशन कब शुरू हो, कब रुके, कब रीसेट हो या कई चरणों को क्रम में कब लगाया जाए, तो AnimationController का इस्तेमाल करके अपना Animation बनाया जा सकता है.

इस चरण में, आपको एक कस्टम CardFlipEffect विजेट बनाना होगा. यह विजेट, सवाल बदलने पर जवाब वाले हर कार्ड को 3D में फ़्लिप करता है. इसके लिए, TweenSequence का इस्तेमाल करके चारों कार्ड को स्टैगर किया जाता है, ताकि वे एक के बाद एक फ़्लिप हों.

Antigravity को एक के बाद एक 3D कार्ड फ़्लिप इफ़ेक्ट बनाने के लिए कहें

lib/flip_effect.dart बनाने के लिए, Antigravity में यह प्रॉम्प्ट भेजें और जवाब वाले कार्ड को lib/question_screen.dart में रैप करें:

Create `lib/flip_effect.dart` with a stateful `CardFlipEffect` widget (`child`, `duration`, and `delayAmount`) using `SingleTickerProviderStateMixin`. When `widget.child.key` changes in `didUpdateWidget`, store the previous child and run an `AnimationController` whose duration is `widget.duration * (widget.delayAmount + 1)` (resetting when it reaches `1`). Drive the controller through a `TweenSequence<double>` (`_animationWithDelay`) that holds at `0.0` with `ConstantTween` for weight `delayAmount` (when `delayAmount > 0`) and then interpolates from `0.0` to `1.0` with weight `1.0`, using `AnimatedBuilder` and `Transform` (`Matrix4.identity()..rotateX(_animationWithDelay.value * math.pi)`) to show `_previousChild` for the first half of the flip and `Transform.flip(flipY: true, child: child)` for the second half. In `AnswerCards` (`lib/question_screen.dart`), wrap each `Card.filled` in `CardFlipEffect` with a 300ms duration and `delayAmount: index.toDouble() / 2`.

जनरेट किए गए कोड को समझना

AnimationController की मदद से ऐनिमेशन लाइफ़साइकल को मैनेज करना

AnimationController की मदद से कस्टम ऐनिमेशन बनाने के लिए, ये चार चरण पूरे करने होते हैं:

  1. StatefulWidget (CardFlipEffect) बनाएं.
  2. SingleTickerProviderStateMixin को State क्लास में मिक्स करें, ताकि यह Ticker फ़्रेम उपलब्ध करा सके.
  3. initState() में AnimationController को vsync: this के साथ शुरू करें. साथ ही, widget.child.key में बदलाव होने पर, didUpdateWidget() में forward() को ट्रिगर करें.
  4. AnimatedBuilder का इस्तेमाल करके, हर टिक पर विजेट ट्री को फिर से बनाएं.

AnimatedBuilder और Transform के साथ 3D रोटेशन

2D रोटेशन के लिए, Flutter में AnimatedRotation (इंप्लिसिट) और RotationTransition (एक्सप्लिसिट) का इस्तेमाल किया जाता है. 3D X-ऐक्सिस कार्ड फ़्लिप के लिए, Matrix4 ट्रांसफ़ॉर्मेशन की ज़रूरत होती है. साथ ही, फ़्लिप (value < 0.5) के बीच में फ़्रंट और बैक विजेट को स्वैप करना पड़ता है. इसलिए, CardFlipEffect, AnimatedBuilder को Transform के साथ जोड़ता है:

@override
Widget build(BuildContext context) {
  return AnimatedBuilder(
    animation: _animationWithDelay,
    builder: (context, child) {
      return Transform(
        alignment: Alignment.center,
        transform: Matrix4.identity()
          ..rotateX(_animationWithDelay.value * math.pi),
        child: _animationController.isAnimating
            ? _animationWithDelay.value < 0.5
                  ? _previousChild
                  : Transform.flip(flipY: true, child: child)
            : child,
      );
    },
    child: widget.child,
  );
}

रोटेशन के पहले हाफ़ (_animationWithDelay.value < 0.5) के दौरान, विजेट _previousChild दिखाता है. जब कार्ड 90 डिग्री से ज़्यादा घूमता है, तो वह वर्टिकल तौर पर फ़्लिप किया गया नया child (Transform.flip(flipY: true)) दिखाता है. इससे टेक्स्ट $\pi$ रेडियन पर रोटेशन पूरा होने पर दाईं ओर दिखता है:

ऐनिमेट किया गया GIF, जिसमें अगले सवाल पर जाने पर, जवाब वाले कार्ड 3D में पलटते हुए दिख रहे हैं.

TweenSequence की मदद से, ऐनिमेशन को स्टैगर करना

ध्यान दें कि CardFlipEffect, कार्ड को अलग-अलग समय पर दिखाने के लिए, dart:async से Future.delayed का इस्तेमाल नहीं करता है. TweenSequence का इस्तेमाल करके, ऐनिमेशन की टाइमलाइन में देरी को बनाए रखने का मतलब है कि स्टैगर्ड इफ़ेक्ट, एक ही TickerProvider से कंट्रोल होता है. इसलिए, Flutter DevTools में धीमे ऐनिमेशन चालू करने से, देरी भी उसी अनुपात में कम हो जाती है.

lib/flip_effect.dart में, _animationWithDelay दो TweenSequenceItem को चेन करता है: delayAmount के वेटेज वाला ConstantTween(0.0) और उसके बाद 1.0 के वेटेज वाला Tween(begin: 0.0, end: 1.0):

_animationWithDelay = TweenSequence<double>([
  if (widget.delayAmount > 0)
    TweenSequenceItem(
      tween: ConstantTween<double>(0.0),
      weight: widget.delayAmount,
    ),
  TweenSequenceItem(tween: Tween(begin: 0.0, end: 1.0), weight: 1.0),
]).animate(_animationController);

AnswerCards (lib/question_screen.dart) में, delayAmount: index.toDouble() / 2 को पास करने पर, ग्रिड में मौजूद हर कार्ड को फ़्लिप करने से पहले, धीरे-धीरे ज़्यादा समय तक होल्ड किया जाता है:

return CardFlipEffect(
  delayAmount: index.toDouble() / 2,
  duration: const Duration(milliseconds: 300),
  child: Card.filled(
    key: ValueKey(answers[index]),
    // ...

ऐप्लिकेशन को चलाना और टेस्ट करना

हॉट रीस्टार्ट करें, किसी सवाल का जवाब दें, और आगे बढ़ें पर टैप करें. इससे आपको जवाब वाले चारों कार्ड एक-एक करके पलटते हुए दिखेंगे.

ऐनिमेट किए गए GIF में, जवाब वाले चार कार्ड एक-एक करके फ़्लिप होते हुए दिख रहे हैं. हर कार्ड के फ़्लिप होने के बीच थोड़ा समय लग रहा है

7. कस्टम नेविगेशन ट्रांज़िशन का इस्तेमाल करना

एक ही स्क्रीन पर विजेट को ऐनिमेट करने के अलावा, स्क्रीन और मुख्य यूज़र इंटरफ़ेस (यूआई) की स्थितियों के बीच ट्रांज़िशन को ऐनिमेट किया जा सकता है. इस चरण में, pub.dev (FadeThroughPageTransitionsBuilder, PageTransitionSwitcher, FadeThroughTransition, और OpenContainer) पर मौजूद आधिकारिक animations पैकेज से, पहले से बने Material मोशन विजेट का इस्तेमाल किया जाएगा. साथ ही, Android पर पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा चालू की जाएगी.

Antigravity को Material मोशन और पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर ट्रांज़िशन जोड़ने के लिए प्रॉम्प्ट करें

lib/main.dart और lib/question_screen.dart को अपडेट करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:

Using `package:animations/animations.dart`, update `ThemeData` in `lib/main.dart` with a `PageTransitionsTheme` that uses `PredictiveBackPageTransitionsBuilder()` on Android and `FadeThroughPageTransitionsBuilder()` on iOS, macOS, Windows, and Linux. In `lib/question_screen.dart`, create a `GameOverScreen` widget displaying `Scoreboard`, "You Win!", the final score, and an "OK" button that pops back to the first route. Update `QuestionCard` to use `PageTransitionSwitcher` (200ms duration) with `FadeThroughTransition` wrapping an `OpenContainer` (`key: ValueKey(question)`, `tappable: false`, `closedColor: Color(0xfff2f3fa)`, 12px rounded corners, elevation 4) whose `closedBuilder` registers `openContainer` using `onChangeOpenContainer` and renders the question text, and whose `openBuilder` returns `GameOverScreen(viewModel: viewModel)` when `_handleGameOver` invokes the stored callback.

जनरेट किए गए कोड को समझना

कस्टम रूट ट्रांज़िशन और Android पर पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर

अगर आपको किसी एक नेविगेशन कॉल को पसंद के मुताबिक बनाना है, तो Navigator.push() को PageRouteBuilder पास करें. साथ ही, transitionsBuilder (जैसे, FadeTransition या FadeThroughTransition) दें, जो प्राइमरी animation और secondaryAnimation, दोनों को हासिल करता है.

अपने पूरे ऐप्लिकेशन में एक जैसे रूट ट्रांज़िशन लागू करने और Android के पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन के ThemeData (lib/main.dart) में pageTransitionsTheme को कॉन्फ़िगर करें:

theme: ThemeData(
  colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
  pageTransitionsTheme: const PageTransitionsTheme(
    builders: {
      TargetPlatform.android: PredictiveBackPageTransitionsBuilder(),
      TargetPlatform.iOS: FadeThroughPageTransitionsBuilder(),
      TargetPlatform.macOS: FadeThroughPageTransitionsBuilder(),
      TargetPlatform.windows: FadeThroughPageTransitionsBuilder(),
      TargetPlatform.linux: FadeThroughPageTransitionsBuilder(),
    },
  ),
),

Android पर ऐनिमेट किया गया GIF, जिसमें उपयोगकर्ता को स्क्रीन के किनारे से पीछे की ओर खींचते हुए दिखाया गया है. इससे, QuestionScreen के पीछे मौजूद HomeScreen की झलक दिखती है.

पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की मदद से, Android उपयोगकर्ता स्क्रीन के किनारे से स्वाइप करके, पिछले रास्ते की झलक देख सकते हैं. इसके बाद, वे वापस जाने का फ़ैसला ले सकते हैं. PredictiveBackPageTransitionsBuilder, Android 14 (एपीआई 34) और इसके बाद के वर्शन पर, पीछे जाने पर झलक दिखाने वाले सिस्टम के जेस्चर को सुनता है. साथ ही, Android के पुराने वर्शन पर ZoomPageTransitionsBuilder पर वापस चला जाता है. प्लैटफ़ॉर्म के कॉन्फ़िगरेशन की जानकारी के लिए, Android पर पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की गाइड देखें.

PageTransitionSwitcher और FadeThroughTransition के साथ सवाल स्विच करना

स्टैंडर्ड AnimatedSwitcher, अपने transitionBuilder में सिर्फ़ एक Animation दिखाता है. FadeThroughTransition जैसे मटीरियल मोशन ट्रांज़िशन, इनकमिंग animation और आउटगोइंग secondaryAnimation, दोनों को कोऑर्डिनेट करते हैं. इसलिए, QuestionCard, animations पैकेज से PageTransitionSwitcher का इस्तेमाल करता है:

return PageTransitionSwitcher(
  duration: const Duration(milliseconds: 200),
  transitionBuilder: (child, animation, secondaryAnimation) {
    return FadeThroughTransition(
      animation: animation,
      secondaryAnimation: secondaryAnimation,
      child: child,
    );
  },
  // ...

OpenContainer के साथ कंटेनर ट्रांसफ़ॉर्म

OpenContainer, बंद कार्ड विजेट को फ़ुल-स्क्रीन ओपन विजेट में बड़ा करता है

OpenContainer विजेट, Material के कंटेनर ट्रांसफ़ॉर्म पैटर्न को लागू करता है. इससे छोटे विजेट (closedBuilder) को फ़ुल-स्क्रीन डेस्टिनेशन (openBuilder) में आसानी से बड़ा किया जा सकता है.

lib/question_screen.dart में, QuestionCard tappable: false के साथ OpenContainer रेंडर करता है. इसलिए, सवाल वाले कार्ड पर टैप करने से गेम खत्म नहीं होता. इसके बजाय, closedBuilder, openContainer कॉलबैक को _QuestionScreenState तक पास करता है. यह आखिरी सवाल का जवाब मिलने पर इसे शुरू करता है:

child: OpenContainer(
  key: ValueKey(question),
  tappable: false,
  closedColor: _backgroundColor,
  closedShape: const RoundedRectangleBorder(
    borderRadius: BorderRadius.all(Radius.circular(12.0)),
  ),
  closedElevation: 4,
  closedBuilder: (context, openContainer) {
    onChangeOpenContainer(openContainer);
    return ColoredBox(
      color: _backgroundColor,
      child: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Text(
          question ?? '',
          style: Theme.of(context).textTheme.displaySmall,
        ),
      ),
    );
  },
  openBuilder: (context, closeContainer) {
    return GameOverScreen(viewModel: viewModel);
  },
),

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीस्टार्ट करें, नया गेम शुरू करें, और तीनों सवालों के जवाब दें. आखिरी सवाल का जवाब देने पर, OpenContainer सवाल वाले कार्ड को फ़ुल-स्क्रीन GameOverScreen में आसानी से बड़ा कर देता है:

ऐनिमेट किया गया GIF, जिसमें OpenContainer का इस्तेमाल करके, QuestionCard को फ़ुल-स्क्रीन GameOverScreen में बड़ा होते हुए दिखाया गया है.

8. बधाई हो

बधाई हो! आपने Google Antigravity के साथ मिलकर, Flutter क्विज़ ऐप्लिकेशन में शानदार ऐनिमेशन इफ़ेक्ट जोड़े हैं. साथ ही, Flutter के ऐनिमेशन सिस्टम के मुख्य बिल्डिंग ब्लॉक के बारे में जाना है.

आपने क्या बनाया है

  • इंप्लिसिटली ऐनिमेटेड स्कोरबोर्ड: खिलाड़ी के स्कोर करने पर, स्टार आइकॉन को ऐनिमेट करने के लिए, ColorTween और Curves.elasticOut के साथ AnimatedScale और TweenAnimationBuilder का इस्तेमाल किया गया है.
  • सवाल के ट्रांज़िशन साफ़ तौर पर दिखते हैं: AnimatedSwitcher के अंदर FadeTransition और SlideTransition को कंपोज़ किया गया है. साथ ही, layoutBuilder को सबसे ऊपर अलाइन किया गया है.
  • स्टैगर्ड 3D कार्ड फ़्लिप: AnimationController, AnimatedBuilder, और TweenSequence डिले का इस्तेमाल करके, 3D Matrix4 रोटेशन को कंट्रोल किया गया.
  • मटेरियल मोशन और पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा: PageTransitionsTheme को PredictiveBackPageTransitionsBuilder और FadeThroughPageTransitionsBuilder के साथ कॉन्फ़िगर किया गया है. साथ ही, animations पैकेज से PageTransitionSwitcher और OpenContainer का इस्तेमाल किया गया है.

Flutter Quiz ऐप्लिकेशन की पूरी हो चुकी रिकॉर्डिंग का ऐनिमेशन, जिसमें सभी ऐनिमेशन इफ़ेक्ट चालू हैं.

आगे क्या करना है?

इनसे मिलते-जुलते कोडलैब देखें:

इस बारे में और पढ़ें

docs.flutter.dev पर ऐनिमेशन से जुड़ी ज़्यादा गाइड और रेसिपी देखें:

रेफ़रंस के लिए दस्तावेज़