Interfejs API Map Google na Wear OS

Dzięki pakietowi Maps SDK na Androida możesz utworzyć aplikację na urządzenia noszące, która działa bezpośrednio na urządzeniach z Wear OS by Google. Użytkownicy aplikacji mogą zobaczyć swoją lokalizację na mapie, zerkając na nadgarstok. Mogą na przykład wyświetlić swoją pozycję na trasie, a następnie powiększyć widok, aby zobaczyć szczegóły, lub kliknąć znacznik, aby wyświetlić okno z informacjami udostępniane przez aplikację.

Na tej stronie opisaliśmy funkcje interfejsu API dostępne na urządzeniu Wear OS oraz ułatwiliśmy Ci rozpoczęcie tworzenia aplikacji.

Pierwsze kroki na Wear OS

Tworzenie aplikacji na urządzenia noszące z pakietem Maps SDK na Androida jest zasadniczo takie samo jak tworzenie aplikacji Mapy Google na dowolne inne urządzenie z Androidem. Różnica polega na tym, że projekt musi być dostosowany do mniejszego formatu urządzenia do noszenia, aby zoptymalizować użyteczność i wydajność aplikacji.

Android Studio to zalecane narzędzie do tworzenia aplikacji na Wear OS, ponieważ umożliwia konfigurowanie projektu, dodawanie bibliotek i pakowanie aplikacji.

Ogólne wskazówki dotyczące projektowania aplikacji na urządzenia noszące znajdziesz w wytycznych dotyczących projektowania aplikacji na Wear OS. Aby uzyskać pomoc w tworzeniu pierwszej aplikacji na urządzenie noszące, zapoznaj się z przewodnikiem Tworzenie aplikacji na urządzenia noszące.

Tworzenie pierwszej aplikacji map na Wear OS

W tym krótkim przewodniku zakładamy, że znasz pakiet Maps SDK na Androida, że wiesz, jak utworzyć moduł na urządzenia noszące, korzystając z przewodnika po Wear OS, i że chcesz teraz dodać mapę do tego modułu.

Dodawanie zależności dla modułu Wear

Upewnij się, że w pliku build.gradle.kts w module aplikacji na Wear OS znajdują się te zależności:

dependencies {
    // ...
    compileOnly("com.google.android.wearable:wearable:2.9.0")
    implementation("com.google.android.support:wearable:2.9.0")
    implementation("com.google.android.gms:play-services-maps:19.0.0")

    // This dependency is necessary for ambient mode
    implementation("androidx.wear:wear:1.3.0")
}

Więcej informacji o zależnościach znajdziesz w przewodniku Dodawanie modułu Wear OS do istniejącego projektu.

Wdrażanie gestu przesunięcia w bok w celu zamknięcia i ustawienie początkowego koloru tła

Zalecamy wyświetlanie mapy na urządzeniu do noszenia za pomocą SwipeDismissFrameLayout. Za pomocą klasy SwipeDismissFrameLayout możesz wdrożyć gest przesuń, aby zamknąć, który umożliwi użytkownikom zamykanie aplikacji przez przesunięcie palcem od lewej krawędzi ekranu.

Aby ustawić niestandardowy początkowy kolor tła, użyj atrybutu XML map:backgroundColor, aby określić kolor, który ma być wyświetlany do momentu załadowania się rzeczywistych kafelków mapy.

Dodaj do definicji układu elementy SwipeDismissFrameLayout i backgroundColor jako element kontenera SupportMapFragment:

  <androidx.wear.widget.SwipeDismissFrameLayout
      android:id="@+id/map_container"
      android:layout_width="match_parent"
      android:layout_height="match_parent">
    <fragment
        android:id="@+id/map"
        android:name="com.google.android.gms.maps.SupportMapFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        map:backgroundColor="#fff0b2dd" />
  </androidx.wear.widget.SwipeDismissFrameLayout>

Gdy uzyskasz obiekt SwipeDismissFrameLayout w swojej aktywności, dodaj wywołanie zwrotne i ustaw zachowanie wywołania zwrotnego, aby wykonać niezbędne działanie usuwania, jak pokazano poniżej:

Kotlin

class MainActivity : AppCompatActivity(), OnMapReadyCallback,
                     AmbientModeSupport.AmbientCallbackProvider {


    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        val controller = AmbientModeSupport.attach(this)
        Log.d(MainActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        val mapFrameLayout = findViewById<SwipeDismissFrameLayout>(R.id.map_container)
        mapFrameLayout.addCallback(object : SwipeDismissFrameLayout.Callback() {
            override fun onDismissed(layout: SwipeDismissFrameLayout) {
                onBackPressed()
            }
        })

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    // ...
}

      

Java

public class MainActivity extends AppCompatActivity implements OnMapReadyCallback,
    AmbientModeSupport.AmbientCallbackProvider {


    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
        Log.d(MainActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        final SwipeDismissFrameLayout mapFrameLayout = (SwipeDismissFrameLayout) findViewById(
            R.id.map_container);
        mapFrameLayout.addCallback(new SwipeDismissFrameLayout.Callback() {
            @Override
            public void onDismissed(SwipeDismissFrameLayout layout) {
                onBackPressed();
            }
        });

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager()
            .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    // ...
}

      

Dodawanie mapy

Aby uzyskać uchwyt do obiektu GoogleMap, użyj zwykłej metody wywołania zwrotnego onMapReady(GoogleMap). Wywołanie zwrotne jest wywoływane, gdy mapa jest gotowa do użycia. W metodzie wywołania możesz dodawać do mapy znaczniki lub linie złożone, dodawać słuchaczy lub przesuwać kamerę. Przykład poniżej pokazuje dodanie znacznika w pobliżu opery w Sydney:

Kotlin

private val sydney = LatLng(-33.85704, 151.21522)

override fun onMapReady(googleMap: GoogleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(
        MarkerOptions().position(sydney)
            .title("Sydney Opera House")
    )

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(sydney, 10f))
}

      

Java

private static final LatLng SYDNEY = new LatLng(-33.85704, 151.21522);

@Override
public void onMapReady(@NonNull GoogleMap googleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(new MarkerOptions().position(SYDNEY)
        .title("Sydney Opera House"));

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(SYDNEY, 10));
}

      

Włączanie trybu nieaktywnego

Pakiet SDK Map na Androida obsługuje tryb ambient w aplikacjach na urządzenia noszące. Aplikacje obsługujące tryb dźwięków otoczenia są czasami nazywane aplikacją zawsze włączoną. Tryb nieaktywny jest uruchamiany, gdy użytkownik przestaje aktywnie korzystać z aplikacji, i pozwala aplikacji pozostać widocznej na urządzeniu do noszenia.

Pakiet SDK Map na Androida zapewnia uproszczone renderowanie mapy w małej ilości kolorów na potrzeby trybu ambient. Styl mapy dostosowuje się automatycznie, gdy urządzenie przełączy się z trybu interaktywnego na tryb ambient. Wszystkie znaczniki, obiekty i elementy interfejsu znikają w trybie otoczenia. Dzięki temu zmniejszysz zużycie energii przez aplikację i zapewnisz spójny wygląd i działanie innych aplikacji takich jak tarcze zegarka.

Aby mieć pewność, że Twoja aplikacja korzysta z trybu nieaktywnej mapy:

1. Zaktualizuj pakiet SDK Androida, aby uwzględniał platformę Androida 6.0 (poziom interfejsu API 23) lub nowszą, która udostępnia interfejsy API umożliwiające przechodzenie aktywności w tryb tła. Informacje o aktualizowaniu pakietu SDK znajdziesz w dokumentacji Androida dotyczącej dodawania pakietów SDK.
2. Upewnij się, że Twój projekt jest kierowany na Androida 6.0 lub nowszego, ustawiając w pliku manifestu aplikacji parametr targetSdkVersion na 23 lub wyższy.
3. Dodaj zależności dotyczące urządzeń noszonych do pliku build.gradle.kts aplikacji. Zobacz przykład na tej stronie.
4. Dodaj wpis w zasobach wspólnych urządzenia do noszenia do pliku manifestu aplikacji na urządzenie do noszenia, zgodnie z opisem w szkoleniu na temat Androida dotyczącym utrzymywania widoczności aplikacji.
5. Dodaj uprawnienia WAKE_LOCK do plików manifestów aplikacji na urządzenia ręczne i na urządzenia noszące, zgodnie z instrukcjami podanymi w szkoleniu na temat Androida dotyczącym utrzymywania widoczności aplikacji.
6. W metodzie onCreate() aktywności wywołaj metodę AmbientModeSupport.attach(). Informuje to system operacyjny, że aplikacja jest zawsze włączona, więc po wyłączeniu urządzenia powinna przejść w tryb ambient, a nie wracać do tarczy zegarka.
7. W swojej aktywności zaimplementuj interfejs AmbientModeSupport.AmbientCallbackProvider, aby mogła ona otrzymywać zmiany stanu trybu nieaktywnego.
8. Skonfiguruj mapę, aby obsługiwała tryb ambient. Możesz to zrobić, ustawiając atrybut map:ambientEnabled="true" w pliku układu XML aktywności lub programowo, ustawiając GoogleMapOptions.ambientEnabled(true). To ustawienie informuje interfejs API, że musi wstępnie wczytać niezbędne kafelki mapy do użytku w trybie otoczenia.
9. Gdy aktywność przełączy się na tryb nieaktywny, system wywoła metodę onEnterAmbient() w AmbientCallback podanym przez Ciebie pakiecie. Zastąpić onEnterAmbient() i wywołać funkcję SupportMapFragment.onEnterAmbient(ambientDetails) lub MapView.onEnterAmbient(ambientDetails). Interfejs API przełącza się na nieinteraktywną mapę z niskim nasycenie kolorów.
10. Podobnie w kolumnie onExitAmbient() wpisz SupportMapFragment.onExitAmbient() lub MapView.onExitAmbient(). Interfejs API przełącza się na normalne renderowanie mapy.

Ten przykładowy kod włącza tryb ambient w aktywności:

Kotlin

class AmbientActivity : AppCompatActivity(), AmbientModeSupport.AmbientCallbackProvider {

    private lateinit var mapFragment: SupportMapFragment

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        val controller = AmbientModeSupport.attach(this)
        Log.d(AmbientActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
    }

    override fun getAmbientCallback(): AmbientModeSupport.AmbientCallback {
        return object : AmbientModeSupport.AmbientCallback() {
            /**
             * Starts ambient mode on the map.
             * The API swaps to a non-interactive and low-color rendering of the map when the user is no
             * longer actively using the app.
             */
            override fun onEnterAmbient(ambientDetails: Bundle) {
                super.onEnterAmbient(ambientDetails)
                mapFragment.onEnterAmbient(ambientDetails)
            }

            /**
             * Exits ambient mode on the map.
             * The API swaps to the normal rendering of the map when the user starts actively using the app.
             */
            override fun onExitAmbient() {
                super.onExitAmbient()
                mapFragment.onExitAmbient()
            }
        }
    }
}

      

Java

public class AmbientActivity extends AppCompatActivity implements
    AmbientModeSupport.AmbientCallbackProvider {

    private SupportMapFragment mapFragment;

    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
        Log.d(AmbientActivity.class.getSimpleName(), "Is ambient enabled: " + controller.isAmbient());

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager()
            .findFragmentById(R.id.map);
    }

    @Override
    public AmbientCallback getAmbientCallback() {
        return new AmbientCallback() {
            /**
             * Starts ambient mode on the map.
             * The API swaps to a non-interactive and low-color rendering of the map when the user is no
             * longer actively using the app.
             */
            @Override
            public void onEnterAmbient(Bundle ambientDetails) {
                super.onEnterAmbient(ambientDetails);
                mapFragment.onEnterAmbient(ambientDetails);
            }

            /**
             * Exits ambient mode on the map.
             * The API swaps to the normal rendering of the map when the user starts actively using the app.
             */
            @Override
            public void onExitAmbient() {
                super.onExitAmbient();
                mapFragment.onExitAmbient();
            }
        };
    }
}

      

Możesz zaktualizować ekran, gdy aplikacja jest w trybie oszczędzania energii. Więcej informacji o aktualizowaniu treści i ogólnych zasadach działania trybu ambient znajdziesz w klasie zajęciach szkoleniowych na temat Androida.

Korzystanie z Street View na Wear OS

Street View jest w pełni obsługiwane na urządzeniach do noszenia.

Aby umożliwić użytkownikom wyjście z aplikacji podczas oglądania panoramy Street View, użyj interfejsu StreetViewPanorama.OnStreetViewPanoramaLongClickListener, aby wykrywać długie kliknięcia. Gdy użytkownik kliknie i przytrzyma w jakimś miejscu obraz w Street View, otrzymasz zdarzenie onStreetViewPanoramaLongClick(StreetViewPanoramaOrientation). Wybierz DismissOverlayView.show(), aby wyświetlić przycisk wyjścia.

Przykładowy kod

Na GitHub jest dostępna aplikacja przykładowa, której możesz użyć jako punktu wyjścia. Pokazuje ona, jak skonfigurować podstawowe Mapy Google na Wear OS.

Obsługiwane funkcje interfejsu API Map Google na Wear OS

W tej sekcji opisano różnice w obsługiwanych funkcjach map na urządzeniach do noszenia w porównaniu z urządzeniami przenośnymi (telefony i tablety). Wszystkie funkcje interfejsu API, które nie są wymienione poniżej, powinny działać zgodnie z dokumentacją pełnego interfejsu API.

Funkcje
Tryb w pełni interaktywny i tryb uproszczony	Pakiet Maps SDK na Androida możesz używać w trybie w pełni interaktywnym lub w trybie uproszczonym. Rozważ użycie trybu lite, jeśli chcesz zoptymalizować działanie urządzenia noszonego, a Twoja aplikacja nie musi obsługiwać interakcji takich jak gesty czy przesuwanie i powiększanie mapy. W trybie uproszczonym, gdy użytkownik kliknie mapę, zamiar uruchomienia aplikacji mobilnej Mapy Google jest wyłączony i nie można go włączyć na urządzeniu do noszenia. Pełną listę różnic między trybem uproszczonym a trybem w pełni interaktywnym znajdziesz w dokumentacji dotyczącej trybu lite.
Pasek narzędzi mapy	Pasek narzędzi mapy jest wyłączony i nie można go włączyć na urządzeniu do noszenia.
Elementy sterujące w interfejsie	Opcje w interfejsie są domyślnie wyłączone na urządzeniach do noszenia. Dotyczy to elementów sterujących powiększeniem, kompasem i moją lokalizacją. Możesz je włączyć, korzystając z klasy UiSettings jak zwykle.
Gesty	Gesty jednodotykowe działają zgodnie z oczekiwaniami. Przykłady: dotknij i przeciągnij, aby przesuwać mapę, kliknij dwukrotnie, aby powiększyć, i kliknij 2 palcami, aby pomniejszyć. Obsługa gestów wielodotykowych zależy od urządzenia użytkownika. Przykłady gestów wielodotykowych: naciśnięcie 2 palcami, aby pochylić mapę, ściśnięcie palców, aby powiększyć widok, i obrócenie 2 palcami.
Mapy obiektów i budynków	Mapy obiektów są domyślnie wyłączone na urządzeniu do noszenia. Aby je włączyć, zadzwoń pod numer GoogleMap.setIndoorEnabled(true). Jeśli mapy wnętrz są włączone, mapa będzie wyświetlać domyślny poziom piętra. Element interfejsu wybierania poziomu nie jest obsługiwany na urządzeniach noszonych.
Nakładki z kafelkami	Nakładki na kafelki nie są obsługiwane na urządzeniach do noszenia.

Sprawdzone metody tworzenia aplikacji z wykorzystaniem interfejsu Map API na Wear OS

Jak zapewnić użytkownikom jak największą wygodę w aplikacji:

• Mapa powinna zajmować dużą część ekranu. Jest to konieczne, aby zoptymalizować użyteczność mapy na małym urządzeniu do noszenia.
• Podczas projektowania interfejsu aplikacji weź pod uwagę fakt, że urządzenie do noszenia ma słabą baterię. Utrzymywanie ekranu w stanie aktywnym i widocznej mapy wpłynie na wydajność baterii.