Pacote io.realm

Class RealmList<E>

  • Parâmetros do tipo:
    E - a classe de objetos na lista.
    Todas as interfaces implementadas:
    io.realm.internal.Freezable<RealmCollection<E>>, io.realm.internal.ManageableObject, OrderedRealmCollection<E>, RealmCollection<E>, Iterable<E>, Collection<E>, List<E>
    public class RealmList<E>
extends AbstractList<E>
implements OrderedRealmCollection<E>
    O RealmList é usado para modelar relacionamentos um-para-muitos em um RealmObject. O RealmList tem dois modos: um modo managed e não gerenciado. No modo managed, todos os objeto são persistentes dentro de um Realm; no modo não gerenciado, ele funciona como um ArrayList normal.

    Somente o Realm pode criar RealmLists managed. Os managed RealmLists atualizarão automaticamente o conteúdo sempre que o Realm subjacente for atualizado e só pode ser acessado usando o getter de um RealmObject.

    RealmLists não managed podem ser criados pelo usuário e podem conter RealmObjects managed e não managed. Isso é útil ao lidar com desserializadores JSON como GSON ou outras estruturas que injetam valores em uma classe. Elementos não gerenciados nesta lista podem ser adicionados a um Realm utilizando o método Realm.copyToRealm(Iterable, ImportFlag...) .

    RealmList pode conter mais elementos do que Integer.MAX_VALUE. Nesse caso, você pode acessar apenas os primeiros elementos Integer.MAX_VALUE nele.

    • Detalhes do campo

      • baseRealm

        public final io.realm.BaseRealm baseRealm
        A instância BaseRealm na qual esta lista reside.

        Aviso: este campo está exposto apenas para uso interno e não deve ser usado.

    • Detalhes do construtor

      • Lista de domínios

        public RealmList()
        Cria um RealmList no modo não gerenciado, onde os elementos não são controlados por um Realm. Isso efetivamente faz com que o RealmList funcione como um ArrayList e não é possível executar query do objeto neste estado.

        Use Realm.copyToRealm(Iterable, ImportFlag...) para persistir adequadamente seus elementos no Realm.

      • Lista de domínios

        public RealmList(E... objeto)
        Cria um RealmList no modo não gerenciado com uma lista inicial de elementos. Um RealmList na função de modo não gerenciado como um ArrayList e não é possível fazer query ao objeto neste estado.

        Use Realm.copyToRealm(Iterable, ImportFlag...) para persistir adequadamente todos os elementos não gerenciados no Realm.

        Parâmetros:
        objects - objetos iniciais na lista.

    • Detalhes do método

      • é válido

        public boolean isValid()
        Verifica se a collection ainda é válida para uso, ou seja, a instância Realm não foi fechada. Ele sempre retornará true para uma coleção não gerenciada.
        Especificado por:
        isValid na interface io.realm.internal.ManageableObject
        Especificado por:
        isValid na interface RealmCollection<E>
        Retorna:
        true se ainda for válido para usar ou uma collection não gerenciada, false caso contrário.

      • congelar

        public RealmList<E> freeze()
        Especificado por:
        freeze na interface io.realm.internal.Freezable<E>

      • IsFrozen

        public boolean isFrozen()
        Especificado por:
        isFrozen na interface io.realm.internal.ManageableObject

      • isManaged

        public boolean isManaged()
        Verifica se a collection é managed pelo Realm. Uma managed collection é apenas um invólucro que envolve os dados no Arquivo de Realm subjacente. Nos threads do loop de eventos, uma managed collection será atualizada ao vivo para que sempre ponto para os dados mais recentes. As managed collection são confinadas por threads para que não possam ser acessadas de outros threads além daquele que as criou.

        Se esse método retornar false, a collection não será gerenciada. Uma collection não gerenciada é apenas uma Java collection normal, portanto, não será atualizada em tempo real.

        Especificado por:
        isManaged na interface io.realm.internal.ManageableObject
        Especificado por:
        isManaged na interface RealmCollection<E>
        Retorna:
        true se este for um RealmCollection managed, false caso contrário.

      • adicionar

        public void add​(int location,
                @Nullable
                E element)
        Insere o objeto especificado nesta Lista no local especificado. O objeto é inserido antes de qualquer elemento anterior no local especificado. Se o local for igual ao tamanho desta Lista, o objeto será adicionado no final.
        1. RealmLists não gerenciados: é possível adicionar objetos gerenciados e não gerenciados. Se adicionarem objeto managed a um RealmList não gerenciado, eles não serão copiados para o Realm novamente se usarem Realm.copyToRealm(RealmModel, ImportFlag...) posteriormente.
        2. managed RealmLists: é possível adicionar objeto não managed a uma RealmList que já é managed. Nesse caso, o objeto será copiado de forma transparente para o Realm usando Realm.copyToRealm(RealmModel, ImportFlag...) ou Realm.copyToRealmOrUpdate(RealmModel, ImportFlag...) se tiver uma chave primária.
        Especificado por:
        add na interface List<E>
        Substitui:
        add na aula AbstractList<E>
        Parâmetros:
        location - o índice no qual inserir.
        element - o elemento a ser adicionado.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto do container tiver sido removido.
        IndexOutOfBoundsException - se location < 0 || location > size().

      • set

        conjunto E público (localização int, objeto @Nullable
             E )
        Substitui o elemento no local especificado nesta lista pelo objeto especificado.
        1. RealmLists não gerenciados: é possível adicionar objetos gerenciados e não gerenciados. Se adicionarem objeto managed a um RealmList não gerenciado, eles não serão copiados para o Realm novamente se usarem Realm.copyToRealm(RealmModel, ImportFlag...) posteriormente.
        2. managed RealmLists: é possível adicionar objeto não managed a uma RealmList que já é managed. Nesse caso, o objeto será copiado de forma transparente para o Realm usando Realm.copyToRealm(RealmModel, ImportFlag...) ou Realm.copyToRealmOrUpdate(RealmModel, ImportFlag...) se tiver uma chave primária.
        Especificado por:
        set na interface List<E>
        Substitui:
        set na aula AbstractList<E>
        Parâmetros:
        location - o índice no qual colocar o objeto especificado.
        object - o objeto a ser adicionado.
        Retorna:
        o elemento anterior no índice.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.
        IndexOutOfBoundsException - se location < 0 || location >= size().

      • mover

        public void move​(int oldPos,
                 int newPos)
        Move um objeto de uma posição para outra, mantendo uma lista de tamanho fixo. Os RealmObjects serão deslocados para que nenhum valor null seja introduzido.
        Parâmetros:
        oldPos - índice do RealmObject a ser movido.
        newPos - posição alvo. Se newPos < antigoPos, o objeto no local será deslocado para a direita. Se antigaPos < newPos, indexes > antigaPos será deslocada uma vez para a esquerda.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.
        IndexOutOfBoundsException - se alguma posição estiver fora de [0, tamanho()].

      • remover

        remoção pública E (localização int)
        Remove o objeto no local especificado desta lista.
        Especificado por:
        remove na interface List<E>
        Substitui:
        remove na aula AbstractList<E>
        Parâmetros:
        location - o índice do objeto a ser removido.
        Retorna:
        o objeto removido.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.
        IndexOutOfBoundsException - se location < 0 || location >= size().

      • remover

        remoção booleana pública(@Nullable
                      objeto objeto)
        Remove uma instância do objeto especificado deste Collection se houver. Essa implementação itera sobre esse Collection e testa cada elemento e retornado pelo iterador, se e é igual ao objeto fornecido. Se object != null , este teste será realizado usando object.equals(e), caso contrário, usando object == null. Se um elemento igual ao objeto fornecido for encontrado, o método remove será chamado no iterador e true será retornado, false caso contrário. Se o iterador não oferecer suporte à remoção de elementos, um UnsupportedOperationException será lançado.
        Especificado por:
        remove na interface Collection<E>
        Especificado por:
        remove na interface List<E>
        Substitui:
        remove na aula AbstractCollection<E>
        Parâmetros:
        object - o objeto a ser removido.
        Retorna:
        true se este Collection for modificado, false caso contrário.
        Lançamentos:
        ClassCastException - se o objeto passado não for do tipo correto.
        NullPointerException - se object for null.

      • Remover todos

        public boolean removeAll​(Collection<?> collection)
        Remove todas as ocorrências neste Collection de cada objeto no Collection especificado. Após este método retornar nenhum dos elementos no Collection passado pode ser encontrado neste Collection mais.

        Essa implementação itera no Collection e testa cada elemento e retornado pelo iterador, se ele está contido no Collection especificado. Se este teste for positivo, o método remove será chamado no iterador.

        Especificado por:
        removeAll na interface Collection<E>
        Especificado por:
        removeAll na interface List<E>
        Substitui:
        removeAll na aula AbstractCollection<E>
        Parâmetros:
        collection - a collection de objeto a serem removidos.
        Retorna:
        true se este Collection for modificado, false caso contrário.
        Lançamentos:
        ClassCastException - se um ou mais elementos de collection não forem do tipo correto.
        NullPointerException - se collection for null.

      • deleteFirstFromRealm

        public boolean deleteFirstFromRealm()
        Exclui o primeiro objeto do Realm. Isso também o remove desta collection.
        Especificado por:
        deleteFirstFromRealm na interface OrderedRealmCollection<E>
        Retorna:
        true se um objeto foi excluído, false caso contrário.

      • deleteLastFromRealm

        public boolean deleteLastFromRealm()
        Exclui o último objeto do Realm. Isso também o remove desta collection.
        Especificado por:
        deleteLastFromRealm na interface OrderedRealmCollection<E>
        Retorna:
        true se um objeto foi excluído, false caso contrário.

      • obter

        @Nullable
public E get(localização int)
        Retorna o elemento no local especificado nesta lista.
        Especificado por:
        get na interface List<E>
        Especificado por:
        get na aula AbstractList<E>
        Parâmetros:
        location - o índice do elemento a ser retornado.
        Retorna:
        o elemento no índice especificado.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.
        IndexOutOfBoundsException - se location < 0 || location >= size().

      • primeiro

        @Nullable
E public E first(@Nullable
               E defaultValue)
        Obtém o primeiro objeto da collection. Se a collection estiver vazia, o padrão fornecido será usado.
        Especificado por:
        first na interface OrderedRealmCollection<E>
        Retorna:
        o primeiro objeto ou o padrão fornecido.

      • último

        @Nullable
public E last(@Nullable
              E defaultValue)
        Obtém o último objeto da collection. Se a collection estiver vazia, o padrão fornecido será usado.
        Especificado por:
        last na interface OrderedRealmCollection<E>
        Retorna:
        o último objeto ou o padrão fornecido.

      • sort

        public RealmResults<E> sort​(String fieldName)
        Classifica uma collection com base no campo fornecido em ordem crescente.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName - o nome do campo pelo qual classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • sort

        public RealmResults<E> sort​(String fieldName,
                            Sort sortOrder)
        Classifica uma collection com base no campo fornecido e na ordem de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName - o nome do campo pelo qual classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder - a direção pela qual classificar.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • sort

        public RealmResults<E> sort​(String fieldName1,
                            Sort sortOrder1,
                            String fieldName2,
                            Sort sortOrder2)
        Classifica uma collection com base nos campos fornecidos e nas ordens de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName1 - nome do primeiro campo. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder1 - ordem de classificação para o primeiro campo.
        fieldName2 - nome do segundo campo. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder2 - ordem de classificação para o segundo campo.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • sort

        public RealmResults<E> sort​(String[] fieldNames,
                            Sort[] sortOrders)
        Classifica uma collection com base nos campos fornecidos e nas ordens de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldNames - uma array de nomes de campos para classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrders - as instruções para classificar por.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • deleteFromRealm

        public void deleteFromRealm​(int location)
        Exclui o objeto no índice fornecido do Realm. Isso também o remove da coleção.
        Especificado por:
        deleteFromRealm na interface OrderedRealmCollection<E>
        Parâmetros:
        location - o índice da array identificando o objeto a ser removido.

      • Tamanho

        public int size()
        Retorna o número de elementos neste List.
        Especificado por:
        size na interface Collection<E>
        Especificado por:
        size na interface List<E>
        Especificado por:
        size na aula AbstractCollection<E>
        Retorna:
        o número de elementos neste List.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.

      • ONDE

        public RealmQuery<E> where()
        Retorna um RealmQuery, que pode ser usado para fazer query de objetos específicos desta classe.
        Especificado por:
        where na interface RealmCollection<E>
        Retorna:
        um objeto RealmQuery.
        Lançamentos:
        IllegalStateException - se a Instância de Realm tiver sido fechada ou o objeto tiver sido removido.
        Veja também:
        RealmQuery

      • min

        @Nullable
public Number min(String fieldName)
        Localiza o valor mínimo de um campo.
        Especificado por:
        min na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar um mínimo. Somente campos numéricos são permitidos.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como o valor para o campo fornecido, null será retornado. Caso contrário, o valor mínimo é devolvido. Ao determinar o valor mínimo, os objetos com valores null são ignorados.

      • max

        @Nullable
public Number max(String fieldName)
        Localiza o valor máximo de um campo.
        Especificado por:
        max na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar um máximo. Somente campos numéricos são permitidos.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como o valor para o campo fornecido, null será retornado. Caso contrário, o valor máximo é retornado. Ao determinar o valor máximo, os objetos com valores null são ignorados.

      • soma

        soma de número público (string fieldName )
        Calcula a soma de um determinado campo.
        Especificado por:
        sum na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo a ser somado. Somente campos numéricos são permitidos.
        Retorna:
        a soma. Se não existirem objetos ou todos eles tiverem null como o valor para o campo fornecido, 0 será retornado. Ao calcular a soma, objetos com valores null são ignorados.

      • média

        média dupla pública (String fieldName)
        Retorna a média de um determinado campo.
        Especificado por:
        average na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para calcular a média. Somente campos numéricos são permitidos.
        Retorna:
        a média do campo fornecido entre os objetos nos resultados da query. Isso será do tipo double para todos os tipos de campos numéricos. Se não existirem objetos ou todos eles tiverem null como o valor para o campo fornecido, 0 será retornado. Ao calcular a média, objetos com valores null são ignorados.

      • maxDate

        @Nullable
public Date maxDate(String fieldName)
        Encontra a data máxima.
        Especificado por:
        maxDate na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar a data máxima. Se fieldName não for do tipo Date, uma exceção será lançada.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como valor para o campo de data fornecido, null será retornado. Caso contrário, a data máxima é retornada. Ao determinar a data máxima, os objetos com valores null são ignorados.

      • minDate

        @Nullable
public Date minDate(String fieldName)
        Encontra a data mínima.
        Especificado por:
        minDate na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar a data mínima. Se fieldName não for do tipo Date, uma exceção será lançada.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como valor para o campo de data fornecido, null será retornado. Caso contrário, a data mínima é retornada. Ao determinar a data mínima, os objetos com valores null são ignorados.

      • deleteAllFromRealm

        public boolean deleteAllFromRealm()
        Isso exclui todos os objetos da collection do Realm subjacente e da collection.
        Especificado por:
        deleteAllFromRealm na interface RealmCollection<E>
        Retorna:
        true se os objetos foram excluídos, false caso contrário.

      • isLoaded

        public boolean isLoaded()
        Verifica se uma collection já terminou de carregar seus dados.
        Especificado por:
        isLoaded na interface RealmCollection<E>
        Retorna:
        true se os dados tiverem sido carregados e estiverem disponíveis, false se os dados ainda estiverem sendo carregados.

      • carregar

        carga booleana pública()
        Bloqueia a collection até que todos os dados estejam disponíveis.
        Especificado por:
        load na interface RealmCollection<E>
        Retorna:
        true se os dados puderem ser carregados com sucesso, false caso contrário.

      • contém

        boolean público contém(objeto @Nullable
                        Object )
        Retorna true se a lista contiver o elemento especificado quando anexado a um Realm. Esse método executará uma query do Realm nativo storage engine para localizar rapidamente o elemento especificado.

        Se a lista não estiver anexada a um Realm, a implementação padrão do List.contains(Object) ocorrerá.

        Especificado por:
        contains na interface Collection<E>
        Especificado por:
        contains na interface List<E>
        Especificado por:
        contains na interface RealmCollection<E>
        Substitui:
        contains na aula AbstractCollection<E>
        Parâmetros:
        object - o elemento cuja presença nesta lista será testada.
        Retorna:
        true se esta lista contiver o elemento especificado, caso contrário false.

      • getRealm

        public Realm getRealm()
        Retorna a instância Realm à qual esta coleção pertence.

        Chamar Closeable.close() na instância retornada não é recomendado, pois é o mesmo que chamá-lo na Instância de Realm, o que pode fazer com que o Realm feche completamente, invalidando a lista.

        Retorna:
        instância Realm a esta collection pertence ou null se a collection não for gerenciada.
        Lançamentos:
        IllegalStateException - se o Realm for uma instância de DynamicRealm ou se o Realm já estiver fechado.

      • asFlowable

        public Flowable<RealmList<E>> asFlowable()
        Retorna um Rx Flowable que monitora as alterações neste RealmList. Ele emitirá o RealmList atual quando for inscrito. O RealmList será emitido continuamente à medida que o RealmList for atualizado - onComplete nunca será chamado.

        Os itens emitidos do Realm Flowables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Os Realm Flowables sempre emitem itens do thread que mantém o RealmList ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        list.asFlowable() .observeOn(Schedulers.computation()) .map(rxResults -> doExpensiveWork(rxResults)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Se você quiser que o asFlowable() pare de emitir itens, você pode instruir o RxJava a emitir apenas somente o primeiro item usando o operador first() : 

         
 list.asFlowable()
      .first()
      .subscribe( ... ) // You only get the results once

        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no caminho de classe ou a Instância de Realm correspondente não suportar RxJava.
        Veja também:
        RxJava e Realm

      • asChangesetObservable

        public Observable<CollectionChange<RealmList<E>>> asChangesetObservable()
        Retorna um Rx Observable que monitora as alterações neste RealmList. Ele emitirá o RealmList atual quando estiver inscrito. Para cada atualização no RealmList, um par que consiste no RealmList e no OrderedCollectionChangeSet será enviado. O changeset será null na primeira vez que um RealmList for emitido.

        O RealmList será emitido continuamente à medida que o RealmList for atualizado - onComplete nunca será chamado.

        Os itens emitidos do Realm Observables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Realm Observables sempre emitem itens do thread que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        list.asChangesetObservable() .observeOn(Schedulers.computation()) .map((rxList, changes) -> doExpensiveWork(rxList, changes)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no caminho de classe ou a Instância de Realm correspondente não suportar RxJava.
        IllegalStateException - se o Realm não tiver sido aberto em uma thread do loop de eventos.
        Veja também:
        RxJava e Realm

      • addChangeListener

        public void addChangeListener​(OrderedRealmCollectionChangeListener<RealmList<E>> listener)
        Adiciona um ouvinte de alteração a este RealmList.

        Registrar um ouvinte de alterações não impedirá que o RealmList subjacente seja coletado o lixo. Se o RealmList for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private RealmList<Dog> dogs; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       dogs = realm.where(Person.class).findFirst().getDogs();
       dogs.addChangeListener(new OrderedRealmCollectionChangeListener<RealmList<Dog>>() {
           \@Override
           public void onChange(RealmList<Dog> dogs, OrderedCollectionChangeSet changeSet) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alterações for null.
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .

      • addChangeListener

        public void addChangeListener​(RealmChangeListener<RealmList<E>> listener)
        Adiciona um ouvinte de alteração a este RealmList.

        Registrar um ouvinte de alterações não impedirá que o RealmList subjacente seja coletado o lixo. Se o RealmList for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private RealmList<Dog> dogs; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       dogs = realm.where(Person.class).findFirst().getDogs();
       dogs.addChangeListener(new RealmChangeListener<RealmList<Dog>>() {
           \@Override
           public void onChange(RealmList<Dog> dogs) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alterações for null.
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .

      • Remover todos os ouvintes de alterações

        public void removeAllChangeListeners()
        Remove todos os ouvintes de alterações definidos pelo usuário.
        Lançamentos:
        IllegalStateException - se você tentar remover ouvintes de um thread que não seja do loop de eventos.
        Veja também:
        RealmChangeListener