@rnmapbox/maps 10.1.15 → 10.1.16

package/android/src/main/java/com/rnmapbox/rnmbx/RNMBXPackage.kt

@@ -52,8 +52,9 @@ import com.rnmapbox.rnmbx.modules.RNMBXOfflineModule
 import com.rnmapbox.rnmbx.modules.RNMBXOfflineModuleLegacy
 import com.rnmapbox.rnmbx.modules.RNMBXSnapshotModule
 import com.rnmapbox.rnmbx.modules.RNMBXTileStoreModule
-import com.rnmapbox.rnmbx.shape_animators.RNMBXMovePointShapeAnimatorModule
-import com.rnmapbox.rnmbx.shape_animators.ShapeAnimatorManager
+import com.rnmapbox.rnmbx.shapeAnimators.RNMBXChangeLineOffsetsShapeAnimatorModule
+import com.rnmapbox.rnmbx.shapeAnimators.RNMBXMovePointShapeAnimatorModule
+import com.rnmapbox.rnmbx.shapeAnimators.ShapeAnimatorManager
 import com.rnmapbox.rnmbx.utils.ViewTagResolver
 
 class RNMBXPackage : TurboReactPackage() {
@@ -103,6 +104,7 @@ class RNMBXPackage : TurboReactPackage() {
             RNMBXImageModule.NAME -> return RNMBXImageModule(reactApplicationContext, getViewTagResolver(reactApplicationContext, s))
             RNMBXPointAnnotationModule.NAME -> return RNMBXPointAnnotationModule(reactApplicationContext, getViewTagResolver(reactApplicationContext, s))
             RNMBXMovePointShapeAnimatorModule.NAME -> return RNMBXMovePointShapeAnimatorModule(reactApplicationContext, getShapeAnimators(s))
+            RNMBXChangeLineOffsetsShapeAnimatorModule.NAME -> return RNMBXChangeLineOffsetsShapeAnimatorModule(reactApplicationContext, getShapeAnimators(s))
         }
         return null
     }
@@ -292,6 +294,15 @@ class RNMBXPackage : TurboReactPackage() {
                 false,
                 isTurboModule
             )
+            moduleInfos[RNMBXChangeLineOffsetsShapeAnimatorModule.NAME] = ReactModuleInfo(
+                RNMBXChangeLineOffsetsShapeAnimatorModule.NAME,
+                RNMBXChangeLineOffsetsShapeAnimatorModule.NAME,
+                false,
+                false,
+                false,
+                false,
+                isTurboModule
+            )
             moduleInfos
         }
     }

package/android/src/main/java/com/rnmapbox/rnmbx/components/AbstractEventEmitter.kt

@@ -10,6 +10,7 @@ import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.rnmapbox.rnmbx.events.IEvent
+import com.rnmapbox.rnmbx.utils.Logger
 
 /**
  * Created by nickitaliano on 8/23/17.
@@ -40,14 +41,19 @@ abstract class AbstractEventEmitter<T : ViewGroup?>(reactApplicationContext: Rea
             return
         }
         mRateLimitedEvents[eventCacheKey] = System.currentTimeMillis()
-        mEventDispatcher!!.dispatchEvent(
-            AbstractEvent(
-                event.iD,
-                event.key,
-                event.canCoalesce(),
-                event.toJSON()
+
+        try {
+            mEventDispatcher!!.dispatchEvent(
+                AbstractEvent(
+                    event.iD,
+                    event.key,
+                    event.canCoalesce(),
+                    event.toJSON()
+                )
             )
-        )
+        } catch (e: Exception) {
+            Logger.e("Error dispatching event:", e.toString())
+        }
     }
 
     override fun addEventEmitters(context: ThemedReactContext, view: T) {

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/sources/RNMBXShapeSource.kt

@@ -1,32 +1,28 @@
 package com.rnmapbox.rnmbx.components.styles.sources
 
 import android.content.Context
-import com.mapbox.maps.extension.style.sources.generated.GeoJsonSource
-import com.rnmapbox.rnmbx.utils.ImageEntry
-import android.graphics.drawable.BitmapDrawable
 import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableMap
-import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
-import com.rnmapbox.rnmbx.events.FeatureClickEvent
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.mapbox.bindgen.Value
 import com.mapbox.geojson.Feature
-import com.rnmapbox.rnmbx.events.AndroidCallbackEvent
 import com.mapbox.geojson.FeatureCollection
 import com.mapbox.geojson.GeoJson
 import com.mapbox.geojson.Geometry
 import com.mapbox.maps.*
 import com.mapbox.maps.extension.style.expressions.generated.Expression
-import com.rnmapbox.rnmbx.shape_animators.ShapeAnimationConsumer
-import com.rnmapbox.rnmbx.shape_animators.ShapeAnimator
-import com.rnmapbox.rnmbx.shape_animators.ShapeAnimatorManager
+import com.mapbox.maps.extension.style.sources.generated.GeoJsonSource
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.events.AndroidCallbackEvent
+import com.rnmapbox.rnmbx.events.FeatureClickEvent
+import com.rnmapbox.rnmbx.shapeAnimators.ShapeAnimationConsumer
+import com.rnmapbox.rnmbx.shapeAnimators.ShapeAnimator
 import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.v11compat.feature.*
 import java.net.URL
-import java.util.ArrayList
-import java.util.HashMap
 
-import com.rnmapbox.rnmbx.v11compat.feature.*
+private const val LOG_TAG = "RNMBXShapeSource"
 
 class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceManager) :
     RNMBXSource<GeoJsonSource>(context), ShapeAnimationConsumer {
@@ -47,6 +43,7 @@ class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceM
     }
 
     override fun addToMap(mapView: RNMBXMapView) {
+
         // Wait for style before adding the source to the map
         mapView.getMapboxMap().getStyle {
             val map = mapView.getMapboxMap()
@@ -54,6 +51,14 @@ class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceM
         }
     }
 
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+
+        if (reason == RemovalReason.VIEW_REMOVAL) {
+            mShapeAnimator?.unsubscribe(this)
+        }
+        return super.removeFromMap(mapView, reason)
+    }
+
     override fun setId(id: Int) {
         super.setId(id)
         mManager.tagAssigned(id)
@@ -85,7 +90,8 @@ class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceM
                 mShapeAnimator = shapeAnimator
                 shapeAnimator.subscribe(this)
 
-                shapeUpdated(shapeAnimator.getShape())
+                val shape = shapeAnimator.getShape()
+                shapeUpdated(shape)
             }
         } else {
             mShape = geoJSONStr
@@ -108,8 +114,8 @@ class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceM
             else -> {
                 Logger.e(
                     LOG_TAG,
-                    "Cannot convert shape to GeoJSONSourceData, neitthe Geometry, nor Feature or FeatureCollection: $geoJson"
-                );
+                    "Cannot convert shape to Geometry, Feature, or FeatureCollection: $geoJson"
+                )
                 return null
             }
         }
@@ -214,7 +220,7 @@ class RNMBXShapeSource(context: Context, private val mManager: RNMBXShapeSourceM
             )
         ) { features ->
             if (features.isError) {
-                Logger.e("RNMBXShapeSource", String.format("Error: %s", features.error))
+                Logger.e(LOG_TAG, String.format("Error: %s", features.error))
             } else {
                 val payload: WritableMap = WritableNativeMap()
                 val result: MutableList<Feature> = ArrayList(

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/sources/RNMBXShapeSourceManager.kt

@@ -7,13 +7,12 @@ import com.rnmapbox.rnmbx.components.AbstractEventEmitter
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.bridge.ReadableType
-import com.facebook.react.common.MapBuilder
 import com.facebook.react.viewmanagers.RNMBXShapeSourceManagerInterface
 import com.mapbox.bindgen.Value
 import com.mapbox.maps.extension.style.expressions.generated.Expression
 import com.rnmapbox.rnmbx.events.constants.EventKeys
 import com.rnmapbox.rnmbx.events.constants.eventMapOf
-import com.rnmapbox.rnmbx.shape_animators.ShapeAnimatorManager
+import com.rnmapbox.rnmbx.shapeAnimators.ShapeAnimatorManager
 import com.rnmapbox.rnmbx.utils.ExpressionParser
 import com.rnmapbox.rnmbx.utils.Logger
 import com.rnmapbox.rnmbx.utils.ViewTagResolver

package/android/src/main/java/com/rnmapbox/rnmbx/shapeAnimators/AnimatableElement.kt

@@ -0,0 +1,38 @@
+package com.rnmapbox.rnmbx.shapeAnimators
+
+internal class AnimatableElement<T>(
+    var source: T,
+    var progress: T,
+    var target: T,
+    var startedAtSec: Double,
+    var progressDurationSec: Double,
+    var totalDurationSec: Double,
+    /** A function returning the difference in meters between the two values. */
+    var getDistanceRemaining: (a: T, b: T) -> Double
+) {
+    fun distanceRemaining(): Double {
+        return getDistanceRemaining(source, target)
+    }
+
+    fun durationRatio(): Double {
+        return if (totalDurationSec > 0.0) {
+            progressDurationSec / totalDurationSec
+        } else {
+            1.0
+        }
+    }
+
+    fun setProgress(value: T, animatorAgeSec: Double) {
+        progress = value
+        progressDurationSec = (animatorAgeSec - startedAtSec)
+    }
+
+    fun reset(_source: T, _progress: T, _target: T, durationSec: Double, animatorAgeSec: Double) {
+        this.source = _source
+        this.progress = _progress
+        this.target = _target
+        this.startedAtSec = animatorAgeSec
+        this.progressDurationSec = 0.0
+        this.totalDurationSec = durationSec
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/shapeAnimators/RNMBXChangeLineOffsetsShapeAnimatorModule.kt

@@ -0,0 +1,217 @@
+package com.rnmapbox.rnmbx.shapeAnimators
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.geojson.GeoJson
+import com.mapbox.geojson.LineString
+import com.mapbox.geojson.Point
+import com.mapbox.turf.TurfConstants.UNIT_METERS
+import com.mapbox.turf.TurfMeasurement
+import com.mapbox.turf.TurfMisc
+import com.rnmapbox.rnmbx.NativeRNMBXChangeLineOffsetsShapeAnimatorModuleSpec
+
+class ChangeLineOffsetsShapeAnimator(tag: Tag, _lineString: LineString, startOffset: Double, endOffset: Double): ShapeAnimatorCommon(tag) {
+    private var lineString = _lineString
+    private var startOfLine = AnimatableElement<Double>(
+        startOffset,
+        startOffset,
+        startOffset,
+        0.0,
+        0.0,
+        0.0,
+        { a, b -> b - a }
+    )
+    private var endOfLine = AnimatableElement<Double>(
+        endOffset,
+        endOffset,
+        endOffset,
+        0.0,
+        0.0,
+        0.0,
+        { a, b -> b - a }
+    )
+
+    override fun getAnimatedShape(animatorAgeSec: Double): GeoJson {
+        if (startOfLine.durationRatio() < 1) {
+            startOfLine.setProgress(
+                startOfLine.source + (startOfLine.distanceRemaining() * startOfLine.durationRatio()),
+                animatorAgeSec
+            )
+        }
+
+        if (endOfLine.durationRatio() < 1) {
+            endOfLine.setProgress(
+                endOfLine.source + (endOfLine.distanceRemaining() * endOfLine.durationRatio()),
+                animatorAgeSec
+            )
+        }
+
+        if (startOfLine.durationRatio() >= 1 && endOfLine.durationRatio() >= 1) {
+            stop()
+        }
+
+        if (lineString.coordinates().count() < 2) {
+            return emptyGeoJsonObj
+        }
+
+        val totalDistance = TurfMeasurement.length(lineString, UNIT_METERS)
+        if (totalDistance == 0.0) {
+            return emptyGeoJsonObj
+        }
+
+        if (startOfLine.progress + endOfLine.progress >= totalDistance) {
+            return emptyGeoJsonObj
+        }
+
+        val trimmed = TurfMisc.lineSliceAlong(
+            lineString,
+            startOfLine.progress,
+            totalDistance - endOfLine.progress,
+            UNIT_METERS
+        )
+        return trimmed
+    }
+
+    fun setLineString(lineString: LineString, startOffset: Double?, endOffset: Double?) {
+        this.lineString = lineString
+        if (startOffset != null) {
+            startOfLine.reset(
+                startOffset,
+                startOffset,
+                startOffset,
+                0.0,
+                getAnimatorAgeSec()
+            )
+        }
+        if (endOffset != null) {
+            endOfLine.reset(
+                endOffset,
+                endOffset,
+                endOffset,
+                0.0,
+                getAnimatorAgeSec()
+            )
+        }
+        refresh()
+    }
+
+    fun setStartOffset(offset: Double, durationSec: Double) {
+        if (durationSec == 0.0) {
+            startOfLine.reset(
+                offset,
+                offset,
+                offset,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+            refresh()
+        } else {
+            start()
+            startOfLine.reset(
+                startOfLine.progress,
+                startOfLine.progress,
+                offset,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+        }
+    }
+
+    fun setEndOffset(offset: Double, durationSec: Double) {
+        if (durationSec == 0.0) {
+            endOfLine.reset(
+                offset,
+                offset,
+                offset,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+            refresh()
+        } else {
+            start()
+            endOfLine.reset(
+                endOfLine.progress,
+                endOfLine.progress,
+                offset,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+        }
+    }
+}
+
+@ReactModule(name = RNMBXChangeLineOffsetsShapeAnimatorModule.NAME)
+class RNMBXChangeLineOffsetsShapeAnimatorModule(
+    reactContext: ReactApplicationContext?,
+    val shapeAnimatorManager: ShapeAnimatorManager
+): NativeRNMBXChangeLineOffsetsShapeAnimatorModuleSpec(reactContext) {
+    companion object {
+        const val LOG_TAG = "RNMBXChangeLineOffsetsShapeAnimatorModule"
+        const val NAME = "RNMBXChangeLineOffsetsShapeAnimatorModule"
+    }
+
+    override fun create(
+        tag: Double,
+        coordinates: ReadableArray,
+        startOffset: Double,
+        endOffset: Double,
+        promise: Promise?
+    ) {
+        val lineString = buildLineString(coordinates)
+
+        shapeAnimatorManager.add(
+            ChangeLineOffsetsShapeAnimator(
+                tag.toLong(),
+                lineString,
+                startOffset,
+                endOffset
+            )
+        )
+        promise?.resolve(tag.toInt())
+    }
+
+    private fun getAnimator(tag: Double): ChangeLineOffsetsShapeAnimator {
+        return shapeAnimatorManager.get(tag.toLong()) as ChangeLineOffsetsShapeAnimator
+    }
+
+    override fun setLineString(tag: Double, coordinates: ReadableArray?, startOffset: Double, endOffset: Double, promise: Promise?) {
+        val animator = getAnimator(tag)
+
+        if (coordinates == null) {
+            return
+        }
+
+        val _startOffset = if (startOffset != -1.0) startOffset else null
+        val _endOffset = if (endOffset != -1.0) endOffset else null
+
+        val lineString = buildLineString(coordinates)
+        animator.setLineString(lineString, _startOffset, _endOffset)
+        promise?.resolve(true)
+    }
+
+    override fun setStartOffset(tag: Double, offset: Double, duration: Double, promise: Promise?) {
+        val animator = getAnimator(tag)
+        animator.setStartOffset(offset, duration / 1000)
+        promise?.resolve(true)
+    }
+
+    override fun setEndOffset(tag: Double, offset: Double, duration: Double, promise: Promise?) {
+        val animator = getAnimator(tag)
+        animator.setEndOffset(offset, duration / 1000)
+        promise?.resolve(true)
+    }
+}
+
+private fun buildLineString(_coordinates: ReadableArray): LineString {
+    var coordinates: List<Point> = listOf()
+
+    for (i in 0 until _coordinates.size()) {
+        val arr = _coordinates.getArray(i)
+        val coord = Point.fromLngLat(arr.getDouble(0), arr.getDouble(1))
+        coordinates = coordinates.plus(coord)
+    }
+
+    return LineString.fromLngLats(coordinates)
+}

package/android/src/main/java/com/rnmapbox/rnmbx/shapeAnimators/RNMBXMovePointShapeAnimatorModule.kt

@@ -0,0 +1,108 @@
+package com.rnmapbox.rnmbx.shapeAnimators
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.geojson.GeoJson
+import com.mapbox.geojson.LineString
+import com.mapbox.geojson.Point
+import com.mapbox.turf.TurfConstants.UNIT_METERS
+import com.mapbox.turf.TurfMeasurement
+import com.rnmapbox.rnmbx.NativeRNMBXMovePointShapeAnimatorModuleSpec
+
+class MovePointShapeAnimator(tag: Tag, coordinate: Point) : ShapeAnimatorCommon(tag) {
+    private var point = AnimatableElement<Point>(
+        coordinate,
+        coordinate,
+        coordinate,
+        0.0,
+        0.0,
+        0.0,
+        { a, b -> TurfMeasurement.distance(a, b) }
+    )
+
+    override fun getAnimatedShape(animatorAgeSec: Double): GeoJson {
+        val line = LineString.fromLngLats(listOf(point.source, point.target))
+        val lineLength = TurfMeasurement.length(line, UNIT_METERS)
+        if (lineLength == 0.0) {
+            stop()
+        }
+
+        val ratio = point.durationRatio()
+        if (ratio >= 0 && ratio < 1) {
+            point.setProgress(
+                TurfMeasurement.along(line, lineLength * ratio, UNIT_METERS),
+                animatorAgeSec
+            )
+        } else if (ratio >= 1) {
+            stop()
+        }
+
+        return point.progress
+    }
+
+    fun moveTo(coordinate: Point, durationSec: Double) {
+        if (durationSec == 0.0) {
+            point.reset(
+                coordinate,
+                coordinate,
+                coordinate,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+            refresh()
+        } else {
+            start()
+            point.reset(
+                point.progress,
+                point.progress,
+                coordinate,
+                durationSec,
+                getAnimatorAgeSec()
+            )
+        }
+    }
+}
+
+@ReactModule(name = RNMBXMovePointShapeAnimatorModule.NAME)
+class RNMBXMovePointShapeAnimatorModule(
+    reactContext: ReactApplicationContext?,
+    val shapeAnimatorManager: ShapeAnimatorManager
+): NativeRNMBXMovePointShapeAnimatorModuleSpec(reactContext) {
+    companion object {
+        const val LOG_TAG = "RNMBXMovePointShapeAnimatorModule"
+        const val NAME = "RNMBXMovePointShapeAnimatorModule"
+    }
+
+    @ReactMethod
+    override fun create(tag: Double, startCoordinate: ReadableArray, promise: Promise) {
+        shapeAnimatorManager.add(
+            MovePointShapeAnimator(
+                tag.toLong(),
+                Point.fromLngLat(
+                    startCoordinate.getDouble(0),
+                    startCoordinate.getDouble(1)
+                )
+            )
+        )
+        promise.resolve(tag.toInt())
+    }
+
+    @ReactMethod
+    override fun moveTo(
+        tag: Double,
+        coordinate: ReadableArray?,
+        duration: Double,
+        promise: Promise?
+    ) {
+        val animator = shapeAnimatorManager.get(tag.toLong()) as MovePointShapeAnimator
+
+        val targetCoord = Point.fromLngLat(
+            coordinate!!.getDouble(0),
+            coordinate.getDouble(1)
+        )
+        animator.moveTo(targetCoord, duration / 1000)
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/shapeAnimators/ShapeAnimatorCommon.kt

@@ -0,0 +1,142 @@
+package com.rnmapbox.rnmbx.shapeAnimators
+
+import android.util.Log
+import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.geojson.GeoJson
+import com.rnmapbox.rnmbx.utils.Logger
+import org.json.JSONObject
+import java.util.Date
+import java.util.Timer
+import java.util.TimerTask
+
+typealias Tag = Long
+
+interface ShapeAnimationConsumer {
+    fun shapeUpdated(geoJson: GeoJson)
+}
+
+abstract class ShapeAnimator(val tag: Tag) {
+    abstract fun getShape(): GeoJson
+    abstract fun getAnimatedShape(animatorAgeSec: Double): GeoJson
+    abstract fun subscribe(consumer: ShapeAnimationConsumer)
+    abstract fun unsubscribe(consumer: ShapeAnimationConsumer)
+    abstract fun refresh()
+    abstract fun start()
+    abstract fun stop()
+}
+
+private const val LOG_TAG = "RNMBXShapeAnimator"
+
+abstract class ShapeAnimatorCommon(tag: Tag): ShapeAnimator(tag) {
+    val emptyGeoJsonObj: FeatureCollection = FeatureCollection.fromFeatures(listOf())
+
+    private var timer: Timer? = null
+    private var startedAt = Date()
+
+    private val fps = 30.0
+    private val period = 1.0 / fps
+
+    /** The number of seconds the animator has been running continuously. */
+    fun getAnimatorAgeSec(): Double {
+        val now = Date()
+        return (now.time - startedAt.time).toDouble() / 1000
+    }
+
+    // region subscribers
+    private var subscribers = mutableListOf<ShapeAnimationConsumer>()
+
+    override fun subscribe(consumer: ShapeAnimationConsumer) {
+        if (subscribers.contains(consumer)) {
+            return
+        }
+
+        subscribers.add(consumer)
+    }
+
+    override fun unsubscribe(consumer: ShapeAnimationConsumer) {
+        subscribers.remove(consumer)
+        if (subscribers.isEmpty()) {
+            stop()
+        }
+    }
+    // endregion
+
+    override fun refresh() {
+        val timestamp = getAnimatorAgeSec()
+//        Log.d(
+//            LOG_TAG,
+//            "Refreshing animator for tag $tag (timestamp: $timestamp, subscribers: ${subscribers.count()})"
+//        )
+
+        val shape = getAnimatedShape(timestamp)
+        runOnUiThread {
+            subscribers.forEach {
+                it.shapeUpdated(shape)
+            }
+        }
+    }
+
+    override fun start() {
+        if (timer != null) {
+            Log.d(LOG_TAG, "Timer for animator $tag is already running (subscribers: ${subscribers.count()})")
+            return
+        }
+
+        Log.d(LOG_TAG, "Started timer for animator $tag (subscribers: ${subscribers.count()})")
+
+        startedAt = Date()
+        timer = Timer()
+        timer?.schedule(object : TimerTask() {
+            override fun run() {
+                refresh()
+            }
+        }, 0, (period * 1000).toLong())
+    }
+
+    override fun stop() {
+        if (timer == null) {
+            Log.d(LOG_TAG, "Timer for animator $tag is already stopped (subscribers: ${subscribers.count()})")
+            return
+        }
+
+        Log.d(LOG_TAG,"Stopped timer for animator $tag (subscribers: ${subscribers.count()})")
+
+        timer?.cancel()
+        timer = null
+    }
+
+    override fun getShape(): GeoJson {
+        return getAnimatedShape(getAnimatorAgeSec())
+    }
+}
+
+class ShapeAnimatorManager {
+    private val animators = hashMapOf<Tag, ShapeAnimator>();
+
+    fun add(animator: ShapeAnimator) {
+        animators[animator.tag] = animator
+    }
+
+    fun isShapeAnimatorTag(shape: String): Boolean {
+        return shape.startsWith("{\"__nativeTag\":")
+    }
+
+    fun get(tag: String): ShapeAnimator? {
+        return if (isShapeAnimatorTag(tag)) {
+            val obj = JSONObject(tag)
+            val _tag = obj.getLong("__nativeTag")
+            get(_tag);
+        } else {
+            null
+        }
+    }
+
+    fun get(tag: Tag): ShapeAnimator? {
+        val result = animators[tag]
+        if (result == null) {
+            Logger.e(LOG_TAG, "Shape animator for tag $tag was not found")
+        }
+        return result
+    }
+}