Primeiros passos com o SDK do Places para Android (Kotlin)

Primeiros passos com o SDK do Places para Android (Kotlin)

Sobre este codelab

Último jun. 22, 2022 atualizado

Escrito por Angela Yu

1. Antes de começar

Este codelab ensina como integrar o SDK do Places para Android ao seu app e usar cada um dos recursos dele.

Prerequisites

• Conhecimento básico de desenvolvimento Android e Kotlin

O que você vai aprender

• Como instalar o SDK do Places para Android com extensões Kotlin.
• Como carregar detalhes de um lugar específico.
• Como adicionar um widget do Place Autocomplete ao app.
• Como carregar o local atual com base no lugar informado pelo dispositivo no momento.

Pré-requisitos

Para concluir este codelab, você vai precisar das seguintes contas, serviços e ferramentas:

• Uma Conta do Google com faturamento ativado.
• Android Studio Bumblebee ou versão mais recente.
• Google Play Services instalado no Android Studio.
• Um dispositivo Android ou um Android Emulator que execute a plataforma de APIs do Google com base no Android 8 ou versões mais recentes (consulte Executar apps no Android Emulator para ver as etapas de instalação).

2. Começar a configuração

Para a etapa abaixo, ative a API Places.

Configurar a Plataforma Google Maps

Caso você ainda não tenha uma conta do Google Cloud Platform e um projeto com faturamento ativado, veja como criá-los no guia da Plataforma Google Maps.

1. No Console do Cloud, clique no menu suspenso do projeto e selecione o projeto que você quer usar neste codelab.

2. Ative as APIs e os SDKs da Plataforma Google Maps necessários para este codelab no Google Cloud Marketplace. Para fazer isso, siga as etapas descritas neste vídeo ou nesta documentação.
3. Gere uma chave de API na página Credenciais do Console do Cloud. Siga as etapas indicadas neste vídeo ou nesta documentação. Todas as solicitações feitas à Plataforma Google Maps exigem uma chave de API.

3. Início rápido

Para começar o mais rápido possível e acompanhar este codelab, faça o download do código inicial. Se preferir, você pode ir direto para a solução, mas continue lendo se quiser desenvolver por conta própria.

1. Clone o repositório se você tiver o git instalado.

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

Se preferir, clique neste botão para fazer o download do código-fonte.

Informar o código

2. Depois de fazer o download do código, abra o projeto no diretório /starter do Android Studio. Esse projeto inclui a estrutura de arquivos básica necessária para concluir o codelab. Tudo o que você precisa para trabalhar está no diretório /starter.

Se você quiser ver o código completo da solução em execução, veja o código concluído no diretório /solution.

4. Instalar o SDK do Places para Android

Nesta seção, você adiciona o SDK do Places para Android às dependências do seu app.

Adicionar sua chave de API

Forneça a chave de API que você criou anteriormente para que o SDK do Places para Android possa associar sua chave ao app.

1. Abra o arquivo local.properties no diretório raiz do projeto (o mesmo nível em que estão gradle.properties e settings.gradle).
2. Defina uma nova chave GOOGLE_MAPS_API_KEY, atribuindo a ela o valor da chave de API que você criou.

local.properties

GOOGLE_MAPS_API_KEY=YOUR_KEY_HERE

O local.properties está incluído no arquivo .gitignore no repositório Git. Isso ocorre porque sua chave de API é considerada informação confidencial e não deve ser verificada no controle de origem, se possível.

3. Em seguida, para expor a chave de API e usá-la em todo o app, inclua o plug-in Secrets Gradle para Android no arquivo build.gradle do app, localizado no diretório app/, e inclua a seguinte linha no bloco plugins:

build.gradle no nível do app

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

Observação: atualize o arquivo build.gradle correto. O projeto precisa ter dois: um arquivo build.gradle no nível do projeto e outro específico para o módulo (app/build.gradle).

4. Modifique o arquivo build.gradle no nível do projeto para incluir o seguinte caminho de classe:

build.gradle no nível do projeto

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

Esse plug-in disponibiliza as chaves definidas no arquivo local.properties como variáveis de build no arquivo de manifesto do Android e como variáveis na classe BuildConfig gerada pelo Gradle no momento da compilação. Usar esse plug-in remove o código boilerplate que seria necessário para ler as propriedades de local.properties, para que elas possam ser acessadas em todo o app.

Observação: as chaves de API são credenciais confidenciais que precisam ser cuidadosamente protegidas para evitar mau uso. Para mais informações sobre as práticas recomendadas de proteção da sua chave de API, leia Proteger chaves de API. Para ver mais dicas sobre o Gradle, consulte Dicas e instruções do Gradle.

Adicionar a dependência do SDK do Places para Android

5. Agora que sua chave de API pode ser acessada no app, adicione a dependência do SDK do Places para Android ao arquivo build.gradle do seu app.

No projeto inicial que acompanha este codelab, essa dependência já foi adicionada para você.

build.gradle no nível do app

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

6. Execute o app.

Você vai ver um app com uma tela vazia. Continue a preencher a tela com três demonstrações.

5. Instalar o Android KTX do Places

Para apps Kotlin que usam um ou mais SDKs do Android da Plataforma Google Maps, as bibliotecas de extensão Kotlin (KTX) permitem aproveitar recursos da linguagem Kotlin, como corrotinas, propriedades/funções de extensão e muito mais. Cada SDK do Google Maps tem uma biblioteca KTX correspondente, como mostrado abaixo:

Nesta tarefa, utilize a biblioteca Places do Android KTX para usar recursos da linguagem específica do Kotlin no seu app.

Observação: o código das bibliotecas KTX da Plataforma Google Maps é aberto no GitHub. Consulte android-maps-ktx e android-places-ktx para saber mais.

Adicionar a dependência do Android KTX do Places

Para aproveitar os recursos específicos do Kotlin, inclua a biblioteca KTX correspondente para esse SDK no arquivo build.gradle no nível do app.

build.gradle

dependencies {
    // ...

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

6. Inicializar o cliente do Places

Inicializar o SDK do Places para o escopo do aplicativo

No arquivo DemoApplication.kt da pasta app/src/main/java/com/google/codelabs/maps/placesdemo, inicialize o SDK do Places para Android. Cole as linhas abaixo no fim da função onCreate:

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

Quando você cria o app, o plug-in de secrets do Gradle para Android (em inglês) disponibiliza a chave de API no seu arquivo local.properties como BuildConfig.GOOGLE_MAPS_API_KEY.

Observação: ao copiar e colar o código deste codelab no seu projeto, você vai ver erros do tipo Unresolved reference. Para corrigi-los, é necessário importar a classe para o arquivo. Isso pode ser feito automaticamente no Android Studio, basta passar o cursor sobre a classe que exibe um erro e clicar em Import na caixa de diálogo do assistente.

Adicionar o arquivo de aplicativo ao manifesto

Como você estendeu o Application com DemoApplication, é necessário atualizar o manifesto. Adicione a propriedade android:name ao elemento application no arquivo AndroidManifest.xml, localizado em app/src/main:

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

Esse código aponta o manifesto do aplicativo para a classe DemoApplication na pasta src/main/java/com/google/codelabs/maps/placesdemo/.

7. Buscar Place Details

Criar a tela "Detalhes"

Um layout activity_details.xml com um LinearLayout vazio está disponível na pasta app/src/main/res/layout/. Preencha o layout linear adicionando o seguinte código entre os colchetes <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" />

Esse código adiciona um campo de entrada de texto em que o usuário pode inserir qualquer ID de local ou usar o padrão fornecido, um botão para iniciar a solicitação do Place Details e um TextView para exibir as informações da resposta. As strings associadas são definidas para você no arquivo src/main/res/values/strings.xml.

IDs de local identificam de forma exclusiva um lugar no banco de dados do Google Places e no Google Maps. Esses identificadores textuais podem ser usados em todas as APIs da Plataforma Google Maps.

IDs de local estão disponíveis para a maioria dos locais, incluindo empresas, pontos turísticos, parques e interseções. É possível que o mesmo local tenha vários IDs de lugar.

Criar a atividade "Detalhes"

1. Crie um arquivo DetailsActivity.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/ e associe-o ao layout que você acabou de criar. Cole este código no arquivo:

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. Crie um cliente do Places para usar com essa atividade. Cole este código após a configuração do objeto de visualização na função onCreate.

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

Se você precisar do cliente Places para várias atividades, crie um Singleton compartilhado entre as atividades. Para permitir o uso modular do exemplo de código, este codelab cria o cliente separadamente para cada atividade.

3. Depois que o cliente do Places estiver configurado, anexe um listener de cliques ao botão. Cole este código após a criação do cliente do Places na função 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
                }
            }
        }

Esse código recupera o ID de lugar que foi inserido no campo de entrada, define quais campos vão ser solicitados, cria um FetchPlaceRequest, inicia a tarefa e detecta um sucesso ou uma falha. Quando a solicitação é bem-sucedida, a função preenche a TextView com os detalhes solicitados.

Ao solicitar um lugar, você precisa especificar quais tipos de dados retornar. Para fazer isso, transmita uma lista de objetos Place.Field, especificando os tipos de dados a serem retornados. Essa é uma consideração importante, já que isso vai afetar o custo de cada solicitação.

4. Converta FetchPlaceResponse em texto definindo uma função de extensão. Um arquivo StringUtil.kt é fornecido para simplificar a conversão das respostas do SDK do Places em strings legíveis.

No fim do arquivo DetailsActivity.kt, defina uma função para converter o objeto de resposta do Fetch Place em uma string.

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

Adicionar a atividade "Detalhes" ao manifesto

Adicione um elemento <activity> para o DetailsActivity como filho do elemento <application> no arquivo AndroidManifest.xml, localizado em app/src/main:

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

Adicionar a atividade "Detalhes" ao menu de demonstração

Um módulo Demo vazio é fornecido para listar as demonstrações disponíveis na tela inicial. Agora que você criou uma atividade do Place Details, adicione-a ao arquivo Demo.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/ com este código:

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

As strings associadas são definidas no arquivo src/main/res/values/strings.xml.

Inspecione o MainActivity.kt e observe que ele cria um ListView preenchido pela iteração do conteúdo do módulo Demo. Quando o usuário toca em um item da lista, o listener de cliques abre a atividade associada.

Executar o app

1. Execute o app. Desta vez, você vai ver um item na lista com a demonstração do Place Details.
2. Toque no texto do Place Details. Você vai ter acesso à visualização criada com um botão e um campo de entrada.
3. Toque no botão "VER DETALHES". Se você usou o ID de lugar padrão, vai ver o nome, o endereço e as coordenadas do mapa, como mostrado na Figura 1.

Figura 1. Atividade do Place Details com resposta exibida.

8. Adicionar Place Autocomplete

Criar uma tela de preenchimento automático

Um layout activity_autocomplete.xml com um LinearLayout vazio foi fornecido na pasta app/src/main/res/layout/. Preencha o layout linear adicionando este código entre os colchetes <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" />

Esse código adiciona um widget AutocompleteSupportFragment e um TextView para exibir as informações da resposta. As strings associadas são definidas no arquivo src/main/res/values/strings.xml.

Criar uma atividade de preenchimento automático

1. Crie um arquivo AutocompleteActivity.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/ e defina-o com este código:

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

Esse código associa a atividade às visualizações e ao AutocompleteSupportFramgent que você definiu no arquivo de layout.

2. Em seguida, defina o que acontece quando o usuário seleciona uma das previsões apresentadas pelo Place Autocomplete. Adicione este código ao fim da função 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()
                }
            }

Esse código define os campos que são solicitados para o lugar e detecta um evento de seleção de lugar, além de sucesso ou falha. Quando a solicitação é bem-sucedida, a função preenche a TextView com os detalhes do lugar. O Place Autocomplete retorna um objeto do Place. Não é necessário fazer outra solicitação do Place Details ao usar o widget do Place Autocomplete.

Adicionar a atividade de preenchimento automático ao manifesto

Adicione um elemento <activity> para o AutocompleteActivity como filho do elemento <application> no arquivo AndroidManifest.xml, localizado em app/src/main:

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

Adicionar a atividade de preenchimento automático ao menu de demonstração

Assim como antes, adicione a demonstração do Place Autocomplete à tela inicial anexando-a à lista no módulo Demo. Agora que você criou uma atividade do Place Autocomplete, adicione-a ao arquivo Demo.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/. Cole este código imediatamente após o item DETAILS_FRAGMENT_DEMO:

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

As strings associadas são definidas no arquivo src/main/res/values/strings.xml.

Executar o app

1. Execute o app. Desta vez, você vai ver dois itens na lista da tela inicial.
2. Toque na linha do Place Autocomplete. Uma entrada do Place Autocomplete é exibida como mostrado na Figura 2.
3. Comece a digitar o nome de um lugar. Pode ser o nome de um estabelecimento, um endereço ou uma região geográfica. As previsões são apresentadas enquanto você digita.
4. Selecione uma das previsões. As previsões vão desaparecer, e o TextView vai exibir os detalhes do lugar selecionado, como mostrado na Figura 3.

Figura 2. Atividade de preenchimento automático depois que o usuário toca no campo de entrada.

Figura 3. Atividade de preenchimento automático que exibe o Place Details depois que o usuário digita e seleciona "Niagara Falls".

9. Acessar o local atual do dispositivo

Criar uma tela do local atual

Um layout activity_current.xml com um LinearLayout vazio foi fornecido na pasta app/src/main/res/layout/. Preencha o layout linear adicionando o seguinte código entre os colchetes <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" />

Criar uma atividade do local atual

1. Crie um arquivo CurrentActivity.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/ e defina-o com este código:

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

Esse código associa a atividade às visualizações que você definiu no arquivo de layout. Ele também adiciona um listener de clique ao botão para chamar a função checkPermissionThenFindCurrentPlace quando o botão é clicado.

2. Defina checkPermissionThenFindCurrentPlace() para verificar a permissão de localização exata e solicite a permissão, se ela ainda não tiver sido concedida. Cole este código após a função 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
    }

O SDK do Places para Android declara as permissões usadas no próprio manifesto. Portanto, não é necessário declarar a permissão ACCESS_FINE_LOCATION em AndroidManifest.xml.

3. Quando a ramificação else da função checkPermissionThenFindCurrentPlace chama requestPermissions, o app apresenta uma caixa de diálogo de solicitação de permissão ao usuário. Quando o usuário executa um dispositivo com um SO anterior ao Android 12, ele só pode conceder permissões de localização precisas. Quando o usuário usa um dispositivo com o Android 12 ou mais recente, ele pode informar um local aproximado, em vez de um lugar exato, como mostrado na Figura 4.

Figura 4. Solicitar permissão do usuário em um dispositivo com o Android 12 ou mais recente permite conceder uma localização aproximada ou precisa.

Depois que o usuário responde à caixa de diálogo de permissões, o sistema invoca a implementação do app de onRequestPermissionsResult. O sistema transmite a resposta do usuário à caixa de diálogo de permissão, além do código de solicitação definido. Substitua onRequestPermissionResult para processar o código de solicitação das permissões de localização relacionadas a essa atividade do local atual colando o seguinte código abaixo de 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. Quando a permissão for concedida, a função findCurrentPlace vai ser executada. Defina a função com esse código após a função 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()

        }
    }

Esse código define quais campos vão ser solicitados para os possíveis lugares, cria um FindCurrentPlaceRequest, inicia a tarefa e preenche o TextView com os detalhes solicitados.

Ao pesquisar o lugar atual, você precisa especificar quais tipos de dados retornar. Para fazer isso, transmita uma lista de objetos Place.Field, especificando os tipos de dados a serem retornados. Essa é uma consideração importante, já que isso vai afetar o custo de cada solicitação.

5. Converta FindCurrentPlaceResponse em texto definindo uma função de extensão. Um arquivo StringUtil.kt é fornecido para simplificar a conversão das respostas do SDK do Places em strings legíveis.

No fim do arquivo CurrentPlaceActivity.kt, defina uma função para converter o objeto de resposta do local atual em uma string.

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

Adicionar a atividade do local atual ao manifesto

Adicione um elemento <activity> para o CurrentPlaceActivity como filho do elemento <application> no arquivo AndroidManifest.xml, localizado em app/src/main:

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

Adicionar a atividade do local atual ao menu de demonstração

Assim como antes, adicione a demonstração do local atual à tela inicial anexando-a à lista no módulo Demo. Agora que você criou uma atividade do local atual, adicione-a ao arquivo Demo.kt na pasta src/main/java/com/google/codelabs/maps/placesdemo/. Cole este código imediatamente após o item AUTOCOMPLETE_FRAGMENT_DEMO:

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

As strings associadas são definidas no arquivo src/main/res/values/strings.xml.

Executar o app

1. Execute o app. Desta vez, você vai ver três itens na lista da tela inicial.
2. Toque na linha do local atual. Você vai ver um botão na tela.
3. Toque no botão. Se você nunca concedeu permissão de localização a este app, uma solicitação de permissão vai ser exibida.
4. Conceda permissão ao app para acessar a localização do dispositivo.
5. Toque no botão novamente. Desta vez, uma lista de até 20 lugares por perto e as probabilidades deles serão exibidas, como mostrado na Figura 5.

Figura 5. Apresentação de possíveis correspondências com locais atuais para o local informado pelo dispositivo.

10. Parabéns

Você criou um app Android com o SDK do Places para Android.

O que você aprendeu

• Como instalar e configurar o SDK do Places para Android.
• Como instalar extensões Kotlin para o SDK do Places para Android.
• Como carregar o Place Details.
• Adicionar Place Autocomplete.
• Como acessar o Local atual.

A seguir

• Explore ou crie uma bifurcação do repositório android-places-demos de amostras e demonstrações do GitHub para ter mais inspiração.
• Aprenda com mais codelabs do Kotlin para criar apps Android com a Plataforma Google Maps.
• Ajude-nos a criar conteúdo útil respondendo à seguinte pergunta:

Quais outros codelabs você quer ver?

Visualização de dados em mapasComo personalizar o estilo dos meus mapasComo criar interações 3D em mapas

O codelab que você quer ver não está listado? Solicite-o aqui.