Android应用：Google Map地点存储至实时云数据库及地理围栏查询求助

Hey there! Let's break down your requirements and walk through the best tools and approaches to build this Android app with Google Maps integration, cloud storage for locations, and geofencing capabilities.

Here are the top real-time cloud databases that play well with geospatial data and your use case:

• Firebase Firestore (or Realtime Database)

  • This is hands-down one of the best picks for real-time sync scenarios. It natively supports live data updates, so clients automatically get notified when new locations are added.
  • Firestore has a built-in GeoPoint type for storing coordinates, and supports distance-based queries when paired with geospatial indexes. Integrating it with Google Maps on Android is super smooth—you can directly convert LatLng objects from Maps to GeoPoint for storage.
  • Perfect if you want a low-fuss, fully managed solution with minimal setup.

• MongoDB Atlas

  • MongoDB offers robust geospatial support via 2dsphere indexes, which lets you run complex queries like polygon fence filters or circular range searches.
  • With MongoDB Realm, you get real-time sync functionality—clients can subscribe to location updates in specific geofences and get instant notifications when new spots are added.
  • Great for projects that need flexible data structures and custom query logic.

• Supabase

  • Built on PostgreSQL, which has the powerful PostGIS extension for advanced geospatial operations. You can run all sorts of geofence queries directly on the database.
  • It provides real-time subscriptions, so clients can listen for changes in a specific geographic area. When a new location is added to the fence, all subscribed users get the update immediately.
  • Open-source and cost-effective, ideal for small to mid-sized projects.

• AWS DynamoDB + DynamoDB Streams + Lambda

  • If you're already working within the AWS ecosystem, DynamoDB can be paired with Streams to push real-time updates. You can use Lambda functions to handle geofence logic (like checking if a new location falls within a fence).
  • While DynamoDB doesn't have native geospatial queries, you can work around this by storing coordinate hashes or integrating with AWS Location Service for more advanced geofence operations.

Let's walk through the key steps to store locations and run geofence queries:

1. Storing Google Map/User-Defined Locations #

No matter which database you choose, the core workflow is similar:

• Grab the latitude/longitude from Google Maps (e.g., from a user's long-press on the map, or a Place API result).
• Convert the LatLng to your database's supported geospatial format:
  • Firestore: GeoPoint(lat, lng)
  • MongoDB: { type: "Point", coordinates: [lng, lat] } (note: MongoDB uses [lng, lat] order)
  • Supabase/PostgreSQL: ST_SetSRID(ST_MakePoint(lng, lat), 4326)
• Critical step: Create a geospatial index on your location field. Without this, geofence queries will be painfully slow as your dataset grows.
• Store additional metadata (like location name, description, creator ID) to make your app's UI useful.

2. Implementing Geofence Queries #

Geofences typically come in two flavors: circular (e.g., 5km around the user's current location) and polygonal (custom-shaped areas). Here's how to handle both with popular databases:

Example 1: Circular Fence Query with Firebase Firestore #

Suppose you have a user_locations collection with a location field of type GeoPoint. To find all locations within 5km of the user's current position:

// Convert user's current LatLng to Firestore GeoPoint
val currentGeoPoint = GeoPoint(currentLatLng.latitude, currentLatLng.longitude)
// Approximate conversion: 1 degree ≈ 111 km, so 5km = ~0.045 degrees
val radiusInDegrees = 5.0 / 111.0

// First, narrow down to a bounding box to reduce results
db.collection("user_locations")
    .whereGreaterThanOrEqualTo("location.latitude", currentGeoPoint.latitude - radiusInDegrees)
    .whereLessThanOrEqualTo("location.latitude", currentGeoPoint.latitude + radiusInDegrees)
    .whereGreaterThanOrEqualTo("location.longitude", currentGeoPoint.longitude - radiusInDegrees)
    .whereLessThanOrEqualTo("location.longitude", currentGeoPoint.longitude + radiusInDegrees)
    .get()
    .addOnSuccessListener { documents ->
        val nearbyLocations = mutableListOf<LocationModel>()
        // Filter by actual distance to exclude corner points in the bounding box
        for (doc in documents) {
            val location = doc.getGeoPoint("location")!!
            val distance = calculateDistance(
                currentLatLng,
                LatLng(location.latitude, location.longitude)
            )
            if (distance <= 5000) { // 5000 meters = 5km
                nearbyLocations.add(doc.toObject(LocationModel::class.java))
            }
        }
        // Update your UI with the nearby locations
    }

For real-time updates, swap the get() call with a addSnapshotListener—this will automatically refresh your list whenever a new location enters the fence.

Example 2: Polygonal Fence Query with MongoDB Atlas #

If you need to query against a custom-shaped polygon fence, use MongoDB's $geoWithin operator with a 2dsphere index:

// Example backend query (can also run client-side via MongoDB Realm)
db.locations.find({
  location: {
    $geoWithin: {
      $geometry: {
        type: "Polygon",
        coordinates: [
          [
            [lng1, lat1], [lng2, lat2], [lng3, lat3], [lng4, lat4], [lng1, lat1]
          ]
        ]
      }
    }
  }
})

Use MongoDB Realm's real-time subscriptions to listen for changes to this query—any new location added to the polygon will trigger an update to all subscribed clients.

3. Real-Time Sync for Fence Users #

To make sure all users in a geofence see new locations instantly:

• Use your database's real-time subscription feature:
  • Firestore: addSnapshotListener
  • MongoDB Realm: subscribeToQuery
  • Supabase: channel().onPostgresChanges(event: "*", schema: "public", table: "locations", callback: ...)
• For location-based triggers (e.g., notify users when they enter a fence), combine this with Android's native GeofencingClient. When the user enters a fence, trigger a real-time subscription to fetch the latest locations in that area.

内容的提问来源于stack exchange，提问作者Vikas Pandey