Android topics — 09: כשהתשובה הישנה מגיעה אחרונה

/**
 * Blocks a worker for a controlled delay and returns a labeled response.
 *
 * @param label text identifying this particular request
 * @param delayMs simulated latency in milliseconds
 * @return one labeled result
 * @throws InterruptedException if cooperative cancellation interrupts the delay
 */
public String[] loadRace(String label, long delayMs) throws InterruptedException {
    Thread.sleep(delayMs);
    return new String[]{label};
}

private final ExecutorService workers = Executors.newFixedThreadPool(2);
private Future<?> slowRequest;
private Future<?> fastRequest;
private int generation;

/**
 * Starts overlapping worker requests with different IDs; only the newest may publish.
 */
public void startRace() {
    if (currentKind() == BooksUiState.Kind.LOADING) {
        return;
    }
    cancelPendingWork();
    state.setValue(BooksUiState.of(BooksUiState.Kind.LOADING));
    int oldRequest = ++generation;
    slowRequest = submitRace("Old result (2 s)", 2000, oldRequest);
    int newRequest = ++generation;
    fastRequest = submitRace("New result (0.4 s)", 400, newRequest);
}

/**
 * Invalidates queued results and interrupts owned work while the UI is loading.
 */
public void cancel() {
    if (currentKind() != BooksUiState.Kind.LOADING) {
        return;
    }
    generation++;
    cancelPendingWork();
    state.setValue(BooksUiState.of(BooksUiState.Kind.IDLE));
}

/**
 * Computes on a worker, then checks relevance and publishes on the main thread.
 *
 * @param label result text for observation
 * @param delayMs controlled worker delay
 * @param requestId generation captured when this request began
 * @return cancellation handle for the submitted worker task
 */
private Future<?> submitRace(String label, long delayMs, int requestId) {
    return workers.submit(() -> {
        try {
            String[] books = repository.loadRace(label, delayMs);
            handler.post(() -> {
                // Decide at publication time, on the thread that owns generation.
                if (requestId == generation) {
                    state.setValue(BooksUiState.success(books));
                }
            });
        } catch (InterruptedException interrupted) {
            // Preserve the cancellation signal rather than swallowing it.
            Thread.currentThread().interrupt();
        }
    });
}

/**
 * Invalidates late publications and releases workers when this ViewModel ends.
 */
@Override
protected void onCleared() {
    generation++;
    cancelPendingWork();
    workers.shutdownNow();
}

/**
 * Removes the queued fake load and interrupts both owned worker tasks.
 * Generation must be changed by the caller to invalidate already posted results.
 */
private void cancelPendingWork() {
    if (pendingLoad != null) {
        handler.removeCallbacks(pendingLoad);
        pendingLoad = null;
    }
    if (slowRequest != null) {
        slowRequest.cancel(true);
        slowRequest = null;
    }
    if (fastRequest != null) {
        fastRequest.cancel(true);
        fastRequest = null;
    }
}

binding.startRace.setOnClickListener(v -> viewModel.startRace());
binding.cancelPending.setOnClickListener(v -> viewModel.cancel());

// In render(BooksUiState state):
binding.startRace.setEnabled(!loading);
binding.cancelPending.setVisibility(loading ? View.VISIBLE : View.GONE);

package com.example.topics;

import androidx.test.core.app.ActivityScenario;
import androidx.test.ext.junit.runners.AndroidJUnit4;

import org.junit.Test;
import org.junit.runner.RunWith;

import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.action.ViewActions.click;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static androidx.test.espresso.matcher.ViewMatchers.withId;
import static androidx.test.espresso.matcher.ViewMatchers.withText;

/** A late response must not replace a newer one or a cancelled screen. */
@RunWith(AndroidJUnit4.class)
public final class AsyncRaceUiTest {
    /**
     * Observes the scripted fast result twice, before and after the slow-result window.
     *
     * @throws InterruptedException if the controlled test wait is interrupted
     */
    @Test
    public void slowOldResultCannotOverwriteFastNewResult() throws InterruptedException {
        try (ActivityScenario<MainActivity> ignored = ActivityScenario.launch(MainActivity.class)) {
            onView(withId(R.id.start_race)).perform(click());
            Thread.sleep(800);
            onView(withId(R.id.book_list)).check(matches(withText("New result (0.4 s)")));
            Thread.sleep(1700);
            onView(withId(R.id.book_list)).check(matches(withText("New result (0.4 s)")));
        }
    }

    /**
     * Checks that scripted requests cannot republish after the user cancels.
     *
     * @throws InterruptedException if the controlled test wait is interrupted
     */
    @Test
    public void cancelPreventsLateResult() throws InterruptedException {
        try (ActivityScenario<MainActivity> ignored = ActivityScenario.launch(MainActivity.class)) {
            onView(withId(R.id.start_race)).perform(click());
            onView(withId(R.id.cancel_pending)).perform(click());
            Thread.sleep(2400);
            onView(withId(R.id.status)).check(matches(withText(R.string.state_idle)));
        }
    }

    /**
     * Checks delivery to the recreated screen while the ViewModel owns the work.
     *
     * @throws InterruptedException if the controlled test wait is interrupted
     */
    @Test
    public void rotationKeepsOneLatestResult() throws InterruptedException {
        try (ActivityScenario<MainActivity> scenario = ActivityScenario.launch(MainActivity.class)) {
            onView(withId(R.id.start_race)).perform(click());
            scenario.recreate();
            Thread.sleep(900);
            onView(withId(R.id.book_list)).check(matches(withText("New result (0.4 s)")));
        }
    }
}