Utiliser les SDK Android générés

Les SDK client Firebase Data Connect vous permettent d'appeler vos requêtes et mutations côté serveur directement depuis une application Firebase. Vous générez un SDK client personnalisé en parallèle de la conception des schémas, des requêtes et des mutations que vous déployez sur votre service Firebase Data Connect.Data Connect Ensuite, vous intégrez les méthodes de ce SDK dans votre logique client.

Comme nous l'avons mentionné 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 ne sont pas exécutées sur le serveur. En revanche, une fois déployées, les opérations Data Connect sont stockées sur le serveur, comme 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 de développement et des outils 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 que vous créez votre prototype.

Une fois que vous avez effectué des mises à jour itératives de vos applications de service et client, les mises à jour côté serveur et côté client sont prêtes à être déployées.

Qu'est-ce que le workflow de développement client ?

Si vous avez suivi la section Premiers pas, vous avez découvert le flux de développement global pour Data Connect. Dans ce guide, vous trouverez des informations plus détaillées sur la génération de SDK Android à partir de votre schéma, ainsi que sur l'utilisation des requêtes et des mutations client.

En résumé, pour utiliser les SDK Android générés dans vos applications clientes, vous devez suivre les étapes préalables suivantes :

1. Ajoutez Firebase à votre application Android.
2. Configurez Data Connect en tant que dépendance dans Gradle.
3. Ajoutez le plug-in Gradle de sérialisation Kotlin et la dépendance Gradle.

Puis :

1. Développez le schéma de votre application.

2. Configurez la génération du SDK :

   • Avec le bouton Ajouter le SDK à l'application de notre extension VS Code Data Connect
   • En mettant à jour votre connector.yaml

3. Initialisez votre code client et importez les bibliothèques.

4. Implémentez les appels aux requêtes et aux mutations.

5. Configurez et utilisez l'émulateur Data Connect, puis itérez.

Générer votre SDK Kotlin

Comme pour la plupart des projets Firebase, le code client Firebase Data Connect est développé dans un répertoire de projet local. L'extension VS Code Data Connect et la CLI Firebase sont des outils locaux importants pour générer et gérer le code client.

Les options de génération du SDK sont associées à plusieurs entrées du fichier dataconnect.yaml généré lors de l'initialisation de votre projet.

Initialiser la génération du SDK

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 créez des prototypes de manière interactive avec l'extension VS Code Data Connect 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 définissant les schémas, les requêtes et les mutations. Cette fonctionnalité peut être utile dans les workflows de rechargement à chaud.

Vous pouvez également utiliser l'interface de ligne de commande pour régénérer les SDK chaque fois que des fichiers .gql sont modifiés :

firebase dataconnect:sdk:generate --watch

Générez des SDK pour l'intégration et pour les versions de production.

Dans certains cas, par exemple lorsque vous préparez des sources de projet à envoyer pour des tests CI, vous pouvez appeler l'interface de ligne de commande Firebase pour une mise à jour par lot.

Dans ce cas, utilisez firebase dataconnect:sdk:generate.

Configurer le code client

Intégrer Data Connect dans votre code client

Pour configurer votre code client afin d'utiliser Data Connect et votre SDK généré, commencez par suivre les instructions de configuration Firebase standards.

Ajoutez ensuite les éléments suivants à 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 les éléments suivants à la section dependencies de app/build.gradle.kts :

implementation(platform("com.google.firebase:firebase-bom:33.16.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

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 spécifié dans connector.yaml, récupérez l'objet du connecteur en appelant :

val connector = com.myapplication.MoviesConnector.instance

Utiliser des requêtes et des mutations à partir de votre SDK Android

L'objet de connecteur vous permet d'exécuter des requêtes et des mutations telles qu'elles sont définies dans le code source GraphQL. Supposons que votre connecteur comporte les opérations suivantes :

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

Prototyper 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 se 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, mettez en commentaire les lignes de connexion à 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. Elles sont représentées dans le SDK comme suit.