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

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

@@ -1,252 +0,0 @@
-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/clustering/NitroClusterEngine.kt

@@ -1,252 +0,0 @@
-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)
-            )
-        }
-    }
-}

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

@@ -1,195 +0,0 @@
-package com.margelo.nitro.nitromap.clustering
-
-import kotlin.math.sqrt
-
-/**
- * Point in 2D space with optional ID
- */
-data class QuadPoint(
-    val x: Double,
-    val y: Double,
-    val id: String = ""
-)
-
-/**
- * Bounding box for spatial queries
- */
-data class BoundingBox(
-    val minX: Double,
-    val minY: Double,
-    val maxX: Double,
-    val maxY: Double
-) {
-    fun contains(point: QuadPoint): Boolean {
-        return point.x >= minX && point.x <= maxX &&
-               point.y >= minY && point.y <= maxY
-    }
-
-    fun intersects(other: BoundingBox): Boolean {
-        return !(other.minX > maxX || other.maxX < minX ||
-                 other.minY > maxY || other.maxY < minY)
-    }
-}
-
-/**
- * High-performance QuadTree for spatial indexing
- * O(log n) point insertion and range queries
- */
-class QuadTree(
-    private val boundary: BoundingBox,
-    private val capacity: Int = MAX_POINTS,
-    private val depth: Int = 0
-) {
-    companion object {
-        const val MAX_POINTS = 4
-        const val MAX_DEPTH = 12
-    }
-
-    private val points = mutableListOf<QuadPoint>()
-    private var divided = false
-    private var northwest: QuadTree? = null
-    private var northeast: QuadTree? = null
-    private var southwest: QuadTree? = null
-    private var southeast: QuadTree? = null
-
-    /**
-     * Insert a point into the tree
-     */
-    fun insert(point: QuadPoint): Boolean {
-        if (!boundary.contains(point)) {
-            return false
-        }
-
-        if (points.size < capacity || depth >= MAX_DEPTH) {
-            points.add(point)
-            return true
-        }
-
-        if (!divided) {
-            subdivide()
-        }
-
-        return northwest?.insert(point) == true ||
-               northeast?.insert(point) == true ||
-               southwest?.insert(point) == true ||
-               southeast?.insert(point) == true
-    }
-
-    /**
-     * Query points within a bounding box
-     */
-    fun query(range: BoundingBox, found: MutableList<QuadPoint>) {
-        if (!boundary.intersects(range)) {
-            return
-        }
-
-        for (point in points) {
-            if (range.contains(point)) {
-                found.add(point)
-            }
-        }
-
-        if (divided) {
-            northwest?.query(range, found)
-            northeast?.query(range, found)
-            southwest?.query(range, found)
-            southeast?.query(range, found)
-        }
-    }
-
-    /**
-     * Query points within a circular radius
-     */
-    fun queryRadius(
-        centerX: Double,
-        centerY: Double,
-        radius: Double,
-        found: MutableList<QuadPoint>
-    ) {
-        val range = BoundingBox(
-            centerX - radius,
-            centerY - radius,
-            centerX + radius,
-            centerY + radius
-        )
-
-        if (!boundary.intersects(range)) {
-            return
-        }
-
-        val radiusSq = radius * radius
-        for (point in points) {
-            val dx = point.x - centerX
-            val dy = point.y - centerY
-            if (dx * dx + dy * dy <= radiusSq) {
-                found.add(point)
-            }
-        }
-
-        if (divided) {
-            northwest?.queryRadius(centerX, centerY, radius, found)
-            northeast?.queryRadius(centerX, centerY, radius, found)
-            southwest?.queryRadius(centerX, centerY, radius, found)
-            southeast?.queryRadius(centerX, centerY, radius, found)
-        }
-    }
-
-    /**
-     * Get all points in the tree
-     */
-    fun getAllPoints(allPoints: MutableList<QuadPoint>) {
-        allPoints.addAll(points)
-        if (divided) {
-            northwest?.getAllPoints(allPoints)
-            northeast?.getAllPoints(allPoints)
-            southwest?.getAllPoints(allPoints)
-            southeast?.getAllPoints(allPoints)
-        }
-    }
-
-    /**
-     * Clear all points from the tree
-     */
-    fun clear() {
-        points.clear()
-        if (divided) {
-            northwest?.clear()
-            northeast?.clear()
-            southwest?.clear()
-            southeast?.clear()
-            northwest = null
-            northeast = null
-            southwest = null
-            southeast = null
-            divided = false
-        }
-    }
-
-    private fun subdivide() {
-        val midX = (boundary.minX + boundary.maxX) / 2
-        val midY = (boundary.minY + boundary.maxY) / 2
-
-        northwest = QuadTree(
-            BoundingBox(boundary.minX, midY, midX, boundary.maxY),
-            capacity,
-            depth + 1
-        )
-        northeast = QuadTree(
-            BoundingBox(midX, midY, boundary.maxX, boundary.maxY),
-            capacity,
-            depth + 1
-        )
-        southwest = QuadTree(
-            BoundingBox(boundary.minX, boundary.minY, midX, midY),
-            capacity,
-            depth + 1
-        )
-        southeast = QuadTree(
-            BoundingBox(midX, boundary.minY, boundary.maxX, midY),
-            capacity,
-            depth + 1
-        )
-
-        divided = true
-    }
-}