Les SDK client Firebase Data Connect vous permettent d'appeler vos requêtes et mutations côté serveur directement à partir d'une application Firebase. Vous générez un SDK client personnalisé en parallèle lorsque vous concevez les schémas, les requêtes et les mutations que vous déployez sur votre service Data Connect. Vous intégrez ensuite les méthodes de ce SDK dans votre logique client.
Comme nous l'avons indiqué ailleurs, il est important de noter que les requêtes et les mutations Data Connect ne sont pas envoyées par le code client et exécutées sur le serveur. Au lieu de cela, une fois déployées, les opérations Data Connect sont stockées sur le serveur, comme dans Cloud Functions. Cela signifie que vous devez déployer les modifications côté client correspondantes pour éviter de perturber les utilisateurs existants (par exemple, sur les anciennes versions de l'application).
C'est pourquoi Data Connect vous fournit un environnement et des outils de développement qui vous permettent de prototyper vos schémas, requêtes et mutations déployés sur le serveur. Il génère également automatiquement des SDK côté client pendant le prototypage.
Une fois que vous avez itéré les mises à jour de votre service et de vos applications clientes, les mises à jour côté serveur et côté client sont prêtes à être déployées.
Générer votre SDK Kotlin
Comme pour la plupart des projets Firebase, le travail sur le code client Firebase Data Connect se déroule dans un répertoire de projet local. L'extension VS Code Data Connect et la CLI Firebase sont tous deux des outils locaux importants pour générer et gérer le code client.
Les options de génération de SDK sont associées à plusieurs entrées dans le fichier dataconnect.yaml généré lorsque vous avez initialisé votre projet.
Initialiser la génération du SDK
Dans votreconnector.yaml, ajoutez outputDir, package et packageJsonDir (pour le SDK Web).
connectorId: movies
generate:
kotlinSdk:
outputDir: ../../../src/main/java/com/myapplication
package: com.myapplication
Remplacez outputDir par le chemin d'accès au répertoire dans lequel le code généré sera placé. Ce chemin est relatif au répertoire contenant le fichier connector.yaml lui-même. Remplacez package par l'instruction de package Kotlin à utiliser dans les fichiers générés, ou omettez package pour utiliser un package par défaut.
Mettre à jour les SDK lors du prototypage
Si vous effectuez un prototypage interactif avec l'extension Data Connect pour VS Code et son émulateur Data Connect, les fichiers sources du SDK sont automatiquement générés et mis à jour lorsque vous modifiez les fichiers .gql qui définissent les schémas, les requêtes et les mutations. Cette fonctionnalité peut s'avérer utile dans les workflows de (re)chargement à chaud.
.gql et mettre à jour automatiquement les sources du SDK.
Vous pouvez également utiliser la CLI pour regénérer les SDK chaque fois que des fichiers .gql sont modifiés :
firebase dataconnect:sdk:generate --watchGénérer des SDK pour les versions d'intégration et de production
Dans certains cas, par exemple lorsque vous préparez les sources de projet à envoyer pour les tests CI, vous pouvez appeler la CLI Firebase pour une mise à jour par lot.
Dans ce cas, utilisez firebase dataconnect:sdk:generate.
Configurer le code client
Intégrer Data Connect dans le code client
Pour configurer votre code client pour utiliser Data Connect et votre SDK généré, suivez d'abord les instructions de configuration standards de Firebase.
Ajoutez ensuite les éléments suivants dans la section plugins de app/build.gradle.kts :
// 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
Ajoutez ensuite le code suivant dans la section dependencies du fichier app/build.gradle.kts:
implementation("com.google.firebase:firebase-dataconnect:16.0.0-beta01")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1")
implementation("com.google.firebase:firebase-auth:23.1.0") // Optional
implementation("com.google.firebase:firebase-appcheck:18.0.0") // Optional
Initialiser le SDK Android Data Connect
Initialisez votre instance Data Connect à l'aide des informations que vous avez utilisées pour configurer Data Connect (toutes disponibles dans l'onglet "Data Connect" de la console Firebase).
Objet ConnectorConfig
Le SDK nécessite un objet de configuration du connecteur.
Cet objet est généré automatiquement à partir de serviceId et location dans dataconnect.yaml, et de connectorId dans connector.yaml.
Obtenir une instance de connecteur
Maintenant que vous avez configuré un objet de configuration, obtenez une instance de connecteur Data Connect. Le code de votre connecteur sera généré par l'émulateur Data Connect. Si le nom de votre connecteur est movies et que le package Kotlin est com.myapplication, comme indiqué dans connector.yaml, récupérez l'objet du connecteur en appelant:
val connector = com.myapplication.MoviesConnector.instance
Exécuter des requêtes et des mutations
Avec l'objet connecteur, vous pouvez exécuter des requêtes et des mutations comme défini dans le code source GraphQL. Supposons que les opérations suivantes soient définies pour votre connecteur :
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
}
}
Vous pouvez ensuite créer et récupérer un film comme suit :
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}")
Vous pouvez également récupérer plusieurs films :
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)
Vous pouvez également collecter un Flow qui ne produira un résultat que lorsqu'un nouveau résultat de requête sera récupéré à l'aide d'un appel à la méthode execute() de la requête.
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
Créer un prototype et tester votre application Android
Instrumenter les clients pour qu'ils utilisent un émulateur local
Vous pouvez utiliser l'émulateur Data Connect, que ce soit à partir de l'extension VS Code Data Connect ou de la CLI.
L'instrumentation de l'application pour la connecter à l'émulateur est la même dans les deux scénarios.
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
Pour passer aux ressources de production, commentez les lignes permettant de se connecter à l'émulateur.
Types de données dans les SDK Data Connect
Le serveur Data Connect représente les types de données GraphQL courants et personnalisés. Ils sont représentés dans le SDK comme suit.
| Type de connexion Data Connect | Kotlin |
|---|---|
| Chaîne | Chaîne |
| Int | Int (32 bits) |
| Float | Double (point flottant 64 bits) |
| Booléen | Booléen |
| UUID | java.util.UUID |
| Date | "java.util.Date" |
| Horodatage | com.google.firebase.Timestamp |
| Int64 | Long |
| Tous | com.google.firebase.dataconnect.AnyValue |