Restringindo a área para a qual o usuário pode ir no Mapview

Question

Estou usando uma versão personalizada do mapview (versão OSMDroid). Estou usando blocos personalizados dentro dela e só quero que o usuário possa visualizar a área onde tenho meus blocos personalizados. Existe uma maneira de definir as long longs do limite de modo que quando eles movimentarem o mapa não ultrapasse esses limites?

Answer 1

No caso, ajuda qualquer pessoa ....

Tenho uma espécie de solução que estou usando, ela funciona bem, mas poderia ser melhor, pois o mapa pode ficar um pouco longe da tela antes de voltar! Ele usa os lat longs e calcula onde o mapa está, eu defino 4 coordenadas que são aproximadamente os 4 cantos do mapa. Eu descobri que funciona melhor se você defini-las levemente no mapa em vez de exatamente nos cantos, então eu calculo se os lat longs deixaram a tela completamente .. em caso afirmativo, eles serão devolvidos na metade:

Eu substituí o mapview e o evento OnTouch do mapa

@Override
public boolean onTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_UP) {

        // (only works for north of equator)
        // * map right side (lat) can't go past the left (lat) of screen

        // get geopoints of the 4 corners of the screen
        Projection proj = getProjection();
        GeoPoint screenTopLeft = proj.fromPixels(0, 0);
        GeoPoint screenTopRight = proj.fromPixels(getWidth(), 0);
        GeoPoint screenBottomLeft = proj.fromPixels(0, getHeight());

        double screenTopLat = screenTopLeft.getLatitudeE6() / 1E6;
        double screenBottomLat = screenBottomLeft.getLatitudeE6() / 1E6;
        double screenLeftlong = screenTopLeft.getLongitudeE6() / 1E6;
        double screenRightlong = screenTopRight.getLongitudeE6() / 1E6;

        double mapTopLat = BoundsTopLeftCorner.getLatitudeE6() / 1E6;
        double mapBottomLat = BoundsBottomLeftCorner.getLatitudeE6() / 1E6;
        double mapLeftlong = BoundsTopLeftCorner.getLongitudeE6() / 1E6;
        double mapRightlong = BoundsTopRightCorner.getLongitudeE6() / 1E6;

        // screen bottom greater than map top
        // screen top less than map bottom
        // screen right less than map left
        // screen left greater than map right
        boolean movedLeft = false;
        boolean movedRight = false;
        boolean movedUp = false;
        boolean movedDown = false;

        boolean offscreen = false;
        if (screenBottomLat > mapTopLat) {
            movedUp = true;
            offscreen = true;
        }
        if (screenTopLat < mapBottomLat) {
            movedDown = true;
            offscreen = true;
        }
        if (screenRightlong < mapLeftlong) {
            movedLeft = true;
            offscreen = true;
        }
        if (screenLeftlong > mapRightlong) {
            movedRight = true;
            offscreen = true;
        }

        if (offscreen) {
            // work out on which plane it's been moved off screen (lat/lng)

            if (movedLeft || movedRight) {

                double newBottomLat = screenBottomLat;
                double newTopLat = screenTopLat;

                double centralLat = newBottomLat
                        + ((newTopLat - newBottomLat) / 2);
                if (movedRight)
                    this.getController().setCenter(
                            new GeoPoint(centralLat, mapRightlong));
                else
                    this.getController().setCenter(
                            new GeoPoint(centralLat, mapLeftlong));

            }
            if (movedUp || movedDown) {

                // longs will all remain the same
                double newLeftLong = screenLeftlong;
                double newRightLong = screenRightlong;

                double centralLong = (newRightLong + newLeftLong) / 2;

                if (movedUp)
                    this.getController().setCenter(
                            new GeoPoint(mapTopLat, centralLong));

                else
                    this.getController().setCenter(
                            new GeoPoint(mapBottomLat, centralLong));
            }

        }

    }
    return super.onTouchEvent(ev);
}}

Algumas coisas que devo apontar se você está pensando em usar isso:

1. Não garanto que funcionará para a sua situação e você só deve usá-lo como ponto de partida.
2. Só funcionará para áreas ao norte do equador (eu acho) devido à forma como fiz as coordenadas!
3. Funciona na "ação inicial" do evento de toque, de modo que leva o ponto em que o usuário tira o dedo da tela. Isso significa que quando o mapa arremessa é completamente impreciso, pois eu não consegui descobrir onde o mapa parou, por isso eu desativei o arremesso substituindo o evento arremesso e não fazendo nada nele .. isso deixa o mapa um pouco agitado!

Se alguém tiver alguma solução melhor ou puder melhorar meu código, fique à vontade!

Answer 2

Atualização: sei que esta é uma pergunta antiga, mas osmdroid agora tem um método setScrollableAreaLimit () que alcançará o que você está procurando.Também existe um método setMinZoomLevel () e setMaxZoomLevel () para restringir facilmente os níveis de zoom.

Resposta original:

Fique de olho em:

http://code.google.com/p/osmdroid/problemas / detalhes? id= 209

Um patch já foi criado e provavelmente será integrado em breve.

Answer 3

Esta é uma postagem cruzada do tópico do osmdroid .Agora há uma lista de uma classe BoundedMapView, que implementa o patch mencionado anteriormente.

Para aqueles que usam .jar ou não estão familiarizados com patches, juntei uma subclasse de MapView que suporta limitar a visão do usuário a uma área específica.

Detalhes sobre como usá-lo, se não for óbvio, pode ser encontrado em http://www.sieswerda.net/2012/08/15 / boundedmapview-a-mapview-with-limits /

Answer 4

Estou procurando exatamente a mesma coisa.

Minha melhor pista é adicionar uma sobreposição, que estende boolean onScroll(...).Se retornar verdadeiro, a rolagem será cancelada.

É exatamente assim que eu quero, exceto por uma coisa: arremessar / sacudir.A mesma abordagem pode ser usada para cancelar eventos de caso, embora você só saiba disso no início do caso.

Idealmente, você seria capaz de ouvir o método computeScroll() e limitar o (x, y) da rolagem, com base em mScroller.getCurX() e mScroller.getCurY().