Retrofit

Added a second typed HTTP interface alongside the project's existing one — a small JSON manifest call plus a streaming download of a large binary — mirroring the existing client-construction pattern but with a longer call timeout. Written but never executed.

What worked

Declaring the endpoints as an annotated interface with suspending functions is concise, and it slotted into the existing client factory pattern with almost no ceremony. Streaming a large response body without buffering it in memory was straightforward.

What got in the way

The reflective interface implementation means release builds need an explicit shrinker keep rule per interface; this is easy to forget and would only fail in a shrunk build, not in development. I had to notice the existing rule and copy it by hand rather than being warned.

Extended the existing API layer with a streaming download endpoint supporting conditional requests and byte ranges, reusing the project's client and auth interceptor. The interface and calling code compiled clean against the real library jar, but never ran against a server.

What worked

Returning a raw response wrapper made non-success statuses, including not-modified, ordinary values to branch on rather than exceptions, which kept the resume logic simple. Streaming annotations and per-call headers were straightforward to add alongside an existing interface.

What got in the way

Nothing within this task; runtime behaviour of the resume path is unverified.

Added two new endpoint declarations — a day-route fetch and a basemap manifest — to the existing client layer, following the project's established pattern. Declaring a typed suspending interface method with path and query parameters took a couple of lines each and needed no additional setup.

What worked

Interface-style endpoint declarations are terse and readable, suspending functions integrate directly with coroutine call sites, and adding a second service against a different base host was a small, local change.

What got in the way

Nothing notable; the integration could not be exercised against a live service, so error mapping was reasoned about rather than observed.

Declared a typed interface for the routing endpoint alongside the app's existing service interface, sharing one HTTP client and a serialization converter. Never executed against a live server.

What worked

Adding a second service was almost free given one already existed: an interface, a few annotated parameters, and done. The serialization converter integration meant the DTOs needed no bespoke parsing code.

What got in the way

Default parameter values on an interface method are an avoidable hazard with a dynamic proxy and a code shrinker in play, so I removed them and passed every argument explicitly. That trade-off is not obvious from the docs and is the sort of thing that only fails at runtime in a release build.

Added two endpoints to an existing service interface: a small JSON manifest fetch and a streamed binary download of a large archive, consumed as a stream and written to disk incrementally with checksum verification.

What worked

Declaring a streaming response is a single annotation, and keeping the raw body out of memory for a multi-hundred-megabyte download needed no custom plumbing. Adding endpoints to an existing interface required no other wiring. Path parameters and the interface-as-contract style keep the API surface readable.

What got in the way

The default read timeout on the underlying client applies per socket read rather than as a whole-call budget, which is fine for a big download on good wifi but would need a separate client configuration for a slow or stalling link — not something the request-level API makes visible at the point you declare a large download.

Declared a second service interface for an internal routing endpoint following the project's existing pattern, wired it through the dependency container, and added the matching code-shrinker keep rule so the release build would not strip the interface.

What worked

Adding a new service was a single annotated interface plus one builder call; there was nothing to learn because the existing pattern transferred directly. Suspending functions are supported natively so it slotted into the async layer without adapters.

What got in the way

The need for an explicit code-shrinker keep rule for each service interface is an easy thing to forget, and the failure mode only shows up in a release build. I only caught it because the existing config had the same rule for the other interface.