🥸 Watcher
Available Since 0.0.39
After we have made our reactive state its time to put the final piece in the puzzle - watchers. Watchers allow us trigger external operations when the state changes.
@Test
void watch() {
MutableObservable<Integer> observable = Observable.mutable(1);
AtomicInteger count = new AtomicInteger();
// we need to create a watcher manager, every watcher needs to be attached to it
WatcherManager watcherManager = new WatcherManager();
// our watcher performs some checks and increments the count variable
// The attached watcher object allows as to cancel the watcher
AttachedWatcher<Integer> watcher = observable.lazyWatch(watcherManager, num -> {
switch (count.get()) {
case 0 -> assertEquals(1, num);
case 1 -> assertEquals(8, num);
case 2 -> assertEquals(67, num);
default -> fail();
}
count.incrementAndGet();
});
// for anything to happen, we have to call the heartbeat method
// It will trigger every watcher attached to the manager that was flagged as dirty
watcherManager.heartbeat(); // 1
watcherManager.heartbeat(); // No new data
watcherManager.heartbeat(); // No new data
observable.set(8);
watcherManager.heartbeat(); // 8
watcherManager.heartbeat(); // No new data
observable.set(4);
observable.set(67);
watcherManager.heartbeat(); // 67
observable.set(8);
observable.set(67);
watcherManager.heartbeat(); // No new data
watcher.detach(); // Detach watcher from manager
assertFalse(watcher.isAttached()); // Make sure it detach
}
Re-attaching Watchers
Available Since 0.0.52
An AttachedWatcher can be detached from its current operator and re-attached to a different one. This is useful when you need to move a watcher between managers, for example when transferring ownership of a game loop or switching execution contexts.
Once detached, the watcher will no longer be triggered by the original operator's heartbeat. After re-attaching to a new operator, the watcher will respond to the new operator's heartbeat instead.
@Test
void reAttachWatcher() {
MutableObservable<Integer> observable = Observable.mutable(1);
AtomicInteger count = new AtomicInteger();
WatcherManager firstManager = new WatcherManager();
WatcherManager secondManager = new WatcherManager();
AttachedWatcher<Integer> watcher = observable.lazyWatch(firstManager, num -> {
count.incrementAndGet();
});
// watcher reacts to the first manager's heartbeat
firstManager.heartbeat();
assertEquals(1, count.get());
observable.set(10);
firstManager.heartbeat();
assertEquals(2, count.get());
// detach from the first manager
watcher.detach();
// first manager no longer triggers the watcher
observable.set(20);
firstManager.heartbeat();
assertEquals(2, count.get());
// re-attach to a different manager
watcher.attach(secondManager);
// now the second manager drives the watcher
observable.set(25);
secondManager.heartbeat();
assertEquals(3, count.get());
observable.set(30);
secondManager.heartbeat();
assertEquals(4, count.get());
watcher.detach();
}
Last modified: 03 July 2026