जनरेट किए गए Android SDK टूल इस्तेमाल करना

Firebase Data Connect क्लाइंट एसडीके की मदद से, सर्वर-साइड की क्वेरी और म्यूटेशन को सीधे Firebase ऐप्लिकेशन से कॉल किया जा सकता है. स्कीमा, क्वेरी, और म्यूटेशन डिज़ाइन करते समय, कस्टम क्लाइंट एसडीके जनरेट किया जाता है. इन्हें Data Connect सेवा में डिप्लॉय किया जाता है. इसके बाद, इस एसडीके टूल के तरीकों को अपने क्लाइंट लॉजिक में इंटिग्रेट करें.

जैसा कि हमने यहां बताया है, यह ध्यान रखना ज़रूरी है कि Data Connect क्लाइंट कोड, क्वेरी और म्यूटेशन सबमिट नहीं करता है. इन्हें सर्वर पर लागू किया जाता है. इसके बजाय, डिप्लॉय किए जाने पर Data Connect कार्रवाइयों को Cloud Functions जैसे सर्वर पर सेव किया जाता है. इसका मतलब है कि आपको क्लाइंट-साइड में ज़रूरी बदलाव करने होंगे, ताकि मौजूदा उपयोगकर्ताओं को कोई परेशानी न हो. उदाहरण के लिए, ऐप्लिकेशन के पुराने वर्शन पर.

इसलिए, Data Connect आपको डेवलपर एनवायरमेंट और टूलिंग उपलब्ध कराता है. इससे आपको सर्वर पर डिप्लॉय किए गए स्कीमा, क्वेरी, और म्यूटेशन का प्रोटोटाइप बनाने में मदद मिलती है. प्रोटोटाइप बनाते समय, यह क्लाइंट-साइड एसडीके भी अपने-आप जनरेट करता है.

जब आपने अपनी सेवा और क्लाइंट ऐप्लिकेशन में अपडेट कर लिए हों, तब सर्वर और क्लाइंट, दोनों के अपडेट डिप्लॉय करने के लिए तैयार होते हैं.

क्लाइंट डेवलपमेंट का वर्कफ़्लो क्या है?

अगर आपने शुरू करें सेक्शन में दिए गए निर्देशों का पालन किया है, तो आपको Data Connect के लिए डेवलपमेंट के पूरे फ़्लो के बारे में जानकारी मिल गई होगी. इस गाइड में, आपको अपने स्कीमा से Android SDK जनरेट करने के बारे में ज़्यादा जानकारी मिलेगी. साथ ही, क्लाइंट क्वेरी और म्यूटेशन के साथ काम करने के बारे में भी जानकारी मिलेगी.

संक्षेप में कहें, तो जनरेट किए गए Android SDK का इस्तेमाल अपने क्लाइंट ऐप्लिकेशन में करने के लिए, आपको ये ज़रूरी चरण पूरे करने होंगे:

1. अपने Android ऐप्लिकेशन में Firebase जोड़ें.
2. Gradle में Data Connect को डिपेंडेंसी के तौर पर कॉन्फ़िगर करें.
3. Kotlin Serialization Gradle प्लगिन और Gradle डिपेंडेंसी जोड़ें.

इसके बाद:

1. अपने ऐप्लिकेशन का स्कीमा डेवलप करें.

2. एसडीके जनरेशन सेट अप करें:

   • हमारे Data Connect VS Code एक्सटेंशन में मौजूद, ऐप्लिकेशन में SDK जोड़ें बटन की मदद से
   • अपने connector.yaml को अपडेट करके

3. अपने क्लाइंट कोड को शुरू करें और लाइब्रेरी इंपोर्ट करें.

4. क्वेरी और म्यूटेशन के लिए कॉल लागू करें.

5. Data Connect एम्युलेटर को सेट अप और इस्तेमाल करें और दोहराएं.

अपना Kotlin SDK टूल जनरेट करना

ज़्यादातर Firebase प्रोजेक्ट की तरह, आपके Firebase Data Connect क्लाइंट कोड पर काम, लोकल प्रोजेक्ट डायरेक्ट्री में होता है. क्लाइंट कोड जनरेट करने और उसे मैनेज करने के लिए, Data Connect VS Code एक्सटेंशन और Firebase CLI, दोनों ही अहम लोकल टूल हैं.

एसडीके जनरेट करने के विकल्प, dataconnect.yaml आपके प्रोजेक्ट को शुरू करते समय जनरेट हुई फ़ाइल में मौजूद कई एंट्री से जुड़े होते हैं.

एसडीके जनरेट करने की प्रोसेस शुरू करना

connectorId: movies
generate:
  kotlinSdk:
    outputDir: ../../../src/main/java/com/myapplication
    package: com.myapplication

outputDir को उस डायरेक्ट्री के पाथ से बदलें जिसमें जनरेट किया गया कोड रखा जाएगा. यह पाथ, उस डायरेक्ट्री के हिसाब से होता है जिसमें connector.yaml फ़ाइल मौजूद होती है. जनरेट की गई फ़ाइलों में इस्तेमाल किए जाने वाले Kotlin पैकेज स्टेटमेंट के साथ package को बदलें. इसके अलावा, डिफ़ॉल्ट पैकेज का इस्तेमाल करने के लिए, package को हटाएं.

प्रोटोटाइपिंग के दौरान एसडीके अपडेट करना

अगर Data Connect VS Code एक्सटेंशन और इसके Data Connect एम्युलेटर की मदद से इंटरैक्टिव प्रोटोटाइपिंग की जा रही है, तो स्कीमा, क्वेरी, और म्यूटेशन तय करने वाली .gql फ़ाइलों में बदलाव करते समय, एसडीके की सोर्स फ़ाइलें अपने-आप जनरेट और अपडेट हो जाती हैं. यह सुविधा, हॉट (री)लोडिंग वर्कफ़्लो में मददगार हो सकती है.

इसके अलावा, .gql फ़ाइलों में बदलाव होने पर, SDK टूल को फिर से जनरेट करने के लिए, CLI का इस्तेमाल किया जा सकता है:

firebase dataconnect:sdk:generate --watch

इंटिग्रेशन और प्रोडक्शन रिलीज़ के लिए एसडीके जनरेट करना

कुछ मामलों में, जैसे कि सीआई टेस्ट के लिए प्रोजेक्ट सोर्स तैयार करते समय, बैच अपडेट के लिए Firebase सीएलआई को कॉल किया जा सकता है.

ऐसे मामलों में, firebase dataconnect:sdk:generate का इस्तेमाल करें.

क्लाइंट कोड सेट अप करना

अपने क्लाइंट कोड में Data Connect को शामिल करें

Data Connect और जनरेट किए गए SDK टूल का इस्तेमाल करने के लिए, क्लाइंट कोड सेट अप करने के लिए, सबसे पहले Firebase के स्टैंडर्ड सेटअप से जुड़े निर्देशों का पालन करें.

इसके बाद, app/build.gradle.kts में मौजूद plugins सेक्शन में यह जानकारी जोड़ें:

// The Firebase team tests with version 1.8.22; however, other 1.8 versions,
// and all newer versions are expected work too.
kotlin("plugin.serialization") version "1.8.22" // MUST match the version of the Kotlin compiler

इसके बाद, app/build.gradle.kts में मौजूद dependencies सेक्शन में यह जानकारी जोड़ें:

implementation(platform("com.google.firebase:firebase-bom:34.0.0"))
implementation("com.google.firebase:firebase-dataconnect")
implementation("com.google.firebase:firebase-auth") // Optional
implementation("com.google.firebase:firebase-appcheck") // Optional
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3") // Newer versions should work too
implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1") // Newer versions should work too

Data Connect Android SDK टूल को शुरू करना

डेटा कनेक्ट को सेट अप करने के लिए इस्तेमाल की गई जानकारी का इस्तेमाल करके, अपने Data Connect इंस्टेंस को शुरू करें. यह जानकारी, Data Connect कंसोल के डेटा कनेक्ट टैब में उपलब्ध है.Firebase

ConnectorConfig ऑब्जेक्ट

SDK को कनेक्टर कॉन्फ़िगरेशन ऑब्जेक्ट की ज़रूरत होती है.

यह ऑब्जेक्ट, dataconnect.yaml में serviceId और location से अपने-आप जनरेट होता है. साथ ही, connector.yaml में connectorId से जनरेट होता है.

कनेक्टर इंस्टेंस पाना

कॉन्फ़िगरेशन ऑब्जेक्ट सेट अप करने के बाद, Data Connect कनेक्टर का इंस्टेंस पाएं. आपके कनेक्टर का कोड, Data Connect एम्युलेटर जनरेट करेगा. अगर आपके कनेक्टर का नाम movies है और Kotlin पैकेज com.myapplication है, जैसा कि connector.yaml में बताया गया है, तो कनेक्टर ऑब्जेक्ट को इस तरीके से कॉल करके वापस पाएं:

val connector = com.myapplication.MoviesConnector.instance

अपने Android SDK टूल से क्वेरी और म्यूटेशन का इस्तेमाल करना

कनेक्टर ऑब्जेक्ट की मदद से, GraphQL सोर्स कोड में तय की गई क्वेरी और म्यूटेशन चलाए जा सकते हैं. मान लें कि आपके कनेक्टर में ये कार्रवाइयां तय की गई हैं:

mutation createMovie($title: String!, $releaseYear: Int!, $genre: String!, $rating: Int!) {
  movie_insert(data: {
    title: $title
    releaseYear: $releaseYear
    genre: $genre
    rating: $rating
  })
}

query getMovieByKey($key: Movie_Key!) {
  movie(key: $key) { id title }
}

query listMoviesByGenre($genre: String!) {
  movies(where: {genre: {eq: $genre}}) {
    id
    title
  }
}

इसके बाद, इस तरह से मूवी बनाई और वापस पाई जा सकती है:

val connector = MoviesConnector.instance

val addMovieResult1 = connector.createMovie.execute(
  title = "Empire Strikes Back",
  releaseYear = 1980,
  genre = "Sci-Fi",
  rating = 5
)

val movie1 = connector.getMovieByKey.execute(addMovieResult1.data.key)

println("Empire Strikes Back: ${movie1.data.movie}")

एक से ज़्यादा फ़िल्में भी वापस लाई जा सकती हैं:

val connector = MoviesConnector.instance

val addMovieResult2 = connector.createMovie.execute(
  title="Attack of the Clones",
  releaseYear = 2002,
  genre = "Sci-Fi",
  rating = 5
)

val listMoviesResult = connector.listMoviesByGenre.execute(genre = "Sci-Fi")

println(listMoviesResult.data.movies)

आपके पास ऐसा Flow इकट्ठा करने का विकल्प भी होता है जो सिर्फ़ तब नतीजा देगा, जब क्वेरी के execute() तरीके को कॉल करके, क्वेरी का नया नतीजा वापस पाया जाएगा.

val connector = MoviesConnector.instance

connector.listMoviesByGenre.flow(genre = "Sci-Fi").collect { data ->
  println(data.movies)
}

connector.createMovie.execute(
  title="A New Hope",
  releaseYear = 1977,
  genre = "Sci-Fi",
  rating = 5
)

connector.listMoviesByGenre.execute(genre = "Sci-Fi") // will cause the Flow to get notified

गिनती वाले फ़ील्ड में हुए बदलावों को हैंडल करना

किसी ऐप्लिकेशन के स्कीमा में गिनती की जानकारी शामिल हो सकती है. इसे आपकी GraphQL क्वेरी ऐक्सेस कर सकती हैं.

ऐप्लिकेशन के डिज़ाइन में बदलाव होने पर, इस्तेमाल की जा सकने वाली नई enum वैल्यू जोड़ी जा सकती हैं. उदाहरण के लिए, मान लें कि ऐप्लिकेशन के लाइफ़साइकल में बाद में, आपने AspectRatio enum में FULLSCREEN वैल्यू जोड़ने का फ़ैसला किया.

Data Connect वर्कफ़्लो में, स्थानीय डेवलपमेंट टूलिंग का इस्तेमाल करके अपनी क्वेरी और एसडीके अपडेट किए जा सकते हैं.

हालांकि, क्लाइंट के अपडेट किए गए वर्शन को रिलीज़ करने से पहले, हो सकता है कि पहले से डिप्लॉय किए गए क्लाइंट काम न करें.

रीसाइलेंट तरीके से लागू करने का उदाहरण

जनरेट किया गया एसडीके, अज्ञात वैल्यू को हैंडल करने के लिए मजबूर करता है, क्योंकि ग्राहक के कोड को EnumValue ऑब्जेक्ट को अनरैप करना होगा. यह ऑब्जेक्ट, जानी-पहचानी enum वैल्यू के लिए EnumValue.Known या अज्ञात वैल्यू के लिए EnumValue.Unknown होता है.

val result = connector.listMoviesByAspectRatio.execute(AspectRatio.WIDESCREEN)
val encounteredAspectRatios = mutableSetOf<String>()

result.data.movies
  .mapNotNull { it.otherAspectRatios }
  .forEach { otherAspectRatios ->
    otherAspectRatios
      .filterNot { it.value == AspectRatio.WIDESCREEN }
      .forEach {
        when (it) {
          is EnumValue.Known -> encounteredAspectRatios.add(it.value.name)
          is EnumValue.Unknown ->
            encounteredAspectRatios.add("[unknown ratio: ${it.stringValue}]")
        }
      }
  }

println(
  "Widescreen movies also include additional aspect ratios: " +
    encounteredAspectRatios.sorted().joinToString()
)

अपने Android ऐप्लिकेशन का प्रोटोटाइप बनाना और उसकी जांच करना

लोकल एम्युलेटर का इस्तेमाल करने के लिए क्लाइंट को इंस्ट्रूमेंट करना

Data Connect एम्युलेटर का इस्तेमाल किया जा सकता है. इसे Data Connect VS Code एक्सटेंशन या सीएलआई से ऐक्सेस किया जा सकता है.

ऐप्लिकेशन को एम्युलेटर से कनेक्ट करने के लिए, दोनों ही स्थितियों में एक ही तरीका इस्तेमाल किया जाता है.

val connector = MoviesConnector.instance

// Connect to the emulator on "10.0.2.2:9399"
connector.dataConnect.useEmulator()

// (alternatively) if you're running your emulator on non-default port:
connector.dataConnect.useEmulator(port = 9999)

// Make calls from your app

प्रोडक्शन रिसॉर्स पर स्विच करने के लिए, एम्युलेटर से कनेक्ट करने वाली लाइनों को टिप्पणी के तौर पर मार्क करें.

Data Connect SDK टूल में डेटा टाइप

Data Connect सर्वर, सामान्य और कस्टम GraphQL डेटा टाइप दिखाता है. इन्हें एसडीके में इस तरह दिखाया जाता है.