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

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

@@ -0,0 +1,36 @@
+package com.googlemapsnitro
+
+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()) }
+      zIndex(poly.zIndex.toFloat())
+    }
+}
+
+fun RNPolygon.polygonEquals(b: RNPolygon): Boolean {
+  if (zIndex != b.zIndex) 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/googlemapsnitro/MapPolyline.kt

@@ -0,0 +1,59 @@
+package com.googlemapsnitro
+
+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()) }
+      zIndex(pl.zIndex.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 ((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/googlemapsnitro/PermissionHandler.kt

@@ -0,0 +1,116 @@
+package com.googlemapsnitro
+
+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/googlemapsnitro/PlayServicesHandler.kt

@@ -0,0 +1,25 @@
+package com.googlemapsnitro
+
+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/ios/Color.swift

@@ -0,0 +1,109 @@
+extension String {
+  func toUIColor(default defaultColor: UIColor = .clear) -> UIColor {
+    return UIColor.fromCssString(self) ?? defaultColor
+  }
+}
+
+extension UIColor {
+  static func fromCssString(_ s: String) -> UIColor? {
+    let str = s.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    if str.hasPrefix("#") { return Self.fromHex(str) }
+    if str.hasPrefix("rgb") { return Self.fromRGBFunction(str) }
+    if str.hasPrefix("hsl") { return Self.fromHSLFunction(str) }
+    if let named = namedColors[str] { return named }
+    return nil
+  }
+
+  private static let namedColors: [String: UIColor] = [
+    "red": .red, "green": .green, "blue": .blue,
+    "black": .black, "white": .white, "gray": .gray, "grey": .gray,
+    "yellow": .yellow, "orange": .orange, "purple": .purple,
+    "cyan": .cyan, "aqua": .cyan, "magenta": .magenta, "fuchsia": .magenta,
+    "brown": .brown, "clear": .clear, "transparent": .clear
+  ]
+
+  private static func fromHex(_ hex: String) -> UIColor? {
+    var sanitized = hex.replacingOccurrences(of: "#", with: "")
+    if sanitized.count == 3 || sanitized.count == 4 {
+      sanitized = sanitized.map { "\($0)\($0)" }.joined()
+    }
+    if sanitized.count == 6 { sanitized += "ff" }
+    guard sanitized.count == 8, let rgba = UInt32(sanitized, radix: 16) else {
+      return nil
+    }
+    let r = CGFloat((rgba & 0xff00_0000) >> 24) / 255.0
+    let g = CGFloat((rgba & 0x00ff_0000) >> 16) / 255.0
+    let b = CGFloat((rgba & 0x0000_ff00) >> 8) / 255.0
+    let a = CGFloat(rgba & 0x0000_00ff) / 255.0
+    return UIColor(red: r, green: g, blue: b, alpha: a)
+  }
+
+  private static func fromRGBFunction(_ s: String) -> UIColor? {
+    let nums =
+      s
+      .replacingOccurrences(of: "rgba", with: "")
+      .replacingOccurrences(of: "rgb", with: "")
+      .replacingOccurrences(of: "(", with: "")
+      .replacingOccurrences(of: ")", with: "")
+      .split(separator: ",")
+      .map { $0.trimmingCharacters(in: .whitespaces) }
+
+    guard nums.count == 3 || nums.count == 4,
+      let r = Double(nums[0]),
+      let g = Double(nums[1]),
+      let b = Double(nums[2])
+    else { return nil }
+    let a = (nums.count == 4) ? (Double(nums[3]) ?? 1.0) : 1.0
+    return UIColor(
+      red: CGFloat(r / 255.0),
+      green: CGFloat(g / 255.0),
+      blue: CGFloat(b / 255.0),
+      alpha: CGFloat(a)
+    )
+  }
+
+  private static func fromHSLFunction(_ s: String) -> UIColor? {
+    let parts =
+      s
+      .replacingOccurrences(of: "hsla", with: "")
+      .replacingOccurrences(of: "hsl", with: "")
+      .replacingOccurrences(of: "(", with: "")
+      .replacingOccurrences(of: ")", with: "")
+      .replacingOccurrences(of: "%", with: "")
+      .split(separator: ",")
+      .map { $0.trimmingCharacters(in: .whitespaces) }
+
+    guard parts.count == 3 || parts.count == 4,
+      let h = Double(parts[0]),
+      let sPerc = Double(parts[1]),
+      let lPerc = Double(parts[2])
+    else { return nil }
+
+    let a = (parts.count == 4) ? (Double(parts[3]) ?? 1.0) : 1.0
+    let s = sPerc / 100.0
+    let l = lPerc / 100.0
+
+    let c = (1 - Swift.abs(2 * l - 1)) * s
+    let x = c * (1 - Swift.abs((h / 60).truncatingRemainder(dividingBy: 2) - 1))
+    let m = l - c / 2
+
+// swiftlint:disable:next large_tuple
+    let (r1, g1, b1): (Double, Double, Double)
+    switch h {
+    case 0..<60: (r1, g1, b1) = (c, x, 0)
+    case 60..<120: (r1, g1, b1) = (x, c, 0)
+    case 120..<180: (r1, g1, b1) = (0, c, x)
+    case 180..<240: (r1, g1, b1) = (0, x, c)
+    case 240..<300: (r1, g1, b1) = (x, 0, c)
+    case 300..<360: (r1, g1, b1) = (c, 0, x)
+    default: (r1, g1, b1) = (0, 0, 0)
+    }
+    return UIColor(
+      red: CGFloat(r1 + m),
+      green: CGFloat(g1 + m),
+      blue: CGFloat(b1 + m),
+      alpha: CGFloat(a)
+    )
+  }
+
+}