@granite-js/naver-map 1.0.0

package/android/src/main/java/run/granite/navermap/GraniteNaverMapProvider.kt

@@ -0,0 +1,242 @@
+package run.granite.navermap
+
+import android.content.Context
+import android.view.View
+
+/**
+ * Data class for map coordinates
+ */
+data class GraniteNaverMapCoordinate(
+    val latitude: Double,
+    val longitude: Double
+)
+
+/**
+ * Data class for camera position
+ */
+data class GraniteNaverMapCameraPosition(
+    val target: GraniteNaverMapCoordinate,
+    val zoom: Double,
+    val tilt: Double = 0.0,
+    val bearing: Double = 0.0
+)
+
+/**
+ * Data class for bounds
+ */
+data class GraniteNaverMapBounds(
+    val southWest: GraniteNaverMapCoordinate,
+    val northEast: GraniteNaverMapCoordinate
+)
+
+/**
+ * Map type enum
+ */
+enum class GraniteNaverMapType {
+    BASIC, NAVI, SATELLITE, HYBRID, TERRAIN, NONE
+}
+
+/**
+ * Location tracking mode enum
+ */
+enum class GraniteNaverMapLocationTrackingMode {
+    NONE, NO_FOLLOW, FOLLOW, FACE
+}
+
+/**
+ * Marker data
+ */
+data class GraniteNaverMapMarkerData(
+    val identifier: String,
+    val coordinate: GraniteNaverMapCoordinate,
+    val width: Int,
+    val height: Int,
+    val zIndex: Int,
+    val rotation: Float,
+    val flat: Boolean,
+    val alpha: Float,
+    val pinColor: Int,
+    val image: String
+)
+
+/**
+ * Polyline data
+ */
+data class GraniteNaverMapPolylineData(
+    val identifier: String,
+    val coordinates: List<GraniteNaverMapCoordinate>,
+    val strokeWidth: Float,
+    val strokeColor: Int,
+    val zIndex: Int,
+    val lineCap: Int,
+    val lineJoin: Int,
+    val pattern: List<Int>
+)
+
+/**
+ * Polygon data
+ */
+data class GraniteNaverMapPolygonData(
+    val identifier: String,
+    val coordinates: List<GraniteNaverMapCoordinate>,
+    val holes: List<List<GraniteNaverMapCoordinate>>,
+    val fillColor: Int,
+    val strokeColor: Int,
+    val strokeWidth: Float,
+    val zIndex: Int
+)
+
+/**
+ * Circle data
+ */
+data class GraniteNaverMapCircleData(
+    val identifier: String,
+    val center: GraniteNaverMapCoordinate,
+    val radius: Double,
+    val fillColor: Int,
+    val strokeColor: Int,
+    val strokeWidth: Float,
+    val zIndex: Int
+)
+
+/**
+ * Path data
+ */
+data class GraniteNaverMapPathData(
+    val identifier: String,
+    val coordinates: List<GraniteNaverMapCoordinate>,
+    val width: Float,
+    val outlineWidth: Float,
+    val color: Int,
+    val outlineColor: Int,
+    val passedColor: Int,
+    val passedOutlineColor: Int,
+    val patternImage: String,
+    val patternInterval: Int,
+    val progress: Float,
+    val zIndex: Int
+)
+
+/**
+ * Provider delegate interface for map events
+ */
+interface GraniteNaverMapProviderDelegate {
+    fun onMapInitialized()
+    fun onCameraChange(position: GraniteNaverMapCameraPosition, contentRegion: List<GraniteNaverMapCoordinate>, coveringRegion: List<GraniteNaverMapCoordinate>)
+    fun onTouch(reason: Int, animated: Boolean)
+    fun onClick(x: Double, y: Double, latitude: Double, longitude: Double)
+    fun onMarkerClick(id: String)
+}
+
+/**
+ * Factory interface for creating NaverMap providers.
+ * Each call to createProvider() should return a new instance.
+ *
+ * Brownfield apps can implement this interface to provide their own map implementation.
+ */
+interface GraniteNaverMapProviderFactory {
+    /**
+     * Create a new provider instance.
+     * This should be called for each NaverMap view.
+     */
+    fun createProvider(context: Context): GraniteNaverMapProvider
+}
+
+/**
+ * Pluggable Provider interface for NaverMap
+ *
+ * Brownfield apps can implement this interface to use their own map implementation.
+ * Note: Each view should have its own Provider instance (created via Factory).
+ */
+interface GraniteNaverMapProvider {
+    /**
+     * Create the map container view
+     */
+    fun createMapView(context: Context): View
+
+    /**
+     * Set the delegate for map events
+     */
+    fun setDelegate(delegate: GraniteNaverMapProviderDelegate?)
+
+    /**
+     * Called when the view is attached to window
+     */
+    fun onAttachedToWindow()
+
+    /**
+     * Called when the view is detached from window
+     */
+    fun onDetachedFromWindow()
+
+    /**
+     * Called when the view size changes
+     */
+    fun onSizeChanged(width: Int, height: Int)
+
+    /**
+     * Called on host resume
+     */
+    fun onHostResume()
+
+    /**
+     * Called on host pause
+     */
+    fun onHostPause()
+
+    // MARK: - Camera
+
+    fun moveCamera(position: GraniteNaverMapCameraPosition, animated: Boolean)
+    fun animateToCoordinate(coordinate: GraniteNaverMapCoordinate)
+    fun animateToBounds(bounds: GraniteNaverMapBounds, padding: Int)
+
+    // MARK: - Map Properties
+
+    fun setMapType(type: GraniteNaverMapType)
+    fun setMapPadding(top: Int, left: Int, bottom: Int, right: Int)
+    fun setCompassEnabled(enabled: Boolean)
+    fun setScaleBarEnabled(enabled: Boolean)
+    fun setZoomControlEnabled(enabled: Boolean)
+    fun setLocationButtonEnabled(enabled: Boolean)
+    fun setBuildingHeight(height: Float)
+    fun setNightModeEnabled(enabled: Boolean)
+    fun setMinZoomLevel(level: Double)
+    fun setMaxZoomLevel(level: Double)
+    fun setScrollGesturesEnabled(enabled: Boolean)
+    fun setZoomGesturesEnabled(enabled: Boolean)
+    fun setTiltGesturesEnabled(enabled: Boolean)
+    fun setRotateGesturesEnabled(enabled: Boolean)
+    fun setStopGesturesEnabled(enabled: Boolean)
+    fun setLocationTrackingMode(mode: GraniteNaverMapLocationTrackingMode)
+    fun setLayerGroupEnabled(group: String, enabled: Boolean)
+
+    // MARK: - Markers
+
+    fun addMarker(data: GraniteNaverMapMarkerData)
+    fun updateMarker(data: GraniteNaverMapMarkerData)
+    fun removeMarker(identifier: String)
+
+    // MARK: - Polylines
+
+    fun addPolyline(data: GraniteNaverMapPolylineData)
+    fun updatePolyline(data: GraniteNaverMapPolylineData)
+    fun removePolyline(identifier: String)
+
+    // MARK: - Polygons
+
+    fun addPolygon(data: GraniteNaverMapPolygonData)
+    fun updatePolygon(data: GraniteNaverMapPolygonData)
+    fun removePolygon(identifier: String)
+
+    // MARK: - Circles
+
+    fun addCircle(data: GraniteNaverMapCircleData)
+    fun updateCircle(data: GraniteNaverMapCircleData)
+    fun removeCircle(identifier: String)
+
+    // MARK: - Paths
+
+    fun addPath(data: GraniteNaverMapPathData)
+    fun updatePath(data: GraniteNaverMapPathData)
+    fun removePath(identifier: String)
+}

package/android/src/main/java/run/granite/navermap/GraniteNaverMapRegistry.kt

@@ -0,0 +1,116 @@
+package run.granite.navermap
+
+import android.content.Context
+
+/**
+ * Type alias for provider creation lambda
+ */
+typealias GraniteNaverMapProviderCreator = (Context) -> GraniteNaverMapProvider
+
+/**
+ * Internal wrapper to adapt lambda to factory interface
+ */
+private class LambdaProviderFactory(
+    private val creator: GraniteNaverMapProviderCreator
+) : GraniteNaverMapProviderFactory {
+    override fun createProvider(context: Context): GraniteNaverMapProvider {
+        return creator(context)
+    }
+}
+
+/**
+ * Registry singleton for NaverMap provider factories
+ *
+ * Brownfield apps can register their own provider factory at app startup.
+ * If no factory is registered and the default provider is included, the built-in
+ * NMapsMap provider factory will be used.
+ *
+ * Usage:
+ * ```kotlin
+ * // In your Application.onCreate() or before using NaverMap:
+ * GraniteNaverMapRegistry.register { context ->
+ *     MyNaverMapProvider(context)
+ * }
+ * ```
+ */
+object GraniteNaverMapRegistry {
+    private var _factory: GraniteNaverMapProviderFactory? = null
+
+    /**
+     * The currently registered factory
+     */
+    val factory: GraniteNaverMapProviderFactory?
+        get() = _factory
+
+    /**
+     * Register a provider using a lambda. Call this at app startup before using NaverMap.
+     * This is the preferred Kotlin API.
+     *
+     * Usage:
+     * ```kotlin
+     * GraniteNaverMapRegistry.register { context ->
+     *     MyNaverMapProvider(context)
+     * }
+     * ```
+     */
+    fun register(creator: GraniteNaverMapProviderCreator) {
+        _factory = LambdaProviderFactory(creator)
+    }
+
+    /**
+     * Register a custom provider factory. Call this at app startup before using NaverMap.
+     * This API is provided for Java compatibility.
+     */
+    fun register(factory: GraniteNaverMapProviderFactory) {
+        _factory = factory
+    }
+
+    /**
+     * Create a new provider instance for a NaverMap view.
+     * Each view should call this to get its own provider instance.
+     *
+     * @return A new provider instance, or null if no factory is registered and default provider is not included
+     */
+    fun createProvider(context: Context): GraniteNaverMapProvider? {
+        // Use registered factory if available
+        _factory?.let { return it.createProvider(context) }
+
+        // Only try to create built-in provider if it's included in the build
+        if (BuildConfig.INCLUDE_DEFAULT_PROVIDER) {
+            return createBuiltInProviderFactory()?.createProvider(context)
+        }
+
+        return null
+    }
+
+    /**
+     * Create built-in provider factory using reflection to avoid compile-time dependency
+     */
+    private fun createBuiltInProviderFactory(): GraniteNaverMapProviderFactory? {
+        return try {
+            val clazz = Class.forName("run.granite.navermap.builtinProvider.BuiltInGraniteNaverMapProviderFactory")
+            clazz.getDeclaredConstructor().newInstance() as GraniteNaverMapProviderFactory
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Check if a custom factory has been registered
+     */
+    val hasCustomFactory: Boolean
+        get() = _factory != null
+
+    /**
+     * Check if the default provider is available in this build
+     */
+    val hasDefaultProvider: Boolean
+        get() = BuildConfig.INCLUDE_DEFAULT_PROVIDER
+
+    /**
+     * Reset the factory (useful for testing)
+     */
+    fun reset() {
+        _factory = null
+    }
+}