refactor(data): Convert Layer to Kotlin and add generics

This commit refactors the `Layer` class by converting it from Java to idiomatic Kotlin. It also introduces generics to both the `Layer` and `Renderer` classes to improve type safety throughout the data layer.

Key changes:
- **Convert `Layer` to Kotlin**: The `Layer` class is now `Layer.kt`, utilizing Kotlin features like properties and `when` expressions for more concise and readable code.
- **Introduce Generics**: `Layer` and `Renderer` are now generic (`Layer<T : Feature>`, `Renderer<T extends Feature>`). This enforces type constraints at compile time.
- **Improve Type Safety**: Subclasses like `GeoJsonLayer`, `KmlLayer`, `GeoJsonRenderer`, and `KmlRenderer` now extend the generic base classes, eliminating the need for unsafe casts when handling features.
- **Add Unit Tests**: A new `LayerTest.kt` file has been added with comprehensive unit tests for the `Layer` class, using MockK and Truth to verify its behavior.

Author: dkhawk

library/src/main/java/com/google/maps/android/data/Layer.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 Google Inc.
+ * 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.
@@ -13,102 +13,97 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+package com.google.maps.android.data
 
-package com.google.maps.android.data;
-
-import com.google.android.gms.maps.GoogleMap;
-import com.google.maps.android.data.geojson.GeoJsonLineStringStyle;
-import com.google.maps.android.data.geojson.GeoJsonPointStyle;
-import com.google.maps.android.data.geojson.GeoJsonPolygonStyle;
-import com.google.maps.android.data.geojson.GeoJsonRenderer;
-import com.google.maps.android.data.kml.KmlContainer;
-import com.google.maps.android.data.kml.KmlGroundOverlay;
-import com.google.maps.android.data.kml.KmlRenderer;
+import com.google.android.gms.maps.GoogleMap
+import com.google.maps.android.data.geojson.GeoJsonLineStringStyle
+import com.google.maps.android.data.geojson.GeoJsonPointStyle
+import com.google.maps.android.data.geojson.GeoJsonPolygonStyle
+import com.google.maps.android.data.geojson.GeoJsonRenderer
+import com.google.maps.android.data.kml.KmlContainer
+import com.google.maps.android.data.kml.KmlGroundOverlay
+import com.google.maps.android.data.kml.KmlRenderer
 
 /**
  * An abstraction that shares the common properties of
- * {@link com.google.maps.android.data.kml.KmlLayer KmlLayer} and
- * {@link com.google.maps.android.data.geojson.GeoJsonLayer GeoJsonLayer}
+ * [com.google.maps.android.data.kml.KmlLayer] and
+ * [com.google.maps.android.data.geojson.GeoJsonLayer]
  */
-public abstract class Layer {
-
-    private Renderer mRenderer;
+abstract class Layer<T : Feature> {
+    @JvmField
+    protected var renderer: Renderer<T>? = null
 
     /**
      * Adds the KML data to the map
      */
-    protected void addKMLToMap() {
-        if (mRenderer instanceof KmlRenderer) {
-            ((KmlRenderer) mRenderer).addLayerToMap();
-        } else {
-            throw new UnsupportedOperationException("Stored renderer is not a KmlRenderer");
-        }
+    protected fun addKMLToMap() {
+        val kmlRenderer = renderer as? KmlRenderer
+            ?: throw UnsupportedOperationException("Stored renderer is not a KmlRenderer")
+        kmlRenderer.addLayerToMap()
     }
 
     /**
      * Adds GeoJson data to the map
      */
-    protected void addGeoJsonToMap() {
-        if (mRenderer instanceof GeoJsonRenderer) {
-            ((GeoJsonRenderer) mRenderer).addLayerToMap();
-        } else {
-            throw new UnsupportedOperationException("Stored renderer is not a GeoJsonRenderer");
-        }
+    protected fun addGeoJsonToMap() {
+        val geoJsonRenderer = renderer as? GeoJsonRenderer
+            ?: throw UnsupportedOperationException("Stored renderer is not a GeoJsonRenderer")
+        geoJsonRenderer.addLayerToMap()
     }
 
-    public abstract void addLayerToMap();
+    abstract fun addLayerToMap()
 
     /**
      * Removes all the data from the map and clears all the stored placemarks
      */
-    public void removeLayerFromMap() {
-        if (mRenderer instanceof GeoJsonRenderer) {
-            ((GeoJsonRenderer) mRenderer).removeLayerFromMap();
-        } else if (mRenderer instanceof KmlRenderer) {
-            ((KmlRenderer) mRenderer).removeLayerFromMap();
+    fun removeLayerFromMap() {
+        when (val r = renderer) {
+            is GeoJsonRenderer -> r.removeLayerFromMap()
+            is KmlRenderer -> r.removeLayerFromMap()
         }
     }
 
     /**
      * Sets a single click listener for the entire GoogleMap object, that will be called
      * with the corresponding Feature object when an object on the map (Polygon,
      * Marker, Polyline) is clicked.
-     * <p>
+     *
      * If getFeature() returns null this means that either the object is inside a KMLContainer,
      * or the object is a MultiPolygon, MultiLineString or MultiPoint and must
      * be handled differently.
      *
      * @param listener Listener providing the onFeatureClick method to call.
      */
-    public void setOnFeatureClickListener(final OnFeatureClickListener listener) {
-        mRenderer.setOnFeatureClickListener(listener);
+    fun setOnFeatureClickListener(listener: OnFeatureClickListener) {
+        renderer?.setOnFeatureClickListener(listener)
     }
 
     /**
      * Callback interface for when a map object is clicked.
      */
-    public interface OnFeatureClickListener {
-        void onFeatureClick(Feature feature);
+    fun interface OnFeatureClickListener {
+        fun onFeatureClick(feature: Feature)
     }
 
     /**
      * Stores a new Renderer object into mRenderer
      *
      * @param renderer the new Renderer object that belongs to this Layer
      */
-    protected void storeRenderer(Renderer renderer) {
-        mRenderer = renderer;
+    protected fun storeRenderer(renderer: Renderer<T>) {
+        this.renderer = renderer
     }
 
     /**
      * Gets an iterable of all Feature elements that have been added to the layer
      *
      * @return iterable of Feature elements
      */
-    public Iterable<? extends Feature> getFeatures() {
-        return mRenderer.getFeatures();
+    open fun getFeatures(): Iterable<T> {
+        return renderer?.features ?: emptyList()
     }
 
+
     /**
      * Retrieves a corresponding Feature instance for the given Object
      * Allows maps with multiple layers to determine which layer the Object
@@ -117,103 +112,91 @@ public abstract class Layer {
      * @param mapObject Object
      * @return Feature for the given object
      */
-    public Feature getFeature(Object mapObject) {
-        return mRenderer.getFeature(mapObject);
+    fun getFeature(mapObject: Any): T? {
+        return renderer?.getFeature(mapObject) as T?
     }
 
-    public Feature getContainerFeature(Object mapObject) {
-        return mRenderer.getContainerFeature(mapObject);
+    fun getContainerFeature(mapObject: Any): T? {
+        return renderer?.getContainerFeature(mapObject) as T?
     }
 
     /**
      * Checks if there are any features currently on the layer
      *
      * @return true if there are features on the layer, false otherwise
      */
-    protected boolean hasFeatures() {
-        return mRenderer.hasFeatures();
-    }
+    protected open fun hasFeatures(): Boolean = renderer?.hasFeatures() ?: false
 
     /**
      * Checks if the layer contains any KmlContainers
      *
      * @return true if there is at least 1 container within the KmlLayer, false otherwise
      */
-    protected boolean hasContainers() {
-        if (mRenderer instanceof KmlRenderer) {
-            return ((KmlRenderer) mRenderer).hasNestedContainers();
-        }
-        return false;
+    protected open fun hasContainers(): Boolean {
+        return (renderer as? KmlRenderer)?.hasNestedContainers() ?: false
     }
 
     /**
      * Gets an iterable of KmlContainerInterface objects
      *
      * @return iterable of KmlContainerInterface objects
      */
-    protected Iterable<KmlContainer> getContainers() {
-        if (mRenderer instanceof KmlRenderer) {
-            return ((KmlRenderer) mRenderer).getNestedContainers();
-        }
-        return null;
+    protected open fun getContainers(): Iterable<KmlContainer>? {
+        return (renderer as? KmlRenderer)?.nestedContainers
     }
 
+
     /**
      * Gets an iterable of KmlGroundOverlay objects
      *
      * @return iterable of KmlGroundOverlay objects
      */
-    protected Iterable<KmlGroundOverlay> getGroundOverlays() {
-        if (mRenderer instanceof KmlRenderer) {
-            return ((KmlRenderer) mRenderer).getGroundOverlays();
-        }
-        return null;
+    protected open fun getGroundOverlays(): Iterable<KmlGroundOverlay>? {
+        return (renderer as? KmlRenderer)?.groundOverlays
     }
 
     /**
      * Gets the map on which the layer is rendered
      *
      * @return map on which the layer is rendered
      */
-    public GoogleMap getMap() {
-        return mRenderer.getMap();
-    }
+    val map: GoogleMap?
+        get() = renderer?.map
 
     /**
      * Renders the layer on the given map. The layer on the current map is removed and
      * added to the given map.
      *
      * @param map to render the layer on, if null the layer is cleared from the current map
      */
-    public void setMap(GoogleMap map) {
-        mRenderer.setMap(map);
+    fun setMap(map: GoogleMap?) {
+        renderer?.map = map
     }
 
     /**
      * Checks if the current layer has been added to the map
      *
      * @return true if the layer is on the map, false otherwise
      */
-    public boolean isLayerOnMap() {
-        return mRenderer.isLayerOnMap();
-    }
+    val isLayerOnMap: Boolean
+        get() = renderer?.isLayerOnMap ?: false
 
     /**
      * Adds a provided feature to the map
      *
      * @param feature feature to add to map
      */
-    protected void addFeature(Feature feature) {
-        mRenderer.addFeature(feature);
+    protected open fun addFeature(feature: T) {
+        renderer?.addFeature(feature)
     }
 
     /**
      * Remove a specified feature from the map
      *
      * @param feature feature to be removed
      */
-    protected void removeFeature(Feature feature) {
-        mRenderer.removeFeature(feature);
+    protected open fun removeFeature(feature: T) {
+        renderer?.removeFeature(feature)
     }
 
     /**
@@ -222,27 +205,24 @@ public abstract class Layer {
      *
      * @return default style used to render GeoJsonPoints
      */
-    public GeoJsonPointStyle getDefaultPointStyle() {
-        return mRenderer.getDefaultPointStyle();
-    }
+    val defaultPointStyle: GeoJsonPointStyle?
+        get() = renderer?.defaultPointStyle
 
     /**
      * Gets the default style used to render GeoJsonLineStrings. Any changes to this style will be
      * reflected in the features that use it.
      *
      * @return default style used to render GeoJsonLineStrings
      */
-    public GeoJsonLineStringStyle getDefaultLineStringStyle() {
-        return mRenderer.getDefaultLineStringStyle();
-    }
+    val defaultLineStringStyle: GeoJsonLineStringStyle?
+        get() = renderer?.defaultLineStringStyle
 
     /**
      * Gets the default style used to render GeoJsonPolygons. Any changes to this style will be
      * reflected in the features that use it.
      *
      * @return default style used to render GeoJsonPolygons
      */
-    public GeoJsonPolygonStyle getDefaultPolygonStyle() {
-        return mRenderer.getDefaultPolygonStyle();
-    }
+    val defaultPolygonStyle: GeoJsonPolygonStyle?
+        get() = renderer?.defaultPolygonStyle
 }

library/src/main/java/com/google/maps/android/data/Renderer.java

@@ -77,7 +77,7 @@
  * {@link com.google.maps.android.data.kml.KmlRenderer KmlRenderer} and
  * {@link com.google.maps.android.data.geojson.GeoJsonRenderer GeoJsonRenderer}
  */
-public class Renderer {
+public class Renderer<T extends Feature> {
 
     private static final int MARKER_ICON_SIZE = 32;
 
@@ -87,7 +87,7 @@ public class Renderer {
 
     private GoogleMap mMap;
 
-    private final BiMultiMap<Feature> mFeatures = new BiMultiMap<>();
+    private final BiMultiMap<T> mFeatures = new BiMultiMap<>();
 
     private HashMap<String, KmlStyle> mStyles;
 
@@ -156,7 +156,7 @@ public Renderer(GoogleMap map,
      * @param polylineManager polyline manager to create polyline collection from
      * @param groundOverlayManager ground overlay manager to create ground overlay collection from
      */
-    public Renderer(GoogleMap map, HashMap<? extends Feature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager) {
+    public Renderer(GoogleMap map, HashMap<T, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager) {
         this(map, null, new GeoJsonPointStyle(), new GeoJsonLineStringStyle(), new GeoJsonPolygonStyle(), null, markerManager, polygonManager, polylineManager, groundOverlayManager);
         mFeatures.putAll(features);
         mImagesCache = null;
@@ -274,7 +274,7 @@ protected void putContainerFeature(Object mapObject, Feature placemark) {
      *
      * @return set containing Features
      */
-    public Set<Feature> getFeatures() {
+    public Set<T> getFeatures() {
         return mFeatures.keySet();
     }
 
@@ -284,7 +284,7 @@ public Set<Feature> getFeatures() {
      * @param mapObject Marker, Polyline or Polygon
      * @return Feature for the given map object
      */
-    Feature getFeature(Object mapObject) {
+    T getFeature(Object mapObject) {
         return mFeatures.getKey(mapObject);
     }
 
@@ -310,7 +310,7 @@ public Collection<Object> getValues() {
      *
      * @return mFeatures hashmap
      */
-    protected HashMap<? extends Feature, Object> getAllFeatures() {
+    protected HashMap<T, Object> getAllFeatures() {
         return mFeatures;
     }
 
@@ -482,7 +482,7 @@ GeoJsonPolygonStyle getDefaultPolygonStyle() {
      * @param feature Feature to be added onto the map
      * @param object  Corresponding map object to this feature
      */
-    protected void putFeatures(Feature feature, Object object) {
+    protected void putFeatures(T feature, Object object) {
         mFeatures.put(feature, object);
     }
 
@@ -610,7 +610,7 @@ protected void removeGroundOverlays(HashMap<KmlGroundOverlay, GroundOverlay> gro
      *
      * @param feature feature to remove from map
      */
-    protected void removeFeature(Feature feature) {
+    protected void removeFeature(T feature) {
         // Check if given feature is stored
         if (mFeatures.containsKey(feature)) {
             removeFromMap(mFeatures.remove(feature));
@@ -652,7 +652,7 @@ protected void clearStylesRenderer() {
      */
     protected void storeData(HashMap<String, KmlStyle> styles,
                              HashMap<String, String> styleMaps,
-                             HashMap<KmlPlacemark, Object> features,
+                             HashMap<T, Object> features,
                              ArrayList<KmlContainer> folders,
                              HashMap<KmlGroundOverlay, GroundOverlay> groundOverlays) {
         mStyles = styles;
@@ -667,7 +667,7 @@ protected void storeData(HashMap<String, KmlStyle> styles,
      *
      * @param feature feature to add to the map
      */
-    protected void addFeature(Feature feature) {
+    protected void addFeature(T feature) {
         Object mapObject = FEATURE_NOT_ON_MAP;
         if (feature instanceof GeoJsonFeature) {
             setFeatureDefaultStyles((GeoJsonFeature) feature);