Eso es todo.

Para comenzar a desarrollar, consulta nuestra documentación para desarrolladores.

Activar la Google Places API for Android

Para que puedas comenzar, te proporcionaremos orientación en la consola para desarrolladores de Google a fin de que hagas primero algunas acciones:

  1. Crear o seleccionar un proyecto
  2. Activar la Google Places API for Android
  3. Crear claves correspondientes
Continuar

Fotos de sitios

Puedes usar la Google Places API for Android para solicitar fotos de sitios que se mostrarán en tu aplicación. Las fotos devueltas por el servicio de fotos provienen de diversas fuentes, como los propietarios comerciales y los usuarios de Google+. Para recuperar imágenes de un sitio, debes seguir estos pasos:

  1. Llama a GeoDataApi.getPlacePhotos() pasando una string con un ID de sitio. Esto muestra una instancia de PlacePhotoMetadataResult.
  2. Llama a getPhotoMetadata() en la instancia de PlacePhotoMetadataResult para obtener un PlacePhotoMetadataBuffer con una lista de instancias de PlacePhotoMetadata (una por cada foto).
  3. Llama a get() en la instancia de PlacePhotoMetadataBuffer, el cual pasa un entero para recuperar la instancia de PlacePhotoMetadata en el índice determinado.

Google Places API for Android requiere acceso a la red. Por lo tanto, todas las llamadas deben hacerse en segundo plano, fuera del subproceso principal de la IU. Por esto, te recomendamos recuperar fotos en segundo plano de manera asincrónica. Para hallar ejemplos en los que se muestre la manera de hacer esto, consulta Obtener fotos en segundo plano usando AsyncTask y Obtener fotos en segundo plano usando ResultCallback.

En el siguiente fragmento de código simplificado se demuestra la obtención de una lista de fotos de un lugar.

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

En el siguiente fragmento de código simplificado se demuestra la obtención de una instancia de PlacePhotoMetadata y el uso de esta para obtener una imagen de mapa de bits de tamaño completo y texto de atribución:

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

Obtener fotos en segundo plano usando AsyncTask

Te recomendamos usar AsyncTask para implementar fotos de sitios en tu app. A continuación, te ofrecemos un resumen de los pasos que debes seguir para poder hacer esto:

  1. Conéctate a la Places API.
  2. Crea una tarea que extienda AsyncTask a fin de encapsular las llamadas para recuperar PlacePhotoMetadata y solicitar la imagen.
  3. Crea un método en el que se originen instancias de esa clase para administrar solicitudes de imágenes.

Crear una clase de tarea de foto

En la siguiente clase de ejemplo se toma un id. de sitio y se obtiene la primera foto en de la lista devuelta. Puedes usar esta clase a modo de plantilla para la clase que crearás en tu propia aplicación.

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

Administrar solicitudes de fotos

En el siguiente ejemplo se demuestra la creación de un método en el que se originan instancias de la clase del ejemplo (PhotoTask), con el fin de solicitar imágenes para un sitio.

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

Obtener fotos en segundo plano usando ResultCallback

Como alternativa para AsyncTask, puedes crear solicitudes de fotos de manera asincrónica usando ResultCallback. En el siguiente ejemplo de código se demuestra la manera de hacerlo.

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

Atribuciones

En la mayoría de los casos, las fotos de sitios podrán usarse sin atribución o tendrán la atribución requerida incluida como parte de la imagen. Sin embargo, si en la instancia PlacePhotoMetadata devuelta se incluye una atribución, debes incluir la atribución adicional en tu aplicación en cualquier lugar en donde muestres la imagen. Para obtener más información, consulta Visualización de atribuciones.

Límites de uso

La recuperación de una foto demanda una unidad de cuota. No hay límites de uso para recuperar metadatos de fotos. Consulta la documentación sobre los límites de uso.

Enviar comentarios sobre...