@maydon_tech/react-native-nitro-maps 0.1.0

package/android/src/main/java/com/margelo/nitro/nitromap/MarkerIconFactory.kt

@@ -0,0 +1,252 @@
+package com.margelo.nitro.nitromap
+
+import android.content.Context
+import android.graphics.*
+import android.util.Base64
+import com.google.android.gms.maps.model.BitmapDescriptor
+import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import java.net.URL
+import kotlin.math.roundToInt
+
+/** Factory for creating marker icons from MarkerData configuration */
+object MarkerIconFactory {
+
+    private var reactContext: com.facebook.react.bridge.ReactContext? = null
+
+    /** Set the React context for view capture (call this from HybridNitroMap initialization) */
+    fun setReactContext(context: com.facebook.react.bridge.ReactContext?) {
+        reactContext = context
+    }
+
+    fun createIcon(context: Context, markerData: MarkerData): BitmapDescriptor? {
+        return when (markerData.config.style) {
+            MarkerStyle.IMAGE -> createImageMarkerIcon(context, markerData.config.image)
+            MarkerStyle.PRICEMARKER ->
+                    createPriceMarkerStyleIcon(context, markerData.config.priceMarker)
+            MarkerStyle.DEFAULT -> null
+        }
+    }
+
+    private fun createPriceMarkerStyleIcon(
+            context: Context,
+            config: PriceMarkerStyle?
+    ): BitmapDescriptor? {
+        config ?: return null
+
+        // Generate cache key (Flyweight pattern)
+        val cacheKey =
+                MarkerIconCache.priceMarkerKey(config.price, config.currency, config.selected)
+
+        // Check cache first
+        MarkerIconCache.getPriceMarker(cacheKey)?.let { cachedBitmap ->
+            return BitmapDescriptorFactory.fromBitmap(cachedBitmap)
+        }
+
+        val density = context.resources.displayMetrics.density
+        val priceText = "${config.price} ${config.currency}"
+        val fontSize = (config.fontSize ?: 14.0) * density
+        val paddingH = (config.paddingHorizontal ?: 12.0) * density
+        val paddingV = (config.paddingVertical ?: 8.0) * density
+
+        val textPaint =
+                Paint(Paint.ANTI_ALIAS_FLAG).apply {
+                    textSize = fontSize.toFloat()
+                    typeface = Typeface.DEFAULT_BOLD
+                    textAlign = Paint.Align.LEFT
+                }
+
+        // Set colors based on selection state
+        val bgColor =
+                if (config.selected) {
+                    config.selectedBackgroundColor?.let { ColorUtils.fromVariant(it) }
+                            ?: Color.parseColor("#E53935") // Red for selected
+                } else {
+                    config.backgroundColor?.let { ColorUtils.fromVariant(it) } ?: Color.WHITE
+                }
+
+        val textColor =
+                if (config.selected) {
+                    config.selectedTextColor?.let { ColorUtils.fromVariant(it) } ?: Color.WHITE
+                } else {
+                    config.textColor?.let { ColorUtils.fromVariant(it) } ?: Color.BLACK
+                }
+
+        textPaint.color = textColor
+
+        val textBounds = Rect()
+        textPaint.getTextBounds(priceText, 0, priceText.length, textBounds)
+
+        val arrowHeight = 8 * density
+        val width = textBounds.width() + paddingH * 2
+        val height = textBounds.height() + paddingV * 2 + arrowHeight
+        val cornerRadius = 8 * density
+
+        val bitmap =
+                Bitmap.createBitmap(
+                        width.roundToInt(),
+                        height.roundToInt(),
+                        Bitmap.Config.ARGB_8888
+                )
+        val canvas = Canvas(bitmap)
+
+        val bgPaint =
+                Paint(Paint.ANTI_ALIAS_FLAG).apply {
+                    color = bgColor
+                    style = Paint.Style.FILL
+                }
+
+        // Add shadow
+        val shadowPaint =
+                Paint(Paint.ANTI_ALIAS_FLAG).apply {
+                    color = Color.BLACK
+                    alpha = ((config.shadowOpacity ?: 0.2) * 255).toInt()
+                    maskFilter = BlurMaskFilter((4 * density).toFloat(), BlurMaskFilter.Blur.NORMAL)
+                }
+
+        val bubbleRect =
+                RectF(
+                        (2 * density).toFloat(),
+                        0f,
+                        (width - 2 * density).toFloat(),
+                        (height - arrowHeight).toFloat()
+                )
+        canvas.drawRoundRect(
+                bubbleRect.apply { offset(0f, (2 * density).toFloat()) },
+                cornerRadius.toFloat(),
+                cornerRadius.toFloat(),
+                shadowPaint
+        )
+
+        bubbleRect.offset(0f, (-2 * density).toFloat())
+        canvas.drawRoundRect(bubbleRect, cornerRadius.toFloat(), cornerRadius.toFloat(), bgPaint)
+
+        // Draw arrow
+        val path =
+                Path().apply {
+                    moveTo((width / 2 - arrowHeight).toFloat(), (height - arrowHeight).toFloat())
+                    lineTo((width / 2).toFloat(), height.toFloat())
+                    lineTo((width / 2 + arrowHeight).toFloat(), (height - arrowHeight).toFloat())
+                    close()
+                }
+        canvas.drawPath(path, bgPaint)
+
+        // Draw text
+        val textX = paddingH.toFloat()
+        val textY = paddingV.toFloat() + textBounds.height()
+        canvas.drawText(priceText, textX, textY, textPaint)
+
+        // Cache the bitmap for reuse
+        MarkerIconCache.putPriceMarker(cacheKey, bitmap)
+
+        return BitmapDescriptorFactory.fromBitmap(bitmap)
+    }
+
+    private fun createImageMarkerIcon(
+            context: Context,
+            config: ImageMarkerConfig?
+    ): BitmapDescriptor? {
+        config ?: return null
+
+        val imageSource = config.imageBase64 ?: config.imageUrl ?: ""
+
+        // Generate cache key (Flyweight pattern)
+        val cacheKey =
+                MarkerIconCache.imageMarkerKey(
+                        imageSource,
+                        config.width,
+                        config.height,
+                        config.cornerRadius
+                )
+
+        // Check cache first
+        MarkerIconCache.getImageMarker(cacheKey)?.let { cachedBitmap ->
+            return BitmapDescriptorFactory.fromBitmap(cachedBitmap)
+        }
+
+        val density = context.resources.displayMetrics.density
+        val width = (config.width * density).roundToInt()
+        val height = (config.height * density).roundToInt()
+        val cornerRadius = config.cornerRadius * density
+        val borderWidth = config.borderWidth * density
+
+        var sourceImage: Bitmap? = null
+
+        // Try to load image from base64
+        config.imageBase64?.let { base64 ->
+            try {
+                val bytes = Base64.decode(base64, Base64.DEFAULT)
+                sourceImage = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        // Try to load from URL (blocking - should be done on background thread in production)
+        if (sourceImage == null) {
+            config.imageUrl?.let { urlString ->
+                try {
+                    val url = URL(urlString)
+                    val connection = url.openConnection()
+                    connection.connectTimeout = 5000
+                    connection.readTimeout = 5000
+                    val inputStream = connection.getInputStream()
+                    sourceImage = BitmapFactory.decodeStream(inputStream)
+                    inputStream.close()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+
+        val clipPath =
+                Path().apply {
+                    addRoundRect(
+                            RectF(0f, 0f, width.toFloat(), height.toFloat()),
+                            cornerRadius.toFloat(),
+                            cornerRadius.toFloat(),
+                            Path.Direction.CW
+                    )
+                }
+        canvas.clipPath(clipPath)
+
+        // Draw image or placeholder
+        sourceImage?.let { img ->
+            val scaledBitmap = Bitmap.createScaledBitmap(img, width, height, true)
+            canvas.drawBitmap(scaledBitmap, 0f, 0f, null)
+            if (scaledBitmap != img) scaledBitmap.recycle()
+        }
+                ?: run {
+                    val placeholderPaint = Paint().apply { color = Color.LTGRAY }
+                    canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), placeholderPaint)
+                }
+
+        // Draw border
+        if (borderWidth > 0) {
+            val borderPaint =
+                    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+                        color = ColorUtils.fromColorValue(config.borderColor)
+                        style = Paint.Style.STROKE
+                        strokeWidth = borderWidth.toFloat()
+                    }
+            canvas.drawRoundRect(
+                    RectF(
+                            borderWidth.toFloat() / 2,
+                            borderWidth.toFloat() / 2,
+                            width - borderWidth.toFloat() / 2,
+                            height - borderWidth.toFloat() / 2
+                    ),
+                    cornerRadius.toFloat(),
+                    cornerRadius.toFloat(),
+                    borderPaint
+            )
+        }
+
+        // Cache the bitmap for reuse
+        MarkerIconCache.putImageMarker(cacheKey, bitmap)
+
+        return BitmapDescriptorFactory.fromBitmap(bitmap)
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitromap/NitroMapPackage.kt

@@ -0,0 +1,33 @@
+package com.margelo.nitro.nitromap
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+import com.margelo.nitro.nitromap.views.HybridNitroMapManager
+
+class NitroMapPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        // Set context for HybridNitroMapConfig on first module access
+        HybridNitroMapConfig.setContext(reactContext)
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        // Set context for HybridNitroMapConfig
+        HybridNitroMapConfig.setContext(reactContext)
+        return listOf(HybridNitroMapManager())
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("nitromap")
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitromap/clustering/NitroClusterEngine.kt

@@ -0,0 +1,252 @@
+package com.margelo.nitro.nitromap.clustering
+
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.LatLngBounds
+import com.margelo.nitro.nitromap.ClusterConfig
+import com.margelo.nitro.nitromap.MarkerData
+import kotlin.math.*
+
+/**
+ * Marker point for clustering
+ */
+data class MarkerPoint(
+    val id: String,
+    val latitude: Double,
+    val longitude: Double
+)
+
+/**
+ * Cluster result containing multiple markers
+ */
+data class Cluster(
+    val latitude: Double,
+    val longitude: Double,
+    val markerIds: List<String>,
+    val count: Int
+)
+
+/**
+ * Full clustering result
+ */
+data class ClusterResult(
+    val clusters: List<Cluster>,
+    val singleMarkers: List<MarkerPoint>
+)
+
+/**
+ * High-performance clustering engine using QuadTree spatial indexing
+ * Kotlin port of C++ ClusterEngine
+ */
+class NitroClusterEngine {
+
+    // QuadTree for O(log n) spatial queries
+    private var quadTree: QuadTree? = null
+
+    // All markers stored by ID
+    private val markers = mutableMapOf<String, MarkerPoint>()
+
+    // Marker data cache for full marker info
+    private val markerDataCache = mutableMapOf<String, MarkerData>()
+
+    // Configuration
+    private var clusterRadius = 60.0
+    private var minClusterSize = 2
+    private var maxZoom = 20.0
+
+    // MARK: - Configuration
+
+    fun setClusterRadius(radius: Double) {
+        clusterRadius = radius
+    }
+
+    fun setMinClusterSize(size: Int) {
+        minClusterSize = size
+    }
+
+    fun setMaxZoom(zoom: Double) {
+        maxZoom = zoom
+    }
+
+    fun updateConfig(config: ClusterConfig?) {
+        config?.let {
+            minClusterSize = it.minimumClusterSize.toInt()
+            maxZoom = it.maxZoom
+        }
+    }
+
+    // MARK: - Marker Management
+
+    fun addMarker(markerData: MarkerData) {
+        val id = markerData.id
+        val point = MarkerPoint(
+            id = id,
+            latitude = markerData.coordinate.latitude,
+            longitude = markerData.coordinate.longitude
+        )
+        markers[id] = point
+        markerDataCache[id] = markerData
+        rebuildQuadTree()
+    }
+
+    fun addMarkers(markersList: List<MarkerData>) {
+        for (marker in markersList) {
+            val id = marker.id
+            val point = MarkerPoint(
+                id = id,
+                latitude = marker.coordinate.latitude,
+                longitude = marker.coordinate.longitude
+            )
+            markers[id] = point
+            markerDataCache[id] = marker
+        }
+        rebuildQuadTree()
+    }
+
+    fun removeMarker(id: String) {
+        markers.remove(id)
+        markerDataCache.remove(id)
+        rebuildQuadTree()
+    }
+
+    fun clearMarkers() {
+        markers.clear()
+        markerDataCache.clear()
+        quadTree?.clear()
+        quadTree = null
+    }
+
+    fun getMarkerCount(): Int = markers.size
+
+    fun getMarkerData(id: String): MarkerData? = markerDataCache[id]
+
+    // MARK: - Clustering
+
+    fun cluster(
+        bounds: LatLngBounds,
+        zoom: Float,
+        mapWidth: Int,
+        mapHeight: Int
+    ): ClusterResult {
+        // At max zoom or beyond, don't cluster
+        if (zoom >= maxZoom) {
+            return ClusterResult(
+                clusters = emptyList(),
+                singleMarkers = markers.values.toList()
+            )
+        }
+
+        val tree = quadTree ?: return ClusterResult(emptyList(), markers.values.toList())
+
+        // Calculate cluster radius in coordinate space
+        val latSpan = bounds.northeast.latitude - bounds.southwest.latitude
+        val lngSpan = bounds.northeast.longitude - bounds.southwest.longitude
+
+        // Pixels to degrees conversion
+        val pixelsPerDegreeLat = if (latSpan > 0) mapHeight / latSpan else 1.0
+        val pixelsPerDegreeLng = if (lngSpan > 0) mapWidth / lngSpan else 1.0
+
+        // Cluster radius in degrees
+        val radiusLat = clusterRadius / pixelsPerDegreeLat
+        val radiusLng = clusterRadius / pixelsPerDegreeLng
+        val avgRadius = (radiusLat + radiusLng) / 2.0
+
+        // Grid-based clustering for O(n) performance
+        val gridSizeLat = radiusLat * 2
+        val gridSizeLng = radiusLng * 2
+
+        // Get visible markers
+        val visiblePoints = mutableListOf<QuadPoint>()
+        val range = BoundingBox(
+            bounds.southwest.longitude,
+            bounds.southwest.latitude,
+            bounds.northeast.longitude,
+            bounds.northeast.latitude
+        )
+        tree.query(range, visiblePoints)
+
+        // Track processed markers
+        val processed = mutableSetOf<String>()
+        val clusters = mutableListOf<Cluster>()
+        val singleMarkers = mutableListOf<MarkerPoint>()
+
+        for (point in visiblePoints) {
+            if (processed.contains(point.id)) continue
+
+            // Find nearby markers
+            val nearbyPoints = mutableListOf<QuadPoint>()
+            tree.queryRadius(point.x, point.y, avgRadius, nearbyPoints)
+
+            // Filter to unprocessed points
+            val unprocessedNearby = nearbyPoints.filter { !processed.contains(it.id) }
+
+            if (unprocessedNearby.size >= minClusterSize) {
+                // Create cluster
+                var sumLat = 0.0
+                var sumLng = 0.0
+                val markerIds = mutableListOf<String>()
+
+                for (nearby in unprocessedNearby) {
+                    sumLng += nearby.x
+                    sumLat += nearby.y
+                    markerIds.add(nearby.id)
+                    processed.add(nearby.id)
+                }
+
+                val count = unprocessedNearby.size
+                clusters.add(
+                    Cluster(
+                        latitude = sumLat / count,
+                        longitude = sumLng / count,
+                        markerIds = markerIds,
+                        count = count
+                    )
+                )
+            } else {
+                // Single marker
+                processed.add(point.id)
+                markers[point.id]?.let { singleMarkers.add(it) }
+            }
+        }
+
+        return ClusterResult(clusters, singleMarkers)
+    }
+
+    private fun rebuildQuadTree() {
+        if (markers.isEmpty()) {
+            quadTree = null
+            return
+        }
+
+        // Find bounds
+        var minLat = Double.MAX_VALUE
+        var maxLat = -Double.MAX_VALUE
+        var minLng = Double.MAX_VALUE
+        var maxLng = -Double.MAX_VALUE
+
+        for (marker in markers.values) {
+            minLat = min(minLat, marker.latitude)
+            maxLat = max(maxLat, marker.latitude)
+            minLng = min(minLng, marker.longitude)
+            maxLng = max(maxLng, marker.longitude)
+        }
+
+        // Add padding
+        val latPadding = (maxLat - minLat) * 0.1 + 0.001
+        val lngPadding = (maxLng - minLng) * 0.1 + 0.001
+
+        val bounds = BoundingBox(
+            minLng - lngPadding,
+            minLat - latPadding,
+            maxLng + lngPadding,
+            maxLat + latPadding
+        )
+
+        quadTree = QuadTree(bounds)
+
+        for (marker in markers.values) {
+            quadTree?.insert(
+                QuadPoint(marker.longitude, marker.latitude, marker.id)
+            )
+        }
+    }
+}