/ /

/ /

SDK de dispositivos Atlas

SDK de React Native

Sincronizar datos

Administrar una sesión de sincronización - SDK de React Native

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Al usar Atlas Device Sync, el SDK de React Native sincroniza los datos con Atlas en segundo plano mediante una sesión de sincronización. Esta sesión se inicia al abrir un dominio sincronizado.

Requisitos previos

Antes de poder administrar una sesión de sincronización, debe realizar lo siguiente:

Abrir un reino sincronizado
Agregar una suscripción de sincronización
Envuelva los componentes que utilizan el useRealm() Gancho para un dominio sincronizado con los AppProvider UserProvider RealmProvider componentes, y. Para obtener más información sobre cómo configurar y abrir un dominio sincronizado, consulte "Abrir un dominio sincronizado".

Acceder a la sesión de sincronización

Acceda a un dominio sincronizado en un componente con el gancho useRealm(). Acceda a la sesión de sincronización con el dominio. Propiedad Realm.syncSession.

import React, {useEffect} from 'react';
import {Context} from '../RealmConfig';
const {useRealm} = Context;
function AccessSyncSession() {
  const realm = useRealm();
  async function workWithSyncSession() {
    const {syncSession} = realm;
    // Do stuff with sync session...
  }
  // ...
}

Pausar o reanudar una sesión de sincronización

Al abrir un reino sincronizado, se inicia una sesión de sincronización. Puedes pausar y reanudar la sesión de sincronización del reino. Si tienes más de un reino abierto, la pausa no afecta las sesiones de sincronización de los demás.

Para pausar la sincronización, utilice el método Realm.syncSession.pause(). Para reanudarla, utilice el método Realm.syncSession.resume().

import React, {useEffect, useState} from 'react';
import {Context} from '../RealmConfig';
const {useRealm} = Context;
function ToggleSyncSession() {
  const realm = useRealm();
  const [isPaused, setIsPaused] = useState(false);
  async function toggleSyncSession() {
    if (isPaused) {
      await realm.syncSession?.resume();
    } else {
      await realm.syncSession?.pause();
    }
    setIsPaused(!isPaused);
  }
  return (
    <Button
      title={isPaused ? 'Pause Sync' : 'Unpause Sync'}
      onPress={toggleSyncSession}
    />
  );
}

Cuándo pausar una sesión de sincronización

En la mayoría de las aplicaciones, no es necesario pausar y reanudar manualmente una sesión de sincronización. Sin embargo, existen algunas circunstancias en las que podría ser conveniente pausar o suspender una sesión de sincronización:

Solo desea sincronizar después de que el usuario realice una acción específica
Solo desea sincronizar durante un momento determinado del día.
No debes intentar sincronizar cuando hay una mala conectividad de red
Quiere forzar explícitamente una sesión de sincronización para conectarse

En el caso de una mala conectividad de red, intentar continuamente establecer una conexión de red puede agotar la batería del dispositivo del usuario.

El caso de forzar explícitamente la conexión de una sesión de sincronización suele estar relacionado con estar desconectado durante un tiempo. El cliente de sincronización intenta conectarse y, al fallar, entra en una fase de desconexión exponencial. Tras un tiempo prolongado desconectado, es posible que el cliente no se vuelva a conectar inmediatamente. Pausar y reanudar la sesión de sincronización fuerza explícitamente la conexión.

Cuando pause una sesión de sincronización, tenga en cuenta lo siguiente:

Si el cliente puede estar fuera de línea por un tiempo mayor al máximo permitido, no podrá reanudar la sincronización y deberá reiniciarlo.
Pausar una sesión de sincronización la pausa en ambos sentidos. Los cambios que realiza la aplicación en el dispositivo no se sincronizan con el backend, y los cambios en los datos del backend o de otros dispositivos no se sincronizan con el dispositivo. No es posible pausar solo las cargas ni las descargas.
No pause una sesión de sincronización si desea que un cliente deje de sincronizarse permanentemente con el backend. Para ello, copie el contenido del dominio sincronizado en uno no sincronizado y utilice este último en el cliente.

No pause la sincronización para detenerla por períodos indefinidos o intervalos de tiempo de meses o años. Esta función no está diseñada ni probada para estos casos de uso. Podría experimentar diversos problemas al usarla de esta manera.

Consulta el progreso de carga y descarga para una sesión de sincronización

Para verificar el progreso de carga y descarga de una sesión de sincronización, agregue una notificación de progreso usando el método Realm.syncSession.addProgressNotification().

El método Realm.syncSession.addProgressNotification() toma los siguientes tres parámetros:

Un parámetro direction. Ajuste en "upload" para registrar notificaciones de carga de datos. Establécelo en "download" para registrar notificaciones al descargar datos.
Un mode parámetro. Configúrelo en "reportIndefinitely" para que las notificaciones continúen hasta que se cancele el registro de la devolución de llamada mediante Realm.syncSession.removeProgressNotification(). Configúrelo en "forCurrentlyOutstandingWork" para que las notificaciones continúen hasta que solo se sincronicen los bytes transferibles actualmente.
Un parámetro de función de devolución de llamada que tiene los argumentos transferred y transferable. transferred es el número actual de bytes ya transferidos. transferable es el número total de bytes ya transferidos más el número de bytes pendientes de transferencia.

Nota

Las notificaciones de progreso de la sincronización flexible aún no son totalmente compatibles. Al usar la sincronización flexible, las descargas solo notifican las notificaciones después de integrar los cambios. La sincronización basada en particiones proporciona notificaciones continuas a medida que se descargan los cambios. Las cargas informan del progreso en ambos modos de sincronización.

El siguiente ejemplo registra una devolución de llamada en syncSession para escuchar eventos de carga indefinidamente. El ejemplo escribe en el dominio y luego cancela el registro de la devolución de llamada de notificación syncSession.

import React, {useEffect, useState} from 'react';
import {SyncedRealmContext} from '../RealmConfig';
const {useRealm} = SyncedRealmContext;
import {Text} from 'react-native';
function CheckUploadProgress() {
  const realm = useRealm();
  const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
  useEffect(() => {
    const progressNotificationCallback = (transferred, transferable) => {
      // Convert decimal to percent with no decimals
      // (e.g. 0.6666... -> 67)
      const percentTransferred =
        parseFloat((transferred / transferable).toFixed(2)) * 100;
      setUploadProgressPercent(percentTransferred);
    };
    // Listen for changes to connection state
    realm.syncSession?.addProgressNotification(
      Realm.ProgressDirection.Upload,
      Realm.ProgressMode.ReportIndefinitely,
      progressNotificationCallback,
    );
    // Remove the connection listener when component unmounts
    return () =>
      realm.syncSession?.removeProgressNotification(
        progressNotificationCallback,
      );
    // Run useEffect only when component mounts
  }, []);
  return <Text>Percent Uploaded: {uploadProgressPercent} %</Text>;
}

import React, {useEffect, useState} from 'react';
import {Context} from '../RealmConfig';
const {useRealm} = Context;
import {Text} from 'react-native';
function CheckUploadProgress() {
  const realm = useRealm();
  const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
  useEffect(() => {
    const progressNotificationCallback: Realm.ProgressNotificationCallback = (
      transferred,
      transferable,
    ) => {
      // Convert decimal to percent with no decimals
      // (e.g. 0.6666... -> 67)
      const percentTransferred =
        parseFloat((transferred / transferable).toFixed(2)) * 100;
      setUploadProgressPercent(percentTransferred);
    };
    // Listen for changes to connection state
    realm.syncSession?.addProgressNotification(
      Realm.ProgressDirection.Upload,
      Realm.ProgressMode.ReportIndefinitely,
      progressNotificationCallback,
    );
    // Remove the connection listener when component unmounts
    return () =>
      realm.syncSession?.removeProgressNotification(
        progressNotificationCallback,
      );
    // Run useEffect only when component mounts
  }, []);
  return <Text>Percent Uploaded: {uploadProgressPercent} %</Text>;
}

Compruebe la conexión de red

El diseño de Realm, que prioriza el uso sin conexión, implica que, por lo general, no es necesario verificar el estado actual de la conexión de red, ya que los datos se sincronizan en segundo plano cuando hay una conexión disponible. Dicho esto, el SDK de Realm proporciona métodos para obtener el estado actual de la conexión de red al servidor.

Para comprobar el estado actual de la conexión con el servidor, llame a Realm.syncSession.isConnected(). Este método devuelve un valor booleano true si hay una conexión de red y la sesión de sincronización está activa.

Para detectar cambios en el estado de la conexión, llame a Realm.syncSession.addConnectionNotification() y pase como argumento una función de devolución de llamada para gestionar los cambios de red. Para anular el registro del receptor, pase la misma función de devolución de llamada a Realm.syncSession.removeConnectionNotification().

import React, {useState, useEffect} from 'react';
import {SyncedRealmContext} from '../RealmConfig';
const {useRealm} = SyncedRealmContext;
import {Text} from 'react-native';
function CheckNetworkConnection() {
  const realm = useRealm();
  const [isConnected, setIsConnected] = useState(
    realm.syncSession?.isConnected(),
  );
  useEffect(() => {
    const connectionNotificationCallback = (newState, oldState) => {
      console.log('Current connection state: ' + newState);
      console.log('Previous connection state: ' + oldState);
      setIsConnected(realm.syncSession?.isConnected());
    };
    // Listen for changes to connection state
    realm.syncSession?.addConnectionNotification(
      connectionNotificationCallback,
    );
    // Remove the connection listener when component unmounts
    return () =>
      realm.syncSession?.removeConnectionNotification(
        connectionNotificationCallback,
      );
    // Run useEffect only when component mounts
  }, []);
  return (
    <Text>
      {isConnected ? 'Connected to Network' : 'Disconnected from Network'}
    </Text>
  );
}

import React, {useState, useEffect} from 'react';
import {Context} from '../RealmConfig';
const {useRealm} = Context;
import {Text} from 'react-native';
function CheckNetworkConnection() {
  const realm = useRealm();
  const [isConnected, setIsConnected] = useState(
    realm.syncSession?.isConnected(),
  );
  useEffect(() => {
    const connectionNotificationCallback: Realm.ConnectionNotificationCallback =
      (newState, oldState) => {
        console.log('Current connection state: ' + newState);
        console.log('Previous connection state: ' + oldState);
        setIsConnected(realm.syncSession?.isConnected());
      };
    // Listen for changes to connection state
    realm.syncSession?.addConnectionNotification(
      connectionNotificationCallback,
    );
    // Remove the connection listener when component unmounts
    return () =>
      realm.syncSession?.removeConnectionNotification(
        connectionNotificationCallback,
      );
    // Run useEffect only when component mounts
  }, []);
  return (
    <Text>
      {isConnected ? 'Connected to Network' : 'Disconnected from Network'}
    </Text>
  );
}

Sesiones de sincronización multiplex

Habilitar multiplexación de sesiones Para consolidar varias sesiones de sincronización de una aplicación Realm. Utilice la multiplexación de sesiones solo si detecta errores al alcanzar el límite de descriptores de archivo y sabe que está utilizando muchas sesiones de sincronización.

Para habilitar la multiplexación de sesiones, llame a Realm.App.Sync.enableSessionMultiplexing() con su Realm.App.

import React, {useEffect} from 'react';
import {Context} from '../RealmConfig';
import {AppProvider, UserProvider, useUser, useApp, Realm} from '@realm/react';
function AppWrapper() {
  return (
    <AppProvider id={APP_ID}>
      <UserProvider fallback={<LogIn />}>
        <RealmWrapper>
          <RestOfApp />
        </RealmWrapper>
      </UserProvider>
    </AppProvider>
  );
}
type RealmWrapperProps = {
  children: React.ReactNode;
};
function RealmWrapper({children}: RealmWrapperProps) {
  const app = useApp();
  Realm.App.Sync.enableSessionMultiplexing(app);
  return <RealmProvider sync={{flexible: true}}>{children}</RealmProvider>;
}

Volver

Administrar suscripciones de sincronización flexible

Manejar errores de sincronización