Java LiveData.observeForever方法代码示例

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
/**
 * Get the value from a LiveData object. We're waiting for LiveData to emit, for 2 seconds.
 * Once we got a notification via onChanged, we stop observing.
 */
public static <T> T getValue(final LiveData<T> liveData) throws InterruptedException {
  final Object[] data = new Object[1];
  final CountDownLatch latch = new CountDownLatch(1);
  Observer<T> observer = new Observer<T>() {
    @Override
    public void onChanged(@Nullable T o) {
      data[0] = o;
      latch.countDown();
      liveData.removeObserver(this);
    }
  };
  liveData.observeForever(observer);
  latch.await(2, TimeUnit.SECONDS);
  //noinspection unchecked
  return (T) data[0];
}
 

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
public static <T> T getValue(LiveData<T> liveData) throws InterruptedException {
    final Object[] data = new Object[1];
    CountDownLatch latch = new CountDownLatch(1);
    Observer<T> observer = new Observer<T>() {
        @Override
        public void onChanged(@Nullable T o) {
            data[0] = o;
            latch.countDown();
            liveData.removeObserver(this);
        }
    };
    liveData.observeForever(observer);
    latch.await(2, TimeUnit.SECONDS);
    //noinspection unchecked
    return (T) data[0];
}
 

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
/**
 * Get the value from a LiveData object. We're waiting for LiveData to emit, for 2 seconds.
 * Once we got a notification via onChanged, we stop observing.
 */
public static <T> T getValue(final LiveData<T> liveData) throws InterruptedException {
    final Object[] data = new Object[1];
    final CountDownLatch latch = new CountDownLatch(1);
    Observer<T> observer = new Observer<T>() {
        @Override
        public void onChanged(@Nullable T o) {
            data[0] = o;
            latch.countDown();
            liveData.removeObserver(this);
        }
    };
    liveData.observeForever(observer);
    latch.await(2, TimeUnit.SECONDS);
    //noinspection unchecked
    return (T) data[0];
}
 

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
@Test
public void loadRepoFromNetwork() throws IOException {
    MutableLiveData<Repo> dbData = new MutableLiveData<>();
    when(dao.load("foo", "bar")).thenReturn(dbData);

    Repo repo = TestUtil.createRepo("foo", "bar", "desc");
    LiveData<ApiResponse<Repo>> call = successCall(repo);
    when(service.getRepo("foo", "bar")).thenReturn(call);

    LiveData<Resource<Repo>> data = repository.loadRepo("foo", "bar");
    verify(dao).load("foo", "bar");
    verifyNoMoreInteractions(service);

    Observer observer = mock(Observer.class);
    data.observeForever(observer);
    verifyNoMoreInteractions(service);
    verify(observer).onChanged(Resource.loading(null));
    MutableLiveData<Repo> updatedDbData = new MutableLiveData<>();
    when(dao.load("foo", "bar")).thenReturn(updatedDbData);

    dbData.postValue(null);
    verify(service).getRepo("foo", "bar");
    verify(dao).insert(repo);

    updatedDbData.postValue(repo);
    verify(observer).onChanged(Resource.success(repo));
}
 

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
@Test
public void loadContributors() throws IOException {
    MutableLiveData<List<Contributor>> dbData = new MutableLiveData<>();
    when(dao.loadContributors("foo", "bar")).thenReturn(dbData);

    LiveData<Resource<List<Contributor>>> data = repository.loadContributors("foo",
            "bar");
    verify(dao).loadContributors("foo", "bar");

    verify(service, never()).getContributors(anyString(), anyString());

    Repo repo = TestUtil.createRepo("foo", "bar", "desc");
    Contributor contributor = TestUtil.createContributor(repo, "log", 3);
    // network does not send these
    contributor.setRepoOwner(null);
    contributor.setRepoName(null);
    List<Contributor> contributors = Collections.singletonList(contributor);
    LiveData<ApiResponse<List<Contributor>>> call = successCall(contributors);
    when(service.getContributors("foo", "bar"))
            .thenReturn(call);

    Observer<Resource<List<Contributor>>> observer = mock(Observer.class);
    data.observeForever(observer);

    verify(observer).onChanged(Resource.loading( null));

    MutableLiveData<List<Contributor>> updatedDbData = new MutableLiveData<>();
    when(dao.loadContributors("foo", "bar")).thenReturn(updatedDbData);
    dbData.setValue(Collections.emptyList());

    verify(service).getContributors("foo", "bar");
    ArgumentCaptor<List<Contributor>> inserted = ArgumentCaptor.forClass((Class) List.class);
    verify(dao).insertContributors(inserted.capture());


    assertThat(inserted.getValue().size(), is(1));
    Contributor first = inserted.getValue().get(0);
    assertThat(first.getRepoName(), is("bar"));
    assertThat(first.getRepoOwner(), is("foo"));

    updatedDbData.setValue(contributors);
    verify(observer).onChanged(Resource.success(contributors));
}
 

import android.arch.lifecycle.LiveData; //导入方法依赖的package包/类
@Override
public void onCreate() {
    super.onCreate();

    PreferenceManager.setDefaultValues(this, R.xml.settings, false);

    enableStrictMode();

    SearchEngineManager.getInstance().init(this);

    TelemetryWrapper.init(this);

    registerActivityLifecycleCallbacks(visibilityLifeCycleCallback = new VisibilityLifeCycleCallback(this));

    final LiveData<List<Session>> sessions = SessionManager.getInstance().getSessions();
    sessions.observeForever(new TelemetrySessionObserver());
    sessions.observeForever(new CleanupSessionObserver(this));
}