O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Como salvar dados com o Firebase Realtime Database para C++

Primeiros passos

Primeiro consulte o guia Get Started se ainda não tiver configurado o aplicativo e o acesso ao banco de dados.

Receber um DatabaseReference

Para gravar dados no Database, você precisa de uma instância de DatabaseReference:

    // Get the root reference location of the database.
    firebase::database::DatabaseReference dbref = database->GetReference();

Como salvar dados

Há quatro métodos para gravar dados no Firebase Realtime Database:

Método Usos comuns
SetValue() Gravar ou substituir dados em um caminho definido, como users/<user-id>/<username>.
PushChild() Adicione a uma lista de dados. Toda vez que você chama Push(), o Firebase gera uma chave exclusiva que também pode ser usada como um identificador exclusivo, como user-scores/<user-id>/<unique-score-id>.
UpdateChildren() Atualize algumas das chaves de um caminho definido sem substituir todos os dados.
RunTransaction() Atualizar dados complexos que podem ser corrompidos por atualizações simultâneas.

Gravar, atualizar ou excluir dados em uma referência

Operações básicas de gravação

Em operações básicas de gravação, use SetValue() para salvar dados em uma referência específica e substitua os dados existentes no caminho. Você pode usar esse método para passar os tipos aceitos pela JSON por um tipo Variant que seja compatível com:

  • null (isso exclui os dados)
  • números inteiros (64 bits)
  • números de ponto flutuante de precisão dupla
  • booleanos
  • strings
  • vetores de variantes
  • Mapas de strings para variantes

O uso de SetValue() dessa maneira substitui os dados no local especificado, incluindo qualquer nó filho. No entanto, ainda é possível atualizar um filho sem substituir o objeto inteiro. Para que os usuários atualizem os próprios perfis, atualize o nome deles desta forma:

dbref.Child("users").Child(userId).Child("username").SetValue(name);

Anexar a uma lista de dados

Use o método PushChild() para anexar dados a uma lista em aplicativos de vários usuários. O método PushChild() gera uma chave exclusiva sempre que um novo filho é adicionado a uma referência específica do Firebase. Ao usar essas chaves geradas automaticamente para cada novo elemento da lista, é possível que vários clientes adicionem filhos ao mesmo local simultaneamente sem criar conflitos de gravação. A chave exclusiva gerada por PushChild()é baseada em um carimbo de data/hora. Portanto, os itens da lista são organizados automaticamente em ordem cronológica.

Use a referência aos novos dados retornados pelo método PushChild() para receber o valor da chave filha que foi gerada automaticamente ou para definir dados para o filho. Chamar GetKey() em uma referência PushChild() retorna o valor da chave gerada automaticamente.

Atualizar campos específicos

Para gravar simultaneamente filhos específicos de um nó sem substituir outros nós filhos, use o método UpdateChildren().

Ao chamar UpdateChildren(), atualize valores de filhos de nível inferior ao especificar um caminho para a chave. Se os dados estiverem armazenados em vários locais para aprimorar a escalabilidade, atualize todas as instâncias usando a distribuição de dados. Por exemplo, um jogo pode ter uma classe LeaderboardEntry como esta:

class LeaderboardEntry {
  std::string uid;
  int score = 0;

 public:
  LeaderboardEntry() {
  }

  LeaderboardEntry(std::string uid, int score) {
    this->uid = uid;
    this->score = score;
  }

  std::map<std::string, Object> ToMap() {
    std::map<string, Variant> result = new std::map<string, Variant>();
    result["uid"] = Variant(uid);
    result["score"] = Variant(score);

    return result;
  }
}

Para criar um LeaderboardEntry e atualizá-lo simultaneamente para o feed de pontuação recente e a própria lista de pontuação do usuário, o jogo usa o seguinte código:

void WriteNewScore(std::string userId, int score) {
  // Create new entry at /user-scores/$userid/$scoreid and at
  // /leaderboard/$scoreid simultaneously
  std::string key = dbref.Child("scores").PushChild().GetKey();
  LeaderBoardEntry entry = new LeaderBoardEntry(userId, score);
  std::map<std::string, Variant> entryValues = entry.ToMap();

  std::map<string, Variant> childUpdates = new std::map<string, Variant>();
  childUpdates["/scores/" + key] = entryValues;
  childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

  dbref.UpdateChildren(childUpdates);
}

Esse exemplo usa PushChild() para criar uma entrada no nó que contém entradas para todos os usuários em /scores/$key e simultaneamente recuperar a chave com key(). A chave pode ser usada para criar uma segunda entrada nas pontuações do usuário em /user-scores/$userid/$key.

Com esses caminhos, você faz atualizações simultâneas em vários locais da árvore JSON com uma única chamada ao UpdateChildren(), da mesma forma que esse exemplo cria a nova entrada nos dois locais. Atualizações simultâneas realizadas dessa maneira são atômicas: ou todas funcionam ou todas falham.

Excluir dados

A maneira mais simples de excluir os dados é chamar RemoveValue() em uma referência ao local desses dados.

Também é possível excluir ao especificar um null Variant como o valor de outra operação de gravação, como SetValue() ou UpdateChildren(). Use essa técnica com UpdateChildren() para excluir vários filhos em uma única chamada de API.

Saiba quando seus dados estão confirmados.

Para saber se os seus dados estão confirmados no servidor do Firebase Realtime Database, verifique se o resultado da classe Future teve sucesso.

Salvar dados como transações

Para tratar dados corrompidos por modificações simultâneas, como contadores incrementais, use uma operação de transação. Dê a essa operação uma função DoTransaction. A função de atualização usa o estado atual dos dados como argumento e retorna o novo estado de acordo com as preferências de gravação. Se outro cliente fizer uma gravação no local antes que seu novo valor seja gravado com sucesso, sua função de atualização será chamada novamente com o novo valor atual e a gravação será repetida.

Por exemplo, em um jogo, você pode permitir que os usuários atualizem uma tabela de classificação com as cinco pontuações mais altas:

void AddScoreToLeaders(std::string email,
                       long score,
                       DatabaseReference leaderBoardRef) {
  leaderBoardRef.RunTransaction([](firebase::database::MutableData* mutableData) {
    if (mutableData.children_count() >= MaxScores) {
      long minScore = LONG_MAX;
      MutableData *minVal = null;
      std::vector<MutableData> children = mutableData.children();
      std::vector<MutableData>::iterator it;
      for (it = children.begin(); it != children.end(); ++it) {
        if (!it->value().is_map())
          continue;
        long childScore = (long)it->Child("score").value().int64_value();
        if (childScore < minScore) {
          minScore = childScore;
          minVal = &*it;
        }
      }
      if (minScore > score) {
        // The new score is lower than the existing 5 scores, abort.
        return kTransactionResultAbort;
      }

      // Remove the lowest score.
      children.Remove(minVal);
    }

    // Add the new high score.
    std::map<std::string, Variant> newScoreMap =
      new std::map<std::string, Variant>();
    newScoreMap["score"] = score;
    newScoreMap["email"] = email;
    children.Add(newScoreMap);
    mutableData->set_value(children);
    return kTransactionResultSuccess;
  });
}

Usar uma transação evita que a tabela de classificação fique incorreta caso vários usuários gravem resultados ao mesmo tempo ou o cliente tenha dados desatualizados. Se a transação for rejeitada, o servidor retornará o valor atual ao cliente, que executará a transação novamente com o valor atualizado. Isso se repetirá até que a transação seja aceita ou até que muitas tentativas sejam realizadas.

Gravar dados off-line

Se um cliente perder a conexão de rede, o app continuará funcionando.

Todos os clientes conectados a um banco de dados do Firebase mantêm a própria versão interna de dados ativos. A gravação deles ocorre primeiro nessa versão local. Depois, o cliente do Firebase sincroniza esses dados com os servidores remotos e com outros clientes de acordo com o modelo “melhor esforço".

Consequentemente, todas as gravações no banco de dados acionam eventos locais, antes de qualquer dado ser gravado no servidor, e o app continua responsivo, independentemente da conectividade ou da latência da rede.

Para que a conectividade seja restabelecida, seu app recebe o conjunto apropriado de eventos, e o cliente faz a sincronização com o estado atual do servidor, sem precisar de um código personalizado.

A seguir