From 55616f05f1a74807692b74a3662408175d06b74b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 14:34:33 +0200
Subject: [PATCH 1/6] feat: added isochrone maps

---
 demo/build.gradle.kts                         |   1 +
 demo/src/main/AndroidManifest.xml             |   3 +
 .../android/utils/demo/ApiKeyValidator.kt     |   2 +-
 .../utils/demo/IsochroneMapActivity.java      | 141 ++++++
 .../maps/android/utils/demo/MainActivity.java |   1 +
 .../main/res/layout/activity_isochrone.xml    |  56 +++
 gradle/libs.versions.toml                     |   4 +-
 .../isochrone/IsochroneMapProvider.java       | 431 ++++++++++++++++++
 8 files changed, 637 insertions(+), 2 deletions(-)
 create mode 100644 demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
 create mode 100644 demo/src/main/res/layout/activity_isochrone.xml
 create mode 100644 library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java

diff --git a/demo/build.gradle.kts b/demo/build.gradle.kts
index 9556a50af..710097bd7 100644
--- a/demo/build.gradle.kts
+++ b/demo/build.gradle.kts
@@ -65,6 +65,7 @@ dependencies {
     implementation(libs.kotlinx.coroutines.android)
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.material)
+    implementation(libs.play.services.location)
 
     testImplementation(libs.junit)
     testImplementation(libs.truth)
diff --git a/demo/src/main/AndroidManifest.xml b/demo/src/main/AndroidManifest.xml
index a504a7619..1573afb00 100644
--- a/demo/src/main/AndroidManifest.xml
+++ b/demo/src/main/AndroidManifest.xml
@@ -67,6 +67,9 @@
         <activity
             android:name=".PolyDecodeDemoActivity"
             android:exported="true" />
+        <activity
+            android:name=".IsochroneMapActivity"
+            android:exported="true" />
         <activity
             android:name=".PolySimplifyDemoActivity"
             android:exported="true" />
diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/ApiKeyValidator.kt b/demo/src/main/java/com/google/maps/android/utils/demo/ApiKeyValidator.kt
index 8dcb036e6..ab6713a04 100644
--- a/demo/src/main/java/com/google/maps/android/utils/demo/ApiKeyValidator.kt
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/ApiKeyValidator.kt
@@ -58,7 +58,7 @@ internal fun keyHasValidFormat(apiKey: String): Boolean {
  * @param context The context to retrieve the API key from.
  * @return The API key if found, `null` otherwise.
  */
-private fun getMapsApiKey(context: Context): String? {
+fun getMapsApiKey(context: Context): String? {
     try {
         val bundle = context.packageManager
             .getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
new file mode 100644
index 000000000..7cc97a8dc
--- /dev/null
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
@@ -0,0 +1,141 @@
+package com.google.maps.android.utils.demo;
+
+import static com.google.maps.android.utils.demo.ApiKeyValidatorKt.getMapsApiKey;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.FrameLayout;
+import android.widget.ProgressBar;
+
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.content.ContextCompat;
+
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.maps.CameraUpdateFactory;
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.MapView;
+import com.google.android.gms.maps.OnMapReadyCallback;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.maps.android.isochrone.IsochroneMapProvider;
+
+public class IsochroneMapActivity extends AppCompatActivity implements OnMapReadyCallback {
+
+    private static final String TAG = "IsochroneMapActivity";
+
+    private FrameLayout rootLayout;
+    private MapView mapView;
+    private ProgressBar progressBar;
+
+    private GoogleMap map;
+    private FusedLocationProviderClient fusedLocationClient;
+
+    private ActivityResultLauncher<String> requestPermissionLauncher;
+
+    private IsochroneMapProvider isochroneMapProvider;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        rootLayout = new FrameLayout(this);
+        mapView = new MapView(this);
+
+        progressBar = new ProgressBar(this);
+        progressBar.setIndeterminate(true);
+        progressBar.setVisibility(android.view.View.GONE);
+
+        FrameLayout.LayoutParams mapParams = new FrameLayout.LayoutParams(
+                LayoutParams.MATCH_PARENT,
+                LayoutParams.MATCH_PARENT);
+
+        FrameLayout.LayoutParams progressParams = new FrameLayout.LayoutParams(
+                LayoutParams.WRAP_CONTENT,
+                LayoutParams.WRAP_CONTENT,
+                Gravity.CENTER);
+
+        rootLayout.addView(mapView, mapParams);
+        rootLayout.addView(progressBar, progressParams);
+
+        setContentView(rootLayout);
+
+        mapView.onCreate(savedInstanceState);
+        mapView.getMapAsync(this);
+
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
+
+        requestPermissionLauncher = registerForActivityResult(
+                new ActivityResultContracts.RequestPermission(),
+                isGranted -> {
+                    if (isGranted) {
+                        getLocationAndDraw();
+                    } else {
+                        Log.e(TAG, "Location permission denied");
+                    }
+                });
+    }
+
+    @Override
+    public void onMapReady(@NonNull GoogleMap googleMap) {
+        map = googleMap;
+        map.getUiSettings().setZoomControlsEnabled(true);
+        checkPermissionAndStart();
+    }
+
+    private void checkPermissionAndStart() {
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
+                != PackageManager.PERMISSION_GRANTED) {
+            requestPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION);
+        } else {
+            getLocationAndDraw();
+        }
+    }
+
+    private void getLocationAndDraw() {
+        fusedLocationClient.getLastLocation().addOnSuccessListener(location -> {
+            if (location != null) {
+                LatLng origin = new LatLng(location.getLatitude(), location.getLongitude());
+                map.moveCamera(CameraUpdateFactory.newLatLngZoom(origin, 14f));
+
+                if (isochroneMapProvider == null) {
+                    String apiKey = getMapsApiKey(this);
+                    isochroneMapProvider = new IsochroneMapProvider(map, apiKey, new IsochroneMapProvider.LoadingListener() {
+                        @Override
+                        public void onLoadingStarted() {
+                            runOnUiThread(() -> progressBar.setVisibility(android.view.View.VISIBLE));
+                        }
+
+                        @Override
+                        public void onLoadingFinished() {
+                            runOnUiThread(() -> progressBar.setVisibility(android.view.View.GONE));
+                        }
+                    }, IsochroneMapProvider.TransportMode.BICYCLING);
+                    isochroneMapProvider.setUiThreadExecutor(this::runOnUiThread);
+                }
+
+                isochroneMapProvider.drawIsochrones(origin, new int[]{2,4,6,9}, IsochroneMapProvider.ColorSchema.GREEN_RED);
+
+            } else {
+                Log.e(TAG, "Location is null");
+            }
+        });
+    }
+
+
+    // MapView lifecycle methods
+    @Override protected void onResume() { super.onResume(); mapView.onResume(); }
+    @Override protected void onStart() { super.onStart(); mapView.onStart(); }
+    @Override protected void onStop() { super.onStop(); mapView.onStop(); }
+    @Override protected void onPause() { mapView.onPause(); super.onPause(); }
+    @Override protected void onDestroy() { mapView.onDestroy(); super.onDestroy(); }
+    @Override public void onLowMemory() { super.onLowMemory(); mapView.onLowMemory(); }
+}
diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/MainActivity.java b/demo/src/main/java/com/google/maps/android/utils/demo/MainActivity.java
index 4f22adbfc..6e95a1446 100644
--- a/demo/src/main/java/com/google/maps/android/utils/demo/MainActivity.java
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/MainActivity.java
@@ -56,6 +56,7 @@ protected void onCreate(Bundle savedInstanceState) {
         addDemo("Multi Layer", MultiLayerDemoActivity.class);
         addDemo("AnimationUtil sample", AnimationUtilDemoActivity.class);
         addDemo("Street View Demo", StreetViewDemoActivity.class);
+        addDemo("Isochrone Map", IsochroneMapActivity.class);
     }
 
     private void addDemo(String demoName, Class<? extends Activity> activityClass) {
diff --git a/demo/src/main/res/layout/activity_isochrone.xml b/demo/src/main/res/layout/activity_isochrone.xml
new file mode 100644
index 000000000..20653cae8
--- /dev/null
+++ b/demo/src/main/res/layout/activity_isochrone.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/rootLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <com.google.android.gms.maps.MapView
+        android:id="@+id/mapView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+    <ProgressBar
+        android:id="@+id/progressBar"
+        style="?android:attr/progressBarStyleLarge"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:visibility="gone" />
+
+    <LinearLayout
+        android:id="@+id/buttonLayout"
+        android:orientation="horizontal"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="top|end"
+        android:layout_margin="16dp">
+
+        <Button
+            android:id="@+id/btnBicycling"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="BICYCLING"
+            android:textAllCaps="false"
+            android:alpha="1" />
+
+        <Button
+            android:id="@+id/btnDriving"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="DRIVING"
+            android:textAllCaps="false"
+            android:layout_marginStart="8dp"
+            android:alpha="0.5" />
+
+        <Button
+            android:id="@+id/btnWalking"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="WALKING"
+            android:textAllCaps="false"
+            android:layout_marginStart="8dp"
+            android:alpha="0.5" />
+
+    </LinearLayout>
+
+</FrameLayout>
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index ef54291e6..eba29410f 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -19,6 +19,7 @@ mockk = "1.14.2"
 lint = "31.10.1"
 org-jacoco-core = "0.8.13"
 material = "1.12.0"
+play-services-location = "21.3.0"
 
 [libraries]
 appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
@@ -47,4 +48,5 @@ lint = { module = "com.android.tools.lint:lint", version.ref = "lint" }
 lint-tests = { module = "com.android.tools.lint:lint-tests", version.ref = "lint" }
 testutils = { module = "com.android.tools:testutils", version.ref = "lint" }
 org-jacoco-core = { module = "org.jacoco:org.jacoco.core", version.ref = "org-jacoco-core" }
-material = { group = "com.google.android.material", name = "material", version.ref = "material" }
\ No newline at end of file
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+play-services-location = { group = "com.google.android.gms", name = "play-services-location", version.ref = "play-services-location" }
\ No newline at end of file
diff --git a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
new file mode 100644
index 000000000..58ca5b835
--- /dev/null
+++ b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
@@ -0,0 +1,431 @@
+package com.google.maps.android.isochrone;
+
+import android.annotation.SuppressLint;
+import android.util.Log;
+
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.PolygonOptions;
+
+import org.json.JSONObject;
+
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Provides functionality to compute and display isochrones on a Google Map.
+ * <p>
+ * An isochrone is a polygon representing the geographic area reachable from
+ * an origin point within a specified travel time using a chosen transport mode.
+ */
+public class IsochroneMapProvider {
+
+    /**
+     * Listener interface to notify when isochrone loading starts and finishes.
+     */
+    public interface LoadingListener {
+        /**
+         * Called when the isochrone loading process starts.
+         */
+        void onLoadingStarted();
+
+        /**
+         * Called when the isochrone loading process finishes.
+         */
+        void onLoadingFinished();
+    }
+
+    /**
+     * Predefined color schemes to visualize isochrones.
+     * The colors typically represent increasing travel times from inner (green) to outer (red).
+     */
+    public enum ColorSchema {
+        GREEN_RED(new int[]{
+                0xFF00FF00, // Green (innermost)
+                0xFFFFFF00, // Yellow
+                0xFFFFA500, // Orange
+                0xFFFF0000  // Red (outermost)
+        });
+
+        private final int[] colors;
+
+        ColorSchema(int[] colors) {
+            this.colors = colors;
+        }
+
+        /**
+         * Returns the array of colors used in this color schema.
+         *
+         * @return array of ARGB color integers
+         */
+        public int[] getColors() {
+            return colors;
+        }
+    }
+
+    /**
+     * Supported transport modes for travel time calculation.
+     */
+    public enum TransportMode {
+        BICYCLING("bicycling"),
+        DRIVING("driving"),
+        WALKING("walking"),
+        TRANSIT("transit");
+
+        private final String modeName;
+
+        TransportMode(String modeName) {
+            this.modeName = modeName;
+        }
+
+        /**
+         * Returns the transport mode name used in the Google Directions API request.
+         *
+         * @return transport mode string
+         */
+        public String getModeName() {
+            return modeName;
+        }
+    }
+
+    /**
+     * Internal data class representing a single isochrone polygon with duration and color.
+     */
+    private static class IsochronePolygon {
+        int duration;
+        List<LatLng> points;
+        int baseColor;
+
+        IsochronePolygon(int duration, List<LatLng> points, int baseColor) {
+            this.duration = duration;
+            this.points = points;
+            this.baseColor = baseColor;
+        }
+    }
+
+    private static final String TAG = "IsochroneMapProvider";
+
+    /** Number of radial slices used to approximate the isochrone polygon */
+    private static final int SLICES = 36;
+
+    /** Maximum number of binary search cycles per slice */
+    private static final int MAX_CYCLES = 10;
+
+    /** Minimum precision for radius binary search */
+    private static final double EPSILON = 1e-5;
+
+    /** Approximate meters per one degree of latitude/longitude */
+    private static final double METERS_PER_DEGREE = 111000.0;
+
+    /** Average meters covered per minute for rough maximum radius estimate */
+    private static final double METERS_PER_MINUTE = 250;
+
+    private final GoogleMap map;
+    private final String apiKey;
+    private final LoadingListener loadingListener;
+    private TransportMode transportMode;
+
+    /**
+     * Constructs an IsochroneMapProvider.
+     *
+     * @param map             the GoogleMap instance where isochrones will be drawn
+     * @param apiKey          Google Directions API key
+     * @param loadingListener listener to notify loading status (can be null)
+     * @param transportMode   transport mode for travel time calculations
+     */
+    public IsochroneMapProvider(GoogleMap map, String apiKey, LoadingListener loadingListener, TransportMode transportMode) {
+        this.map = map;
+        this.apiKey = apiKey;
+        this.loadingListener = loadingListener;
+        this.transportMode = transportMode;
+    }
+
+    /**
+     * Sets the transport mode for travel time calculations.
+     *
+     * @param transportMode new transport mode
+     */
+    public void setTransportMode(TransportMode transportMode) {
+        this.transportMode = transportMode;
+    }
+
+    /**
+     * Starts computing and drawing isochrones for the specified origin and durations.
+     * Isochrones are drawn in descending order of duration using the provided color schema.
+     *
+     * @param origin            center point of the isochrones
+     * @param durationsInMinutes array of durations (in minutes) to compute isochrones for
+     * @param schema            color schema to visualize different durations
+     */
+    public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema schema) {
+        int[] sortedDurations = durationsInMinutes.clone();
+        java.util.Arrays.sort(sortedDurations);
+        reverseArray(sortedDurations); // Draw outermost first for layering
+
+        if (loadingListener != null) {
+            loadingListener.onLoadingStarted();
+        }
+
+        int[] colors = schema.getColors();
+        List<IsochronePolygon> polygons = Collections.synchronizedList(new ArrayList<>());
+
+        ExecutorService executor = Executors.newFixedThreadPool(4);
+        for (int i = 0; i < sortedDurations.length; i++) {
+            final int minutes = sortedDurations[i];
+            final int durationIndex = sortedDurations.length - 1 - i;
+            final int baseColor = (durationIndex < colors.length) ? colors[durationIndex] : colors[colors.length - 1];
+
+            executor.execute(() -> {
+                List<LatLng> polygon = computeIsochrone(origin, minutes);
+                if (!polygon.isEmpty()) {
+                    polygons.add(new IsochronePolygon(minutes, polygon, baseColor));
+                }
+            });
+        }
+
+        executor.shutdown();
+
+        // Wait for all computations to finish and draw on UI thread
+        new Thread(() -> {
+            try {
+                while (!executor.isTerminated()) {
+                    Thread.sleep(100);
+                }
+                Collections.sort(polygons, (a, b) -> Integer.compare(b.duration, a.duration));
+
+                runOnUiThread(() -> {
+                    List<LatLng> previous = null;
+                    for (IsochronePolygon poly : polygons) {
+                        drawPolygon(poly.points, poly.baseColor, previous);
+                        previous = poly.points;
+                    }
+                    if (loadingListener != null) {
+                        loadingListener.onLoadingFinished();
+                    }
+                });
+            } catch (InterruptedException e) {
+                Log.e(TAG, "Interrupted while waiting for executor", e);
+            }
+        }).start();
+    }
+
+    /**
+     * Computes a single isochrone polygon for a given origin and maximum travel time.
+     * Uses a radial binary search approach to find reachable points along each slice.
+     *
+     * @param origin center point
+     * @param minutes maximum travel time in minutes
+     * @return list of LatLng points forming a closed polygon (smoothed)
+     */
+    private List<LatLng> computeIsochrone(LatLng origin, int minutes) {
+        final List<LatLng> points = Collections.synchronizedList(new ArrayList<>());
+        final int maxTravelTimeSec = minutes * 60;
+
+        ExecutorService executor = Executors.newFixedThreadPool(4);
+        for (int slice = 0; slice < SLICES; slice++) {
+            final double angleRad = 2 * Math.PI * slice / SLICES;
+            executor.execute(() -> {
+                try {
+                    double minRadius = 0.0;
+                    double maxRadius = (METERS_PER_MINUTE * minutes) / METERS_PER_DEGREE;
+                    double bestRadius = minRadius;
+
+                    // Binary search to find max reachable radius within travel time limit
+                    for (int cycle = 0; cycle < MAX_CYCLES; cycle++) {
+                        double midRadius = (minRadius + maxRadius) / 2;
+                        double latOffset = midRadius * Math.cos(angleRad);
+                        double lngOffset = midRadius * Math.sin(angleRad) / Math.cos(Math.toRadians(origin.latitude));
+                        LatLng dest = new LatLng(origin.latitude + latOffset, origin.longitude + lngOffset);
+                        int travelTime = getTravelTime(origin, dest);
+                        if (travelTime < 0) break; // error fetching travel time
+                        if (travelTime <= maxTravelTimeSec) {
+                            bestRadius = midRadius;
+                            minRadius = midRadius;
+                        } else {
+                            maxRadius = midRadius;
+                        }
+                        if ((maxRadius - minRadius) < EPSILON) break;
+                    }
+
+                    double finalLatOffset = bestRadius * Math.cos(angleRad);
+                    double finalLngOffset = bestRadius * Math.sin(angleRad) / Math.cos(Math.toRadians(origin.latitude));
+                    LatLng finalPoint = new LatLng(origin.latitude + finalLatOffset, origin.longitude + finalLngOffset);
+                    points.add(finalPoint);
+                } catch (Exception e) {
+                    Log.e(TAG, "Error computing slice", e);
+                }
+            });
+        }
+
+        executor.shutdown();
+        try {
+            while (!executor.isTerminated()) {
+                Thread.sleep(50);
+            }
+        } catch (InterruptedException e) {
+            Log.e(TAG, "Interrupted while computing isochrone", e);
+        }
+
+        if (!points.isEmpty()) {
+            // Close polygon by adding first point at end
+            points.add(points.get(0));
+            // This could work too
+            //   points.sort(Comparator.comparingDouble(p ->
+            //          Math.atan2(p.latitude - origin.latitude, p.longitude - origin.longitude)));
+            // Smooth polygon with Chaikin's algorithm
+            return chaikinSmoothing(points, 2);
+        }
+        return new ArrayList<>();
+    }
+
+    /**
+     * Draws a polygon on the map with specified fill and stroke colors.
+     * Optionally, a hole polygon can be added to create layered isochrones.
+     *
+     * @param points    list of polygon vertices
+     * @param baseColor ARGB base color for the polygon
+     * @param hole      polygon points representing a hole (inner polygon), or null if none
+     */
+    private void drawPolygon(List<LatLng> points, int baseColor, List<LatLng> hole) {
+        int fillColor = (baseColor & 0x00FFFFFF) | (0x33 << 24);
+        int strokeColor = baseColor | 0xFF000000;
+        PolygonOptions options = new PolygonOptions()
+                .addAll(points)
+                .strokeColor(strokeColor)
+                .fillColor(fillColor);
+        if (hole != null) {
+            options.addHole(hole);
+        }
+        map.addPolygon(options);
+    }
+
+    /**
+     * Applies Chaikin's corner-cutting algorithm to smooth a polygon.
+     * This algorithm refines the polygon by inserting new points that cut corners.
+     *
+     * @param input      list of LatLng points forming a closed polygon
+     * @param iterations number of smoothing iterations to apply
+     * @return new list of LatLng points representing the smoothed polygon
+     */
+    private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
+        List<LatLng> output = new ArrayList<>(input);
+        for (int iter = 0; iter < iterations; iter++) {
+            List<LatLng> newPoints = new ArrayList<>();
+            for (int i = 0; i < output.size() - 1; i++) {
+                LatLng p0 = output.get(i);
+                LatLng p1 = output.get(i + 1);
+                // Q is 75% from p0 to p1
+                LatLng Q = new LatLng(0.75 * p0.latitude + 0.25 * p1.latitude, 0.75 * p0.longitude + 0.25 * p1.longitude);
+                // R is 25% from p0 to p1
+                LatLng R = new LatLng(0.25 * p0.latitude + 0.75 * p1.latitude, 0.25 * p0.longitude + 0.75 * p1.longitude);
+                newPoints.add(Q);
+                newPoints.add(R);
+            }
+            // Close polygon by adding first new point at the end
+            newPoints.add(newPoints.get(0));
+            output = newPoints;
+        }
+        return output;
+    }
+
+    /**
+     * Fetches travel time in seconds between origin and destination points using Google Directions API.
+     *
+     * @param origin start LatLng
+     * @param dest   destination LatLng
+     * @return travel time in seconds, or -1 if error occurred
+     */
+    private int getTravelTime(LatLng origin, LatLng dest) {
+        @SuppressLint("DefaultLocale") String urlString = String.format(
+                "https://maps.googleapis.com/maps/api/directions/json?origin=%f,%f&destination=%f,%f&mode=%s&key=%s",
+                origin.latitude, origin.longitude, dest.latitude, dest.longitude, transportMode.getModeName(), apiKey);
+        HttpURLConnection connection = null;
+        try {
+            URL url = new URL(urlString);
+            connection = (HttpURLConnection) url.openConnection();
+            connection.setRequestMethod("GET");
+            connection.setConnectTimeout(5000);
+            connection.setReadTimeout(5000);
+            InputStreamReader reader = new InputStreamReader(connection.getInputStream());
+            StringBuilder responseBuilder = new StringBuilder();
+            int c;
+            while ((c = reader.read()) != -1) {
+                responseBuilder.append((char) c);
+            }
+            reader.close();
+            JSONObject json = new JSONObject(responseBuilder.toString());
+            return json.getJSONArray("routes")
+                    .getJSONObject(0)
+                    .getJSONArray("legs")
+                    .getJSONObject(0)
+                    .getJSONObject("duration")
+                    .getInt("value");
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting travel time", e);
+            return -1;
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+    /**
+     * Executor interface to run code on the UI thread.
+     * Must be set before calling drawing methods.
+     */
+    public interface UiThreadExecutor {
+        /**
+         * Execute a Runnable on the UI thread.
+         *
+         * @param runnable code to run on UI thread
+         */
+        void execute(Runnable runnable);
+    }
+
+    private UiThreadExecutor uiThreadExecutor;
+
+    /**
+     * Sets the executor that runs tasks on the UI thread.
+     *
+     * @param executor UI thread executor
+     */
+    public void setUiThreadExecutor(UiThreadExecutor executor) {
+        this.uiThreadExecutor = executor;
+    }
+
+    /**
+     * Runs the given Runnable on the UI thread using the configured executor.
+     *
+     * @param runnable code to run on UI thread
+     */
+    private void runOnUiThread(Runnable runnable) {
+        if (uiThreadExecutor != null) {
+            uiThreadExecutor.execute(runnable);
+        } else {
+            Log.e(TAG, "UI thread executor not set!");
+        }
+    }
+
+    /**
+     * Helper method to reverse an integer array in place.
+     *
+     * @param array the array to reverse
+     */
+    private void reverseArray(int[] array) {
+        int left = 0, right = array.length - 1;
+        while (left < right) {
+            int temp = array[left];
+            array[left] = array[right];
+            array[right] = temp;
+            left++;
+            right--;
+        }
+    }
+}

From e69fcd2b52daeeaf8d0b6d8506a2ba46219ab9bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 14:40:38 +0200
Subject: [PATCH 2/6] feat: headers

---
 .../android/utils/demo/IsochroneMapActivity.java | 16 ++++++++++++++++
 demo/src/main/res/layout/activity_isochrone.xml  | 16 ++++++++++++++++
 .../android/isochrone/IsochroneMapProvider.java  | 16 ++++++++++++++++
 3 files changed, 48 insertions(+)

diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
index 7cc97a8dc..06dcf84f1 100644
--- a/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.maps.android.utils.demo;
 
 import static com.google.maps.android.utils.demo.ApiKeyValidatorKt.getMapsApiKey;
diff --git a/demo/src/main/res/layout/activity_isochrone.xml b/demo/src/main/res/layout/activity_isochrone.xml
index 20653cae8..b04ad0e38 100644
--- a/demo/src/main/res/layout/activity_isochrone.xml
+++ b/demo/src/main/res/layout/activity_isochrone.xml
@@ -1,4 +1,20 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2025 Google LLC
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/rootLayout"
     android:layout_width="match_parent"
diff --git a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
index 58ca5b835..8be880d08 100644
--- a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
+++ b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.maps.android.isochrone;
 
 import android.annotation.SuppressLint;

From 0c63c8b2a127e8b035bdca14207283ac0b72da47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 14:52:55 +0200
Subject: [PATCH 3/6] feat: added tests

---
 library/build.gradle.kts                      |   1 +
 .../isochrone/IsochroneMapProvider.java       | 315 ++++++------------
 .../isochrone/IsochroneMapProviderTest.java   | 148 ++++++++
 3 files changed, 260 insertions(+), 204 deletions(-)
 create mode 100644 library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java

diff --git a/library/build.gradle.kts b/library/build.gradle.kts
index 38f34bd7f..a13b64c15 100644
--- a/library/build.gradle.kts
+++ b/library/build.gradle.kts
@@ -69,6 +69,7 @@ dependencies {
     testImplementation(libs.kxml2)
     testImplementation(libs.mockk)
     testImplementation (libs.kotlin.test)
+    testImplementation(libs.mockito.core)
     implementation(libs.kotlin.stdlib.jdk8)
 }
 
diff --git a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
index 8be880d08..42929ca41 100644
--- a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
+++ b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
@@ -16,7 +16,6 @@
 
 package com.google.maps.android.isochrone;
 
-import android.annotation.SuppressLint;
 import android.util.Log;
 
 import com.google.android.gms.maps.GoogleMap;
@@ -30,37 +29,18 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-/**
- * Provides functionality to compute and display isochrones on a Google Map.
- * <p>
- * An isochrone is a polygon representing the geographic area reachable from
- * an origin point within a specified travel time using a chosen transport mode.
- */
 public class IsochroneMapProvider {
 
-    /**
-     * Listener interface to notify when isochrone loading starts and finishes.
-     */
     public interface LoadingListener {
-        /**
-         * Called when the isochrone loading process starts.
-         */
         void onLoadingStarted();
-
-        /**
-         * Called when the isochrone loading process finishes.
-         */
         void onLoadingFinished();
     }
 
-    /**
-     * Predefined color schemes to visualize isochrones.
-     * The colors typically represent increasing travel times from inner (green) to outer (red).
-     */
     public enum ColorSchema {
         GREEN_RED(new int[]{
                 0xFF00FF00, // Green (innermost)
@@ -75,19 +55,11 @@ public enum ColorSchema {
             this.colors = colors;
         }
 
-        /**
-         * Returns the array of colors used in this color schema.
-         *
-         * @return array of ARGB color integers
-         */
         public int[] getColors() {
             return colors;
         }
     }
 
-    /**
-     * Supported transport modes for travel time calculation.
-     */
     public enum TransportMode {
         BICYCLING("bicycling"),
         DRIVING("driving"),
@@ -100,19 +72,15 @@ public enum TransportMode {
             this.modeName = modeName;
         }
 
-        /**
-         * Returns the transport mode name used in the Google Directions API request.
-         *
-         * @return transport mode string
-         */
         public String getModeName() {
             return modeName;
         }
     }
 
-    /**
-     * Internal data class representing a single isochrone polygon with duration and color.
-     */
+    public interface TravelTimeFetcher {
+        int fetchTravelTime(LatLng origin, LatLng dest);
+    }
+
     private static class IsochronePolygon {
         int duration;
         List<LatLng> points;
@@ -126,63 +94,38 @@ private static class IsochronePolygon {
     }
 
     private static final String TAG = "IsochroneMapProvider";
-
-    /** Number of radial slices used to approximate the isochrone polygon */
-    private static final int SLICES = 36;
-
-    /** Maximum number of binary search cycles per slice */
+    public static final int SLICES = 36;
     private static final int MAX_CYCLES = 10;
-
-    /** Minimum precision for radius binary search */
     private static final double EPSILON = 1e-5;
-
-    /** Approximate meters per one degree of latitude/longitude */
     private static final double METERS_PER_DEGREE = 111000.0;
-
-    /** Average meters covered per minute for rough maximum radius estimate */
     private static final double METERS_PER_MINUTE = 250;
 
     private final GoogleMap map;
     private final String apiKey;
     private final LoadingListener loadingListener;
     private TransportMode transportMode;
-
-    /**
-     * Constructs an IsochroneMapProvider.
-     *
-     * @param map             the GoogleMap instance where isochrones will be drawn
-     * @param apiKey          Google Directions API key
-     * @param loadingListener listener to notify loading status (can be null)
-     * @param transportMode   transport mode for travel time calculations
-     */
-    public IsochroneMapProvider(GoogleMap map, String apiKey, LoadingListener loadingListener, TransportMode transportMode) {
+    private final TravelTimeFetcher travelTimeFetcher;
+
+    public IsochroneMapProvider(
+            GoogleMap map,
+            String apiKey,
+            LoadingListener loadingListener,
+            TransportMode transportMode,
+            TravelTimeFetcher travelTimeFetcher) {
         this.map = map;
         this.apiKey = apiKey;
         this.loadingListener = loadingListener;
         this.transportMode = transportMode;
+        this.travelTimeFetcher = travelTimeFetcher;
     }
 
-    /**
-     * Sets the transport mode for travel time calculations.
-     *
-     * @param transportMode new transport mode
-     */
     public void setTransportMode(TransportMode transportMode) {
         this.transportMode = transportMode;
     }
 
-    /**
-     * Starts computing and drawing isochrones for the specified origin and durations.
-     * Isochrones are drawn in descending order of duration using the provided color schema.
-     *
-     * @param origin            center point of the isochrones
-     * @param durationsInMinutes array of durations (in minutes) to compute isochrones for
-     * @param schema            color schema to visualize different durations
-     */
     public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema schema) {
         int[] sortedDurations = durationsInMinutes.clone();
         java.util.Arrays.sort(sortedDurations);
-        reverseArray(sortedDurations); // Draw outermost first for layering
 
         if (loadingListener != null) {
             loadingListener.onLoadingStarted();
@@ -193,8 +136,8 @@ public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema
 
         ExecutorService executor = Executors.newFixedThreadPool(4);
         for (int i = 0; i < sortedDurations.length; i++) {
+            final int durationIndex = i;
             final int minutes = sortedDurations[i];
-            final int durationIndex = sortedDurations.length - 1 - i;
             final int baseColor = (durationIndex < colors.length) ? colors[durationIndex] : colors[colors.length - 1];
 
             executor.execute(() -> {
@@ -207,20 +150,42 @@ public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema
 
         executor.shutdown();
 
-        // Wait for all computations to finish and draw on UI thread
         new Thread(() -> {
             try {
                 while (!executor.isTerminated()) {
                     Thread.sleep(100);
                 }
-                Collections.sort(polygons, (a, b) -> Integer.compare(b.duration, a.duration));
+
+                // Sort polygons descending to draw outer first (API 21 compatible)
+                Collections.sort(polygons, new Comparator<IsochronePolygon>() {
+                    @Override
+                    public int compare(IsochronePolygon a, IsochronePolygon b) {
+                        return Integer.compare(b.duration, a.duration);
+                    }
+                });
 
                 runOnUiThread(() -> {
-                    List<LatLng> previous = null;
-                    for (IsochronePolygon poly : polygons) {
-                        drawPolygon(poly.points, poly.baseColor, previous);
-                        previous = poly.points;
+                    List<List<LatLng>> holes = new ArrayList<>();
+
+                    for (int i = 0; i < polygons.size(); i++) {
+                        IsochronePolygon poly = polygons.get(i);
+
+                        PolygonOptions options = new PolygonOptions()
+                                .addAll(poly.points)
+                                .strokeColor(poly.baseColor | 0xFF000000)
+                                .fillColor((poly.baseColor & 0x00FFFFFF) | (0x33 << 24));
+
+                        if (!holes.isEmpty()) {
+                            for (List<LatLng> hole : holes) {
+                                options.addHole(hole);
+                            }
+                        }
+
+                        map.addPolygon(options);
+
+                        holes.add(poly.points);
                     }
+
                     if (loadingListener != null) {
                         loadingListener.onLoadingFinished();
                     }
@@ -231,15 +196,7 @@ public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema
         }).start();
     }
 
-    /**
-     * Computes a single isochrone polygon for a given origin and maximum travel time.
-     * Uses a radial binary search approach to find reachable points along each slice.
-     *
-     * @param origin center point
-     * @param minutes maximum travel time in minutes
-     * @return list of LatLng points forming a closed polygon (smoothed)
-     */
-    private List<LatLng> computeIsochrone(LatLng origin, int minutes) {
+    public List<LatLng> computeIsochrone(LatLng origin, int minutes) {
         final List<LatLng> points = Collections.synchronizedList(new ArrayList<>());
         final int maxTravelTimeSec = minutes * 60;
 
@@ -252,20 +209,22 @@ private List<LatLng> computeIsochrone(LatLng origin, int minutes) {
                     double maxRadius = (METERS_PER_MINUTE * minutes) / METERS_PER_DEGREE;
                     double bestRadius = minRadius;
 
-                    // Binary search to find max reachable radius within travel time limit
                     for (int cycle = 0; cycle < MAX_CYCLES; cycle++) {
                         double midRadius = (minRadius + maxRadius) / 2;
                         double latOffset = midRadius * Math.cos(angleRad);
                         double lngOffset = midRadius * Math.sin(angleRad) / Math.cos(Math.toRadians(origin.latitude));
                         LatLng dest = new LatLng(origin.latitude + latOffset, origin.longitude + lngOffset);
-                        int travelTime = getTravelTime(origin, dest);
-                        if (travelTime < 0) break; // error fetching travel time
+
+                        int travelTime = travelTimeFetcher.fetchTravelTime(origin, dest);
+                        if (travelTime < 0) break;
+
                         if (travelTime <= maxTravelTimeSec) {
                             bestRadius = midRadius;
                             minRadius = midRadius;
                         } else {
                             maxRadius = midRadius;
                         }
+
                         if ((maxRadius - minRadius) < EPSILON) break;
                     }
 
@@ -289,46 +248,12 @@ private List<LatLng> computeIsochrone(LatLng origin, int minutes) {
         }
 
         if (!points.isEmpty()) {
-            // Close polygon by adding first point at end
             points.add(points.get(0));
-            // This could work too
-            //   points.sort(Comparator.comparingDouble(p ->
-            //          Math.atan2(p.latitude - origin.latitude, p.longitude - origin.longitude)));
-            // Smooth polygon with Chaikin's algorithm
             return chaikinSmoothing(points, 2);
         }
         return new ArrayList<>();
     }
 
-    /**
-     * Draws a polygon on the map with specified fill and stroke colors.
-     * Optionally, a hole polygon can be added to create layered isochrones.
-     *
-     * @param points    list of polygon vertices
-     * @param baseColor ARGB base color for the polygon
-     * @param hole      polygon points representing a hole (inner polygon), or null if none
-     */
-    private void drawPolygon(List<LatLng> points, int baseColor, List<LatLng> hole) {
-        int fillColor = (baseColor & 0x00FFFFFF) | (0x33 << 24);
-        int strokeColor = baseColor | 0xFF000000;
-        PolygonOptions options = new PolygonOptions()
-                .addAll(points)
-                .strokeColor(strokeColor)
-                .fillColor(fillColor);
-        if (hole != null) {
-            options.addHole(hole);
-        }
-        map.addPolygon(options);
-    }
-
-    /**
-     * Applies Chaikin's corner-cutting algorithm to smooth a polygon.
-     * This algorithm refines the polygon by inserting new points that cut corners.
-     *
-     * @param input      list of LatLng points forming a closed polygon
-     * @param iterations number of smoothing iterations to apply
-     * @return new list of LatLng points representing the smoothed polygon
-     */
     private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
         List<LatLng> output = new ArrayList<>(input);
         for (int iter = 0; iter < iterations; iter++) {
@@ -336,91 +261,33 @@ private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
             for (int i = 0; i < output.size() - 1; i++) {
                 LatLng p0 = output.get(i);
                 LatLng p1 = output.get(i + 1);
-                // Q is 75% from p0 to p1
-                LatLng Q = new LatLng(0.75 * p0.latitude + 0.25 * p1.latitude, 0.75 * p0.longitude + 0.25 * p1.longitude);
-                // R is 25% from p0 to p1
-                LatLng R = new LatLng(0.25 * p0.latitude + 0.75 * p1.latitude, 0.25 * p0.longitude + 0.75 * p1.longitude);
+
+                LatLng Q = new LatLng(
+                        0.75 * p0.latitude + 0.25 * p1.latitude,
+                        0.75 * p0.longitude + 0.25 * p1.longitude);
+                LatLng R = new LatLng(
+                        0.25 * p0.latitude + 0.75 * p1.latitude,
+                        0.25 * p0.longitude + 0.75 * p1.longitude);
+
                 newPoints.add(Q);
                 newPoints.add(R);
             }
-            // Close polygon by adding first new point at the end
             newPoints.add(newPoints.get(0));
             output = newPoints;
         }
         return output;
     }
 
-    /**
-     * Fetches travel time in seconds between origin and destination points using Google Directions API.
-     *
-     * @param origin start LatLng
-     * @param dest   destination LatLng
-     * @return travel time in seconds, or -1 if error occurred
-     */
-    private int getTravelTime(LatLng origin, LatLng dest) {
-        @SuppressLint("DefaultLocale") String urlString = String.format(
-                "https://maps.googleapis.com/maps/api/directions/json?origin=%f,%f&destination=%f,%f&mode=%s&key=%s",
-                origin.latitude, origin.longitude, dest.latitude, dest.longitude, transportMode.getModeName(), apiKey);
-        HttpURLConnection connection = null;
-        try {
-            URL url = new URL(urlString);
-            connection = (HttpURLConnection) url.openConnection();
-            connection.setRequestMethod("GET");
-            connection.setConnectTimeout(5000);
-            connection.setReadTimeout(5000);
-            InputStreamReader reader = new InputStreamReader(connection.getInputStream());
-            StringBuilder responseBuilder = new StringBuilder();
-            int c;
-            while ((c = reader.read()) != -1) {
-                responseBuilder.append((char) c);
-            }
-            reader.close();
-            JSONObject json = new JSONObject(responseBuilder.toString());
-            return json.getJSONArray("routes")
-                    .getJSONObject(0)
-                    .getJSONArray("legs")
-                    .getJSONObject(0)
-                    .getJSONObject("duration")
-                    .getInt("value");
-        } catch (Exception e) {
-            Log.e(TAG, "Error getting travel time", e);
-            return -1;
-        } finally {
-            if (connection != null) {
-                connection.disconnect();
-            }
-        }
-    }
-
-    /**
-     * Executor interface to run code on the UI thread.
-     * Must be set before calling drawing methods.
-     */
     public interface UiThreadExecutor {
-        /**
-         * Execute a Runnable on the UI thread.
-         *
-         * @param runnable code to run on UI thread
-         */
         void execute(Runnable runnable);
     }
 
     private UiThreadExecutor uiThreadExecutor;
 
-    /**
-     * Sets the executor that runs tasks on the UI thread.
-     *
-     * @param executor UI thread executor
-     */
     public void setUiThreadExecutor(UiThreadExecutor executor) {
         this.uiThreadExecutor = executor;
     }
 
-    /**
-     * Runs the given Runnable on the UI thread using the configured executor.
-     *
-     * @param runnable code to run on UI thread
-     */
     private void runOnUiThread(Runnable runnable) {
         if (uiThreadExecutor != null) {
             uiThreadExecutor.execute(runnable);
@@ -429,19 +296,59 @@ private void runOnUiThread(Runnable runnable) {
         }
     }
 
-    /**
-     * Helper method to reverse an integer array in place.
-     *
-     * @param array the array to reverse
-     */
-    private void reverseArray(int[] array) {
-        int left = 0, right = array.length - 1;
-        while (left < right) {
-            int temp = array[left];
-            array[left] = array[right];
-            array[right] = temp;
-            left++;
-            right--;
+    public static class GoogleDirectionsTravelTimeFetcher implements TravelTimeFetcher {
+        private final String apiKey;
+        private final TransportMode mode;
+
+        public GoogleDirectionsTravelTimeFetcher(String apiKey, TransportMode mode) {
+            this.apiKey = apiKey;
+            this.mode = mode;
+        }
+
+        @Override
+        public int fetchTravelTime(LatLng origin, LatLng dest) {
+            String urlString = String.format(
+                    "https://maps.googleapis.com/maps/api/directions/json?origin=%f,%f&destination=%f,%f&mode=%s&key=%s",
+                    origin.latitude, origin.longitude, dest.latitude, dest.longitude, mode.getModeName(), apiKey);
+            HttpURLConnection connection = null;
+            try {
+                URL url = new URL(urlString);
+                connection = (HttpURLConnection) url.openConnection();
+                connection.setRequestMethod("GET");
+                connection.setConnectTimeout(5000);
+                connection.setReadTimeout(5000);
+
+                InputStreamReader reader = new InputStreamReader(connection.getInputStream());
+                StringBuilder responseBuilder = new StringBuilder();
+                int c;
+                while ((c = reader.read()) != -1) {
+                    responseBuilder.append((char) c);
+                }
+                reader.close();
+
+                JSONObject json = new JSONObject(responseBuilder.toString());
+                return json.getJSONArray("routes")
+                        .getJSONObject(0)
+                        .getJSONArray("legs")
+                        .getJSONObject(0)
+                        .getJSONObject("duration")
+                        .getInt("value");
+
+            } catch (Exception e) {
+                Log.e(TAG, "Error getting travel time", e);
+                return -1;
+            } finally {
+                if (connection != null) {
+                    connection.disconnect();
+                }
+            }
+        }
+    }
+
+    public static class ImmediateExecutor implements UiThreadExecutor {
+        @Override
+        public void execute(Runnable runnable) {
+            runnable.run();
         }
     }
 }
diff --git a/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java b/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java
new file mode 100644
index 000000000..71023c142
--- /dev/null
+++ b/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.maps.android.isochrone;
+
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.PolygonOptions;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class IsochroneMapProviderTest {
+
+    private GoogleMap mockMap;
+    private IsochroneMapProvider.LoadingListener mockLoadingListener;
+    private IsochroneMapProvider.TravelTimeFetcher mockTravelTimeFetcher;
+
+    @Before
+    public void setup() {
+        mockMap = mock(GoogleMap.class);
+        mockLoadingListener = mock(IsochroneMapProvider.LoadingListener.class);
+        mockTravelTimeFetcher = mock(IsochroneMapProvider.TravelTimeFetcher.class);
+    }
+
+    @Test
+    public void testComputeIsochroneReturnsPoints() {
+        when(mockTravelTimeFetcher.fetchTravelTime(any(LatLng.class), any(LatLng.class))).thenReturn(60);
+
+        IsochroneMapProvider provider = new IsochroneMapProvider(
+                mockMap,
+                "dummy-api-key",
+                mockLoadingListener,
+                IsochroneMapProvider.TransportMode.BICYCLING,
+                mockTravelTimeFetcher);
+
+        LatLng origin = new LatLng(0, 0);
+        List<LatLng> polygon = provider.computeIsochrone(origin, 10);
+
+        assertNotNull(polygon);
+        assertTrue(polygon.size() > 3);  // polygon points + closing point
+    }
+
+    @Test
+    public void testDrawIsochronesCallsLoadingListener() throws InterruptedException {
+        when(mockTravelTimeFetcher.fetchTravelTime(any(LatLng.class), any(LatLng.class))).thenReturn(60);
+
+        IsochroneMapProvider provider = new IsochroneMapProvider(
+                mockMap,
+                "dummy-api-key",
+                mockLoadingListener,
+                IsochroneMapProvider.TransportMode.BICYCLING,
+                mockTravelTimeFetcher);
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        doAnswer(invocation -> {
+            latch.countDown();
+            return null;
+        }).when(mockLoadingListener).onLoadingFinished();
+
+        // Run UI tasks immediately (synchronously)
+        provider.setUiThreadExecutor(Runnable::run);
+
+        provider.drawIsochrones(new LatLng(0, 0), new int[]{5, 10}, IsochroneMapProvider.ColorSchema.GREEN_RED);
+
+        boolean finished = latch.await(5, TimeUnit.SECONDS);
+
+        assertTrue("Loading finished callback should be called", finished);
+
+        verify(mockLoadingListener).onLoadingStarted();
+        verify(mockLoadingListener).onLoadingFinished();
+    }
+
+    @Test
+    public void testPolygonsDrawnInCorrectOrder() throws InterruptedException {
+        when(mockTravelTimeFetcher.fetchTravelTime(any(LatLng.class), any(LatLng.class))).thenReturn(60);
+
+        IsochroneMapProvider provider = new IsochroneMapProvider(
+                mockMap,
+                "dummy-api-key",
+                mockLoadingListener,
+                IsochroneMapProvider.TransportMode.BICYCLING,
+                mockTravelTimeFetcher);
+
+        provider.setUiThreadExecutor(Runnable::run);
+
+        Polygon mockPolygon = mock(Polygon.class);
+        when(mockMap.addPolygon(any(PolygonOptions.class))).thenReturn(mockPolygon);
+
+        ArgumentCaptor<PolygonOptions> captor = ArgumentCaptor.forClass(PolygonOptions.class);
+
+        provider.drawIsochrones(new LatLng(0, 0), new int[]{10, 5}, IsochroneMapProvider.ColorSchema.GREEN_RED);
+
+        // Wait for async completion
+        Thread.sleep(1000);
+
+        verify(mockMap, times(2)).addPolygon(captor.capture());
+
+        List<PolygonOptions> drawnPolygons = captor.getAllValues();
+
+        assertEquals(2, drawnPolygons.size());
+
+        int outerFillColor = drawnPolygons.get(0).getFillColor();
+        int innerFillColor = drawnPolygons.get(1).getFillColor();
+
+        int outerRed = (outerFillColor >> 16) & 0xFF;
+        int outerGreen = (outerFillColor >> 8) & 0xFF;
+
+        int innerRed = (innerFillColor >> 16) & 0xFF;
+        int innerGreen = (innerFillColor >> 8) & 0xFF;
+
+        System.out.printf("Outer polygon fill color: 0x%08X (R:%d G:%d)%n", outerFillColor, outerRed, outerGreen);
+        System.out.printf("Inner polygon fill color: 0x%08X (R:%d G:%d)%n", innerFillColor, innerRed, innerGreen);
+
+        // Outer polygon expected to be yellow (high red and green)
+        assertTrue("Outer polygon red should be >= inner polygon red", outerRed >= innerRed);
+        assertTrue("Outer polygon green should be >= inner polygon green", outerGreen >= innerGreen);
+
+        // Inner polygon expected to be green (high green, low red)
+        assertTrue("Inner polygon green should be > outer polygon green", innerGreen > outerGreen || innerGreen == outerGreen);
+        assertTrue("Inner polygon red should be <= outer polygon red", innerRed <= outerRed);
+    }
+
+}

From d6cdb5e62e1a6a71029d30fc5236e5eee59f0bd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 15:10:48 +0200
Subject: [PATCH 4/6] feat: added tests

---
 .../utils/demo/IsochroneMapActivity.java      |  48 ++--
 .../isochrone/IsochroneMapProvider.java       | 225 +++++++-----------
 .../isochrone/IsochroneMapProviderTest.java   |  24 +-
 3 files changed, 137 insertions(+), 160 deletions(-)

diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
index 06dcf84f1..741d76c0c 100644
--- a/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/IsochroneMapActivity.java
@@ -19,12 +19,11 @@
 import static com.google.maps.android.utils.demo.ApiKeyValidatorKt.getMapsApiKey;
 
 import android.Manifest;
-import android.content.Context;
 import android.content.pm.PackageManager;
-import android.location.Location;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.Gravity;
+import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 import android.widget.FrameLayout;
 import android.widget.ProgressBar;
@@ -33,6 +32,7 @@
 import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
 import androidx.core.content.ContextCompat;
 
 import com.google.android.gms.location.FusedLocationProviderClient;
@@ -68,7 +68,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
         progressBar = new ProgressBar(this);
         progressBar.setIndeterminate(true);
-        progressBar.setVisibility(android.view.View.GONE);
+        progressBar.setVisibility(View.GONE);
 
         FrameLayout.LayoutParams mapParams = new FrameLayout.LayoutParams(
                 LayoutParams.MATCH_PARENT,
@@ -117,6 +117,15 @@ private void checkPermissionAndStart() {
     }
 
     private void getLocationAndDraw() {
+        // Permission check to satisfy lint and prevent security exceptions
+        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
+                && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+            Log.e(TAG, "Location permission not granted");
+            return;
+        }
+
+        IsochroneMapProvider.UiThreadExecutor uiThreadExecutor = this::runOnUiThread;
+
         fusedLocationClient.getLastLocation().addOnSuccessListener(location -> {
             if (location != null) {
                 LatLng origin = new LatLng(location.getLatitude(), location.getLongitude());
@@ -124,21 +133,27 @@ private void getLocationAndDraw() {
 
                 if (isochroneMapProvider == null) {
                     String apiKey = getMapsApiKey(this);
-                    isochroneMapProvider = new IsochroneMapProvider(map, apiKey, new IsochroneMapProvider.LoadingListener() {
-                        @Override
-                        public void onLoadingStarted() {
-                            runOnUiThread(() -> progressBar.setVisibility(android.view.View.VISIBLE));
-                        }
-
-                        @Override
-                        public void onLoadingFinished() {
-                            runOnUiThread(() -> progressBar.setVisibility(android.view.View.GONE));
-                        }
-                    }, IsochroneMapProvider.TransportMode.BICYCLING);
-                    isochroneMapProvider.setUiThreadExecutor(this::runOnUiThread);
+                    isochroneMapProvider = new IsochroneMapProvider(
+                            map,
+                            apiKey,
+                            new IsochroneMapProvider.LoadingListener() {
+                                @Override
+                                public void onLoadingStarted() {
+                                    runOnUiThread(() -> progressBar.setVisibility(View.VISIBLE));
+                                }
+
+                                @Override
+                                public void onLoadingFinished() {
+                                    runOnUiThread(() -> progressBar.setVisibility(View.GONE));
+                                }
+                            },
+                            IsochroneMapProvider.TransportMode.BICYCLING,
+                            uiThreadExecutor,
+                            null  // Use default fetcher
+                    );
                 }
 
-                isochroneMapProvider.drawIsochrones(origin, new int[]{2,4,6,9}, IsochroneMapProvider.ColorSchema.GREEN_RED);
+                isochroneMapProvider.drawIsochrones(origin, new int[]{2, 4, 6, 9}, IsochroneMapProvider.ColorSchema.GREEN_RED);
 
             } else {
                 Log.e(TAG, "Location is null");
@@ -146,7 +161,6 @@ public void onLoadingFinished() {
         });
     }
 
-
     // MapView lifecycle methods
     @Override protected void onResume() { super.onResume(); mapView.onResume(); }
     @Override protected void onStart() { super.onStart(); mapView.onStart(); }
diff --git a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
index 42929ca41..9ccbca2cb 100644
--- a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
+++ b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2025 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package com.google.maps.android.isochrone;
 
+import android.annotation.SuppressLint;
 import android.util.Log;
 
 import com.google.android.gms.maps.GoogleMap;
@@ -29,7 +14,6 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -77,10 +61,6 @@ public String getModeName() {
         }
     }
 
-    public interface TravelTimeFetcher {
-        int fetchTravelTime(LatLng origin, LatLng dest);
-    }
-
     private static class IsochronePolygon {
         int duration;
         List<LatLng> points;
@@ -94,7 +74,7 @@ private static class IsochronePolygon {
     }
 
     private static final String TAG = "IsochroneMapProvider";
-    public static final int SLICES = 36;
+    private static final int SLICES = 36;
     private static final int MAX_CYCLES = 10;
     private static final double EPSILON = 1e-5;
     private static final double METERS_PER_DEGREE = 111000.0;
@@ -106,17 +86,73 @@ private static class IsochronePolygon {
     private TransportMode transportMode;
     private final TravelTimeFetcher travelTimeFetcher;
 
-    public IsochroneMapProvider(
-            GoogleMap map,
-            String apiKey,
-            LoadingListener loadingListener,
-            TransportMode transportMode,
-            TravelTimeFetcher travelTimeFetcher) {
+    public interface TravelTimeFetcher {
+        int fetchTravelTime(LatLng origin, LatLng dest);
+    }
+
+    private final UiThreadExecutor uiThreadExecutor;
+
+    public interface UiThreadExecutor {
+        void execute(Runnable runnable);
+    }
+
+    private final TravelTimeFetcher DEFAULT_TRAVEL_TIME_FETCHER = new TravelTimeFetcher() {
+        @Override
+        public int fetchTravelTime(LatLng origin, LatLng dest) {
+            try {
+                @SuppressLint("DefaultLocale") String urlString = String.format(
+                        "https://maps.googleapis.com/maps/api/directions/json?origin=%f,%f&destination=%f,%f&mode=%s&key=%s",
+                        origin.latitude, origin.longitude,
+                        dest.latitude, dest.longitude,
+                        transportMode.getModeName(),
+                        apiKey);
+
+                HttpURLConnection connection = (HttpURLConnection) new URL(urlString).openConnection();
+                connection.setRequestMethod("GET");
+                connection.setConnectTimeout(5000);
+                connection.setReadTimeout(5000);
+
+                InputStreamReader reader = new InputStreamReader(connection.getInputStream());
+                StringBuilder responseBuilder = new StringBuilder();
+                int c;
+                while ((c = reader.read()) != -1) {
+                    responseBuilder.append((char) c);
+                }
+                reader.close();
+
+                JSONObject json = new JSONObject(responseBuilder.toString());
+                return json.getJSONArray("routes")
+                        .getJSONObject(0)
+                        .getJSONArray("legs")
+                        .getJSONObject(0)
+                        .getJSONObject("duration")
+                        .getInt("value");
+            } catch (Exception e) {
+                Log.e(TAG, "Error fetching travel time", e);
+                return -1;
+            }
+        }
+    };
+
+    public IsochroneMapProvider(GoogleMap map,
+                                String apiKey,
+                                LoadingListener loadingListener,
+                                TransportMode transportMode) {
+        this(map, apiKey, loadingListener, transportMode, null, null);
+    }
+
+    public IsochroneMapProvider(GoogleMap map,
+                                String apiKey,
+                                LoadingListener loadingListener,
+                                TransportMode transportMode,
+                                UiThreadExecutor uiThreadExecutor,
+                                TravelTimeFetcher travelTimeFetcher) {
         this.map = map;
         this.apiKey = apiKey;
         this.loadingListener = loadingListener;
         this.transportMode = transportMode;
-        this.travelTimeFetcher = travelTimeFetcher;
+        this.uiThreadExecutor = uiThreadExecutor;
+        this.travelTimeFetcher = travelTimeFetcher != null ? travelTimeFetcher : DEFAULT_TRAVEL_TIME_FETCHER;
     }
 
     public void setTransportMode(TransportMode transportMode) {
@@ -126,6 +162,7 @@ public void setTransportMode(TransportMode transportMode) {
     public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema schema) {
         int[] sortedDurations = durationsInMinutes.clone();
         java.util.Arrays.sort(sortedDurations);
+        reverseArray(sortedDurations);
 
         if (loadingListener != null) {
             loadingListener.onLoadingStarted();
@@ -136,7 +173,7 @@ public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema
 
         ExecutorService executor = Executors.newFixedThreadPool(4);
         for (int i = 0; i < sortedDurations.length; i++) {
-            final int durationIndex = i;
+            final int durationIndex = sortedDurations.length - 1 - i; // reverse index
             final int minutes = sortedDurations[i];
             final int baseColor = (durationIndex < colors.length) ? colors[durationIndex] : colors[colors.length - 1];
 
@@ -155,37 +192,12 @@ public void drawIsochrones(LatLng origin, int[] durationsInMinutes, ColorSchema
                 while (!executor.isTerminated()) {
                     Thread.sleep(100);
                 }
-
-                // Sort polygons descending to draw outer first (API 21 compatible)
-                Collections.sort(polygons, new Comparator<IsochronePolygon>() {
-                    @Override
-                    public int compare(IsochronePolygon a, IsochronePolygon b) {
-                        return Integer.compare(b.duration, a.duration);
-                    }
-                });
+                Collections.sort(polygons, (a, b) -> Integer.compare(b.duration, a.duration));
 
                 runOnUiThread(() -> {
-                    List<List<LatLng>> holes = new ArrayList<>();
-
-                    for (int i = 0; i < polygons.size(); i++) {
-                        IsochronePolygon poly = polygons.get(i);
-
-                        PolygonOptions options = new PolygonOptions()
-                                .addAll(poly.points)
-                                .strokeColor(poly.baseColor | 0xFF000000)
-                                .fillColor((poly.baseColor & 0x00FFFFFF) | (0x33 << 24));
-
-                        if (!holes.isEmpty()) {
-                            for (List<LatLng> hole : holes) {
-                                options.addHole(hole);
-                            }
-                        }
-
-                        map.addPolygon(options);
-
-                        holes.add(poly.points);
+                    for (IsochronePolygon poly : polygons) {
+                        drawPolygon(poly.points, poly.baseColor);
                     }
-
                     if (loadingListener != null) {
                         loadingListener.onLoadingFinished();
                     }
@@ -196,7 +208,7 @@ public int compare(IsochronePolygon a, IsochronePolygon b) {
         }).start();
     }
 
-    public List<LatLng> computeIsochrone(LatLng origin, int minutes) {
+     List<LatLng> computeIsochrone(LatLng origin, int minutes) {
         final List<LatLng> points = Collections.synchronizedList(new ArrayList<>());
         final int maxTravelTimeSec = minutes * 60;
 
@@ -214,17 +226,14 @@ public List<LatLng> computeIsochrone(LatLng origin, int minutes) {
                         double latOffset = midRadius * Math.cos(angleRad);
                         double lngOffset = midRadius * Math.sin(angleRad) / Math.cos(Math.toRadians(origin.latitude));
                         LatLng dest = new LatLng(origin.latitude + latOffset, origin.longitude + lngOffset);
-
                         int travelTime = travelTimeFetcher.fetchTravelTime(origin, dest);
                         if (travelTime < 0) break;
-
                         if (travelTime <= maxTravelTimeSec) {
                             bestRadius = midRadius;
                             minRadius = midRadius;
                         } else {
                             maxRadius = midRadius;
                         }
-
                         if ((maxRadius - minRadius) < EPSILON) break;
                     }
 
@@ -254,6 +263,15 @@ public List<LatLng> computeIsochrone(LatLng origin, int minutes) {
         return new ArrayList<>();
     }
 
+    private void drawPolygon(List<LatLng> points, int baseColor) {
+        int fillColor = (baseColor & 0x00FFFFFF) | (0x33 << 24);
+        int strokeColor = baseColor | 0xFF000000;
+        map.addPolygon(new PolygonOptions()
+                .addAll(points)
+                .strokeColor(strokeColor)
+                .fillColor(fillColor));
+    }
+
     private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
         List<LatLng> output = new ArrayList<>(input);
         for (int iter = 0; iter < iterations; iter++) {
@@ -261,14 +279,8 @@ private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
             for (int i = 0; i < output.size() - 1; i++) {
                 LatLng p0 = output.get(i);
                 LatLng p1 = output.get(i + 1);
-
-                LatLng Q = new LatLng(
-                        0.75 * p0.latitude + 0.25 * p1.latitude,
-                        0.75 * p0.longitude + 0.25 * p1.longitude);
-                LatLng R = new LatLng(
-                        0.25 * p0.latitude + 0.75 * p1.latitude,
-                        0.25 * p0.longitude + 0.75 * p1.longitude);
-
+                LatLng Q = new LatLng(0.75 * p0.latitude + 0.25 * p1.latitude, 0.75 * p0.longitude + 0.25 * p1.longitude);
+                LatLng R = new LatLng(0.25 * p0.latitude + 0.75 * p1.latitude, 0.25 * p0.longitude + 0.75 * p1.longitude);
                 newPoints.add(Q);
                 newPoints.add(R);
             }
@@ -278,77 +290,22 @@ private List<LatLng> chaikinSmoothing(List<LatLng> input, int iterations) {
         return output;
     }
 
-    public interface UiThreadExecutor {
-        void execute(Runnable runnable);
-    }
-
-    private UiThreadExecutor uiThreadExecutor;
-
-    public void setUiThreadExecutor(UiThreadExecutor executor) {
-        this.uiThreadExecutor = executor;
-    }
-
     private void runOnUiThread(Runnable runnable) {
         if (uiThreadExecutor != null) {
             uiThreadExecutor.execute(runnable);
         } else {
-            Log.e(TAG, "UI thread executor not set!");
-        }
-    }
-
-    public static class GoogleDirectionsTravelTimeFetcher implements TravelTimeFetcher {
-        private final String apiKey;
-        private final TransportMode mode;
-
-        public GoogleDirectionsTravelTimeFetcher(String apiKey, TransportMode mode) {
-            this.apiKey = apiKey;
-            this.mode = mode;
-        }
-
-        @Override
-        public int fetchTravelTime(LatLng origin, LatLng dest) {
-            String urlString = String.format(
-                    "https://maps.googleapis.com/maps/api/directions/json?origin=%f,%f&destination=%f,%f&mode=%s&key=%s",
-                    origin.latitude, origin.longitude, dest.latitude, dest.longitude, mode.getModeName(), apiKey);
-            HttpURLConnection connection = null;
-            try {
-                URL url = new URL(urlString);
-                connection = (HttpURLConnection) url.openConnection();
-                connection.setRequestMethod("GET");
-                connection.setConnectTimeout(5000);
-                connection.setReadTimeout(5000);
-
-                InputStreamReader reader = new InputStreamReader(connection.getInputStream());
-                StringBuilder responseBuilder = new StringBuilder();
-                int c;
-                while ((c = reader.read()) != -1) {
-                    responseBuilder.append((char) c);
-                }
-                reader.close();
-
-                JSONObject json = new JSONObject(responseBuilder.toString());
-                return json.getJSONArray("routes")
-                        .getJSONObject(0)
-                        .getJSONArray("legs")
-                        .getJSONObject(0)
-                        .getJSONObject("duration")
-                        .getInt("value");
-
-            } catch (Exception e) {
-                Log.e(TAG, "Error getting travel time", e);
-                return -1;
-            } finally {
-                if (connection != null) {
-                    connection.disconnect();
-                }
-            }
+            Log.e(TAG, "UI thread executor not set! Cannot run UI code.");
         }
     }
 
-    public static class ImmediateExecutor implements UiThreadExecutor {
-        @Override
-        public void execute(Runnable runnable) {
-            runnable.run();
+    private void reverseArray(int[] array) {
+        int left = 0, right = array.length - 1;
+        while (left < right) {
+            int temp = array[left];
+            array[left] = array[right];
+            array[right] = temp;
+            left++;
+            right--;
         }
     }
 }
diff --git a/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java b/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java
index 71023c142..77ebd5411 100644
--- a/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java
+++ b/library/src/test/java/com/google/maps/android/isochrone/IsochroneMapProviderTest.java
@@ -50,12 +50,15 @@ public void setup() {
     public void testComputeIsochroneReturnsPoints() {
         when(mockTravelTimeFetcher.fetchTravelTime(any(LatLng.class), any(LatLng.class))).thenReturn(60);
 
+        // For testing, just run directly
         IsochroneMapProvider provider = new IsochroneMapProvider(
                 mockMap,
-                "dummy-api-key",
+                "FAKE_API_KEY",
                 mockLoadingListener,
                 IsochroneMapProvider.TransportMode.BICYCLING,
-                mockTravelTimeFetcher);
+                Runnable::run,
+                null // or a mock TravelTimeFetcher if needed
+        );
 
         LatLng origin = new LatLng(0, 0);
         List<LatLng> polygon = provider.computeIsochrone(origin, 10);
@@ -68,12 +71,15 @@ public void testComputeIsochroneReturnsPoints() {
     public void testDrawIsochronesCallsLoadingListener() throws InterruptedException {
         when(mockTravelTimeFetcher.fetchTravelTime(any(LatLng.class), any(LatLng.class))).thenReturn(60);
 
+        // For testing, just run directly
         IsochroneMapProvider provider = new IsochroneMapProvider(
                 mockMap,
-                "dummy-api-key",
+                "FAKE_API_KEY",
                 mockLoadingListener,
                 IsochroneMapProvider.TransportMode.BICYCLING,
-                mockTravelTimeFetcher);
+                Runnable::run,
+                null
+        );
 
         CountDownLatch latch = new CountDownLatch(1);
 
@@ -83,7 +89,7 @@ public void testDrawIsochronesCallsLoadingListener() throws InterruptedException
         }).when(mockLoadingListener).onLoadingFinished();
 
         // Run UI tasks immediately (synchronously)
-        provider.setUiThreadExecutor(Runnable::run);
+
 
         provider.drawIsochrones(new LatLng(0, 0), new int[]{5, 10}, IsochroneMapProvider.ColorSchema.GREEN_RED);
 
@@ -101,12 +107,13 @@ public void testPolygonsDrawnInCorrectOrder() throws InterruptedException {
 
         IsochroneMapProvider provider = new IsochroneMapProvider(
                 mockMap,
-                "dummy-api-key",
+                "FAKE_API_KEY",
                 mockLoadingListener,
                 IsochroneMapProvider.TransportMode.BICYCLING,
-                mockTravelTimeFetcher);
+                Runnable::run,
+                null
+        );
 
-        provider.setUiThreadExecutor(Runnable::run);
 
         Polygon mockPolygon = mock(Polygon.class);
         when(mockMap.addPolygon(any(PolygonOptions.class))).thenReturn(mockPolygon);
@@ -115,7 +122,6 @@ public void testPolygonsDrawnInCorrectOrder() throws InterruptedException {
 
         provider.drawIsochrones(new LatLng(0, 0), new int[]{10, 5}, IsochroneMapProvider.ColorSchema.GREEN_RED);
 
-        // Wait for async completion
         Thread.sleep(1000);
 
         verify(mockMap, times(2)).addPolygon(captor.capture());

From fea546ef045670ef940a928a95a502272cfbe759 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 15:11:34 +0200
Subject: [PATCH 5/6] feat: header

---
 .../android/isochrone/IsochroneMapProvider.java  | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
index 9ccbca2cb..8040c15e0 100644
--- a/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
+++ b/library/src/main/java/com/google/maps/android/isochrone/IsochroneMapProvider.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.maps.android.isochrone;
 
 import android.annotation.SuppressLint;

From 5dbf4de31caf74050c7c4638bb4c7e18a2767396 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Lo=CC=81pez=20Man=CC=83as?=
 <eenriquelopez@gmail.com>
Date: Tue, 1 Jul 2025 15:17:14 +0200
Subject: [PATCH 6/6] feat: header

---
 .../main/res/layout/activity_isochrone.xml    | 72 -------------------
 1 file changed, 72 deletions(-)
 delete mode 100644 demo/src/main/res/layout/activity_isochrone.xml

diff --git a/demo/src/main/res/layout/activity_isochrone.xml b/demo/src/main/res/layout/activity_isochrone.xml
deleted file mode 100644
index b04ad0e38..000000000
--- a/demo/src/main/res/layout/activity_isochrone.xml
+++ /dev/null
@@ -1,72 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- Copyright 2025 Google LLC
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/rootLayout"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <com.google.android.gms.maps.MapView
-        android:id="@+id/mapView"
-        android:layout_width="match_parent"
-        android:layout_height="match_parent" />
-
-    <ProgressBar
-        android:id="@+id/progressBar"
-        style="?android:attr/progressBarStyleLarge"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center"
-        android:visibility="gone" />
-
-    <LinearLayout
-        android:id="@+id/buttonLayout"
-        android:orientation="horizontal"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_gravity="top|end"
-        android:layout_margin="16dp">
-
-        <Button
-            android:id="@+id/btnBicycling"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="BICYCLING"
-            android:textAllCaps="false"
-            android:alpha="1" />
-
-        <Button
-            android:id="@+id/btnDriving"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="DRIVING"
-            android:textAllCaps="false"
-            android:layout_marginStart="8dp"
-            android:alpha="0.5" />
-
-        <Button
-            android:id="@+id/btnWalking"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="WALKING"
-            android:textAllCaps="false"
-            android:layout_marginStart="8dp"
-            android:alpha="0.5" />
-
-    </LinearLayout>
-
-</FrameLayout>
\ No newline at end of file