1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
package it.niedermann.nextcloud.deck.persistence.sync.adapters.db.util;
import androidx.annotation.NonNull;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MediatorLiveData;
import androidx.lifecycle.Observer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static androidx.lifecycle.Transformations.distinctUntilChanged;
public class LiveDataHelper {
private LiveDataHelper() {
throw new UnsupportedOperationException("This class must not be instantiated.");
}
private static final ExecutorService executor = Executors.newCachedThreadPool();
public static <T> LiveData<T> interceptLiveData(LiveData<T> data, DataChangeProcessor<T> onDataChange) {
MediatorLiveData<T> ret = new MediatorLiveData<>();
ret.addSource(data, changedData ->
executor.submit(() -> {
onDataChange.onDataChanged(changedData);
ret.postValue(changedData);
})
);
return distinctUntilChanged(ret);
}
public static <I, O> LiveData<O> postCustomValue(LiveData<I> data, DataTransformator<I, O> transformator) {
final MediatorLiveData<O> ret = new MediatorLiveData<>();
ret.addSource(data, changedData -> executor.submit(() -> ret.postValue(transformator.transform(changedData))));
return distinctUntilChanged(ret);
}
public static <I> MediatorLiveData<I> of(I oneShot) {
return new MediatorLiveData<I>() {
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
super.observe(owner, observer);
executor.submit(() -> postValue(oneShot));
}
};
}
public static <I, O> LiveData<O> postSingleValue(LiveData<I> data, DataTransformator<I, O> transformator) {
final MediatorLiveData<O> ret = new MediatorLiveData<>();
ret.addSource(data, changedData -> executor.submit(() -> ret.postValue(transformator.transform(changedData))));
return distinctUntilChanged(ret);
}
public static <T> void observeOnce(LiveData<T> liveData, LifecycleOwner owner, Observer<T> observer) {
final Observer<T> tempObserver = new Observer<T>() {
@Override
public void onChanged(T result) {
liveData.removeObserver(this);
observer.onChanged(result);
}
};
liveData.observe(owner, tempObserver);
}
public interface DataChangeProcessor<T> {
void onDataChanged(T data);
}
public interface DataTransformator<I, O> {
O transform(I data);
}
}
|
