Managed uma sessão de sincronização - Node.js SDK

Nesta página

Pré-requisitos

Acessar sessão de sincronização
Pausar ou retomar uma sessão de sincronização
Quando pausar uma sessão de sincronização
Aguarde o Upload e Download
Verificar o progresso do upload e download de uma sessão de sincronização
Verifique a conexão de rede
Sessões de sincronização multiplex

Os Atlas Device SDKs estão obsoletos. Consulte apágina de descontinuação do para detalhes.

Quando você usa o Atlas Device Sync, o Node.js SDK sincroniza os dados com o Atlas em segundo plano usando uma sessão de sincronização. Uma sessão de sincronização começa sempre que você abre um Realm sincronizado.

Pré-requisitos

Antes de managed uma sessão de sincronização, você deve executar o seguinte:

Acessar sessão de sincronização

Após abrir um domínio sincronizado, você pode acessar sua sessão de sincronização com a propriedadeRealm.syncSession do .

const realm = await Realm.open(config);
const syncSession = realm.syncSession;

Pausar ou retomar uma sessão de sincronização

Abrir um domínio sincronizado inicia uma sessão de sincronização. Você pode pausar e retomar a sessão de sincronização no domínio. Pausar uma sessão de sincronização pausa apenas a sessão de sincronização desse realm. Se você tiver mais de um domínio aberto, a pausa não afetará as sessões de sincronização de outros domínios.

Para pausar a sincronização, use o arquivo syncSession.pause() . Para retomar a sincronização, use o método syncSession.resume() .

const behaviorConfiguration = {
  type: "openImmediately",
};
const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const pauseSyncSession = () => {
  realm.syncSession?.pause();
};
const resumeSyncSession = () => {
  realm.syncSession?.resume();
};

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: Realm.OpenRealmBehaviorType.OpenImmediately,
};
const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const pauseSyncSession = () => {
  realm.syncSession?.pause();
};
const resumeSyncSession = () => {
  realm.syncSession?.resume();
};

Quando pausar uma sessão de sincronização

Para a maioria dos aplicativos, não é necessário pausar e retomar manualmente uma sessão de sincronização. No entanto, existem algumas circunstâncias em que você pode querer pausar ou suspenso uma sessão de sincronização:

Você só quer sincronizar depois que o usuário executar uma ação específica
Você só deseja sincronizar durante um determinado horário do dia
Você não quer tentar sincronizar quando a conectividade de rede estiver ruim
Você deseja forçar explicitamente uma sessão de sincronização para se conectar

No caso de uma conectividade de rede ruim, tentar continuamente estabelecer uma conexão de rede pode esgotar a bateria do dispositivo do usuário.

O caso de forçar explicitamente uma sessão de sincronização para se conectar é mais comumente relacionado a estar offline por algum tempo. O cliente de sincronização tenta se conectar e, em caso de falha, entra em backoff exponencial. After being offline for a long time, the client may not immediately reconnect. Pausar e retomar a sessão de sincronização força explicitamente a conexão.

Ao pausar uma sessão de sincronização, lembre-se do seguinte:

Se o cliente ficar offline por mais tempo do que o tempo máximo offline do cliente , o cliente não conseguirá retomar a sincronização e deverá fazer um reinício do cliente.
Pausar uma sessão de sincronização a pausa em ambas as direções. As alterações feitas pelo seu aplicativo no dispositivo não são sincronizadas com o backend, e as alterações nos dados no backend ou em outros dispositivos não são sincronizadas com o dispositivo. Não há como pausar apenas uploads ou pausar apenas downloads.
Não pause uma sessão de sincronização se quiser que um cliente pare permanentemente de sincronizar com o backend. Para parar permanentemente a sincronização, copie o conteúdo do Realm sincronizado em um Realm não sincronizado e use o Realm não sincronizado no cliente.

Não pause a sincronização para parar a sincronização por períodos indefinidos ou intervalos de tempo em meses e anos. A funcionalidade não foi projetada ou testada para esses casos de uso. Você pode encontrar uma série de problemas ao usá-lo dessa forma.

Aguarde o Upload e Download

Para aguardar de forma assíncrona que todas as alterações sejam carregadas no Atlas a partir do seu domínio sincronizado, chame uploadAllLocalChanges(). Este método retorna verdadeiro quando todas as alterações tiverem sido carregadas.

realm.write(() => {
  realm.create(Doggie, {
    _id: new BSON.ObjectID(),
    owner_id: app.currentUser!.id,
    name: "Maui",
    age: 3,
  });
});
await realm.syncSession?.uploadAllLocalChanges();

Para aguardar de forma assíncrona que todas as alterações no Atlas sejam baixadas do servidor do Device Sync para o domínio sincronizado, chame downloadAllServerChanges(). Este método retorna verdadeiro quando todas as alterações tiverem sido baixadas.

await realm.syncSession?.downloadAllServerChanges();

Você pode especificar um tempo limite de solicitação na configuração do aplicativo. Com um tempo limite especificado, você pode definir cancelWaitsOnNonFatalErrors em seu BaseSyncConfiguration. Quando true e o intervalo de tempo limite chegam, qualquer trabalho pendente que esteja aguardando uploads e downloads é cancelado. Quando essa configuração é falsa, a espera de uploads e downloads não é cancelada porque o Realm trata esses tempos limite como erros não fatais.

Para obter mais informações, consulte Configurar um tempo limite para o cliente do aplicativo e Cancelar operações assíncronas após um tempo limite.

Verificar o progresso do upload e download de uma sessão de sincronização

Para verificar o progresso de upload e download de uma sessão de sincronização, adicione uma notificação de progresso usando o syncSession.addProgressNotification() método.

O método syncSession.addProgressNotification() utiliza os seguintes três parâmetros:

Um parâmetro direction . Defina como "upload" para registrar notificações de upload de dados. Defina como "download" para registrar notificações para baixar dados.
Um parâmetro mode . Defina como "reportIndefinitely" para que as notificações continuem até que o registro da chamada de resposta seja cancelado usando syncSession.removeProgressNotification(). Defina como "forCurrentlyOutstandingWork" para que as notificações continuem até que somente os bytes atualmente transferíveis sejam sincronizados.
Um parâmetro de função de chamada de resposta que tem os argumentos transferred e transferable. transferred é o número atual de bytes já transferidos. transferable é o número total de bytes já transferidos mais o número de bytes pendentes de transferência.

Observação

As notificações de progresso da Flexible Sync ainda não são totalmente suportadas. Ao usar a Flexible Sync, os downloads só relatam notificações após a integração das alterações. A sincronização baseada em partição fornece notificações contínuas à medida que o download das alterações progride. Os carregamentos relatam notificações de progresso contínuo para ambos os modos de sincronização.

Exemplo

No exemplo a seguir, um desenvolvedor de aplicativos registra uma chamada de resposta no syncSession para escutar eventos de upload indefinidamente. O desenvolvedor grava no Realm e, em seguida, cancela o registro da chamada de resposta syncSession .

const behaviorConfiguration = {
  type: "openImmediately",
};
const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const handleNotifcationRemoval = (transferred, transferable) => {
  console.log(`There were ${transferable} transferable bytes total.`);
  console.log(`${transferred} bytes were transferred.`);
};
const handleNotifications = (transferred, transferable) => {
  if (transferred === transferable) {
    console.log(
      `${transferred} bytes of ${transferable} were transferred.`
    );
    // Remove progress notification.
    realm.syncSession?.removeProgressNotification(handleNotifcationRemoval);
  }
};
realm.syncSession?.addProgressNotification(
  "upload",
  "reportIndefinitely",
  handleNotifications
);
// Upload a Realm object.
const dog = realm.write(() => {
  return realm.create("Dog", {
    _id: new Realm.BSON.ObjectID(),
    MyPartitionValue: "MyPartitionValue",
    name: "Fido",
    age: 2,
  });
});

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: Realm.OpenRealmBehaviorType.OpenImmediately,
};
const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const handleNotifcationRemoval = (
  transferred: number,
  transferable: number
) => {
  console.log(`There were ${transferable} transferable bytes total.`);
  console.log(`${transferred} bytes were transferred.`);
};
const handleNotifications = (transferred: number, transferable: number) => {
  if (transferred === transferable) {
    console.log(
      `${transferred} bytes of ${transferable} were transferred.`
    );
    // Remove progress notification.
    realm.syncSession?.removeProgressNotification(handleNotifcationRemoval);
  }
};
realm.syncSession?.addProgressNotification(
  Realm.ProgressDirection.Upload,
  Realm.ProgressMode.ReportIndefinitely,
  handleNotifications
);
// Upload a Realm object.
const dog = realm.write(() => {
  return realm.create("Dog", {
    _id: new Realm.BSON.ObjectID(),
    MyPartitionValue: "MyPartitionValue",
    name: "Fido",
    age: 2,
  });
});

Verifique a conexão de rede

Para verificar o estado atual da conexão com o servidor, chame o syncSession.connectionState() método.

O design offline do Realm significa que geralmente você não precisa verificar o estado atual da conexão de rede. Dito isto, o método syncSession.connectionState() estará disponível se o seu aplicativo precisar de obter o estado atual da conexão com o servidor.

const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
  },
};
const realm = await Realm.open(config);
const connectionState = realm.syncSession?.connectionState;

const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
  },
};
const realm = await Realm.open(config);
const connectionState = realm.syncSession?.connectionState;

Sessões de sincronização multiplex

Habilitar multiplexação de sessão para consolidar múltiplas sessões de sincronização de um aplicativo Realm. Use a multiplexação de sessão somente se ver erros ao atingir o limite do descritor de arquivos e saber que está usando muitas sessões de sincronização.

Para habilitar a multiplexação de sessão, chame Realm.App.Sync.enableSessionMultitexing() com seu Realm.App.

Exemplo

Realm.App.Sync.enableSessionMultiplexing(app);

Voltar

Gerenciar assinaturas de sincronização flexível

Gerenciar erros de sincronização