setminzoompreference - zoom google maps android api

Configuración del nivel de zoom máximo en google maps android api v2

Question

Actualmente estoy trabajando en el desarrollo de aplicaciones usando Google Maps android API v2. Mi código es el siguiente. Supongamos que el mapa tiene varios marcadores y aumenta para mostrar todos los marcadores en la pantalla.

LatLngBuilder.Builder builder = LatLngBounds.builder();
for(Marker m : markers){
    builder.include(m.getPosition());
}
LatLngBounds bounds = builder.build();
map.animateCamera(CameraUpdateFactory.newLatLngBounds(bounds, 10);

Este código funciona bien, pero quiero dejar de animar cuando el nivel de zoom llegó a 17.0f; Parece que Map API no tiene dicho método para controlar el nivel de zoom. ¿Alguien sabe alguna idea para resolver este problema?

Answer 1

Antes de la cámara animada puede verificar si los puntos SW y NE de los límites no están demasiado cerca y, si es necesario, ajustar los límites:

        ...
        LatLngBounds bounds = builder.Build();

        var sw = bounds.Southwest;
        var ne = bounds.Northeast;
        var deltaLat = Math.Abs(sw.Latitude - ne.Latitude);
        var deltaLon = Math.Abs(sw.Longitude - ne.Longitude);

        const double zoomN = 0.005; // set whatever zoom coefficient you need!!!
        if (deltaLat < zoomN) {
            sw.Latitude = sw.Latitude - (zoomN - deltaLat / 2);
            ne.Latitude = ne.Latitude + (zoomN - deltaLat / 2);
            bounds = new LatLngBounds(sw, ne);
        }
        else if (deltaLon < zoomN) {
            sw.Longitude = sw.Longitude - (zoomN - deltaLon / 2);
            ne.Longitude = ne.Longitude + (zoomN - deltaLon / 2);
            bounds = new LatLngBounds(sw, ne);
        }

        map.animateCamera(CameraUpdateFactory.NewLatLngBounds(bounds, 10);

PD. Mi ejemplo está en c # para Xamarin pero puedes ajustarlo fácilmente para Java

Answer 2

Aquí está el código de Java correspondiente para la solución de Arvis que funcionó bien para mí:

private LatLngBounds adjustBoundsForMaxZoomLevel(LatLngBounds bounds) {
  LatLng sw = bounds.southwest;
  LatLng ne = bounds.northeast;
  double deltaLat = Math.abs(sw.latitude - ne.latitude);
  double deltaLon = Math.abs(sw.longitude - ne.longitude);

  final double zoomN = 0.005; // minimum zoom coefficient
  if (deltaLat < zoomN) {
     sw = new LatLng(sw.latitude - (zoomN - deltaLat / 2), sw.longitude);
     ne = new LatLng(ne.latitude + (zoomN - deltaLat / 2), ne.longitude);
     bounds = new LatLngBounds(sw, ne);
  }
  else if (deltaLon < zoomN) {
     sw = new LatLng(sw.latitude, sw.longitude - (zoomN - deltaLon / 2));
     ne = new LatLng(ne.latitude, ne.longitude + (zoomN - deltaLon / 2));
     bounds = new LatLngBounds(sw, ne);
  }

  return bounds;
}

Answer 3

Con com.google.android.gms:play-services-maps:9.4.0 puedes establecer fácilmente el zoom mínimo / máximo. Con GoogleMap.setMinZoomPreference() y GoogleMap.setMaxZoomPreference() , puede establecer un nivel de zoom mínimo y / o máximo preferido. Más ver here .

Answer 4

Desde el documento de Android: https://developers.google.com/maps/documentation/android-api/views

You may find it useful to set a prefered minimum and/or maximum zoom level. For example, this is useful to control the user''s experience if your app shows a defined area around a point of interest, or if you''re using a custom tile overlay with a limited set of zoom levels.

    private GoogleMap mMap;
    // Set a preference for minimum and maximum zoom.
    mMap.setMinZoomPreference(6.0f);
    mMap.setMaxZoomPreference(14.0f);

Answer 5

El enfoque de @kasimir establece un número mínimo de grados, ya sea en la latitud o longitud, y se sintió un poco difícil de leer. Así que modifiqué para establecer un mínimo en la latitud, que me pareció que era un poco más legible:

private LatLngBounds adjustBoundsForMinimumLatitudeDegrees(LatLngBounds bounds, double minLatitudeDegrees) {
    LatLng sw = bounds.southwest;
    LatLng ne = bounds.northeast;
    double visibleLatitudeDegrees = Math.abs(sw.latitude - ne.latitude);

    if (visibleLatitudeDegrees < minLatitudeDegrees) {
        LatLng center = bounds.getCenter();
        sw = new LatLng(center.latitude - (minLatitudeDegrees / 2), sw.longitude);
        ne = new LatLng(center.latitude + (minLatitudeDegrees / 2), ne.longitude);
        bounds = new LatLngBounds(sw, ne);
    }

    return bounds;
}

Answer 6

El mapa tiene una propiedad llamada maxZoom. Simplemente ajuste esto a su valor cuando crea su mapa

Answer 7

En el nuevo Google Maps 9.8

com.google.android.gms:play-services-maps:9.8.0

Así es como lo hice y trabajé

    googleMap.setOnCameraMoveListener(new GoogleMap.OnCameraMoveListener() {
        @Override
        public void onCameraMove() {
            Log.d(App.TAG, "onCameraMove");

            CameraPosition position = googleMap.getCameraPosition();

            float maxZoom = 9.0f;
            if (position.zoom > maxZoom) {

                googleMap.setMinZoomPreference(maxZoom);
            }

            Log.d(App.TAG, "position.zoom = " + position.zoom);

        }
    });

Answer 8

Esto es de la referencia de API para la include(position) que está utilizando:

"Incluye este punto para la construcción de los límites. Los límites se extenderán de manera mínima para incluir este punto. Más precisamente, considerará extender los límites tanto hacia el este como hacia el oeste (uno de los cuales puede envolver al mundo) y elija el más pequeño de los dos. En el caso de que ambas direcciones den como resultado un LatLngBounds del mismo tamaño, esto lo extenderá hacia el este ".

El mapa se alejará hasta que pueda mostrar todos los marcadores que está agregando en su ciclo for.

Si solo desea reducir el zoom a 17 y aún mostrar marcadores, anime primero para ampliar el nivel 17, luego obtenga los límites para ello y luego agregue los marcadores.

@Override
public void onCameraChange(CameraPosition camPos) {

    if (camPos.zoom < 17 && mCurrentLoc != null) {
        // set zoom 17 and disable zoom gestures so map can''t be zoomed out
        // all the way
        mMap.animateCamera(CameraUpdateFactory.newLatLngZoom(position,17));
        mMap.getUiSettings().setZoomGesturesEnabled(false);
    }
    if (camPos.zoom >= 17) {
        mMap.getUiSettings().setZoomGesturesEnabled(true);
    }

    LatLngBounds visibleBounds =  mMap.getProjection().getVisibleRegion().latLngBounds;

//add the markers

Answer 9

Igual que la solución de Arvis pero usando la Location [ distanceBetween() ] ( http://developer.android.com/reference/android/location/Location.html#distanceBetween(double , double, double, double, float [])) método para calcular la distancia entre puntos:

@Override
public void zoomToMarkers(Set<Marker> markers) {

    LatLngBounds.Builder builder = new LatLngBounds.Builder();
    for (Marker marker : markers) {
        builder.include(marker.getPosition());
    }
    LatLngBounds bounds = builder.build();

    // Calculate distance between northeast and southwest
    float[] results = new float[1];
    android.location.Location.distanceBetween(bounds.northeast.latitude, bounds.northeast.longitude,
            bounds.southwest.latitude, bounds.southwest.longitude, results);

    CameraUpdate cu = null;
    if (results[0] < 1000) { // distance is less than 1 km -> set to zoom level 15
        cu = CameraUpdateFactory.newLatLngZoom(bounds.getCenter(), 15);
    } else {
        int padding = 50; // offset from edges of the map in pixels
        cu = CameraUpdateFactory.newLatLngBounds(bounds, padding);
    }
    if (cu != null) {
        mMap.moveCamera(cu);
    }
}

Answer 10

Lo que terminé haciendo fue crear mis propios botones y deshabilitar los predeterminados para tener un control total.

Algo así en el diseño para colocar los botones:

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:layout_gravity="bottom"
    android:layout_alignParentRight="true"
    android:layout_alignParentBottom="true">

    <Button
        android:id="@+id/bzoomin"
        android:layout_width="55dp"
        android:layout_height="55dp"
        android:gravity="center"
        android:textSize="28sp"
        android:text="+" />
    <Button
            android:id="@+id/bzoomout"
            android:layout_width="55dp"
            android:layout_height="55dp"
            android:gravity="center"
            android:textSize="23sp"
            android:text="—" />
</LinearLayout>

Luego, esto en el código para desactivar los botones predeterminados y configurar nuestros nuevos:

map.getUiSettings().setZoomControlsEnabled(false);

// setup zoom control buttons
Button zoomout = (Button) findViewById(R.id.bzoomout);
zoomout.setOnClickListener(new OnClickListener(){

    @Override
    public void onClick(View v) {
        if(map.getCameraPosition().zoom >= 8.0f){
            // Zoom like normal
            map.animateCamera(CameraUpdateFactory.zoomOut());
        }else{
            // Do whatever you want if user went too far
            Messages.toast_short(MapsActivity.this, "Maximum zoom out level reached");
        }
    }

});

Button zoomin = (Button) findViewById(R.id.bzoomin);
zoomin.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        if (map.getCameraPosition().zoom <= 14.0f) {
            // Zoom like normal
            map.animateCamera(CameraUpdateFactory.zoomIn());
        } else {
            // Do whatever you want if user went too far
            Messages.toast_short(MapsActivity.this, "Maximum zoom in level reached");
        }
    }
});

Answer 11

No estoy seguro de si esto funcionará, ¿pueden intentarlo?

map.animateCamera(CameraUpdateFactory.zoomTo(10), 2000, null);

Espero eso ayude

Answer 12

No he encontrado ninguna solución directa en la API de Google Maps. Una posible solución a este problema consiste en escuchar en contra del evento OnCameraChange : Siempre que este evento se active y el nivel de acercamiento esté por encima del nivel máximo de zoom, es posible llamar a animateCamera() . El código resultante sería el siguiente:

@Override
public void onCameraChange(CameraPosition position) {
    float maxZoom = 17.0f;
    if (position.zoom > maxZoom)
        map_.animateCamera(CameraUpdateFactory.zoomTo(maxZoom));
}

Answer 13

No podemos restringir la función de zoom del mapa directamente, pero podemos tratar de obtener la misma función de esta manera.

agregar map.setOnCameraChangeListener

final float maxZoom = 10.0f;

@Override
public void onCameraChange(CameraPosition position) {

    if (position.zoom > maxZoom)
        map.animateCamera(CameraUpdateFactory.zoomTo(maxZoom));
}

Answer 14

Puede obtener el nivel máximo de zoom llamándolo getMaxZoomLevel() y luego establecer ese valor:

mGoogleMap.animateCamera(CameraUpdateFactory.newLatLngZoom(fromPosition, getMaxZoomLevel()));

Answer 15

Una update reciente de la API de Google Maps presenta las funciones que necesita:

GoogleMap.setMaxZoomPreference()

GoogleMap.setMinZoomPreference()

Sin embargo, no impide que la animación se reproduzca.

Answer 16

map.setMinZoomPreference(floatValue);