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 del 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 del cliente.
En resumen, para usar los SDKs de Android generados en tus apps de cliente, debes seguir estos pasos de requisitos previos:
- Agrega Firebase a tu app para Android.
- Configura Data Connect como una dependencia en Gradle.
- Agrega el complemento de Gradle de serialización de Kotlin y la dependencia de Gradle.
Luego:
- Desarrolla el esquema de tu app.
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
Inicializa tu código de cliente y bibliotecas de importación.
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 debe 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 --watchGenera 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:generateConfigura 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.
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()
)
Habilita el almacenamiento en caché del cliente
Data Connect tiene una función opcional de almacenamiento en caché del cliente, que puedes
habilitar editando el archivo connector.yaml. Cuando se habilita esta función, los SDKs de cliente generados almacenan en caché de forma local las respuestas de las consultas, lo que puede reducir la cantidad de solicitudes de base de datos que realiza tu app y permite que las partes de la app que dependen de la base de datos funcionen cuando se interrumpe la disponibilidad de la red.
Para habilitar el almacenamiento en caché del cliente, agrega una configuración de almacenamiento en caché del cliente a la configuración del conector:
generate:
kotlinSdk:
outputDir: "../android"
package: "com.google.firebase.dataconnect.generated"
clientCache:
maxAge: 5s
storage: persistent
Esta configuración tiene dos parámetros, ambos opcionales:
maxAge: Es la antigüedad máxima que puede tener una respuesta almacenada en caché antes de que el SDK de cliente recupere valores nuevos. Ejemplos: "0", "30s", "1h30m".El valor predeterminado de
maxAgees0, lo que significa que las respuestas se almacenan en caché, pero el SDK de cliente siempre recuperará valores nuevos. Los valores almacenados en caché solo se usarán cuando se especifiqueCACHE_ONLYenexecute().storage: El SDK de cliente se puede configurar para almacenar en caché las respuestas en el almacenamientopersistento en lamemory. Los resultados almacenados en caché en el almacenamientopersistentse conservarán entre los reinicios de la app. En los SDKs de Android, el valor predeterminado espersistent.
Después de actualizar la configuración de almacenamiento en caché del conector, vuelve a generar los SDKs de cliente
y vuelve a compilar tu app. Una vez que lo hagas, execute()
almacenará en caché
las respuestas y usará los valores almacenados en caché según la política que configuraste. Por lo general, esto sucede automáticamente, sin que tengas que realizar ningún paso adicional. Sin embargo, ten en cuenta lo siguiente:
El comportamiento predeterminado de
execute()es el que se describió anteriormente: si un resultado se almacena en caché para una consulta y el valor almacenado en caché no es más antiguo quemaxAge, usa el valor almacenado en caché. Este comportamiento predeterminado se denomina políticaPREFER_CACHE.También puedes especificar invocaciones individuales de
execute()para que solo entreguen valores almacenados en caché (CACHE_ONLY) o para recuperar valores nuevos del servidor de forma incondicional (SERVER_ONLY).val queryResult = queryRef.execute(QueryRef.FetchPolicy.CACHE_ONLY)val queryResult = queryRef.execute(QueryRef.FetchPolicy.SERVER_ONLY)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 en 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 appPara 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 (número de 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