Place Autocomplete

O serviço de preenchimento automático no SDK do Places para Android retorna previsões de locais em resposta a consultas de pesquisa dos usuários. Conforme o usuário digita, o serviço de preenchimento automático retorna sugestões de lugares, como empresas, endereços, códigos extras e pontos de interesse.

É possível adicionar o preenchimento automático no aplicativo das seguintes formas:

• Adicione um widget de preenchimento automático para economizar tempo de desenvolvimento e garantir uma experiência consistente ao usuário.
• Receba sugestões de lugares de maneira programática para criar uma experiência do usuário personalizada.

Adicionar um widget de preenchimento automático

O widget de preenchimento automático é uma caixa de diálogo de pesquisa com a funcionalidade integrada de preenchimento automático. À medida que o usuário digita termos de pesquisa, o widget apresenta uma lista de locais previstos para escolha. Quando o usuário faz uma seleção, uma instância Place é retornada, e o app pode usá-la para ver detalhes sobre o lugar selecionado.

Há duas opções para se adicionar o widget de preenchimento automático ao seu aplicativo:

• Opção 1: incorporar uma AutocompleteSupportFragment.
• Opção 2: usar uma intent para iniciar a atividade de preenchimento automático.

Opção 1: incorporar um AutocompleteSupportFragment

Para adicionar um AutocompleteSupportFragment ao app, siga estas etapas:

1. Adicione um fragmento ao layout XML da atividade.
2. Adicione um listener à atividade ou ao fragmento.

Adicionar AutocompleteSupportFragment à atividade.

Para adicionar AutocompleteSupportFragment a uma atividade, inclua um novo fragmento em um layout XML. Exemplo:

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

• Por padrão, o fragmento não tem borda nem plano de fundo. Para oferecer uma aparência visual consistente, aninhe o fragmento em outro elemento de layout, como uma CardView.
• Se você estiver usando o fragmento de preenchimento automático e precisar substituir onActivityResult, chame super.onActivityResult. Caso contrário, o fragmento não funcionará corretamente.

Adicionar um PlaceSelectionListener a uma atividade

O PlaceSelectionListener processa o retorno de um lugar em resposta à seleção do usuário. O código abaixo mostra como criar uma referência ao fragmento e adicionar um listener ao AutocompleteSupportFragment:

    // Initialize the AutocompleteSupportFragment.
    AutocompleteSupportFragment autocompleteFragment = (AutocompleteSupportFragment)
        getSupportFragmentManager().findFragmentById(R.id.autocomplete_fragment);

    // Specify the types of place data to return.
    autocompleteFragment.setPlaceFields(Arrays.asList(Place.Field.ID, Place.Field.NAME));

    // Set up a PlaceSelectionListener to handle the response.
    autocompleteFragment.setOnPlaceSelectedListener(new PlaceSelectionListener() {
        @Override
        public void onPlaceSelected(@NonNull Place place) {
            // TODO: Get info about the selected place.
            Log.i(TAG, "Place: " + place.getName() + ", " + place.getId());
        }


        @Override
        public void onError(@NonNull Status status) {
            // TODO: Handle the error.
            Log.i(TAG, "An error occurred: " + status);
        }
    });

      

    // Initialize the AutocompleteSupportFragment.
    val autocompleteFragment =
        supportFragmentManager.findFragmentById(R.id.autocomplete_fragment)
            as AutocompleteSupportFragment

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

    // Set up a PlaceSelectionListener to handle the response.
    autocompleteFragment.setOnPlaceSelectedListener(object : PlaceSelectionListener {
        override fun onPlaceSelected(place: Place) {
            // TODO: Get info about the selected place.
            Log.i(TAG, "Place: ${place.name}, ${place.id}")
        }

        override fun onError(status: Status) {
            // TODO: Handle the error.
            Log.i(TAG, "An error occurred: $status")
        }
    })

      

Opção 2: usar uma intent para iniciar a atividade de preenchimento automático

Se você quiser que seu app use um fluxo de navegação diferente (por exemplo, para acionar a experiência de preenchimento automático de um ícone em vez de um campo de pesquisa), ele pode iniciar o preenchimento automático usando uma intent.

Para inicializar o widget de preenchimento automático usando um intent, faça o seguinte:

1. Use Autocomplete.IntentBuilder para criar uma intent, transmitindo o modo Autocomplete desejado. A intent precisa chamar startActivityForResult, transmitindo um código de solicitação que a identifica.
2. Modifique o callback onActivityResult para receber o lugar selecionado.

Criar uma intent de preenchimento automático

O exemplo abaixo mostra o uso de Autocomplete.IntentBuilder para criar uma intent para iniciar o widget de preenchimento automático como uma intent:

    private static int AUTOCOMPLETE_REQUEST_CODE = 1;

    // Set the fields to specify which types of place data to
    // return after the user has made a selection.
    List<Place.Field> fields = Arrays.asList(Place.Field.ID, Place.Field.NAME);

    // Start the autocomplete intent.
    Intent intent = new Autocomplete.IntentBuilder(AutocompleteActivityMode.FULLSCREEN, fields)
        .build(this);
    startActivityForResult(intent, AUTOCOMPLETE_REQUEST_CODE);

      

    private val AUTOCOMPLETE_REQUEST_CODE = 1

    // Set the fields to specify which types of place data to
    // return after the user has made a selection.
    val fields = listOf(Place.Field.ID, Place.Field.NAME)

    // Start the autocomplete intent.
    val intent = Autocomplete.IntentBuilder(AutocompleteActivityMode.FULLSCREEN, fields)
        .build(this)
    startActivityForResult(intent, AUTOCOMPLETE_REQUEST_CODE)

      

Ao usar uma intent para iniciar o widget de preenchimento automático, você pode escolher entre os modos de sobreposição ou de exibição em tela cheia. As capturas de tela abaixo mostram cada modo de exibição:

Substituir o callback onActivityResult

Para receber uma notificação quando o usuário selecionar um lugar, seu app precisa modificar o onActivityResult() da atividade, verificando o código de solicitação transmitido para a intent, conforme mostrado no exemplo a seguir.

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    if (requestCode == AUTOCOMPLETE_REQUEST_CODE) {
        if (resultCode == RESULT_OK) {
            Place place = Autocomplete.getPlaceFromIntent(data);
            Log.i(TAG, "Place: " + place.getName() + ", " + place.getId());
        } else if (resultCode == AutocompleteActivity.RESULT_ERROR) {
            // TODO: Handle the error.
            Status status = Autocomplete.getStatusFromIntent(data);
            Log.i(TAG, status.getStatusMessage());
        } else if (resultCode == RESULT_CANCELED) {
            // The user canceled the operation.
        }
        return;
    }
    super.onActivityResult(requestCode, resultCode, data);
}

      

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    if (requestCode == AUTOCOMPLETE_REQUEST_CODE) {
        when (resultCode) {
            Activity.RESULT_OK -> {
                data?.let {
                    val place = Autocomplete.getPlaceFromIntent(data)
                    Log.i(TAG, "Place: ${place.name}, ${place.id}")
                }
            }
            AutocompleteActivity.RESULT_ERROR -> {
                // TODO: Handle the error.
                data?.let {
                    val status = Autocomplete.getStatusFromIntent(data)
                    Log.i(TAG, status.statusMessage ?: "")
                }
            }
            Activity.RESULT_CANCELED -> {
                // The user canceled the operation.
            }
        }
        return
    }
    super.onActivityResult(requestCode, resultCode, data)
}

      

Como receber previsões de lugar de forma programática

Você pode criar uma IU de pesquisa personalizada como uma alternativa à IU fornecida pelo widget de preenchimento automático. Para fazer isso, seu app precisa receber previsões de lugar de forma programática. Seu app pode receber uma lista de sugestões de nomes e/ou endereços de lugares da API Autocomplete chamando PlacesClient.findAutocompletePredictions(), transmitindo um objeto FindAutocompletePredictionsRequest com os seguintes parâmetros:

• Obrigatório:uma string query contendo o texto digitado pelo usuário.
• Recomendado:um AutocompleteSessionToken, que agrupa as fases de consulta e seleção de uma pesquisa de usuário em uma sessão distintiva para fins de faturamento. A sessão começa quando o usuário começa a digitar uma consulta e é concluída quando ele seleciona um lugar.
• Recomendado:um objeto RectangularBounds, que especifica os limites de latitude e longitude para restringir os resultados à região especificada.
• Opcional:um ou mais códigos de país de duas letras (ISO 3166-1 Alfa-2), indicando o país ou os países a que os resultados devem ser restritos.

• Opcional:um TypeFilter, que pode ser usado para restringir os resultados ao tipo de lugar especificado. Os seguintes tipos de local são compatíveis:

  • TypeFilter.GEOCODE: retorna apenas resultados de geocodificação, e não empresas. Use essa solicitação para diferenciar os resultados em que o local especificado pode ser indeterminado.
  • TypeFilter.ADDRESS: retorna apenas resultados de preenchimento automático com um endereço preciso. Use esse tipo quando o usuário estiver procurando um endereço totalmente especificado.
  • TypeFilter.ESTABLISHMENT: retorna apenas lugares que são empresas.

  • TypeFilter.REGIONS: retorna apenas lugares que correspondem a um dos seguintes tipos:

    • LOCALITY
    • SUBLOCALITY
    • POSTAL_CODE
    • COUNTRY
    • ADMINISTRATIVE_AREA_LEVEL_1
    • ADMINISTRATIVE_AREA_LEVEL_2

  • TypeFilter.CITIES: retorna apenas resultados que correspondem a LOCALITY ou ADMINISTRATIVE_AREA_LEVEL_3.

• Opcional:um LatLng especificando o local de origem da solicitação. Quando você chama setOrigin(), o serviço retorna a distância em metros (distanceMeters) da origem especificada para cada previsão de preenchimento automático na resposta.

Para ver informações sobre os tipos de lugar, consulte o guia sobre tipos de lugar.

O exemplo abaixo mostra uma chamada completa para PlacesClient.findAutocompletePredictions().

    // Create a new token for the autocomplete session. Pass this to FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    AutocompleteSessionToken token = AutocompleteSessionToken.newInstance();

    // Create a RectangularBounds object.
    RectangularBounds bounds = RectangularBounds.newInstance(
        new LatLng(-33.880490, 151.184363),
        new LatLng(-33.858754, 151.229596));
    // Use the builder to create a FindAutocompletePredictionsRequest.
    FindAutocompletePredictionsRequest request = FindAutocompletePredictionsRequest.builder()
        // Call either setLocationBias() OR setLocationRestriction().
        .setLocationBias(bounds)
        //.setLocationRestriction(bounds)
        .setOrigin(new LatLng(-33.8749937,151.2041382))
        .setCountries("AU", "NZ")
        .setTypesFilter(Arrays.asList(TypeFilter.ADDRESS.toString()))
        .setSessionToken(token)
        .setQuery(query)
        .build();

    placesClient.findAutocompletePredictions(request).addOnSuccessListener((response) -> {
        for (AutocompletePrediction prediction : response.getAutocompletePredictions()) {
            Log.i(TAG, prediction.getPlaceId());
            Log.i(TAG, prediction.getPrimaryText(null).toString());
        }
    }).addOnFailureListener((exception) -> {
        if (exception instanceof ApiException) {
            ApiException apiException = (ApiException) exception;
            Log.e(TAG, "Place not found: " + apiException.getStatusCode());
        }
    });

      

    // Create a new token for the autocomplete session. Pass this to FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    val token = AutocompleteSessionToken.newInstance()

    // Create a RectangularBounds object.
    val bounds = RectangularBounds.newInstance(
        LatLng(-33.880490, 151.184363),
        LatLng(-33.858754, 151.229596)
    )
    // Use the builder to create a FindAutocompletePredictionsRequest.
    val request =
        FindAutocompletePredictionsRequest.builder()
            // Call either setLocationBias() OR setLocationRestriction().
            .setLocationBias(bounds)
            //.setLocationRestriction(bounds)
            .setOrigin(LatLng(-33.8749937, 151.2041382))
            .setCountries("AU", "NZ")
            .setTypesFilter(listOf(TypeFilter.ADDRESS.toString()))
            .setSessionToken(token)
            .setQuery(query)
            .build()
    placesClient.findAutocompletePredictions(request)
        .addOnSuccessListener { response: FindAutocompletePredictionsResponse ->
            for (prediction in response.autocompletePredictions) {
                Log.i(TAG, prediction.placeId)
                Log.i(TAG, prediction.getPrimaryText(null).toString())
            }
        }.addOnFailureListener { exception: Exception? ->
            if (exception is ApiException) {
                Log.e(TAG, "Place not found: " + exception.statusCode)
            }
        }

      

A API retorna um FindAutocompletePredictionsResponse em um Task. O FindAutocompletePredictionsResponse contém uma lista de objetos AutocompletePrediction que representam lugares previstos. A lista poderá estar vazia se não houver um local conhecido correspondente à consulta e aos critérios de filtro.

Para cada local previsto, chame os seguintes métodos para recuperar detalhes do lugar:

• getFullText(CharacterStyle) retorna o texto completo da descrição de um lugar. Essa é uma combinação dos textos principal e secundário. Exemplo: "Torre Eiffel, Avenue Anatole France, Paris, França". Além disso, esse método permite destacar as seções da descrição que correspondem à pesquisa com o estilo que você quiser usando CharacterStyle. O parâmetro CharacterStyle é opcional. Defina-o como nulo se não precisar de nenhum destaque.
• getPrimaryText(CharacterStyle) retorna o texto principal que descreve um lugar. Normalmente, é o nome do lugar. Exemplos: "Eiffel Tower" e "123 Pitt Street".
• getSecondaryText(CharacterStyle) retorna o texto da subsidiária de uma descrição de lugar. Isso é útil, por exemplo, como uma segunda linha ao mostrar previsões de preenchimento automático. Exemplos: "A Avenue Anatole France, Paris, France" e "Sydney, Nova Gales do Sul".
• getPlaceId() retorna o ID do lugar previsto. Um ID de lugar é um identificador textual que identifica um lugar de forma exclusiva, que pode ser usado para recuperar o objeto Place mais tarde. Para mais informações sobre IDs de lugar no SDK do Places para Android, consulte o Place Details. Para informações gerais sobre IDs de lugar, consulte a Visão geral do ID de lugar.
• getPlaceTypes() retorna a lista de tipos de lugar associados a esse local.
• getDistanceMeters() retorna a distância em linha reta em metros entre esse lugar e a origem especificada na solicitação.

Tokens de sessão

Os tokens de sessão agrupam as fases de consulta e seleção de uma pesquisa de preenchimento automático de usuários em uma sessão discreta para fins de faturamento. A sessão começa quando o usuário começa a digitar uma consulta e é concluída quando ele seleciona um lugar. Cada sessão pode ter várias consultas, seguidas por uma seleção de lugares. Quando uma sessão é concluída, o token deixa de ser válido. O app precisa gerar um token novo para cada sessão. Recomendamos o uso de tokens de sessão para todas as sessões de preenchimento automático programático (quando você incorpora um fragmento ou inicia o preenchimento automático usando uma intent, a API cuida disso automaticamente).

O SDK do Places para Android usa um AutocompleteSessionToken para identificar cada sessão. Seu app precisa transmitir um novo token no início de cada sessão e, em seguida, transmitir esse mesmo token com um ID de local na chamada seguinte para fetchPlace() para recuperar o Place Details do local selecionado pelo usuário.

Saiba mais sobre tokens de sessão.

Restringir resultados do preenchimento automático

É possível restringir os resultados do Autocomplete a uma região geográfica específica e/ou filtrar os resultados por um ou mais tipos de lugar ou por até cinco países. Você pode aplicar essas restrições à atividade de preenchimento automático, AutocompleteSupportFragment e às APIs de preenchimento automático programático.

Para restringir os resultados, faça o seguinte:

• Para preferir resultados dentro da região definida, chame setLocationBias(). Alguns resultados de fora da região definida ainda podem ser retornados.
• Para mostrar somente resultados na região definida, chame setLocationRestriction(). Somente os resultados dentro da região definida serão retornados.
• Para retornar apenas resultados que estejam em conformidade com um tipo de lugar específico, chame setTypesFilter(). Por exemplo, especificar TypeFilter.ADDRESS retornará apenas resultados com um endereço preciso.
• Para retornar apenas resultados dentro de até cinco países especificados, chame setCountries(). Os países precisam ser enviados como um código de país de dois caracteres compatível com ISO 3166-1 Alpha-2.

Viés dos resultados para uma região específica

Para polarizar os resultados do preenchimento automático para uma região geográfica específica, chame setLocationBias(), transmitindo um RectangularBounds. O exemplo de código a seguir mostra a chamada de setLocationBias() em uma instância de fragmento para polarizar as sugestões de preenchimento automático dela para uma região de Sydney, Austrália.

    autocompleteFragment.setLocationBias(RectangularBounds.newInstance(
        new LatLng(-33.880490, 151.184363),
        new LatLng(-33.858754, 151.229596)));

      

    autocompleteFragment.setLocationBias(
        RectangularBounds.newInstance(
            LatLng(-33.880490, 151.184363),
            LatLng(-33.858754, 151.229596)
        )
    )

      

Restringir os resultados a uma região específica

Para restringir os resultados do Autocomplete a uma região geográfica específica, chame setLocationRestriction(), transmitindo um RectangularBounds. O exemplo de código a seguir mostra a chamada de setLocationRestriction() em uma instância de fragmento para influenciar as sugestões de preenchimento automático para uma região de Sydney, Austrália.

    autocompleteFragment.setLocationRestriction(RectangularBounds.newInstance(
        new LatLng(-33.880490, 151.184363),
        new LatLng(-33.858754, 151.229596)));

      

    autocompleteFragment.setLocationRestriction(
        RectangularBounds.newInstance(
            LatLng(-33.880490, 151.184363),
            LatLng(-33.858754, 151.229596)
        )
    )

      

Observação:essa restrição é aplicada apenas a rotas inteiras. Os resultados sintéticos localizados fora dos limites retangulares podem ser retornados com base em uma rota que se sobrepõe à restrição de local.

Filtrar resultados por tipo de lugar ou coleção de tipos

É possível restringir os resultados de uma solicitação de preenchimento automático para que eles retornem apenas um determinado tipo de lugar. Especifique um filtro usando os tipos de lugar ou um conjunto de tipos listado nas Tabelas 1, 2 e 3 em Tipos de lugar. Se nada for especificado, todos os tipos vão ser retornados.

Para filtrar os resultados do preenchimento automático, chame setTypesFilter() para definir o filtro.

Para especificar um tipo ou filtro de coleção de tipos:

• Chame setTypesFilter() e especifique até cinco valores de type nas tabelas 1 e 2 mostradas em Tipos de local. Os valores de tipo são definidos pelas constantes em PlaceTypes.

• Chame setTypesFilter() e especifique uma coleção de tipos da Tabela 3, mostrada em Tipos de lugar. Os valores da coleção são definidos pelas constantes em PlaceTypes.

  Somente um tipo da Tabela 3 é permitido na solicitação. Se você especificar um valor na Tabela 3, não será possível especificar um na Tabela 1 ou na Tabela 2. Se você fizer isso, ocorrerá um erro.

O exemplo de código a seguir chama setTypesFilter() em uma AutocompleteSupportFragment e especifica vários valores de tipo.

    autocompleteFragment.setTypesFilter(Arrays.asList("landmark", "restaurant", "store"));

      

    autocompleteFragment.setTypesFilter(listOf("landmark", "restaurant", "store"))

      

O exemplo de código a seguir mostra a chamada de setTypesFilter() em uma AutocompleteSupportFragment para definir um filtro que retorne apenas resultados com um endereço preciso especificando uma coleção de tipos.

    autocompleteFragment.setTypesFilter(Arrays.asList(TypeFilter.ADDRESS.toString()));

      

    autocompleteFragment.setTypesFilter(listOf(TypeFilter.ADDRESS.toString()))

      

O exemplo de código a seguir mostra a chamada de setTypesFilter() em uma IntentBuilder para definir um filtro que retorne apenas resultados com um endereço preciso especificando uma coleção de tipos.

    Intent intent = new Autocomplete.IntentBuilder(
        AutocompleteActivityMode.FULLSCREEN, fields)
        .setTypesFilter(Arrays.asList(TypeFilter.ADDRESS.toString()))
        .build(this);
    startActivityForResult(intent, AUTOCOMPLETE_REQUEST_CODE);

      

    val intent = Autocomplete.IntentBuilder(AutocompleteActivityMode.FULLSCREEN, fields)
        .setTypesFilter(listOf(TypeFilter.ADDRESS.toString()))
        .build(this)
    startActivityForResult(intent, AUTOCOMPLETE_REQUEST_CODE)

      

Filtrar resultados por país

Para filtrar os resultados do preenchimento automático para até cinco países, chame setCountries() para definir o código do país. Em seguida, passe o filtro a um fragmento ou intent. Os países precisam ser transmitidos como um código de país de dois caracteres compatível com ISO 3166-1 Alfa-2.

O exemplo de código a seguir mostra a chamada de setCountries() em um AutocompleteSupportFragment para definir um filtro que retorne apenas resultados nos países especificados.

    autocompleteFragment.setCountries("AU", "NZ");

      

    autocompleteFragment.setCountries("AU", "NZ")

      

Limites de uso

O uso da API Places, incluindo o SDK do Places para Android, não está mais limitado a um número máximo de solicitações por dia (QPD). No entanto, os seguintes limites de uso ainda se aplicam:

• O limite de taxa é de 100 solicitações por segundo (QPS). É calculado como a soma das solicitações do lado do cliente e do servidor para todos os aplicativos que usam as credenciais do mesmo projeto.

Exibir atribuições no seu aplicativo

• Se o app usa o serviço de preenchimento automático de forma programática, a IU precisa exibir uma atribuição "Tecnologia do Google" ou aparecer em um mapa com marca do Google.
• Se o app usa o widget de preenchimento automático, nenhuma outra ação é necessária (a atribuição necessária é exibida por padrão).
• Se você recuperar e exibir outras informações do lugar depois de conseguir um lugar por ID, também será necessário exibir atribuições de terceiros.

Para mais detalhes, consulte a documentação sobre atribuições.

Otimização do Place Autocomplete

Esta seção descreve as práticas recomendadas para você aproveitar ao máximo o serviço Place Autocomplete.

Aqui estão algumas diretrizes gerais:

• A maneira mais rápida de desenvolver uma interface do usuário funcional é usar o widget do Autocomplete da API Maps JavaScript, o widget do Autocomplete do SDK do Places para Android ou Controle de IU do Autocomplete do SDK do Places para iOS.
• Entender os campos de dados essenciais do Place Autocomplete desde o início.
• Os campos de direcionamento de local e restrição de local são opcionais, mas podem afetar bastante a performance do preenchimento automático.
• Use o tratamento de erros para garantir que o aplicativo faça uma degradação simples se a API retornar um erro.
• Verifique se o app continua funcionando quando não há seleção e que oferece às pessoas uma maneira de continuar.

Práticas recomendadas de otimização de custos

Otimização básica de custos

Para otimizar o custo do uso do serviço Place Autocomplete, use máscaras de campo nos widgets Place Details e Place Autocomplete para retornar apenas os campos de dados de lugar necessários.

Otimização avançada de custos

Faça a implementação programática do Place Autocomplete para acessar preços por solicitação e pedir resultados da API Geocoding sobre o lugar selecionado em vez do Place Details. O preço por solicitação combinado com a API Geocoding vai ser mais econômico que o preço por sessão se as duas condições a seguir forem atendidas:

• Se você só precisa da latitude/longitude ou do endereço do local selecionado pela pessoa, a API Geocoding fornece essas informações por menos do que uma chamada do Place Details.
• Se os usuários selecionarem uma previsão de preenchimento automático em média com quatro solicitações desse tipo, o preço por solicitação poderá ser mais econômico que o custo por sessão.

Seu aplicativo requer outras informações além do endereço e da latitude/longitude da previsão selecionada?

Práticas recomendadas de performance

As diretrizes a seguir descrevem como otimizar a performance do Place Autocomplete:

• Adicione restrições de país, direcionamento de local e preferência de idioma (para implementações programáticas) à implementação do Place Autocomplete. A preferência de idioma não é necessária com widgets porque eles usam o que está definido no navegador ou no dispositivo móvel do usuário.
• Se o Place Autocomplete estiver acompanhado por um mapa, é possível direcionar o local por janela de visualização do mapa.
• Quando a pessoa não escolhe uma das previsões do Autocomplete, geralmente porque nenhuma delas revisões é o endereço que ela quer, você pode reutilizar a entrada original para tentar receber resultados mais relevantes:
  • Se quiser que o usuário insira apenas informações de endereço, reutilize a entrada original dele em uma chamada para a API Geocoding.
  • Se quiser que o usuário insira consultas para um lugar específico por nome ou endereço, use uma solicitação do Find Place. Se os resultados forem esperados apenas em uma região específica, use o direcionamento de local.
  Outros cenários em que é melhor voltar para a API Geocoding são:
  • Usuários que inserem endereços de sublocal em países onde a compatibilidade do Place Autocomplete com esse tipo de endereço é parcial (como República Tcheca, Estônia e Lituânia). Por exemplo, o endereço tcheco "Stroupežnického 3191/17, Praha" gera uma previsão parcial no Place Autocomplete.
  • Usuários que digitam endereços com prefixos de trechos de via, como "23-30 29th St, Queens", na cidade de Nova York, ou "47-380 Kamehameha Hwy, Kaneohe", na ilha de Kauai, no Havaí.

Solução de problemas

Embora uma grande variedade de erros possa ocorrer, a maioria dos erros que seu app provavelmente receberá é causada por erros de configuração. Por exemplo, a chave de API incorreta foi usada ou a chave de API foi configurada incorretamente, ou erros de cota (o app excedeu a cota). Consulte Limites de uso para mais informações sobre cotas.

Os erros que ocorrem no uso dos controles de preenchimento automático são retornados no callback onActivityResult(). Chame Autocomplete.getStatus() para receber a mensagem de status do resultado.