Pronto!

Para começar a desenvolver, acesse nossa documentação do desenvolvedor.

Ativar a API do Google Places para Android

Para começar, orientaremos você pelo Console de Desenvolvedores do Google para realizar algumas atividades:

  1. Criar ou selecionar um projeto
  2. Ativar a Google Places API for Android
  3. Criar chaves apropriadas
Continuar

Place Photos

É possível usar a Google Places API for Android para solicitar que fotos de locais sejam exibidas no seu aplicativo. Fotos retornadas pelo serviço de fotos têm origens variadas, incluindo proprietários de empresas e usuários do Google+. Execute as seguintes etapas para recuperar imagens de um local:

  1. Chame GeoDataApi.getPlacePhotos() passando uma string com um ID de local. Isso retorna uma instância de PlacePhotoMetadataResult.
  2. Chame getPhotoMetadata() na instância de PlacePhotoMetadataResult para obter um PlacePhotoMetadataBuffer com uma lista de instâncias de PlacePhotoMetadata (uma para cada foto).
  3. Chame get() na instância de PlacePhotoMetadataBuffer passando um número inteiro para recuperar a instância de PlacePhotoMetadata no índice fornecido.

A Google Places API for Android exige acesso à rede. Dessa forma, todas as chamadas devem ser feitas em segundo plano, fora do encadeamento principal da IU. Por esse motivo, recomendamos recuperar fotos em segundo plano de forma assíncrona. Para conferir exemplos de como fazer isso, consulte Obter fotos em segundo plano usando AsyncTask e Obter fotos em segundo plano usando ResultCallback.

O fragmento de código simplificado a seguir demonstra como obter uma lista de fotos para um local.

// Get a PlacePhotoMetadataResult containing metadata for the first 10 photos.
PlacePhotoMetadataResult result = Places.GeoDataApi
      .getPlacePhotos(mGoogleApiClient, placeId).await();
// Get a PhotoMetadataBuffer instance containing a list of photos (PhotoMetadata).
if (result != null && result.getStatus().isSuccess()) {
      PlacePhotoMetadataBuffer photoMetadataBuffer = result.getPhotoMetadata();
}

O fragmento de código simplificado a seguir demonstra como obter uma instância de PlacePhotoMetadata e usá-la para obter uma imagem bitmap completa e um texto de atribuição:

// Get the first photo in the list.
PlacePhotoMetadata photo = photoMetadataBuffer.get(0);
// Get a full-size bitmap for the photo.
Bitmap image = photo.getPhoto(mGoogleApiClient).await()
    .getBitmap();
// Get the attribution text.
CharSequence attribution = photo.getAttributions();

Obter fotos em segundo plano usando AsyncTask

Recomendamos usar AsyncTask para implementar fotos de locais em seu aplicativo. Veja a seguir um resumo das etapas necessárias para isso:

  1. Conecte-se à Places API.
  2. Crie uma classe de tarefa que estenda AsyncTask para encapsular as chamadas para recuperar PlacePhotoMetadata e solicitar a imagem.
  3. Crie um método para instanciar essa classe para processar solicitações de imagem.

Criar uma classe de tarefa de foto

O exemplo de classe a seguir coleta um ID de local e obtém a primeira foto na lista retornada. Use essa classe como modelo para criar a classe no seu próprio aplicativo.

abstract class PhotoTask extends AsyncTask<String, Void, PhotoTask.AttributedPhoto> {

    private int mHeight;

    private int mWidth;

    public PhotoTask(int width, int height) {
        mHeight = height;
        mWidth = width;
    }

    /**
     * Loads the first photo for a place id from the Geo Data API.
     * The place id must be the first (and only) parameter.
     */
    @Override
    protected AttributedPhoto doInBackground(String... params) {
        if (params.length != 1) {
            return null;
        }
        final String placeId = params[0];
        AttributedPhoto attributedPhoto = null;

        PlacePhotoMetadataResult result = Places.GeoDataApi
                .getPlacePhotos(mGoogleApiClient, placeId).await();

        if (result.getStatus().isSuccess()) {
            PlacePhotoMetadataBuffer photoMetadataBuffer = result.getPhotoMetadata();
            if (photoMetadata.getCount() > 0 && !isCancelled()) {
                // Get the first bitmap and its attributions.
                PlacePhotoMetadata photo = photoMetadata.get(0);
                CharSequence attribution = photo.getAttributions();
                // Load a scaled bitmap for this photo.
                Bitmap image = photo.getScaledPhoto(mGoogleApiClient, mWidth, mHeight).await()
                        .getBitmap();

                attributedPhoto = new AttributedPhoto(attribution, image);
            }
            // Release the PlacePhotoMetadataBuffer.
            photoMetadataBuffer.release();
        }
        return attributedPhoto;
    }

    /**
     * Holder for an image and its attribution.
     */
    class AttributedPhoto {

        public final CharSequence attribution;

        public final Bitmap bitmap;

        public AttributedPhoto(CharSequence attribution, Bitmap bitmap) {
            this.attribution = attribution;
            this.bitmap = bitmap;
        }
    }
}

Processar solicitações de foto

O exemplo a seguir demonstra como criar um método que instancie o exemplo de classe (PhotoTask) para solicitar imagens para um local.

private void placePhotosTask() {
    final String placeId = "ChIJrTLr-GyuEmsRBfy61i59si0"; // Australian Cruise Group

    // Create a new AsyncTask that displays the bitmap and attribution once loaded.
    new PhotoTask(mImageView.getWidth(), mImageView.getHeight()) {
        @Override
        protected void onPreExecute() {
            // Display a temporary image to show while bitmap is loading.
            mImageView.setImageResource(R.drawable.empty_photo);
        }

        @Override
        protected void onPostExecute(AttributedPhoto attributedPhoto) {
            if (attributedPhoto != null) {
                // Photo has been loaded, display it.
                mImageView.setImageBitmap(attributedPhoto.bitmap);

                // Display the attribution as HTML content if set.
                if (attributedPhoto.attribution == null) {
                    mText.setVisibility(View.GONE);
                } else {
                    mText.setVisibility(View.VISIBLE);
                    mText.setText(Html.fromHtml(attributedPhoto.attribution.toString()));
                }

            }
        }
    }.execute(placeId);
}

Obter fotos em segundo plano usando ResultCallback

Como uma alternativa para o recurso AsyncTask, é possível fazer solicitações de foto de maneira assíncrona ao usar ResultCallback. O exemplo de código a seguir demonstra como fazer isso.

private ResultCallback<PlacePhotoResult> mDisplayPhotoResultCallback
        = new ResultCallback<PlacePhotoResult>() {
    @Override
    public void onResult(PlacePhotoResult placePhotoResult) {
        if (!placePhotoResult.getStatus().isSuccess()) {
            return;
        }
        mImageView.setImageBitmap(placePhotoResult.getBitmap());
    }
};

/**
 * Load a bitmap from the photos API asynchronously
 * by using buffers and result callbacks.
 */
private void placePhotosAsync() {
    final String placeId = "ChIJrTLr-GyuEmsRBfy61i59si0"; // Australian Cruise Group
    Places.GeoDataApi.getPlacePhotos(mGoogleApiClient, placeId)
            .setResultCallback(new ResultCallback<PlacePhotoMetadataResult>() {


                @Override
                public void onResult(PlacePhotoMetadataResult photos) {
                    if (!photos.getStatus().isSuccess()) {
                        return;
                    }

                    PlacePhotoMetadataBuffer photoMetadataBuffer = photos.getPhotoMetadata();
                    if (photoMetadataBuffer.getCount() > 0) {
                        // Display the first bitmap in an ImageView in the size of the view
                        photoMetadataBuffer.get(0)
                                .getScaledPhoto(mGoogleApiClient, mImageView.getWidth(),
                                        mImageView.getHeight())
                                .setResultCallback(mDisplayPhotoResultCallback);
                    }
                    photoMetadataBuffer.release();
                }
            });
}

Atribuições

Na maioria dos casos, fotos de locais podem ser usadas sem atribuição ou terão a atribuição necessária incluída como parte da imagem. No entanto, se a instância de PlacePhotoMetadata retornada incluir uma atribuição, será necessário incluir a atribuição adicional no aplicativo em qualquer lugar que exiba a imagem. Para saber mais, consulte Exibir atribuições.

Limites de uso

A recuperação de uma imagem custa uma unidade de cota e não há limites de uso para recuperar metadados de fotos. Consulte a documentação sobre limites de uso.

Enviar comentários sobre…

location_on
Google Places API for Android