Inicio rápido - SDK de Flutter

Crear modelo de datos

Para definir el modelo de datos de su aplicación, agregue una definición de clase de modelo Realm al código de su aplicación.

Algunas consideraciones al definir su clase de modelo Realm:

• Importe el paquete en la parte superior del archivo de definición de clase.

• En su archivo, asigne a su clase un nombre privado (que comience con _), como un archivo car.dart con una clase _Car. La clase pública RealmObject se genera mediante el comando de la sección "Generar clase RealmObject". Este comando genera una clase pública, como Car.

• Asegúrese de incluir el nombre del archivo generado, como part car.realm.dart, antes del código que define su modelo. Esto es necesario para generar la clase 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;
}

Generar clase RealmObject

Ahora genere una clase RealmObject Car a partir de la clase de modelo de datos Car:

dart run realm generate

dart run realm_dart generate

Al ejecutar esto, se crea una clase Car en un archivo car.realm.dart ubicado en el directorio donde se definió la clase del modelo según la sección anterior "Crear un modelo de datos". Esta clase Car es pública y forma parte de la misma biblioteca que la clase del modelo de datos _Car. La clase Car generada es la que se utiliza en toda la aplicación.

Si desea ver cómo su clase de modelo de datos genera una nueva clase Car cada vez que haya un cambio en _Car, ejecute:

dart run realm generate --watch

dart run realm_dart generate --watch

Crear objetos

Para crear un nuevo Car, cree una instancia de la clase Car y agréguela al reino en un bloque de transacción de escritura:

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

Actualizar objetos

Para modificar un automóvil, actualice sus propiedades en un bloque de transacción de escritura:

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

Consulta de objetos

Recupere una colección de todos los objetos de un modelo de datos en el reino con el método Realm.all():

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

Filtra una colección para recuperar un segmento específico de objetos con el Realm.query() método. En el argumento del método query(), use operadores del Lenguaje de Consulta Realm para realizar filtrado.

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

Eliminar objetos

Eliminar un automóvil llamando al método Realm.delete() en un bloque de transacción de escritura:

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

Reaccionar a los cambios

Escucha y responde a los cambios en una consulta, un objeto individual o una lista dentro de un objeto. El detector de cambios es un flujo que invoca una función de devolución de llamada cuyo argumento contiene los cambios desde la última invocación.

Para escuchar una consulta, utilice 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
});

También puedes pausar y reanudar las suscripciones.

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

Una vez que haya terminado de escuchar los cambios, cierre el detector de cambios para evitar pérdidas de memoria.

await subscription.cancel();

Para obtener más información, consulte Reaccionar a los cambios.

Requisitos previos

Antes de poder usar Device Sync con Realm en su aplicación cliente, debe configurar Device Sync mediante Atlas App Services:

1. Crear una aplicación de servicios de aplicaciones

2. Habilitar la autenticación anónima

3. Habilitar sincronización owner_id flexible. Establecer como campo consultable.

4. Define las reglas que determinan los permisos que tienen los usuarios al usar Device Sync. En este ejemplo, asignamos un rol predeterminado, que se aplica a cualquier colección que no tenga un rol específico. En este ejemplo, un usuario puede leer y escribir datos donde el user.id del usuario conectado coincide con el owner_id del 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
       }
     ]
   }

Ahora, implemente las actualizaciones de su aplicación.

Inicializar servicios de aplicaciones

Para usar las funciones de App Services, como la autenticación y la sincronización, accede a tu aplicación de App Services con tu ID de aplicación. Puedes encontrarlo en la interfaz de App Services.

final app = App(AppConfiguration(appId));

Para obtener más información, consulte Conectarse a los servicios de la aplicación.

Autenticar un usuario

Después de habilitar la autenticación anónima en la interfaz de usuario de App Services, los usuarios pueden iniciar sesión inmediatamente en su aplicación sin proporcionar ninguna información de identificación:

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

Para obtener más información, consulte Autenticar un usuario.

Abrir un reino sincronizado

Una vez que haya habilitado la sincronización de dispositivos y autenticado a un usuario, abra un dominio sincronizado con Configuration.flexibleSync(). Luego, pase la configuración a Realm() para abrir una instancia del dominio. El dominio sincronizado debe tener un Configuration.path diferente al de otros dominios locales abiertos.

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

Para obtener más información, consulte Abrir un reino sincronizado.

Agregar una suscripción de sincronización

Ahora cree una suscripción para sincronizar datos con Atlas mediante Device Sync. Añada la suscripción dentro de la función de devolución de llamada SubscriptionSet.update().

La función de retorno del bloque de actualización incluye un objeto MutableSubscriptionSet() como argumento. Utiliza MutableSubscriptionSet.add() para agregar una nueva suscripción.

// 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 obtener más información, consulte Administrar suscripciones de sincronización.