在Firebase数据库中通过Realtime lat＆lang更改标记位置，而不添加新的标记

Question

我的实时Firebase数据库

我尝试在某些时候像超级汽车那样改变许多拉特朗姆的位置，但是当我改变拉特或郎或两者时，这不会改变标记的位置，但它会重新标记。我希望当lat在实时数据库中更改时，标记也会根据该lat的值进行更改

我试着创造条件

`if (marker != null) 
    setPosition 
 else "marker == null"` 
    add new marker 

但问题是我有> 1个标记，因此这个解决方案只在地图上显示一个标记因为标记！= null

public class Map extends FragmentActivity implements OnMapReadyCallback {
FirebaseDatabase database;
DatabaseReference myRef;
GoogleMap mMap;
MarkerOptions options;
Marker mCurrLocationMarker;
LatLng ll;
model save;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_map);
    // Obtain the SupportMapFragment and get notified when the map is ready to be used.
    SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
            .findFragmentById(R.id.map);
    mapFragment.getMapAsync(this);
}

  @Override
public void onMapReady(GoogleMap googleMap) {
    mMap = googleMap;

    database = FirebaseDatabase.getInstance();
    myRef = database.getReference("user");

    myRef.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            for (DataSnapshot ds : dataSnapshot.getChildren()) {

                Double lang = ds.child("lang").getValue(Double.class);
                Double lat = ds.child("lat").getValue(Double.class);
                save = new model(lat, lang);
                ll = new LatLng(save.getLat(), save.getLang());

                mCurrLocationMarker = mMap.addMarker(options
                        .position(ll));

            }

        }

        @Override
        public void onCancelled(DatabaseError databaseError) {

        }
    });
}

我预计当我在firebase中更改实时lat和lang时，标记的位置会发生变化，但结果会创建另一个标记。

Answer 1

根据我对其他答案的评论，以下是我根据您的问题提出的问题。

此代码将在地图上显示多个标记，但在数据库中/users下的每个ID只有一个标记。如果特定ID的位置发生更改，则会移动相关标记，而不会影响地图上的其他标记。

警告：以下代码将实时更新您的地图。您可以缓存新标记位置，每隔2-5秒左右更新一次，具体取决于数据更改的频率。

在深入研究代码之前的一些快速说明：

• 每个标记都链接到数据库中名为mNamedMarkers的Map下的字符串ID。
• 由于没有提供model并且似乎无关紧要，我从下面的代码中省略了它。
• 我不确定你是否来自日耳曼背景，但lng是经度的缩写，而不是在这种情况下“lang”。我还会更改您的数据库条目以使用lng而不是lang / long / longitude / etc（它可以节省空间并消除混淆）。
• 在下面的代码中，我添加了getMarkerOptions(key)，这样您就可以添加代码，根据它的ID为每个标记获取不同的图像，标题和文本。目前，它将为每个标记生成相同的数据。
• 我为每个函数添加了Javadoc标记，以总结每个函数的作用。
• 有几个TODO需要进一步开发。

这是代码：

public class Map extends FragmentActivity implements OnMapReadyCallback {
    FirebaseDatabase database;
    DatabaseReference userLocationsRef;
    GoogleMap mMap;

    Map<String, Marker> mNamedMarkers = new HashMap<String,Marker>();

    ChildEventListener markerUpdateListener = new ChildEventListener() {

            /**
             * Adds each existing/new location of a marker.
             *
             * Will silently update any existing markers as needed.
             * @param dataSnapshot  The new location data
             * @param previousChildName  The key of the previous child event
             */
            @Override
            public void onChildAdded(DataSnapshot dataSnapshot, String previousChildName) {
                    String key = dataSnapshot.getKey();
                    Log.d(TAG, "Adding location for '" + key + "'");

                    Double lng = ds.child("lang").getValue(Double.class);
                    Double lat = ds.child("lat").getValue(Double.class);
                    LatLng location = new LatLng(lat, lng);

                    Marker marker = mNamedMarkers.get(key);

                    if (marker == null) {
                        MarkerOptions options = getMarkerOptions(key);
                        marker = mMap.addMarker(options.position(location));
                        mNamedMarkers.put(key, marker);
                    } else {
                        // This marker-already-exists section should never be called in this listener's normal use, but is here to handle edge cases quietly.
                        // TODO: Confirm if marker title/snippet needs updating.
                        marker.setPosition(location);
                    }
            }

            /**
             * Updates the location of a previously loaded marker.
             *
             * Will silently create any missing markers as needed.
             * @param dataSnapshot  The new location data
             * @param previousChildName  The key of the previous child event
             */
            @Override
            public void onChildChanged(DataSnapshot dataSnapshot, String previousChildName) {
                    String key = dataSnapshot.getKey();
                    Log.d(TAG, "Location for '" + key + "' was updated.");

                    Double lng = ds.child("lang").getValue(Double.class);
                    Double lat = ds.child("lat").getValue(Double.class);
                    LatLng location = new LatLng(lat, lng);

                    Marker marker = mNamedMarkers.get(key);

                    if (marker == null) {
                        // This null-handling section should never be called in this listener's normal use, but is here to handle edge cases quietly.
                        Log.d(TAG, "Expected existing marker for '" + key + "', but one was not found. Added now.");
                        MarkerOptions options = getMarkerOptions(key); // TODO: Read data from database for this marker (e.g. Name, Driver, Vehicle type)
                        marker = mMap.addMarker(options.position(location));
                        mNamedMarkers.put(key, marker);
                    } else {
                        // TODO: Confirm if marker title/snippet needs updating.
                        marker.setPosition(location);
                    }
            }

            /**
             * Removes the marker from its GoogleMap instance
             * @param dataSnapshot  The removed data
             */
            @Override
            public void onChildRemoved(DataSnapshot dataSnapshot) {
                    String key = dataSnapshot.getKey();
                    Log.d(TAG, "Location for '" + key + "' was removed.");

                    Marker marker = mNamedMarkers.get(key);
                    if (marker != null)
                        marker.remove()
            }

            /**
             * Ignored.
             * @param dataSnapshot  The moved data
             * @param previousChildName  The key of the previous child event
             */
            @Override
            public void onChildMoved(DataSnapshot dataSnapshot, String previousChildName) {
                    // Unused
                    Log.d(TAG, "Priority for '" + dataSnapshot.getKey() "' was changed.");
            }

            /**
             * Error handler when listener is canceled.
             * @param databaseError  The error object
             */
            @Override
            public void onCancelled(DatabaseError databaseError) {
                    Log.w(TAG, "markerUpdateListener:onCancelled", databaseError.toException());
                    Toast.makeText(mContext, "Failed to load location markers.", Toast.LENGTH_SHORT).show();
            }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_map);
            // Obtain the SupportMapFragment and get notified when the map is ready to be used.
            SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                            .findFragmentById(R.id.map);
            mapFragment.getMapAsync(this);
    }

    /**
     * Waits for the map to be ready then loads markers from the database.
     * @param googleMap  The GoogleMap instance
     */
    @Override
    public void onMapReady(GoogleMap googleMap) {
            mMap = googleMap;

            database = FirebaseDatabase.getInstance();
            userLocationsRef = database.getReference("user");

            userLocationsRef.addChildEventListener(markerUpdateListener);



            // later when the activity becomes inactive.
            // userLocationsRef.removeEventListener(markerUpdateListener)
    }

    /**
     * Retrieves the marker data for the given key.
     * @param key  The ID of the marker
     * @return A MarkerOptions instance containing this marker's infoormation
     */
    private MarkerOptions getMarkerOptions(String key) {
        // TODO: Read data from database for the given marker (e.g. Name, Driver, Vehicle type)
        return new MarkerOptions().title('Location placeholder').snippet('Update this with marker information');
    } 
}

Answer 2

试试这个。

并且您必须实现OnMapReadyCallback

@Override
public void onMapReady(GoogleMap googleMap) {
    mMap = googleMap;

}

并且mMap使私有或公共变量。

在调用循环方法之前

插入以下代码

mMap.clear();

你对addValueEventListener使用了错误的方法。

您可以在onCreate方法中提交addValueEventlistener，并且还需要在调用之前检查null。

在OnMapReadyCallback方法中，只能绑定mMap变量。

Answer 3

请使用以下Kotlin代码查看完整的标记，动画和像优步一样移动的跟踪：

最初添加你的firebase监听器

mFirebaseRef?.child(mDriverId)!!.addChildEventListener(listener);

定义您的firebase侦听器

 var listener = object : ChildEventListener {
    override fun onCancelled(p0: DatabaseError) {
        Log.e("onCancelled", " " + p0.message)
    }

    override fun onChildMoved(p0: DataSnapshot, p1: String?) {
        Log.e("onChildMoved", " " + p0.key)
    }

    override fun onChildChanged(dataSnapshot: DataSnapshot, p1: String?) {
        Log.e("onChildChanged", " " + dataSnapshot.key)

      //Write your database reference login for getting Lat Lng

        if (dataSnapshot.key.equals("l")) {
            val latLatLng = dataSnapshot.value as ArrayList<Any>?
            if (latLatLng!!.size == 2) {
                displayLocation(latLatLng) 
            }
        }
    }

    override fun onChildAdded(p0: DataSnapshot, p1: String?) {
        Log.e("onChildAdded", " " + p0.key)
    }

    override fun onChildRemoved(p0: DataSnapshot) {
        Log.e("onChildRemoved", " " + p0.key)
    }
}

第一次使用开始缩放添加和更新标记

private fun displayLocation(latLatLng: ArrayList<Any>) {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this,
                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
                REQUEST_LOCATION)
    } else {
        mLastLocation = Location(LocationManager.GPS_PROVIDER)
        mLastLocation!!.latitude = latLatLng[0] as Double;
        mLastLocation!!.longitude = latLatLng[1] as Double;
        val latitude = latLatLng[0]!!
        val longitude = latLatLng[1]!!

        addMarker(mMap, latitude as Double, longitude as Double)

        if (isFirstTime) {
            isFirstTime = false
            try {

                var pickUPLatLng: LatLng = LatLng(pick_lat.toDouble(), pick_long.toDouble())
                var deliveryLatLng: LatLng = LatLng(drop_lat.toDouble(), drop_long.toDouble())

                var latLngBounds: LatLngBounds = LatLngBounds.Builder()
                        .include(pickUPLatLng)
                        .include(deliveryLatLng)
                        .include(LatLng(latitude as Double, longitude as Double))
                        .build()
                lstLatLngRoute.clear()
                try {
                    mLastLocation = Location(LocationManager.GPS_PROVIDER)
                    mLastLocation!!.longitude = longitude as Double
                    mLastLocation!!.latitude = latitude as Double
                    lstLatLngRoute.add(LatLng(mLastLocation!!.latitude, mLastLocation!!.longitude))
                } catch (e: Exception) {
                    e.printStackTrace()
                }
                lstLatLngRoute.add(pickUPLatLng)
                lstLatLngRoute.add(deliveryLatLng)
                zoomRoute(mMap!!, lstLatLngRoute)
                //mMap!!.moveCamera(CameraUpdateFactory.newLatLngBounds(latLngBounds, 250))
                //mMap!!.animateCamera(CameraUpdateFactory.newLatLngZoom(LatLng(latitude as Double, longitude as Double), 14f))
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }

    }
}

现在添加标记（如果尚未添加到Google地图上）或使用前一次

private var markerCount: Int = 0
private var marker: Marker? = null;
private var mLastLocation: Location? = null

fun addMarker(googleMap: GoogleMap?, lat: Double, lon: Double) {

    if (markerCount == 1) {

        try {
            try {
                animateMarker(marker!!, LatLng(mLastLocation!!.latitude, mLastLocation!!.longitude))
             } catch (e: Exception) {
            }

        } catch (e: Exception) {
            e.printStackTrace()
        }

    } else if (markerCount == 0) {

        var pickUpBmp: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.carbike)
        mMap = googleMap
        val latlong = LatLng(lat, lon)
        marker = mMap!!.addMarker(MarkerOptions().position(LatLng(lat, lon))
                .icon(BitmapDescriptorFactory.fromBitmap(pickUpBmp))
                .anchor(0.5f, 0.5f)
                .flat(false))
        mMap!!.moveCamera(CameraUpdateFactory.newLatLngZoom(latlong, MAP_ZOOM_LEVEL))

        markerCount = 1

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return
        }
    }
}

最后，使用以下方法为标记设置动画：

fun animateMarker( marker: Marker,toPosition: LatLng) {
    val handler = Handler()
    val start = SystemClock.uptimeMillis()
    val proj = mMap!!.getProjection()
    val startPoint = proj.toScreenLocation(marker.getPosition())
    val startLatLng = proj.fromScreenLocation(startPoint)
    val duration: Long = 3000

    val interpolator = LinearInterpolator()

    handler.post(object : Runnable {
        override fun run() {
            val elapsed = SystemClock.uptimeMillis() - start
            val t = interpolator.getInterpolation(elapsed.toFloat() / duration)
            val lng = t * toPosition.longitude + (1 - t) * startLatLng.longitude
            val lat = t * toPosition.latitude + (1 - t) * startLatLng.latitude
            marker.position = LatLng(lat, lng)
            marker.rotation = (getBearingBetweenTwoPoints1(startLatLng, toPosition).toString().toFloat())

            runOnUiThread(Runnable {
                mMap!!.moveCamera(CameraUpdateFactory
                        .newCameraPosition(CameraPosition.Builder()
                                .target(toPosition)
                                .zoom(MAP_ZOOM_LEVEL)
                                .build()))
            })

            if (t < 1.0) {
                handler.postDelayed(this, 16)
            }
        }
    })
}

使用以下方法进行标记的轴承或头部计算

 private fun getBearingBetweenTwoPoints1(latLng1: LatLng, latLng2: LatLng): Double {

    val lat1 = degreesToRadians(latLng1.latitude)
    val long1 = degreesToRadians(latLng1.longitude)
    val lat2 = degreesToRadians(latLng2.latitude)
    val long2 = degreesToRadians(latLng2.longitude)

    val dLon = long2 - long1
    val y = Math.sin(dLon) * Math.cos(lat2)
    val x = Math.cos(lat1) * Math.sin(lat2) - (Math.sin(lat1)
            * Math.cos(lat2) * Math.cos(dLon))

    val radiansBearing = Math.atan2(y, x)
    return radiansToDegrees(radiansBearing)
}

private fun degreesToRadians(degrees: Double): Double {
    return degrees * Math.PI / 180.0
}

private fun radiansToDegrees(radians: Double): Double {
    return radians * 180.0 / Math.PI
}

我希望这对你有帮助，如果你熟悉Kotlin :)

@mohamedgaber不需要混淆，只需像这样更新你的听众，它将适用于多个孩子（标记）而不是单个标记（确保你的标记不同）。只需在Koltin中转换这个监听器并使用我给出的其他代码，我保证它会像Uber一样顺利运行。

 myRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        for (DataSnapshot ds : dataSnapshot.getChildren()) {

            Double lang = ds.child("lang").getValue(Double.class);
            Double lat = ds.child("lat").getValue(Double.class);
            save = new model(lat, lang);
            ll = new LatLng(save.getLat(), save.getLang());

            displayLocation(ll) 

       }
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {

    }
});