Cómo usar los SDKs de Android generados

Los SDK de cliente de Firebase Data Connect te permiten llamar a tus consultas y mutaciones del servidor directamente desde una app de Firebase. Generas un SDK de cliente personalizado en paralelo mientras diseñas los esquemas, las consultas y las mutaciones que implementas en tu Data Connect servicio. Luego, integras métodos de este SDK en tu lógica de cliente.

Como mencionamos en otro lugar, es importante tener en cuenta que el código de cliente no envía las Data Connect consultas y mutaciones, y que estas no se ejecutan en el servidor. En cambio, cuando se implementan, las operaciones Data Connect se almacenan en el servidor como Cloud Functions. Esto significa que debes implementar los cambios correspondientes del cliente para evitar interrumpir a los usuarios existentes (por ejemplo, en versiones anteriores de la app).

Por eso, Data Connect te proporciona un entorno de desarrollo y herramientas que te permiten crear prototipos de tus esquemas, consultas y mutaciones implementados en el servidor. También genera SDKs de cliente automáticamente mientras creas prototipos.

Cuando hayas iterado las actualizaciones de tu servicio y las apps de cliente, las actualizaciones del servidor y del cliente estarán listas para implementarse.

¿Cuál es el flujo de trabajo de desarrollo de cliente?

Si seguiste la guía de introducción, conociste el flujo de desarrollo general de Data Connect. En esta guía, encontrarás información más detallada sobre la generación de SDKs de Android a partir de tu esquema y el trabajo con consultas y mutaciones de cliente.

Puedes aprender el desarrollo de cliente con un repositorio de apps de inicio rápido y compilar una app con todas las funciones siguiendo nuestro codelab para Android.Data Connect

En resumen, para usar los SDKs de Android generados en tus apps de cliente, debes seguir estos pasos de requisitos previos:

1. Agrega Firebase a tu app para Android.
2. Configura Data Connect como una dependencia en Gradle.
3. Agrega el complemento de Gradle de serialización de Kotlin y la dependencia de Gradle.

Luego:

1. Desarrolla el esquema de tu app.

2. Configura la generación del SDK:

   • Con el botón Add SDK to app en nuestra extensión de Data Connect para VS Code
   • Actualizando tu connector.yaml

3. Inicializa tu código de cliente y las bibliotecas de importación.

4. Implementa llamadas a consultas y mutaciones.

5. Configura y usa el emulador Data Connect y realiza iteraciones.

Genera tu SDK de Kotlin

Usa el Firebase CLI para configurar los Data Connect generados SDKs en tus apps. El comando init debería detectar todas las apps en la carpeta actual y, luego, instalar los SDKs generados automáticamente.

firebase init dataconnect:sdk

Actualiza los SDKs mientras creas prototipos

Si tienes instalada la extensión de Data Connect para VS Code, siempre mantendrá actualizados los SDKs generados.

Si no usas la extensión de Data Connect para VS Code, puedes usar Firebase CLI para mantener actualizados los SDKs generados.

firebase dataconnect:sdk:generate --watch

Genera SDKs en canalizaciones de compilación

Puedes usar Firebase CLI para generar Data Connect SDKs en procesos de compilación de CI/CD.

firebase dataconnect:sdk:generate

Configura el código de cliente

Incorpora Data Connect en tu código de cliente

Para configurar tu código de cliente para usar Data Connect y tu SDK generado, primero sigue las instrucciones de configuración estándar de Firebase.

Luego, agrega lo siguiente a la sección plugins en 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

Luego, agrega lo siguiente a la sección dependencies en app/build.gradle.kts:

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

Inicializa el SDK de Android Data Connect

Inicializa tu Data Connect instancia con la información que usaste para configurar Data Connect (todo disponible en la Firebase console Data Connect tab).

El objeto ConnectorConfig

El SDK requiere un objeto de configuración del conector.

Este objeto se genera automáticamente a partir de serviceId y location en dataconnect.yaml, y connectorId en connector.yaml.

Obtén una instancia de conector

Ahora que configuraste un objeto de configuración, obtén una instancia de Data Connect conector. El emulador Data Connect generará el código de tu conector. Si el nombre del conector es movies y el paquete de Kotlin es com.myapplication, como se especifica en connector.yaml, recupera el objeto del conector llamando a:

val connector = com.myapplication.MoviesConnector.instance

Usa consultas y mutaciones desde tu SDK de Android

Con el objeto del conector, puedes ejecutar consultas y mutaciones como se define en el código fuente de GraphQL. Supongamos que tu conector tiene definidas estas operaciones:

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
  }
}

Luego, puedes crear y recuperar una película de la siguiente manera:

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}")

También puedes recuperar varias películas:

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)

También puedes recopilar un Flow que solo producirá un resultado cuando se recupere un resultado de consulta nuevo con una llamada al método execute() de la consulta.

Nota: Este flujo no se actualiza en tiempo real.

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

Controla los cambios en los campos de enumeración

El esquema de una app puede contener enumeraciones, a las que pueden acceder tus consultas de GraphQL.

A medida que cambia el diseño de una app, puedes agregar nuevos valores compatibles con enum. Por ejemplo, imagina que, más adelante en el ciclo de vida de tu aplicación, decides agregar un valor FULLSCREEN a la enumeración AspectRatio.

En el flujo de trabajo Data Connect, puedes usar herramientas de desarrollo local para actualizar tus consultas y SDKs.

Sin embargo, antes de lanzar una versión actualizada de tus clientes, es posible que los clientes implementados más antiguos se interrumpan.

Ejemplo de implementación resistente

El SDK generado fuerza el control de valores desconocidos, ya que el código del cliente debe desenvolver el objeto EnumValue, que es EnumValue.Known para valores de enumeración conocidos o EnumValue.Unknown para valores desconocidos.

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()
)

Crea prototipos y prueba tu aplicación para Android

Instrumenta clientes para usar un emulador local

Puedes usar el Data Connect emulador, ya sea desde la extensión de Data Connect para VS Code o desde la CLI.

La instrumentación de la app para conectarse al emulador es la misma para ambos casos.

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

Para cambiar a los recursos de producción, comenta las líneas para conectarte al emulador.

Tipos de datos en los Data Connect SDKs

El servidor Data Connect representa tipos de datos de GraphQL comunes y personalizados. Estos se representan en el SDK de la siguiente manera.

Data Connect Tipo	Kotlin
String	String
Int	Int (número entero de 32 bits)
Float	Double (punto flotante de 64 bits)
Boolean	Boolean
UUID	java.util.UUID
Date	com.google.firebase.dataconnect.LocalDate (era java.util.Date hasta la versión 16.0.0-beta03)
Timestamp	com.google.firebase.Timestamp
Int64	Long
Any	com.google.firebase.dataconnect.AnyValue