Vous êtes prêt !

Pour passer à l'étape de développement, accédez à notre documentation pour les développeurs.

Activer Google Places API for Android

Pour commencer, nous allons vous guider à travers la console Google Developers et effectuer deux ou trois petites choses :

  1. Créer ou choisir un projet
  2. Activer Google Places API for Android
  3. Créer les clés appropriées
Continuer

Photos de lieu

Vous pouvez utiliser Google Places API for Android pour demander des photos de lieu à afficher dans votre application. Les photos renvoyées par le service photos sont extraites de sources variées, notamment les propriétaires d'entreprise et les photos fournies par les utilisateurs de Google+. Pour obtenir des images de lieu, procédez comme suit :

  1. Appelez GeoDataApi.getPlacePhotos() en spécifiant une chaîne avec un identifiant de lieu. Vous obtenez alors une instance PlacePhotoMetadataResult.
  2. Appelez getPhotoMetadata() sur l'instance PlacePhotoMetadataResult pour obtenir un objet PlacePhotoMetadataBuffer contenant une liste d'instances PlacePhotoMetadata (une pour chaque photo).
  3. Appelez get() sur l'instance PlacePhotoMetadataBuffer en indiquant un entier pour extraire l'instance PlacePhotoMetadata à l'index donné.

Google Places API for Android nécessite un accès réseau. Tous les appels doivent donc être exécutés en arrière-plan, en-dehors du thread IU principal. C'est pourquoi nous recommandons d'extraire les photos en arrière-plan de manière asynchrone. Pour des exemples de cette procédure, voir Obtenir des photos en arrière-plan à l'aide d'AsyncTask et Obtenir des photos en arrière-plan à l'aide de ResultCallback.

L'extrait de code simplifié suivant décrit l'extraction d'une liste de photos pour un lieu.

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

L'extrait de code simplifié suivant décrit l'extraction d'une instance PlacePhotoMetadata, puis l'utilisation de cette instance pour obtenir une image bitmap plein format et le texte de mention :

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

Obtenir des photos en arrière-plan à l'aide d'AsyncTask

Il est recommandé d'utiliser AsyncTask pour intégrer des photos de lieu dans votre application. Pour cela, suivez la procédure récapitulative suivante :

  1. Connectez-vous à Places API.
  2. Créez une classe de tâche qui s'étend à AsyncTask pour englober les appels permettant d'extraire une instance PlacePhotoMetadata et de demander l'image.
  3. Créez une méthode qui permet d'instancier cette classe pour traiter les demandes d'image.

Créer une classe de tâche de photo

L'exemple de classe suivant s'appuie sur un identifiant de lieu et extrait la première photo de la liste renvoyée. Vous pouvez utiliser cette classe comme modèle pour la classe à créer dans votre application.

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

Traiter les requêtes de photo

L'exemple suivant illustre la création d'une méthode qui instancie l'exemple de classe (PhotoTask) pour demander des images correspondant à un lieu.

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

Obtenir des photos en arrière-plan à l'aide de ResultCallback

Outre via AsyncTask, vous pouvez demander des photos de manière asynchrone en utilisant ResultCallback. L'exemple de code suivant illustre la procédure à suivre.

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

Mentions

Dans la plupart des cas, les photos de lieu peuvent être utilisées sans mention ou bien la mention requise est incluse dans l'image. Toutefois, si l'instance PlacePhotoMetadata renvoyée inclut une mention, vous devez inclure la mention supplémentaire dans votre application avec l'image affichée. Pour plus d'informations, voir Afficher les mentions.

Limites d'utilisation

L'extraction d'une image correspond à une unité de quota. Il n'y a aucune limite d'utilisation quant à l'extraction des métadonnées de photo. Voir la documentation sur les limites d'utilisation.

Envoyer des commentaires concernant…

location_on
Google Places API for Android