Interfejs API Map Google na Wear OS

Za pomocą pakietu Maps SDK na Androida możesz utworzyć aplikację do noszenia opartą na mapie. która działa bezpośrednio na urządzeniach z Wear OS by Google. Użytkownicy Twojej aplikacji może wyświetlić swoją lokalizację na mapie, patrząc na nadgarstki. Mogą sprawdzić ich pozycję na trasie, a następnie powiększyć widok, aby uzyskać szczegóły, lub kliknąć aby zobaczyć okno informacyjne dostarczone przez Twoją aplikację.

Na tej stronie opisujemy funkcje interfejsu API dostępne na urządzeniach do Wear oraz pomaga rozpocząć tworzenie aplikacji.

Pierwsze kroki na Wear OS

Tworzenie aplikacji do noszenia przy użyciu pakietu Maps SDK na Androida tak samo jak tworzenie aplikacji Mapy Google na inne urządzenie z Androidem. Różnica jest odpowiedni dla mniejszego konstrukcji urządzenia do noszenia. optymalizować łatwość obsługi i wydajność aplikacji.

Narzędziem zalecanym do tworzenia aplikacji na Wear OS jest Android Studio. Zapewnia on konfigurację projektu, włączenie biblioteki i ułatwienia w tworzeniu pakietów.

Ogólną pomoc w projektowaniu aplikacji do noszenia znajdziesz tutaj: Wytyczne projektowe dla Wear OS Aby uzyskać pomoc przy tworzeniu pierwszej aplikacji do noszenia, przeczytaj przewodnik tworzenia takich aplikacji.

Tworzenie pierwszej aplikacji z mapami na Wear OS

W tym krótkim przewodniku zakładamy, że znasz pakiet Maps SDK na Androida, wykonanie czynności opisanych w przewodnikach dotyczących Wear OS, aby utworzyć moduł do noszenia w aplikacji i że chcesz dodać mapę do modułu do noszenia.

Dodaję zależności modułu Wear

Sprawdź, czy plik build.gradle.kts zawiera te zależności modułu Wear OS aplikacji:

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ł Wear OS w istniejącym projekcie

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

Do wyświetlania mapy zalecamy korzystanie z: SwipeDismissFrameLayout urządzenie do noszenia. Za pomocą zajęć SwipeDismissFrameLayout możesz: zaimplementuj gest swipe-to-dimiss, dając użytkownikom aby wyjść z aplikacji, przesuń palcem od lewej krawędzi ekranu.

Aby ustawić niestandardowy początkowy kolor tła, użyj pliku XML map:backgroundColor w celu określenia koloru do wyświetlenia do momentu wczytania rzeczywistych fragmentów mapy.

Dodaj do układu elementy SwipeDismissFrameLayout i backgroundColor definicja jako kontener tabeli 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 zdobędziesz obiekt SwipeDismissFrameLayout, dodaj do aktywności wywołanie zwrotne i ustawić działanie wywołania zwrotnego w celu wykonania niezbędnego odrzucenia, działanie jak 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 to zrobić, użyj metody wywołania zwrotnego onMapReady(GoogleMap) w zwykły sposób: aby uzyskać uchwyt do obiektu GoogleMap. Oddzwanianie to uruchamianych, gdy mapa jest gotowa do użycia. W metodzie wywołania zwrotnego możesz dodać znaczniki lub linie łamane do mapy, dodać detektory lub przesunąć kamerę. poniższy przykład dodaje znacznik 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łączam dźwięki otoczenia

Pakiet Maps SDK na Androida obsługuje tryb nieaktywny na urządzeniach do noszenia aplikacji. Aplikacje obsługujące dźwięki otoczenia są czasami nazywane aplikacjami zawsze włączonymi. Oświetlenie kinowe jest aktywowane, gdy użytkownik nie korzysta już z aplikacji. i umożliwia pozostawienie aplikacji na urządzeniu do noszenia.

Maps SDK na Androida upraszcza renderowanie bez kolorów do użycia w trybie nieaktywnym, a styl mapy zostanie automatycznie dostosowany, urządzenie przełącza się z trybu interaktywnego w tryb nieaktywny. Wszystkie znaczniki, obiekty i UI elementy sterujące znikają w trybie nieaktywnym. Zmniejsza to zużycie energii aplikacji oraz zapewnia spójność jej wyglądu i stylu z innymi aplikacjami do obsługi otoczenia, takich jak tarcze zegarka.

Aby aplikacja używała trybu nieaktywnego mapy, wykonaj te czynności:

1. Zaktualizuj pakiet SDK do Androida, dodając Androida w wersji 6.0 (API 23) lub nowszej udostępnia platformę udostępniającą interfejsy API umożliwiające przekazywanie działań do otoczenia i trybu uzyskiwania zgody. Informacje o aktualizowaniu pakietu SDK znajdziesz w dokumentacji Androida o dodawaniu pakietów SDK.
2. Upewnij się, że projekt jest kierowany na Androida 6.0 lub nowszego, ustawiając targetSdkVersion na 23 lub więcej w manifeście aplikacji.
3. Dodaj zależności urządzenia do noszenia do pliku build.gradle.kts aplikacji. Zobacz znajdziesz na tej stronie.
4. Dodaj wpis biblioteki współdzielonej urządzenia do noszenia do manifestu aplikacji do noszenia jako omówiono w ramach szkolenia na temat Androida aby aplikacja była widoczna.
5. Dodaj uprawnienie WAKE_LOCK do plików manifestu aplikacji na urządzenia mobilne i urządzenia do noszenia. jak opisano w zajęciach na temat Androida, aby aplikacja była widoczna.
6. W metodzie onCreate() swojej aktywności wywołaj funkcję Metoda AmbientModeSupport.attach(). Dzięki temu systemu operacyjnego, w którym aplikacja jest zawsze włączona. Dzięki temu, gdy urządzenie Wyłącza się, więc powinien włączyć tryb nieaktywny zamiast wracać do zegarka twarzy.
7. Zaimplementuj interfejs AmbientModeSupport.AmbientCallbackProvider w Działanie, aby mogło odbierać zmiany stanu trybu nieaktywnego.
8. Skonfiguruj mapę tak, aby obsługiwała dźwięki otoczenia. Aby to zrobić, ustaw parametr atrybutu map:ambientEnabled="true" w pliku układu XML aktywności. ją automatycznie za pomocą ustawienia GoogleMapOptions.ambientEnabled(true). To ustawienie informuje interfejs API, że musi wstępnie wczytywać niezbędne kafelki mapy dla: w trybie nieaktywnym.
9. Kiedy aktywność przełączy się w tryb nieaktywny, system wywoła metodę Metoda onEnterAmbient() w AmbientCallback i udostępniania. Zastąp onEnterAmbient() i wywołaj SupportMapFragment.onEnterAmbient(ambientDetails) lub MapView.onEnterAmbient(ambientDetails). Interfejs API jest zastępowany nieinteraktywne, małokolorowe renderowanie mapy.
10. Podobnie w wywołaniu onExitAmbient() SupportMapFragment.onExitAmbient() lub MapView.onExitAmbient(). Interfejs API spowoduje przełączenie na normalne renderowanie mapy.

Ten przykładowy kod włącza tryb nieaktywny 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 trybie nieaktywnym znajdziesz w na temat tego, jak zadbać o widoczność aplikacji.

Korzystanie ze Street View na Wear OS

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

Aby użytkownicy mogli wyjść z aplikacji podczas oglądania panoramy Street View, użyj przycisku StreetViewPanorama.OnStreetViewPanoramaLongClickListener aby nasłuchiwać gestu długiego kliknięcia. Gdy użytkownik kliknie długo zdjęcia Street View otrzymasz onStreetViewPanoramaLongClick(StreetViewPanoramaOrientation) zdarzenie. Zadzwoń do nas DismissOverlayView.show(), aby wyświetlić przycisk wyjścia.

Przykładowy kod

Przykładowa aplikacja jest dostępna w GitHub i możesz jej używać jako jako punkt początkowy Twojej aplikacji. Z przykładu dowiesz się, jak skonfigurować podstawowej mapy Google na Wear OS.

Obsługiwane funkcje interfejsu API Map Google na Wear OS

W tej sekcji omawiamy różnice w obsługiwanych funkcjach map na urządzeń do noszenia w porównaniu z urządzeniami ręcznymi (telefonami i tabletami). Wszystkie funkcje interfejsu API, które nie zostały wymienione poniżej, powinny działać zgodnie z opisem dla pełnego interfejsu API.

Sprawdzone metody tworzenia aplikacji za pomocą interfejsu API Map Google na Wear OS

Jak zadbać o wygodę użytkowników aplikacji:

• Mapa powinna zajmować dużą część ekranu. Jest to konieczne, optymalizować łatwość obsługi mapy na małych urządzeniach do noszenia. urządzenia.
• Projektując aplikację, weź pod uwagę fakt, urządzenie do noszenia ma słabą baterię. Utrzymywanie aktywnego ekranu wyświetlenie mapy wpłynie na zużycie baterii.