Clase RealmObject

Adds a change listener to a RealmObject that will be triggered if any value field or referenced RealmObject field is changed, or the RealmList field itself is changed.Registering a change listener will not prevent the underlying RealmObject from being garbage collected. If the RealmObject is garbage collected, the change listener will stop being triggered. To avoid this, keep a strong reference for as long as appropriate e.g. in a class variable.

public class MyActivity extends Activity {
    private Person person; // Strong reference to keep listeners alive
    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      person = realm.where(Person.class).findFirst();
      person.addChangeListener(new RealmChangeListener<Person>() {
          @Override
          public void onChange(Person person) {
              // React to change
          }
      });
    }
}

Parámetros

• object - RealmObject to add listener to.

• listener - the change listener to be notified.

Throws

• IllegalArgumentException - si el object es null o un objeto no administrado, o el listener de cambio está null .

• IllegalStateException - if you try to add a listener from a non-Looper or IntentService thread.

• IllegalStateException - if you try to add a listener inside a transaction.

Adds a change listener to a RealmObject to get detailed information about the changes. The listener will be triggered if any value field or referenced RealmObject field is changed, or the RealmList field itself is changed.Registering a change listener will not prevent the underlying RealmObject from being garbage collected. If the RealmObject is garbage collected, the change listener will stop being triggered. To avoid this, keep a strong reference for as long as appropriate e.g. in a class variable.

public class MyActivity extends Activity {
    private Person person; // Strong reference to keep listeners alive
    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      person = realm.where(Person.class).findFirst();
      person.addChangeListener(new RealmObjectChangeListener<Person>() {
          @Override
          public void onChange(Person person, ObjectChangeSet changeSet) {
              // React to change
          }
      });
    }
}

Parámetros

• object - RealmObject to add listener to.

• listener - the change listener to be notified.

Throws

• IllegalArgumentException - si el object es null o un objeto no administrado, o el listener de cambio está null .

• IllegalStateException - if you try to add a listener from a non-Looper or IntentService thread.

• IllegalStateException - if you try to add a listener inside a transaction.

Adds a change listener to this RealmObject that will be triggered if any value field or referenced RealmObject field is changed, or the RealmList field itself is changed.Registering a change listener will not prevent the underlying RealmObject from being garbage collected. If the RealmObject is garbage collected, the change listener will stop being triggered. To avoid this, keep a strong reference for as long as appropriate e.g. in a class variable.

public class MyActivity extends Activity {
    private Person person; // Strong reference to keep listeners alive
    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      person = realm.where(Person.class).findFirst();
      person.addChangeListener(new RealmChangeListener<Person>() {
          @Override
          public void onChange(Person person) {
              // React to change
          }
      });
    }
}

Parámetros

• listener - the change listener to be notified.

Throws

• IllegalArgumentException - if the change listener is null or the object is an unmanaged object.

• IllegalStateException - if you try to add a listener from a non-Looper or IntentService thread.

• IllegalStateException - if you try to add a listener inside a transaction.

Adds a change listener to this RealmObject to get detailed information about changes. The listener will be triggered if any value field or referenced RealmObject field is changed, or the RealmList field itself is changed.Registering a change listener will not prevent the underlying RealmObject from being garbage collected. If the RealmObject is garbage collected, the change listener will stop being triggered. To avoid this, keep a strong reference for as long as appropriate e.g. in a class variable.

public class MyActivity extends Activity {
    private Person person; // Strong reference to keep listeners alive
    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      person = realm.where(Person.class).findFirst();
      person.addChangeListener(new RealmObjectChangeListener<Person>() {
          @Override
          public void onChange(Person person, ObjectChangeSet changeSet) {
              // React to change
          }
      });
    }
}

Parámetros

• listener - the change listener to be notified.

Throws

• IllegalArgumentException - if the change listener is null or the object is an unmanaged object.

• IllegalStateException - if you try to add a listener from a non-Looper or IntentService thread.

• IllegalStateException - if you try to add a listener inside a transaction.

Returns an Rx Observable that monitors changes to this RealmObject. It will emit the current RealmObject when subscribed to. For each update to the RealmObject a pair consisting of the RealmObject and the ObjectChangeSet will be sent. The changeset will be null the first time the RealmObject is emitted.

The RealmObject will continually be emitted as it is updated - onComplete will never be called.

Los elementos emitidos por Realm Observables están congelados (consulta freeze() ). Esto significa que son inmutables y se pueden leer en cualquier hilo.

Realm Observables always emit items from the thread holding the live Realm. This means that if you need to do further processing, it is recommend to observe the values on a computation scheduler:

obj.asChangesetObservable()
 .observeOn(Schedulers.computation())
 .map((rxObj, changes) -> doExpensiveWork(rxObj, changeså))
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe( ... );

Parámetros

• object - RealmObject class that is being observed. Must be this class or its super types.

Devuelve

RxJava Observable that only calls onNext . It will never call onComplete or OnError .

Throws

• UnsupportedOperationException - if the required RxJava framework is not on the classpath or the corresponding Realm instance doesn't support RxJava.

• IllegalStateException - if the Realm wasn't opened on a Looper thread.

Returns an Rx Observable that monitors changes to this RealmObject. It will emit the current RealmObject when subscribed to. For each update to the RealmObject a pair consisting of the RealmObject and the ObjectChangeSet will be sent. The changeset will be null the first time the RealmObject is emitted.

The RealmObject will continually be emitted as it is updated - onComplete will never be called.

Los elementos emitidos por Realm Observables están congelados (consulta freeze() ). Esto significa que son inmutables y se pueden leer en cualquier hilo.

Realm Observables always emit items from the thread holding the live Realm. This means that if you need to do further processing, it is recommend to observe the values on a computation scheduler:

obj.asChangesetObservable()
 .observeOn(Schedulers.computation())
 .map((rxObj, changes) -> doExpensiveWork(rxObj, changeså))
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe( ... );

Devuelve

RxJava Observable that only calls onNext . It will never call onComplete or OnError .

Throws

• UnsupportedOperationException - if the required RxJava framework is not on the classpath or the corresponding Realm instance doesn't support RxJava.

• IllegalStateException - if the Realm wasn't opened on a Looper thread.

Returns an RxJava Flowable that monitors changes to this RealmObject. It will emit the current object when subscribed to. Object updates will continuously be emitted as the RealmObject is updated - onComplete will never be called.

When chaining a RealmObject observable use obj.<MyRealmObjectClass>asFlowable() to pass on type information, otherwise the type of the following observables will be RealmObject .

Items emitted from Realm Flowables are frozen (See freeze() . This means that they are immutable and can be read on any thread.

Realm Flowables always emit items from the thread holding the live Realm. This means that if you need to do further processing, it is recommend to observe the values on a computation scheduler:

obj.asFlowable()
 .observeOn(Schedulers.computation())
 .map((rxObj) -> doExpensiveWork(rxObj))
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe( ... );

If you would like the asFlowable() to stop emitting items you can instruct RxJava to emit only the first item by using the first() operator:

obj.asFlowable()
     .filter(obj -> obj.isLoaded())
     .first()
     .subscribe( ... ) // You only get the object once

Parámetros

• object - RealmObject class that is being observed. Must be this class or its super types.

Devuelve

RxJava Observable that only calls onNext . It will never call onComplete or OnError .

Throws

• UnsupportedOperationException - si el framework RxJava requerido no está en el classpath.

• IllegalStateException - if the Realm wasn't opened on a Looper thread.

Devuelve un RxJava Flowable que supervisa cambios en este RealmObject. Emitirá el objeto actual cuando se suscriba. Las actualizaciones de los objetos se emitirán continuamente a medida que se actualice el RealmObject - onComplete nunca se llamará.

When chaining a RealmObject flowable use obj.<MyRealmObjectClass>asFlowable() to pass on type information, otherwise the type of the following observables will be RealmObject .

Items emitted from Realm Flowables are frozen (See freeze() . This means that they are immutable and can be read on any thread.

Realm Flowables always emit items from the thread holding the live Realm. This means that if you need to do further processing, it is recommend to observe the values on a computation scheduler:

obj.asFlowable()
 .observeOn(Schedulers.computation())
 .map((rxObj) -> doExpensiveWork(rxObj))
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe( ... );

If you would like the asFlowable() to stop emitting items you can instruct RxJava to only emit only the first item by using the first() operator:

obj.asFlowable()
     .filter(obj -> obj.isLoaded())
     .first()
     .subscribe( ... ) // You only get the object once

Type Parameters

• E - RealmObject class that is being observed. Must be this class or its super types.

Devuelve

RxJava Observable that only calls onNext . It will never call onComplete or OnError .

Throws

• UnsupportedOperationException - if the required RxJava framework is not on the classpath or the corresponding Realm instance doesn't support RxJava.

• IllegalStateException - if the Realm wasn't opened on a Looper thread.

Deletes the object from the Realm it is currently associated with.After this method is called the object will be invalid and any operation (read or write) performed on it will fail with an IllegalStateException.

Throws

• IllegalStateException - if the corresponding Realm is closed or in an incorrect thread.

Deletes the object from the Realm it is currently associated to.After this method is called the object will be invalid and any operation (read or write) performed on it will fail with an IllegalStateException.

Throws

• IllegalStateException - if the corresponding Realm is closed or in an incorrect thread.

Returns a frozen snapshot of this object. The frozen copy can be read and queried from any thread without throwing an IllegalStateException .

La congelación de un RealmObject también crea un Realm congelado que tiene su propio ciclo de vida, pero si el Realm en vivo que generó la colección original se cierra completamente (es decir, todas las instancias de todos los hilos están cerradas), el Realm congelado y el objeto también se cerrarán.

Frozen objects can be queried as normal, but trying to mutate it in any way or attempting to register a listener will throw an IllegalStateException .

Nota: Mantener un gran número de objetos congelados con diferentes versiones activas puede tener un impacto negativo en el tamaño del archivo del Realm. Para evitar una situación así, es posible establecer RealmConfiguration.Builder.maxNumberOfActiveVersions(long) .

Devuelve

una copia congelada de este objeto.

Throws

• IllegalStateException - if this method is called from inside a write transaction.

Returns a frozen snapshot of this object. The frozen copy can be read and queried from any thread without throwing an IllegalStateException .

La congelación de un RealmObject también crea un Realm congelado que tiene su propio ciclo de vida, pero si el Realm en vivo que generó la colección original se cierra completamente (es decir, todas las instancias de todos los hilos están cerradas), el Realm congelado y el objeto también se cerrarán.

Frozen objects can be queried as normal, but trying to mutate it in any way or attempting to register a listener will throw an IllegalStateException .

Nota: Mantener un gran número de objetos congelados con diferentes versiones activas puede tener un impacto negativo en el tamaño del archivo del Realm. Para evitar una situación así, es posible establecer RealmConfiguration.Builder.maxNumberOfActiveVersions(long) .

Devuelve

una copia congelada de este objeto.

Throws

• IllegalStateException - if this method is called from inside a write transaction.

returns Realm instance where the model belongs.

You must not call Realm.close() against returned instance.

Parámetros

• model - an RealmModel instance other than DynamicRealmObject .

Devuelve

Realm instance where the model belongs or null if the model is unmanaged.

Throws

• IllegalArgumentException - if the model is null .

• IllegalStateException - si el model es una instancia de DynamicRealmObject o este objeto ya fue eliminado, o el Realm correspondiente ya fue cerrado.

Devuelve la instancia Realm a la que pertenece este RealmObject.

You must not call Realm.close() against returned instance.

Devuelve

Instancia de Realm a la que pertenece este objeto o null si este objeto no está gestionado.

Throws

• IllegalStateException - if this object is an instance of DynamicRealmObject or this object was already deleted or the corresponding Realm was already closed.

Indica si este RealmObject está congelado o no.

Devuelve

true if the RealmObject is frozen, false if it is not.

Indica si este RealmObject está congelado o no.

Devuelve

true if the RealmObject is frozen, false if it is not.

Checks if the query used to find this RealmObject has completed.Async methods like RealmQuery.findFirstAsync() return an RealmObject that represents the future result of the RealmQuery . It can be considered similar to a java.util.concurrent.Future in this regard.

Una vez que isLoaded() devuelva true , el objeto representa el resultado de la query incluso si la query no encontró ningún objeto que cumpla con los parámetros de la query. En este caso, el RealmObject se convertirá en un objeto "null".

"Null" objects represents null . An exception is throw if any accessor is called, so it is important to also check isValid() before calling any methods. A common pattern is:

Person person = realm.where(Person.class).findFirstAsync();
RealmObject.isLoaded(person); // == false
RealmObject.addChangeListener(person, new RealmChangeListener() {
     @Override
     public void onChange(Person person) {
         RealmObject.isLoaded(person); // always true here
         if (RealmObject.isValid(person)) {
             // It is safe to access the person.
         }
     }
});

Synchronous RealmObjects are by definition blocking hence this method will always return true for them. This method will return true if called on an unmanaged object (created outside of Realm).

Parámetros

• object - RealmObject to check.

Devuelve

true si la consulta se ha completado, false si la consulta está en progreso.

Checks if the query used to find this RealmObject has completed.Async methods like RealmQuery.findFirstAsync() return a RealmObject that represents the future result of the RealmQuery . It can be considered similar to a java.util.concurrent.Future in this regard.

Una vez que isLoaded() devuelva true , el objeto representa el resultado de la query incluso si la query no encontró ningún objeto que cumpla con los parámetros de la query. En este caso, el RealmObject se convertirá en un objeto "null".

"Null" objects represents null . An exception is throw if any accessor is called, so it is important to also check isValid() before calling any methods. A common pattern is:

Person person = realm.where(Person.class).findFirstAsync();
person.isLoaded(); // == false
person.addChangeListener(new RealmChangeListener() {
     @Override
     public void onChange(Person person) {
         person.isLoaded(); // Always true here
         if (person.isValid()) {
             // It is safe to access the person.
         }
     }
});

Synchronous RealmObjects are by definition blocking hence this method will always return true for them. This method will return true if called on an unmanaged object (created outside of Realm).

Devuelve

true si la consulta se ha completado, false si la consulta está en progreso.

Verifica si este objeto es gestionado por Realm. Un objeto gestionado es solo un contenedor alrededor de los datos en el archivo Realm subyacente. En los Looper threads, un objeto gestionado se actualizará en vivo para que siempre apunte a los datos más recientes. Es posible registrar un oyente de cambios usando addChangeListener(RealmModel, RealmChangeListener) para recibir notificaciones cuando ocurran cambios. Los objetos gestionados están confinados a un hilo para que no se pueda acceder a ellos desde otros hilos que no sean el que los creó.

Si este método retorna false , el objeto no está gestionado. Un objeto no administrado es simplemente un objeto Java normal, por lo que se puede analizar libremente en todos los hilos, pero los datos en el objeto no están conectados al Realm subyacente, por lo que no se actualizarán en vivo.

It is possible to create a managed object from an unmanaged object by using Realm.copyToRealm(RealmModel, ImportFlag...) . An unmanaged object can be created from a managed object by using Realm.copyFromRealm(RealmModel) .

Devuelve

true si el objeto está gestionado, false si no lo está.

Verifica si este objeto es gestionado por Realm. Un objeto gestionado es solo un contenedor alrededor de los datos en el archivo Realm subyacente. En los Looper threads, un objeto gestionado se actualizará en vivo para que siempre apunte a los datos más recientes. Es posible registrar un observador de cambios utilizando addChangeListener(RealmChangeListener) para recibir notificaciones cuando ocurran cambios. Los objetos gestionados están confinados a un hilo para que no se pueda acceder a ellos desde otros hilos que no sean el que los creó.

Si este método retorna false , el objeto no está gestionado. Un objeto no administrado es simplemente un objeto Java normal, por lo que se puede analizar libremente en todos los hilos, pero los datos en el objeto no están conectados al Realm subyacente, por lo que no se actualizarán en vivo.

It is possible to create a managed object from an unmanaged object by using Realm.copyToRealm(RealmModel, ImportFlag...) . An unmanaged object can be created from a managed object by using Realm.copyFromRealm(RealmModel) .

Devuelve

true si el objeto está gestionado, false si no lo está.

Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the io.realm.Realm been closed. It will always return true for unmanaged objects.

Parámetros

• object - RealmObject to check validity for.

Devuelve

true if the object is still accessible or an unmanaged object, false otherwise.

Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the io.realm.Realm been closed. It will always return true for unmanaged objects.

Note that this can be used to check the validity of certain conditions such as being null when observed.

realm.where(BannerRealm.class).equalTo("type", type).findFirstAsync().asFlowable()
     .filter(result.isLoaded() && result.isValid())
     .first()

Devuelve

true if the object is still accessible or an unmanaged object, false otherwise.

Makes an asynchronous query blocking. This will also trigger any registered listeners.Note: This will return true if called for an unmanaged object (created outside of Realm).

Parámetros

• object - RealmObject to force load.

Devuelve

true if it successfully completed the query, false otherwise.

Makes an asynchronous query blocking. This will also trigger any registered listeners.Note: This will return true if called for an unmanaged object (created outside of Realm).

Devuelve

true if it successfully completed the query, false otherwise.

Removes all registered listeners from the given RealmObject.

Parámetros

• object - RealmObject to remove all listeners from.

Throws

• IllegalArgumentException - if object is null or isn't managed by Realm.

Removes all registered listeners.

Removes a previously registered listener on the given RealmObject.

Parámetros

• object - RealmObject to remove listener from.

• listener - the instance to be removed.

Throws

• IllegalArgumentException - if the object or the change listener is null .

• IllegalArgumentException - si el objeto es un RealmObject no gestionado.

• IllegalStateException - if you try to remove a listener from a non-Looper Thread.

Removes a previously registered listener on the given RealmObject.

Parámetros

• object - RealmObject to remove listener from.

• listener - the instance to be removed.

Throws

• IllegalArgumentException - if the object or the change listener is null .

• IllegalArgumentException - si el objeto es un RealmObject no gestionado.

• IllegalStateException - if you try to remove a listener from a non-Looper Thread.

Removes a previously registered listener.

Parámetros

• listener - the instance to be removed.

Throws

• IllegalArgumentException - if the change listener is null or the object is an unmanaged object.

• IllegalStateException - if you try to remove a listener from a non-Looper Thread.

Removes a previously registered listener.

Parámetros

• listener - the instance to be removed.

Throws

• IllegalArgumentException - if the change listener is null or the object is an unmanaged object.

• IllegalStateException - if you try to remove a listener from a non-Looper Thread.