@exterio/react-native-yamap-lite 1.0.1

package/android/src/main/java/com/yamaplite/ClusteredYamapLiteViewManager.kt

@@ -0,0 +1,181 @@
+package com.yamaplite
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.ClusteredYamapLiteViewManagerInterface
+import com.facebook.react.viewmanagers.ClusteredYamapLiteViewManagerDelegate
+import android.view.View
+import android.graphics.Color
+import com.yamaplite.components.ClusteredYamapLiteView
+import com.yamaplite.utils.PointParser
+
+class ClusteredYamapLiteViewManager : ViewGroupManager<ClusteredYamapLiteView>(), ClusteredYamapLiteViewManagerInterface<ClusteredYamapLiteView> {
+  private val mDelegate: ViewManagerDelegate<ClusteredYamapLiteView>
+
+  init {
+    mDelegate = ClusteredYamapLiteViewManagerDelegate(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<ClusteredYamapLiteView> = mDelegate
+
+  override fun createViewInstance(context: ThemedReactContext): ClusteredYamapLiteView {
+    return ClusteredYamapLiteView(context)
+  }
+
+  override fun onDropViewInstance(view: ClusteredYamapLiteView) {
+    view.onDropViewInstance()
+    super.onDropViewInstance(view)
+  }
+
+  override fun addView(parent: ClusteredYamapLiteView, child: View, index: Int) {
+    parent.addChild(child, index)
+    super.addView(parent, child, index)
+  }
+
+  override fun getChildAt(parent: ClusteredYamapLiteView, index: Int): View {
+    return parent.getReactChildAt(index) ?: throw IndexOutOfBoundsException("Index $index is out of bounds for child count ${parent.getReactChildCount()}")
+  }
+
+  override fun getChildCount(parent: ClusteredYamapLiteView): Int {
+    return parent.getReactChildCount()
+  }
+
+  override fun removeViewAt(parent: ClusteredYamapLiteView, index: Int) {
+    val childCount = parent.getReactChildCount()
+    if (index >= 0 && index < childCount) {
+      parent.removeChild(index)
+      super.removeViewAt(parent, index)
+    }
+  }
+
+  override fun getName() = "ClusteredYamapLiteView"
+
+  @ReactProp(name = "userLocationIcon")
+  override fun setUserLocationIcon(view: ClusteredYamapLiteView, value: String?) {
+    view.setUserLocationIcon(value)
+  }
+
+  @ReactProp(name = "userLocationIconScale")
+  override fun setUserLocationIconScale(view: ClusteredYamapLiteView, value: Float) {
+    view.setUserLocationIconScale(value)
+  }
+
+  @ReactProp(name = "showUserPosition")
+  override fun setShowUserPosition(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setShowUserPosition(value)
+  }
+
+  @ReactProp(name = "nightMode")
+  override fun setNightMode(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setNightMode(value)
+  }
+
+  @ReactProp(name = "mapStyle")
+  override fun setMapStyle(view: ClusteredYamapLiteView, value: String?) {
+    view.setMapStyle(value)
+  }
+
+  @ReactProp(name = "scrollGesturesEnabled")
+  override fun setScrollGesturesEnabled(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setScrollGesturesEnabled(value)
+  }
+
+  @ReactProp(name = "zoomGesturesEnabled")
+  override fun setZoomGesturesEnabled(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setZoomGesturesEnabled(value)
+  }
+
+  @ReactProp(name = "tiltGesturesEnabled")
+  override fun setTiltGesturesEnabled(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setTiltGesturesEnabled(value)
+  }
+
+  @ReactProp(name = "rotateGesturesEnabled")
+  override fun setRotateGesturesEnabled(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setRotateGesturesEnabled(value)
+  }
+
+  @ReactProp(name = "fastTapEnabled")
+  override fun setFastTapEnabled(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setFastTapEnabled(value)
+  }
+
+  @ReactProp(name = "initialRegion")
+  override fun setInitialRegion(view: ClusteredYamapLiteView, value: ReadableMap?) {
+    if (value != null) {
+      val region = mutableMapOf<String, Any>()
+      if (value.hasKey("lat")) region["lat"] = value.getDouble("lat")
+      if (value.hasKey("lon")) region["lon"] = value.getDouble("lon")
+      if (value.hasKey("zoom")) region["zoom"] = value.getDouble("zoom")
+      if (value.hasKey("azimuth")) region["azimuth"] = value.getDouble("azimuth")
+      if (value.hasKey("tilt")) region["tilt"] = value.getDouble("tilt")
+      view.setInitialRegion(region)
+    }
+  }
+
+  @ReactProp(name = "maxFps")
+  override fun setMaxFps(view: ClusteredYamapLiteView, value: Float) {
+    view.setMaxFps(value)
+  }
+
+  @ReactProp(name = "mapType")
+  override fun setMapType(view: ClusteredYamapLiteView, value: String?) {
+    view.setMapType(value)
+  }
+
+  @ReactProp(name = "logoPosition")
+  override fun setLogoPosition(view: ClusteredYamapLiteView, value: ReadableMap?) {
+    if (value != null) {
+      val position = mutableMapOf<String, Any>()
+      if (value.hasKey("vertical")) position["vertical"] = value.getString("vertical") ?: "bottom"
+      if (value.hasKey("horizontal")) position["horizontal"] = value.getString("horizontal") ?: "left"
+      view.setLogoPosition(position)
+    }
+  }
+
+  @ReactProp(name = "logoPadding")
+  override fun setLogoPadding(view: ClusteredYamapLiteView, value: ReadableMap?) {
+    if (value != null) {
+      val horizontalPadding =
+        if ((value.hasKey("horizontal") && !value.isNull("horizontal"))) value.getInt("horizontal") else 0
+      val verticalPadding =
+        if ((value.hasKey("vertical") && !value.isNull("vertical"))) value.getInt("vertical") else 0
+      view.setLogoPadding(horizontalPadding, verticalPadding)
+    }
+  }
+
+  @ReactProp(name = "userLocationAccuracyFillColor")
+  override fun setUserLocationAccuracyFillColor(view: ClusteredYamapLiteView, value: String?) {
+    view.setUserLocationAccuracyFillColor(value)
+  }
+
+  @ReactProp(name = "userLocationAccuracyStrokeColor")
+  override fun setUserLocationAccuracyStrokeColor(view: ClusteredYamapLiteView, value: String?) {
+    view.setUserLocationAccuracyStrokeColor(value)
+  }
+
+  @ReactProp(name = "userLocationAccuracyStrokeWidth")
+  override fun setUserLocationAccuracyStrokeWidth(view: ClusteredYamapLiteView, value: Float) {
+    view.setUserLocationAccuracyStrokeWidth(value)
+  }
+
+  @ReactProp(name = "clusteredMarkers")
+  override fun setClusteredMarkers(view: ClusteredYamapLiteView, points: ReadableArray?) {
+    view.setClusteredMarkers(PointParser.parsePoints(points))
+  }
+
+  @ReactProp(name = "clusterColor")
+  override fun setClusterColor(view: ClusteredYamapLiteView, value: String?) {
+    view.setClusterColor(Color.parseColor(value ?: "#000000"))
+  }
+
+  @ReactProp(name = "followUser")
+  override fun setFollowUser(view: ClusteredYamapLiteView, value: Boolean) {
+    view.setFollowUser(value)
+  }
+}

package/android/src/main/java/com/yamaplite/Components/ClusteredYamapLiteView.kt

@@ -0,0 +1,169 @@
+package com.yamaplite.components
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.view.View
+import com.yandex.mapkit.geometry.Point
+import com.yandex.mapkit.map.Cluster
+import com.yandex.mapkit.map.ClusterListener
+import com.yandex.mapkit.map.ClusterTapListener
+import com.yandex.mapkit.map.ClusterizedPlacemarkCollection
+import com.yandex.mapkit.map.IconStyle
+import com.yandex.mapkit.map.PlacemarkMapObject
+import com.yandex.runtime.image.ImageProvider
+import kotlin.math.abs
+import kotlin.math.sqrt
+
+class ClusteredYamapLiteView(context: Context) :
+        YamapLiteView(context), ClusterListener, ClusterTapListener {
+  private var clusterCollection: ClusterizedPlacemarkCollection
+  private var clusterColor = Color.RED
+  private val placemarksMap: HashMap<String?, PlacemarkMapObject?> =
+          HashMap<String?, PlacemarkMapObject?>()
+  private var pointsList = ArrayList<Point>()
+
+  init {
+    clusterCollection = mapView.mapWindow.map.mapObjects.addClusterizedPlacemarkCollection(this)
+  }
+
+  fun setClusteredMarkers(points: List<Point>) {
+    pointsList = ArrayList(points)
+    rebuildClusterPlacemarks()
+  }
+
+  fun setClusterColor(color: Int) {
+    clusterColor = color
+    rebuildClusterPlacemarks()
+  }
+
+  private fun rebuildClusterPlacemarks() {
+    clusterCollection.clear()
+    placemarksMap.clear()
+    val placemarks = clusterCollection.addPlacemarks(pointsList, TextImageProvider(""), IconStyle())
+    val childCount = super.getReactChildCount()
+    for (i in placemarks.indices) {
+      val placemark = placemarks[i]
+      val geometry = placemark.geometry
+      placemarksMap[geometryKey(geometry.latitude, geometry.longitude)] = placemark
+      if (i < childCount) {
+        val child = super.getReactChildAt(i)
+        if (child is YamapLiteMarkerView) {
+          child.setMarkerMapObject(placemark)
+        }
+      }
+    }
+    clusterCollection.clusterPlacemarks(50.0, 12)
+  }
+
+  private fun geometryKey(lat: Double, lon: Double): String = "$lat,$lon"
+
+  fun addChild(child: View, index: Int) {
+    if (child is YamapLiteMarkerView) {
+      addReactChildToList(child, index)
+      val placemark = placemarksMap[geometryKey(child.latitude, child.longitude)]
+      if (placemark != null) {
+        child.setMarkerMapObject(placemark)
+      }
+    } else {
+      super.addReactChild(child, index)
+    }
+  }
+
+  fun removeChild(index: Int) {
+    if (index < 0 || index >= super.getReactChildCount()) {
+      return
+    }
+    val child = super.getReactChildAt(index)
+    if (child is YamapLiteMarkerView) {
+      val clusterPlacemark = placemarksMap.remove(geometryKey(child.latitude, child.longitude))
+      if (clusterPlacemark != null && clusterPlacemark.isValid) {
+        clusterCollection.remove(clusterPlacemark)
+      }
+      removeReactChildFromListAt(index)
+    } else {
+      super.removeReactChildAt(index)
+    }
+  }
+
+  override fun onClusterAdded(cluster: Cluster) {
+    cluster.appearance.setIcon(TextImageProvider(cluster.size.toString()))
+    cluster.addClusterTapListener(this)
+  }
+
+  override fun onClusterTap(cluster: Cluster): Boolean {
+    val points = ArrayList<Point?>()
+    for (placemark in cluster.placemarks) {
+      points.add(placemark.geometry)
+    }
+    super.fitMarkers(points)
+    return true
+  }
+
+  private inner class TextImageProvider(private val text: String) : ImageProvider() {
+    override fun getId(): String {
+      return "text_$text"
+    }
+
+    override fun getImage(): Bitmap {
+      // Scale sizes by display density to match iOS (which uses points that scale automatically)
+      val density = this@ClusteredYamapLiteView.context.resources.displayMetrics.density
+      val scaledFontSize = Companion.FONT_SIZE * density
+      val scaledMarginSize = Companion.MARGIN_SIZE * density
+      val scaledStrokeSize = Companion.STROKE_SIZE * density
+
+      val textPaint = Paint()
+      textPaint.textSize = scaledFontSize
+      textPaint.textAlign = Paint.Align.CENTER
+      textPaint.style = Paint.Style.FILL
+      textPaint.isAntiAlias = true
+
+      val widthF = textPaint.measureText(text)
+      val textMetrics = textPaint.fontMetrics
+      val heightF = (abs(textMetrics.bottom.toDouble()) + abs(textMetrics.top.toDouble())).toFloat()
+      val textRadius = sqrt((widthF * widthF + heightF * heightF).toDouble()).toFloat() / 2
+      val internalRadius = textRadius + scaledMarginSize
+      val externalRadius = internalRadius + scaledStrokeSize
+
+      val width = (2 * externalRadius + 0.5).toInt()
+
+      val bitmap = Bitmap.createBitmap(width, width, Bitmap.Config.ARGB_8888)
+      val canvas = Canvas(bitmap)
+
+      val backgroundPaint = Paint()
+      backgroundPaint.isAntiAlias = true
+      backgroundPaint.color = clusterColor
+      canvas.drawCircle(
+              (width / 2).toFloat(),
+              (width / 2).toFloat(),
+              externalRadius,
+              backgroundPaint
+      )
+
+      backgroundPaint.color = Color.WHITE
+      canvas.drawCircle(
+              (width / 2).toFloat(),
+              (width / 2).toFloat(),
+              internalRadius,
+              backgroundPaint
+      )
+
+      canvas.drawText(
+              text,
+              (width / 2).toFloat(),
+              width / 2 - (textMetrics.ascent + textMetrics.descent) / 2,
+              textPaint
+      )
+
+      return bitmap
+    }
+  }
+
+  companion object {
+    private const val FONT_SIZE = 45f
+    private const val MARGIN_SIZE = 9f
+    private const val STROKE_SIZE = 9f
+  }
+}

package/android/src/main/java/com/yamaplite/Components/YamapLiteCircleView.kt

@@ -0,0 +1,145 @@
+package com.yamaplite.components
+
+import android.content.Context
+import android.graphics.Color
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.yamaplite.events.PressEvent
+import com.yandex.mapkit.geometry.Circle
+import com.yandex.mapkit.geometry.Point
+import com.yandex.mapkit.map.CircleMapObject
+import com.yandex.mapkit.map.MapObject
+import com.yandex.mapkit.map.MapObjectTapListener
+import com.yandex.mapkit.mapview.MapView
+
+class YamapCircle(context: Context?) : ViewGroup(context), MapObjectTapListener {
+  var circle: Circle
+
+  var rnMapObject: MapObject? = null
+  private var mapView: MapView? = null
+  private var handled = true
+  private var fillColor = Color.BLACK
+  private var strokeColor = Color.BLACK
+  private var zInd = 1
+  private var strokeWidth = 1f
+  private var center = Point(0.0, 0.0)
+  private var radius = 0f
+
+  init {
+    circle = Circle(center, radius)
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
+
+  // PROPS
+  fun setCenter(point: Point) {
+    center = point
+    updateGeometry()
+    if (rnMapObject == null && mapView != null && radius > 0) {
+      addToMap(mapView!!)
+    } else {
+      updateCircle()
+    }
+  }
+
+  fun setRadius(_radius: Float) {
+    radius = _radius
+    updateGeometry()
+    if (rnMapObject == null &&
+                    mapView != null &&
+                    radius > 0 &&
+                    (center.latitude != 0.0 || center.longitude != 0.0)
+    ) {
+      addToMap(mapView!!)
+    } else {
+      updateCircle()
+    }
+  }
+
+  private fun updateGeometry() {
+    circle = Circle(center, radius)
+  }
+
+  fun setZInd(_zInd: Int) {
+    zInd = _zInd
+    updateCircle()
+  }
+
+  fun setHandled(_handled: Boolean) {
+    handled = _handled
+  }
+
+  fun setStrokeColor(_color: Int) {
+    strokeColor = _color
+    updateCircle()
+  }
+
+  fun setFillColor(_color: Int) {
+    fillColor = _color
+    updateCircle()
+  }
+
+  fun setStrokeWidth(width: Float) {
+    strokeWidth = width
+    updateCircle()
+  }
+
+  private fun updateCircle() {
+    if (rnMapObject != null) {
+      (rnMapObject as CircleMapObject).geometry = circle
+      (rnMapObject as CircleMapObject).strokeWidth = strokeWidth
+      (rnMapObject as CircleMapObject).strokeColor = strokeColor
+      (rnMapObject as CircleMapObject).fillColor = fillColor
+      (rnMapObject as CircleMapObject).zIndex = zInd.toFloat()
+    }
+  }
+
+  fun setCircleMapObject(obj: MapObject?) {
+    rnMapObject = obj as CircleMapObject?
+    rnMapObject!!.addTapListener(this)
+    updateCircle()
+  }
+
+  fun addToMap(mapView: MapView) {
+    this.mapView = mapView
+    updateGeometry()
+    if (!isGeometryValid()) {
+      return
+    }
+    val circleObject = mapView.getMapWindow().map.mapObjects.addCircle(circle)
+    rnMapObject = circleObject
+    circleObject.addTapListener(this)
+    updateCircle()
+  }
+
+  private fun isGeometryValid(): Boolean {
+    return radius > 0f && center.latitude.isFinite() && center.longitude.isFinite()
+  }
+
+  fun removeFromMap(mapView: MapView) {
+    rnMapObject?.let {
+      if (it.isValid) {
+        mapView.getMapWindow().map.mapObjects.remove(it)
+      }
+    }
+    rnMapObject = null
+  }
+
+  override fun onMapObjectTap(mapObject: MapObject, point: Point): Boolean {
+    val reactContext = context as? ReactContext
+    if (reactContext == null) {
+      return false
+    }
+
+    val viewId = getId()
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, viewId)
+
+    if (eventDispatcher != null) {
+      val event = PressEvent(surfaceId, viewId, "onCirclePress", point)
+      eventDispatcher.dispatchEvent(event)
+    }
+    return handled
+  }
+}

package/android/src/main/java/com/yamaplite/Components/YamapLiteMarkerView.kt

@@ -0,0 +1,214 @@
+package com.yamaplite.components
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.PointF
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.yamaplite.events.PressEvent
+import com.yamaplite.utils.ResolveImageHelper
+import com.yandex.mapkit.geometry.Point
+import com.yandex.mapkit.map.IconStyle
+import com.yandex.mapkit.map.MapObject
+import com.yandex.mapkit.map.MapObjectTapListener
+import com.yandex.mapkit.map.PlacemarkMapObject
+import com.yandex.mapkit.map.RotationType
+import com.yandex.mapkit.mapview.MapView
+import com.yandex.runtime.image.ImageProvider
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class YamapLiteMarkerView(context: Context) : View(context), MapObjectTapListener {
+  var latitude: Double = 0.0
+  var longitude: Double = 0.0
+  private var iconSource: String? = null
+  private var iconBitmap: Bitmap? = null
+  var markerScale: Double = 1.0
+  var zInd: Float = 0f
+  var isVisibleFlag: Boolean = true
+  var anchorX: Double = 0.5
+  var anchorY: Double = 0.5
+  private var _rotated: Boolean = false
+  private var _handled: Boolean = false
+  private var _size: Int = 25
+  private var _childView: View? = null
+
+  var placemark: PlacemarkMapObject? = null
+  private val coroutineScope = CoroutineScope(Dispatchers.Main)
+
+  private val childLayoutListener = OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+    applyStyle()
+  }
+
+  fun setMarkerMapObject(obj: PlacemarkMapObject?) {
+    placemark = obj
+    placemark?.userData = this
+    placemark?.addTapListener(this)
+    placemark?.isVisible = false
+    applyStyle()
+  }
+
+  fun addToMap(mapView: MapView) {
+    if (!latitude.isFinite() || !longitude.isFinite()) {
+      return
+    }
+    placemark?.let {
+      if (it.isValid) {
+        mapView.mapWindow.map.mapObjects.remove(it)
+      }
+    }
+    val point = Point(latitude, longitude)
+    placemark = mapView.mapWindow.map.mapObjects.addPlacemark(point)
+    placemark?.userData = this
+    placemark?.addTapListener(this)
+    applyStyle()
+  }
+
+  fun onDrop() {
+    _childView?.removeOnLayoutChangeListener(childLayoutListener)
+    _childView = null
+    coroutineScope.cancel()
+  }
+
+  fun removeFromMap(mapView: MapView) {
+    placemark?.let {
+      if (it.isValid) {
+        mapView.mapWindow.map.mapObjects.remove(it)
+      }
+    }
+    placemark = null
+  }
+
+  fun setPoint(lat: Double, lon: Double) {
+    latitude = lat
+    longitude = lon
+    placemark?.geometry = Point(lat, lon)
+  }
+
+  fun setIconSource(name: String?) {
+    iconSource = name
+    applyStyle()
+  }
+
+  fun setScale(value: Double) {
+    markerScale = value
+    applyStyle()
+  }
+
+  fun setZInd(value: Int) {
+    zInd = value.toFloat()
+    applyStyle()
+  }
+
+  fun setVisible(value: Boolean) {
+    isVisibleFlag = value
+    placemark?.isVisible = value
+  }
+
+  fun setAnchor(x: Double, y: Double) {
+    anchorX = x
+    anchorY = y
+    applyStyle()
+  }
+
+  fun setRotated(value: Boolean) {
+    _rotated = value
+    applyStyle()
+  }
+
+  fun setHandled(value: Boolean) {
+    _handled = value
+  }
+
+  fun getRotated(): Boolean = _rotated
+
+  fun getHandled(): Boolean = _handled
+
+  fun setSize(value: Int) {
+    _size = value
+    applyStyle()
+  }
+
+  fun setChildView(view: View?) {
+    if (view == null) {
+      _childView?.removeOnLayoutChangeListener(childLayoutListener)
+      _childView = null
+      applyStyle()
+      return
+    }
+    _childView = view
+    _childView!!.addOnLayoutChangeListener(childLayoutListener)
+    if (_childView!!.width > 0 && _childView!!.height > 0) {
+      applyStyle()
+    }
+  }
+
+  private fun applyStyle() {
+    if (placemark != null && placemark!!.isValid) {
+      (placemark as PlacemarkMapObject).isVisible = false
+      val iconStyle = IconStyle()
+      iconStyle.setScale(markerScale.toFloat())
+      iconStyle.setRotationType(if (_rotated) RotationType.ROTATE else RotationType.NO_ROTATION)
+      iconStyle.setVisible(isVisibleFlag)
+      iconStyle.setAnchor(PointF(anchorX.toFloat(), anchorY.toFloat()))
+      (placemark as PlacemarkMapObject).geometry = Point(latitude, longitude)
+      (placemark as PlacemarkMapObject).zIndex = zInd.toFloat()
+      (placemark as PlacemarkMapObject).setIconStyle(iconStyle)
+
+      if (_childView != null && _childView!!.width > 0 && _childView!!.height > 0) {
+        try {
+          val b =
+                  Bitmap.createBitmap(
+                          _childView!!.width,
+                          _childView!!.height,
+                          Bitmap.Config.ARGB_8888
+                  )
+          val c = Canvas(b)
+          _childView!!.draw(c)
+          val resizedBitmap = ResolveImageHelper.getInstance().resizeBitmap(context, b, _size)
+          (placemark as PlacemarkMapObject).setIcon(ImageProvider.fromBitmap(resizedBitmap))
+          (placemark as PlacemarkMapObject).setIconStyle(iconStyle)
+          (placemark as PlacemarkMapObject).isVisible = isVisibleFlag
+        } catch (e: Exception) {
+          e.printStackTrace()
+        }
+      }
+      if (_childView == null && iconSource?.isNotEmpty() == true) {
+        val currentIconStyle = iconStyle
+        coroutineScope.launch {
+          val icon = ResolveImageHelper.getInstance().resolveImage(context, iconSource!!, _size)
+          icon?.let {
+            placemark?.let { pm ->
+              if (pm.isValid) {
+                pm.setIcon(it)
+                currentIconStyle.let { pm.setIconStyle(it) }
+                pm.isVisible = isVisibleFlag
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  override fun onMapObjectTap(p0: MapObject, p1: Point): Boolean {
+    val reactContext = context as? ReactContext
+    if (reactContext == null) {
+      return _handled
+    }
+
+    val viewId = getId()
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, viewId)
+
+    if (eventDispatcher != null) {
+      val event = PressEvent(surfaceId, viewId, "onMarkerPress", p1)
+      eventDispatcher.dispatchEvent(event)
+    }
+    return _handled
+  }
+}