Interfejs API Map Google na Wear OS

Dzięki pakietowi Maps SDK na Androida możesz utworzyć aplikację na urządzenie do noszenia, 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 z 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 musisz zaprojektować aplikację pod kątem mniejszego formatu urządzenia do noszenia, aby zoptymalizować jej użyteczność i wydajność.

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

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ć w swojej aplikacji moduł na urządzenia do noszenia, korzystając z przewodnika po Wear OS, i że chcesz teraz dodać mapę do tego modułu.

Dodawanie zależności dla modułu na 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żliwia 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 płytek 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 w swojej aktywności uzyskasz obiekt SwipeDismissFrameLayout, dodaj wywołanie zwrotne i ustaw zachowanie wywołania zwrotnego, aby wykonać niezbędne działanie odrzucenia, jak pokazano poniżej:

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


    public override fun onCreate(savedState: Bundle?) {
        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.
        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)
    }

    // ...
}

      

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:

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))
}

      

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 do noszenia. 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 sterujące interfejsu znikają w trybie otoczenia. Dzięki temu zmniejszysz zużycie energii przez aplikację i zapewnisz spójny wygląd i działanie w porównaniu z innymi aplikacjami na ekranie Ambient, takimi 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 odbierać zmiany stanu trybu nieaktywnego.
8. Skonfiguruj mapę tak, aby obsługiwała tryb otoczenia. Aby to zrobić, ustaw atrybut map:ambientEnabled="true" w pliku układu XML aktywności lub ustaw go programowo, ustawiając GoogleMapOptions.ambientEnabled(true). To ustawienie informuje interfejs API, że musi wstępnie wczytać niezbędne elementy mapy na potrzeby trybu ambient.
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:

class AmbientActivity : AppCompatActivity(), AmbientModeSupport.AmbientCallbackProvider {

    private lateinit var mapFragment: SupportMapFragment

    public override fun onCreate(savedState: Bundle?) {
        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.
        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()
            }
        }
    }
}

      

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 nieaktywnym. Więcej informacji o aktualizowaniu treści i o ogólnych zasadach działania trybu oszczędzania energii znajdziesz w klasie Utrzymywanie widoczności aplikacji.

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 próbna, którą możesz wykorzystać jako punkt wyjścia do stworzenia własnej aplikacji. Przykład pokazuje, 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.

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

Jak zapewnić użytkownikom jak największą wygodę w Twojej 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 ma wpływ na zużycie baterii.