react-native-google-maps-plus 0.1.0 → 1.0.1

package/android/src/main/java/com/googlemapsnitro/HybridGoogleMapsNitroModule.kt

@@ -0,0 +1,22 @@
+package com.googlemapsnitro
+
+import com.margelo.nitro.core.Promise
+
+class HybridGoogleMapsNitroModule : HybridGoogleMapsNitroModuleSpec() {
+  val context = GoogleMapsNitroPackage.AppContextHolder.context
+  private val locationHandler: LocationHandler = LocationHandler(context)
+  private val permissionHandler: PermissionHandler = PermissionHandler(context)
+  private val playServicesHandler: PlayServicesHandler = PlayServicesHandler(context)
+
+  override fun showLocationDialog() {
+    locationHandler.showLocationDialog()
+  }
+
+  override fun openLocationSettings() {
+    locationHandler.openLocationSettings()
+  }
+
+  override fun requestLocationPermission(): Promise<RNLocationPermissionResult> = permissionHandler.requestLocationPermission()
+
+  override fun isGooglePlayServicesAvailable(): Boolean = playServicesHandler.isPlayServicesAvailable()
+}

package/android/src/main/java/com/googlemapsnitro/HybridGoogleMapsNitroView.kt

@@ -0,0 +1,337 @@
+package com.googlemapsnitro
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.MapColorScheme
+import com.google.android.gms.maps.model.MapStyleOptions
+import com.margelo.nitro.core.Promise
+
+@DoNotStrip
+class HybridGoogleMapsNitroView(
+  val context: ThemedReactContext,
+) : HybridGoogleMapsNitroViewSpec() {
+  private var currentCustomMapStyle: String = ""
+  private var permissionHandler = PermissionHandler(context)
+  private var locationHandler = LocationHandler(context)
+  private var playServiceHandler = PlayServicesHandler(context)
+  private val markerOptions = MarkerOptions()
+
+  override val view =
+    GoogleMapsNitroViewImpl(context, locationHandler, playServiceHandler, markerOptions)
+
+  private val polylineOptions = MapPolylineOptions()
+  private val polygonOptions = MapPolygonOptions()
+
+  override var buildingEnabled: Boolean
+    get() = view.buildingEnabled
+    set(value) {
+      view.buildingEnabled = value
+    }
+
+  override var trafficEnabled: Boolean
+    get() = view.trafficEnabled
+    set(value) {
+      view.trafficEnabled = value
+    }
+
+  override var customMapStyle: String
+    get() = currentCustomMapStyle
+    set(value) {
+      currentCustomMapStyle = value
+      view.customMapStyle = MapStyleOptions(value)
+    }
+
+  override var initialCamera: RNCamera
+    get() = mapCameraPotionToCamera(view.initialCamera)
+    set(value) {
+      view.initialCamera = mapCameraToCameraPosition(value)
+    }
+
+  override var userInterfaceStyle: RNUserInterfaceStyle
+    get() = mapColorSchemeToUserInterfaceStyle(view.userInterfaceStyle)
+    set(value) {
+      view.userInterfaceStyle = userInterfaceStyleToMapColorScheme(value)
+    }
+
+  override var minZoomLevel: Double
+    get() = view.minZoomLevel
+    set(value) {
+      view.minZoomLevel = value
+    }
+
+  override var maxZoomLevel: Double
+    get() = view.maxZoomLevel
+    set(value) {
+      view.maxZoomLevel = value
+    }
+
+  override var mapPadding: RNMapPadding
+    get() = view.mapPadding
+    set(value) {
+      view.mapPadding = value
+    }
+
+  override var markers: Array<RNMarker> = emptyArray()
+    set(value) {
+      val prevById = field.associateBy { it.id }
+      val nextById = value.associateBy { it.id }
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        markerOptions.cancelIconJob(id)
+        view.removeMarker(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          markerOptions.buildIconAsync(id, next) { icon ->
+            view.addMarker(
+              id,
+              markerOptions.build(next, icon),
+            )
+          }
+        } else if (!prev.markerEquals(next)) {
+          view.updateMarker(id) { m ->
+            onUi {
+              if (prev.coordinate != next.coordinate) {
+                m.position =
+                  com.google.android.gms.maps.model.LatLng(
+                    next.coordinate.latitude,
+                    next.coordinate.longitude,
+                  )
+              }
+              if (prev.zIndex != next.zIndex) {
+                m.zIndex = next.zIndex.toFloat()
+              }
+              if (!prev.markerStyleEquals(next)) {
+                markerOptions.buildIconAsync(id, next) { icon ->
+                  m.setIcon(icon)
+                }
+              }
+              if (prev.anchor != next.anchor) {
+                m.setAnchor(
+                  (next.anchor?.x ?: 0.5).toFloat(),
+                  (next.anchor?.y ?: 0.5).toFloat(),
+                )
+              }
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var polylines: Array<RNPolyline> = emptyArray()
+    set(value) {
+      val prevById = field.associateBy { it.id }
+      val nextById = value.associateBy { it.id }
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        view.removePolyline(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          view.addPolyline(id, polylineOptions.buildPolylineOptions(next))
+        } else if (!prev.polylineEquals(next)) {
+          view.updatePolyline(id) { gms ->
+            onUi {
+              gms.points =
+                next.coordinates.map {
+                  com.google.android.gms.maps.model
+                    .LatLng(it.latitude, it.longitude)
+                }
+              next.width?.let { gms.width = it.dpToPx() }
+              next.lineCap?.let {
+                val cap = polylineOptions.mapLineCap(it)
+                gms.startCap = cap
+                gms.endCap = cap
+              }
+              next.lineJoin?.let { gms.jointType = polylineOptions.mapLineJoin(it) }
+              next.color?.let { gms.color = it.toColor() }
+              gms.zIndex = next.zIndex.toFloat()
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var polygons: Array<RNPolygon> = emptyArray()
+    set(value) {
+      val prevById = field.associateBy { it.id }
+      val nextById = value.associateBy { it.id }
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        view.removePolygon(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          view.addPolygon(id, polygonOptions.buildPolygonOptions(next))
+        } else if (!prev.polygonEquals(next)) {
+          view.updatePolygon(id) { gmsPoly ->
+            onUi {
+              gmsPoly.points =
+                next.coordinates.map {
+                  com.google.android.gms.maps.model
+                    .LatLng(it.latitude, it.longitude)
+                }
+              next.fillColor?.let { gmsPoly.fillColor = it.toColor() }
+              next.strokeColor?.let { gmsPoly.strokeColor = it.toColor() }
+              next.strokeWidth?.let { gmsPoly.strokeWidth = it.dpToPx() }
+              gmsPoly.zIndex = next.zIndex.toFloat()
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var onMapError: ((RNMapErrorCode) -> Unit)?
+    get() = view.onMapError
+    set(cb) {
+      view.onMapError = cb
+    }
+
+  override var onMapReady: ((Boolean) -> Unit)?
+    get() = view.onMapReady
+    set(cb) {
+      view.onMapReady = cb
+    }
+  override var onLocationUpdate: ((RNLocation) -> Unit)?
+    get() = view.onLocationUpdate
+    set(cb) {
+      view.onLocationUpdate = cb
+    }
+
+  override var onLocationError: ((RNLocationErrorCode) -> Unit)?
+    get() = view.onLocationError
+    set(cb) {
+      view.onLocationError = cb
+    }
+
+  override var onMapPress: ((RNLatLng) -> Unit)?
+    get() = view.onMapPress
+    set(cb) {
+      view.onMapPress = cb
+    }
+
+  override var onMarkerPress: ((String) -> Unit)?
+    get() = view.onMarkerPress
+    set(cb) {
+      view.onMarkerPress = cb
+    }
+
+  override var onCameraChangeStart: ((RNRegion, RNCamera, Boolean) -> Unit)?
+    get() = view.onCameraChangeStart
+    set(cb) {
+      view.onCameraChangeStart = cb
+    }
+
+  override var onCameraChange: ((RNRegion, RNCamera, Boolean) -> Unit)?
+    get() = view.onCameraChange
+    set(cb) {
+      view.onCameraChange = cb
+    }
+
+  override var onCameraChangeComplete: ((RNRegion, RNCamera, Boolean) -> Unit)?
+    get() = view.onCameraChangeComplete
+    set(cb) {
+      view.onCameraChangeComplete = cb
+    }
+
+  override fun setCamera(
+    camera: RNCamera,
+    animated: Boolean?,
+    durationMS: Double?,
+  ) {
+    view.setCamera(camera, animated == true, durationMS?.toInt() ?: 3000)
+  }
+
+  override fun setCameraToCoordinates(
+    coordinates: Array<RNLatLng>,
+    padding: RNMapPadding?,
+    animated: Boolean?,
+    durationMS: Double?,
+  ) {
+    view.setCameraToCoordinates(
+      coordinates,
+      padding = padding ?: RNMapPadding(0.0, 0.0, 0.0, 0.0),
+      animated == true,
+      durationMS?.toInt() ?: 3000,
+    )
+  }
+
+  override fun showLocationDialog() {
+    locationHandler.showLocationDialog()
+  }
+
+  override fun openLocationSettings() {
+    locationHandler.openLocationSettings()
+  }
+
+  override fun requestLocationPermission(): Promise<RNLocationPermissionResult> = permissionHandler.requestLocationPermission()
+
+  override fun isGooglePlayServicesAvailable(): Boolean = playServiceHandler.isPlayServicesAvailable()
+
+  fun userInterfaceStyleToMapColorScheme(value: RNUserInterfaceStyle): Int =
+    when (value) {
+      RNUserInterfaceStyle.LIGHT -> {
+        MapColorScheme.LIGHT
+      }
+
+      RNUserInterfaceStyle.DARK -> {
+        MapColorScheme.DARK
+      }
+
+      RNUserInterfaceStyle.DEFAULT -> {
+        MapColorScheme.FOLLOW_SYSTEM
+      }
+    }
+
+  fun mapCameraToCameraPosition(camera: RNCamera): CameraPosition {
+    val builder = CameraPosition.builder()
+    camera.center?.let {
+      builder.target(
+        com.google.android.gms.maps.model.LatLng(
+          camera.center.latitude,
+          camera.center.longitude,
+        ),
+      )
+    }
+    camera.zoom?.let { builder.zoom(it.toFloat()) }
+    camera.bearing?.let { builder.bearing(it.toFloat()) }
+    camera.tilt?.let { builder.tilt(it.toFloat()) }
+
+    return builder.build()
+  }
+
+  fun mapCameraPotionToCamera(cameraPosition: CameraPosition): RNCamera =
+    RNCamera(
+      center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
+      zoom = cameraPosition.zoom.toDouble(),
+      bearing = cameraPosition.bearing.toDouble(),
+      tilt = cameraPosition.tilt.toDouble(),
+    )
+
+  fun mapColorSchemeToUserInterfaceStyle(value: Int): RNUserInterfaceStyle =
+    when (value) {
+      MapColorScheme.LIGHT -> RNUserInterfaceStyle.LIGHT
+      MapColorScheme.DARK -> RNUserInterfaceStyle.DARK
+      else -> RNUserInterfaceStyle.DEFAULT
+    }
+}
+
+private inline fun onUi(crossinline block: () -> Unit) {
+  if (UiThreadUtil.isOnUiThread()) {
+    block()
+  } else {
+    UiThreadUtil.runOnUiThread { block() }
+  }
+}

package/android/src/main/java/com/googlemapsnitro/LocationHandler.kt

@@ -0,0 +1,205 @@
+package com.googlemapsnitro
+
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.location.Location
+import android.os.Build
+import android.os.Looper
+import android.provider.Settings
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.common.api.ApiException
+import com.google.android.gms.common.api.CommonStatusCodes
+import com.google.android.gms.common.api.ResolvableApiException
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.LocationSettingsRequest
+import com.google.android.gms.location.LocationSettingsStatusCodes
+import com.google.android.gms.location.Priority
+import com.google.android.gms.tasks.OnSuccessListener
+
+private const val REQ_LOCATION_SETTINGS = 2001
+
+class LocationHandler(
+  val context: ReactContext,
+) {
+  private val fusedLocationClientProviderClient: FusedLocationProviderClient =
+    LocationServices.getFusedLocationProviderClient(context)
+  private var locationRequest: LocationRequest? = null
+  private var locationCallback: LocationCallback? = null
+  private var priority = Priority.PRIORITY_HIGH_ACCURACY
+  private var interval: Long = 5000
+  private var minUpdateInterval: Long = 5000
+  var onUpdate: ((Location) -> Unit)? = null
+  var onError: ((RNLocationErrorCode) -> Unit)? = null
+
+  init {
+    buildLocationRequest()
+  }
+
+  fun showLocationDialog() {
+    UiThreadUtil.runOnUiThread {
+      val activity = context.currentActivity ?: run { return@runOnUiThread }
+
+      val lr =
+        if (Build.VERSION.SDK_INT >= 31) {
+          LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 10_000L).build()
+        } else {
+          @Suppress("DEPRECATION")
+          LocationRequest.create().apply { priority = Priority.PRIORITY_HIGH_ACCURACY }
+        }
+
+      val req =
+        LocationSettingsRequest
+          .Builder()
+          .addLocationRequest(lr)
+          .setAlwaysShow(true)
+          .build()
+
+      val settingsClient = LocationServices.getSettingsClient(activity)
+      settingsClient
+        .checkLocationSettings(req)
+        .addOnSuccessListener {
+        }.addOnFailureListener { ex ->
+          if (ex is ResolvableApiException) {
+            try {
+              ex.startResolutionForResult(activity, REQ_LOCATION_SETTINGS)
+            } catch (_: Exception) {
+              onError?.invoke(RNLocationErrorCode.SETTINGS_NOT_SATISFIED)
+            }
+          } else {
+            onError?.invoke(RNLocationErrorCode.SETTINGS_NOT_SATISFIED)
+            openLocationSettings()
+          }
+        }
+    }
+  }
+
+  fun openLocationSettings() {
+    UiThreadUtil.runOnUiThread {
+      val intent =
+        Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      context.currentActivity?.startActivity(intent)
+    }
+  }
+
+  @Suppress("deprecation")
+  private fun buildLocationRequest() {
+    locationRequest =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        LocationRequest
+          .Builder(priority, interval)
+          .setMinUpdateIntervalMillis(minUpdateInterval)
+          .build()
+      } else {
+        LocationRequest
+          .create()
+          .setPriority(priority)
+          .setInterval(interval)
+          .setFastestInterval(minUpdateInterval)
+      }
+    restartLocationUpdates()
+  }
+
+  fun setPriority(priority: Int) {
+    this.priority = priority
+    buildLocationRequest()
+  }
+
+  fun setInterval(interval: Int) {
+    this.interval = interval.toLong()
+    buildLocationRequest()
+  }
+
+  fun setFastestInterval(fastestInterval: Int) {
+    this.minUpdateInterval = fastestInterval.toLong()
+    buildLocationRequest()
+  }
+
+  private fun restartLocationUpdates() {
+    stop()
+    // 4) Google Play Services checken – früh zurückmelden
+    val playServicesStatus =
+      GoogleApiAvailability
+        .getInstance()
+        .isGooglePlayServicesAvailable(context)
+    if (playServicesStatus != ConnectionResult.SUCCESS) {
+      onError?.invoke(RNLocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE)
+      return
+    }
+    start()
+  }
+
+  @SuppressLint("MissingPermission")
+  fun start() {
+    try {
+      fusedLocationClientProviderClient.lastLocation
+        .addOnSuccessListener(
+          OnSuccessListener { location ->
+            if (location != null) {
+              onUpdate?.invoke(location)
+            }
+          },
+        ).addOnFailureListener { e ->
+          val error = mapThrowableToCode(e)
+          onError?.invoke(error)
+        }
+      locationCallback =
+        object : LocationCallback() {
+          override fun onLocationResult(locationResult: LocationResult) {
+            val location = locationResult.lastLocation
+            if (location != null) {
+              onUpdate?.invoke(location)
+            } else {
+              onError?.invoke(RNLocationErrorCode.POSITION_UNAVAILABLE)
+            }
+          }
+        }
+      fusedLocationClientProviderClient
+        .requestLocationUpdates(
+          locationRequest!!,
+          locationCallback!!,
+          Looper.getMainLooper(),
+        ).addOnFailureListener { e ->
+          val error = mapThrowableToCode(e)
+          onError?.invoke(error)
+        }
+    } catch (se: SecurityException) {
+      onError?.invoke(RNLocationErrorCode.PERMISSION_DENIED)
+    } catch (ex: Exception) {
+      val error = mapThrowableToCode(ex)
+      onError?.invoke(error)
+    }
+  }
+
+  private fun mapThrowableToCode(t: Throwable): RNLocationErrorCode {
+    if (t is SecurityException) return RNLocationErrorCode.PERMISSION_DENIED
+    if (t.message?.contains("GoogleApi", ignoreCase = true) == true) {
+      val gms = GoogleApiAvailability.getInstance()
+      val status = gms.isGooglePlayServicesAvailable(context)
+      if (status != ConnectionResult.SUCCESS) return RNLocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE
+    }
+    if (t is ApiException) {
+      when (t.statusCode) {
+        CommonStatusCodes.NETWORK_ERROR -> return RNLocationErrorCode.POSITION_UNAVAILABLE
+        LocationSettingsStatusCodes.RESOLUTION_REQUIRED,
+        LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE,
+        -> return RNLocationErrorCode.SETTINGS_NOT_SATISFIED
+      }
+      return RNLocationErrorCode.INTERNAL_ERROR
+    }
+    return RNLocationErrorCode.INTERNAL_ERROR
+  }
+
+  fun stop() {
+    if (locationCallback != null) {
+      fusedLocationClientProviderClient.removeLocationUpdates(locationCallback!!)
+      locationCallback = null
+    }
+  }
+}

package/android/src/main/java/com/googlemapsnitro/MapMarker.kt

@@ -0,0 +1,145 @@
+package com.googlemapsnitro
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.util.LruCache
+import androidx.core.graphics.createBitmap
+import com.caverock.androidsvg.SVG
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.google.android.gms.maps.model.BitmapDescriptor
+import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.MarkerOptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.coroutineContext
+
+class MarkerOptions(
+  private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
+) {
+  private val iconCache =
+    object : LruCache<Int, BitmapDescriptor>(512) {
+      override fun sizeOf(
+        key: Int,
+        value: BitmapDescriptor,
+      ): Int = 1
+    }
+
+  private val jobsById = mutableMapOf<String, Job>()
+
+  fun build(
+    m: RNMarker,
+    icon: BitmapDescriptor,
+  ): MarkerOptions =
+    MarkerOptions()
+      .position(LatLng(m.coordinate.latitude, m.coordinate.longitude))
+      .zIndex(m.zIndex.toFloat())
+      .icon(icon)
+      .anchor((m.anchor?.x ?: 0.5).toFloat(), (m.anchor?.y ?: 0.5).toFloat())
+
+  fun buildIconAsync(
+    id: String,
+    m: RNMarker,
+    onReady: (BitmapDescriptor) -> Unit,
+  ) {
+    jobsById[id]?.cancel()
+
+    val key = m.styleHash()
+    iconCache.get(key)?.let { cached ->
+      onReady(cached)
+      return
+    }
+
+    val job =
+      scope.launch {
+        try {
+          ensureActive()
+          val bmp = renderBitmap(m)
+          if (bmp != null) {
+            ensureActive()
+            val desc = BitmapDescriptorFactory.fromBitmap(bmp)
+            iconCache.put(key, desc)
+            bmp.recycle()
+            withContext(Dispatchers.Main) {
+              ensureActive()
+              onReady(desc)
+            }
+          }
+        } catch (_: OutOfMemoryError) {
+          iconCache.evictAll()
+        } catch (_: Throwable) {
+        } finally {
+          jobsById.remove(id)
+        }
+      }
+
+    jobsById[id] = job
+  }
+
+  fun cancelIconJob(id: String) {
+    jobsById[id]?.cancel()
+    jobsById.remove(id)
+  }
+
+  fun cancelAllJobs() {
+    val ids = jobsById.keys.toList()
+    ids.forEach { id ->
+      jobsById[id]?.cancel()
+    }
+    jobsById.clear()
+    iconCache.evictAll()
+  }
+
+  private suspend fun renderBitmap(m: RNMarker): Bitmap? {
+    var bmp: Bitmap? = null
+    try {
+      coroutineContext.ensureActive()
+      val svg = SVG.getFromString(m.iconSvg)
+
+      coroutineContext.ensureActive()
+      svg.setDocumentWidth(m.width.dpToPx())
+      svg.setDocumentHeight(m.height.dpToPx())
+
+      coroutineContext.ensureActive()
+      bmp =
+        createBitmap(m.width.dpToPx().toInt(), m.height.dpToPx().toInt(), Bitmap.Config.ARGB_8888)
+
+      coroutineContext.ensureActive()
+      val canvas = Canvas(bmp)
+      svg.renderToCanvas(canvas)
+
+      coroutineContext.ensureActive()
+      return bmp
+    } catch (t: Throwable) {
+      try {
+        bmp?.recycle()
+      } catch (_: Throwable) {
+      }
+      throw t
+    }
+  }
+}
+
+fun RNMarker.markerEquals(b: RNMarker): Boolean =
+  id == b.id &&
+    zIndex == b.zIndex &&
+    coordinate == b.coordinate &&
+    anchor == b.anchor &&
+    markerStyleEquals(b)
+
+fun RNMarker.markerStyleEquals(b: RNMarker): Boolean =
+  width == b.width &&
+    height == b.height &&
+    iconSvg == b.iconSvg
+
+fun RNMarker.styleHash(): Int =
+  arrayOf<Any?>(
+    width,
+    height,
+    iconSvg,
+  ).contentHashCode()