La versione 2 dell'API Maps JavaScript non è più disponibile dal 26
maggio 2021. Di conseguenza, le mappe v2 del tuo sito smetteranno di funzionare e restituiranno
errori JavaScript. Per continuare a utilizzare le mappe sul tuo sito, esegui la migrazione alla versione 3 dell'API Maps JavaScript. Questa guida ti aiuterà a svolgere la procedura.
Panoramica
Ogni applicazione avrà una procedura di migrazione leggermente diversa, ma alcuni passaggi sono comuni a tutti i progetti:
- Richiedi una nuova chiave. L'API Maps JavaScript ora utilizza la console Google Cloud per gestire le chiavi. Se utilizzi ancora una chiave v2, assicurati di ottenere la nuova chiave API prima di iniziare la migrazione.
- Aggiorna il bootstrap dell'API. La maggior parte delle applicazioni carica
l'API Maps JavaScript v3 con il seguente codice:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
- Aggiorna il codice. La quantità di modifiche necessarie dipende molto dalla tua applicazione. Le modifiche più comuni includono:
- Fai sempre riferimento allo spazio dei nomi google.maps. Nella versione 3,
tutto il codice dell'API Maps JavaScript viene memorizzato nello
spazio dei nomi
google.maps.*
anziché nello
spazio dei nomi globale. Nell'ambito di questo
processo, la maggior parte degli oggetti è stata rinominata. Ad esempio, invece di GMap2
, ora caricate google.maps.Map
.
- Rimuovi eventuali riferimenti a metodi obsoleti. È stato rimosso un numero
di metodi di utilità generici, ad esempio
GDownloadURL
e GLog
.
Sostituisci questa funzionalità con librerie di utilità di terze parti o rimuovi questi riferimenti dal codice.
- (Facoltativo) Aggiungi librerie al codice. Molte
funzionalità sono state estruse in librerie di utilità in modo che ogni
app debba caricare solo le parti dell'API che verranno utilizzate.
- (Facoltativo) Configura il progetto in modo da utilizzare gli elementi esterni v3.
Gli elementi extern della versione 3 possono essere utilizzati per convalidare il codice con il
Closure
Compiler o per attivare il completamento automatico nell'IDE.
Scopri di più su
Compilazione avanzata ed esterni.
- Esegui test e iterazioni. A questo punto, dovrai ancora fare un po' di lavoro, ma la buona notizia è che sei sulla buona strada per creare la tua nuova applicazione Maps v3.
Modifiche nella versione 3 dell'API Maps JavaScript
Prima di pianificare la migrazione, ti consigliamo di comprendere le differenze tra la versione 2 e la versione 3 dell'API Maps JavaScript. La versione più recente dell'API Maps JavaScript è stata scritta da zero, con un'attenzione particolare alle tecniche di programmazione JavaScript moderne, all'utilizzo maggiore delle librerie e a un'API semplificata.
All'API sono state aggiunte molte nuove funzionalità e alcune funzionalità familiari sono state modificate o addirittura rimosse. Questa sezione mette in evidenza alcune delle principali differenze tra le due release.
Alcune delle modifiche nell'API v3 includono:
- Una libreria di base semplificata. Molte delle funzioni supplementari sono state spostate in librerie, contribuendo a ridurre i tempi di caricamento e analisi dell'API Core, il che consente di caricare rapidamente la mappa su qualsiasi dispositivo.
- Miglioramento delle prestazioni di diverse funzionalità, ad esempio il rendering dei poligoni e il posizionamento degli indicatori.
- Un nuovo approccio ai limiti di utilizzo lato client per supportare meglio gli indirizzi condivisi utilizzati dai proxy mobile e dai firewall aziendali.
- È stato aggiunto il supporto per diversi browser moderni e browser mobile. Il supporto per Internet Explorer 6 è stato ritirato.
- Sono stati rimossi molti dei classi helper generici (
GLog
o
GDownloadUrl
). Oggi esistono molte
eccellenti librerie JavaScript che forniscono funzionalità simili,
come Closure o
jQuery.
- Un'implementazione di Street View in HTML5 che verrà caricata su qualsiasi dispositivo mobile.
- Panorami di Street View personalizzati con le tue foto, che ti consentono di condividere panorami di piste da sci, case in vendita o altri luoghi interessanti.
- Personalizzazioni delle mappe stilizzate che ti consentono di modificare la visualizzazione degli elementi sulla mappa di base in base al tuo stile visivo unico.
- Supporto di diversi nuovi servizi, come ElevationService e DistanceMatriX.
- Un servizio di indicazioni stradali migliorato fornisce percorsi alternativi, ottimizzazione dei percorsi (soluzioni approssimative al
problema del commesso viaggiatore), indicazioni per biciclette (con il
livello per biciclette), indicazioni per i trasporti pubblici e
indicazioni spostabili.
- Un formato Geocoding aggiornato che fornisce informazioni sul tipo più precise rispetto al valore
accuracy
dell'API Geocoding v2.
- Supporto di più finestre informative in una singola mappa
Eseguire l'upgrade dell'applicazione
La tua nuova chiave
La versione 3 dell'API Maps JavaScript utilizza un nuovo sistema di chiavi rispetto alla versione 2. È possibile che tu stia già utilizzando una chiave v3 con la tua applicazione, in questo caso non è necessaria alcuna modifica. Per verificare, controlla il
parametro key
dell'URL da cui carichi l'API Maps JavaScript. Se il valore della chiave inizia con "ABQIAA", significa che stai utilizzando una chiave v2. Se hai una chiave v2, devi eseguire l'upgrade a una chiave v3 nell'ambito della migrazione,
che:
La chiave viene passata durante il caricamento dell'API Maps JavaScript v3.
Scopri di più sulla generazione di chiavi API.
Tieni presente che se sei un cliente delle API di Google Maps per il lavoro, potresti utilizzare un ID cliente con il parametro client
anziché il parametro key
. Gli ID client sono ancora supportati nella versione 3 dell'API JavaScript di Maps e non devono essere sottoposti alla procedura di upgrade delle chiavi.
Caricamento dell'API in corso
La prima modifica che dovrai apportare al codice riguarda il caricamento dell'API. Nella versione 2, carichi l'API Maps JavaScript
tramite una richiesta a
http://maps.google.com/maps
. Se caricate la versione 3 dell'API Maps JavaScript, dovete apportare le seguenti modifiche:
- Carica l'API da
//maps.googleapis.com/maps/api/js
- Rimuovi il parametro
file
.
- Aggiorna il parametro
key
con la nuova chiave v3. I clienti delle API di Google Maps per il lavoro devono utilizzare un parametro client
.
- (Solo per il piano Premium di Google Maps Platform) Assicurati che il parametro
client
sia fornito come spiegato nella
Guida per gli sviluppatori del piano Premium di Google Maps Platform.
- Rimuovi il parametro
v
per richiedere la
versione rilasciata più recente o modifica il relativo valore in base allo schema di
versionamento v3.
- (Facoltativo) Sostituisci il parametro
hl
con
language
e mantieni il relativo valore.
- (Facoltativo) Aggiungi un parametro
libraries
per caricare librerie facoltative.
Nel caso più semplice, lo bootstrap della versione 3 specificherà solo il parametro della chiave API:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
L'esempio seguente richiede la versione più recente dell'API Maps JavaScript v2 in tedesco:
<script src="//maps.google.com/maps?file=api&v=2.x&key=YOUR_API_KEY&hl=de"></script>
L'esempio seguente è una richiesta equivalente per la versione 3.
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&language=de"></script>
Introduzione allo spazio dei nomi google.maps
Probabilmente la modifica più evidente nell'API Maps JavaScript 3 è l'introduzione dello spazio dei nomi google.maps
. L'API v2 inserisce per impostazione predefinita tutti gli oggetti nello spazio dei nomi globale, il che può comportare collisioni dei nomi. Nella versione 3, tutti gli oggetti si trovano nello spazio dei nomi google.maps
.
Quando esegui la migrazione dell'applicazione alla versione 3, dovrai modificare il codice per utilizzare il nuovo spazio dei nomi. Purtroppo, la ricerca di "G" e la sostituzione con "google.maps" non funziona completamente, ma è una buona regola di base da applicare durante la revisione del codice. Di seguito sono riportati alcuni esempi di classi equivalenti nella versione 2 e 3.
v2 |
v3 |
GMap2 |
google.maps.Map |
GLatLng |
google.maps.LatLng |
GInfoWindow |
google.maps.InfoWindow |
GMapOptions |
google.map.MapOptions |
G_API_VERSION |
google.maps.version |
GPolyStyleOptions |
google.maps.PolygonOptions or
google.maps.PolylineOptions |
Rimozione del codice obsoleto
La versione 3 dell'API JavaScript di Maps ha elementi paralleli per la maggior parte
delle funzionalità della versione 2; tuttavia, alcune classi non sono più supportate. Nell'ambito della migrazione, devi sostituire queste classi con librerie di utilità di terze parti o rimuovere questi riferimenti dal codice. Esistono molte ottime librerie JavaScript che
forniscono funzionalità simili, come Closure o
jQuery.
Le seguenti classi non hanno un parallelo nella versione 3 dell'API Maps JavaScript:
GBounds | GLanguage |
GBrowserIsCompatible | GLayer |
GControl | GLog |
GControlAnchor | GMercatorProjection |
GControlImpl | GNavLabelControl |
GControlPosition | GObliqueMercator |
GCopyright | GOverlay |
GCopyrightCollection | GPhotoSpec |
GDownloadUrl | GPolyEditingOptions |
GDraggableObject | GScreenOverlay |
GDraggableObjectOptions | GStreetviewFeatures |
GFactualGeocodeCache | GStreetviewLocation |
GGeoAddressAccuracy | GStreetviewOverlay |
GGeocodeCache | GStreetviewUserPhotosOptions |
GGoogleBar | GTileLayerOptions |
GGoogleBarAdsOptions | GTileLayerOverlayOptions |
GGoogleBarLinkTarget | GTrafficOverlayOptions |
GGoogleBarListingTypes | GUnload |
GGoogleBarOptions | GXml |
GGoogleBarResultList | GXmlHttp |
GInfoWindowTab | GXslt |
GKeyboardHandler |
|
Confronto del codice
Confrontiamo due applicazioni piuttosto semplici scritte con le API v2 e v3.
<!DOCTYPE html>
<html>
<head>
<script src="//maps.google.com/maps?file=api&v=2&key=YOUR_API_KEY"></script>
<style>
html, body, #map { height: 100%; margin: 0; }
</style>
<script>
function initialize() {
if (GBrowserIsCompatible()) {
var map = new GMap2(
document.getElementById('map'));
map.setCenter(new GLatLng(37.4419, -122.1419), 13);
map.setUIToDefault();
map.addOverlay(new GMarker(new GLatLng(37.4419, -122.1419)));
}
}
</script>
</head>
<body onload="initialize()" onunload="GUnload()">
<div id="map"></div>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
<style>
html, body, #map { height: 100%; margin: 0; }
</style>
<script>
function initialize() {
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(37.4419, -122.1419),
zoom: 13,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var marker = new google.maps.Marker({
position: new google.maps.LatLng(37.4419, -122.1419),
map: map
});
}
google.maps.event.addDomListener(window, 'load', initialize);
</script>
</head>
<body>
<div id="map"></div>
</body>
</html>
Come puoi vedere, esistono diverse differenze tra le due applicazioni. Le modifiche principali includono:
- L'indirizzo da cui viene caricata l'API è cambiato.
- I metodi
GBrowserIsCompatible()
e GUnload()
non sono più obbligatori nella versione 3 e sono stati rimossi dall' API.
- L'oggetto
GMap2
viene sostituito da
google.maps.Map
come oggetto centrale dell'API.
- Le proprietà vengono ora caricate tramite le classi Options. Nell'esempio precedente, abbiamo impostato le tre proprietà necessarie per caricare una mappa (
center
, zoom
e mapTypeId
) tramite un oggetto MapOptions
in linea.
- L'interfaccia utente predefinita è attiva per impostazione predefinita nella versione 3. Puoi disattivare questa opzione impostando la proprietà
disableDefaultUI
su true nell'oggetto MapOptions
.
Riepilogo
A questo punto avrai avuto un'idea di alcuni dei punti chiave coinvolti nella migrazione dalla versione 2 alla versione 3 dell'API JavaScript di Maps.
Potresti dover conoscere altre informazioni, ma dipende dalla tua
applicazione. Nelle sezioni seguenti sono incluse istruzioni di migrazione per
casi specifici che potresti riscontrare. Inoltre, esistono diverse risorse
che potresti trovare utili durante la procedura di upgrade.
In caso di problemi o domande su questo articolo, utilizza
il link INVIACI FEEDBACK nella parte superiore di questa pagina.
Questa sezione fornisce un confronto dettagliato delle funzionalità più utilizzate sia per la versione 2 che per la versione 3 dell'API Maps JavaScript. Ogni
sezione del riferimento è progettata per essere letta singolarmente. Ti consigliamo di non leggere questo documento di riferimento nella sua interezza, ma di utilizzare questo materiale per facilitare la migrazione caso per caso.
- Eventi: registrazione e gestione degli eventi.
- Controlli: consente di manipolare i controlli di navigazione visualizzati sulla mappa.
- Overlay: per aggiungere e modificare gli oggetti sulla mappa.
- Tipi di mappa: i riquadri che compongono la mappa base.
- Livelli: per aggiungere e modificare i contenuti come gruppo, ad esempio i livelli KML o di traffico.
- Servizi: utilizzo dei servizi di geocodifica, indicazioni stradali o Street View di Google.
Eventi
Il modello di eventi per la versione 3 dell'API Maps JavaScript è simile a quello utilizzato nella versione 2, anche se molto è cambiato sotto il cofano.
Nuovo evento per il supporto MVC
L'API v3 aggiunge un nuovo tipo di evento per riflettere le modifiche dello stato MVC. Ora esistono due tipi di eventi:
- Gli eventi utente (ad esempio gli eventi del mouse "click") vengono propagati dal DOM all'API JavaScript di Maps. Questi eventi sono separati e distintamente dagli eventi DOM standard.
- Le notifiche di modifica dello stato MVC riflettono le modifiche agli oggetti dell'API Maps
e vengono denominate utilizzando una convenzione
property_changed
.
Ogni oggetto dell'API Maps esporta una serie di eventi denominati. Le applicazioni
interessate a eventi specifici devono registrare gli ascoltatori di eventi
per questi eventi ed eseguire il codice quando vengono ricevuti. Questo
meccanismo basato su eventi è lo stesso nell'API Maps JavaScript v2 e v3, tranne per il fatto che lo spazio dei nomi è passato da GEvent
a
google.maps.event
:
GEvent.addListener(map, 'click', function() {
alert('You clicked the map.');
});
google.maps.event.addListener(map, 'click', function() {
alert('You clicked the map.');
});
Rimozione dei listener di eventi
Per motivi di prestazioni, è meglio rimuovere un gestore di eventi quando non è più necessario. La rimozione di un gestore di eventi funziona allo stesso modo nella versione 2 e
v3:
- Quando crei un listener di eventi, viene restituito un oggetto opaco (GEventListener
nella versione 2, MapsEventListener
nella versione 3).
- Quando vuoi rimuovere il listener di eventi, passa questo oggetto al metodo
removeListener()
(GEvent.removeListener()
nella versione 2 o google.maps.event.removeListener()
nella versione 3) per rimuoverlo.
Ascolto degli eventi DOM
Se vuoi acquisire e rispondere agli eventi DOM (Document Object Model), la versione 3 fornisce il metodo statico google.maps.event.addDomListener()
, equivalente al metodo GEvent.addDomListener()
nella versione 2.
Utilizzare gli argomenti passati negli eventi
Gli eventi della UI spesso passano un argomento evento a cui può accedere
l'ascoltatore di eventi. La maggior parte degli argomenti evento nella versione 3 è stata semplificata per essere più coerente con gli oggetti dell'API. Per maggiori dettagli, consulta la documentazione di riferimento della versione 3.
Non esiste alcun argomento overlay
nei listener di eventi della versione 3. Se registri un evento click
su una mappa v3, il callback si verifica solo quando l'utente fa clic sulla mappa di base. Se devi reagire a questi clic, puoi registrare callback aggiuntivi per gli overlay cliccabili.
// Passes an overlay argument when clicking on a map
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
map.setUIToDefault();
GEvent.addListener(map,'click', function(overlay, latlng) {
if (latlng) {
var marker = new GMarker(latlng);
map.addOverlay(marker);
}
});
// Passes only an event argument
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
google.maps.event.addListener(map, 'click', function(event) {
var marker = new google.maps.Marker({
position: event.latLng,
map: map
});
});
Controlli
L'API Maps JavaScript mostra i controlli dell'interfaccia utente che consentono agli utenti di interagire con la mappa. Puoi utilizzare l'API per personalizzare la visualizzazione di questi controlli.
Modifiche ai tipi di controllo
Con l'API v3 sono state introdotte alcune modifiche ai tipi control
.
- L'API v3 supporta altri
tipi di mappe
, tra cui le mappe del terreno e la possibilità di aggiungere tipi di mappe personalizzate.
- Il controllo gerarchico v2,
GHierarchicalMapTypeControl
, non è più disponibile.
Puoi ottenere un effetto simile utilizzando il controllo
google.maps.MapTypeControlStyle.HORIZONTAL_BAR
.
- Il layout orizzontale fornito da
GMapTypeControl
nella versione 2 non è disponibile nella versione 3.
Aggiunta di controlli alla mappa
Con la versione 2 dell'API Maps JavaScript, aggiungi i controlli alla mappa tramite il metodo addControl()
dell'oggetto mappa. Nella versione 3, anziché accedere o modificare direttamente i controlli,
modifichi l'oggetto MapOptions
associato. L'esempio riportato di seguito mostra come personalizzare la mappa per aggiungere i seguenti controlli:
- pulsanti che consentono all'utente di passare da un tipo di mappa all'altro
- una scala della mappa
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
// Add controls
map.addControl(new GMapTypeControl());
map.addControl(new GScaleControl());
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP,
// Add controls
mapTypeControl: true,
scaleControl: true
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
Controlli di posizionamento sulla mappa
I controlli di posizionamento sono cambiati molto nella versione 3. Nella versione 2, il metodo
addControl()
accetta un secondo parametro facoltativo
che consente di specificare la posizione del controllo rispetto ai
vertici della mappa.
Nella versione 3, imposti la posizione di un controllo tramite la proprietà
position
delle opzioni di controllo. Il posizionamento di questi controlli non è assoluto; l'API li dispone in modo intelligente facendoli "scorrere" attorno agli elementi della mappa esistenti entro determinati vincoli (ad esempio le dimensioni della mappa).
In questo modo, i controlli predefiniti sono compatibili con i tuoi controlli.
Per ulteriori informazioni, consulta Controllare il posizionamento nella versione 3.
Il seguente codice riposiziona i controlli degli esempi precedenti:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
// Add map type control
map.addControl(new GMapTypeControl(), new GControlPosition(
G_ANCHOR_TOP_LEFT, new GSize(10, 10)));
// Add scale
map.addControl(new GScaleControl(), new GControlPosition(
G_ANCHOR_BOTTOM_RIGHT, new GSize(20, 20)));
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP,
// Add map type control
mapTypeControl: true,
mapTypeControlOptions: {
style: google.maps.MapTypeControlStyle.HORIZONTAL_BAR,
position: google.maps.ControlPosition.TOP_LEFT
},
// Add scale
scaleControl: true,
scaleControlOptions: {
position: google.maps.ControlPosition.BOTTOM_RIGHT
}
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
Controlli personalizzati
L'API Maps JavaScript ti consente di creare controlli di navigazione personalizzati.
Per personalizzare i controlli con l'API v2, devi creare una sottoclasse della classe
GControl
e definire i gestori per i metodi
initialize()
e getDefaultPosition()
.
Non esiste un equivalente per la classe GControl
nella versione 3. I controlli vengono invece rappresentati come elementi DOM. Per aggiungere un controllo personalizzato
con l'API v3, crea una struttura DOM per il controllo in un
costruttore come elemento secondario di un Node
(ad es. un
elemento <div>
) e aggiungi ascoltatori di eventi per gestire eventuali
eventi DOM. Inserisci Node
nell'array controls[position]
delle mappe per aggiungere un'istanza del controllo personalizzato alla mappa.
Data un'implementazione della classe HomeControl
che rispetti
i requisiti di interfaccia indicati sopra (per maggiori dettagli, consulta la documentazione relativa ai controlli personalizzati), i seguenti esempi di codice mostrano
come aggiungere un controllo personalizzato a una mappa.
map.addControl(new HomeControl(),
GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(10, 10)));
var homeControlDiv = document.createElement('DIV');
var homeControl = new HomeControl(homeControlDiv, map);
map.controls[google.maps.ControlPosition.TOP_RIGHT].push(
homeControlDiv);
Sovrapposizioni
Gli overlay riflettono gli oggetti che "aggiungi" alla mappa per designare punti, linee, aree o raccolte di oggetti.
Aggiunta e rimozione di overlay
I tipi di oggetti rappresentati da un overlay sono gli stessi tra la versione 2 e la versione 3, ma vengono gestiti in modo diverso.
Gli overlay nell'API v2 sono stati aggiunti e rimossi dalla mappa utilizzando i metodi addOverlay()
e removeOverlay()
dell'oggetto GMap2
. Nella versione 3, assegni una mappa a un overlay tramite la proprietà map
della classe di opzioni di overlay associata.
Puoi anche aggiungere o rimuovere un overlay direttamente chiamando il metodo setMap()
dell'oggetto overlay e specificando la mappa che ti interessa. Se imposti la proprietà mappa su null
, l'overlay viene rimosso.
Nella versione 3 non esiste il metodo clearOverlays()
.
Se vuoi gestire un insieme di overlay, devi creare un array per contenerli. Utilizzando questo array, puoi chiamare
setMap()
su ogni overlay nell'array (passando
null
se devi rimuoverli).
Indicatori spostabili
Per impostazione predefinita, gli indicatori sono cliccabili, ma non possono essere trascinati. I seguenti due esempi aggiungono un indicatore trascinabile:
var myLatLng = new GLatLng(-25.363882, 131.044922);
var map = new GMap2(document.getElementById('map'));
map.setCenter(myLatLng, 4);
var marker = new GMarker(latLng, {
draggable: true
});
map.addOverlay(marker);
var myLatLng = new google.maps.LatLng(-25.363882, 131.044922);
var map = new google.maps.Map(
document.getElementById('map'), {
center: myLatLng,
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var marker = new google.maps.Marker({
position: myLatLng,
draggable: true,
map: map
});
Icone
Puoi definire un'icona personalizzata da mostrare al posto dell'indicatore predefinito.
Per utilizzare un'immagine personalizzata nella versione 2, puoi creare un'istanza GIcon
da G_DEFAULT_ICON type
e modificarla. Se
l'immagine è più grande o più piccola dell'icona predefinita, devi
specificarla con un'istanza GSize
.
L'API v3 semplifica leggermente questa procedura.
Basta impostare la proprietà icon
dell'indicatore sull'URL dell'immagine personalizzata e l'API imposterà automaticamente le dimensioni dell'icona.
L'API Maps JavaScript supporta anche le icone complesse.
Un'icona complessa può includere più riquadri, forme complesse o specificare l'"ordine di impilaggio" di come devono essere visualizzate le immagini rispetto ad altri overlay. Per aggiungere una forma a un indicatore nella versione 2, devi specificare la proprietà aggiuntiva in ogni istanza GIcon
e passarla come opzione a un costruttore GMarker
. Nella versione 3, le icone
specificate in questo modo devono impostare le proprietà icon
su un oggetto di tipo Icon
.
Le ombre degli indicatori non sono supportate nella versione 3.
Gli esempi seguenti mostrano una bandiera da spiaggia a Bondi Beach, in Australia, con la parte trasparente dell'icona non cliccabile:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
map.setUIToDefault();
var flagIcon = new GIcon(G_DEFAULT_ICON);
flagIcon.image = '/images/beachflag.png';
flagIcon.imageMap = [1, 1, 1, 20, 18, 20, 18 , 1];
var bbLatLng = new GLatLng(-33.890542, 151.274856);
map.addOverlay(new GMarker(bbLatLng, {
icon: flagIcon
}));
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var shape = {
coord: [1, 1, 1, 20, 18, 20, 18 , 1],
type: 'poly'
};
var bbLatLng = new google.maps.LatLng(-33.890542, 151.274856);
var bbMarker = new google.maps.Marker({
icon: '/images/beachflag.png'
shape: shape,
position: bbLatLng,
map: map
});
Polilinee
Un polilinea è costituito da un array di LatLng
, oltre a una serie di segmenti che collegano le posizioni in una sequenza ordinata.
La creazione e la visualizzazione di un oggetto Polyline
nella versione 3 è simile
all'utilizzo di un oggetto Polyline
nella versione 2.GPolyline
I seguenti esempi disegnano un polilinea geodetico semitrasparente di 3 pixel di larghezza da Zurigo a Sydney passando per Singapore:
var polyline = new GPolyline(
[
new GLatLng(47.3690239, 8.5380326),
new GLatLng(1.352083, 103.819836),
new GLatLng(-33.867139, 151.207114)
],
'#FF0000', 3, 0.5, {
geodesic: true
});
map.addOverlay(polyline);
var polyline = new google.maps.Polyline({
path: [
new google.maps.LatLng(47.3690239, 8.5380326),
new google.maps.LatLng(1.352083, 103.819836),
new google.maps.LatLng(-33.867139, 151.207114)
],
strokeColor: '#FF0000',
strokeOpacity: 0.5,
strokeWeight: 3,
geodesic: true
});
polyline.setMap(map);
Polilinee codificate
La versione 3 non supporta la creazione di oggetti Polyline
direttamente da polilinee codificate. La libreria di geometria
fornisce invece metodi per codificare e decodificare le polilinee. Per ulteriori informazioni su come caricare questa libreria, consulta la sezione Raccolte nell'API Maps v3.
Gli esempi riportati di seguito disegnano lo stesso polilinea codificato; il codice della versione 3 utilizza il metodo
decodePath()
dello spazio dei nomi
google.maps.geometry.encoding
.
var polyline = new GPolyline.fromEncoded({
points: 'kwb`Huqbs@ztzwGgvpdQbw}uEoif`H',
levels: 'PPP',
zoomFactor: 2,
numLevels: 18,
color: '#ff0000',
opacity: 0.8,
weight: 3
});
map.addOverlay(polyline);
var polyline = new google.maps.Polyline({
path: google.maps.geometry.encoding.decodePath(
'kwb`Huqbs@ztzwGgvpdQbw}uEoif`H'),
strokeColor: '#FF0000',
strokeOpacity: 0.5,
strokeWeight: 3,
});
polyline.setMap(map);
Poligoni
Un poligono definisce una regione all'interno di un circuito chiuso. Molto simile all'oggetto Polyline
, gli oggetti Polygon
sono costituiti da una serie di punti in una sequenza ordinata. La classe Polygon
v3 è molto simile alla classe GPolygon
v2, con la notevole eccezione che non è più necessario ripetere il vertice iniziale alla fine del percorso per chiudere il ciclo. L'API v3 chiude automaticamente tutti i poligoni disegnando un tratto che collega la ultima alla prima coordinata. I seguenti snippet di codice
creano un poligono che rappresenta il triangolo delle Bermude:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(24.886436, -70.268554), 5);
var bermudaTriangle = new GPolygon(
[
new GLatLng(25.774252, -80.190262),
new GLatLng(18.466465, -66.118292),
new GLatLng(32.321384, -64.75737),
new GLatLng(25.774252, -80.190262)
],
'#FF0000', 2, 0.8, '#FF0000', 0.35);
map.addOverlay(bermudaTriangle);
var map = new google.maps.Map(document.getElementById('map'), {
center: new google.maps.LatLng(24.886436, -70.268554),
mapTypeId: google.maps.MapTypeId.TERRAIN,
zoom: 5
});
var bermudaTriangle = new google.maps.Polygon({
paths: [
new google.maps.LatLng(25.774252, -80.190262),
new google.maps.LatLng(18.466465, -66.118292),
new google.maps.LatLng(32.321384, -64.75737)
],
strokeColor: '#FF0000',
strokeWeight: 2,
strokeOpacity: 0.8,
fillColor: '#FF0000',
fillOpacity: 0.35
});
bermudaTriangle.setMap(map);
Forme modificabili dall'utente
È possibile rendere modificabili da parte dell'utente le polilinee e i poligoni. I seguenti snippet di codice
sono equivalenti:
map.addOverlay(polyline);
polyline.enableEditing();
polyline.setMap(map);
polyline.setEditable(true);
Per funzionalità di disegno più avanzate, consulta la libreria di disegni nella documentazione della versione 3.
Finestre di informazioni
Un InfoWindow
mostra i contenuti in una finestra popup sopra la mappa. Esistono alcune differenze fondamentali tra le finestre di informazioni della versione 2 e della versione 3:
- L'API v2 supporta un solo
GInfoWindow
per mappa, mentre
l'API v3 supporta più InfoWindow
simultanei su
ogni mappa.
- La versione 3
InfoWindow
rimarrà aperta quando farai clic sulla mappa. La versione 2 GInfoWindow
si chiude automaticamente quando fai clic sulla mappa. Puoi emulare il comportamento della v2
aggiungendo un ascoltatore click
all'oggetto
Map
.
- L'API v3 non fornisce il supporto nativo per un
InfoWindow
con schede.
Overlay del suolo
Per posizionare un'immagine su una mappa, devi utilizzare un oggetto
GroundOverlay
. Il costruttore di un
GroundOverlay
è essenzialmente lo stesso nella versione 2 e 3: specifica un URL di un'immagine e i relativi confini come
parametri.
L'esempio seguente mostra una mappa antica di Newark, nel New Jersey, come overlay sulla mappa:
var bounds = new GLatLngBounds(
new GLatLng(40.716216, -74.213393),
new GLatLng(40.765641, -74.139235));
var overlay = new GGroundOverlay(
'http://lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
bounds);
map.addOverlay(overlay);
var bounds = new google.maps.LatLngBounds(
new google.maps.LatLng(40.716216, -74.213393),
new google.maps.LatLng(40.765641, -74.139235));
var overlay = new google.maps.GroundOverlay(
'http://lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
bounds);
overlay.setMap(map);
Tipi di mappe
I tipi di mappe disponibili nelle versioni 2 e 3 sono leggermente diversi, ma tutti i tipi di mappe di base sono disponibili in entrambe le versioni dell'API. Per impostazione predefinita, la versione 2 utilizza i riquadri della mappa stradale "dipinta" standard. Tuttavia, la versione 3 richiede di specificare un tipo di mappa
quando si crea un oggetto google.maps.Map
.
Tipi di mappe comuni
I quattro tipi di mappe di base sono disponibili sia nella versione 2 che nella versione 3:
MapTypeId.ROADMAP
(sostituisce G_NORMAL_MAP
)
mostra la visualizzazione della mappa stradale.
MapTypeId.SATELLITE
(sostituisce G_SATELLITE_MAP
)
mostra le immagini satellitari di Google Earth.
MapTypeId.HYBRID
(sostituisce G_HYBRID_MAP
)
mostra una combinazione di viste normali e satellitari.
MapTypeId.TERRAIN
(sostituisce G_PHYSICAL_MAP
)
mostra una mappa fisica basata sulle informazioni del terreno.
Di seguito è riportato un esempio di v2 e v3 che impostano la mappa sulla visualizzazione del terreno:
map.setMapType(G_PHYSICAL_MAP);
map.setMapTypeId(google.maps.MapTypeId.TERRAIN);
La versione 3 dell'API Maps JavaScript ha apportato alcune modifiche anche ai tipi di mappa meno comuni:
- I tessere della mappa per corpi celesti diversi dalla Terra
non sono disponibili come tipi di mappa nell'API v3, ma è possibile accedervi come
tipi di mappa personalizzati come mostrato in
questo esempio.
- Nella versione 3 non è presente un tipo di mappa speciale che sostituisca il tipo
G_SATELLITE_3D_MAP
della versione 2. In alternativa,
puoi integrare il plug-in di Google Earth nelle tue mappe v3 utilizzando
questa
raccolta.
Immagini con zoom massimo
Le immagini satellitari non sono sempre disponibili a livelli di zoom elevati. Se vuoi conoscere il livello di zoom più alto disponibile prima di impostarlo, utilizza la classe google.maps.MaxZoomService
. Questa classe sostituisce il metodo GMapType.getMaxZoomAtLatLng()
della versione 2.
var point = new GLatLng(
180 * Math.random() - 90, 360 * Math.random() - 180);
var map = new GMap2(document.getElementById("map"));
map.setUIToDefault();
map.setCenter(point);
map.setMapType(G_HYBRID_MAP);
map.getCurrentMapType().getMaxZoomAtLatLng(point,
function(response) {
if (response.status) {
map.setZoom(response.zoom);
} else {
alert("Error in Max Zoom Service.");
}
});
var myLatlng = new google.maps.LatLng(
180 * Math.random() - 90, 360 * Math.random() - 180);
var map = new google.maps.Map(
document.getElementById("map"),{
zoom: 0,
center: myLatlng,
mapTypeId: google.maps.MapTypeId.HYBRID
});
var maxZoomService = new google.maps.MaxZoomService();
maxZoomService.getMaxZoomAtLatLng(
myLatlng,
function(response) {
if (response.status == google.maps.MaxZoomStatus.OK) {
map.setZoom(response.zoom);
} else {
alert("Error in Max Zoom Service.");
}
});
Immagini aeree prospettiche
Quando attivi le immagini aeree nella versione 3, i controlli sono simili a quelli della versione 2.GLargeZoomControl3D
, con un controllo aggiuntivo di rotazione per passare tra le direzioni supportate.
Puoi monitorare le città in cui le immagini a 45° sono attualmente disponibili su
questa mappa. Quando sono disponibili immagini a 45°, viene aggiunta un'opzione di sottomenu al pulsante Satellite dell'API Maps.
Livelli
I livelli sono oggetti sulla mappa costituiti da uno o più overlay. Possono essere manipolati come un'unica unità e generalmente riflettono raccolte di oggetti.
Livelli supportati
L'API v3 fornisce l'accesso a diversi livelli. Questi livelli si sovrappongono alla classe GLayer
v2 nelle seguenti aree:
-
L'oggetto
KmlLayer
esegue il rendering degli elementi KML e GeoRSS in overlay v3, fornendo l'equivalente per il livello GeoXml
v2.
- L'oggetto
TrafficLayer
esegue il rendering di un livello che mostra le condizioni del traffico, in modo simile all'overlay GTrafficOverlay
della versione 2.
Questi livelli sono diversi dalla versione 2. Le differenze sono descritte
di seguito. Possono essere aggiunti a una mappa chiamando setMap()
,
passando l'oggetto Map
su cui visualizzare il
livello.
Ulteriori informazioni sui livelli supportati sono disponibili nella documentazione dei livelli.
Livelli KML e GeoRSS
L'API JavaScript di Maps supporta i formati di dati KML e GeoRSS per la visualizzazione di informazioni geografiche. I file KML o GeoRSS devono essere accessibili pubblicamente se vuoi includerli in una mappa. Nella versione 3, questi
formati di dati vengono visualizzati utilizzando un'istanza di KmlLayer
,
che sostituisce l'oggetto GGeoXml
della versione 2.
L'API v3 è più flessibile durante il rendering del KML, consentendoti di eliminare le finestre di informazioni e modificare la risposta al clic. Per ulteriori dettagli, consulta la documentazione relativa ai livelli KML e GeoRSS della versione 3.
Quando viene visualizzato un KmlLayer
, si applicano limitazioni di dimensioni e complessità. Per informazioni dettagliate, consulta la documentazione di KmlLayer.
Gli esempi riportati di seguito mostrano come caricare un file KML.
geoXml = new GGeoXml(
'https://googlearchive.github.io/js-v2-samples/ggeoxml/cta.kml');
map.addOverlay(geoXml);
var layer = new google.maps.KmlLayer(
'https://googlearchive.github.io/js-v2-samples/ggeoxml/cta.kml', {
preserveViewport: true
});
layer.setMap(map);
Il livello di traffico
La versione 3 ti consente di aggiungere informazioni sul traffico in tempo reale (se supportate) alle tue mappe utilizzando l'oggetto TrafficLayer
. Le informazioni sul traffico vengono fornite per l'ora in cui viene effettuata la richiesta. Questi esempi mostrano le informazioni sul traffico per Los Angeles:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(34.0492459, -118.241043), 13);
map.setUIToDefault();
var trafficOptions = {incidents:false};
trafficInfo = new GTrafficOverlay(trafficOptions);
map.addOverlay(trafficInfo);
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(34.0492459, -118.241043),
mapTypeId: google.maps.MapTypeId.ROADMAP,
zoom: 13
});
var trafficLayer = new google.maps.TrafficLayer();
trafficLayer.setMap(map);
A differenza della versione 2, nella versione 3 non sono disponibili opzioni per il costruttore TrafficLayer
. Gli incidenti non sono disponibili nella versione 3.
Servizi
Geocoding
L'API Maps JavaScript fornisce un oggetto geocoder
per
geocodificare gli indirizzi in modo dinamico in base all'input dell'utente. Se vuoi
geocodificare indirizzi statici noti, consulta la documentazione dell'API Geocoding.
L'API Geocoding è stata
oggetto di un upgrade e di un miglioramento significativi, con l'aggiunta di nuove funzionalità e la modifica
della modalità di rappresentazione dei dati.
GClientGeocoder
nell'API v2 forniva due metodi diversi per il geocodificamento in avanti e all'indietro, nonché metodi aggiuntivi per influenzare il modo in cui veniva eseguito il geocodificamento. Al contrario, l'oggetto Geocoder
v3 fornisce solo un metodo geocode()
, che accetta un letterale oggetto contenente i termini di input (sotto forma di un oggetto Geocoding Requests) e un metodo di callback. A seconda che la richiesta contenga un attributo address
di testo o un oggetto LatLng
, l'API Geocoding restituirà una risposta di geocodifica diretta o inversa. Puoi influire sulla modalità di esecuzione della geocodifica passando campi aggiuntivi alla richiesta di geocodifica:
- L'inclusione di un
address
di testo attiva il geocodificamento in avanti,
equivalente alla chiamata del metodo getLatLng()
.
- L'inclusione di un oggetto
latLng
attiva la geocodifica inversa,
equivalente alla chiamata del metodo getLocations()
.
- L'inclusione dell'attributo
bounds
attiva la funzionalità Biasing
del viewport, equivalente alla chiamata del metodo setViewport()
.
- L'inclusione dell'attributo
region
attiva la funzionalità Region
Code Biasing, equivalente alla chiamata del metodo
setBaseCountryCode()
.
Le risposte
di geocodifica nella versione 3 sono molto diverse da quelle della versione 2. L'API v3
sostituisce la struttura nidificata utilizzata dalla versione 2 con una struttura più piatta che
è più facile da analizzare. Inoltre, le risposte della versione 3 sono più dettagliate: ogni risultato ha diversi componenti di indirizzo che aiutano a dare un'idea migliore della risoluzione di ogni risultato.
Il seguente codice prende un indirizzo in formato testo e mostra il primo risultato
della geocodifica:
var geocoder = new GClientGeocoder();
var infoPanel;
var map;
var AccuracyDescription = [
'Unknown accuracy', 'country level accuracy',
'region level accuracy', 'sub-region level accuracy',
'town level accuracy', 'post code level accuracy',
'street level accuracy', 'intersection level accuracy',
'address level accuracy', 'premise level accuracy',
];
function geocode_result_handler(response) {
if (!response || response.Status.code != 200) {
alert('Geocoding failed. ' + response.Status.code);
} else {
var bounds = new GLatLngBounds(new GLatLng(
response.Placemark[0].ExtendedData.LatLonBox.south,
response.Placemark[0].ExtendedData.LatLonBox.west
), new GLatLng(
response.Placemark[0].ExtendedData.LatLonBox.north,
response.Placemark[0].ExtendedData.LatLonBox.east
));
map.setCenter(bounds.getCenter(),
map.getBoundsZoomLevel(bounds));
var latlng = new GLatLng(
response.Placemark[0].Point.coordinates[1],
response.Placemark[0].Point.coordinates[0]);
infoPanel.innerHTML += '<p>1st result is <em>' +
// No info about location type
response.Placemark[0].address +
'</em> of <em>' +
AccuracyDescription[response.Placemark[0].
AddressDetails.Accuracy] +
'</em> at <tt>' + latlng + '</tt></p>';
var marker_title = response.Placemark[0].address +
' at ' + latlng;
map.clearOverlays();
var marker = marker = new GMarker(
latlng,
{'title': marker_title}
);
map.addOverlay(marker);
}
}
function geocode_address() {
var address = document.getElementById('input-text').value;
infoPanel.innerHTML = '<p>Original address: ' + address + '</p>';
geocoder.getLocations(address, geocode_result_handler);
}
function initialize() {
map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(38, 15), 2);
map.setUIToDefault();
infoPanel = document.getElementById('info-panel');
}
var geocoder = new google.maps.Geocoder();
var infoPanel;
var map;
var marker;
function geocode_result_handler(result, status) {
if (status != google.maps.GeocoderStatus.OK) {
alert('Geocoding failed. ' + status);
} else {
map.fitBounds(result[0].geometry.viewport);
infoPanel.innerHTML += '<p>1st result for geocoding is <em>' +
result[0].geometry.location_type.toLowerCase() +
'</em> to <em>' +
result[0].formatted_address + '</em> of types <em>' +
result[0].types.join('</em>, <em>').replace(/_/, ' ') +
'</em> at <tt>' + result[0].geometry.location +
'</tt></p>';
var marker_title = result[0].formatted_address +
' at ' + latlng;
if (marker) {
marker.setPosition(result[0].geometry.location);
marker.setTitle(marker_title);
} else {
marker = new google.maps.Marker({
position: result[0].geometry.location,
title: marker_title,
map: map
});
}
}
}
function geocode_address() {
var address = document.getElementById('input-text').value;
infoPanel.innerHTML = '<p>Original address: ' + address + '</p>';
geocoder.geocode({'address': address}, geocode_result_handler);
}
function initialize() {
map = new google.maps.Map(document.getElementById('map'), {
center: new google.maps.LatLng(38, 15),
zoom: 2,
mapTypeId: google.maps.MapTypeId.HYBRID
});
infoPanel = document.getElementById('info-panel');
}
Directions
La versione 3 dell'API Maps JavaScript sostituisce la classe GDirections
della versione 2 con la classe DirectionsService
per calcolare le indicazioni stradali.
Il metodo route()
nella versione 3 sostituisce entrambi i metodi load()
e loadFromWaypoints()
dell'API v2. Questo metodo accetta un singolo valore letterale dell'oggetto DirectionsRequest
contenente i termini di input e un metodo di callback da eseguire al ricevimento della risposta. In questo letterale oggetto possono essere fornite opzioni,
in modo simile al letterale oggetto GDirectionsOptions
nella versione 2.
Nell'API Maps JavaScript v3, l'attività di invio delle richieste di indicazioni stradali è stata separata dall'attività di elaborazione delle richieste di rendering, che ora viene gestita con la classe DirectionsRenderer
. Puoi associare un oggetto
DirectionsRenderer
a qualsiasi mappa o
DirectionsResult
oggetto tramite i metodi setMap()
e
setDirections()
. Poiché il visualizzatore è un
MVCObject
, rileverà eventuali modifiche alle sue proprietà e
aggiornerà la mappa quando le indicazioni associate sono cambiate.
Il codice seguente mostra come richiedere indicazioni stradali per raggiungere una
località specifica utilizzando percorsi pedonali da un indirizzo. Tieni presente che solo la versione 3 è in grado di fornire indicazioni stradali per i percorsi pedonali allo zoo di Dublino.
var map;
var directions;
var directionsPanel;
function initialize() {
var origin = new google.maps.LatLng(53.348172, -6.297285);
var destination = new google.maps.LatLng(53.355502, -6.30557);
directionsPanel = document.getElementById("route");
map = new GMap2(document.getElementById('map'));
map.setCenter(origin, 10);
map.setUIToDefault();
directions = new GDirections(map, directionsPanel);
directions.loadFromWaypoints(
[origin, destination], {
travelMode: 'G_TRAVEL_MODE_WALKING',
});
}
var map;
var directionsRenderer;
var directionsService = new google.maps.DirectionsService();
function initialize() {
var origin = new google.maps.LatLng(53.348172, -6.297285);
var destination = new google.maps.LatLng(53.355502, -6.30557);
directionsRenderer = new google.maps.DirectionsRenderer();
map = new google.maps.Map(
document.getElementById('map'), {
center: origin,
zoom: 10,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
directionsRenderer.setPanel(document.getElementById("route"));
directionsRenderer.setMap(map);
directionsService.route({
origin: origin,
destination: destination,
travelMode: google.maps.DirectionsTravelMode.WALKING
}, function(result, status) {
if (status == google.maps.DirectionsStatus.OK) {
directionsRenderer.setDirections(result);
}
});
}
Street View
Google Street View fornisce viste interattive a 360 gradi da
località designate all'interno della sua area di copertura. L'API v3 supporta
Street View in modo nativo all'interno del browser, a differenza della v2 che richiedeva
il plug-in Flash® per visualizzare le immagini di Street View.
Le immagini di Street View sono supportate tramite l'utilizzo dell'oggetto
StreetViewPanorama
nella versione 3 o dell'oggetto
GStreetviewPanorama
nella versione 2. Queste classi hanno interface diverse, ma svolgono lo stesso ruolo: collegano il contenitore div
alle immagini di Street View e ti consentono di specificare la posizione e il punto di vista (POV) del panorama di Street View.
function initialize() {
var fenwayPark = new GLatLng(42.345573, -71.098326);
panoramaOptions = {
latlng: fenwayPark,
pov: {
heading: 35,
pitch: 5,
zoom: 1
}
};
var panorama = new GStreetviewPanorama(
document.getElementById('pano'),
panoramaOptions);
GEvent.addListener(myPano, "error", handleNoFlash);
}
function handleNoFlash(errorCode) {
if (errorCode == FLASH_UNAVAILABLE) {
alert('Error: Your browser does not support Flash');
return;
}
}
function initialize() {
var fenway = new google.maps.LatLng(42.345573, -71.098326);
var panoramaOptions = {
position: fenway,
pov: {
heading: 35,
pitch: 5,
zoom: 1
}
};
var panorama = new google.maps.StreetViewPanorama(
document.getElementById('pano'),
panoramaOptions);
}
L'accesso diretto ai dati di Street View è possibile tramite l'oggetto
StreetViewService
nella versione 3 o l'oggetto simile
GStreetviewClient
nella versione 2. Entrambi forniscono interfacce simili per recuperare o verificare la disponibilità dei dati di Street View e consentono di eseguire ricerche per località o ID panorama.
Nella versione 3, Street View è attivo per impostazione predefinita. La mappa verrà visualizzata con un
controllo Pegman di Street View e l'API riutilizzerà il div della mappa per visualizzare
le panoramiche di Street View. Il codice seguente illustra come emulare il comportamento della versione 2 separando i panorami di Street View in un div separato.
var marker;
var panoClient = new GStreetviewClient();
function initialize() {
if (GBrowserIsCompatible()) {
var myPano = new GStreetviewPanorama(
document.getElementById('pano'));
GEvent.addListener(myPano, 'error', handleNoFlash);
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(42.345573, -71.098326), 16);
map.setUIToDefault();
GEvent.addListener(map, 'click', function(overlay, latlng) {
if (marker) {
marker.setLatLng(latlng);
} else {
marker = new GMarker(latlng);
map.addOverlay(marker);
}
var nearestPano = panoClient.getNearestPanorama(
latlng, processSVData);
});
function processSVData(panoData) {
if (panoData.code != 200) {
alert("Panorama data not found for this location.");
}
var latlng = marker.getLatLng();
var dLat = latlng.latRadians()
- panoData.location.latlng.latRadians();
var dLon = latlng.lngRadians()
- panoData.location.latlng.lngRadians();
var y = Math.sin(dLon) * Math.cos(latlng.latRadians());
var x = Math.cos(panoData.location.latlng.latRadians()) *
Math.sin(latlng.latRadians()) -
Math.sin(panoData.location.latlng.latRadians()) *
Math.cos(latlng.latRadians()) * Math.cos(dLon);
var bearing = Math.atan2(y, x) * 180 / Math.PI;
myPano.setLocationAndPOV(panoData.location.latlng, {
yaw: bearing
});
}
function handleNoFlash(errorCode) {
if (errorCode == FLASH_UNAVAILABLE) {
alert('Error: Your browser does not support Flash');
return;
}
}
}
}
// Load the API with libraries=geometry
var map;
var marker;
var panorama;
var sv = new google.maps.StreetViewService();
function radians(degrees) { return Math.PI * degrees / 180.0 };
function initialize() {
panorama = new google.maps.StreetViewPanorama(
document.getElementById("pano"));
map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(42.345573, -71.098326),
mapTypeId: google.maps.MapTypeId.ROADMAP,
zoom: 16
});
google.maps.event.addListener(map, 'click', function(event) {
if (!marker) {
marker = new google.maps.Marker({
position: event.latLng,
map: map
});
} else {
marker.setPosition(event.latLng);
}
sv.getPanoramaByLocation(event.latLng, 50, processSVData);
});
}
function processSVData(panoData, status) {
if (status == google.maps.StreetViewStatus.OK) {
alert("Panorama data not found for this location.");
}
var bearing = google.maps.geometry.spherical.computeHeading(
panoData.location.latLng, marker.getPosition());
panorama.setPano(panoData.location.pano);
panorama.setPov({
heading: bearing,
pitch: 0,
zoom: 1
});
panorama.setVisible(true);
marker.setMap(panorama);
}