Usar SDKs do Android gerados

Com os SDKs do cliente do Firebase Data Connect, é possível chamar consultas e mutações do lado do servidor diretamente de um app do Firebase. Você gera um SDK do cliente personalizado em paralelo ao projetar os esquemas, as consultas e as mutações que implanta no seu serviço Data Connect. Em seguida, integre métodos desse SDK à lógica do cliente.

Como mencionamos em outro lugar, é importante observar que as consultas e mutações não são enviadas pelo código do cliente e executadas no servidor.Data Connect Em vez disso, quando implantadas, as operações Data Connect são armazenadas no servidor, como o Cloud Functions. Isso significa que você precisa implantar as mudanças correspondentes do lado do cliente para evitar falhas nos usuários atuais (por exemplo, em versões mais antigas do app).

Por isso, o Data Connect oferece um ambiente de desenvolvimento e ferramentas que permitem criar protótipos de esquemas, consultas e mutações implantados no servidor. Ele também gera SDKs do lado do cliente automaticamente enquanto você cria protótipos.

Depois de iterar as atualizações nos apps de serviço e cliente, as atualizações do lado do servidor e do cliente estarão prontas para implantação.

Qual é o fluxo de trabalho de desenvolvimento do cliente?

Se você seguiu os Primeiros passos, conheceu o fluxo geral de desenvolvimento do Data Connect. Neste guia, você encontra informações mais detalhadas sobre como gerar SDKs do Android com base no seu esquema e trabalhar com consultas e mutações do cliente.

Aprenda desenvolvimento de clientes com um repositório de apps de início rápido e crie um app Data Connect completo seguindo nosso codelab para Android.

Resumindo, para usar os SDKs do Android gerados nos seus apps cliente, siga estas etapas de pré-requisito:

1. Adicione o Firebase ao seu app Android.
2. Configure Data Connect como uma dependência no Gradle.
3. Adicione o plug-in do Gradle e a dependência do Gradle para a serialização do Kotlin.

Depois, siga estas instruções:

1. Desenvolva o esquema do app.

2. Configure a geração de SDKs:

   • Com o botão Adicionar SDK ao app na extensão Data Connect do VS Code
   • Atualize seu connector.yaml

3. Inicialize o código do cliente e importe as bibliotecas.

4. Implemente chamadas para consultas e mutações.

5. Configure e use o emulador Data Connect e faça iterações.

Gerar seu SDK Kotlin

Como na maioria dos projetos do Firebase, o trabalho no código do cliente Firebase Data Connect acontece em um diretório de projeto local. A extensão do Data Connect VS Code e a CLI Firebase são ferramentas locais importantes para gerar e gerenciar código do cliente.

As opções de geração do SDK são associadas a várias entradas no arquivo dataconnect.yaml gerado quando você inicializou o projeto.

Inicializar a geração de SDK

No seu connector.yaml, adicione outputDir, package e (para o SDK da Web) packageJsonDir.

connectorId: movies
generate:
  kotlinSdk:
    outputDir: ../../../src/main/java/com/myapplication
    package: com.myapplication

Substitua outputDir pelo caminho do diretório em que o código gerado será colocado. Esse caminho é relativo ao diretório que contém o arquivo connector.yaml. Substitua package pela instrução do pacote Kotlin a ser usada nos arquivos gerados ou omita package para usar um pacote padrão.

Observação: o Data Connect gera um pacote padrão com um nome derivado do ID do conector.

Observação: é possível fornecer um caminho absoluto para diretórios se o projeto estiver configurado em uma estrutura de diretório separada.

Atualizar SDKs durante a criação de protótipos

Se você estiver criando protótipos interativamente com a extensão Data Connect do VS Code e o emulador Data Connect, os arquivos de origem do SDK serão gerados e atualizados automaticamente enquanto você modifica os arquivos .gql que definem esquemas, consultas e mutações. Esse pode ser um recurso útil em fluxos de trabalho de recarga (automática) dinâmica.

Em outros cenários, se você estiver usando o emulador Data Connect da CLI Firebase, poderá definir um monitoramento nas atualizações do .gql e também ter fontes do SDK atualizadas automaticamente.

Como alternativa, use a CLI para regenerar os SDKs sempre que os arquivos .gql forem alterados:

firebase dataconnect:sdk:generate --watch

Gerar SDKs para integração e para versões de produção

Em alguns casos, como ao preparar fontes de projetos para enviar para testes de CI, você pode chamar a CLI Firebase para uma atualização em lote.

Nesses casos, use firebase dataconnect:sdk:generate.

Configurar o código do cliente

Incorpore Data Connect ao código do cliente

Para configurar seu código do cliente para usar Data Connect e o SDK gerado, siga primeiro as instruções de configuração padrão do Firebase.

Em seguida, adicione o seguinte à seção plugins em 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

Em seguida, adicione o seguinte à seção dependencies em 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

Inicializar o SDK do Android Data Connect

Inicialize sua instância Data Connect usando as informações que você usou para configurar o Data Connect (tudo disponível na guia "Data Connect" do console Firebase).

O objeto ConnectorConfig

O SDK exige um objeto de configuração do conector.

Esse objeto é gerado automaticamente de serviceId e location em dataconnect.yaml, e connectorId em connector.yaml.

Como conseguir uma instância de conector

Agora que você configurou um objeto de configuração, receba uma instância de conector Data Connect. O código do conector será gerado pelo emulador Data Connect. Se o nome do conector for movies e o pacote Kotlin for com.myapplication, conforme especificado em connector.yaml, recupere o objeto do conector chamando:

val connector = com.myapplication.MoviesConnector.instance

Usar consultas e mutações do SDK do Android

Com o objeto conector, é possível executar consultas e mutações conforme definido no código-fonte GraphQL. Suponha que seu conector tenha estas operações definidas:

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

então você pode criar e recuperar um filme da seguinte maneira:

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

Você também pode recuperar vários filmes:

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)

Também é possível coletar um Flow que só produzirá um resultado quando um novo resultado de consulta for recuperado usando uma chamada para o método execute() da consulta.

Observação: esse fluxo não é atualizado em tempo 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

Criar protótipos e testar seu aplicativo Android

Instrumentar clientes para usar um emulador local

É possível usar o emulador Data Connect, seja na extensão do Data Connect para VS Code ou na CLI.

A instrumentação do app para se conectar ao emulador é a mesma nos dois cenários.

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 mudar para recursos de produção, comente as linhas de conexão com o emulador.

Tipos de dados nos SDKs Data Connect

O servidor Data Connect representa tipos de dados GraphQL comuns e personalizados. Elas são representadas no SDK da seguinte maneira.

Tipo de conexão de dados	Kotlin
String	String
Int	Int (número inteiro de 32 bits)
Ponto flutuante	Double (ponto flutuante de 64 bits)
Booleano	Booleano
UUID	java.util.UUID
Data	com.google.firebase.dataconnect.LocalDate (era java.util.Date até a versão 16.0.0-beta03)
Carimbo de data/hora	com.google.firebase.Timestamp
Int64	Longo
Qualquer	com.google.firebase.dataconnect.AnyValue