Od 26 maja 2021 r. interfejs Maps JavaScript API w wersji 2 nie jest już dostępny. W efekcie mapy w wersji 2 witryny przestaną działać i będą zwracać błędy JavaScriptu. Aby nadal korzystać z map w swojej witrynie, przejdź na interfejs Maps JavaScript API w wersji 3. Ten przewodnik pomoże Ci przejść przez cały proces.
Przegląd
Każda aplikacja przechodzi nieco inny proces migracji, ale są pewne kroki wspólne dla wszystkich projektów:
- Uzyskaj nowy klucz. Interfejs Maps JavaScript API korzysta teraz z konsoli Google Cloud do zarządzania kluczami. Jeśli nadal używasz klucza w wersji 2, przed rozpoczęciem migracji uzyskaj nowy klucz interfejsu API.
- Zaktualizuj interfejs API Bootstrap. Większość aplikacji wczyta interfejs Maps JavaScript API w wersji 3 za pomocą tego kodu:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
- Zaktualizuj kod. Ilość wymaganych zmian w dużym stopniu zależy od Twojej aplikacji. Typowe zmiany:
- Zawsze uwzględniaj przestrzeń nazw google.maps. W wersji 3 cały kod JavaScript API Map Google jest przechowywany w przestrzeni nazw
google.maps.*
, a nie w globalnej przestrzeni nazw. W ramach tego procesu zmieniły się również nazwy większości obiektów. Na przykład zamiast GMap2
wczytasz teraz google.maps.Map
.
- Usuń wszelkie odwołania do przestarzałych metod. Usunięto wiele metod uniwersalnego przeznaczenia, takich jak
GDownloadURL
i GLog
.
Zastąp tę funkcję bibliotekami narzędziowymi innych firm lub usuń te odwołania z kodu.
- (Opcjonalnie) Dodaj biblioteki do kodu. Wiele funkcji zostało przeniesionych do zewnętrznych bibliotek, aby każda aplikacja mogła wczytywać tylko te części interfejsu API, które będą używane.
- (Opcjonalnie) Skonfiguruj w projekcie środowisko zewnętrzne w wersji 3.
Obiekty zewnętrzne w wersji 3 mogą służyć do weryfikowania kodu za pomocą kompilatora Closure Compiler lub do aktywowania autouzupełniania w IDE.
Dowiedz się więcej o
kompilacji zaawansowanej i elementach Extern.
- Testowanie i powielanie. Na tym etapie masz jeszcze trochę pracy do wykonania, ale mamy dobrą wiadomość: wszystko jest na dobrej drodze, by zacząć korzystać z nowej aplikacji z mapami w wersji 3.
Zmiany w interfejsie Maps JavaScript API w wersji 3
Przed zaplanowaniem migracji warto poznać różnice między interfejsem Maps JavaScript API w wersji 2 i Maps JavaScript API w wersji 3. Najnowsza wersja interfejsu Maps JavaScript API została napisana od podstaw z myślą o nowoczesnych technikach programowania JavaScript, większym wykorzystaniu bibliotek i uproszczonym interfejsie API.
Do interfejsu API dodano wiele nowych funkcji. Zmodyfikowaliśmy lub usunęliśmy kilka znanych funkcji. W tej sekcji omawiamy główne różnice między tymi wersjami.
Oto niektóre zmiany w interfejsie API wersji 3:
- Usprawniona główna biblioteka. Wiele funkcji dodatkowych zostało przeniesionych do bibliotek, co pozwoliło skrócić czas wczytywania i analizy interfejsu API Core, który umożliwia szybkie wczytywanie mapy na dowolnym urządzeniu.
- Zwiększono wydajność kilku funkcji, takich jak renderowanie wielokątów i umieszczanie znaczników.
- Nowe podejście do limitów wykorzystania po stronie klienta mające na celu lepszą obsługę współdzielonych adresów używanych przez mobilne serwery proxy i firmowe zapory sieciowe.
- Dodaliśmy obsługę kilku nowoczesnych przeglądarek i przeglądarek mobilnych. Wyłączono obsługę Internet Explorera 6.
- Usunięto wiele klas pomocniczych do zwykłych obciążeń (
GLog
lub
GDownloadUrl
). Istnieje wiele świetnych bibliotek JavaScript o podobnych funkcjach, takich jak Closure czy jQuery.
- Implementacja Street View HTML5, która będzie ładowana na każdym urządzeniu mobilnym.
- Niestandardowe
panoramy Street View z Twoimi zdjęciami, które umożliwiają Ci udostępnianie
panoram stoków narciarskich, domów na sprzedaż lub innych ciekawych miejsc.
- Dostosowania stylowych map, które umożliwiają zmianę wyświetlania elementów na mapie podstawowej w celu dopasowania do Twojego niepowtarzalnego stylu wizualnego.
- Obsługa kilku nowych usług, takich jak ElevationService i matryca odległości.
- Ulepszone usługi wyznaczania trasy obejmują trasy alternatywne, optymalizację trasy (przybliżone rozwiązania
problemu podróżnego sprzedawcy), wskazówki dojazdu rowerem (z
warstwą rowerową), wskazówki dojazdu transportem publicznym i
wskazówki, które można przeciągać.
- Zaktualizowany format geokodowania, który zapewnia dokładniejsze informacje o atrybucie type niż wartość
accuracy
z interfejsu Geocoding API w wersji 2.
- obsługa wielu okien informacyjnych na jednej mapie,
Twój nowy klucz
Interfejs Maps JavaScript API w wersji 3 wykorzystuje nowy system kluczy z wersji 2. Być może używasz już w swojej aplikacji klucza w wersji 3. W takim przypadku nie musisz wprowadzać żadnych zmian. Aby to sprawdzić, sprawdź parametr key
w adresie URL, z którego wczytujesz interfejs Maps JavaScript API. Jeśli wartość klucza zaczyna się od „ABQIAA”, używasz klucza w wersji 2. Jeśli masz klucz w wersji 2, w ramach migracji musisz uaktualnić go do wersji v3, co spowoduje:
Klucz jest przekazywany podczas wczytywania interfejsu Maps JavaScript API w wersji 3.
Więcej informacji o generowaniu kluczy interfejsu API
Pamiętaj, że jeśli jesteś klientem Google Maps API for Work, możliwe, że zamiast key
możesz używać identyfikatora klienta z parametrem client
. Identyfikatory klientów są nadal obsługiwane w interfejsie Maps JavaScript API w wersji 3 i nie wymagają procesu uaktualniania klucza.
Wczytywanie interfejsu API
Pierwsza modyfikacja kodu, jaką musisz wprowadzić, obejmuje sposób wczytywania interfejsu API. W wersji 2 interfejs Maps JavaScript API wczytuje się za pomocą żądania wysyłanego do: http://maps.google.com/maps
. Jeśli wczytujesz interfejs Maps JavaScript API w wersji 3, musisz wprowadzić te zmiany:
- Wczytaj interfejs API z
//maps.googleapis.com/maps/api/js
- Usuń parametr
file
.
- Zaktualizuj parametr
key
nowym kluczem w wersji 3. Klienci korzystający z interfejsów Google Maps API for Work powinni używać parametru client
.
- (Tylko w przypadku abonamentu Premium) Upewnij się, że parametr
client
jest podany w sposób opisany w
Przewodniku dla programistów, który udostępnia abonament Premium w Google Maps Platform.
- Usuń parametr
v
, aby zażądać najnowszej wersji, lub zmień jego wartość zgodnie ze schematem obsługi wersji 3.
- (Opcjonalnie) Zastąp parametr
hl
wartością language
i zachowaj jego wartość.
- (Opcjonalnie) Dodaj parametr
libraries
, aby wczytywać biblioteki opcjonalne.
W najprostszym przypadku pobieranie w wersji 3 określa tylko parametr klucza interfejsu API:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
Przykład poniżej zawiera żądanie najnowszej wersji interfejsu Maps JavaScript API v2 w języku niemieckim:
<script src="//maps.google.com/maps?file=api&v=2.x&key=YOUR_API_KEY&hl=de"></script>
Przykład poniżej to równoważne żądanie w wersji 3.
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&language=de"></script>
Przedstawiamy przestrzeń nazw google.maps
Prawdopodobnie najbardziej zauważalną zmianą w interfejsie Maps JavaScript API w wersji 3 jest wprowadzenie przestrzeni nazw google.maps
. Interfejs API w wersji 2 domyślnie umieszcza wszystkie obiekty w globalnej przestrzeni nazw, co może powodować konflikty nazw. W wersji 3 wszystkie obiekty znajdują się w przestrzeni nazw google.maps
.
Podczas migracji aplikacji do wersji 3 musisz zmienić kod, aby skorzystać z nowej przestrzeni nazw. Niestety wyszukanie litery „G” i zastępowanie jej ciągiem „google.maps”. Nie zadziała, ale podczas sprawdzania kodu warto zastosować się do reguły. Poniżej znajdziesz kilka przykładów równoważnych klas w wersjach 2 i 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 |
Usuwanie przestarzałego kodu
Interfejs Maps JavaScript API w wersji 3 ma równolegle większości funkcji dostępnych w wersji 2. Niektóre klasy nie są już obsługiwane. W trakcie migracji musisz zastąpić te klasy bibliotekami narzędziowymi innych firm albo usunąć te odwołania z kodu. Istnieje wiele świetnych bibliotek JavaScript o podobnych funkcjach, np. Closure lub jQuery.
Te klasy nie mają równoległego odpowiednika w interfejsie Maps JavaScript API w wersji 3:
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 |
|
Porównanie kodu
Porównajmy 2 proste aplikacje napisane przy użyciu interfejsów API w wersjach 2 i 3.
<!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>
Jak widać, między tymi aplikacjami występuje kilka różnic. Najważniejsze zmiany:
- Zmienił się adres, z którego załadowano interfejs API.
- Metody
GBrowserIsCompatible()
i GUnload()
nie są już wymagane w wersji 3, więc zostały usunięte z interfejsu API.
- Obiekt
GMap2
zostaje zastąpiony przez google.maps.Map
jako centralny obiekt w interfejsie API.
- Właściwości są teraz wczytywane przez klasy opcji. W powyższym przykładzie ustawiliśmy 3 właściwości wymagane do wczytania mapy –
center
, zoom
i mapTypeId
– za pomocą wbudowanego obiektu MapOptions
.
- W wersji 3 domyślny interfejs użytkownika jest domyślnie włączony. Możesz wyłączyć tę opcję, ustawiając wartość właściwości
disableDefaultUI
w obiekcie MapOptions
na wartość Prawda.
Podsumowanie
Masz już jednak przedsmak najważniejszych punktów związanych z migracją z wersji 2 do 3 interfejsu Maps JavaScript API.
Możesz potrzebować więcej informacji, ale będą one zależały od Twojej aplikacji. W kolejnych sekcjach zamieściliśmy instrukcje migracji dotyczące konkretnych przypadków, w których możesz natrafić. Masz też do dyspozycji kilka materiałów, które mogą Ci się przydać podczas uaktualniania.
Jeśli masz problemy lub pytania związane z tym artykułem, kliknij link PRZEŚLIJ OPINIĘ u góry tej strony.
W tej sekcji znajdziesz szczegółowe porównanie najpopularniejszych funkcji interfejsu Maps JavaScript API w wersjach 2 i 3. Każdą sekcję należy czytać oddzielnie. Nie zalecamy zapoznawania się z tym materiałem w całości. Zamiast tego możesz korzystać z tego materiału, aby dostosować proces migracji do poszczególnych przypadków.
- Zdarzenia – rejestrowanie i obsługa zdarzeń.
- Elementy sterujące – sterowanie elementami sterującymi wyświetlanymi na mapie.
- Nakładki – dodawanie i edytowanie obiektów na mapie.
- Typy map – kafelki tworzące mapę bazową.
- Warstwy – dodawanie i edytowanie treści w ramach grupy, np. warstw KML lub natężenia ruchu.
- Usługi – obsługa geokodowania, wskazówek dojazdu lub usług Street View.
Wydarzenia
Model zdarzeń dla interfejsu Maps JavaScript API w wersji 3 jest podobny do tego w wersji 2, ale wiele już się zmieniło.
Nowe zdarzenie obsługi MVC
Interfejs API w wersji 3 dodaje nowy typ zdarzenia, aby odzwierciedlić zmiany stanu MVC. Istnieją teraz 2 rodzaje zdarzeń:
- Zdarzenia użytkownika (takie jak zdarzenia myszy „kliknięcie”) są przesyłane z interfejsu DOM do interfejsu Maps JavaScript API. Zdarzenia te są niezależne i różnią się od standardowych zdarzeń DOM.
- Powiadomienia o zmianie stanu MVC odzwierciedlają zmiany w obiektach interfejsu API Map Google i są nazywane zgodnie z konwencją
property_changed
.
Każdy obiekt interfejsu API Map Google eksportuje pewną liczbę nazwanych zdarzeń. Aplikacje zainteresowane konkretnymi zdarzeniami powinny rejestrować detektory tych zdarzeń i uruchamiać kod po ich otrzymaniu. Ten mechanizm oparty na zdarzeniach jest taki sam w interfejsach Maps JavaScript API w wersjach 2 i 3 z tą różnicą, że przestrzeń nazw uległa zmianie z GEvent
na 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.');
});
Usuwanie detektorów zdarzeń
Ze względu na wydajność najlepiej usunąć detektor zdarzeń, gdy nie jest już potrzebny. Usuwanie detektora zdarzeń działa tak samo w wersjach 2 i 3:
- Gdy utworzysz odbiornik, zwracany jest nieprzezroczysty obiekt (GEventListener w wersji 2, MapsEventListener w wersji 3).
- Jeśli chcesz usunąć detektor zdarzeń, przekaż ten obiekt do metody
removeListener()
(GEvent.removeListener()
w wersji 2 lub google.maps.event.removeListener()
w wersji 3), aby go usunąć.
Odsłuchiwanie zdarzeń DOM
Jeśli chcesz przechwytywać zdarzenia DOM (model obiektu dokumentu) i odpowiadać na nie, wersja 3 udostępnia metodę statyczną google.maps.event.addDomListener()
, która odpowiada metodzie GEvent.addDomListener()
w wersji 2.
Używanie przekazanych argumentów w zdarzeniach
Zdarzenia interfejsu często przekazują argument zdarzenia, do którego detektor zdarzeń ma dostęp. Większość argumentów zdarzeń w wersji 3 została uproszczona, aby była bardziej spójna w porównaniu z obiektami w interfejsie API. (Więcej informacji znajdziesz w dokumentacji wersji 3).
W detektorach zdarzeń w wersji 3 nie ma argumentu overlay
. Jeśli zarejestrujesz zdarzenie click
na mapie w wersji 3, wywołanie zwrotne będzie możliwe tylko wtedy, gdy użytkownik kliknie mapę podstawową. Możesz zarejestrować dodatkowe wywołania zwrotne dla klikalnych nakładek, jeśli chcesz zareagować na te kliknięcia.
// 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
});
});
Opcje
Interfejs Maps JavaScript API wyświetla elementy sterujące interfejsu, które pozwalają użytkownikom na interakcję z mapą. Za pomocą interfejsu API możesz dostosować sposób wyświetlania tych opcji.
Zmiany w typach elementów sterujących
W interfejsie API w wersji 3 wprowadzono pewne zmiany w typach control
.
- Interfejs API w wersji 3 obsługuje dodatkowe typy map, w tym mapy terenu i możliwość dodawania niestandardowych typów map.
- Element sterujący hierarchiczny w wersji 2 (
GHierarchicalMapTypeControl
) nie jest już dostępny.
Podobny efekt możesz uzyskać za pomocą elementu sterującego google.maps.MapTypeControlStyle.HORIZONTAL_BAR
.
- Układ poziomy udostępniony przez
GMapTypeControl
w wersji 2 nie jest dostępny w wersji 3.
Dodawanie elementów sterujących do mapy
Za pomocą interfejsu Maps JavaScript API w wersji 2 możesz dodawać elementy sterujące do mapy za pomocą metody addControl()
obiektu mapy. W wersji 3 zamiast uzyskiwać bezpośredni dostęp do elementów sterujących i ich modyfikować, zmodyfikujesz powiązany obiekt MapOptions
. Poniższy przykład pokazuje, jak dostosować mapę, aby dodać te elementy sterujące:
- przyciski umożliwiające przełączanie się między dostępnymi typami map.
- skalę mapy
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);
Elementy sterujące pozycjonowaniem na mapie
W wersji 3 elementy sterujące pozycjonowaniem znacznie się zmieniły. W wersji 2 metoda addControl()
przyjmuje opcjonalny drugi parametr, który pozwala określić położenie elementu sterującego względem narożników mapy.
W wersji 3 położenie elementu sterującego ustawia się we właściwości position
w opcjach sterujących. Umiejscowienie tych elementów sterujących nie jest bezwzględne. Interfejs API rozmieści je w inteligentny sposób, „obciągając” je wokół istniejących elementów mapy w ramach określonych ograniczeń (takich jak rozmiar mapy).
Dzięki temu domyślne elementy sterujące są zgodne z Twoimi elementami.
Więcej informacji znajdziesz w artykule Kontrola pozycjonowania w wersji 3.
Poniższe przykładowe elementy sterujące umożliwiają zmianę położenia kodu:
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);
Ustawienia niestandardowe
Interfejs Maps JavaScript API umożliwia tworzenie niestandardowych elementów sterujących nawigacją.
Aby dostosować ustawienia za pomocą interfejsu API w wersji 2, musisz podklasyfikować klasę GControl
i zdefiniować moduły obsługi metod initialize()
i getDefaultPosition()
.
Nie ma odpowiednika klasy GControl
w wersji 3. Zamiast tego elementy sterujące są reprezentowane jako elementy DOM. Aby dodać niestandardową kontrolkę za pomocą interfejsu API w wersji 3, utwórz strukturę DOM dla elementu sterującego w konstruktorze jako element podrzędny elementu Node
(np. elementu <div>
) i dodaj detektory zdarzeń do obsługi dowolnych zdarzeń DOM. Wypchnij Node
do tablicy controls[position]
map, aby dodać do mapy instancję niestandardowego elementu sterującego.
Biorąc pod uwagę implementację klasy HomeControl
, która jest zgodna z wymienionymi powyżej wymaganiami interfejsu (szczegóły znajdziesz w dokumentacji niestandardowych elementów sterujących), poniższe przykłady kodu pokazują, jak dodać do mapy niestandardowy element sterujący.
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);
Nakładki reklamowe
Nakładki to obiekty, które „dodasz” do mapy, aby wyznaczyć punkty, linie, obszary lub zbiory obiektów.
Dodawanie i usuwanie nakładek
Typy obiektów reprezentowanych przez nakładkę są takie same w wersjach 2 i 3, ale są obsługiwane inaczej.
Nakładki w interfejsie API w wersji 2 zostały dodane do mapy i usunięte z niej za pomocą metod addOverlay()
i removeOverlay()
obiektu GMap2
. W wersji 3 mapę do nakładki przypisujesz za pomocą właściwości map
powiązanej klasy opcji nakładki.
Możesz też dodać lub usunąć nakładkę bezpośrednio, wywołując metodę setMap()
obiektu nakładki i określając odpowiednią mapę. Ustawienie właściwości mapy na null
powoduje usunięcie nakładki.
W wersji 3 nie ma metody clearOverlays()
.
Jeśli chcesz zarządzać zestawem nakładek, musisz utworzyć tablicę do przechowywania nakładek. Korzystając z tej tablicy, możesz następnie wywołać setMap()
przy każdej nakładce w tablicy (jeśli musisz usunąć nakładkę, przejdź do tablicy null
).
Znaczniki do przeciągania
Domyślnie znaczniki można klikać, ale nie można ich przeciągać. Te 2 przykłady dodają znacznik, który można przeciągać:
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
});
Ikony
Możesz zdefiniować ikonę niestandardową, która będzie wyświetlana w miejscu domyślnego znacznika.
Aby użyć obrazu niestandardowego w wersji 2, możesz utworzyć instancję GIcon
z G_DEFAULT_ICON type
, a następnie ją zmodyfikować. Jeśli obraz jest większy lub mniejszy od ikony domyślnej, musisz go określić za pomocą instancji GSize
.
Interfejs API w wersji 3 nieco upraszcza ten proces.
Wystarczy ustawić właściwość icon
znacznika na adres URL niestandardowego obrazu, a interfejs API automatycznie dostosuje rozmiar ikony.
Interfejs Maps JavaScript API zapewnia również obsługę złożonych ikon.
Złożona ikona może zawierać wiele kafelków lub złożonych kształtów albo określać „kolejność stosu” określającą sposób wyświetlania obrazów w stosunku do innych nakładek. Aby dodać kształt do znacznika w wersji 2, musisz określić dodatkową właściwość w każdym wystąpieniu GIcon
i przekazać ją jako opcję do konstruktora GMarker
. W wersji 3 ikony określone w ten sposób powinny ustawiać właściwości icon
na obiekt typu Icon
.
Cienie znaczników nie są obsługiwane w wersji 3.
W poniższych przykładach widać flagę plażową na plaży Bondi w Australii, a przezroczysta część ikony nie jest klikalna:
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
});
Linie łamane
Linia łamana składa się z tablicy elementów LatLng
oraz serii segmentów łączących te lokalizacje w ustalonej kolejności.
Tworzenie i wyświetlanie obiektu Polyline
w wersji 3 przypomina użycie obiektu GPolyline
w wersji 2. W poniższych przykładach narysowaliśmy półprzezroczystą linię łamaną geodezyjną o szerokości 3 pikseli z Zurychu do Sydney przez Singapur:
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);
Kodowane linie łamane
Wersja 3 nie obsługuje tworzenia obiektów Polyline
bezpośrednio z zakodowanych linii łamanych. Zamiast tego biblioteka geometrii udostępnia metody kodowania i dekodowania linii łamanych. Więcej informacji o wczytywaniu tej biblioteki znajdziesz w sekcji Biblioteki interfejsu API Map Google w wersji 3.
W przykładach poniżej widać tę samą zakodowaną linię łamaną. W kodzie w wersji 3 używamy metody decodePath()
z przestrzeni nazw 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);
Wielokąty
Wielokąt definiuje region w zamkniętej pętli. Podobnie jak obiekt Polyline
, obiekty Polygon
składają się z serii punktów w uporządkowanej kolejności. Klasa Polygon
w wersji 3 jest bardzo podobna do klasy GPolygon
w wersji 2. Różnica polega na tym, że nie trzeba już powtarzać początkowego wierzchołka na końcu ścieżki, aby zamknąć pętlę. Interfejs API w wersji 3 automatycznie zamknie wszystkie wielokąty, rysując linię łączącą ostatnią współrzędną z pierwszą współrzędną. Poniższe fragmenty kodu tworzą wielokąt reprezentujący Trójkąt Bermudzki:
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);
Kształty dostępne do edycji przez użytkownika
Linie łamane i wielokąty można udostępnić do edycji przez użytkownika. Te fragmenty kodu są równoważne:
map.addOverlay(polyline);
polyline.enableEditing();
polyline.setMap(map);
polyline.setEditable(true);
Więcej informacji o zaawansowanych możliwościach rysowania znajdziesz w bibliotece rysunków w dokumentacji wersji 3.
Okna informacyjne
Element InfoWindow
wyświetla zawartość w pływającym oknie nad mapą. Okna informacyjne w wersjach 2 i 3 różnią się między sobą:
- Interfejs API w wersji 2 obsługuje tylko
GInfoWindow
na mapę, a interfejs API v3 obsługuje wiele równoczesnych komponentów InfoWindow
w przypadku każdej mapy.
- Gdy klikniesz mapę,
InfoWindow
w wersji 3 pozostanie otwarty. GInfoWindow
w wersji 2 zamyka się automatycznie po kliknięciu mapy. Możesz emulować działanie wersji 2, dodając odbiornik click
w obiekcie Map
.
- Interfejs API w wersji 3 nie zapewnia natywnej obsługi kart
InfoWindow
.
Warstwy
Aby umieścić obraz na mapie, użyj obiektu GroundOverlay
. Konstruktor elementu GroundOverlay
jest zasadniczo taki sam w wersjach 2 i 3: określa adres URL obrazu i granice obrazu jako parametry.
Poniższy przykład pokazuje, jak zabytkową mapę Newark (NJ) umieszczono na mapie jako nakładkę:
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);
Typy map
Typy map dostępne w wersjach 2 i 3 nieco się różnią, ale wszystkie podstawowe typy map są dostępne w obu wersjach interfejsu API. Domyślnie wersja 2 używa standardowych „malowanych” fragmentów mapy drogowej. Wersja 3 wymaga jednak, aby podczas tworzenia obiektu google.maps.Map
podać określony typ mapy.
Popularne typy map
Cztery podstawowe typy map są dostępne zarówno w wersji 2, jak i 3:
MapTypeId.ROADMAP
(zamiast G_NORMAL_MAP
) to widok mapy drogowej.
MapTypeId.SATELLITE
(zamiast G_SATELLITE_MAP
) wyświetla zdjęcia satelitarne z Google Earth.
MapTypeId.HYBRID
(zastępuje G_HYBRID_MAP
) pokazuje zarówno widok normalny, jak i widok satelitarny.
MapTypeId.TERRAIN
(zamiast G_PHYSICAL_MAP
) wyświetla fizyczną mapę na podstawie informacji o ukształtowaniu terenu.
Poniżej znajduje się przykład wykorzystania wersji 2 oraz 3 ustawienia mapy na widok terenu:
map.setMapType(G_PHYSICAL_MAP);
map.setMapTypeId(google.maps.MapTypeId.TERRAIN);
W interfejsie Maps JavaScript API w wersji 3 wprowadzono też kilka zmian w mniej popularnych typach map:
- Kafelki map ciał niebieskich innych niż Ziemia nie są dostępne jako typy map w interfejsie API w wersji 3, ale można uzyskać do nich dostęp w postaci niestandardowych typów map, jak pokazano w tym przykładzie.
- W wersji 3 nie ma specjalnego typu mapy, który zastąpiłby typ
G_SATELLITE_3D_MAP
z wersji 2. Zamiast tego możesz zintegrować wtyczkę Google Earth z mapami w wersji 3, korzystając z tej biblioteki.
Zdjęcia z maksymalnym powiększeniem
Zdjęcia satelitarne nie zawsze są dostępne przy dużym poziomie powiększenia. Jeśli przed ustawieniem poziomu powiększenia chcesz poznać największy dostępny poziom powiększenia, użyj klasy google.maps.MaxZoomService
. Ta klasa zastępuje metodę GMapType.getMaxZoomAtLatLng()
z wersji 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.");
}
});
Zdjęcia z perspektywy z lotu ptaka
Po włączeniu zdjęć lotniczych w wersji 3 elementy sterujące są podobne do opcji GLargeZoomControl3D
w wersji 2, z dodatkową opcją obracania reklamy pełnoekranowej umożliwiającej obracanie widoku w obsługiwanych kierunkach.
Na tej mapie możesz śledzić miasta, w których obecnie dostępne są zdjęcia sferyczne. Gdy zdjęcia pod kątem 45° są dostępne, do przycisku Maps API zmienia się w podmenu.
Warstwy
Warstwy to obiekty na mapie, które składają się z co najmniej 1 nakładki. Można ich używać jako pojedynczej jednostki i zwykle odzwierciedla ona zbiory obiektów.
Obsługiwane warstwy
Interfejs API w wersji 3 zapewnia dostęp do kilku różnych warstw. Te warstwy pokrywają się z klasą GLayer
w wersji 2 w tych obszarach:
-
Obiekt
KmlLayer
renderuje elementy KML i GeoRSS w postaci nakładek w wersji 3, co zapewnia odpowiednik warstwy GeoXml
w wersji 2.
- Obiekt
TrafficLayer
renderuje warstwę przedstawiającą warunki na drodze, podobną do nakładki GTrafficOverlay
w wersji 2.
Te warstwy różnią się od wersji 2. Różnice opisujemy poniżej. Można je dodawać do mapy, wywołując setMap()
, przekazując mu obiekt Map
, w którym ma być wyświetlana warstwa.
Więcej informacji o obsługiwanych warstwach znajdziesz w dokumentacji warstw.
Warstwy KML i GeoRSS
Interfejs Maps JavaScript API obsługuje formaty danych KML i GeoRSS w celu wyświetlania informacji geograficznych. Jeśli chcesz uwzględnić na mapie pliki KML lub GeoRSS, muszą być dostępne publicznie. W wersji 3 te formaty danych są wyświetlane za pomocą instancji KmlLayer
, która zastępuje obiekt GGeoXml
z wersji 2.
Interfejs API w wersji 3 jest bardziej elastyczny podczas renderowania pliku KML, umożliwiając pomijanie systemu InfoWindows i modyfikowanie odpowiedzi kliknięcia. Więcej informacji znajdziesz w dokumentacji warstw KML i GeoRSS w wersji 3.
Podczas renderowania elementu KmlLayer
obowiązują ograniczenia dotyczące rozmiaru i złożoności. Więcej informacji znajdziesz w dokumentacji KmlLayer.
Poniższe przykłady pokazują, jak wczytać plik 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);
Warstwa Ruch
Wersja 3 umożliwia dodawanie do map informacji o natężeniu ruchu w czasie rzeczywistym (tam, gdzie są obsługiwane) za pomocą obiektu TrafficLayer
. Informacje o ruchu są podawane dla momentu, w którym zostało wysłane żądanie. Te przykłady pokazują informacje o natężeniu ruchu w Gdańsku:
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);
W przeciwieństwie do wersji 2 w wersji 3 konstruktor TrafficLayer
nie ma żadnych opcji. Incydenty nie są dostępne w wersji 3.
Usługi
Geokodowanie
Interfejs Maps JavaScript API udostępnia obiekt geocoder
do geokodowania adresów dynamicznie na podstawie danych wejściowych użytkownika. Jeśli chcesz geokodować statyczne, znane adresy, zapoznaj się z dokumentacją Geocoding API.
Interfejs Geocoding API został znacznie uaktualniony i ulepszony. Dodaliśmy nowe funkcje oraz zmieniliśmy sposób prezentowania danych.
GClientGeocoder
w interfejsie API w wersji 2 udostępnia 2 różne metody geokodowania do przodu i do tyłu, a także dodatkowe metody wpływania na sposób wykonywania geokodowania. W przeciwieństwie do tego obiekt Geocoder
w wersji 3 udostępnia tylko metodę geocode()
, która pobiera literał obiektu zawierający terminy wejściowe (w postaci obiektu żądań geokodowania) i metodę wywołania zwrotnego. W zależności od tego, czy żądanie zawiera tekstowy atrybut address
czy obiekt LatLng
, interfejs Geocoding API zwróci odpowiedź na odwrotne lub do przodu. Możesz wpłynąć na sposób wykonywania geokodowania, przekazując do żądania geokodowania dodatkowe pola:
- Dodanie tekstowego elementu
address
aktywuje geokodowanie do przodu, co odpowiada wywołaniu metody getLatLng()
.
- Dodanie obiektu
latLng
aktywuje odwrotne geokodowanie, co odpowiada wywołaniu metody getLocations()
.
- Dodanie atrybutu
bounds
włącza promowanie widocznego obszaru, co odpowiada wywołaniu metody setViewport()
.
- Dodanie atrybutu
region
włącza promowanie kodu regionalnego, co odpowiada wywołaniu metody setBaseCountryCode()
.
Odpowiedzi geokodowane w wersji 3 bardzo różnią się od odpowiedzi w wersji 2. Interfejs API w wersji 3 zastępuje zagnieżdżoną strukturę, której używa wersja 2, prostszą strukturą, która jest łatwiejsza do analizowania. Poza tym odpowiedzi w wersji 3 są bardziej szczegółowe: każdy wynik ma kilka komponentów adresu, które dają lepsze pojęcie o rozdzielczości każdego wyniku.
Poniższy kod pobiera adres tekstowy i wyświetla pierwszy wynik po jego geokodowaniu:
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');
}
Instrukcje
Interfejs Maps JavaScript API w wersji 3 zastępuje klasę GDirections
z wersji 2 klasą DirectionsService
do obliczania wskazówek.
Metoda route()
w wersji 3 zastępuje zarówno metody load()
, jak i loadFromWaypoints()
z interfejsu API w wersji 2. Ta metoda przyjmuje pojedynczy literał obiektu DirectionsRequest
zawierający hasła wejściowe i metodę wywołania zwrotnego do wykonania po otrzymaniu odpowiedzi. Do tego literału obiektu można podać opcje podobnie do literału obiektu GDirectionsOptions
w wersji 2.
W interfejsie Maps JavaScript API w wersji 3 zadanie przesyłania żądań wskazówek dojazdu zostało oddzielone od zadania renderowania, które jest teraz obsługiwane za pomocą klasy DirectionsRenderer
. Możesz powiązać obiekt DirectionsRenderer
z dowolną mapą lub obiektem DirectionsResult
za pomocą metod setMap()
i setDirections()
. Mechanizm renderowania to MVCObject
, więc wykryje wszelkie zmiany jego właściwości i zaktualizuje mapę, gdy zmienią się powiązane wskazówki.
Poniższy kod pokazuje, jak uzyskać z danego adresu trasę pieszą do określonej lokalizacji przy użyciu ścieżek dla pieszych. Pamiętaj, że tylko wersja 3 może wyświetlać trasy piesze na ścieżce pieszej w dublińskim zoo.
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 oferuje interaktywne, 360-stopniowe widoki z wyznaczonych miejsc na danym obszarze. Interfejs API w wersji 3 bezpośrednio obsługuje funkcję Street View w przeglądarce, w odróżnieniu od wersji 2, która do wyświetlania zdjęć Street View wymaga wtyczki Flash®.
W wersji 3 obrazy Street View są obsługiwane przez obiekt StreetViewPanorama
, a w wersji 2 obiekt GStreetviewPanorama
. Te klasy mają różne interfejsy, ale pełnią tę samą rolę: umożliwiają połączenie kontenera div
ze zdjęciami Street View oraz określenie lokalizacji i punktu widzenia (punktu widzenia) panoramy 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);
}
Bezpośredni dostęp do danych Street View jest możliwy za pomocą obiektu StreetViewService
w wersji 3 lub podobnego obiektu GStreetviewClient
w wersji 2. Oba interfejsy mają podobny interfejs do pobierania lub sprawdzania dostępności danych Street View i umożliwiają wyszukiwanie według lokalizacji lub identyfikatora panoramy.
W wersji 3 funkcja Street View jest domyślnie włączona. Mapa wyświetli się z elementem sterującym Pegmana w Street View, a interfejs API będzie ponownie używać elementu div mapy do wyświetlania panoram Street View. Poniższy kod pokazuje, jak emulować działanie wersji v2 przez rozdzielenie panoram Street View w osobny element div.
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);
}