trazar - mapview android studio

Animación de marcadores en Google Maps v2

Question

¿Cuál es la mejor manera de animar marcadores en Google Maps usando la API v2?

Estoy trabajando en un juego centrado en el mapa donde rastrearé ubicaciones de personas y las mostraré en el mapa para que las vean las otras personas. A medida que la gente se mueve, quiero animar un marcador desde su actual a su última posición. Cada persona tiene una dirección, por lo que necesito rotar el marcador de manera apropiada.

¿Cuál es la mejor manera de hacerlo utilizando la nueva API de Google Maps?

Answer 1

Algunos ingenieros de Google han proporcionado un buen video de demostración con un código de muestra elegante sobre cómo animar marcadores desde un punto de partida hasta un punto final, para todas las diversas versiones de Android:

El código relevante está aquí:

https://gist.github.com/broady/6314689

Y un buen video de demostración de todo eso en acción.

http://youtu.be/WKfZsCKSXVQ

ANTIGUA RESPUESTA DEPRIMIDA A CONTINUACIÓN

En la documentación, se menciona que los iconos de marcador no se pueden cambiar:

Icono

Un mapa de bits que se muestra para el marcador. Si el icono no se configura, se muestra un icono predeterminado. Puede especificar una coloración alternativa del icono predeterminado usando defaultMarker (float). No puede cambiar el icono una vez que haya creado el marcador.

Documentación de Google Maps API v2

Tendrá que hacer un seguimiento de los marcadores específicos, quizás usando un método similar al descrito aquí: vincule un Marcador a un Objeto , luego determine qué marcador necesita actualizar. Llame a .remove() en el marcador, luego cree una imagen girada dependiendo de la "dirección" que desee, cree un nuevo marcador con esa imagen y agregue el nuevo marcador al mapa.

No necesita "borrar" el mapa, simplemente elimine el marcador que desea modificar, cree uno nuevo y vuélvalo a agregar al mapa.

Desafortunadamente, la nueva API de Maps aún no es muy flexible. Esperemos que Google continúe mejorando.

Answer 2

Marker tiene una nueva función agregada a partir de rev.7 de API v2. Marker.setIcon , por lo que puede usar varios iconos para mostrar la dirección.

Answer 3

Ejemplo de uso para la respuesta de DiscDev (arriba):

LatLng fromLocation = new LatLng(38.5, -100.4); // Whatever origin coordinates
LatLng toLocation = new LatLng(37.7, -107.7); // Whatever destination coordinates
Marker marker = mMap.addMarker(new MarkerOptions().position(firstLocation));
MarkerAnimation.animateMarkerToICS(marker, toLocation, new LatLngInterpolator.Spherical());

Y para aquellos de ustedes que usan GPS / o cualquier proveedor de posición que recibe actualizaciones de ubicación:

Marker ourGlobalMarker;
// We''ve got a location from some provider of ours, now we can call:
private void updateMarkerPosition(Location newLocation) {

    LatLng newLatLng = new LatLng(newLocation.getLatitude(), newLocation.getLongitude());

    if(ourGlobalMarker == null) { // First time adding marker to map
        ourGlobalMarker = mMap.addMarker(new MarkerOptions().position(newLatLng));
    }
    else {
        MarkerAnimation.animateMarkerToICS(ourGlobalMarker, newLatLng, new LatLngInterpolator.Spherical());
    }         
}

IMPORTANTE:

Dentro de 1MarkerAnimation.java Si la duración de la animación se establece en X, y estás recibiendo actualizaciones de ubicación en una tasa menor que X, se ejecutarán varias animaciones, y es posible que veas que el marcador parpadea.

Para evitar esto, el método animationMarkerToICS (tomé aquí animationMarkerToICS por ejemplo), debería verse más o menos así,

implementación completa del método:

private static Animator animator; // MAKING ANIMATOR GLOBAL INSTEAD OF LOCAL TO THE STATIC FUNCTION

...

// Ice Cream Sandwich compatible
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public static void animateMarkerToICS(Marker marker, LatLng finalPosition, final LatLngInterpolator latLngInterpolator) {

    TypeEvaluator<LatLng> typeEvaluator = new TypeEvaluator<LatLng>() {
        @Override
        public LatLng evaluate(float fraction, LatLng startValue, LatLng endValue) {
            return latLngInterpolator.interpolate(fraction, startValue, endValue);
        }
    };
    Property<Marker, LatLng> property = Property.of(Marker.class, LatLng.class, "position");

    // ADD THIS TO STOP ANIMATION IF ALREADY ANIMATING TO AN OBSOLETE LOCATION
    if(animator != null && animator.isRunning()) {
        animator.cancel();
        animator = null;
    }
    animator = ObjectAnimator.ofObject(marker, property, typeEvaluator, finalPosition);
    animator.setDuration((long) ANIMATION_DURATION);
    animator.start();
}

Disfrutar.

Answer 4

    //Your code         
    double bearing = 0.0;
             bearing = getBearing(new LatLng(
                                                currentPosition.latitude
                                                ,currentPosition.longitude),
                                        new LatLng(
                                                nextPosition.latitude,
                                                nextPosition.longitude));  

          bearing -= 90;
                            CameraPosition cameraPosition = new CameraPosition
                                    .Builder()
                                    .target(new LatLng(nextPosition.latitude, nextPosition.longitude))
                                    .bearing((float) bearing)
                                    .zoom(ZOOM_LEVEL).build();


                            mGoogleMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 5000, null);

                 animatedMarker(currentPosition,nextPosition,busMarker);



                //Method for finding bearing between two points
                    private float getBearing(LatLng begin, LatLng end) {
                        double lat = Math.abs(begin.latitude - end.latitude);
                        double lng = Math.abs(begin.longitude - end.longitude);
                        if (begin.latitude < end.latitude && begin.longitude < end.longitude)
                            return (float) (Math.toDegrees(Math.atan(lng / lat)));
                        else if (begin.latitude >= end.latitude && begin.longitude < end.longitude)
                            return (float) ((90 - Math.toDegrees(Math.atan(lng / lat))) + 90);
                        else if (begin.latitude >= end.latitude && begin.longitude >= end.longitude)
                            return (float) (Math.toDegrees(Math.atan(lng / lat)) + 180);
                        else if (begin.latitude < end.latitude && begin.longitude >= end.longitude)
                            return (float) ((90 - Math.toDegrees(Math.atan(lng / lat))) + 270);
                        return -1;
                    }

   private void animatedMarker(final LatLng startPosition,final LatLng nextPosition,final Marker mMarker)
    {

        final Handler handler = new Handler();
        final long start = SystemClock.uptimeMillis();
        final Interpolator interpolator = new AccelerateDecelerateInterpolator();
        final float durationInMs = 3000;
        final boolean hideMarker = false;

        handler.post(new Runnable() {
            long elapsed;
            float t;
            float v;

            @Override
            public void run() {
                // Calculate progress using interpolator
                elapsed = SystemClock.uptimeMillis() - start;
                t = elapsed / durationInMs;
                v = interpolator.getInterpolation(t);

                LatLng currentPosition = new LatLng(
                        startPosition.latitude * (1 - t) + nextPosition.latitude * t,
                        startPosition.longitude * (1 - t) + nextPosition.longitude * t);

                mMarker.setPosition(currentPosition);

                // Repeat till progress is complete.
                if (t < 1) {
                    // Post again 16ms later.
                    handler.postDelayed(this, 16);
                } else {
                    if (hideMarker) {
                        mMarker.setVisible(false);
                    } else {
                        mMarker.setVisible(true);
                    }
                }
            }
        });

    }