API di Google Maps su Wear OS

Con Maps SDK for Android, puoi creare un'app indossabile basata su mappe. direttamente sui dispositivi Wear OS by Google. Utenti della tua app possono vedere la loro posizione sulla mappa semplicemente dando un'occhiata al polso. Possono indica la loro posizione su un percorso, ad esempio e aumenta lo zoom per visualizzare i dettagli. per visualizzare una finestra informativa fornita dalla tua applicazione.

In questa pagina viene descritta la funzionalità dell'API disponibile su un dispositivo indossabile e ti aiuta a iniziare a creare la tua app.

Introduzione a Wear OS

La creazione di un'app indossabile con Maps SDK for Android è fondamentalmente come creare un'app Google Maps per qualsiasi altro dispositivo Android. La differenza dipende dal design in quanto è il fattore di forma più piccolo del dispositivo indossabile, ottimizzare l'usabilità e le prestazioni dell'app.

Android Studio è lo strumento consigliato per lo sviluppo di Wear OS, poiché fornisce funzionalità di configurazione del progetto, inclusione delle librerie e comodità di presentazione.

Per assistenza generica per la progettazione di un'app indossabile, consulta le Linee guida per la progettazione per Wear OS. Se hai bisogno di aiuto per la creazione prima app per dispositivi indossabili, consulta la guida per la creazione di app per indossabili.

Creazione della tua prima app per le mappe su Wear OS

Questa guida rapida presuppone che tu abbia familiarità con Maps SDK for Android, di aver seguito le guide di Wear OS per creare un modulo indossabile la tua app e che ora vuoi aggiungere una mappa al modulo indossabile.

Aggiunta di dipendenze per il modulo Wear

Assicurati che le seguenti dipendenze siano incluse nel file build.gradle del modulo per Wear OS della tua app:

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

Per ulteriori informazioni sulle dipendenze, consulta la guida per aggiungere un Modulo Wear OS nel progetto esistente.

Implementazione di un gesto di scorrimento per ignorare e impostazione del colore di sfondo iniziale

Ti consigliamo di utilizzare un SwipeDismissFrameLayout per visualizzare la mappa il dispositivo indossabile. Con il corso SwipeDismissFrameLayout, puoi implementare il gesto scorri per eliminare, che offre agli utenti per uscire dall'app scorrendo dal bordo all'estrema sinistra dello schermo.

Per impostare un colore di sfondo iniziale personalizzato, utilizza il file XML map:backgroundColor per definire il colore da visualizzare fino al caricamento effettivo dei riquadri della mappa.

Aggiungi gli elementi SwipeDismissFrameLayout e backgroundColor al layout definizione come container di 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>

Quando ottieni l'oggetto SwipeDismissFrameLayout nella tua attività, aggiungi un elemento e impostare il comportamento del callback in modo da eseguire le come mostrato di seguito:

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

    // ...
}

      

Aggiunta di una mappa

Utilizza il metodo di callback onMapReady(GoogleMap) come di consueto, per ottenere un handle all'oggetto GoogleMap. Il richiamo è quando la mappa è pronta per essere utilizzata. Nel metodo di callback, puoi aggiungi indicatori o polilinee alla mappa, aggiungi ascoltatori o sposta la videocamera. La nell'esempio riportato di seguito viene aggiunto un indicatore vicino al Teatro dell'opera di 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));
}

      

Attivazione della modalità Ambient

Maps SDK for Android supporta la modalità Ambient per gli indossabili app. Le app che supportano la modalità Ambient sono a volte chiamate app sempre attive. La modalità Ambient viene attivata quando l'utente non utilizza più attivamente l'app. e consente all'app di rimanere visibile sul dispositivo indossabile.

Maps SDK for Android offre una visualizzazione semplificata e a colori della mappa per l'uso in modalità Ambient, e lo stile della mappa si regola automaticamente quando il dispositivo passa dalla modalità interattiva a quella Ambient. Tutti gli indicatori, gli oggetti e l'interfaccia utente i controlli scompaiono in modalità Ambient. In questo modo si riduce il consumo di corrente e garantiscono un aspetto e un design coerenti con altre app Ambient, come quadranti.

Segui questi passaggi per assicurarti che la tua app utilizzi la modalità Ambient della mappa:

1. Aggiorna l'SDK Android in modo da includere Android 6.0 (API 23) o versioni successive che fornisce le API per consentire l'integrazione delle attività nell'ambiente . Per informazioni su come aggiornare l'SDK, consulta la documentazione di Android sull'aggiunta di pacchetti SDK.
2. Assicurati che il progetto abbia come target Android 6.0 o versioni successive impostando il metodo targetSdkVersion a 23 o superiore nel file manifest dell'app.
3. Aggiungi le dipendenze indossabili al file build.gradle dell'app. Consulta le esempio in questa pagina.
4. Aggiungi la voce della libreria condivisa indossabile al file manifest dell'app indossabile, come: descritti nel corso di formazione su Android mantenendo visibile la tua app.
5. Aggiungi l'autorizzazione WAKE_LOCK ai file manifest delle app per dispositivi portatili e indossabili. come descritto nel corso di formazione su Android mantenendo visibile la tua app.
6. Nel metodo onCreate() della tua attività, chiama il metodo AmbientModeSupport.attach(). Questo indica operativo in modo che l'applicazione sia sempre attiva, in modo che Lo spegnimento dovrebbe attivare la modalità Ambient invece di tornare allo smartwatch. volto.
7. Implementa l'interfaccia AmbientModeSupport.AmbientCallbackProvider nel tuo Attività per poter ricevere le modifiche dello stato della modalità Ambient.
8. Imposta la mappa in modo che supporti la modalità Ambient. Puoi farlo impostando l'attributo map:ambientEnabled="true" nel file di layout XML dell'attività oppure in modo programmatico impostando GoogleMapOptions.ambientEnabled(true). Questa impostazione comunica all'API che deve precaricare i riquadri della mappa necessari da usare in modalità Ambient.
9. Quando l'attività passa alla modalità Ambient, il sistema chiama la Metodo onEnterAmbient() nel AmbientCallback tu che fornisce. Esegui l'override di onEnterAmbient() e chiama SupportMapFragment.onEnterAmbient(ambientDetails) o MapView.onEnterAmbient(ambientDetails). L'API passa a un non interattiva e con pochi colori della mappa.
10. Analogamente, nella chiamata a onExitAmbient() SupportMapFragment.onExitAmbient() o MapView.onExitAmbient(). L'API passa al rendering normale della mappa.

Il seguente esempio di codice abilita la modalità Ambient nell'attività:

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

      

Puoi aggiornare lo schermo mentre l'app è in modalità Ambient. Per maggiori dettagli sull'aggiornamento dei contenuti e sulla modalità Ambient in generale, consulta le corso di formazione su come mantenere visibile la tua app.

Utilizzare Street View su Wear OS

Street View è completamente supportato sui dispositivi indossabili.

Per consentire agli utenti di uscire dall'app quando visualizzano una panoramica di Street View, utilizza la StreetViewPanorama.OnStreetViewPanoramaLongClickListener per ascoltare il gesto di clic a lungo. Quando un utente fa clic a lungo su un sito sull'immagine di Street View, riceverai un onStreetViewPanoramaLongClick(StreetViewPanoramaOrientation) evento. Chiama DismissOverlayView.show() per visualizzare un pulsante di uscita.

Codice di esempio

Su GitHub è disponibile un'app di esempio che puoi usare come punto di partenza per la tua app. L'esempio mostra come configurare una mappa di base di Google Maps su Wear OS.

Funzionalità supportate nell'API di Google Maps su Wear OS

Questa sezione illustra le differenze nelle funzionalità supportate per le mappe su dispositivi indossabili rispetto ai dispositivi portatili (smartphone e tablet). Tutte le funzionalità dell'API non menzionate di seguito dovrebbero funzionare come documentato per l'API completa.

Best practice per lo sviluppo con l'API di Google Maps su Wear OS

Come offrire la migliore esperienza utente nella tua app:

• La mappa dovrebbe occupare gran parte dello schermo. Questa operazione è necessaria per ottimizzare l'usabilità della mappa sul fattore di forma ridotto di un indossabile dispositivo.
• Quando progetti l'esperienza utente della tua app, tieni presente il fatto indica che la batteria di un dispositivo indossabile è in esaurimento. Mantengo lo schermo attivo la mappa visibile avrà impatto sulle prestazioni della batteria.