@rnmapbox/maps 10.0.0-beta.69 → 10.0.0-beta.70

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.kt

@@ -13,7 +13,6 @@ import com.mapbox.maps.ViewAnnotationOptions
 import com.mapbox.maps.viewannotation.viewAnnotationOptions
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.modules.RCTMGLLogging
 import com.mapbox.rctmgl.utils.Logger
 import java.util.Vector
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCamera.kt

@@ -3,34 +3,17 @@ package com.mapbox.rctmgl.components.camera
 import android.animation.Animator
 import android.content.Context
 import android.location.Location
-import com.mapbox.rctmgl.utils.GeoJSONUtils.toPoint
 import com.mapbox.maps.plugin.gestures.gestures
 import com.mapbox.rctmgl.location.LocationManager.Companion.getInstance
-import com.mapbox.maps.plugin.animation.camera
-import com.mapbox.rctmgl.utils.GeoJSONUtils.toLocation
-import com.mapbox.maps.plugin.animation.MapAnimationOptions.Builder
 import com.mapbox.maps.plugin.animation.flyTo
-import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.components.camera.CameraStop
-import com.mapbox.rctmgl.components.camera.CameraUpdateQueue
 import com.mapbox.rctmgl.components.location.LocationComponentManager
 import com.mapbox.rctmgl.utils.LatLngBounds
-import com.mapbox.rctmgl.location.LocationManager.OnUserLocationChange
-import com.mapbox.rctmgl.utils.GeoJSONUtils
 import com.mapbox.maps.plugin.locationcomponent.OnIndicatorBearingChangedListener
 import com.mapbox.maps.plugin.locationcomponent.OnIndicatorPositionChangedListener
-import com.mapbox.rctmgl.components.camera.CameraUpdateItem
-import com.mapbox.rctmgl.events.IEvent
-import com.mapbox.rctmgl.events.MapChangeEvent
-import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.components.camera.RCTMGLCamera
-import com.mapbox.android.core.permissions.PermissionsManager
-import com.mapbox.maps.plugin.animation.CameraAnimationsPlugin
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
-import com.mapbox.geojson.Point
 import com.mapbox.maps.*
 import com.mapbox.maps.plugin.PuckBearingSource
 import com.mapbox.maps.plugin.locationcomponent.location
@@ -41,8 +24,6 @@ import com.mapbox.maps.plugin.viewport.viewport
 import com.mapbox.rctmgl.components.camera.constants.CameraMode
 import com.mapbox.rctmgl.components.location.*
 import com.mapbox.rctmgl.location.*
-import com.mapbox.rctmgl.modules.RCTMGLLogging
-import com.mapbox.rctmgl.utils.LatLng
 import com.mapbox.rctmgl.utils.Logger
 
 
@@ -224,7 +205,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         if (mLocationComponentManager == null) {
             mLocationComponentManager = mMapView!!.locationComponentManager
         }
-        mLocationComponentManager!!.update(style)
+        mLocationComponentManager!!.update()
     }
 
     fun setMinZoomLevel(zoomLevel: Double?) {
@@ -290,6 +271,11 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         mMapView?.let {
             val map = it
             val viewport = map.viewport;
+
+            if (mLocationComponentManager == null) {
+                mLocationComponentManager = it.locationComponentManager
+            }
+
             if (mFollowUserLocation == false) {
                 viewport.idle()
                 mLocationComponentManager?.setFollowLocation(false)
@@ -298,10 +284,10 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
 
             mLocationComponentManager?.setFollowLocation(true)
             mLocationManager?.let {
-
-                val provider = it.provider
-                map.location.setLocationProvider(provider);
-                map.location2.setLocationProvider(provider);
+                val provider = map.location.getLocationProvider()
+                if (provider != null) {
+                    it.provider = provider
+                }
             }
 
             val location = map.location2

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/LocationComponentManager.kt

@@ -2,124 +2,166 @@ package com.mapbox.rctmgl.components.location
 
 import android.content.Context
 import android.graphics.Color
+import android.graphics.drawable.Drawable
 import android.graphics.drawable.VectorDrawable
 import androidx.appcompat.content.res.AppCompatResources
+import androidx.lifecycle.Lifecycle
 import com.mapbox.maps.plugin.locationcomponent.location
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.maps.Style
 import com.mapbox.maps.plugin.LocationPuck2D
+import com.mapbox.maps.plugin.PuckBearingSource
+import com.mapbox.maps.plugin.lifecycle.lifecycle
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.location.LocationManager
 
 /**
  * The LocationComponent on android implements display of user's current location.
- * But viewport seems to be tied to it in the sense that if location is not enbabled then it's viewport user tracking is not working.
+ * But viewport seems to be tied to it in the sense that if location is not enabled then it's viewport user tracking is not working.
  * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
  * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
  */
 class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
-    private var mShowNativeUserLocation = false
-    private var mFollowLocation = false
     var mMapView = mapView
     var mContext = context
-    var mState = State(enabled=true, hidden=false, tintColor= null)
-    var mLocationManager: LocationManager? = LocationManager.getInstance(context!!)
+    private var mState = State(showUserLocation=false, followUserLocation=false, hidden=false, tintColor= null, bearingImage = null, puckBearingSource =null)
+
+    private var mLocationManager: LocationManager = LocationManager.getInstance(context)
+
+    private var mNeedsFullUpdate = true
+
+    private var mLocationManagerStarted = false
 
     data class State(
-        val enabled: Boolean, // in case followUserLocation is active or visible
+        val showUserLocation: Boolean,
+        val followUserLocation: Boolean,
         val hidden: Boolean, // in case it isn't native
         val tintColor: Int?, // tint of location puck
-    )
-
-    fun showNativeUserLocation(showUserLocation: Boolean) {
-        mShowNativeUserLocation = showUserLocation
-
-        _applyChanges()
+        var bearingImage: Drawable?, // bearing image (background)
+        var puckBearingSource: PuckBearingSource? // bearing source
+    ) {
+        val enabled: Boolean
+            get() = showUserLocation || followUserLocation
     }
 
-    fun setFollowLocation(followLoation: Boolean) {
-        mFollowLocation = followLoation
-
-        _applyChanges()
+    fun update(newStateCallback: (currentState: State) -> State) {
+        val newState = newStateCallback(mState);
+        if (newState != mState) {
+            applyStateChanges(mState, newState)
+            mState = newState
+        }
     }
 
-    fun update(style: Style) {
-        _applyChanges()
-    }
+    private fun applyStateChanges(oldState: State, newState: State) {
+        mMapView.let {
+            val needsFullUpdate = mNeedsFullUpdate
 
-    fun setRenderMode(renderMode: RenderMode) {
-        _applyChanges()
+            applyStateChanges(it, oldState, newState,  needsFullUpdate)
+
+            mNeedsFullUpdate = false
+        }
     }
 
-    fun _applyChanges() {
-        mMapView?.let {
-            val newState = State(
-                enabled = mShowNativeUserLocation || mFollowLocation,
-                hidden = !mShowNativeUserLocation,
-                tintColor = mMapView!!.tintColor,
-            )
-
-            if (! mState.equals(newState)) {
-                it.location.updateSettings {
-                    val trackLocation = true
-                    enabled = newState.enabled
-
-                    if ((newState.hidden != mState.hidden) || (newState.tintColor != mState.tintColor)) {
-                        if (newState.hidden) {
-                            var emptyLocationPuck = LocationPuck2D()
-                            val empty = AppCompatResources.getDrawable(mContext!!, R.drawable.empty)
-                            emptyLocationPuck.bearingImage = empty
-                            emptyLocationPuck.shadowImage = empty
-                            emptyLocationPuck.topImage = empty
-                            //emptyLocationPuck.opacity = 0.0
-                            locationPuck = emptyLocationPuck
-                            pulsingEnabled = false
-                        } else {
-                            val mapboxBlueColor = Color.parseColor("#4A90E2")
-                            val tintColor = newState.tintColor
-                            val defaultLocationPuck = LocationPuck2D()
-                            var topImage = AppCompatResources.getDrawable(mContext!!, R.drawable.mapbox_user_icon)
-                            if (tintColor != null) {
-                                val drawable = topImage as VectorDrawable?
-                                drawable!!.setTint(tintColor)
-                                topImage = drawable
-                            }
-                            defaultLocationPuck.topImage = topImage
-                            val bearingImage = AppCompatResources.getDrawable(
-                                mContext!!, R.drawable.mapbox_user_stroke_icon
-                            )
-                            defaultLocationPuck.bearingImage = bearingImage
-                            val shadowImage = AppCompatResources.getDrawable(
-                                mContext!!, R.drawable.mapbox_user_icon_shadow
-                            )
-                            defaultLocationPuck.shadowImage = shadowImage
-                            locationPuck = defaultLocationPuck
-                            pulsingEnabled = true
-                            if (tintColor != null) {
-                                pulsingColor = tintColor
-                            } else {
-                                pulsingColor = mapboxBlueColor
-                            }
-                        }
+    private fun applyStateChanges(map: RCTMGLMapView, oldState: State, newState: State, fullUpdate: Boolean) {
+        if (map.getLifecycleState() != Lifecycle.State.STARTED) {
+            // In case lifecycle was already stopped, so we're part of shutdown, do not call updateSettings as it'll just restart
+            // the loationComponent that will not be stopped. See https://github.com/mapbox/mapbox-maps-android/issues/2017
+            if (!newState.enabled) {
+                stopLocationManager()
+            }
+            return
+        }
+        map.location.updateSettings {
+            enabled = newState.enabled
+
+            if (fullUpdate || (newState.hidden != oldState.hidden) || (newState.tintColor != oldState.tintColor) || (newState.bearingImage != oldState.bearingImage)) {
+                if (newState.hidden) {
+                    var emptyLocationPuck = LocationPuck2D()
+                    val empty = AppCompatResources.getDrawable(mContext, R.drawable.empty)
+                    emptyLocationPuck.bearingImage = empty
+                    emptyLocationPuck.shadowImage = empty
+                    emptyLocationPuck.topImage = empty
+                    //emptyLocationPuck.opacity = 0.0
+                    locationPuck = emptyLocationPuck
+                    pulsingEnabled = false
+                } else {
+                    val mapboxBlueColor = Color.parseColor("#4A90E2")
+                    val tintColor = newState.tintColor
+                    val defaultLocationPuck = LocationPuck2D()
+                    var topImage = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon)
+                    if (tintColor != null) {
+                        val drawable = topImage as VectorDrawable?
+                        drawable!!.setTint(tintColor)
+                        topImage = drawable
                     }
-                }
-
-                if (newState.enabled != mState.enabled) {
-                    if (newState.enabled) {
-                        mLocationManager?.startCounted()
-                        val provider = mLocationManager?.provider
-                        if (provider != null) {
-                            it.location.setLocationProvider(provider)
-                        }
+                    defaultLocationPuck.topImage = topImage
+                    val defaultBearingImage = AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_stroke_icon
+                    );
+                    defaultLocationPuck.bearingImage = newState.bearingImage ?: defaultBearingImage
+                    val shadowImage = AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_icon_shadow
+                    )
+                    defaultLocationPuck.shadowImage = shadowImage
+                    locationPuck = defaultLocationPuck
+                    pulsingEnabled = true
+                    if (tintColor != null) {
+                        pulsingColor = tintColor
                     } else {
-                        mLocationManager?.stopCounted()
+                        pulsingColor = mapboxBlueColor
                     }
                 }
+            }
 
-                mState = newState;
+            if (fullUpdate || newState.enabled != mState.enabled) {
+                if (newState.enabled) {
+                    startLocationManager()
+                    useMapLocationProvider(map)
+                } else {
+                    stopLocationManager()
+                }
             }
+        }
+    }
+
+    private fun startLocationManager() {
+        if (!mLocationManagerStarted) {
+            mLocationManager.startCounted()
+            mLocationManagerStarted = true
+        }
+    }
+
+    private fun stopLocationManager() {
+        if (mLocationManagerStarted) {
+            mLocationManager.stopCounted()
+            mLocationManagerStarted = false
+        }
+    }
+
+    private fun useMapLocationProvider(mapView: RCTMGLMapView) {
+        val provider = mapView.location.getLocationProvider()
+        if (provider != null) {
+            mLocationManager.provider = provider
+        }
+    }
+
 
+    fun showNativeUserLocation(showUserLocation: Boolean) {
+        update {
+            it.copy(showUserLocation = showUserLocation)
+        }
+    }
 
+    fun setFollowLocation(followUserLocation: Boolean) {
+        update {
+            it.copy(followUserLocation = followUserLocation)
         }
     }
+
+    fun update() {
+        update { it }
+    }
+
+    fun onDestroy() {
+        stopLocationManager();
+    }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocation.kt

@@ -2,25 +2,33 @@ package com.mapbox.rctmgl.components.location
 
 import android.annotation.SuppressLint
 import android.content.Context
+import androidx.appcompat.content.res.AppCompatResources
 import com.mapbox.rctmgl.components.mapview.OnMapReadyCallback
 import com.mapbox.maps.MapboxMap
 import com.mapbox.android.core.permissions.PermissionsManager
 import com.mapbox.maps.Style
+import com.mapbox.maps.plugin.PuckBearingSource
+import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 
-class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+enum class RenderMode {
+    GPS, COMPASS, NORMAL
+}
+
+class RCTMGLNativeUserLocation(context: Context) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
     private var mEnabled = true
     private var mMap: MapboxMap? = null
+    private var mRenderMode : RenderMode = RenderMode.NORMAL;
+    private var mContext : Context = context
 
-    private var mRenderMode : RenderMode = RenderMode.COMPASS
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(mapView)
         mEnabled = true
         mapView.getMapboxMap()
         mapView.getMapAsync(this)
-        setRenderMode(mRenderMode)
         mMapView?.locationComponentManager?.showNativeUserLocation(true)
+        applyChanges()
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
@@ -34,6 +42,12 @@ class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context),
     override fun onMapReady(mapboxMap: MapboxMap) {
         mMap = mapboxMap
         mapboxMap.getStyle(this)
+        applyChanges()
+    }
+
+    fun setAndroidRenderMode(renderMode: RenderMode) {
+        mRenderMode = renderMode;
+        applyChanges();
     }
 
     @SuppressLint("MissingPermission")
@@ -43,12 +57,24 @@ class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context),
             return
         }
 
-        mMapView?.locationComponentManager?.update(style)
+        mMapView?.locationComponentManager?.update()
         mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
     }
 
-    fun setRenderMode(renderMode: RenderMode) {
-        mRenderMode = renderMode
-        mMapView?.locationComponentManager?.setRenderMode(renderMode)
+    fun applyChanges() {
+        mMapView?.locationComponentManager?.let {
+            // emulate https://docs.mapbox.com/android/legacy/maps/guides/location-component/
+            when (mRenderMode) {
+                RenderMode.NORMAL ->
+                    it.update { it.copy(bearingImage =  null, puckBearingSource = null)}
+                RenderMode.GPS -> it.update {
+                    it.copy(bearingImage =  AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_bearing_icon
+                    ), puckBearingSource = PuckBearingSource.COURSE) }
+                RenderMode.COMPASS -> it.update{ it.copy(bearingImage=  AppCompatResources.getDrawable(
+                    mContext, R.drawable.mapbox_user_puck_icon
+                ), puckBearingSource = PuckBearingSource.HEADING) }
+            }
+        }
     }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocationManager.kt

@@ -0,0 +1,32 @@
+package com.mapbox.rctmgl.components.location
+
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.mapbox.rctmgl.utils.Logger
+import javax.annotation.Nonnull
+
+class RCTMGLNativeUserLocationManager : ViewGroupManager<RCTMGLNativeUserLocation>() {
+    @Nonnull
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactProp(name = "androidRenderMode")
+    fun setAndroidRenderMode(userLocation: RCTMGLNativeUserLocation, mode: String) {
+        when (mode) {
+            "compass" -> userLocation.setAndroidRenderMode(RenderMode.COMPASS);
+            "gps" -> userLocation.setAndroidRenderMode(RenderMode.GPS);
+            "normal" -> userLocation.setAndroidRenderMode(RenderMode.NORMAL);
+        }
+    }
+
+    @Nonnull
+    override fun createViewInstance(@Nonnull reactContext: ThemedReactContext): RCTMGLNativeUserLocation {
+        return RCTMGLNativeUserLocation(reactContext)
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLNativeUserLocation"
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -28,6 +28,7 @@ import com.mapbox.maps.extension.style.layers.properties.generated.ProjectionNam
 import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
 import com.mapbox.maps.extension.style.projection.generated.Projection
 import com.mapbox.maps.extension.style.projection.generated.setProjection
+import com.mapbox.maps.plugin.animation.camera
 import com.mapbox.maps.plugin.annotation.Annotation
 import com.mapbox.maps.plugin.annotation.AnnotationConfig
 import com.mapbox.maps.plugin.annotation.annotations
@@ -38,10 +39,13 @@ import com.mapbox.maps.plugin.compass.compass
 import com.mapbox.maps.plugin.compass.generated.CompassSettings
 import com.mapbox.maps.plugin.delegates.listeners.*
 import com.mapbox.maps.plugin.gestures.*
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.maps.plugin.locationcomponent.location2
 import com.mapbox.maps.plugin.logo.generated.LogoSettings
 import com.mapbox.maps.plugin.logo.logo
 import com.mapbox.maps.plugin.scalebar.generated.ScaleBarSettings
 import com.mapbox.maps.plugin.scalebar.scalebar
+import com.mapbox.maps.plugin.viewport.viewport
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerView
@@ -77,11 +81,64 @@ data class OrnamentSettings(
     var position: Int = -1
 )
 
-
-interface RCTMGLMapViewLifecycleOwner : LifecycleOwner {
+/***
+ * Mapbox's MapView observers lifecycle events see MapboxLifecyclePluginImpl - (ON_START, ON_STOP, ON_DESTROY)
+ * We need to emulate those.
+ */
+interface RCTMGLLifeCycleOwner : LifecycleOwner {
     fun handleLifecycleEvent(event: Lifecycle.Event)
 }
 
+class RCTMGLLifeCycle {
+    private var lifecycleOwner : RCTMGLLifeCycleOwner? = null
+
+    fun onAttachedToWindow(view: View) {
+        if (lifecycleOwner == null) {
+            lifecycleOwner = object : RCTMGLLifeCycleOwner {
+                private lateinit var lifecycleRegistry: LifecycleRegistry
+                init {
+                    lifecycleRegistry = LifecycleRegistry(this)
+                    lifecycleRegistry.currentState = Lifecycle.State.CREATED
+                }
+
+                override fun handleLifecycleEvent(event: Lifecycle.Event) {
+                    try {
+                        lifecycleRegistry.handleLifecycleEvent(event)
+                    } catch (e: RuntimeException) {
+                        Log.e("RCTMGLMapView", "handleLifecycleEvent, handleLifecycleEvent error: $e")
+                    }
+                }
+
+                override fun getLifecycle(): Lifecycle {
+                    return lifecycleRegistry
+                }
+            }
+            ViewTreeLifecycleOwner.set(view, lifecycleOwner);
+        }
+        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_START)
+    }
+
+    fun onDetachedFromWindow() {
+        if (lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.DESTROYED) {
+            return
+        }
+        lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_STOP)
+    }
+
+    fun onDestroy() {
+        if (lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.STARTED || lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.RESUMED) {
+            lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_STOP)
+        }
+        if (lifecycleOwner?.lifecycle?.currentState != Lifecycle.State.DESTROYED) {
+            lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_DESTROY)
+        }
+    }
+
+    fun getState() : Lifecycle.State {
+        return lifecycleOwner?.lifecycle?.currentState ?: Lifecycle.State.INITIALIZED;
+    }
+}
+
 open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapViewManager /*, MapboxMapOptions options*/) : MapView(mContext), OnMapClickListener, OnMapLongClickListener {
     /**
      * `PointAnnotations` are rendered to a canvas, but the React Native `Image` component is
@@ -1140,51 +1197,34 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     // endregion
 
     // region lifecycle
-    private var lifecycleOwner : RCTMGLMapViewLifecycleOwner? = null
+    private val lifecycle : RCTMGLLifeCycle by lazy { RCTMGLLifeCycle() }
+
+    fun getLifecycleState() : Lifecycle.State {
+        return this.lifecycle.getState()
+    }
 
     override fun onDetachedFromWindow() {
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+        lifecycle.onDetachedFromWindow()
         super.onDetachedFromWindow();
     }
 
     override fun onDestroy() {
         removeAllFeatures()
         viewAnnotationManager.removeAllViewAnnotations()
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+        mLocationComponentManager?.onDestroy();
+
+        lifecycle.onDestroy()
         super.onDestroy()
     }
 
     fun onDropViewInstance() {
         removeAllFeatures()
         viewAnnotationManager.removeAllViewAnnotations()
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+        lifecycle.onDestroy()
     }
 
     override fun onAttachedToWindow() {
-        if (lifecycleOwner == null) {
-            lifecycleOwner = object : RCTMGLMapViewLifecycleOwner {
-                private lateinit var lifecycleRegistry: LifecycleRegistry
-                init {
-                    lifecycleRegistry = LifecycleRegistry(this)
-                    lifecycleRegistry.currentState = Lifecycle.State.CREATED
-                }
-
-                override fun handleLifecycleEvent(event: Lifecycle.Event) {
-                    try {
-                        lifecycleRegistry.handleLifecycleEvent(event)
-                    } catch (e: RuntimeException) {
-                        Log.e("RCTMGLMapView", "onAttachedToWindow error: $e")
-                    }
-                }
-
-                override fun getLifecycle(): Lifecycle {
-                    return lifecycleRegistry
-                }
-            }
-            ViewTreeLifecycleOwner.set(this, lifecycleOwner);
-        } else {
-            lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
-        }
+        lifecycle.onAttachedToWindow(this)
         super.onAttachedToWindow()
     }