Inizia a utilizzare Firebase SQL Connect su Android

In questa guida rapida, creerai e implementerai un piccolo database di esempio e vi accederai da un'app per Android.

Prerequisiti

Per completare questa guida rapida, avrai bisogno di quanto segue:

  • Un ambiente con i seguenti strumenti installati:
  • Un Account Google.

Tutorial

Tutorial

1. Crea un nuovo progetto Android Studio

In Android Studio, crea un nuovo progetto con il modello Attività vuota.

Assegna al progetto il nome Quickstart App con il nome del pacchetto com.example.quickstartapp.

 Finestra di dialogo Nuovo progetto di Android Studio

2. Aggiungi Firebase al tuo progetto Android Studio

Aggiungi le dipendenze Firebase e il plug-in di serializzazione Kotlin ai file build.gradle.kts.

 QuickstartApp/build.gradle.kts 
plugins {
  alias(libs.plugins.android.application) apply false
  alias(libs.plugins.kotlin.compose) apply false

  // Add this line.
  id("com.google.gms.google-services") version "4.4.4" apply false
}
 QuickstartApp/app/build.gradle.kts 
plugins {
  alias(libs.plugins.android.application)
  alias(libs.plugins.kotlin.compose)

  // Add these lines.
  kotlin("plugin.serialization") version libs.versions.kotlin
  id("com.google.gms.google-services")
}

// ...

dependencies {
  // ...

  // Add these lines.
  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0")
  implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.11.0")

  implementation(platform("com.google.firebase:firebase-bom:34.14.0"))
  implementation("com.google.firebase:firebase-dataconnect")
}

3. Inizializzare un progetto Firebase

Passa alla directory del progetto Android Studio e inizializza un progetto Firebase al suo interno.

 
cd ~/QuickstartApp
 
firebase login --reauth
 
firebase init dataconnect

Quando richiesto, scegli le seguenti opzioni:

  • Crea un nuovo progetto Firebase.
  • Non creare uno schema con Gemini (in questo tutorial utilizzerai uno schema di esempio predefinito).
  • Esegui il provisioning di un'istanza e di un database di prova senza costi Cloud SQL.

Accetta i valori predefiniti per tutti gli altri prompt.

Poi, registra la tua app per Android nel progetto Firebase.

firebase apps:create -a com.example.quickstartapp android android-quickstart
 
firebase apps:sdkconfig android -o app/google-services.json

4. Esamina le definizioni GraphQL di esempio

In SQL Connect, definisci tutti gli schemi e le operazioni del database utilizzando GraphQL. Quando hai inizializzato il progetto, la CLI Firebase ha creato alcune definizioni di esempio per iniziare.

 dataconnect/schema/schema.gql (estratto) 
type Movie @table {
  title: String!
  imageUrl: String!
  genre: String
}

type MovieMetadata @table {
  movie: Movie! @unique
  rating: Float
  releaseYear: Int
  description: String
}
 dataconnect/example/queries.gql (estratto) 
query ListMovies @auth(level: PUBLIC) {
  movies {
    id
    title
    imageUrl
    genre
  }
}

5. Esegui il deployment di schemi e operazioni

Ogni volta che apporti modifiche agli schemi, alle query o alle mutazioni del database, devi eseguirne il deployment affinché le modifiche abbiano effetto sul database.

 
firebase deploy --only dataconnect

6. Inserisci dati di esempio nel database

Questi dati iniziali ti daranno qualcosa da esaminare quando testi l'app di esempio. Tieni presente che in questo passaggio esegui GraphQL arbitrario, consentito per le attività amministrative.

 
firebase dataconnect:execute dataconnect/seed_data.gql

7. Genera un SDK client Android

Questo comando utilizza le definizioni GraphQL per generare un SDK client Android specifico per il tuo database. Utilizzi questa libreria nell'app client per eseguire tutte le operazioni del database.

Puoi generare librerie per più piattaforme, tra cui Swift per iOS, JavaScript per il web e Flutter, aggiungendo definizioni a connector.yaml.

 
firebase dataconnect:sdk:generate
 SDK Android generato automaticamente (estratto) 
public interface ExampleConnector : GeneratedConnector<ExampleConnector> {
  override val dataConnect: com.google.firebase.dataconnect.FirebaseDataConnect

  public val listMovies: ListMoviesQuery

  // ...
}

8. Scrivi un client Android di esempio

Sostituisci i contenuti di app/src/main/java/com/example/sequel/MainActivity.kt con questa semplice app per Android.

Tieni presente che l'app completa l'accesso al database necessario utilizzando una funzione dell'SDK generato.

 
package com.example.quickstartapp

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import com.example.quickstartapp.ui.theme.QuickstartAppTheme
import com.google.firebase.dataconnect.generated.ExampleConnector
import com.google.firebase.dataconnect.generated.ListMoviesQuery
import com.google.firebase.dataconnect.generated.execute
import com.google.firebase.dataconnect.generated.instance

class MainActivity : ComponentActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    enableEdgeToEdge()
    setContent {
      QuickstartAppTheme() {
        Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
          var movies by remember {
            mutableStateOf(emptyList<ListMoviesQuery.Data.MoviesItem>())
          }
          LaunchedEffect(Unit) {
            // Queries need to be executed in a coroutine context
            try {
              movies = ExampleConnector.instance.listMovies.execute().data.movies
            } catch (e: Exception) {
              // TODO: Handle error, e.g., show a Toast or update a state variable to
              //   display an error message.
            }
          }
          LazyColumn(modifier = Modifier.padding(innerPadding)) {
            items(movies) { movie ->
              Text(text = movie.title)
            }
          }
        }
      }
    }
  }
}

9. Prova l'app

Da Android Studio, esegui l'app di esempio per vederla in azione.

Passaggi successivi

Prova l'estensione SQL Connect VS Code

Quando sviluppi con SQL Connect, ti consigliamo vivamente di utilizzare l'estensione SQL Connect VS Code. Anche se non utilizzi Visual Studio Code come ambiente di sviluppo principale, l'estensione offre diverse funzionalità che rendono più pratico lo sviluppo di schemi e operazioni:

  • Un server di linguaggio GraphQL che fornisce il controllo della sintassi e suggerimenti di completamento automatico specifici per SQL Connect
  • Pulsanti CodeLens in linea con il codice che ti consentono di leggere e scrivere dati dai file di definizione dello schema ed eseguire query e mutazioni dalle definizioni delle operazioni.
  • Mantieni sincronizzati automaticamente gli SDK generati con le definizioni GraphQL.
  • Configurazione semplificata dell'emulatore locale.
  • Deployment semplificato in produzione.

Utilizza l'emulatore SQL Connect per lo sviluppo locale

Anche se questo tutorial ti ha mostrato come eseguire il deployment di schemi e operazioni di SQL Connect direttamente in produzione, probabilmente non vorrai apportare modifiche al database di produzione mentre sviluppi attivamente la tua app. Configura invece l'emulatore SQL Connect e svolgi il lavoro di sviluppo su questo emulatore anziché sulla produzione. L'emulatore configura un'istanza PGlite locale che si comporta in modo simile a un'istanza PostgreSQL live su Cloud SQL.

Scopri come scrivere schemi e operazioni per la tua app

Quando sviluppi app con SQL Connect, la progettazione di schemi e operazioni è una delle prime e più importanti attività di sviluppo che completerai.

  • Gemini nella console Firebase è uno strumento di AI che può generare schemi SQL Connect da una descrizione in linguaggio naturale della tua app. Questo strumento può aiutarti a iniziare molto rapidamente, soprattutto se non hai mai lavorato con database relazionali.
  • In alternativa, puoi scrivere schemi di database, query e mutazioni direttamente utilizzando GraphQL. Inizia con le indicazioni riportate in Schemi SQL Connect, quindi continua a leggere le pagine successive per scoprire come scrivere le operazioni.