1. परिचय
Flutter ऐप्लिकेशन में इन-ऐप्लिकेशन खरीदारी की सुविधा जोड़ने के लिए, Apple App Store और Google Play Store को कॉन्फ़िगर करना ज़रूरी है. साथ ही, किसी भरोसेमंद बैकएंड पर खरीदारी के टोकन की पुष्टि करना और इस्तेमाल की जा सकने वाली मुद्रा, वन-टाइम अपग्रेड या बार-बार ली जाने वाली सदस्यता के फ़ायदे जैसे एनटाइटेलमेंट देना ज़रूरी है.
इस कोडलैब में, Google Antigravity के साथ मिलकर Dash Clicker बनाया जाता है. यह एक मोबाइल क्लिकर गेम है, जिसमें Dash मैस्कॉट का इस्तेमाल मुद्रा के तौर पर किया जाता है. साथ ही, इसे Dart shelf बैकएंड सेवा और Cloud Firestore के साथ जोड़ा जाता है, ताकि इन-ऐप्लिकेशन खरीदारी के तीन टाइप की पुष्टि की जा सके और उन्हें ट्रैक किया जा सके:
- इस्तेमाल किया जा सकने वाला आइटम (
dash_consumable_2k): यह एक ऐसा आइटम है जिसे बार-बार खरीदा जा सकता है. इसे खरीदने पर, खिलाड़ी को तुरंत 2,000 डैश मिलते हैं. - नॉन-कन्ज़्यूमेबल (
dash_upgrade_3d): यह एक बार किया जाने वाला स्थायी अपग्रेड है. इससे क्लासिक डैश मैस्कॉट को हमेशा के लिए मॉडर्न 3D डैश में बदला जा सकता है. - सदस्यता (
dash_subscription_doubler): अपने-आप रिन्यू होने वाली सदस्यता, जो सदस्यता के चालू रहने के दौरान, पैसिव तरीके से जनरेट होने वाले क्लिक की संख्या को बढ़ाती है.
|
|
|
आपको क्या बनाना होगा
material_uiऔरcupertino_uiकी मदद से स्टाइल किया गया Flutter मोबाइल ऐप्लिकेशन (app/). यह ऐप्लिकेशन, स्टोर के प्रॉडक्ट के बारे में क्वेरी करता है, खरीदारी शुरू करता है, और रीयल-टाइम में खरीदारी की स्ट्रीम पर प्रतिक्रिया देता है.- Dart
shelfबैकएंड सर्वर (dart-backend/), जो Google Play और App Store से खरीदारी की रसीदों की पुष्टि करता है. साथ ही, स्टोर के बिलिंग इवेंट पोल करता है और Cloud Firestore में खरीदारी की स्थितियों को रिकॉर्ड करता है.
सीखने का आपका सफ़र
इस कोडलैब में, आपको इन-ऐप्लिकेशन खरीदारी के फ़ुल-स्टैक फ़्लो को बनाने और कनेक्ट करने का तरीका सिलसिलेवार तरीके से बताया गया है:
- डेवलपमेंट एनवायरमेंट सेट अप करना - Flutter और Google Antigravity इंस्टॉल करें. इसके बाद, Antigravity को Dash Clicker स्टार्टर प्रोजेक्ट (
app/) को स्कैफ़ोल्ड करने के लिए कहें. साथ ही, अपने iOS बंडल आइडेंटिफ़ायर और AndroidapplicationIdको कॉन्फ़िगर करें. - प्लगिन इंस्टॉल करना - Antigravity को
app/मेंin_app_purchaseऔरin_app_purchase_platform_interfaceजोड़ने के लिए कहें. - App Store सेट अप करना - अपना ऐप्लिकेशन आईडी रजिस्टर करें, सैंडबॉक्स टेस्ट खाता बनाएं, और App Store Connect में तीनों प्रॉडक्ट कॉन्फ़िगर करें.
- Play Store सेट अप करना - Google Play Console में अपना ऐप्लिकेशन बनाएं. Antigravity को Gradle में रिलीज़ कीस्टोर साइनिंग को कॉन्फ़िगर करने के लिए कहें. शुरुआती ऐप्लिकेशन बंडल अपलोड करें. लाइसेंस टेस्टर जोड़ें और प्रॉडक्ट कॉन्फ़िगर करें.
- Firebase सेट अप करें - Firebase कंसोल में, Google साइन-इन और Cloud Firestore को चालू करें. इसके बाद,
flutterfire configureको चलाएं और Android SHA-1 फ़िंगरप्रिंट और iOS यूआरएल स्कीम को कॉन्फ़िगर करें. - खरीदारी से जुड़े अपडेट सुनना - Antigravity को टेस्ट किए जा सकने वाले
IAPConnectionरैपर को जोड़ने,purchaseStreamकी सदस्यता लेने, औरTestIAPConnectionकी मदद से ऐप्लिकेशन को टेस्ट करने के लिए कहें. - खरीदारी करना - Antigravity को
ProductDetailsकोPurchasableProductमें रैप करने, स्टोर के प्रॉडक्ट के बारे में क्वेरी करने,buyConsumableऔरbuyNonConsumableको ट्रिगर करने, और अधूरी खरीदारी पूरी करने के लिए कहें. - बैकएंड सेट अप करें - Antigravity को
IapRepositoryके साथdart-backend/सर्वर को स्कैफ़ोल्ड करने के लिए कहें. साथ ही, सेवा खाते के क्रेडेंशियल कॉन्फ़िगर करें. - खरीदारियों की पुष्टि करें - Antigravity को
PurchasePageपर Firebase लॉगिन की ज़रूरत के बारे में बताएं,/verifypurchaseपर खरीदारी के टोकन पोस्ट करें, औरGooglePlayPurchaseHandlerऔरAppStorePurchaseHandlerलागू करें. - खरीदारियों को ट्रैक करना - Antigravity को बैकएंड पर Google Cloud Pub/Sub और App Store Server API को पोल करने के लिए कहें. साथ ही,
IAPRepoका इस्तेमाल करके, Flutter क्लाइंट के लिए एनटाइटलमेंट को सिंक करें.
आपको क्या सीखने को मिलेगा
- Google Antigravity के साथ मिलकर, Dart बैकएंड और Flutter इन-ऐप्लिकेशन खरीदारी वाले फ़ुल-स्टैक ऐप्लिकेशन को बार-बार बनाने और उसे पसंद के मुताबिक बनाने का तरीका.
- इस्तेमाल किए जा सकने वाले, इस्तेमाल न किए जा सकने वाले, और सदस्यता वाले प्रॉडक्ट के लिए, App Store Connect और Google Play Console को कॉन्फ़िगर करने का तरीका.
in_app_purchaseप्लग इन की मदद से, प्रॉडक्ट के बारे में क्वेरी करने, खरीदारी शुरू करने, और खरीदारी की स्ट्रीम मैनेज करने का तरीका.- Dart बैकएंड पर Google Play और App Store के खरीदारी टोकन की पुष्टि करने और उन्हें Cloud Firestore में सेव करने का तरीका.
- स्टोर बिलिंग इवेंट को प्रोसेस करने और सभी डिवाइसों पर सदस्यता और अपग्रेड एनटाइटलमेंट को सिंक करने का तरीका.
ज़रूरी शर्तें
- Flutter विजेट, Dart सिंटैक्स, और
Providerस्टेट मैनेजमेंट के बारे में बुनियादी जानकारी. - Apple डेवलपर खाता (iOS पर App Store से की गई खरीदारी को टेस्ट करने के लिए), Google Play डेवलपर खाता (Android पर Play Store से की गई खरीदारी को टेस्ट करने के लिए) या दोनों.
- एक Firebase खाता और Firebase CLI.
2. डेवलपमेंट एनवायरमेंट सेट अप करना
संपादक
इस कोडलैब में, Google Antigravity का इस्तेमाल एआई-फ़र्स्ट डेवलपमेंट एनवायरमेंट के तौर पर किया जाता है. हर चरण में, Antigravity को Flutter क्लाइंट (app/) और Dart बैकएंड (dart-backend/) जनरेट करने या उसे बेहतर बनाने के लिए प्रॉम्प्ट दिया जाता है. इसके बाद, जनरेट किए गए कोड की जांच की जाती है और ज़रूरत पड़ने पर, उसके अलग-अलग वर्शन एक्सप्लोर किए जाते हैं.
Flutter इंस्टॉल करना
Flutter SDK टूल को इंस्टॉल करने के बारे में अप-टू-डेट निर्देश, हमेशा docs.flutter.dev पर उपलब्ध होते हैं.
इस कोडलैब के लिए, यह सॉफ़्टवेयर इंस्टॉल करें:
- Flutter SDK
- Google Antigravity में Dart और Flutter का आधिकारिक प्लगइन चालू होना चाहिए. यह प्लगइन, प्लगइन Marketplace में Build with Google सेक्शन में उपलब्ध है.
- आपके चुने गए मोबाइल टारगेट के लिए कंपाइलर सॉफ़्टवेयर (Android को टारगेट करने के लिए Android Studio या iOS को टारगेट करने के लिए Xcode).
स्टार्टर प्रोजेक्ट बनाने के लिए, Antigravity को प्रॉम्प्ट दें
- Google Antigravity लॉन्च करें और एक खाली वर्कस्पेस डायरेक्ट्री खोलें, जहां आपको अपना Flutter ऐप्लिकेशन (
app/) और Dart सर्वर (dart-backend/), दोनों बनाने हैं. ऐसा पाथ चुनें जिसके लिए खास सुविधाओं के ऐक्सेस की ज़रूरत न हो या जिसमें स्पेस न हों. जैसे, आपकी होम डायरेक्ट्री याC:\src\में मौजूद कोई फ़ोल्डर. - Antigravity एजेंट के चैट पैनल में,
app/में Dash Clicker स्टार्टर ऐप्लिकेशन को स्कैफ़ोल्ड करने के लिए, यह प्रॉम्प्ट भेजें:
Create a new empty Flutter project in `app/` named `dashclicker` targeting Android and iOS (`flutter create app --project-name dashclicker --empty --platforms android,ios`). Add the `cloud_firestore`, `cupertino_icons`, `firebase_auth`, `firebase_core`, `google_sign_in`, `http`, `intl`, `provider`, `logging`, `material_ui`, and `cupertino_ui` packages. Download `dash_old.png` and `dash.png` from `https://raw.githubusercontent.com/flutter/codelabs/main/in_app_purchases/step_00/app/assets/dash_old.png` and `https://raw.githubusercontent.com/flutter/codelabs/main/in_app_purchases/step_00/app/assets/dash.png` into `app/assets/` and register `assets/` under `flutter: assets:` in `app/pubspec.yaml`. Set `minSdk = 23` in `app/android/app/build.gradle.kts`, and add `GIDClientID` and `CFBundleURLTypes` placeholders in `app/ios/Runner/Info.plist`. Scaffold the Dash Clicker starter files using `package:material_ui/material_ui.dart` and `package:cupertino_ui/cupertino_ui.dart`:
- `lib/constants.dart` defining `cloudRegion = 'europe-west1'`, `storeKeyConsumable = 'dash_consumable_2k'`, `storeKeyUpgrade = 'dash_upgrade_3d'`, `storeKeySubscription = 'dash_subscription_doubler'`, and `serverIp = '192.168.178.46'`
- `lib/firebase_options.dart` with a placeholder `DefaultFirebaseOptions` for Android and iOS
- `lib/model/firebase_state.dart` (`enum FirebaseState { loading, available, notAvailable }`), `lib/model/store_state.dart` (`enum StoreState { loading, available, notAvailable }`), `lib/model/purchasable_product.dart` (`enum ProductStatus { purchasable, purchased, pending }` and `PurchasableProduct(this.title, this.description, this.price)`), and `lib/model/past_purchase.dart` (`PurchaseType`, `Store`, `Status`, and `PastPurchase.fromJson`)
- `lib/logic/dash_counter.dart` (`DashCounter extends ChangeNotifier` with `count`, `countString`, `increment()`, `addAutoIncrement()`, `applyPaidMultiplier()`, `removePaidMultiplier()`, `addBoughtDashes(int amount)`, and a 10Hz `Timer.periodic`)
- `lib/logic/dash_purchases.dart` (`DashPurchases extends ChangeNotifier` with `counter`, `storeState = StoreState.available`, mock `products`, `bool get beautifiedDash => false`, and a simulated `buy(PurchasableProduct product)` method)
- `lib/logic/dash_upgrades.dart` (`DashUpgrades extends ChangeNotifier` and `Upgrade` for `'Tim Sneath'`)
- `lib/logic/firebase_notifier.dart` (`FirebaseNotifier extends ChangeNotifier` initializing `Firebase.initializeApp`, `GoogleSignIn.instance`, `FirebaseAuth`, and `FirebaseFirestore`)
- `lib/repo/iap_repo.dart` (`IAPRepo extends ChangeNotifier` listening to Firebase auth changes and the `purchases` collection in Firestore)
- `lib/pages/home_page.dart` (`HomePage`, `DashClickerWidget`, `CounterStateWidget`, and `UpgradeList`), `lib/pages/login_page.dart` (`LoginPage`), and `lib/pages/purchase_page.dart` (`PurchasePage`, `_PurchasesLoading`, `_PurchasesNotAvailable`, `_PurchaseList`, `_PurchaseWidget`, and `PastPurchasesWidget`)
- `lib/main.dart` (`MyApp` and `MyHomePage` providing `FirebaseNotifier`, `DashCounter`, `DashUpgrades`, `IAPRepo`, and `DashPurchases` using `MultiProvider` with a `BottomNavigationBar` switching between `HomePage` and `PurchasePage`)
- `test/widget_test.dart` pumping `const MyApp()` and verifying `find.text('Tim Sneath')`.
जनरेट किए गए स्टार्टर कोड को समझना
Antigravity, app/ Flutter प्रोजेक्ट बनाता है और Provider और ChangeNotifier का इस्तेमाल करके, Dash Clicker गेम आर्किटेक्चर को स्कैफ़ोल्ड करता है:
app/lib/main.dart,MyHomePageमें पांचChangeNotifierProvider(FirebaseNotifier,DashCounter,DashUpgrades,IAPRepo, औरDashPurchases) रजिस्टर करता है. साथ ही,HomePageऔरPurchasePageके बीच स्विच करता है.app/lib/constants.dart, स्टोर के तीन प्रॉडक्ट आईडी तय करता है. ये आईडी, App Store Connect और Google Play Console में कॉन्फ़िगर किए गए आईडी से मैच होने चाहिए:
const cloudRegion = 'europe-west1';
const storeKeyConsumable = 'dash_consumable_2k';
const storeKeyUpgrade = 'dash_upgrade_3d';
const storeKeySubscription = 'dash_subscription_doubler';
// TODO: Replace by your own server IP
const serverIp = '192.168.178.46';
अपने ऐप्लिकेशन के बंडल आइडेंटिफ़ायर और ऐप्लिकेशन आईडी को कॉन्फ़िगर करना
App Store और Play Store के साथ कम्यूनिकेट करने के लिए, आपके ऐप्लिकेशन को एक यूनीक रिवर्स-डोमेन आइडेंटिफ़ायर की ज़रूरत होती है. उदाहरण के लिए, dev.flutter.dashclicker. iOS पर, इसे बंडल आइडेंटिफ़ायर कहा जाता है. वहीं, Android पर इसे ऐप्लिकेशन आईडी कहा जाता है. दोनों प्लैटफ़ॉर्म पर एक ही आइडेंटिफ़ायर का इस्तेमाल करने से, कॉन्फ़िगरेशन आसान हो जाता है.
सबसे पहले, Xcode में app/ios/Runner.xcworkspace खोलकर iOS के लिए बंडल आईडी सेट अप करें:

Xcode के प्रोजेक्ट नेविगेटर में, सबसे ऊपर मौजूद Runner को चुनें. इसके बाद, Signing & Capabilities टैब खोलें और अपनी Team चुनें. इसके बाद, अपना यूनीक बंडल आइडेंटिफ़ायर डालें:

इसके बाद, app/android/app/build.gradle.kts में Android applicationId को अपडेट करें, ताकि वह आपके चुने गए आइडेंटिफ़ायर से मैच हो सके. इसके लिए, सीधे तौर पर बदलाव किया जा सकता है या Antigravity से app/android/app/build.gradle.kts में applicationId को आपके चुने गए आईडी के हिसाब से अपडेट करने के लिए कहा जा सकता है:

3. प्लगिन इंस्टॉल करना
इस चरण में, Antigravity को in_app_purchase प्लगिन और उसके प्लैटफ़ॉर्म इंटरफ़ेस पैकेज को app/ में जोड़ने के लिए कहा जाता है. इस पैकेज का इस्तेमाल, विजेट टेस्ट में स्टोर कनेक्शन को मॉक करने के लिए किया जाता है.
Antigravity को in_app_purchase इंस्टॉल करने के लिए कहें
Antigravity एजेंट के चैट पैनल में, यह प्रॉम्प्ट भेजें:
In `app/`, add `in_app_purchase` to `dependencies` and `in_app_purchase_platform_interface` to `dev_dependencies` in `pubspec.yaml`.
जनरेट किए गए कोड को समझना
Antigravity, app/ में flutter pub add in_app_purchase dev:in_app_purchase_platform_interface को चलाता है और app/pubspec.yaml को अपडेट करता है:
dependencies:
flutter:
sdk: flutter
cloud_firestore: ^7.1.0
cupertino_icons: ^2.0.0
cupertino_ui: ^1.1.6
firebase_auth: ^7.0.1
firebase_core: ^5.1.0
google_sign_in: ^7.2.0
http: ^1.6.0
in_app_purchase: ^3.3.1
intl: ^0.20.3
logging: ^1.3.0
material_ui: ^1.11.0
provider: ^6.1.5+1
dev_dependencies:
flutter_test:
sdk: flutter
flutter_lints: ^6.0.0
in_app_purchase_platform_interface: ^1.4.1
in_app_purchase, iOS पर StoreKit और Android पर Google Play Billing की मदद से, क्रॉस-प्लैटफ़ॉर्मInAppPurchaseएपीआई उपलब्ध कराता है.in_app_purchase_platform_interface,InAppPurchasePlatformAdditionको एक्सपोज़ करता है. इससेapp/test/widget_test.dartमें मॉकInAppPurchaseक्लाइंट को लागू किया जा सकता है.
4. ऐप स्टोर सेट अप करें
iOS पर इन-ऐप्लिकेशन खरीदारी की सुविधा को टेस्ट करने के लिए, आपको App Store Connect में अपना ऐप्लिकेशन रजिस्टर करना होगा. साथ ही, खरीदे जा सकने वाले प्रॉडक्ट कॉन्फ़िगर करने होंगे. आपको ऐप्लिकेशन को पब्लिश करने या समीक्षा के लिए सबमिट करने की ज़रूरत नहीं है. हालांकि, आपके पास Apple Developer खाता होना चाहिए. अगर आपके पास यह खाता नहीं है, तो Apple Developer Program में रजिस्टर करें.
पैसे चुकाकर डाउनलोड किए जाने वाले ऐप्लिकेशन से जुड़े कानूनी समझौते
इन-ऐप्लिकेशन खरीदारी की सुविधा इस्तेमाल करने के लिए, आपके पास App Store Connect में पैसे चुकाकर डाउनलोड किए जाने वाले ऐप्लिकेशन का चालू कानूनी समझौता होना चाहिए. App Store Connect पर जाएं. इसके बाद, Agreements, Tax, and Banking (या Business) को चुनें.

मुफ़्त और पैसे चुकाकर डाउनलोड किए जाने वाले ऐप्लिकेशन के लिए कानूनी समझौते देखें. पैसे चुकाकर डाउनलोड किए जाने वाले ऐप्लिकेशन के लिए, शर्तें देखें और उन्हें स्वीकार करें. साथ ही, टैक्स और बैंकिंग से जुड़ी ज़रूरी जानकारी डालें.

सभी चीज़ें कॉन्फ़िगर होने के बाद, पैसे चुकाकर डाउनलोड किए जाने वाले ऐप्लिकेशन की स्थिति बदलकर चालू है हो जाती है. अगर पैसे चुकाकर डाउनलोड किया जाने वाला ऐप्लिकेशन के लिए किया गया कानूनी समझौता चालू नहीं है, तो StoreKit टेस्टिंग के दौरान आपके ऐप्लिकेशन में खरीदने के लिए प्रॉडक्ट नहीं दिखाएगा.

ऐप्लिकेशन आईडी रजिस्टर करना
Apple डेवलपर पोर्टल में नया ऐप आईडी बनाएं:
- Apple Developer Identifiers पर जाएं और Identifiers हेडर के बगल में मौजूद, + आइकॉन पर क्लिक करें.

- App IDs को चुनें और Continue पर क्लिक करें.

- टाइप के तौर पर ऐप्लिकेशन चुनें और जारी रखें पर क्लिक करें.

- जानकारी डालें और बंडल आईडी (एक्सप्लिसिट) को उस बंडल आइडेंटिफ़ायर पर सेट करें जिसे आपने Xcode में कॉन्फ़िगर किया है. पक्का करें कि इन-ऐप्लिकेशन खरीदारी की सुविधा चालू हो. इसके बाद, आइडेंटिफ़ायर को रजिस्टर करें.

ज़्यादा जानकारी के लिए, Apple डेवलपर खाते से जुड़ी सहायता देखें.
नया ऐप्लिकेशन और सैंडबॉक्स उपयोगकर्ता बनाना
अपने रजिस्टर किए गए बंडल आइडेंटिफ़ायर का इस्तेमाल करके, App Store Connect में नया ऐप्लिकेशन बनाएं:
|
|
ऐप्लिकेशन बनाने और कानूनी समझौतों को मैनेज करने के बारे में ज़्यादा जानने के लिए, App Store Connect का सहायता केंद्र देखें.
बिना किसी शुल्क के इन-ऐप्लिकेशन खरीदारी की सुविधा को टेस्ट करने के लिए, App Store Connect में Sandbox Apple खाता बनाएं. इसके लिए, Users and Access > Sandbox पर जाएं. आपको ऐसे ईमेल पते का इस्तेमाल करना होगा जो पहले से किसी Apple खाते से न जुड़ा हो.

टेस्टिंग के लिए इस्तेमाल किए जा रहे iPhone या iPad पर, Settings > Developer > Sandbox Apple Account में जाकर, अपने सैंडबॉक्स खाते से साइन इन करें.
|
|
इन-ऐप्लिकेशन खरीदारी कॉन्फ़िगर करना
इसके बाद, App Store Connect में जाकर, खरीदारी के लिए उपलब्ध तीन आइटम कॉन्फ़िगर करें:
dash_consumable_2k: इस्तेमाल किया जा सकने वाला ऐसा आइटम जिसे बार-बार खरीदा जा सकता है. हर खरीदारी पर 2,000 डैश मिलते हैं.dash_upgrade_3d: यह एक ऐसा अपग्रेड है जिसे सिर्फ़ एक बार खरीदा जा सकता है. इसे खरीदने पर, 3D Dash मैस्कॉट अनलॉक हो जाता है.dash_subscription_doubler: अपने-आप रिन्यू होने वाली सदस्यता, जो चालू होने पर पैसिव क्लिक की संख्या बढ़ाती है.

अपने ऐप्लिकेशन के इन-ऐप्लिकेशन खरीदारी (और सदस्यताएं) सेक्शन में, इन प्रॉडक्ट आईडी के साथ तीन प्रॉडक्ट बनाएं:
- इस्तेमाल किया जा सकने वाला प्रॉडक्ट (
dash_consumable_2k):- इस्तेमाल किया जा सकने वाला प्रॉडक्ट बनाएं. इसके लिए, रेफ़रंस के तौर पर नाम
dash consumable 2kऔर प्रॉडक्ट आईडीdash_consumable_2kडालें.
- प्रॉडक्ट की उपलब्धता को कॉन्फ़िगर करें, ताकि वह आपके सैंडबॉक्स उपयोगकर्ता के देश या इलाके में उपलब्ध हो.

- कीमत को
\$1.99(या स्थानीय मुद्रा के हिसाब से इसके बराबर) पर सेट करें.
Spring is in the airडिसप्ले नेम और2000 dashes fly outब्यौरे के साथ स्थानीय भाषा जोड़ें.
- समीक्षा का स्क्रीनशॉट अपलोड करें. सैंडबॉक्स टेस्टिंग के लिए, इमेज के कॉन्टेंट से कोई फ़र्क़ नहीं पड़ता. हालांकि, स्क्रीनशॉट अपलोड करने से प्रॉडक्ट, सबमिट करने के लिए तैयार स्थिति में आ जाता है. ऐप्लिकेशन को StoreKit से प्रॉडक्ट फ़ेच करने के लिए, यह ज़रूरी है.

- इस्तेमाल किया जा सकने वाला प्रॉडक्ट बनाएं. इसके लिए, रेफ़रंस के तौर पर नाम
- इस्तेमाल न किए जा सकने वाले प्रॉडक्ट (
dash_upgrade_3d):dash upgrade 3dरेफ़रंस नाम औरdash_upgrade_3dप्रॉडक्ट आईडी वाला नॉन-कन्ज़्यूमेबल प्रॉडक्ट बनाएं.- डिसप्ले नेम को
3D Dash, ब्यौरे कोBrings your dash back to the future, और कीमत को\$0.99पर सेट करें. - उपलब्धता को कॉन्फ़िगर करें और समीक्षा के लिए स्क्रीनशॉट अपलोड करें. ठीक उसी तरह जैसे आपने
dash_consumable_2kके लिए किया था.
- अपने-आप रिन्यू होने वाली सदस्यता (
dash_subscription_doubler):- सदस्यताएं में जाकर,
subscriptionsनाम का एक सदस्यता ग्रुप बनाएं. उपयोगकर्ता एक समय में एक ही ग्रुप में मौजूद सिर्फ़ एक प्रॉडक्ट की सदस्यता ले सकते हैं. साथ ही, वे ग्रुप में मौजूद प्रॉडक्ट की सदस्यता को अपग्रेड या डाउनग्रेड कर सकते हैं.
- सदस्यता ग्रुप के लिए, App Store में स्थानीय भाषा में जानकारी जोड़ें.

- ग्रुप में, रेफ़रंस नेम
dash subscription doublerऔर प्रॉडक्ट आईडीdash_subscription_doublerके साथ सदस्यता बनाएं.
- सदस्यता की अवधि को 1 हफ़्ता, डिसप्ले नेम को
Jet Engine, ब्यौरे कोDoubles your clicks, और कीमत को\$0.49पर सेट करें. उपलब्धता को कॉन्फ़िगर करें और समीक्षा के लिए स्क्रीनशॉट अपलोड करें, ताकि इसकी स्थिति सबमिट करने के लिए तैयार हो जाए.
- सदस्यताएं में जाकर,
अब आपके प्रॉडक्ट, App Store Connect में सबमिट करने के लिए तैयार स्टेटस के साथ दिखने चाहिए:


5. Play Store को सेट अप करना
Android पर इन-ऐप्लिकेशन खरीदारी की सुविधा को टेस्ट करने के लिए, आपके पास Google Play डेवलपर खाता होना चाहिए. अगर आपके पास अब तक कोई खाता नहीं है, तो Google Play डेवलपर खाते के लिए रजिस्टर करें.
नया ऐप्लिकेशन बनाना
Google Play Console में नया ऐप्लिकेशन बनाएं:
- Google Play Console खोलें.
- सभी ऐप्लिकेशन > ऐप्लिकेशन बनाएं को चुनें.
- कोई डिफ़ॉल्ट भाषा चुनें और ऐप्लिकेशन का नाम डालें. इसे बाद में बदला जा सकता है.
- ऐप्लिकेशन के टाइप के तौर पर गेम और कीमत के मॉडल के तौर पर मुफ़्त चुनें.
- Developer Program की नीतियां और एक्सपोर्ट से जुड़े अमेरिका के कानून की शर्तें स्वीकार करें. इसके बाद, ऐप्लिकेशन बनाएं को चुनें.
ऐप्लिकेशन बनाने के बाद, डैशबोर्ड पर जाकर अपना ऐप्लिकेशन सेट अप करें सेक्शन में मौजूद शुरुआती टास्क पूरे करें:

ऐप्लिकेशन पर हस्ताक्षर करें
Google Play Billing को टेस्ट करने के लिए, आपको Google Play Console में किसी टेस्टिंग ट्रैक पर, साइन की गई कम से कम एक रिलीज़ appbundle अपलोड करनी होगी.
कीस्टोर बनाना
अगर आपके पास पहले से कोई अपलोड कीस्टोर नहीं है, तो टर्मिनल से एक कीस्टोर जनरेट करें.
macOS या Linux पर:
keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key
Windows पर:
keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key
app/android/key.properties बनाएं
app/android/key.properties बनाएं, जिसमें आपके कीस्टोर का रेफ़रंस शामिल हो:
storePassword=<password from previous step>
keyPassword=<password from previous step>
keyAlias=key
storeFile=<location of the key store file, such as /Users/<user name>/key.jks>
Gradle में रिलीज़ साइनिंग को कॉन्फ़िगर करने के लिए, Antigravity को प्रॉम्प्ट देना
app/android/app/build.gradle.kts में रिलीज़ साइनिंग को सेट अप करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:
Update `app/android/app/build.gradle.kts` to load `key.properties` into a `Properties` object if the file exists, configure a `release` signing config inside `signingConfigs` using `keyAlias`, `keyPassword`, `storeFile`, and `storePassword`, and assign `signingConfigs.getByName("release")` to the `release` build type when `key.properties` is present.
Antigravity, app/android/app/build.gradle.kts को अपडेट करता है, ताकि key.properties को लोड किया जा सके और रिलीज़ के लिए तैयार बिल्ड पर हस्ताक्षर किए जा सकें:
val keystoreProperties = Properties()
val keystorePropertiesFile = rootProject.file("key.properties")
if (keystorePropertiesFile.exists()) {
keystoreProperties.load(FileInputStream(keystorePropertiesFile))
}
android {
// ...
signingConfigs {
create("release") {
keyAlias = keystoreProperties["keyAlias"] as String?
keyPassword = keystoreProperties["keyPassword"] as String?
storeFile = keystoreProperties["storeFile"]?.let { file(it) }
storePassword = keystoreProperties["storePassword"] as String?
}
}
buildTypes {
release {
signingConfig = signingConfigs.getByName("release")
}
}
}
अपना पहला बिल्ड अपलोड करना
app/ से, साइन किया गया रिलीज़ ऐप्लिकेशन बंडल बनाएं:
cd app
flutter build appbundle
रिलीज़ बंडल को app/build/app/outputs/bundle/release/app-release.aab में लिखा जाता है.
Google Play Console में, जांच करें और रिलीज़ करें > जांच > क्लोज़्ड टेस्टिंग पर जाएं. इसके बाद, क्लोज़्ड टेस्टिंग रिलीज़ बनाएं, app-release.aab अपलोड करें, और सेव करें > रिलीज़ की समीक्षा करें > क्लोज़्ड टेस्टिंग के लिए रोल आउट शुरू करें पर क्लिक करें.
टेस्ट यूज़र सेट अप करना
Android पर इन-ऐप्लिकेशन खरीदारी की सुविधा को टेस्ट करने के लिए, Google Play Console में दो जगहों पर अपने टेस्टर के Google खाते जोड़ें:
- टेस्टिंग ट्रैक के टेस्टर: जांच करें और रिलीज़ करें > टेस्टिंग > इंटरनल टेस्टिंग (या क्लोज़्ड टेस्टिंग) पर जाएं. इसके बाद, टेस्टर टैब खोलें और ईमेल सूची बनाएं पर क्लिक करें. अब टेस्टर के ईमेल पते जोड़ें, सूची चुनें, और बदलाव सेव करें पर क्लिक करें.

- लाइसेंस टेस्टर: सभी ऐप्लिकेशन व्यू पर वापस जाएं. इसके बाद, सेटिंग > लाइसेंस की जांच को चुनें और टेस्टर के वही ईमेल पते जोड़ें. इसके बाद, लाइसेंस का जवाब को
RESPOND_NORMALLYपर सेट करें और बदलाव सेव करें पर क्लिक करें.
इन-ऐप्लिकेशन खरीदारी कॉन्फ़िगर करना
Google Play Console में, इन तीन प्रॉडक्ट आईडी को कॉन्फ़िगर करें:
dash_consumable_2k: इस्तेमाल किया जा सकने वाला आइटम, जिसे खरीदने पर 2,000 डैश मिलते हैं.dash_upgrade_3d: इस्तेमाल न किया जा सकने वाला, एक बार में मिलने वाला 3D Dash अपग्रेड.dash_subscription_doubler: अपने-आप रिन्यू होने वाली क्लिक-मल्टीप्लायर सदस्यता.
सबसे पहले, वन-टाइम प्रॉडक्ट (dash_consumable_2k और dash_upgrade_3d) बनाएं:
- Google Play Console में अपना ऐप्लिकेशन चुनें. इसके बाद, Google Play का इस्तेमाल करके कमाई करें > प्रॉडक्ट > ऐप्लिकेशन में खरीदने के लिए प्रॉडक्ट पर जाएं.
- प्रॉडक्ट बनाएं पर क्लिक करें.

- प्रॉडक्ट आईडी (
dash_consumable_2k), नाम, ब्यौरा, और कीमत डालें. इसके बाद, सेव करें और चालू करें पर क्लिक करें. dash_upgrade_3dके लिए भी यही प्रोसेस दोहराएं.
इसके बाद, सदस्यता (dash_subscription_doubler) बनाएं:
- Google Play का इस्तेमाल करके कमाई करें > प्रॉडक्ट > सदस्यताएं पर जाएं. इसके बाद, सदस्यता बनाएं पर क्लिक करें.

- प्रॉडक्ट आईडी (
dash_subscription_doubler) डालें. इसके बाद, हर हफ़्ते की बिलिंग अवधि और कीमत वाला बुनियादी प्लान जोड़ें. फिर उसे सेव करें और चालू करें.
6. Firebase सेट अप करना
खरीदारी की पुष्टि करने और उन्हें ट्रैक करने के लिए, Cloud Firestore के साथ बैकएंड सेवा का इस्तेमाल करने से आपके ऐप्लिकेशन को सुरक्षा से जुड़े कई फ़ायदे मिलते हैं:
- Google Play और Apple के सर्वर से सीधे तौर पर लेन-देन की पुष्टि की जाती है.
- सर्वर-साइड बिलिंग इवेंट (जैसे, रिन्यूअल या रद्द करना) पर प्रतिक्रिया दी जा सकती है.
- Cloud Firestore में, पुष्टि किए गए हर उपयोगकर्ता के लिए एकमात्र भरोसेमंद सोर्स सेव किया जाता है.
- उपयोगकर्ता अपने डिवाइस की घड़ी में छेड़छाड़ करके, प्रीमियम फ़ायदे अनलॉक नहीं कर सकते.
Firebase प्रोजेक्ट बनाना
- Firebase कंसोल खोलें और एक नया Firebase प्रोजेक्ट बनाएं. उदाहरण के लिए, Dash Clicker.
- Build > Authentication पर जाएं. इसके बाद, Get started पर क्लिक करें और Sign-in method टैब खोलें. इसके बाद, Google साइन-इन की सुविधा देने वाली कंपनी को चालू करें.

- Build > Firestore Database पर जाएं और एक डेटाबेस बनाएं.

- Cloud Firestore में नियम टैब खोलें और सुरक्षा से जुड़े ये नियम पब्लिश करें, ताकि पुष्टि किए गए उपयोगकर्ता सिर्फ़ अपनी खरीदारी के दस्तावेज़ पढ़ सकें:
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /purchases/{purchaseId} {
allow read: if request.auth != null && request.auth.uid == resource.data.userId
}
}
}
Flutter के लिए Firebase सेट अप करना
FlutterFire सीएलआई इंस्टॉल करने के लिए, FlutterFire सेटअप गाइड में दिया गया तरीका अपनाएं. इसके बाद, app/ में flutterfire configure चलाएं:
cd app
flutterfire configure
- वह Firebase प्रोजेक्ट चुनें जिसे आपने बनाया है.
- android और ios को चालू करें.
lib/firebase_options.dartको ओवरराइड करने के लिए पूछे जाने पर, हां पर क्लिक करें.
Android के लिए Firebase सेट अप करना: SHA-1 सर्टिफ़िकेट को डीबग करना
Android पर Google साइन-इन की सुविधा का इस्तेमाल करने के लिए, आपको Firebase कंसोल में अपने डीबग कीस्टोर के SHA-1 फ़िंगरप्रिंट को रजिस्टर करना होगा:
- Firebase कंसोल में, प्रोजेक्ट की खास जानकारी > प्रोजेक्ट सेटिंग > सामान्य पर जाएं. इसके बाद, नीचे की ओर स्क्रोल करके आपके ऐप्लिकेशन पर जाएं और अपना Android ऐप्लिकेशन चुनें:

app/android/से साइनिंग रिपोर्ट जनरेट करें:cd app/android ./gradlew :app:signingReportVariant: debugमेंSHA1फ़िंगरप्रिंट ढूंढें औरConfig: debugमें, इसे Firebase कंसोल में अपने Android ऐप्लिकेशन में जोड़ें. इसके बाद,app/मेंflutterfire configureको फिर से चलाएं, ताकिgoogle-services.jsonऔरlib/firebase_options.dartमें अपडेट किया गया OAuth क्लाइंट कॉन्फ़िगरेशन शामिल हो.
iOS के लिए Firebase सेट अप करना: यूआरएल स्कीम कॉन्फ़िगर करना
iOS पर Google साइन-इन की सुविधा देने के लिए, app/ios/Runner/Info.plist में CFBundleURLTypes के अंदर app/ios/Runner/GoogleService-Info.plist से REVERSED_CLIENT_ID शामिल होना चाहिए (google_sign_in iOS इंटिग्रेशन दस्तावेज़ देखें).
Antigravity को app/ios/Runner/GoogleService-Info.plist से REVERSED_CLIENT_ID और CLIENT_ID को app/ios/Runner/Info.plist में कॉपी करने के लिए प्रॉम्प्ट दिया जा सकता है:
Read `CLIENT_ID` and `REVERSED_CLIENT_ID` from `app/ios/Runner/GoogleService-Info.plist` and update `GIDClientID` and `CFBundleURLTypes` (`CFBundleURLSchemes`) in `app/ios/Runner/Info.plist` with those values.
app/ios/Runner/Info.plist में, CFBundleURLTypes एंट्री इस तरह दिखती है:
<key>CFBundleURLTypes</key>
<array>
<dict>
<key>CFBundleTypeRole</key>
<string>Editor</string>
<key>CFBundleURLSchemes</key>
<array>
<string>com.googleusercontent.apps.YOUR_REVERSED_CLIENT_ID</string>
</array>
</dict>
</array>
7. खरीदारी के अपडेट सुनना
इस चरण में, Flutter ऐप्लिकेशन को इस तरह तैयार किया जाता है कि वह ऐप्लिकेशन लॉन्च होते ही, स्टोर से की गई खरीदारी के अपडेट सुन सके. साथ ही, विजेट ट्री को टेस्ट करने लायक बनाए रखने के लिए, ओवरराइड किए जा सकने वाले IAPConnection रैपर को शामिल किया जाता है.
Antigravity को खरीदारी से जुड़े अपडेट सुनने के लिए कहें
Antigravity में यह प्रॉम्प्ट भेजें:
Update `app/lib/main.dart` to define an `IAPConnection` class with a static `InAppPurchase? _instance` and a static getter and setter for `instance` (defaulting to `InAppPurchase.instance`), and set `lazy: false` on `ChangeNotifierProvider<DashPurchases>`. Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` to set `storeState = StoreState.notAvailable`, hold `final iapConnection = IAPConnection.instance` and `late StreamSubscription<List<PurchaseDetails>> _subscription`, subscribe to `iapConnection.purchaseStream.listen(_onPurchaseUpdate, onDone: _updateStreamOnDone, onError: _updateStreamOnError)` in the constructor, cancel `_subscription` in `dispose()`, and add `_onPurchaseUpdate`, `_updateStreamOnDone`, and `_updateStreamOnError` methods. Finally, update `app/test/widget_test.dart` to define `TestIAPConnection implements InAppPurchase` and set `IAPConnection.instance = TestIAPConnection()` before pumping `MyApp`.
जनरेट किए गए कोड को समझना
app/lib/main.dart में IAPConnection और ईगर प्रोवाइडर को शुरू करना
डिफ़ॉल्ट रूप से, Provider अपनी वैल्यू को लेज़ी तरीके से तब बनाता है, जब कोई विजेट उसे पहली बार पढ़ता है. स्टोर के बाकी लेन-देन, स्टार्टअप के तुरंत बाद purchaseStream पर आ सकते हैं. इसलिए, ChangeNotifierProvider, lazy: false सेट करता है. इसके अलावा, IAPConnection एक स्टैटिक सीम उपलब्ध कराता है, ताकि विजेट टेस्ट, नकली InAppPurchase लागू कर सकें:
class IAPConnection {
static InAppPurchase? _instance;
static set instance(InAppPurchase value) {
_instance = value;
}
static InAppPurchase get instance {
_instance ??= InAppPurchase.instance;
return _instance!;
}
}
ChangeNotifierProvider<DashPurchases>(
create: (context) => DashPurchases(context.read<DashCounter>()),
lazy: false,
),
app/lib/logic/dash_purchases.dart में purchaseStream की सदस्यता ली जा रही है
DashPurchases में, कंस्ट्रक्टर iapConnection.purchaseStream की सदस्यता लेता है और dispose(), _subscription को रद्द करता है:
final iapConnection = IAPConnection.instance;
DashPurchases(this.counter) {
final purchaseUpdated = iapConnection.purchaseStream;
_subscription = purchaseUpdated.listen(
_onPurchaseUpdate,
onDone: _updateStreamOnDone,
onError: _updateStreamOnError,
);
}
@override
void dispose() {
_subscription.cancel();
super.dispose();
}
ऐप्लिकेशन को चलाना और टेस्ट करना
app/ में विजेट टेस्ट सुइट चलाएं, ताकि यह पुष्टि की जा सके कि TestIAPConnection, स्टोर कनेक्शन को सही तरीके से मॉक करता है:
cd app
flutter test
8. ख़रीदारी करना
इस चरण में, हार्डकोड किए गए मॉक प्रॉडक्ट को लाइव स्टोर के प्रॉडक्ट से बदलें. ये प्रॉडक्ट, queryProductDetails का इस्तेमाल करके फ़ेच किए जाते हैं. साथ ही, जब उपयोगकर्ता किसी प्रॉडक्ट पर टैप करे, तो खरीदारी शुरू करें. इसके अलावा, purchaseStream पर अपडेट मिलने पर लेन-देन पूरा करें.
Antigravity को लोड करने और खरीदारी करने के लिए प्रॉम्प्ट
Antigravity में यह प्रॉम्प्ट भेजें:
Update `PurchasableProduct` in `app/lib/model/purchasable_product.dart` to wrap a `ProductDetails productDetails` from `package:in_app_purchase/in_app_purchase.dart`, exposing `id`, `title`, `description`, and `price` getters from `productDetails` and initializing `status = ProductStatus.purchasable`. Then update `DashPurchases` in `app/lib/logic/dash_purchases.dart` to initialize `storeState = StoreState.loading`, `products = []`, and `bool _beautifiedDashUpgrade = false` (backing `beautifiedDash`), call `loadPurchases()` in the constructor to check `iapConnection.isAvailable()` and query `{storeKeyConsumable, storeKeySubscription, storeKeyUpgrade}` with `iapConnection.queryProductDetails(ids)`, implement `buy(PurchasableProduct product)` using `PurchaseParam` to call `iapConnection.buyConsumable` for `storeKeyConsumable` and `iapConnection.buyNonConsumable` for `storeKeySubscription` and `storeKeyUpgrade`, and implement `_onPurchaseUpdate` and `_handlePurchase(PurchaseDetails purchaseDetails)` to apply `PurchaseStatus.purchased` rewards (`counter.applyPaidMultiplier()`, `counter.addBoughtDashes(2000)`, `_beautifiedDashUpgrade = true`) and call `iapConnection.completePurchase(purchaseDetails)` when `purchaseDetails.pendingCompletePurchase` is true.
जनरेट किए गए कोड को समझना
app/lib/model/purchasable_product.dart में ProductDetails को रैप किया जा रहा है
PurchasableProduct, लोकल यूज़र इंटरफ़ेस (यूआई) ProductStatus (purchasable, purchased या pending) को ट्रैक करते समय, स्टोर से मिले ProductDetails को रैप करता है:
class PurchasableProduct {
String get id => productDetails.id;
String get title => productDetails.title;
String get description => productDetails.description;
String get price => productDetails.price;
ProductStatus status;
ProductDetails productDetails;
PurchasableProduct(this.productDetails) : status = ProductStatus.purchasable;
}
app/lib/logic/dash_purchases.dart में प्रॉडक्ट के बारे में क्वेरी की जा रही है
loadPurchases() सबसे पहले यह पुष्टि करता है कि iapConnection.isAvailable() का इस्तेमाल करके, स्टोर तक पहुंचा जा सकता है. इसके बाद, app/lib/constants.dart में तय किए गए तीन प्रॉडक्ट आईडी के बारे में क्वेरी करता है:
Future<void> loadPurchases() async {
final available = await iapConnection.isAvailable();
if (!available) {
storeState = StoreState.notAvailable;
notifyListeners();
return;
}
const ids = <String>{
storeKeyConsumable,
storeKeySubscription,
storeKeyUpgrade,
};
final response = await iapConnection.queryProductDetails(ids);
products = response.productDetails
.map((e) => PurchasableProduct(e))
.toList();
storeState = StoreState.available;
notifyListeners();
}
खरीदारी शुरू करना और उसे पूरा करना
जब कोई उपयोगकर्ता PurchasePage में किसी प्रॉडक्ट पर टैप करता है, तो buy() एक PurchaseParam बनाता है. इसके बाद, वह इस्तेमाल किए जा सकने वाले आइटम को buyConsumable पर और वन-टाइम अपग्रेड या सदस्यताओं को buyNonConsumable पर भेजता है:
Future<void> buy(PurchasableProduct product) async {
final purchaseParam = PurchaseParam(productDetails: product.productDetails);
switch (product.id) {
case storeKeyConsumable:
await iapConnection.buyConsumable(purchaseParam: purchaseParam);
case storeKeySubscription:
case storeKeyUpgrade:
await iapConnection.buyNonConsumable(purchaseParam: purchaseParam);
default:
throw ArgumentError.value(
product.productDetails,
'${product.id} is not a known product',
);
}
}
जब स्टोर purchaseStream पर अपडेट किए गए PurchaseDetails ऑब्जेक्ट दिखाता है, तब _handlePurchase उससे जुड़ा इनाम देता है. साथ ही, completePurchase को कॉल करके, टास्क पूरा होने की जानकारी देता है:
Future<void> _handlePurchase(PurchaseDetails purchaseDetails) async {
if (purchaseDetails.status == PurchaseStatus.purchased) {
switch (purchaseDetails.productID) {
case storeKeySubscription:
counter.applyPaidMultiplier();
case storeKeyConsumable:
counter.addBoughtDashes(2000);
case storeKeyUpgrade:
_beautifiedDashUpgrade = true;
}
}
if (purchaseDetails.pendingCompletePurchase) {
await iapConnection.completePurchase(purchaseDetails);
}
}
ऐप्लिकेशन को चलाना और टेस्ट करना
flutter test को app/ में चलाएं और कॉन्फ़िगर किए गए टेस्ट डिवाइस पर ऐप्लिकेशन लॉन्च करें. जब आपके स्टोर के प्रॉडक्ट ऐक्टिव होते हैं, तो खरीदारी टैब में वे खरीदारी के लिए उपलब्ध दिखते हैं:

9. बैकएंड सेट अप करना
किसी सर्वर पर खरीदारी की पुष्टि करने और उसे ट्रैक करने से पहले, आपको app/ के साथ-साथ dart-backend/ में Dart बैकएंड सेवा को स्कैफ़ोल्ड करना होगा. साथ ही, Firebase, Google Play, और App Store के लिए क्रेडेंशियल कॉन्फ़िगर करने होंगे.
Dart बैकएंड को स्कैफ़ोल्ड करने के लिए, Antigravity को प्रॉम्प्ट देना
Antigravity एजेंट के चैट पैनल में, dart-backend/ प्रोजेक्ट बनाने के लिए यह प्रॉम्प्ट भेजें:
Create a Dart shelf server project in `dart-backend/` with package name `firebase_backend_dart` (`dart create -t server-shelf`). Add `googleapis: ^16.0.0`, `googleapis_auth`, `http`, and `app_store_server_sdk` to `dependencies`, and `test` to `dev_dependencies` (configuring `deprecated_member_use: ignore` in `dart-backend/analysis_options.yaml`). Create:
- `dart-backend/lib/constants.dart` defining `androidPackageId`, `appStoreIssuerId`, `appStoreKeyId`, `appStoreSharedSecret`, `bundleId`, `googleCloudProjectId`, and `googlePlayPubsubBillingTopic = 'play_billing'`
- `dart-backend/lib/helpers.dart` with `serveHandler(Handler handler)`, `listenPort()`, and `terminateRequestFuture()` listening to `SIGINT` and `SIGTERM`
- `dart-backend/lib/products.dart` defining `ProductData(this.productId, this.type)`, `enum ProductType { subscription, nonSubscription }`, and `productDataMap` for `'dash_consumable_2k'`, `'dash_upgrade_3d'`, and `'dash_subscription_doubler'`
- `dart-backend/lib/iap_repository.dart` defining `enum IAPSource { googleplay, appstore }`, `abstract class Purchase`, `NonSubscriptionPurchase`, `SubscriptionPurchase`, and `IapRepository(this.api, this.projectId)` using `package:googleapis/firestore/v1.dart` (`createOrUpdatePurchase`, `updatePurchase`, and `getPurchases`)
- `dart-backend/bin/server.dart` starting an empty `Router()` with `await serveHandler(router.call)`.
जनरेट किए गए कोड को समझना
dart-backend/bin/server.dart,shelf_routerRouterको शुरू करता है औरdart-backend/lib/helpers.dartमेंserveHandlerका इस्तेमाल करके, पोर्ट8080पर एचटीटीपी अनुरोधों को पूरा करता है.dart-backend/lib/products.dartहर प्रॉडक्ट आईडी (dash_consumable_2k,dash_upgrade_3d, औरdash_subscription_doubler) को उसकेProductType(nonSubscriptionयाsubscription) से मैप करता है.dart-backend/lib/iap_repository.dart,FirestoreApiका इस्तेमाल करके, Cloud Firestore केpurchasesकलेक्शन मेंNonSubscriptionPurchaseऔरSubscriptionPurchaseदस्तावेज़ों को पढ़ने और लिखने की सुविधा देता है.
यह जांच की जा सकती है कि सर्वर स्थानीय तौर पर शुरू हो रहा है या नहीं. इसके लिए, यह कमांड चलाएं:
cd dart-backend
dart run ./bin/server.dart
Firebase का ऐक्सेस सेट अप करना
dart-backend/ को Cloud Firestore में, पुष्टि की गई खरीदारी की जानकारी लिखने की अनुमति देने के लिए, सेवा खाते की कुंजी जनरेट करें:
- Firebase कंसोल में, प्रोजेक्ट सेटिंग > सेवा खाते खोलें और नई निजी कुंजी जनरेट करें पर क्लिक करें.

- डाउनलोड की गई JSON फ़ाइल को
dart-backend/assets/service-account-firebase.jsonके तौर पर सेव करें.
Google Play का ऐक्सेस सेट अप करना
dart-backend/ को Google Play Android Developer API की मदद से, Android पर की गई खरीदारी की पुष्टि करने की अनुमति देने के लिए:
- Google Cloud Console में Google Play Android Developer API पेज खोलें और एपीआई को चालू करें.

- Google Cloud के सेवा खाते वाले पेज पर जाएं और + सेवा खाता बनाएं पर क्लिक करें.

- सर्विस खाते का नाम डालें और बनाएं और जारी रखें पर क्लिक करें.

- Pub/Sub सब्सक्राइबर की भूमिका असाइन करें और हो गया पर क्लिक करें.

- नए बनाए गए सेवा खाते का ऐक्शन मेन्यू खोलें और कुंजियां मैनेज करें को चुनें.

- कुंजी जोड़ें > नई कुंजी बनाएं को चुनें. इसके बाद, JSON को चुनें और कुंजी डाउनलोड करें:


- डाउनलोड की गई फ़ाइल को
dart-backend/assets/service-account-google-play.jsonके तौर पर सेव करें. - Google Play Console में उपयोगकर्ता और अनुमतियां खोलें. इसके बाद, नए उपयोगकर्ताओं को न्योता भेजें पर क्लिक करें और सेवा खाते का ईमेल पता डालें:


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

Apple App Store का ऐक्सेस सेट अप करना
बैकएंड पर ऐप स्टोर की रसीदों की पुष्टि करने के लिए, ऐप्लिकेशन के लिए खास तौर पर शेयर किया गया सीक्रेट जनरेट करें:
- App Store Connect खोलें, Apps को चुनें, और अपना ऐप्लिकेशन चुनें.
- साइडबार में, General > App Information पर जाएं.
- App-Specific Shared Secret में जाकर, Manage पर क्लिक करें. इसके बाद, नया शेयर किया गया सीक्रेट जनरेट करें और उसे कॉपी करें:


dart-backend/lib/constants.dart को अपडेट करें
पक्का करें कि dart-backend/lib/constants.dart में ये कॉन्सटैंट सेट हों:
androidPackageId: आपका AndroidapplicationId(जैसे,com.example.dashclicker).appStoreSharedSecret: आपके ऐप स्टोर Connect का शेयर किया गया सीक्रेट.bundleId: आपका iOS बंडल आइडेंटिफ़ायर (जैसे किcom.example.dashclicker).
10. खरीदारी की पुष्टि करना
जब कोई उपयोगकर्ता iOS या Android पर खरीदारी पूरी करता है, तो स्टोर पुष्टि के लिए एक टोकन (PurchaseDetails.verificationData.serverVerificationData) जारी करता है. क्लाइंट डिवाइस पर सीधे भरोसा करने के बजाय, Flutter ऐप्लिकेशन इस टोकन को dart-backend/ पर भेजता है. यह Google Play या App Store से टोकन की पुष्टि करता है और Cloud Firestore में खरीदारी को रिकॉर्ड करता है.

क्लाइंट और बैकएंड पर खरीदारी की पुष्टि करने के लिए, Antigravity को प्रॉम्प्ट करना
Flutter ऐप्लिकेशन और Dart बैकएंड के पुष्टि करने के फ़्लो को कनेक्ट करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:
1. In `app/`:
- Update `PurchasePage` in `app/lib/pages/purchase_page.dart` to watch `FirebaseNotifier` and return `_PurchasesLoading()` when `state == FirebaseState.loading`, `_PurchasesNotAvailable()` when `state == FirebaseState.notAvailable`, and `const LoginPage()` when `!firebaseNotifier.loggedIn`.
- Add `User? get user => FirebaseAuth.instance.currentUser;` to `FirebaseNotifier` in `app/lib/logic/firebase_notifier.dart`.
- Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` (and its provider in `app/lib/main.dart`) to accept `this.firebaseNotifier`, implement `_verifyPurchase(PurchaseDetails purchaseDetails)` that sends an HTTP `POST` request to `Uri.http('$serverIp:8080', '/verifypurchase')` with JSON body `{'source': purchaseDetails.verificationData.source, 'productId': purchaseDetails.productID, 'verificationData': purchaseDetails.verificationData.serverVerificationData, 'userId': firebaseNotifier.user?.uid}`, and update `_handlePurchase` so purchase rewards are only applied when `await _verifyPurchase(purchaseDetails)` returns `true`.
2. In `dart-backend/`:
- Create `dart-backend/lib/purchase_handler.dart` with `abstract class PurchaseHandler` defining `handleNonSubscription`, `handleSubscription`, and `verifyPurchase` switching on `productData.type`.
- Create `dart-backend/lib/google_play_purchase_handler.dart` with `GooglePlayPurchaseHandler extends PurchaseHandler` that verifies one-time purchases using `androidPublisher.purchases.products.get` and subscriptions using `androidPublisher.purchases.subscriptions.get`, parses order IDs with `extractOrderId(String orderId)` (stripping `..` renewal suffixes), maps statuses with `_nonSubscriptionStatusFrom` and `_subscriptionStatusFrom`, and saves purchases to `iapRepository`.
- Create `dart-backend/lib/app_store_purchase_handler.dart` with `AppStorePurchaseHandler extends PurchaseHandler` that validates receipts with `ITunesApi(ITunesHttpClient(ITunesEnvironment.sandbox(), loggingEnabled: true)).verifyReceipt` and saves `NonSubscriptionPurchase` and `SubscriptionPurchase` records to `iapRepository`.
- Update `dart-backend/bin/server.dart` to initialize `AndroidPublisherApi` and `FirestoreApi` from the service account JSON files in `_createPurchaseHandlers()`, register a `POST /verifypurchase` route, and extract request fields in `getPurchaseData(dynamic payload)` using Dart 3 map pattern matching.
जनरेट किए गए कोड को समझना
खरीदारी करने से पहले, पुष्टि करने की प्रोसेस पूरी करना और /verifypurchase को कॉल करना
app/lib/pages/purchase_page.dart में, PurchasePage FirebaseNotifier की जांच करता है और उपयोगकर्ता के साइन इन करने तक LoginPage दिखाता है:
var firebaseNotifier = context.watch<FirebaseNotifier>();
if (firebaseNotifier.state == FirebaseState.loading) {
return _PurchasesLoading();
} else if (firebaseNotifier.state == FirebaseState.notAvailable) {
return _PurchasesNotAvailable();
}
if (!firebaseNotifier.loggedIn) {
return const LoginPage();
}
app/lib/logic/dash_purchases.dart में, _verifyPurchase, Dart बैकएंड पर स्टोर सोर्स (google_play या app_store), productID, serverVerificationData, और साइन-इन किए गए userId को पोस्ट करता है. इसके बाद, _handlePurchase इन-ऐप्लिकेशन रिवॉर्ड देता है:
Future<bool> _verifyPurchase(PurchaseDetails purchaseDetails) async {
final url = Uri.http('$serverIp:8080', '/verifypurchase');
const headers = {
'Content-type': 'application/json',
'Accept': 'application/json',
};
final response = await http.post(
url,
body: jsonEncode({
'source': purchaseDetails.verificationData.source,
'productId': purchaseDetails.productID,
'verificationData':
purchaseDetails.verificationData.serverVerificationData,
'userId': firebaseNotifier.user?.uid,
}),
headers: headers,
);
if (response.statusCode == 200) {
return true;
} else {
return false;
}
}
dart-backend/bin/server.dart में Dart 3 के पैटर्न मैचिंग और रूटिंग की सुविधा
सर्वर पर, POST /verifypurchase Dart 3 मैप पैटर्न और रिकॉर्ड रिटर्न टाइप का इस्तेमाल करके, getPurchaseData के साथ JSON अनुरोध के मुख्य हिस्से को डिकोड करता है. इसके बाद, पुष्टि करने की ज़िम्मेदारी, मैच होने वाले स्टोर हैंडलर को सौंपता है:
router.post('/verifypurchase', (Request request) async {
final dynamic payload = json.decode(await request.readAsString());
final (:userId, :source, :productData, :token) = getPurchaseData(payload);
final result = await purchaseHandlers[source]!.verifyPurchase(
userId: userId,
productData: productData,
token: token,
);
if (result) {
return Response.ok('all good!');
} else {
return Response.internalServerError();
}
});
({String userId, String source, ProductData productData, String token})
getPurchaseData(dynamic payload) {
if (payload case {
'userId': String userId,
'source': String source,
'productId': String productId,
'verificationData': String token,
}) {
return (
userId: userId,
source: source,
productData: productDataMap[productId]!,
token: token,
);
} else {
throw const FormatException('Unexpected JSON');
}
}
Google Play और ऐप स्टोर की रसीदों की पुष्टि करना
dart-backend/lib/google_play_purchase_handler.dartमें,GooglePlayPurchaseHandlerवन-टाइम प्रॉडक्ट के लिएandroidPublisher.purchases.products.getऔर सदस्यताओं के लिएandroidPublisher.purchases.subscriptions.getसे जुड़ी क्वेरी करता है. साथ ही,extractOrderIdका इस्तेमाल करके, सदस्यता के ऑर्डर आईडी से रिन्यूअल के सफ़िक्स..#को हटाता है. इसके बाद,iapRepositoryका इस्तेमाल करके, Cloud Firestore मेंNonSubscriptionPurchaseयाSubscriptionPurchaseको लिखता है.dart-backend/lib/app_store_purchase_handler.dartमें,AppStorePurchaseHandlerapp_store_server_sdkपैकेज का इस्तेमाल करके_iTunesAPI.verifyReceiptको कॉल करता है. साथ ही, पुष्टि की गई हर रसीद कोresponse.latestReceiptInfoमें Cloud Firestore में सेव करता है.
बैकएंड को चलाना और उसकी जांच करना
dart-backend/ से बैकएंड सर्वर शुरू करें:
cd dart-backend
dart run bin/server.dart
11. खरीदारी पर नज़र रखना
सदस्यताएं आपके ऐप्लिकेशन के बाहर रिन्यू, रद्द या खत्म हो सकती हैं. इस चरण में, Google Cloud Pub/Sub और App Store Server API से स्टोर बिलिंग के अपडेट पोल करने के लिए, बैकएंड को कॉन्फ़िगर करें. साथ ही, IAPRepo का इस्तेमाल करके, Cloud Firestore से उपयोगकर्ता के चालू एनटाइटलमेंट को रीयल-टाइम में सिंक करने के लिए, Flutter क्लाइंट को अपडेट करें.
Cloud Pub/Sub और App Store Server API की कुंजियां कॉन्फ़िगर करना
Google Play Cloud Pub/Sub का सेटअप
dart-backend/lib/constants.dartमेंgoogleCloudProjectIdको अपने Google Cloud और Firebase प्रोजेक्ट आईडी पर सेट करें.- Google Cloud Console में Cloud Pub/Sub विषय पेज खोलें. पक्का करें कि आपका प्रोजेक्ट चुना गया हो. इसके बाद, + विषय बनाएं पर क्लिक करें.

- Topic ID को
play_billingपर सेट करें. यहdart-backend/lib/constants.dartमेंgooglePlayPubsubBillingTopicसे मैच होना चाहिए. इससे डिफ़ॉल्ट सदस्यताplay_billing-subअपने-आप बन जाती है. इसके बाद, Create पर क्लिक करें.
- अपने
play_billingविषय पर मौजूद तीन बिंदुओं वाले मेन्यू को खोलें और अनुमतियां देखें को चुनें.
- प्रिंसिपल जोड़ें पर क्लिक करें,
google-play-developer-notifications@system.gserviceaccount.comडालें, Pub/Sub पब्लिशर की भूमिका असाइन करें, और सेव करें पर क्लिक करें.
- विषय का पूरा नाम कॉपी करें. इसके बाद, Google Play Console में अपना ऐप्लिकेशन खोलें और Google Play से कमाई करें > कमाई करने के लिए सेटअप पर जाएं. फिर, विषय का नाम चिपकाएं और बदलाव सेव करें पर क्लिक करें.

App Store Server API पासकोड का सेटअप
- App Store Connect में साइन इन करें और Users and Access को चुनें.
- इंटिग्रेशन > कुंजियां > इन-ऐप्लिकेशन खरीदारी पर जाएं. इसके बाद, नई कुंजी जनरेट करने के लिए, + बटन पर क्लिक करें. उदाहरण के लिए,
Codelab key. .p8कुंजी फ़ाइल डाउनलोड करें और उसेdart-backend/assets/SubscriptionKey.p8के तौर पर सेव करें.- कुंजी आईडी और जारी करने वाले का आईडी कॉपी करें. इसके बाद, इन्हें
dart-backend/lib/constants.dartमें मौजूदappStoreKeyIdऔरappStoreIssuerIdमें चिपकाएं.

Antigravity को स्टोर इवेंट पोल करने और क्लाइंट की स्थिति को सिंक करने के लिए कहें
Antigravity में यह प्रॉम्प्ट भेजें:
1. In `dart-backend/`:
- Update `GooglePlayPurchaseHandler` in `dart-backend/lib/google_play_purchase_handler.dart` to accept `pubsub.PubsubApi pubsubApi` from `package:googleapis/pubsub/v1.dart`, start a 10-second `Timer.periodic` calling `_pullMessageFromPubSub()`, decode base64 Pub/Sub messages in `_processMessage(String data64, String? ackId)` (handling `testNotification`, `subscriptionNotification`, and `oneTimeProductNotification`), and acknowledge processed messages in `_ackMessage(String id)`.
- Update `AppStorePurchaseHandler` in `dart-backend/lib/app_store_purchase_handler.dart` to accept `AppStoreServerAPI appStoreServerAPI`, start a 10-second `Timer.periodic` calling `_pullStatus()`, query `appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId)` for active App Store subscriptions in `iapRepository`, and update their expiration date and `SubscriptionStatus` in Firestore.
- Update `dart-backend/bin/server.dart` to add `pubsub.PubsubApi.cloudPlatformScope` to the Google Play client scopes, construct `PubsubApi` and `AppStoreServerAPI` (reading `assets/SubscriptionKey.p8` and caching JWT tokens in `assets/appstore.token`), and pass them to `GooglePlayPurchaseHandler` and `AppStorePurchaseHandler`.
- Create unit tests in `dart-backend/test/firebase_backend_dart_test.dart` verifying `extractOrderId` (with and without a `..0` suffix) and `getPurchaseData` (valid and invalid payloads).
2. In `app/`:
- Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` (and its provider in `app/lib/main.dart`) to accept `this.iapRepo` (`IAPRepo`), register `iapRepo.addListener(purchasesUpdate)` in the constructor and `iapRepo.removeListener(purchasesUpdate)` in `dispose()`, and implement `purchasesUpdate()` and `_updateStatus(PurchasableProduct product, ProductStatus status)` (setting `product.status = status` when `product.status != status`) so `iapRepo.hasActiveSubscription` applies or removes the paid counter multiplier and `iapRepo.hasUpgrade` updates `_beautifiedDashUpgrade` and product statuses.
जनरेट किए गए कोड को समझना
बैकएंड पर Google Play Pub/Sub और App Store Server API को पोल करना
dart-backend/lib/google_play_purchase_handler.dart में, _pullMessageFromPubSub हर 10 सेकंड में projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub सदस्यता को पोल करता है. साथ ही, हर base64 सूचना पेलोड को डिकोड करता है. इसके बाद, Firestore को रीफ़्रेश करने के लिए, handleSubscription या handleNonSubscription को फिर से चलाता है और _ackMessage का इस्तेमाल करके मैसेज को स्वीकार करता है:
Future<void> _pullMessageFromPubSub() async {
print('Polling Google Play messages');
final request = pubsub.PullRequest(maxMessages: 1000);
final topicName =
'projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub';
final pullResponse = await pubsubApi.projects.subscriptions.pull(
request,
topicName,
);
final messages = pullResponse.receivedMessages ?? [];
for (final message in messages) {
final data64 = message.message?.data;
if (data64 != null) {
await _processMessage(data64, message.ackId);
}
}
}
इसी तरह, dart-backend/lib/app_store_purchase_handler.dart में, _pullStatus हर 10 सेकंड में appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId) क्वेरी करता है और Cloud Firestore में हर सदस्यता के expiryDate और SubscriptionStatus (active या expired) को अपडेट करता है.
डिवाइस पर Firestore की खरीदारी सिंक करना
app/lib/repo/iap_repo.dart में, IAPRepo Cloud Firestore में पुष्टि किए गए उपयोगकर्ता के purchases दस्तावेज़ों को रीयल टाइम में सुनता है. साथ ही, hasActiveSubscription और hasUpgrade की गिनती करता है:
var purchaseStream = _firestore
.collection('purchases')
.where('userId', isEqualTo: user.uid)
.snapshots();
_purchaseSubscription = purchaseStream.listen((snapshot) {
purchases = snapshot.docs.map((document) {
var data = document.data();
return PastPurchase.fromJson(data);
}).toList();
hasActiveSubscription = purchases.any(
(element) =>
element.productId == storeKeySubscription &&
element.status != Status.expired,
);
hasUpgrade = purchases.any(
(element) => element.productId == storeKeyUpgrade,
);
notifyListeners();
});
जब भी IAPRepo अपने लिसनर को सूचना देता है, तब app/lib/logic/dash_purchases.dart में मौजूद DashPurchases.purchasesUpdate(), 10x क्लिक मल्टीप्लायर को चालू या बंद करता है, _beautifiedDashUpgrade को टॉगल करता है, और PurchasePage पर दिखाए गए प्रॉडक्ट की स्थितियों को अपडेट करता है:
void purchasesUpdate() {
var subscriptions = <PurchasableProduct>[];
var upgrades = <PurchasableProduct>[];
if (products.isNotEmpty) {
subscriptions = products
.where((element) => element.productDetails.id == storeKeySubscription)
.toList();
upgrades = products
.where((element) => element.productDetails.id == storeKeyUpgrade)
.toList();
}
if (iapRepo.hasActiveSubscription) {
counter.applyPaidMultiplier();
for (var element in subscriptions) {
_updateStatus(element, ProductStatus.purchased);
}
} else {
counter.removePaidMultiplier();
for (var element in subscriptions) {
_updateStatus(element, ProductStatus.purchasable);
}
}
if (iapRepo.hasUpgrade != _beautifiedDashUpgrade) {
_beautifiedDashUpgrade = iapRepo.hasUpgrade;
for (var element in upgrades) {
_updateStatus(
element,
_beautifiedDashUpgrade
? ProductStatus.purchased
: ProductStatus.purchasable,
);
}
notifyListeners();
}
}
void _updateStatus(PurchasableProduct product, ProductStatus status) {
if (product.status != status) {
product.status = status;
notifyListeners();
}
}
ऐप्लिकेशन और बैकएंड को चलाएं और टेस्ट करें
दोनों प्रोजेक्ट में यूनिट और विजेट टेस्ट चलाएं, ताकि यह पुष्टि की जा सके कि सब कुछ सही तरीके से विश्लेषण और पास हो रहा है:
cd dart-backend
dart test
cd ../app
flutter test
12. बधाई हो
बधाई हो! आपने Google Antigravity के साथ मिलकर, Flutter में इन-ऐप्लिकेशन खरीदारी का फ़ुल-स्टैक इंटिग्रेशन बनाया है. इसमें Dart की मदद से पुष्टि करने वाला बैकएंड शामिल है.
आपने क्या बनाया है
- App Store Connect और Google Play Console में, इस्तेमाल किए जा सकने वाले (
dash_consumable_2k), इस्तेमाल न किए जा सकने वाले (dash_upgrade_3d), और अपने-आप रिन्यू होने वाली सदस्यता (dash_subscription_doubler) वाले प्रॉडक्ट कॉन्फ़िगर किए गए हों. - Dash Clicker Flutter ऐप्लिकेशन (
app/) कोin_app_purchaseप्लग इन से कनेक्ट किया गया. इससे प्रॉडक्ट की जानकारी के बारे में क्वेरी की जा सकती है औरpurchaseStreamको सुना जा सकता है. - हमने Dart
shelfबैकएंड (dart-backend/) बनाया है. यह Google Play Android Developer API और App Store की मदद से, खरीदारी के टोकन की पुष्टि करता है. साथ ही, Cloud Pub/Sub और App Store Server API का इस्तेमाल करके, बिलिंग से जुड़े अपडेट पोल करता है. इसके अलावा, Cloud Firestore में खरीदारी की स्थिति को सेव रखता है. IAPRepoका इस्तेमाल करके, Flutter क्लाइंट को रीयल टाइम में, पुष्टि की गई खरीदारी के एनटाइटलमेंट वापस सिंक किए जाते हैं.
अगले चरण
dart-backend/bin/server.dartमेंPOST /verifypurchaseमें Firebase Auth आईडी टोकन की पुष्टि करने वाला मिडलवेयर जोड़ें.dart-backend/को Cloud Run पर डिप्लॉय करें. साथ ही, Google Cloud Pub/Sub और App Store Server Notifications के लिए, पुश वेबहुक कॉन्फ़िगर करें.






