Gli SDK client di Firebase Data Connect ti consentono di chiamare le query e le mutazioni lato server direttamente da un'app Firebase. Generi un SDK client personalizzato in parallelo durante la progettazione degli schemi, delle query e delle mutazioni da eseguire nel servizio Data Connect. Quindi, puoi integrare i metodi di questo SDK nella logica del client.
Come accennato altrove, è importante notare che le query e le mutazioni Data Connect non vengono inviate dal codice client ed eseguite sul server. Al contrario, quando vengono di cui è stato eseguito il deployment, le operazioni Data Connect vengono memorizzate sul server come Cloud Functions. Ciò significa che devi implementare le modifiche lato client corrispondenti per evitare di interrompere gli utenti esistenti (ad esempio, nelle versioni precedenti dell'app).
Per questo motivo, Data Connect fornisce un ambiente di sviluppo e strumenti che ti consentono di realizzare il prototipo di schemi, query e mutazioni di cui è stato eseguito il deployment sul server. Inoltre, genera automaticamente gli SDK lato client durante la creazione del prototipo.
Una volta eseguite le iterazioni degli aggiornamenti delle app di servizio e client, gli aggiornamenti sia lato server sia lato client sono pronti per il deployment.
Generare l'SDK Kotlin
Come per la maggior parte dei progetti Firebase, il codice clientFirebase Data Connect viene modificato in una directory del progetto locale. Sia l'estensione VS Code di Data Connect sia la CLI di Firebase sono importanti strumenti locali per la generazione e la gestione del codice client.
Le opzioni di generazione dell'SDK sono associate a diverse voci nel file dataconnect.yaml
generato al momento dell'inizializzazione del progetto.
Inizializza la generazione dell'SDK
Inconnector.yaml
, aggiungi outputDir
, package
e (per l'SDK web)packageJsonDir
.
connectorId: movies
generate:
kotlinSdk:
outputDir: ../../../src/main/java/com/myapplication
package: com.myapplication
Sostituisci outputDir
con il percorso della directory in cui verrà inserito il codice generato. Questo percorso è relativo alla directory che contiene il file connector.yaml
stesso. Sostituisci package
con l'istruzione del pacchetto Kotlin da utilizzare nei file generati oppure ometti package
per utilizzare un pacchetto predefinito.
Aggiornare gli SDK durante la prototipazione
Se stai creando una prototipazione in modo interattivo con l'estensione VS Code di Data Connect e il relativo emulatore Data Connect, i file di codice sorgente dell'SDK vengono generati e aggiornati automaticamente mentre modifichi i file Data Connect che definiscono schemi, query e mutazioni. Questa può essere una funzionalità utile nei flussi di lavoro di (ri)caricamento a caldo.
In altri scenari, se utilizzi l'emulatore Data Connect dall'interfaccia a riga di comando Firebase, puoi impostare una sorveglianza sugli aggiornamenti di.gql
e anche aggiornare automaticamente le sorgenti SDK.
In alternativa, puoi utilizzare la CLI per rigenerare gli SDK ogni volta che i file .gql vengono modificati:
firebase dataconnect:sdk:generate --watch
Genera SDK per l'integrazione e per le release di produzione
In alcuni scenari, ad esempio per preparare le origini del progetto da inviare per i test CI, puoi chiamare la CLI Firebase per un aggiornamento collettivo.
In questi casi, utilizza firebase dataconnect:sdk:generate
.
Configura il codice client
Incorporare Data Connect nel codice client
Per configurare il codice client in modo da utilizzare Data Connect e l'SDK generato, segui prima le istruzioni di configurazione standard di Firebase.
Aggiungi poi quanto segue alla sezione plugins
in
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
Aggiungi poi quanto segue alla sezione dependencies
in
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
Inizializza l'SDK Android Data Connect
Inizializza l'istanza Data Connect utilizzando le informazioni che hai utilizzato per configurare Data Connect (tutte disponibili nella scheda Data Connect della console Firebase).
Oggetto ConnectorConfig
L'SDK richiede un oggetto di configurazione del connettore.
Questo oggetto viene generato automaticamente da serviceId
e location
in dataconnect.yaml
e da connectorId
in connector.yaml
.
Ottenere un'istanza del connettore
Ora che hai configurato un oggetto di configurazione, ottieni un'istanza del connettore Data Connect. Il codice per il connettore verrà generato dall'emulatore Data Connect. Se il nome del connettore è movies
e il pacchetto Kotlin è com.myapplication
, come specificato in connector.yaml
, recupera l'oggetto connettore chiamando:
val connector = com.myapplication.MoviesConnector.instance
Eseguire query e mutazioni
Con l'oggetto connettore, puoi eseguire query e mutazioni come definito nel codice sorgente di GraphQL. Supponiamo che il connettore abbia definito queste operazioni:
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
}
}
puoi creare e recuperare un filmato nel seguente modo:
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}")
Puoi anche recuperare più film:
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)
Puoi anche raccogliere un Flow
che produrrà un risultato solo quando viene recuperato un nuovo risultato della query utilizzando una chiamata al metodo execute()
della query.
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
Creare un prototipo e testare l'applicazione per Android
Strumenta i client per utilizzare un emulatore locale
Puoi utilizzare l'emulatore Data Connect dall'estensione VS Code di Data Connect o dalla CLI.
La strumentazione dell'app per la connessione all'emulatore è la stessa per entrambi gli scenari.
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
Per passare alle risorse di produzione, commenta le righe per la connessione all'emulatore.
Tipi di dati negli SDK Data Connect
Il server Data Connect rappresenta i tipi di dati GraphQL comuni e personalizzati. Questi sono rappresentati nell'SDK come segue.
Tipo di Data Connect | Kotlin |
---|---|
Stringa | Stringa |
Int | Int (32 bit) |
In virgola mobile | Doppia (valore in virgola mobile a 64 bit) |
Booleano | Booleano |
UUID | java.util.UUID |
Data | java.util.Date |
Timestamp | com.google.firebase.Timestamp |
Int64 | Lungo |
Qualsiasi | com.google.firebase.dataconnect.AnyValue |