react-native-google-maps-plus 0.1.0 → 1.0.0-dev.2

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

@@ -0,0 +1,205 @@
+package com.rngooglemapsplus
+
+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/rngooglemapsplus/MapCircle.kt

@@ -0,0 +1,29 @@
+package com.rngooglemapsplus
+
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.google.android.gms.maps.model.CircleOptions
+import com.google.android.gms.maps.model.LatLng
+
+class MapCircleOptions {
+  fun buildCircleOptions(circle: RNCircle): CircleOptions =
+    CircleOptions().apply {
+      center(LatLng(circle.center.latitude, circle.center.longitude))
+      circle.radius?.let { radius(it) }
+      circle.strokeWidth?.let { strokeWidth(it.dpToPx()) }
+      circle.strokeColor?.let { strokeColor(it.toColor()) }
+      circle.fillColor?.let { fillColor(it.toColor()) }
+      circle.pressable?.let { clickable(it) }
+      circle.zIndex?.let { zIndex(it.toFloat()) }
+    }
+}
+
+fun RNCircle.circleEquals(b: RNCircle): Boolean {
+  if (zIndex != b.zIndex) return false
+  if (pressable != b.pressable) return false
+  if (center != b.center) return false
+  if (radius != b.radius) return false
+  if (strokeWidth != b.strokeWidth) return false
+  if (strokeColor != b.strokeColor) return false
+  if (fillColor != b.fillColor) return false
+  return true
+}

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

@@ -0,0 +1,146 @@
+package com.rngooglemapsplus
+
+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().apply {
+      position(LatLng(m.coordinate.latitude, m.coordinate.longitude))
+      anchor((m.anchor?.x ?: 0.5).toFloat(), (m.anchor?.y ?: 0.5).toFloat())
+      icon(icon)
+      m.zIndex?.let { zIndex(it.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()

package/android/src/main/java/com/rngooglemapsplus/MapPolygon.kt

@@ -0,0 +1,38 @@
+package com.rngooglemapsplus
+
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.google.android.gms.maps.model.PolygonOptions
+
+class MapPolygonOptions {
+  fun buildPolygonOptions(poly: RNPolygon): PolygonOptions =
+    PolygonOptions().apply {
+      poly.coordinates.forEach { pt ->
+        add(
+          com.google.android.gms.maps.model
+            .LatLng(pt.latitude, pt.longitude),
+        )
+      }
+      poly.fillColor?.let { fillColor(it.toColor()) }
+      poly.strokeColor?.let { strokeColor(it.toColor()) }
+      poly.strokeWidth?.let { strokeWidth(it.dpToPx()) }
+      poly.pressable?.let { clickable(it) }
+      poly.zIndex?.let { zIndex(it.toFloat()) }
+    }
+}
+
+fun RNPolygon.polygonEquals(b: RNPolygon): Boolean {
+  if (zIndex != b.zIndex) return false
+  if (pressable != b.pressable) return false
+  if (strokeWidth != b.strokeWidth) return false
+  if (fillColor != b.fillColor) return false
+  if (strokeColor != b.strokeColor) return false
+  val ac = coordinates
+  val bc = b.coordinates
+  if (ac.size != bc.size) return false
+  for (i in ac.indices) {
+    val p = ac[i]
+    val q = bc[i]
+    if (p.latitude != q.latitude || p.longitude != q.longitude) return false
+  }
+  return true
+}

package/android/src/main/java/com/rngooglemapsplus/MapPolyline.kt

@@ -0,0 +1,61 @@
+package com.rngooglemapsplus
+
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.google.android.gms.maps.model.ButtCap
+import com.google.android.gms.maps.model.Cap
+import com.google.android.gms.maps.model.JointType
+import com.google.android.gms.maps.model.PolylineOptions
+import com.google.android.gms.maps.model.RoundCap
+import com.google.android.gms.maps.model.SquareCap
+
+class MapPolylineOptions {
+  fun buildPolylineOptions(pl: RNPolyline): PolylineOptions =
+    PolylineOptions().apply {
+      pl.coordinates.forEach { pt ->
+        add(
+          com.google.android.gms.maps.model
+            .LatLng(pt.latitude, pt.longitude),
+        )
+      }
+      pl.width?.let { width(it.dpToPx()) }
+      pl.lineCap?.let { startCap(mapLineCap(it)) }
+      pl.lineCap?.let { endCap(mapLineCap(it)) }
+      pl.lineJoin?.let { jointType(mapLineJoin(it)) }
+      pl.color?.let { color(it.toColor()) }
+      pl.pressable?.let { clickable(it) }
+      pl.zIndex?.let { zIndex(it.toFloat()) }
+    }
+
+  fun mapLineCap(type: RNLineCapType?): Cap =
+    when (type) {
+      RNLineCapType.ROUND -> RoundCap()
+      RNLineCapType.SQUARE -> SquareCap()
+      else -> ButtCap()
+    }
+
+  fun mapLineJoin(type: RNLineJoinType?): Int =
+    when (type) {
+      RNLineJoinType.ROUND -> JointType.ROUND
+      RNLineJoinType.BEVEL -> JointType.BEVEL
+      RNLineJoinType.MITER -> JointType.DEFAULT
+      null -> JointType.DEFAULT
+    }
+}
+
+fun RNPolyline.polylineEquals(b: RNPolyline): Boolean {
+  if (zIndex != b.zIndex) return false
+  if (pressable != b.pressable) return false
+  if ((width ?: 0.0) != (b.width ?: 0.0)) return false
+  if (lineCap != b.lineCap) return false
+  if (lineJoin != b.lineJoin) return false
+  if (color != b.color) return false
+  val ac = coordinates
+  val bc = b.coordinates
+  if (ac.size != bc.size) return false
+  for (i in ac.indices) {
+    val p = ac[i]
+    val q = bc[i]
+    if (p.latitude != q.latitude || p.longitude != q.longitude) return false
+  }
+  return true
+}

package/android/src/main/java/com/rngooglemapsplus/PermissionHandler.kt

@@ -0,0 +1,116 @@
+package com.rngooglemapsplus
+
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.margelo.nitro.core.Promise
+
+private const val REQ_LOCATION = 1001
+
+class PermissionHandler(
+  private val context: ReactContext,
+) {
+  fun requestLocationPermission(): Promise<RNLocationPermissionResult> {
+    val promise = Promise<RNLocationPermissionResult>()
+
+    val perms =
+      arrayOf(
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+        Manifest.permission.ACCESS_FINE_LOCATION,
+      )
+
+    val alreadyGranted =
+      ContextCompat.checkSelfPermission(
+        context,
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+      ) == PackageManager.PERMISSION_GRANTED
+    if (alreadyGranted) {
+      promise.resolve(RNLocationPermissionResult(RNAndroidLocationPermissionResult.GRANTED, null))
+      return promise
+    }
+
+    UiThreadUtil.runOnUiThread {
+      val hostActivity = context.currentActivity
+      if (hostActivity !is PermissionAwareActivity) {
+        promise.resolve(RNLocationPermissionResult(RNAndroidLocationPermissionResult.DENIED, null))
+        return@runOnUiThread
+      }
+
+      hostActivity.requestPermissions(
+        perms,
+        REQ_LOCATION,
+        object : PermissionListener {
+          override fun onRequestPermissionsResult(
+            requestCode: Int,
+            permissions: Array<String>,
+            grantResults: IntArray,
+          ): Boolean {
+            if (requestCode != REQ_LOCATION) return false
+
+            var coarseGranted = false
+            var fineGranted = false
+
+            for (i in permissions.indices) {
+              val p = permissions[i]
+              val r = grantResults.getOrNull(i) ?: continue
+              if (p == Manifest.permission.ACCESS_COARSE_LOCATION && r == PackageManager.PERMISSION_GRANTED) {
+                coarseGranted = true
+              }
+              if (p == Manifest.permission.ACCESS_FINE_LOCATION && r == PackageManager.PERMISSION_GRANTED) {
+                fineGranted = true
+              }
+            }
+
+            val hostActivity =
+              context.currentActivity ?: run {
+                promise.resolve(
+                  RNLocationPermissionResult(
+                    RNAndroidLocationPermissionResult.DENIED,
+                    null,
+                  ),
+                )
+                return true
+              }
+
+            val granted = coarseGranted || fineGranted
+            if (granted) {
+              promise.resolve(
+                RNLocationPermissionResult(
+                  RNAndroidLocationPermissionResult.GRANTED,
+                  null,
+                ),
+              )
+            } else {
+              val neverAskAgain =
+                !hostActivity.shouldShowRequestPermissionRationale(Manifest.permission.ACCESS_COARSE_LOCATION)
+
+              if (neverAskAgain) {
+                promise.resolve(
+                  RNLocationPermissionResult(
+                    RNAndroidLocationPermissionResult.NEVER_ASK_AGAIN,
+                    null,
+                  ),
+                )
+              } else {
+                promise.resolve(
+                  RNLocationPermissionResult(
+                    RNAndroidLocationPermissionResult.DENIED,
+                    null,
+                  ),
+                )
+              }
+            }
+
+            return true
+          }
+        },
+      )
+    }
+
+    return promise
+  }
+}

package/android/src/main/java/com/rngooglemapsplus/PlayServicesHandler.kt

@@ -0,0 +1,25 @@
+package com.rngooglemapsplus
+
+import com.facebook.react.bridge.ReactContext
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+
+class PlayServicesHandler(
+  val context: ReactContext,
+) {
+  fun playServicesAvailability(): Int {
+    val availability = GoogleApiAvailability.getInstance()
+    return availability.isGooglePlayServicesAvailable(context)
+  }
+
+  fun isPlayServicesAvailable(): Boolean {
+    val availability = playServicesAvailability()
+    return when (availability) {
+      ConnectionResult.SERVICE_MISSING,
+      ConnectionResult.SERVICE_INVALID,
+      -> false
+
+      else -> true
+    }
+  }
+}

package/android/src/main/java/com/rngooglemapsplus/RNGoogleMapsPlusModule.kt

@@ -0,0 +1,22 @@
+package com.rngooglemapsplus
+
+import com.margelo.nitro.core.Promise
+
+class RNGoogleMapsPlusModule : HybridRNGoogleMapsPlusModuleSpec() {
+  val context = RNGoogleMapsPlusPackage.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/rngooglemapsplus/RNGoogleMapsPlusPackage.kt

@@ -0,0 +1,35 @@
+package com.rngooglemapsplus
+
+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.rngooglemapsplus.RNGoogleMapsPlusPackage.AppContextHolder.context
+import com.rngooglemapsplus.views.HybridRNGoogleMapsPlusViewManager
+
+class RNGoogleMapsPlusPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    context = reactContext
+    return listOf(
+      HybridRNGoogleMapsPlusViewManager(),
+    )
+  }
+
+  object AppContextHolder {
+    lateinit var context: ReactApplicationContext
+  }
+
+  companion object {
+    init {
+      RNGoogleMapsPlusOnLoad.initializeNative()
+    }
+  }
+}