reinício do cliente - .NET SDK

Recuperar alterações locais não sincronizadas

Em um reinício do cliente que não envolve uma alteração de esquema de quebra, o SDK integra objeto criados localmente que não sincronizaram antes do reinício do cliente. As regras a seguir determinam como os conflitos são resolvidos quando o backend e o cliente fazem alterações no mesmo objeto:

• Se um objeto for excluído no servidor, mas for modificado no cliente de recuperação, a exclusão terá precedência e o cliente descartará a atualização.

• Se um objeto for excluído no cliente em recuperação, mas não no servidor, o cliente aplicará a instrução de exclusão.

• No caso de atualizações conflitantes no mesmo campo, a atualização do cliente é aplicada.

Há dois manipuladores de reinício do cliente que tentam recuperar automaticamente os dados locais não sincronizados: RecoverOrDiscardUnsyncedChangesHandler e RecoverUnsyncedChangesHandler.

var conf = new FlexibleSyncConfiguration(user)
{
    ClientResetHandler = new RecoverOrDiscardUnsyncedChangesHandler
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterRecovery = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        OnAfterDiscard = (beforeReset, afterReset) =>
        {
            // Executed if the automatic recovery has failed
            // but the DiscardUnsyncedChanges fallback has completed
            // successfully
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    }
};

var conf = new FlexibleSyncConfiguration(user)
{
    ClientResetHandler = new RecoverUnsyncedChangesHandler
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterReset = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    }
};

Descartar alterações não sincronizadas

Essa estratégia exclui permanentemente todas as alterações locais não sincronizadas feitas desde a última sincronização bem-sucedida. Se você optar por usar um DiscardUnsyncedChangesHandler, o SDK restaurará seu arquivo de Realm local para um estado sincronizável sem fechar o Realm e, ao mesmo tempo, manter as notificações funcionando perfeitamente. Se esse processo falhar, ele voltará para uma estratégia de reinício manual explicada na seção Recuperação manual. Este manipulador fornece os seguintes métodos de chamada de resposta de resposta:

• OnBeforeReset, que o SDK invoca antes da redefinição do cliente. Você pode usar esse retorno de chamada para notificar o usuário antes que a redefinição comece.

• OnAfterReset, que o SDK invoca se e somente se a redefinição for concluída com êxito. Você pode usá-lo para notificar o usuário quando a redefinição for concluída.

• ManualResetFallback, que o SDK invoca se a redefinição falhar. Sua lógica aqui deve ser semelhante à descrita para um ManualRecoveryHandler.

O exemplo a seguir mostra como você pode implementar um DiscardUnsyncedChangesHandler:

{
    var config = new FlexibleSyncConfiguration(user);
    config.ClientResetHandler = new DiscardUnsyncedChangesHandler()
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterReset = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    };
    try
    {
        var realm = await Realm.GetInstanceAsync(config);
    }
    catch (Exception ex)
    {
        Console.WriteLine($@"Error creating or opening the
            realm file. {ex.Message}");
    }

Recuperação manual

Na maioria dos casos, você deve usar uma das outras estratégias para redefinir o cliente . Para os casos pouco frequentes em que você precisa personalizar seu processo de recuperação de dados, selecione o manipulador ManualRecoveryHandler .

Dentro do ManualRecoveryHandler, você descarta o domínio existente e, em seguida, chama o método InitiateClientReset() .

O exemplo a seguir demonstra a implementação do ManualRecoveryHandler :

private void SetupRealm()
{
    var config = new FlexibleSyncConfiguration(user);
    config.ClientResetHandler =
        new ManualRecoveryHandler(HandleClientResetError);
    var realm = await Realm.GetInstanceAsync(config);
}

private void HandleClientResetError(ClientResetException clientResetException)
{
    Console.WriteLine($"Client Reset requested: {clientResetException.Message}");

    // Prompt user to perform a client reset immediately. If they don't,
    // they won't receive any data from the server until they restart the app
    // and all changes they make will be discarded when the app restarts.
    var didUserConfirmReset = ShowUserAConfirmationDialog();
    if (didUserConfirmReset)
    {
        // Close the Realm before doing the reset. It must be 
        // deleted as part of the reset.
        fsRealm.Dispose();

        // perform the client reset
        var didReset = clientResetException.InitiateClientReset();
        if (didReset)
        {
            // Navigate the user back to the main page or reopen the
            // the Realm and reinitialize the current page
        }
        else
        {
            // Reset failed - notify user that they'll need to
            // update the app
        }
    }
}

Tratamento de reinício do cliente de teste

Você pode testar manualmente o tratamento de redefinição do cliente do seu aplicativo encerrando e reativando o Device Sync.

Quando você encerra e reativa a sincronização, os clientes que se conectaram anteriormente à sincronização não conseguem se conectar até depois de fazerem um reinício do cliente. O encerramento da sincronização exclui os metadados do servidor que permitem ao cliente sincronizar. O cliente deve baixar uma nova cópia do Realm do servidor. O servidor envia um erro de reinício do cliente para esses clientes. Então, ao encerrar a sincronização, você trigger a condição de reinício do cliente.

Para testar o tratamento de reinício do cliente:

1. Escreva dados de um aplicativo cliente e aguarde a sincronização.

2. Encerre e reative o Realm Mobile Sync.

3. Run the client app again. O aplicativo deve receber um erro de reinício do cliente ao tentar se conectar ao servidor.