Guida introduttiva a Google Maps per Android avanzato

1. Introduzione

Sebbene le funzioni standard di Google Maps siano incredibilmente utili, ci saranno momenti in cui vorresti fare ancora un po 'di più. Fortunatamente, Google ha creato una libreria open source contenente una serie di utility che gli sviluppatori Android possono utilizzare per rendere le loro applicazioni ancora migliori con le mappe potenziate.

In questo tutorial, imparerai come utilizzare questa libreria di utilità per aggiungere visualizzazioni di mappe di calore per i tuoi dati, raggruppare un gran numero di marker per una visualizzazione più semplice e utilizzare vari metodi di utilità per lavorare con la natura sferica della Terra o disegnare percorsi su strade.

I file sorgente per questo tutorial sono disponibili su GitHub.

2. Installazione

Nel primo tutorial di questa serie, ho esaminato come impostare un progetto utilizzando la Google Developer Console e aggiungendo una chiave API al manifest. Per questo tutorial, devi ottenere una chiave API e impostare il tuo progetto con un manifest come descritto qui.

Avanti, aperto build.gradle e aggiungi due nuove dipendenze, una per Play Services per utilizzare Google Maps e un'altra per la libreria di Google Maps Utils.

compila 'com.google.android.gms: play-services-maps: 7.8.0' compila 'com.google.maps.android:android-maps-utils:0.4'

Devo notare che la libreria di Google Maps Utils è tecnicamente ancora in beta, sebbene sia stata disponibile per gli ultimi due anni. Una volta importate queste librerie e sincronizzato il progetto, è necessario aggiornare il file di layout per MainActivity.java in modo che utilizzi il frammento personalizzato mostrato di seguito.

Quindi, crea il UtilsListFragment classe che viene utilizzata sopra in modo che mostri un semplice elenco di elementi che rappresentano le varie parti della libreria che imparerai a conoscere in questo tutorial.

public class UtilsListFragment estende ListFragment @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); ArrayAdapter adattatore = nuovo ArrayAdapter(getActivity (), android.R.layout.simple_list_item_1); String [] items = getResources (). GetStringArray (R.array.list_items); adapter.addAll (new ArrayList (Arrays.asList (items))); setListAdapter (adattatore);  @Override public void onListItemClick (ListView l, Visualizza v, int position, long id) super.onListItemClick (l, v, position, id); Stringa item = ((TextView) v) .getText (). ToString (); if (getString (R.string.item_clustering) .equalsIgnoreCase (item)) startActivity (new Intent (getActivity (), ClusterMarkerActivity.class));  else if (getString (R.string.item_heat_map) .equalsIgnoreCase (item)) startActivity (new Intent (getActivity (), HeatMapActivity.class));  else if (getString (R.string.item_polylines) .equalsIgnoreCase (item)) startActivity (new Intent (getActivity (), PolylineActivity.class));  else if (getString (R.string.item_spherical_geometry) .equalsIgnoreCase (item)) startActivity (new Intent (getActivity (), SphericalGeometryActivity.class)); 

Ciascuna stringa è definita e inserita in a stringa-array per uniformità.

Clustering Mappa di calore Decodifica polilinea Utilità geometriche sferiche  @ String / item_clustering @ String / item_heat_map @ stringa / item_polylines @ String / item_spherical_geometry 

Una volta che l'elenco è disponibile, è necessario creare BaseMapActivity.java, che gestisce tutte le impostazioni relative alla mappa comune per ciascuna delle attività di esempio che verranno create. Questo Attività inizializza a Google Map e ingrandisce la videocamera in un'area specifica. In questo caso, quella zona è la città di Denver in Colorado, USA. Tutto in questa classe dovrebbe sembrare familiare dagli ultimi due articoli di questa serie.

classe astratta pubblica BaseMapActivity estende AppCompatActivity protected LatLng mCenterLocation = new LatLng (39.7392, -104.9903); protetto GoogleMap mGoogleMap; @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (getMapLayoutId ()); initMapIfNecessary ();  @Override protected void onResume () super.onResume (); initMapIfNecessary ();  protected void initMapIfNecessary () if (mGoogleMap! = null) return;  mGoogleMap = ((MapFragment) getFragmentManager (). findFragmentById (R.id.map)) .getMap (); initMapSettings (); initCamera ();  protected void initCamera () CameraPosition position = CameraPosition.builder () .target (mCenterLocation) .zoom (getInitialMapZoomLevel ()) .build (); mGoogleMap.animateCamera (CameraUpdateFactory.newCameraPosition (posizione), null);  protected int getMapLayoutId () return R.layout.activity_map;  protected float getInitialMapZoomLevel () return 12.0f;  protected abstract void initMapSettings (); 

Ora che hai creato il progetto iniziale, puoi passare alla sezione successiva in cui ne creerai una nuova Attività per ogni utilità che stiamo andando a coprire in questo tutorial.

3. Mappe di calore

Le mappe di calore sono un modo eccellente per rappresentare visivamente le concentrazioni di punti dati su una mappa. La libreria Google Maps Utils semplifica l'aggiunta a un'applicazione. Per iniziare, creane uno nuovo BaseMapActivity di nome HeatMapActivity e aggiungilo al tuo AndroidManifest.xml file. Nella parte superiore di quella classe, dichiara a HeatmapTileProvider che useremo per costruire la sovrapposizione della mappa.

HeatmapTileProvider privato mProvider;

Nel BaseMapActivity, un metodo chiamato initMapSettings è chiamato che ti permette di aggiungere le tue personalizzazioni alla mappa. Per questo Attività, è necessario sovrascrivere quel metodo per ottenere un Lista di array di LatLng oggetti che vengono poi utilizzati per generare il HeatmapTileProvider oggetto.

Il fornitore ha vari metodi che possono essere utilizzati per modificare l'aspetto della mappa termica, come i colori del gradiente, il raggio per ciascun punto e il peso di ciascun punto. Una volta creato il tuo provider, puoi creare la mappa di calore TileOverlay e applicalo alla tua mappa.

@Override protetto void initMapSettings () ArrayList locations = generateLocations (); mProvider = new HeatmapTileProvider.Builder (). data (locations) .build (); mProvider.setRadius (HeatmapTileProvider.DEFAULT_RADIUS); mGoogleMap.addTileOverlay (new TileOverlayOptions (). tileProvider (mProvider)); 

Nell'implementazione di cui sopra initMapSettings, generateLocations è un metodo di supporto che genera 1000 LatLng posizioni attorno alla posizione della mappa centrale.

ArrayList privato generateLocations () ArrayList locations = new ArrayList(); doppio lat; doppio lng; Generatore casuale = nuovo casuale (); per (int i = 0; i < 1000; i++ )  lat = generator.nextDouble() / 3; lng = generator.nextDouble() / 3; if( generator.nextBoolean() )  lat = -lat;  if( generator.nextBoolean() )  lng = -lng;  locations.add(new LatLng(mCenterLocation.latitude + lat, mCenterLocation.longitude + lng));  return locations; 

Una volta che hai finito di implementare initMapSettings e generateLocations, puoi eseguire la tua app e fare clic sulla sezione mappa di calore per vederla in azione.

4. Indicatori di raggruppamento

Quando una mappa ha molti punti dati in una piccola area, può diventare ingombra molto rapidamente man mano che l'utente effettua lo zoom. Non solo, ma avere troppi indicatori visualizzati contemporaneamente può causare considerevoli rallentamenti di alcuni dispositivi.

Per contribuire ad alleviare alcune delle frustrazioni causate da questi problemi, puoi utilizzare la libreria di Google Maps Utils per animare i tuoi marcatori in cluster. La prima cosa che devi fare è creare un nuovo oggetto modello che implementa il ClusterItem interfaccia. Questo modello deve implementare il getPosition metodo dal ClusterItem interfaccia per restituire un valido LatLng oggetto.

classe pubblica ClusterMarkerLocation implementa ClusterItem posizione privata LatLng; public ClusterMarkerLocation (LatLng latLng) position = latLng;  @Override public LatLng getPosition () return position;  public void setPosition (posizione LatLng) this.position = position; 

Con il modello creato, puoi crearne uno nuovo Attività chiamato ClusterMarkerActivity e aggiungilo al tuo manifest. Quando si inizializza la mappa, è necessario creare un ClusterManager, associarlo con il tuo Google Map, e aggiungi il tuo LatLng posizioni come ClusterMarkerLocations al ClusterManager per l'utilità sapere cosa raggruppare. Dai un'occhiata all'implementazione di initMarkers per capire meglio come funziona.

private void initMarkers () ClusterManager clusterManager = new ClusterManager(questo, mGoogleMap); mGoogleMap.setOnCameraChangeListener (clusterManager); doppio lat; doppio lng; Generatore casuale = nuovo casuale (); per (int i = 0; i < 1000; i++ )  lat = generator.nextDouble() / 3; lng = generator.nextDouble() / 3; if( generator.nextBoolean() )  lat = -lat;  if( generator.nextBoolean() )  lng = -lng;  clusterManager.addItem( new ClusterMarkerLocation( new LatLng( mCenterLocation.latitude + lat, mCenterLocation.longitude + lng ) ) );  

In questo esempio, creiamo 1000 punti casuali per visualizzarli e aggiungerli alla mappa. La libreria di Google Maps Utils gestisce tutto il resto per noi.

5. Altre Utilità

Oltre agli ultimi due elementi, la libreria di Google Maps Utils è piena di piccole utilità utili. Se hai molti punti diversi che compongono un percorso, puoi codificarli come polilinea e quindi aggiungere la polilinea alla tua mappa usando PolyUtil. Questo mostrerà un percorso tra ciascuno dei punti lungo la mappa.

public class PolylineActivity estende BaseMapActivity polizza finale statica privata polilinea = "gsqqFxxu_SyRlTys @ npAkhAzY MsVc'AuHwbB Lil @ [goCqGe | BnUa'A ~ MkbG? eq @ hRq @_ N vKdB"; @Override protetto void initMapSettings () List decodedPath = PolyUtil.decode (polyline); mGoogleMap.addPolyline (new PolylineOptions (). addAll (decodedPath)); 

Inoltre PolyUtil, Google ha aggiunto SphericalUtil che può essere usato per misurare le distanze o calcolare la geometria lungo la superficie di una sfera. Se vuoi trovare la distanza tra due punti sulla mappa, puoi chiamare SphericalUtil.computeDistanceBetween (LatLng position1, LatLng position2) restituire a Doppio della distanza in metri. Se si desidera trovare la direzione tra due punti, è possibile chiamare SphericalUtil.computeHeading (LatLng point1, LatLng point2).

In relazione a questo, un altro metodo di utilità nel SpericalUtil classe ti permette di trovare un punto a una certa direzione e distanza. Consiglio di consultare la documentazione per ulteriori informazioni su SpericalUtil classe.

Conclusione

In questo tutorial, hai appena scalfito la superficie della libreria di Google Maps Utils e tutto ciò che ha da offrire. Altre funzionalità che può aggiungere alla tua applicazione includono l'aggiunta di sovrapposizioni per i dati KML, la creazione di marcatori personalizzati e metodi di supporto per lavorare con GeoJSON.

Fortunatamente, Google ha aperto l'intera libreria, quindi puoi trovare il codice sorgente e il codice demo della biblioteca su GitHub. Dopo aver analizzato le ultime tre parti di questa serie, ora dovresti essere abbastanza comodo con Google Maps per aggiungerle alle tue applicazioni per arricchire l'esperienza utente e creare app fantastiche.