Início rápido - Flutter SDK

Criar Modelo de Dados

Para definir o modelo de dados do aplicativo, adicione uma definição de classe de modelo Realm ao código do aplicativo.

Algumas considerações ao definir sua classe de modelo Realm:

• Importar pacote na parte superior do arquivo de definição da classe.

• Em seu arquivo, forneça à sua classe um nome privado (começando com _), como um arquivo car.dart com uma classe _Car. Você gera a classe pública RealmObject utilizando o comando na seguinte seção Gerar Classe RealmObject. Este comando gera uma classe pública, como Car.

• Certifique-se de incluir o nome do arquivo gerado, como part car.realm.dart, antes do código que define seu modelo. Isso é necessário para gerar a classe RealmObject.

import 'package:realm/realm.dart';
part 'car.realm.dart';
@RealmModel()
class _Car {
  @PrimaryKey()
  late ObjectId id;
  late String make;
  late String? model;
  late int? miles;
}

import 'package:realm_dart/realm.dart';
part 'car.realm.dart';
@RealmModel()
class _Car {
  @PrimaryKey()
  late ObjectId id;
  late String make;
  late String? model;
  late int? miles;
}

Gerar classe RealmObject

Agora gere uma classe RealmObject Car a partir da classe Car do modelo de dados:

dart run realm generate

dart run realm_dart generate

Executar isto cria uma classe Car em um arquivo car.realm.dart localizado no diretório onde você definiu a classe de modelo de acordo com a seção Criar Modelo de Dados anterior. Esta classe do Car é pública e parte da mesma biblioteca que a classe de modelo de dados do _Car. A classe Car gerada é a que é usada em todo o aplicativo.

Se você quiser assistir sua classe de modelo de dados para gerar uma nova classe Car sempre que houver uma alteração em _Car, execute:

dart run realm generate --watch

dart run realm_dart generate --watch

Criar objetos

Para criar uma nova Car, instancie uma instância da classe Car e adicione-a ao domínio em um bloco de transação de gravação:

final car = Car(ObjectId(), 'Tesla', model: 'Model S', miles: 42);
realm.write(() {
  realm.add(car);
});

Atualizar objetos

Para modificar um carro, atualize suas propriedades em um bloco de transação de gravação:

realm.write(() {
  car.miles = 99;
});

Query para objetos

Recupere uma coleção de todos os objetos de um modelo de dados no domínio com o método Realm.all() :

final cars = realm.all<Car>();
final myCar = cars[0];
print('My car is ${myCar.make} ${myCar.model}');

Filtre uma coleção para recuperar um segmento específico de objetos com o método .query() do Realm método. No argumento do método query(), use operadoresRQL para executar a filtragem.

final cars = realm.query<Car>('make == "Tesla"');

Excluir objetos

Exclua um carro chamando o método Realm.delete() em um bloco de transação de gravação:

realm.write(() {
  realm.delete(car);
});

Reagir às alterações

Ouça e responda a alterações em uma consulta, um único objeto ou uma lista dentro de um objeto. O ouvinte de alterações é um fluxo que invoca uma função de retorno de chamada com um argumento que contém as alterações desde a última chamada.

Para escutar uma consulta, use RealmResults.changes.listen().

// Listen for changes on whole collection
final characters = realm.all<Character>();
final subscription = characters.changes.listen((changes) {
  changes.inserted; // Indexes of inserted objects.
  changes.modified; // Indexes of modified objects.
  changes.deleted; // Indexes of deleted objects.
  changes.newModified; // Indexes of modified objects after accounting for deletions & insertions.
  changes.moved; // Indexes of moved objects.
  changes.results; // The full List of objects.
  changes.isCleared; // `true` after call to characters.clear(); otherwise, `false`.
});
// Listen for changes on RealmResults.
final hobbits = fellowshipOfTheRing.members.query('species == "Hobbit"');
final hobbitsSubscription = hobbits.changes.listen((changes) {
  // ... all the same data as above
});

Você também pode pausar e retomar as assinaturas.

subscription.pause();
// The changes.listen() method won't fire until subscription is resumed.
subscription.resume();

Quando terminar de ouvir as alterações, feche o ouvinte de alterações para evitar vazamentos de memória.

await subscription.cancel();

Para mais informações, veja Como reagir a alterações.

Pré-requisitos

Antes de poder usar o Device Sync com o Realm em seu aplicativo cliente, você deve configurar o Device Sync usando o Atlas App Services:

1. Criar um App Services App

2. Habilitar autenticação anônima

3. Ative a Flexible Sync. Defina owner_id como um campo que pode ser consultado.

4. Defina as regras que determinam quais permissões os usuários terão ao usar o Device Sync. Para este exemplo, atribuímos uma role padrão, que se aplica a qualquer collection que não tenha uma role específica da collection. Neste exemplo, um usuário pode ler e escrever dados onde o user.id do usuário conectado corresponde ao owner_id do objeto:

   {
     "roles": [
       {
         "name": "owner-read-write",
         "apply_when": {},
         "document_filters": {
           "write": {
             "owner_id": "%%user.id"
           },
           "read": {
             "owner_id": "%%user.id"
           }
         },
         "read": true,
         "write": true,
         "insert": true,
         "delete": true,
         "search": true
       }
     ]
   }

Agora, implante as atualizações do seu aplicativo.

Inicializar App Services

Para usar as funcionalidades do App Services, como autenticação e sincronização, acesse o App Services App usando seu ID do aplicativo. O ID do aplicativo está disponível na UI do App Services.

final app = App(AppConfiguration(appId));

Para obter mais informações, consulte Conectar-se ao App Services.

Autenticar um usuário

Depois de ativar a autenticação anônima na IU do App Services, os usuários podem fazer login imediatamente no seu aplicativo sem fornecer nenhuma informação de identificação:

final loggedInUser = await app.logIn(Credentials.anonymous());

Para mais informações, consulte Como autenticar um usuário.

Abrir um realm sincronizado

Depois de habilitar o Device Sync e autenticar um usuário, abra um Realm sincronizado com Configuration.flexibleSync(). Em seguida, passe a configuração para Realm() para abrir uma instância do Realm. O Realm sincronizado deve ter um Configuration.path diferente de outros domínios abertos somente locais.

final config = Configuration.flexibleSync(loggedInUser, [Todo.schema]);
final realm = Realm(
  config,
);

Para obter mais informações, consulte Abrir um Realm sincronizado.

Adicionar uma inscrição de sincronização

Agora crie uma inscrição para sincronizar dados com o Atlas usando o Device Sync. Adicione a inscrição dentro do SubscriptionSet.update() na função de chamada de resposta.

A função de chamada de resposta de chamada do bloco de atualização inclui um MutableSubscriptionSet() objeto como argumento. Use MutableSubscriptionSet.add() para adicionar uma nova assinatura.

// Check if the subscription already exists before adding
final userTodoSub = realm.subscriptions.findByName('getUserTodos');
if (userTodoSub == null) {
  realm.subscriptions.update((mutableSubscriptions) {
    // server-side rules ensure user only downloads their own Todos
    mutableSubscriptions.add(realm.all<Todo>(), name: 'getUserTodos');
  });
}

Para mais informações, consulte Gerenciar assinaturas de sincronização.