Android topics — 08: מבקשת HTTP למודל Java

package com.example.topics;

/** The small typed subset of a JSONPlaceholder todo that this screen needs. */
public final class Todo {
    public int userId;
    public int id;
    public String title;
    public boolean completed;
}

package com.example.topics;

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Path;

/** Maps one HTTP GET route to a typed response. */
public interface TodoApi {
    /**
     * Describes one GET; network work starts only when the returned Call is executed.
     *
     * @param id identifier substituted into the URL path
     * @return a new single-use, cancellable request
     */
    @GET("todos/{id}")
    Call<Todo> getTodo(@Path("id") int id);
}

package com.example.topics;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

import com.google.gson.JsonParseException;
import com.google.gson.stream.MalformedJsonException;

import okhttp3.OkHttpClient;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

/** Owns HTTP, JSON conversion, and response classification outside the Activity. */
public final class TodoRepository {
    public enum Kind { SUCCESS, HTTP_ERROR, NETWORK_ERROR, DECODE_ERROR, INVALID_BODY }

    public static final class Result {
        public final Kind kind;
        public final Todo todo;
        public final int status;
        public final String contentType;
        public final String detail;

        /**
         * Stores one classified response for the screen to interpret.
         *
         * @param kind result category
         * @param todo decoded payload on success, otherwise null
         * @param status HTTP code when available, otherwise zero
         * @param contentType response header when available
         * @param detail diagnostic failure category without sensitive request data
         */
        private Result(Kind kind, Todo todo, int status, String contentType, String detail) {
            this.kind = kind;
            this.todo = todo;
            this.status = status;
            this.contentType = contentType;
            this.detail = detail;
        }
    }

    public interface Listener {
        /**
         * Receives one classified, noncanceled outcome; UI work must use the UI thread.
         *
         * @param result source outcome, with payload only on success
         */
        void onResult(Result result);
    }

    private final TodoApi api;

    /**
     * Creates the production-facing lab client with a public dummy-data endpoint.
     */
    public TodoRepository() {
        this("https://jsonplaceholder.typicode.com/");
    }

    /**
     * Builds the same HTTP pipeline for a configurable endpoint.
     *
     * @param baseUrl endpoint with a trailing slash; tests supply their local server URL
     */
    TodoRepository(String baseUrl) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .retryOnConnectionFailure(false)
                .build();
        api = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .build()
                .create(TodoApi.class);
    }

    /**
     * Enqueues a fresh GET and returns its cancellation handle without blocking.
     *
     * @param id requested resource identifier
     * @param listener recipient of a classified result; canceled calls do not report errors
     * @return the single-use Call owned by the screen
     */
    public Call<Todo> load(int id, Listener listener) {
        Call<Todo> call = api.getTodo(id);
        call.enqueue(new Callback<>() {
            /**
             * Classifies an HTTP response independently from transport success.
             *
             * @param ignored completed call
             * @param response decoded response, whose code and required fields still need checking
             */
            @Override
            public void onResponse(Call<Todo> ignored, Response<Todo> response) {
                String type = response.headers().get("Content-Type");
                if (!response.isSuccessful()) {
                    listener.onResult(new Result(Kind.HTTP_ERROR, null, response.code(), type, ""));
                } else if (response.body() == null || response.body().id <= 0
                        || response.body().title == null || response.body().title.isBlank()) {
                    listener.onResult(new Result(Kind.INVALID_BODY, null, response.code(), type, ""));
                } else {
                    listener.onResult(new Result(Kind.SUCCESS, response.body(), response.code(), type, ""));
                }
            }

            /**
             * Reports known decoding or transport failures unless the caller canceled.
             *
             * @param failedCall failed call, used to distinguish user cancellation
             * @param error transport or converter exception
             */
            @Override
            public void onFailure(Call<Todo> failedCall, Throwable error) {
                if (!failedCall.isCanceled()) {
                    boolean badJson = error instanceof MalformedJsonException
                            || error instanceof JsonParseException;
                    listener.onResult(new Result(badJson || !(error instanceof IOException)
                            ? Kind.DECODE_ERROR : Kind.NETWORK_ERROR, null, 0, null,
                            error.getClass().getSimpleName()));
                }
            }
        });
        return call;
    }
}

private final TodoRepository repository = new TodoRepository();
private Call<Todo> activeCall;
private int generation;
private int lastRequestedId = 1;

// Inside onCreate, after the insets listener:
binding.loadTodo.setOnClickListener(v -> load(1));
binding.loadMissing.setOnClickListener(v -> load(999999));
binding.cancelRequest.setOnClickListener(v -> cancel());
binding.retryRequest.setOnClickListener(v -> load(lastRequestedId));

/**
 * Starts a fresh screen request, remembering its ID for Retry.
 * Only the captured generation may update this Activity when the result arrives.
 *
 * @param id resource identifier to request
 */
private void load(int id) {
    lastRequestedId = id;
    generation++;
    if (activeCall != null) {
        activeCall.cancel();
    }
    int expectedGeneration = generation;
    binding.loadTodo.setEnabled(false);
    binding.loadMissing.setEnabled(false);
    binding.cancelRequest.setVisibility(View.VISIBLE);
    binding.retryRequest.setVisibility(View.GONE);
    binding.loading.setVisibility(View.VISIBLE);
    binding.status.setText(getString(R.string.http_loading, id));
    binding.todoDetail.setText("");

    activeCall = repository.load(id, result -> runOnUiThread(() -> {
        // Cancellation cannot retract every queued callback; reject obsolete generations.
        if (expectedGeneration != generation || isDestroyed()) {
            return;
        }
        activeCall = null;
        binding.loadTodo.setEnabled(true);
        binding.loadMissing.setEnabled(true);
        binding.cancelRequest.setVisibility(View.GONE);
        binding.loading.setVisibility(View.GONE);
        binding.retryRequest.setVisibility(result.kind == TodoRepository.Kind.NETWORK_ERROR
                || (result.kind == TodoRepository.Kind.HTTP_ERROR && result.status >= 500)
                ? View.VISIBLE : View.GONE);
        switch (result.kind) {
            case SUCCESS:
                binding.status.setText(getString(R.string.http_success, result.status, result.contentType));
                Todo todo = result.todo;
                binding.todoDetail.setText(getString(R.string.todo_detail,
                        todo.id, todo.userId, todo.title, todo.completed));
                break;
            case HTTP_ERROR:
                binding.status.setText(getString(R.string.http_error, result.status, result.contentType));
                break;
            case NETWORK_ERROR:
                binding.status.setText(getString(R.string.http_network_error, result.detail));
                break;
            case DECODE_ERROR:
                binding.status.setText(getString(R.string.http_decode_error, result.detail));
                break;
            case INVALID_BODY:
                binding.status.setText(getString(R.string.http_invalid_body, result.status));
                break;
        }
    }));
}

/**
 * Invalidates queued results, requests cancellation, and restores nonloading UI.
 */
private void cancel() {
    generation++;
    if (activeCall != null) {
        activeCall.cancel();
        activeCall = null;
    }
    binding.loadTodo.setEnabled(true);
    binding.loadMissing.setEnabled(true);
    binding.cancelRequest.setVisibility(View.GONE);
    binding.loading.setVisibility(View.GONE);
    binding.status.setText(R.string.http_cancelled);
}

/**
 * Invalidates late results and cancels the request owned by this screen.
 */
@Override
protected void onDestroy() {
    generation++;
    if (activeCall != null) {
        activeCall.cancel();
    }
    super.onDestroy();
}

package com.example.topics;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;

/** Exercises real HTTP response handling without depending on a public endpoint. */
public final class TodoRepositoryTest {
    private MockWebServer server;
    private TodoRepository repository;

    /**
     * Starts a fresh local HTTP server and points the real client at its endpoint.
     *
     * @throws IOException if the local test server cannot start
     */
    @Before
    public void setUp() throws IOException {
        server = new MockWebServer();
        server.start();
        repository = new TodoRepository(server.url("/").toString());
    }

    /**
     * Closes the local server after each test, including tests with failed assertions.
     *
     * @throws IOException if server shutdown fails
     */
    @After
    public void tearDown() throws IOException {
        server.shutdown();
    }

    /**
     * Checks JSON conversion, required fields, status, and the actual outgoing URL path.
     *
     * @throws InterruptedException if the test thread is interrupted while awaiting HTTP
     */
    @Test
    public void validJsonBecomesTypedTodo() throws InterruptedException {
        server.enqueue(new MockResponse().setResponseCode(200)
                .addHeader("Content-Type", "application/json")
                .setBody("{\"userId\":2,\"id\":7,\"title\":\"Study\",\"completed\":true}"));
        TodoRepository.Result result = load(7);
        assertEquals(TodoRepository.Kind.SUCCESS, result.kind);
        assertEquals(200, result.status);
        assertNotNull(result.todo);
        assertEquals(7, result.todo.id);
        assertEquals("Study", result.todo.title);
        assertTrue(result.todo.completed);
        assertEquals("/todos/7", server.takeRequest(3, TimeUnit.SECONDS).getPath());
    }

    /**
     * Checks that an HTTP 404 is a server response, not a transport failure.
     *
     * @throws InterruptedException if awaiting the callback is interrupted
     */
    @Test
    public void missingResourceIsHttpError() throws InterruptedException {
        server.enqueue(new MockResponse().setResponseCode(404).setBody("{}"));
        TodoRepository.Result result = load(999999);
        assertEquals(TodoRepository.Kind.HTTP_ERROR, result.kind);
        assertEquals(404, result.status);
    }

    /**
     * Checks that 200 does not bypass the application's required-field validation.
     *
     * @throws InterruptedException if awaiting the callback is interrupted
     */
    @Test
    public void successfulStatusWithMissingFieldsIsInvalidBody() throws InterruptedException {
        server.enqueue(new MockResponse().setResponseCode(200).setBody("{}"));
        assertEquals(TodoRepository.Kind.INVALID_BODY, load(1).kind);
    }

    /**
     * Checks that malformed JSON is classified as a decoding failure.
     *
     * @throws InterruptedException if awaiting the callback is interrupted
     */
    @Test
    public void malformedJsonIsNotReportedAsSuccess() throws InterruptedException {
        server.enqueue(new MockResponse().setResponseCode(200).setBody("{not json"));
        assertEquals(TodoRepository.Kind.DECODE_ERROR, load(1).kind);
    }

    /**
     * Waits on the JVM test thread for one asynchronous repository outcome.
     *
     * @param id requested resource identity
     * @return classified callback result
     * @throws InterruptedException if the test wait is interrupted
     */
    private TodoRepository.Result load(int id) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        AtomicReference<TodoRepository.Result> result = new AtomicReference<>();
        repository.load(id, value -> {
            result.set(value);
            // Store before signaling so the waiting test reads a completed result.
            latch.countDown();
        });
        assertTrue("HTTP callback did not arrive", latch.await(3, TimeUnit.SECONDS));
        return result.get();
    }
}