Iniziare a utilizzare l'SDK Places per Android (Kotlin)

Iniziare a utilizzare l'SDK Places per Android (Kotlin)

Informazioni su questo codelab

Ultimo aggiornamento: giu 22, 2022

Scritto da: Angela Yu

1. Prima di iniziare

Questo codelab ti spiega come integrare l'SDK Places per Android nella tua app e come utilizzare ciascuna delle funzionalità dell'SDK Places.

Prerequisiti

• Conoscenza di base dello sviluppo di Kotlin e Android

Obiettivi didattici

• Come installare l'SDK Places per Android con le estensioni Kotlin.
• Come caricare i dettagli di un luogo specifico.
• Come aggiungere un widget Place Autocomplete alla tua app.
• Come caricare la posizione corrente in base alla posizione attualmente segnalata del dispositivo.

Che cosa ti serve

Per completare questo codelab, avrai bisogno dei seguenti account, servizi e strumenti:

• Un Account Google con fatturazione abilitata.
• Android Studio Bumblebee o versioni successive.
• Google Play Services installato in Android Studio.
• Un dispositivo Android o un emulatore Android che esegue la piattaforma API di Google in base ad Android 8 o versioni successive (per la procedura di installazione, consulta l'articolo Eseguire app sull'emulatore Android).

2. Configura

Per il passaggio di attivazione qui sotto, attiva l'API Places.

Configurare Google Maps Platform

Se non hai ancora un account Google Cloud Platform e un progetto con la fatturazione abilitata, consulta la guida Utilizzo di Google Maps Platform per creare un account di fatturazione e un progetto.

1. In Cloud Console, fai clic sul menu a discesa del progetto e seleziona il progetto che vuoi utilizzare per questo codelab.

2. Abilita le API e gli SDK di Google Maps Platform richiesti per questo codelab in Google Cloud Marketplace. Per farlo, segui la procedura descritta in questo video o in questa documentazione.
3. Genera una chiave API nella pagina Credentials di Cloud Console. Puoi seguire la procedura descritta in questo video o in questa documentazione. Tutte le richieste a Google Maps Platform richiedono una chiave API.

3. Avvio rapido

Per iniziare il più rapidamente possibile, scarica il codice di avvio per seguire questo codelab. Puoi passare alla soluzione, ma se vuoi seguire tutti i passaggi per crearla da sola, continua a leggere.

1. Clona il repository se hai installato git.

git clone https://github.com/googlemaps/codelab-places-101-android.git

In alternativa, fai clic su questo pulsante per scaricare il codice sorgente.

Dammi il codice

2. Dopo aver scaricato il codice, apri il progetto presente nella directory /starter di Android Studio. Questo progetto include la struttura di base del file di cui avrai bisogno per completare il codelab. Tutto ciò che ti serve è disponibile nella directory /starter.

Se vuoi vedere il codice della soluzione completo in esecuzione, puoi visualizzare il codice completato nella directory /solution.

4. Installa l'SDK Places per Android

In questa sezione aggiungerai l'SDK Places per Android alle dipendenze dell'app.

Aggiungi la tua chiave API

Fornisci la chiave API creata in precedenza all'app, in modo che l'SDK Places per Android possa associare la tua chiave all'app.

1. Apri il file local.properties nella directory radice del progetto (lo stesso livello in cui si trovano gradle.properties e settings.gradle).
2. Definisci una nuova chiave GOOGLE_MAPS_API_KEY, impostando il relativo valore sulla chiave API che hai creato.

proprietà.local

GOOGLE_MAPS_API_KEY=YOUR_KEY_HERE

Nota: local.properties è elencato nel file .gitignore nel repository Git. Ciò è dovuto al fatto che la tua chiave API è considerata sensibile e non deve essere controllata al controllo della sorgente, se possibile.

3. Successivamente, per esporre la tua chiave API in modo che possa essere utilizzata in tutta l'app, includi il plug-in Secrets Gradle Plugin for Android nel file build.gradle dell'app, situato nella directory app/, e aggiungi la seguente riga nel blocco plugins:

build.gradle a livello di app

plugins {
    // ...
    id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'
}

Nota: assicurati di aggiornare il file build.gradle corretto. Dovrebbero esserci due file nel progetto: un file build.gradle a livello di progetto e uno specifico per il modulo (app/build.gradle).

4. Modifica il file build.gradle a livello di progetto per includere il seguente percorso di classe:

build.gradle a livello di progetto

buildscript {
    dependencies {
        // ...
        classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.1"
    }
}

Questo plug-in rende disponibili le chiavi che hai definito nel file local.properties come variabili di build nel file manifest di Android e come variabili nella classe BuildConfig generata da Gradle al momento della creazione. L'utilizzo di questo plug-in comporta la rimozione del codice boilerplate altrimenti necessario per leggere le proprietà da local.properties, in modo che sia possibile accedervi da tutta l'app.

Nota: le chiavi API sono credenziali sensibili che devono essere protette con attenzione per evitare utilizzi illeciti. Per saperne di più sulle best practice per la protezione della chiave API, leggi l'articolo Proteggere le chiavi API. Per altri suggerimenti su Gradle, vedi Suggerimenti e ricette per Gradle.

Aggiungere la dipendenza Places SDK for Android

5. Ora che puoi accedere alla tua chiave API all'interno dell'app, aggiungi la dipendenza Places SDK for Android al file build.gradle della tua app.

Nel progetto iniziale fornito con questo codelab, questa dipendenza è già stata aggiunta per te.

build.gradle a livello di app

dependencies {
   // Dependency to include Places SDK for Android
   implementation 'com.google.android.libraries.places:places:2.6.0'
}

6. Esegui l'app.

A questo punto dovresti vedere un'app con una schermata vuota. Continua a completare questa schermata con tre demo.

5. Installa Places Android KTX

Per le app Kotlin che utilizzano uno o più SDK Android di Google Maps Platform, le librerie Kotlin di estensione (KTX) ti consentono di sfruttare le funzionalità del linguaggio Kotlin, come coroutine, proprietà/funzioni delle estensioni e altro ancora. Ogni SDK di Google Maps ha una libreria KTX corrispondente come mostrato di seguito:

In questa attività, utilizza la libreria Places KTX di Android per utilizzare le funzionalità relative alla lingua specifiche di Kotlin nella tua app.

Nota: le librerie KTX di Google Maps Platform sono tutte open source su GitHub. Per saperne di più, vedi android-maps-ktx e android-place-ktx.

Aggiungere la dipendenza KTX di Android per Places

Per sfruttare le funzionalità specifiche di Kotlin, includi la libreria KTX corrispondente a questo SDK nel file build.gradle a livello di app.

build.gradle

dependencies {
    // ...

    // Places SDK for Android KTX Library
    implementation 'com.google.maps.android:places-ktx:2.0.0'
}

6. Inizializza il client Places

Inizializza l'SDK Places per l'ambito dell'applicazione

Nel file DemoApplication.kt della cartella app/src/main/java/com/google/codelabs/maps/placesdemo, inizializza l'SDK Places per Android. Incolla le righe seguenti alla fine della funzione onCreate:

        // Initialize the SDK with the Google Maps Platform API key
        Places.initialize(this, BuildConfig.GOOGLE_MAPS_API_KEY)

Quando crei la tua app, il plug-in Secret Gradle per Android rende disponibile la chiave API nel file local.properties come BuildConfig.GOOGLE_MAPS_API_KEY.

Nota: quando copi e incolli il codice da questo codelab al tuo progetto, verranno visualizzati errori Riferimento non risolto. Per risolvere il problema, devi importare la classe nel tuo file. Puoi eseguire questa operazione automaticamente in Android Studio passando il mouse sopra il corso che mostra un errore e facendo clic su Importa nella finestra di dialogo della guida.

Aggiungi il file dell'applicazione al manifest

Poiché hai esteso Application con DemoApplication, devi aggiornare il manifest. Aggiungi la proprietà android:name all'elemento application nel file AndroidManifest.xml, situato in app/src/main:

    <application
        android:name=".DemoApplication"
        ...
    </application>

Questo codice indirizza il manifest dell'applicazione alla classe DemoApplication nella cartella src/main/java/com/google/codelabs/maps/placesdemo/.

7. Dettagli luogo di recupero

Creare una schermata Dettagli

Un layout activity_details.xml con LinearLayout vuoto è disponibile nella cartella app/src/main/res/layout/. Completa il layout lineare aggiungendo il seguente codice tra le parentesi <LinearLayout>.

    <com.google.android.material.textfield.TextInputLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <com.google.android.material.textfield.TextInputEditText
            android:id="@+id/details_input"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="@string/details_input_hint"
            android:text="@string/details_input_default" />

    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/details_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/button_details" />

    <TextView
        android:id="@+id/details_response_content"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingTop="16dp"
        android:textIsSelectable="true" />

Questo codice aggiunge un campo di immissione di testo in cui l'utente può inserire qualsiasi ID luogo o utilizzare l'impostazione predefinita fornita, un pulsante per avviare la richiesta di dettagli del luogo e una proprietà TextView per visualizzare le informazioni della risposta. Le stringhe associate sono definite automaticamente nel file src/main/res/values/strings.xml.

Gli ID luogo identificano in modo univoco un luogo nel database di Google Places e su Google Maps. Questi identificatori testuali possono essere utilizzati nelle API di Google Maps Platform.

Gli ID luogo sono disponibili per la maggior parte delle sedi, tra cui attività commerciali, punti di riferimento, parchi e incroci. È possibile che uno stesso luogo o più sedi abbiano più ID luogo diversi.

Creare un'attività Dettagli

1. Crea un file DetailsActivity.kt nella cartella src/main/java/com/google/codelabs/maps/placesdemo/ e associalo al layout appena creato. Incolla questo codice nel file:

class DetailsActivity : AppCompatActivity() {
    private lateinit var placesClient: PlacesClient
    private lateinit var detailsButton: Button
    private lateinit var detailsInput: TextInputEditText
    private lateinit var responseView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_details)

        // Set up view objects
        detailsInput = findViewById(R.id.details_input)
        detailsButton = findViewById(R.id.details_button)
        responseView = findViewById(R.id.details_response_content)

    }
}

2. Creare un client Places da utilizzare per questa attività. Incolla questo codice dopo l'oggetto di visualizzazione impostato nella funzione onCreate.

        // Retrieve a PlacesClient (previously initialized - see DemoApplication)
        placesClient = Places.createClient(this)

Se hai bisogno del client Places per più attività, crea un Singleton da condividere tra le attività. Per consentire l'utilizzo modulare del codice di esempio, questo codelab crea il client separatamente per ogni attività.

3. Dopo aver configurato il client Places, allega un listener di clic al pulsante. Incolla questo codice dopo la creazione del client Places nella funzione onCreate.

        // Upon button click, fetch and display the Place Details
        detailsButton.setOnClickListener {
            val placeId = detailsInput.text.toString()
            val placeFields = listOf(
                Place.Field.NAME,
                Place.Field.ID,
                Place.Field.LAT_LNG,
                Place.Field.ADDRESS
            )
            lifecycleScope.launch {
                try {
                    val response = placesClient.awaitFetchPlace(placeId, placeFields)
                    responseView.text = response.prettyPrint()
                } catch (e: Exception) {
                    e.printStackTrace()
                    responseView.text = e.message
                }
            }
        }

Questo codice recupera l'ID luogo inserito nel campo di immissione, definisce i campi da richiedere per il luogo, crea un FetchPlaceRequest, avvia l'attività e rimane in ascolto per operazioni riuscite o non riuscite. Se la richiesta ha esito positivo, la funzione completa il campo TextView con i dettagli richiesti.

Quando richiedi un luogo, devi specificare i tipi di dati sui luoghi da restituire. Per farlo, passa un elenco di Place.Field oggetti, specificando i tipi di dati da restituire. Questa è una considerazione importante, poiché interessa il costo di ogni richiesta.

4. Converti FetchPlaceResponse in testo definendo una funzione di estensione. Viene fornito un file StringUtil.kt per semplificare la conversione delle risposte dell'SDK Places in stringhe leggibili dall'utente.

Alla fine del file DetailsActivity.kt, definisci una funzione per convertire l'oggetto di risposta Fetch Place in una stringa.

fun FetchPlaceResponse.prettyPrint(): String {
    return StringUtil.stringify(this, false)
}

Aggiungere l'attività Dettagli nel file manifest

Aggiungi un elemento <activity> per DetailsActivity come elemento secondario dell'elemento <application> nel file AndroidManifest.xml, che si trova in app/src/main:

        <activity android:name=".DetailsActivity" />

Aggiungere l'attività Dettagli al menu dimostrativo

È disponibile un modulo Demo vuoto per elencare le demo disponibili nella schermata Home. Ora che hai creato un'attività Dettagli luogo, aggiungila al file Demo.kt nella cartella src/main/java/com/google/codelabs/maps/placesdemo/ con questo codice:

    DETAILS_FRAGMENT_DEMO(
        R.string.details_demo_title,
        R.string.details_demo_description,
        DetailsActivity::class.java
    ),

Le stringhe associate sono definite nel file src/main/res/values/strings.xml.

Esamina MainActivity.kt e osserva che crea una ListView, che viene compilata eseguendo l'iterazione dei contenuti del modulo Demo. Se l'utente tocca un elemento dell'elenco, il listener di clic apre l'attività associata.

Esegui l'app

1. Esegui l'app. Questa volta dovresti vedere un elemento nell'elenco che presenta la demo Dettagli del luogo.
2. Tocca il testo dei dettagli sul luogo. Dovresti vedere la vista che hai creato, con un campo e un pulsante di immissione.
3. Tocca il pulsante "OTTIENI DETTAGLI". Se hai utilizzato l'ID luogo predefinito, dovresti vedere il nome, l'indirizzo e le coordinate della mappa, come mostrato nella Figura 1.

Figura 1. Attività luogo con visualizzazione della risposta.

8. Aggiungi completamento automatico luogo

Creare una schermata di completamento automatico

Nella cartella app/src/main/res/layout/ viene fornito un layout activity_autocomplete.xml con LinearLayout vuoto. Completa il layout lineare aggiungendo questo codice tra le parentesi <LinearLayout>.

    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/autocomplete_fragment"
        android:background="@android:color/white"
        android:name="com.google.android.libraries.places.widget.AutocompleteSupportFragment"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <TextView
        android:id="@+id/autocomplete_response_content"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingTop="16dp"
        android:textIsSelectable="true" />

Questo codice aggiunge un widget AutocompleteSupportFragment e un elemento TextView per visualizzare le informazioni della risposta. Le stringhe associate sono definite nel file src/main/res/values/strings.xml.

Creare un'attività di completamento automatico

1. Crea un file AutocompleteActivity.kt nella cartella src/main/java/com/google/codelabs/maps/placesdemo/ e definiscilo con questo codice:

class AutocompleteActivity : AppCompatActivity() {
    private lateinit var responseView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_autocomplete)

        // Set up view objects
        responseView = findViewById(R.id.autocomplete_response_content)
        val autocompleteFragment =
            supportFragmentManager.findFragmentById(R.id.autocomplete_fragment)
                    as AutocompleteSupportFragment
    }
}

Questo codice associa l'attività alle viste e a AutocompleteSupportFramgent definite nel file di layout.

2. Definisci quindi cosa accade quando l'utente seleziona una delle previsioni presentate da Place Autocomplete. Aggiungi questo codice alla fine della funzione onCreate:

        // Specify the types of place data to return.
        autocompleteFragment.setPlaceFields(listOf(Place.Field.NAME, Place.Field.ID, Place.Field.LAT_LNG, Place.Field.ADDRESS))

        // Listen to place selection events
        lifecycleScope.launchWhenCreated {
            autocompleteFragment.placeSelectionEvents().collect { event ->
                when (event) {
                    is PlaceSelectionSuccess -> {
                        val place = event.place
                        responseView.text = StringUtil.stringifyAutocompleteWidget(place, false)
                    }
                    is PlaceSelectionError -> Toast.makeText(
                        this@AutocompleteActivity,
                        "Failed to get place '${event.status.statusMessage}'",
                        Toast.LENGTH_SHORT
                    ).show()
                }
            }

Questo codice definisce i campi da richiedere per il luogo, in ascolto di un evento di selezione del luogo e per l'esito positivo o negativo. Se la richiesta ha esito positivo, la funzione completa il campo TextView con i dettagli del luogo. Tieni presente che la funzionalità di completamento automatico del luogo restituisce un oggetto luogo; non è necessario fare una richiesta Dettagli luogo separata quando utilizzi il widget Luogo di completamento automatico.

Aggiungere l'attività di completamento automatico al file manifest

Aggiungi un elemento <activity> per AutocompleteActivity come elemento secondario dell'elemento <application> nel file AndroidManifest.xml, che si trova in app/src/main:

        <activity android:name=".AutocompleteActivity" />

Aggiungere l'attività di completamento automatico al menu demo

Come in precedenza, puoi aggiungere la demo del completamento automatico di luoghi alla schermata Home aggiungendola all'elenco nel modulo Demo. Ora che hai creato un'attività di completamento automatico del luogo, aggiungila al file Demo.kt nella cartella src/main/java/com/google/codelabs/maps/placesdemo/. Incolla questo codice subito dopo l'elemento DETAILS_FRAGMENT_DEMO:

    AUTOCOMPLETE_FRAGMENT_DEMO(
        R.string.autocomplete_fragment_demo_title,
        R.string.autocomplete_fragment_demo_description,
        AutocompleteActivity::class.java
    ),

Le stringhe associate sono definite nel file src/main/res/values/strings.xml.

Esegui l'app

1. Esegui l'app. Questa volta dovresti vedere due elementi nell'elenco della schermata Home.
2. Tocca la riga Inserisci completamento automatico. Dovresti vedere un popup di inserimento del completamento automatico del luogo come mostrato nella Figura 2.
3. Inizia a digitare il nome di un luogo. Può essere il nome di un'azienda, un indirizzo o un'area geografica. Le previsioni devono essere presentate durante la digitazione.
4. Seleziona una delle previsioni. Le previsioni dovrebbero scomparire e TextView dovrebbe ora mostrare i dettagli sul luogo selezionato, come mostrato nella Figura 3.

Figura 2. Completa automaticamente l'attività dopo che l'utente tocca il campo di immissione.

Figura 3. Attività di completamento automatico che mostra i dettagli del luogo dopo che l'utente ha digitato e selezionato le cascate di Niagara.

9. Ricevi la posizione corrente del dispositivo

Creare una schermata Indirizzo corrente

È stato fornito un layout activity_current.xml con LinearLayout vuoto nella cartella app/src/main/res/layout/. Completa il layout lineare aggiungendo il seguente codice tra le parentesi <LinearLayout>.

    <Button
        android:id="@+id/current_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/current_button" />

    <TextView
        android:id="@+id/current_response_content"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingTop="16dp"
        android:scrollbars = "vertical"
        android:textIsSelectable="true" />

Creare un'attività Luogo corrente

1. Crea un file CurrentActivity.kt nella cartella src/main/java/com/google/codelabs/maps/placesdemo/ e definiscilo con questo codice:

class CurrentPlaceActivity : AppCompatActivity() {
    private lateinit var placesClient: PlacesClient
    private lateinit var currentButton: Button
    private lateinit var responseView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_current)

        // Retrieve a PlacesClient (previously initialized - see DemoApplication)
        placesClient = Places.createClient(this)

        // Set view objects
        currentButton = findViewById(R.id.current_button)
        responseView = findViewById(R.id.current_response_content)


        // Set listener for initiating Current Place
        currentButton.setOnClickListener {
            checkPermissionThenFindCurrentPlace()
        }
    }
}

Questo codice associa l'attività alle viste definite nel file di layout. Aggiunge inoltre un listener di clic al pulsante per chiamare la funzione checkPermissionThenFindCurrentPlace quando l'utente fa clic sul pulsante.

2. Definisci checkPermissionThenFindCurrentPlace() per verificare la corretta autorizzazione della posizione e richiedi l'autorizzazione se non l'hai ancora concessa. Incolla questo codice dopo la funzione onCreate.

    /**
     * Checks that the user has granted permission for fine or coarse location.
     * If granted, finds current Place.
     * If not yet granted, launches the permission request.
     * See https://developer.android.com/training/permissions/requesting
     */
    private fun checkPermissionThenFindCurrentPlace() {
        when {
            (ContextCompat.checkSelfPermission(
                this,
                ACCESS_FINE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(
                this,
                ACCESS_COARSE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED) -> {
                // You can use the API that requires the permission.
                findCurrentPlace()
            }
            shouldShowRequestPermissionRationale(ACCESS_FINE_LOCATION)
            -> {
                Log.d(TAG, "Showing permission rationale dialog")
                // TODO: In an educational UI, explain to the user why your app requires this
                // permission for a specific feature to behave as expected. In this UI,
                // include a "cancel" or "no thanks" button that allows the user to
                // continue using your app without granting the permission.
            }
            else -> {
                // Ask for both the ACCESS_FINE_LOCATION and ACCESS_COARSE_LOCATION permissions.
                ActivityCompat.requestPermissions(
                    this,
                    arrayOf(
                        Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.ACCESS_COARSE_LOCATION
                    ),
                    PERMISSION_REQUEST_CODE
                )
            }
        }
    }

    companion object {
        private val TAG = "CurrentPlaceActivity"
        private const val PERMISSION_REQUEST_CODE = 9
    }

L'SDK Places per Android dichiara le autorizzazioni che utilizza nel proprio file manifest, quindi non è necessario dichiarare personalmente l'autorizzazione ACCESS_FINE_LOCATION in AndroidManifest.xml.

3. Quando il ramo else della funzione checkPermissionThenFindCurrentPlace chiama requestPermissions, l'app mostrerà una finestra di dialogo per la richiesta di autorizzazione all'utente. Se esegue un dispositivo con un sistema operativo precedente ad Android 12, può concedere solo l'autorizzazione di accesso alla posizione esatta. Se l'utente utilizza un dispositivo con Android 12 o versioni successive, gli verrà data l'opzione di fornire una posizione approssimativa (approssimativa) e non esatta, come mostrato nella Figura 4.

Figura 4. La richiesta di autorizzazione dell'utente su un dispositivo con Android 12 o versioni successive offre la possibilità di concedere una posizione precisa o approssimativa.

Dopo che l'utente ha risposto alla finestra di dialogo delle autorizzazioni di sistema, il sistema richiama l'implementazione di onRequestPermissionsResult della tua app. Il sistema trasmette la risposta dell'utente alla finestra di dialogo delle autorizzazioni, oltre al codice di richiesta definito. Esegui l'override di onRequestPermissionResult per gestire il codice di richiesta per le autorizzazioni di posizione relative a questa attività di questo luogo incollando il codice seguente di seguito checkPermissionThenFindCurrentPlace.

    @SuppressLint("MissingPermission")
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<String>, grantResults: IntArray
    ) {
        if (requestCode != PERMISSION_REQUEST_CODE) {
            super.onRequestPermissionsResult(
                requestCode,
                permissions,
                grantResults
            )
            return
        } else if (permissions.toList().zip(grantResults.toList())
                .firstOrNull { (permission, grantResult) ->
                    grantResult == PackageManager.PERMISSION_GRANTED && (permission == ACCESS_FINE_LOCATION || permission == ACCESS_COARSE_LOCATION)
                } != null
        )
            // At least one location permission has been granted, so proceed with Find Current Place
            findCurrentPlace()
    }

4. Una volta concessa l'autorizzazione, verrà eseguita la funzione findCurrentPlace. Definisci la funzione con questo codice dopo la funzione onRequestPermissionsResult.

    /**
     * Fetches a list of [PlaceLikelihood] instances that represent the Places the user is
     * most
     * likely to be at currently.
     */
    @RequiresPermission(anyOf = [ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION])
    private fun findCurrentPlace() {
        // Use fields to define the data types to return.
        val placeFields: List<Place.Field> =
            listOf(Place.Field.NAME, Place.Field.ID, Place.Field.ADDRESS, Place.Field.LAT_LNG)

        // Use the builder to create a FindCurrentPlaceRequest.
        val request: FindCurrentPlaceRequest = FindCurrentPlaceRequest.newInstance(placeFields)

        // Call findCurrentPlace and handle the response (first check that the user has granted permission).
        if (ContextCompat.checkSelfPermission(this, ACCESS_FINE_LOCATION) ==
            PackageManager.PERMISSION_GRANTED ||
            ContextCompat.checkSelfPermission(this, ACCESS_COARSE_LOCATION) ==
            PackageManager.PERMISSION_GRANTED
        ) {
            // Retrieve likely places based on the device's current location
            lifecycleScope.launch {
                try {
                    val response = placesClient.awaitFindCurrentPlace(placeFields)
                    responseView.text = response.prettyPrint()

                    // Enable scrolling on the long list of likely places
                    val movementMethod = ScrollingMovementMethod()
                    responseView.movementMethod = movementMethod
                } catch (e: Exception) {
                    e.printStackTrace()
                    responseView.text = e.message
                }
            }
        } else {
            Log.d(TAG, "LOCATION permission not granted")
            checkPermissionThenFindCurrentPlace()

        }
    }

Questo codice definisce i campi da richiedere per i luoghi probabili, crea un FindCurrentPlaceRequest, avvia l'attività e completa il campo TextView con i dettagli richiesti.

Quando cerchi il luogo corrente, devi specificare i tipi di dati sui luoghi da restituire. Per farlo, passa un elenco di Place.Field oggetti, specificando i tipi di dati da restituire. Questa è una considerazione importante, poiché interessa il costo di ogni richiesta.

5. Converti FindCurrentPlaceResponse in testo definendo una funzione di estensione. Viene fornito un file StringUtil.kt per semplificare la conversione delle risposte dell'SDK Places in stringhe leggibili dall'utente.

Alla fine del file CurrentPlaceActivity.kt, definisci una funzione per convertire l'oggetto della risposta Place attuale in una stringa.

fun FindCurrentPlaceResponse.prettyPrint(): String {
    return StringUtil.stringify(this, false)
}

Aggiungi l'attività Luogo attuale al manifest

Aggiungi un elemento <activity> per CurrentPlaceActivity come elemento secondario dell'elemento <application> nel file AndroidManifest.xml, che si trova in app/src/main:

        <activity android:name=".CurrentPlaceActivity" />

Aggiungere l'attività Luogo attuale al menu della demo

Come in precedenza, puoi aggiungere la demo di Luoghi attuali alla schermata Home aggiungendola all'elenco nel modulo Demo. Ora che hai creato un'attività Luogo corrente, aggiungila al file Demo.kt della cartella src/main/java/com/google/codelabs/maps/placesdemo/. Incolla questo codice subito dopo l'elemento AUTOCOMPLETE_FRAGMENT_DEMO:

    CURRENT_FRAGMENT_DEMO(
        R.string.current_demo_title,
        R.string.current_demo_description,
        CurrentPlaceActivity::class.java
    ),

Le stringhe associate sono definite nel file src/main/res/values/strings.xml.

Esegui l'app

1. Esegui l'app. Questa volta dovresti vedere tre elementi nell'elenco della schermata Home.
2. Toccare la riga Luogo corrente. Dovresti vedere un pulsante sullo schermo.
3. Tocca il pulsante. Se in precedenza non hai concesso l'autorizzazione di accesso alla posizione a questa app, dovrebbe essere visualizzata una richiesta di autorizzazione.
4. Concedi all'app l'autorizzazione ad accedere alla posizione del dispositivo.
5. Tocca di nuovo il pulsante. Questa volta, dovrebbe essere visualizzato un elenco di massimo 20 luoghi nelle vicinanze con le relative probabilità, come mostrato nella Figura 5.

Figura 5. Visualizzazione della corrispondenza esatta del luogo attuale per la posizione segnalata dal dispositivo.

10. Complimenti

Hai creato un'app Android con l'SDK Places per Android.

Che cosa hai imparato

• Installando e configurando l'SDK Places per Android.
• Installare estensioni Kotlin per l'SDK Places per Android.
• Caricamento Dettagli luogo.
• Aggiunta del completamento automatico del luogo.
• Viene visualizzato il luogo attuale.

Passaggi successivi

• Esplora o crea un fork nel repository android-places-demos di esempi e demo per trovare più ispirazione.
• Scopri altri codelab di Kotlin per creare app Android con Google Maps Platform.
• Aiutaci a creare i contenuti che troverai più utili rispondendo alla seguente domanda:

Quali altri codelab vorresti vedere?

Visualizzazione dei dati sulle mappeUlteriori informazioni sullo stile delle mappeCreazione di interazioni 3D nelle mappe

Il codelab non vuoi includere? Richiedilo qui con un nuovo problema.