@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.0

package/android/src/main/kotlin/com/margelo/nitro/nitromap/NitroMap.kt

@@ -0,0 +1,397 @@
+package com.margelo.nitro.nitromap
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.widget.FrameLayout
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nitromap.providers.MapProviderFactory
+import com.margelo.nitro.nitromap.providers.MapProviderInterface
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * HybridNitroMap — Android map implementation for Nitro Modules.
+ *
+ * Provider-agnostic facade: delegates all map operations to a MapProviderInterface
+ * implementation created via MapProviderFactory. Currently supports Google Maps,
+ * with Apple Maps (N/A on Android) and Yandex Maps planned.
+ *
+ * Lifecycle:
+ *   onViewAttachedToWindow → create provider MapView + init
+ *   onViewDetachedFromWindow → pause MapView (DO NOT destroy — preserves state for navigation)
+ *   dispose() → destroy MapView + full cleanup (only on actual unmount)
+ *
+ * Threading:
+ *   Props from React render → UI Thread (safe)
+ *   Props from hybridRef → may be JS Thread (dispatch to main)
+ *   Methods from hybridRef → JS Thread (dispatch to main)
+ */
+class HybridNitroMap(context: Context) : HybridNitroMapSpec() {
+
+    companion object {
+        private const val TAG = "NitroMap"
+    }
+
+    // MARK: - View
+
+    private val mapContext: Context = context
+    private val container = FrameLayout(context).apply {
+        clipChildren = false
+        clipToPadding = false
+    }
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    override val view: View get() = container
+
+    // MARK: - Provider + Lifecycle State
+
+    private val mapProvider: MapProviderInterface by lazy {
+        MapProviderFactory.create(provider ?: MapProvider.GOOGLE, mapContext)
+    }
+    private val locationManager = UserLocationManager(mapContext)
+    private var currentMapView: View? = null
+    @Volatile
+    private var isDisposed = false
+
+    init {
+        container.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {
+            override fun onViewAttachedToWindow(v: View) {
+                if (!isDisposed) {
+                    attachMapView()
+                }
+            }
+
+            override fun onViewDetachedFromWindow(v: View) {
+                detachMapView()
+            }
+        })
+    }
+
+    private fun attachMapView() {
+        if (currentMapView != null) return // already attached
+
+        val mv = mapProvider.createMapView(mapContext)
+        container.addView(mv, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+
+        if (!isDisposed) {
+            mapProvider.onViewAttached(mv)
+        }
+        currentMapView = mv
+        Log.d(TAG, "MapView attached")
+    }
+
+    private fun detachMapView() {
+        currentMapView?.let { mv ->
+            mapProvider.onViewDetaching()
+            container.removeView(mv)
+        }
+        currentMapView = null
+        Log.d(TAG, "MapView detached (paused, state saved)")
+    }
+
+    override fun dispose() {
+        isDisposed = true
+        locationManager.destroy()
+        currentMapView?.let { mv ->
+            mapProvider.onViewDestroying()
+            container.removeView(mv)
+        }
+        currentMapView = null
+        Log.d(TAG, "MapView disposed (destroyed)")
+        super.dispose()
+    }
+
+    // MARK: - Properties (dispatch to mapProvider)
+
+    override var provider: MapProvider? = null
+
+    override var initialRegion: Region? = null
+        set(value) {
+            // Negative deltas = JS sentinel meaning "unset/cleared" (Fabric null workaround)
+            if (value != null && (value.latitudeDelta < 0 || value.longitudeDelta < 0)) return
+            field = value
+            mapProvider.initialRegion = value
+        }
+
+    override var region: Region? = null
+        set(value) {
+            // Negative deltas = JS sentinel meaning "unset/cleared" (Fabric null workaround)
+            if (value != null && (value.latitudeDelta < 0 || value.longitudeDelta < 0)) {
+                if (field == null) return // already cleared
+                field = null
+                mapProvider.region = null
+                return
+            }
+            // Skip if same value re-applied (Fabric re-commits all props on every
+            // cycle, unlike iOS which only calls didSet for changed props — without
+            // this guard, panning away from a controlled region snaps back)
+            if (field == value) return
+            field = value
+            mapProvider.region = value
+        }
+
+    override var showsUserLocation: Boolean? = null
+        set(value) {
+            val changed = field != value
+            field = value
+            mapProvider.showsUserLocation = value
+            if (value == true) {
+                locationManager.onLocationUpdate = { location, heading ->
+                    mapProvider.updateUserLocation(location, heading)
+                    onUserLocationChange?.invoke(
+                        UserLocationChangeEvent(
+                            Coordinate(location.latitude, location.longitude),
+                            location.accuracy.toDouble(),
+                            heading?.toDouble() ?: -1.0,
+                            location.speed.toDouble()
+                        )
+                    )
+                }
+                locationManager.onLocationError = { code, message ->
+                    onUserLocationError?.invoke(MapError(code, message))
+                }
+                locationManager.startUpdating()
+                // Only create the marker on actual change (not re-renders),
+                // otherwise it resets rotation to 0 and heading is lost on idle
+                if (changed) {
+                    mapProvider.setupCustomUserLocationMarker(mapContext)
+                }
+            } else {
+                locationManager.stopUpdating()
+                mapProvider.disableUserLocation()
+            }
+        }
+
+    override var zoomEnabled: Boolean? = null
+        set(value) { field = value; mapProvider.zoomEnabled = value }
+
+    override var scrollEnabled: Boolean? = null
+        set(value) { field = value; mapProvider.scrollEnabled = value }
+
+    override var rotateEnabled: Boolean? = null
+        set(value) { field = value; mapProvider.rotateEnabled = value }
+
+    override var pitchEnabled: Boolean? = null
+        set(value) { field = value; mapProvider.pitchEnabled = value }
+
+    override var mapType: MapType? = null
+        set(value) { field = value; mapProvider.mapType = value }
+
+    override var customMapStyle: Array<MapStyleElement>? = null
+        set(value) { field = value; mapProvider.customMapStyle = value }
+
+    override var clusterConfig: ClusterConfig? = null
+        set(value) { field = value; mapProvider.clusterConfig = value }
+
+    override var mapPadding: EdgePadding = EdgePadding(0.0, 0.0, 0.0, 0.0)
+        set(value) { field = value; mapProvider.mapPadding = value }
+
+    override var showsTraffic: Boolean? = null
+        set(value) { field = value; mapProvider.showsTraffic = value }
+
+    override var showsBuildings: Boolean? = null
+        set(value) { field = value; mapProvider.showsBuildings = value }
+
+    override var showsCompass: Boolean? = null
+        set(value) { field = value; mapProvider.showsCompass = value }
+
+    // L-2: Align with iOS default (1.0, not 0.0)
+    override var minZoom: Double = 1.0
+        set(value) { field = value; mapProvider.minZoom = value }
+
+    override var maxZoom: Double = 22.0
+        set(value) { field = value; mapProvider.maxZoom = value }
+
+    override var darkMode: Boolean? = null
+        set(value) { field = value; mapProvider.darkMode = value }
+
+    override var userTrackingMode: UserTrackingMode? = null
+        set(value) { field = value; mapProvider.userTrackingMode = value }
+
+    override var userLocationImage: String = ""
+        set(value) {
+            if (field == value) return
+            field = value
+            mapProvider.userLocationImage = value
+            if (showsUserLocation == true) {
+                mapProvider.setupCustomUserLocationMarker(mapContext)
+            }
+        }
+
+    override var userLocationSize: Double = 0.0
+        set(value) {
+            if (field == value) return
+            field = value
+            mapProvider.userLocationSize = value
+            if (showsUserLocation == true) {
+                mapProvider.setupCustomUserLocationMarker(mapContext)
+            }
+        }
+
+    override var userLocationAnchor: Point? = null
+        set(value) { field = value; mapProvider.userLocationAnchor = value }
+
+    // MARK: - Callback Properties (wire directly to mapProvider)
+
+    override var onPress: ((event: MapPressEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onPress = value }
+
+    override var onLongPress: ((event: MapPressEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onLongPress = value }
+
+    override var onMapReady: (() -> Unit)? = null
+        set(value) { field = value; mapProvider.onMapReadyCallback = value }
+
+    override var onRegionChange: ((region: RegionChangeEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onRegionChange = value }
+
+    override var onRegionChangeComplete: ((region: RegionChangeEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onRegionChangeComplete = value }
+
+    override var onMarkerPress: ((event: MarkerPressEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onMarkerPress = value }
+
+    override var onMarkerDragStart: ((event: MarkerDragEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onMarkerDragStart = value }
+
+    override var onMarkerDrag: ((event: MarkerDragEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onMarkerDrag = value }
+
+    override var onMarkerDragEnd: ((event: MarkerDragEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onMarkerDragEnd = value }
+
+    override var onClusterPress: ((event: ClusterPressEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onClusterPress = value }
+
+    override var onPolylinePress: ((id: String) -> Unit)? = null
+        set(value) { field = value; mapProvider.onPolylinePress = value }
+
+    override var onPolygonPress: ((id: String) -> Unit)? = null
+        set(value) { field = value; mapProvider.onPolygonPress = value }
+
+    override var onCirclePress: ((id: String) -> Unit)? = null
+        set(value) { field = value; mapProvider.onCirclePress = value }
+
+    override var onError: ((error: MapError) -> Unit)? = null
+        set(value) { field = value; mapProvider.onError = value }
+
+    override var onUserLocationChange: ((event: UserLocationChangeEvent) -> Unit)? = null
+        set(value) { field = value; mapProvider.onUserLocationChange = value }
+
+    override var onUserTrackingModeChange: ((mode: UserTrackingMode) -> Unit)? = null
+        set(value) { field = value; mapProvider.onUserTrackingModeChange = value }
+
+    override var onUserLocationError: ((error: MapError) -> Unit)? = null
+        set(value) { field = value; mapProvider.onUserLocationError = value }
+
+    override var onMapIdle: (() -> Unit)? = null
+        set(value) { field = value; mapProvider.onMapIdle = value }
+
+    // MARK: - Thread Dispatch Helper
+
+    /**
+     * Run a block on the main thread and return the result.
+     * If already on the main thread, executes directly.
+     * Otherwise, posts to mainHandler and waits with CountDownLatch.
+     */
+    // C-2: Increased timeout to 10s and added graceful handling.
+    // Using indefinite await risks permanent JS thread block if main thread is dead.
+    // 10s is generous enough to survive heavy main-thread load without ANR (5s threshold).
+    private fun <T> runOnMainThread(caller: String = "unknown", block: () -> T): T {
+        if (Looper.myLooper() == Looper.getMainLooper()) return block()
+        val ref = AtomicReference<T>()
+        val errorRef = AtomicReference<Throwable>()
+        val latch = CountDownLatch(1)
+        mainHandler.post {
+            try {
+                ref.set(block())
+            } catch (e: Throwable) {
+                errorRef.set(e)
+            } finally {
+                latch.countDown()
+            }
+        }
+        val completed = latch.await(10, TimeUnit.SECONDS)
+        if (!completed) {
+            Log.w(TAG, "$caller: main thread dispatch timed out after 10s")
+            throw RuntimeException("NitroMap.$caller: main thread dispatch timed out after 10s")
+        }
+        errorRef.get()?.let { throw it }
+        return ref.get()
+    }
+
+    // MARK: - Methods (dispatch to mapProvider)
+
+    override fun animateToRegion(region: Region, duration: Double?) =
+        mapProvider.animateToRegion(region, duration)
+
+    override fun fitToCoordinates(coordinates: Array<Coordinate>, edgePadding: EdgePadding?, animated: Boolean?) =
+        mapProvider.fitToCoordinates(coordinates, edgePadding, animated)
+
+    override fun fitToSuppliedMarkers(markerIds: Array<String>, edgePadding: EdgePadding?, animated: Boolean?) =
+        mapProvider.fitToSuppliedMarkers(markerIds, edgePadding, animated)
+
+    override fun animateCamera(camera: Camera, duration: Double?) =
+        mapProvider.animateCamera(camera, duration)
+
+    override fun getCamera(): Promise<Camera> = Promise.async {
+        runOnMainThread("getCamera") { mapProvider.getCamera() }
+    }
+
+    override fun setCamera(camera: Camera) = mapProvider.setCamera(camera)
+
+    override fun setMapStyle(style: Array<MapStyleElement>?) { customMapStyle = style }
+
+    override fun getMapBoundaries(): Promise<MapBoundaries> = Promise.async {
+        runOnMainThread("getMapBoundaries") {
+            mapProvider.getMapBoundaries() ?: MapBoundaries(Coordinate(0.0, 0.0), Coordinate(0.0, 0.0))
+        }
+    }
+
+    override fun centerOnUserLocation() = mapProvider.centerOnUserLocation()
+
+    override fun pointForCoordinate(coordinate: Coordinate): Point =
+        runOnMainThread("pointForCoordinate") { mapProvider.pointForCoordinate(coordinate) }
+
+    override fun coordinateForPoint(point: Point): Coordinate =
+        runOnMainThread("coordinateForPoint") { mapProvider.coordinateForPoint(point) }
+
+    override fun setIsDarkMode(enabled: Boolean) { darkMode = enabled }
+
+    // MARK: - Marker Methods (Batch 5)
+    // C-1/C-2: All mutating methods dispatch to main thread to match iOS DispatchQueue.main.async.
+    // These methods return Unit so fire-and-forget via mainHandler.post is safe.
+    override fun addMarker(marker: MarkerData) { mainHandler.post { mapProvider.addMarker(marker) } }
+    override fun addMarkers(markers: Array<MarkerData>) { mainHandler.post { mapProvider.addMarkers(markers) } }
+    override fun updateMarker(marker: MarkerData) { mainHandler.post { mapProvider.updateMarker(marker) } }
+    override fun removeMarker(id: String) { mainHandler.post { mapProvider.removeMarker(id) } }
+    override fun selectMarker(id: String) { mainHandler.post { mapProvider.selectMarker(id) } }
+    override fun deselectMarker() { mainHandler.post { mapProvider.deselectMarker() } }
+    override fun clearMarkers() { mainHandler.post { mapProvider.clearMarkers() } }
+
+
+    // MARK: - Clustering Methods
+    override fun setClusteringEnabled(enabled: Boolean) { mainHandler.post { mapProvider.setClusteringEnabled(enabled) } }
+    override fun refreshClusters() { mainHandler.post { mapProvider.refreshClusters() } }
+
+    // MARK: - Overlay Methods (Polyline, Polygon, Circle)
+    override fun addPolyline(polyline: PolylineData) { mainHandler.post { mapProvider.addPolyline(polyline) } }
+    override fun updatePolyline(polyline: PolylineData) { mainHandler.post { mapProvider.updatePolyline(polyline) } }
+    override fun removePolyline(id: String) { mainHandler.post { mapProvider.removePolyline(id) } }
+    override fun clearPolylines() { mainHandler.post { mapProvider.clearPolylines() } }
+    override fun addPolygon(polygon: PolygonData) { mainHandler.post { mapProvider.addPolygon(polygon) } }
+    override fun updatePolygon(polygon: PolygonData) { mainHandler.post { mapProvider.updatePolygon(polygon) } }
+    override fun removePolygon(id: String) { mainHandler.post { mapProvider.removePolygon(id) } }
+    override fun clearPolygons() { mainHandler.post { mapProvider.clearPolygons() } }
+    override fun addCircle(circle: CircleData) { mainHandler.post { mapProvider.addCircle(circle) } }
+    override fun updateCircle(circle: CircleData) { mainHandler.post { mapProvider.updateCircle(circle) } }
+    override fun removeCircle(id: String) { mainHandler.post { mapProvider.removeCircle(id) } }
+    override fun clearCircles() { mainHandler.post { mapProvider.clearCircles() } }
+
+    override val memorySize: Long
+        get() = 0L
+}

package/android/src/main/kotlin/com/margelo/nitro/nitromap/NitroMapConfig.kt

@@ -0,0 +1,53 @@
+package com.margelo.nitro.nitromap
+
+import android.util.Log
+import com.google.android.gms.maps.MapsInitializer
+import com.margelo.nitro.NitroModules
+
+class HybridNitroMapConfig : HybridNitroMapConfigSpec() {
+
+    companion object {
+        private var isInitialized = false
+        /** The provider that was initialized. Used for consistency validation. */
+        var initializedProvider: MapProvider? = null
+            private set
+    }
+
+    override fun NitroMapInitialize(apiKey: String, provider: MapProvider) {
+        if (isInitialized) {
+            Log.d("NitroMap", "Already initialized, skipping...")
+            return
+        }
+
+        when (provider) {
+            MapProvider.GOOGLE -> {
+                try {
+                    // On Android, the API key is read from AndroidManifest.xml <meta-data>
+                    // at build time — not passed at runtime like iOS.
+                    val context = NitroModules.applicationContext
+                        ?: throw IllegalStateException("Application context not available")
+                    MapsInitializer.initialize(context)
+                    isInitialized = true
+                    initializedProvider = provider
+                    Log.d("NitroMap", "Google Maps initialized")
+                } catch (e: Exception) {
+                    Log.e("NitroMap", "Failed to initialize Google Maps: ${e.message}")
+                }
+            }
+            MapProvider.APPLE -> {
+                Log.e("NitroMap", "Apple Maps is not available on Android")
+            }
+            MapProvider.YANDEX -> {
+                // Future: YandexMapKit initialization with apiKey
+                Log.e("NitroMap", "Yandex Maps is not yet implemented")
+            }
+        }
+    }
+
+    override fun IsNitroMapInitialized(): Boolean {
+        return isInitialized
+    }
+
+    override val memorySize: Long
+        get() = 0L
+}

package/android/src/main/{java → kotlin}/com/margelo/nitro/nitromap/NitroMapPackage.kt

@@ -8,10 +8,12 @@ import com.facebook.react.uimanager.ViewManager
 
 import com.margelo.nitro.nitromap.views.HybridNitroMapManager
 
+/**
+ * React Native Package for NitroMap.
+ * Registers the ViewManager and loads the native C++ library.
+ */
 class NitroMapPackage : BaseReactPackage() {
     override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-        // Set context for HybridNitroMapConfig on first module access
-        HybridNitroMapConfig.setContext(reactContext)
         return null
     }
 
@@ -20,8 +22,6 @@ class NitroMapPackage : BaseReactPackage() {
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        // Set context for HybridNitroMapConfig
-        HybridNitroMapConfig.setContext(reactContext)
         return listOf(HybridNitroMapManager())
     }
 

package/android/src/main/kotlin/com/margelo/nitro/nitromap/NitroMapView.kt

@@ -0,0 +1,73 @@
+package com.margelo.nitro.nitromap
+
+import android.content.Context
+import android.view.Choreographer
+import android.view.View
+import android.view.ViewGroup
+import com.google.android.gms.maps.MapView
+
+/**
+ * Custom MapView subclass that fixes two Fabric layout issues:
+ *
+ * 1. **Viewport clipping**: When GoogleMap.setPadding() is called, the SDK internally
+ *    calls View.setPadding() on this MapView. In Fabric, that View-level padding
+ *    causes the viewport to shrink/clip. We block it here.
+ *
+ * 2. **Controls not measured**: In Fabric, requestLayout() is intercepted by Yoga,
+ *    so when the compass transitions INVISIBLE→VISIBLE, it never gets re-measured
+ *    (stays 0x0). We use Choreographer to force a manual layout pass whenever
+ *    requestLayout is called, ensuring all internal SDK views get measured.
+ */
+class NitroMapView(context: Context) : MapView(context) {
+
+    // Flag to track if construction is complete (requestLayout is called
+    // during super constructor before our fields are initialized)
+    private var isConstructed = false
+
+    private var layoutRequested = false
+
+    private val layoutCallback = Choreographer.FrameCallback {
+        layoutRequested = false
+        // Manually measure and layout this view and all children.
+        // Fabric's Yoga sets our dimensions, so we use them as-is.
+        if (width > 0 && height > 0) {
+            measure(
+                MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+            )
+            layout(left, top, right, bottom)
+        }
+    }
+
+    init {
+        isConstructed = true
+    }
+
+    /**
+     * Block View-level padding changes.
+     * GoogleMap.setPadding() internally calls this, which in Fabric causes
+     * the viewport to shrink. The SDK still positions controls (compass, logo)
+     * via their own LayoutParams using the stored GoogleMap padding values.
+     */
+    override fun setPadding(left: Int, top: Int, right: Int, bottom: Int) {
+        // Intentionally blocked — prevents Fabric viewport shrinking
+    }
+
+    /**
+     * Override requestLayout to schedule a manual layout pass via Choreographer.
+     * In Fabric, the default requestLayout() is intercepted by Yoga and may not
+     * trigger a real measure/layout pass for this view's children. By using
+     * Choreographer, we ensure internal SDK views (compass, logo, etc.) get
+     * measured when they change visibility or position.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        // Guard: skip during super constructor (fields not yet initialized)
+        if (!isConstructed) return
+        // Avoid scheduling multiple callbacks per frame
+        if (!layoutRequested) {
+            layoutRequested = true
+            Choreographer.getInstance().postFrameCallback(layoutCallback)
+        }
+    }
+}