Changer la position du marqueur par lat et lang en temps réel dans la base de données Firebase sans ajouter de nouveau marqueur

Essayez ceci.

Et vous devez implémenter OnMapReadyCallback

mMap.clear();

Et mMap rend une variable privée ou publique.

Avant d'appeler la méthode de boucle

Insérer le code de suivi

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

}

Vous utilisez la mauvaise méthode pour addValueEventListener.

Vous pouvez soumettre addValueEventlistener dans la méthode onCreate, et vous devez également vérifier la valeur null avant l'appel.

Dans la méthode OnMapReadyCallback, ne liez que la variable mMap.

Veuillez jeter un œil pour un suivi complet du marqueur, animez et déplacez comme uber, avec le code Kotlin ci-dessous:

Ajoutez initialement votre auditeur Firebase

 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) {

    }
});

Suite à mes commentaires sur d'autres réponses, voici ce que j'ai trouvé en fonction de votre question.

Ce code affichera plusieurs marqueurs sur la carte, mais un seul marqueur pour chaque identifiant sous / utilisateurs dans la base de données. Si l'emplacement d'un identifiant particulier change, son marqueur associé sera déplacé sans affecter les autres marqueurs sur la carte.

Attention: Le code ci-dessous mettra à jour votre carte en réel- temps. Vous pouvez mettre en cache les nouveaux emplacements de marqueurs et ne les mettre à jour qu'une fois toutes les 2 à 5 secondes environ, en fonction de la fréquence à laquelle vos données changent.

Quelques notes rapides avant de plonger dans le code:

• Chaque marqueur est lié à son ID de chaîne dans la base de données sous une carte appelée mNamedMarkers .
• Le model n'étant pas fourni et ne semble pas pertinent, je l'ai omis du code ci-dessous.
• Je ne sais pas si vous venez d'un milieu germanique, mais lng est l'abréviation de Longitude, et non de "lang" dans ce contexte. Je changerais également les entrées de votre base de données pour utiliser lng plutôt que lang / long / longitude / etc (cela économise de l'espace et élimine la confusion).
• Dans le code ci-dessous, j'ai ajouté getMarkerOptions (key) , afin que vous puissiez ajouter du code pour obtenir des images, des titres et du texte différents pour chaque marqueur en fonction de son ID. Actuellement, il produira les mêmes données pour chaque marqueur.
• J'ai ajouté un balisage Javadoc pour chaque fonction afin de résumer ce que chacune fait.
• Il existe quelques TODO à développer.

Voici le code:

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');
    } 
}

    mMap.setOnMarkerClickListener(new GoogleMap.OnMarkerClickListener() {
        @Override
        public boolean onMarkerClick(final Marker marker) {
            dbref.addSnapshotListener(Mapsimport1.this, new EventListener<DocumentSnapshot>() {
                @Override
                public void onEvent(DocumentSnapshot documentSnapshot, FirebaseFirestoreException e) {
                    if (e != null) {
                        Toast.makeText(Mapsimport1.this, "Error while loading!", Toast.LENGTH_SHORT).show();
                        Log.d(TAG, e.toString());
                        return;
                    }

                    if (documentSnapshot.exists()) {
                        String acmilan = documentSnapshot.getString(marker.getTitle());
                                Log.d("acmilan**",acmilan);
                        marker.setSnippet(acmilan);                        }
                }
            });
            return false;
        }
    });