Google Places API photo_reference

Question

I have been trying to extract the goolge places api photo reference but have not had any success. I was wondering if someone could help me. Below is my code:

// KEY Strings
public static String KEY_REFERENCE = "reference"; // id of the place
public static String KEY_NAME = "name"; // name of the place
public static String KEY_VICINITY = "vicinity"; // Place area name
public static String KEY_PHOTO = "photo_reference";

class LoadPlaces extends AsyncTask<String, String, String> {

    /**
     * getting google places JSON response
     * */

    protected String doInBackground(String... args) {
        // creating Places class object
        googlePlaces = new GooglePlaces();

        try {
            String types = MenuActivity.type;
            String keyword = MenuActivity.keyword;

             // get nearest places
            nearPlaces = googlePlaces.search(gps.getLatitude(),gps.getLongitude(), 
            types, keyword); 

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    protected void onPostExecute(String file_url) {
        // updating UI from Background Thread

        runOnUiThread(new Runnable() {
            public void run() {
                /**
                 * Updating parsed Places into LISTVIEW
                 * */

                // Get JSON response status
                String status = nearPlaces.status;

                // Check for OK status
                if (status.equals("OK")) {
                    // Successfully got places details
                    if (nearPlaces.results != null) {
                        // loop through each place
                        for (Place p : nearPlaces.results) {
                            HashMap<String, String> map = new HashMap<String, String>();

                            map.put(KEY_REFERENCE, p.reference);
                            map.put(KEY_NAME, p.name);
                            map.put(KEY_PHOTO,p.photo);
                            map.put(KEY_VICINITY, p.vicinity);

                            // adding HashMap to ArrayList
                            placesListItems.add(map);

                        }
                        // list adapter - removed rating
                        ListAdapter adapter = new SimpleAdapter(
                                MainActivity.this, placesListItems,
                                R.layout.list_item, new String[] {
                                KEY_REFERENCE, KEY_NAME, KEY_VICINITY, KEY_PHOTO},
                                new int[] { R.id.reference, R.id.name, R.id.address, R.id.phptp});

                        // Adding data into ListView
                        lv.setAdapter(adapter);
                    }
                } 
}

Below is my code that performs the search and parses the data:

 public class GooglePlaces {

/** Global instance of the HTTP transport. */
private static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
private static final String LOG_KEY = "GGPlace";

// Google API Key
private static final String API_KEY = ""; 

// Google Places serach 
private static final String PLACES_SEARCH_URL = "https://maps.googleapis.com/maps/api/place/nearbysearch/json?&rankby=distance";

private double _latitude;
private double _longitude;
private double _radius;
private String address;

public PlacesList search(double latitude, double longitude, String types, String keyword) 
        throws Exception {

    this._latitude = latitude;
    this._longitude = longitude;

    try {

        HttpRequestFactory httpRequestFactory = createRequestFactory(HTTP_TRANSPORT);
        HttpRequest request = httpRequestFactory.buildGetRequest(new GenericUrl(PLACES_SEARCH_URL));
        request.getUrl().put("key", API_KEY);
        request.getUrl().put("location", _latitude + "," + _longitude);
        request.getUrl().put("sensor", "true");
        if(types != null)
        {
            request.getUrl().put("types", types);
            request.getUrl().put("keyword", keyword);
        }

        PlacesList list = request.execute().parseAs(PlacesList.class);
        // Check log cat for places response status
        Log.d("Places Status", "" + list.status);
        return list;

    } catch (HttpResponseException e) {
        Log.e("Error:", e.getMessage());
        return null;
    }

}
public static HttpRequestFactory createRequestFactory(
        final HttpTransport transport) {
    return transport.createRequestFactory(new HttpRequestInitializer() {
        public void initialize(HttpRequest request) {
            GoogleHeaders headers = new GoogleHeaders();
            headers.setApplicationName("APP NAME");
            headers.gdataVersion="2";
            request.setHeaders(headers);
            JsonHttpParser parser = new JsonHttpParser(new JacksonFactory());
            request.addParser(parser);
        }
    });
}
}

This is my PlaceList class:

public class PlacesList implements Serializable {
@Key
public String status;

@Key
public List<Place> results;

}

Here is my Place class:

 public class Place implements Serializable {

@Key
public String id;

@Key
public String name;

@Key
public String reference;

@Key
public String vicinity;

@Key
public Geometry geometry;

@Key
public List<Photo> photos;
}

And finally my Photo class:

public class Photo implements Serializable {

@Key
public String photo_reference;

@Key
public int height;

@Key
public int width;

}  

I guess I am calling or passing the photo_reference the wrong way. I am hoping there is someone out there that can help me out. I've been working on this for weeks and have almost completely given up.

Answer 1

I first misunderstood photo_reference as Base64 Encoded String. But it is not indeed it is a reference parameter to identify and fetch a photo from google maps API. Imagine this as a token parameter. So to fetch a photo with max-width 400 you can use below URL.

https://maps.googleapis.com/maps/api/place/photo?maxwidth=400&photoreference=CnRtAAAATLZNl354RwP_9UKbQ_5Psy40texXePv4oAlgP4qNEkdIrkyse7rPXYGd9D_Uj1rVsQdWT4oRz4QrYAJNpFX7rzqqMlZw2h2E2y5IKMUZ7ouD_SlcHxYq1yL4KbKUv3qtWgTK0A6QbGh87GB3sscrHRIQiG2RrmU_jF4tENr9wGS_YxoUSSDrYjWmrNfeEHSGSc3FyhNLlBU&key=YOUR_API_KEY

For more details visit Google Places documentation https://developers.google.com/places/web-service/photos

Answer 2

Hi firstly your search url is wrong.

You have to follow this format:

https://developers.google.com/places/web-service/photos

Please see below for a complete example:

http://wptrafficanalyzer.in/blog/showing-nearby-places-with-photos-at-any-location-in-google-maps-android-api-v2/

If you download the source code, it will help you see how to fetch the json string in an array which is in another array.

The snippet below just answers the part where you have to fetch the image:

package in.wptrafficanalyzer.locationnearbyplacesphotos;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

public class PlaceJSONParser {

    /** Receives a JSONObject and returns a list */
    public Place[] parse(JSONObject jObject){       

        JSONArray jPlaces = null;
        try {           
            /** Retrieves all the elements in the 'places' array */
            jPlaces = jObject.getJSONArray("results");
        } catch (JSONException e) {
            e.printStackTrace();
        }
        /** Invoking getPlaces with the array of json object
         * where each json object represent a place
         */
        return getPlaces(jPlaces);
    }


    private Place[] getPlaces(JSONArray jPlaces){
        int placesCount = jPlaces.length();     
        Place[] places = new Place[placesCount];    

        /** Taking each place, parses and adds to list object */
        for(int i=0; i<placesCount;i++){
            try {
                /** Call getPlace with place JSON object to parse the place */
                places[i] = getPlace((JSONObject)jPlaces.get(i));               


            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        return places;
    }

    /** Parsing the Place JSON object */
    private Place getPlace(JSONObject jPlace){

        Place place = new Place();



        try {
            // Extracting Place name, if available
            if(!jPlace.isNull("name")){             
                place.mPlaceName = jPlace.getString("name");
            }

            // Extracting Place Vicinity, if available
            if(!jPlace.isNull("vicinity")){
                place.mVicinity = jPlace.getString("vicinity");
            }   

            if(!jPlace.isNull("photos")){
                JSONArray photos = jPlace.getJSONArray("photos");
                place.mPhotos = new Photo[photos.length()];
                for(int i=0;i<photos.length();i++){
                    place.mPhotos[i] = new Photo();
                    place.mPhotos[i].mWidth = ((JSONObject)photos.get(i)).getInt("width");
                    place.mPhotos[i].mHeight = ((JSONObject)photos.get(i)).getInt("height");
                    place.mPhotos[i].mPhotoReference = ((JSONObject)photos.get(i)).getString("photo_reference");
                    JSONArray attributions = ((JSONObject)photos.get(i)).getJSONArray("html_attributions");
                    place.mPhotos[i].mAttributions = new Attribution[attributions.length()];
                    for(int j=0;j<attributions.length();j++){
                        place.mPhotos[i].mAttributions[j] = new Attribution();
                        place.mPhotos[i].mAttributions[j].mHtmlAttribution = attributions.getString(j);
                    }                   
                }
            }

            place.mLat = jPlace.getJSONObject("geometry").getJSONObject("location").getString("lat");
            place.mLng = jPlace.getJSONObject("geometry").getJSONObject("location").getString("lng");                       



        } catch (JSONException e) {         
            e.printStackTrace();
            Log.d("EXCEPTION", e.toString());
        }       
        return place;
    }
}