{"id":310,"date":"2010-09-15T20:48:00","date_gmt":"2010-09-15T20:48:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/android-reverse-geocoding-with-yahoo-api-placefinder.html"},"modified":"2012-10-21T19:19:07","modified_gmt":"2012-10-21T19:19:07","slug":"android-reverse-geocoding-yahoo-api","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2010\/09\/android-reverse-geocoding-yahoo-api.html","title":{"rendered":"Android Reverse Geocoding with Yahoo API – PlaceFinder"},"content":{"rendered":"

In my previous tutorial (Android Location Based Services Application \u2013 GPS location<\/a>) I showed you how to retrieve the user’s current location in the form of latitude and longitude coordinates. Using those coordinates we are going to provide information regarding the user’s position. For example, we are going to find the street address nearest to a specific point. That process is called reverse Geocoding<\/a> and it is the reverse process of Geocoding<\/a>, which involves finding associated geographic coordinates (often expressed as latitude and longitude) from other geographic data, such as street addresses, or zip codes (postal codes).<\/p>\n

For that purpose, we are going to use Yahoo! PlaceFinder, a super cool API for geocoding and reverse geocoding. From the official site<\/a>:<\/p>\n

\u201cYahoo! PlaceFinder is a geocoding Web service that helps developers make their applications location-aware by converting street addresses or place names into geographic coordinates (and vice versa).\u201d<\/p>\n

In order to use the API, you are going to need a key<\/a> (totally free). However, for the purposes of this tutorial, a key is not required. We are going to use the sample request which can be reached here<\/a>. The response is in XML format so an XML parser will be needed. Don’t worry though, since Android has included XML capabilities in its core API.<\/p>\n

Another thing to note is that PlaceFinder is a web API, so in order to be used by an Android application, the device has to be connected to the… well… web. Moreover, an HTTP client will have to be used by our application. Again, don’t worry because the Android API includes Apache’s HTTP Client<\/a> for that purpose.<\/p>\n

So, let’s get started. We are going to continue from where we left the previous tutorial. Please check it out<\/a> if you haven’t already read it. You can download the Eclipse project from here<\/a>.<\/p>\n

First, we add a new Button<\/a> which will trigger the reverse geocoding procedure. Thus, the \u201cmain.xml\u201d file for the user interface becomes as follows:<\/p>\n

<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<LinearLayout xmlns:android=\"http:\/\/schemas.android.com\/apk\/res\/android\"\r\n    android:orientation=\"vertical\"\r\n    android:layout_width=\"fill_parent\"\r\n    android:layout_height=\"fill_parent\"\r\n    >\r\n<Button\r\n android:id=\"@+id\/retrieve_location_button\" \r\n android:text=\"Retrieve Location\"\r\n android:layout_width=\"wrap_content\" \r\n android:layout_height=\"wrap_content\" \r\n \/>\r\n<Button \r\n android:id=\"@+id\/reverse_geocoding_button\" \r\n android:text=\"Reverse Geocoding\"\r\n android:layout_width=\"wrap_content\" \r\n android:layout_height=\"wrap_content\" \r\n \/>\r\n<\/LinearLayout>\r\n<\/pre>\n
The new button gets hooked up with a OnClickListener<\/a> and when it is clicked, the \u201cperformReverseGeocodingInBackground\u201d method is invoked. In that method, the current location is retrieved (as shown in the previous tutorial). A Location<\/a> instance object, named \u201ccurrentLocation\u201d is used in order to store the user’s latest known location. Then, the reverse geocoding procedure gets started.<\/p>\n
Note that the operation will take place in the background, meaning it will execute in a thread other than the main UI thread. This is because Android is very sensitive in responsiveness issues<\/a>. Fetching data from the internet can be a time consuming operation and we don’t want to pause the main thread while the HTTP client waits for the data to be downloaded. Also note that stalling the main thread UI for more than five seconds will trigger an \u201cApplication Not Responding\u201d (ANR) dialog, where the user is given the opportunity to kill your application. Not very good. <\/p>\n
For that reason, we will execute the data retrieval operation in a new thread, leveraging the Android API. The class that we will use extends the AsyncTask<\/a> and is named \u201cReverseGeocodeLookupTask\u201d. From the official documentation page, \u201cAsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and\/or handlers\u201d.<\/p>\n
There are three methods that we will override. First, onPreExecute<\/a>, which occurs in the main thread and is generally used for initialization purposes. In our implementation, we use a ProgressDialog<\/a> widget to let the user know that some operation is taking place. Second, the doInBackground<\/a> method, in which a computation is performed on a background thread and a result object (defined by the subclass of this task) is returned.  In our implementation, the XML data are retrieved and parsed (as I will show you in a minute) and we pass back a domain model class named \u201cGeoCodeResult\u201d which is a placeholder for the location data. Third, the onPostExecute<\/a>, which also runs on the UI thread and is used for cleanup purposes. In our case, the ProgressDialog<\/a> is cancelled and a Toast<\/a> notification presents the retrieved data to the user. Incorporating all the above, the code for our main Activity is now the following:<\/p>\n
package com.javacodegeeks.android.lbs;\r\n\r\nimport android.app.Activity;\r\nimport android.app.ProgressDialog;\r\nimport android.content.Context;\r\nimport android.location.Location;\r\nimport android.location.LocationListener;\r\nimport android.location.LocationManager;\r\nimport android.os.AsyncTask;\r\nimport android.os.Bundle;\r\nimport android.view.View;\r\nimport android.view.View.OnClickListener;\r\nimport android.widget.Button;\r\nimport android.widget.Toast;\r\n\r\nimport com.javacodegeeks.android.lbs.model.GeoCodeResult;\r\nimport com.javacodegeeks.android.lbs.services.GeoCoder;\r\n\r\npublic class LbsGeocodingActivity extends Activity {\r\n    \r\n    private static final long MINIMUM_DISTANCE_CHANGE_FOR_UPDATES = 1; \/\/ in Meters\r\n    private static final long MINIMUM_TIME_BETWEEN_UPDATES = 1000; \/\/ in Milliseconds\r\n    \r\n    private GeoCoder geoCoder = new GeoCoder();\r\n    \r\n    protected LocationManager locationManager;\r\n    protected Location currentLocation;\r\n\r\n    protected Button retrieveLocationButton;\r\n    protected Button reverseGeocodingButton;\r\n    \r\n    @Override\r\n    public void onCreate(Bundle savedInstanceState) {\r\n        \r\n        super.onCreate(savedInstanceState);\r\n        setContentView(R.layout.main);\r\n\r\n        retrieveLocationButton = (Button) findViewById(R.id.retrieve_location_button);\r\n        reverseGeocodingButton = (Button) findViewById(R.id.reverse_geocoding_button);\r\n        \r\n        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);\r\n        \r\n        locationManager.requestLocationUpdates(\r\n                LocationManager.GPS_PROVIDER, \r\n                MINIMUM_TIME_BETWEEN_UPDATES, \r\n                MINIMUM_DISTANCE_CHANGE_FOR_UPDATES,\r\n                new MyLocationListener()\r\n        );\r\n        \r\n        retrieveLocationButton.setOnClickListener(new OnClickListener() {\r\n            @Override\r\n            public void onClick(View v) {\r\n                showCurrentLocation();\r\n            }\r\n        });\r\n        \r\n        reverseGeocodingButton.setOnClickListener(new OnClickListener() {            \r\n            @Override\r\n            public void onClick(View v) {                \r\n                performReverseGeocodingInBackground();\r\n            }\r\n        });\r\n        \r\n    }    \r\n\r\n    protected void performReverseGeocodingInBackground() {\r\n        showCurrentLocation();\r\n        new ReverseGeocodeLookupTask().execute((Void[])null);\r\n    }\r\n\r\n    protected void showCurrentLocation() {\r\n\r\n        currentLocation = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);\r\n\r\n        if (currentLocation != null) {\r\n            String message = String.format(\r\n                    \"Current Location \\n Longitude: %1$s \\n Latitude: %2$s\",\r\n                    currentLocation.getLongitude(), currentLocation.getLatitude()\r\n            );\r\n            Toast.makeText(LbsGeocodingActivity.this, message,\r\n                    Toast.LENGTH_LONG).show();\r\n        }\r\n\r\n    }   \r\n\r\n    private class MyLocationListener implements LocationListener {\r\n\r\n        public void onLocationChanged(Location location) {\r\n            String message = String.format(\r\n                    \"New Location \\n Longitude: %1$s \\n Latitude: %2$s\",\r\n                    location.getLongitude(), location.getLatitude()\r\n            );\r\n            Toast.makeText(LbsGeocodingActivity.this, message, Toast.LENGTH_LONG).show();\r\n        }\r\n\r\n        public void onStatusChanged(String s, int i, Bundle b) {\r\n            Toast.makeText(LbsGeocodingActivity.this, \"Provider status changed\",\r\n                    Toast.LENGTH_LONG).show();\r\n        }\r\n\r\n        public void onProviderDisabled(String s) {\r\n            Toast.makeText(LbsGeocodingActivity.this,\r\n                    \"Provider disabled by the user. GPS turned off\",\r\n                    Toast.LENGTH_LONG).show();\r\n        }\r\n\r\n        public void onProviderEnabled(String s) {\r\n            Toast.makeText(LbsGeocodingActivity.this,\r\n                    \"Provider enabled by the user. GPS turned on\",\r\n                    Toast.LENGTH_LONG).show();\r\n        }\r\n\r\n    }\r\n    \r\n    public class ReverseGeocodeLookupTask extends AsyncTask <Void, Void, GeoCodeResult> {\r\n        \r\n        private ProgressDialog progressDialog;\r\n\r\n        @Override\r\n        protected void onPreExecute() {\r\n            this.progressDialog = ProgressDialog.show(\r\n                    LbsGeocodingActivity.this,\r\n                    \"Please wait...contacting Yahoo!\", \/\/ title\r\n                    \"Requesting reverse geocode lookup\", \/\/ message\r\n                    true \/\/ indeterminate\r\n            );\r\n        }\r\n\r\n        @Override\r\n        protected GeoCodeResult doInBackground(Void... params) {\r\n            return geoCoder.reverseGeoCode(currentLocation.getLatitude(), currentLocation.getLongitude());\r\n        }\r\n\r\n        @Override\r\n        protected void onPostExecute(GeoCodeResult result) {\r\n            this.progressDialog.cancel();\r\n            Toast.makeText(LbsGeocodingActivity.this, result.toString(), Toast.LENGTH_LONG).show();            \r\n        }\r\n        \r\n    }\r\n    \r\n}\r\n<\/pre>\n
In order to keep things simple and separate the application’s concerns, we are going to use multiple small classes. The main activity uses a GeoCoder service, our custom implementation which uses the Yahoo API. The code for that class is the following:
 
<\/div> <\/div><\/p>\n
package com.javacodegeeks.android.lbs.services;\r\n\r\nimport com.javacodegeeks.android.lbs.model.GeoCodeResult;\r\n\r\npublic class GeoCoder {\r\n    \r\n    private static final String YAHOO_API_BASE_URL = \"http:\/\/where.yahooapis.com\/geocode?q=%1$s,+%2$s&gflags=R&appid=[yourappidhere]\";\r\n    \r\n    private HttpRetriever httpRetriever = new HttpRetriever();\r\n    private XmlParser xmlParser = new XmlParser();\r\n    \r\n    public GeoCodeResult reverseGeoCode(double latitude, double longitude) {\r\n        \r\n        String url = String.format(YAHOO_API_BASE_URL, String.valueOf(latitude), String.valueOf(longitude));        \r\n        String response = httpRetriever.retrieve(url);\r\n        return xmlParser.parseXmlResponse(response);\r\n        \r\n    }\r\n\r\n}\r\n<\/pre>\n
The model object class named GeoCodeResult will be described later. The GeoCoder service uses two others services.<\/p>\n
First we have the \u201cHttpRetriever\u201d class which uses the Apache HTTP client API to perform a GET request and retrieve the data from the Yahoo API URL. The code is the following:<\/p>\n
package com.javacodegeeks.android.lbs.services;\r\n\r\nimport java.io.IOException;\r\n\r\nimport org.apache.http.HttpEntity;\r\nimport org.apache.http.HttpResponse;\r\nimport org.apache.http.client.methods.HttpGet;\r\nimport org.apache.http.impl.client.DefaultHttpClient;\r\nimport org.apache.http.util.EntityUtils;\r\n\r\nimport android.util.Log;\r\n\r\npublic class HttpRetriever {\r\n    \r\n    private final String TAG = getClass().getSimpleName();\r\n\r\n    private DefaultHttpClient client = new DefaultHttpClient();\r\n\r\n    public String retrieve(String url) {\r\n\r\n        HttpGet get = new HttpGet(url);\r\n\r\n        try {\r\n\r\n            HttpResponse getResponse = client.execute(get);\r\n            HttpEntity getResponseEntity = getResponse.getEntity();\r\n\r\n            if (getResponseEntity != null) {\r\n                String response = EntityUtils.toString(getResponseEntity);\r\n                Log.d(TAG, response);\r\n                return response;\r\n            }\r\n\r\n        } catch (IOException e) {\r\n            e.printStackTrace();\r\n        }\r\n\r\n        return null;\r\n\r\n    }\r\n\r\n}\r\n<\/pre>\n
Easy stuff here. A DefaultHttpClient<\/a> instance is used for the HTTP requests. A HttpGet<\/a> is used to represent a GET request and is passed as an argument to the execute<\/a> method of the client. A HttpResponse<\/a> is retrieved as a result (in successful operations) and from that we get an HttpEntity<\/a> object. Finally, the EntityUtils<\/a> helper class is used to convert the response to a String and that response is returned to the caller. Note that no control of unsuccessful operations has been implemented, please take care of that if you want something more robust.<\/p>\n
Next service to exam is the \u201cXmlParser\u201d class. This uses the existing DOM manipulation classes to perform parsing of the XML response. From the API’s response (example here<\/a>), we are going to use only the \u201cline1\u201d – \u201cline4\u201d nodes of the ResultSet\/Result element. The implementation is a typical DOM one, so I will not get into many details. Here is the code:<\/p>\n
package com.javacodegeeks.android.lbs.services;\r\n\r\nimport java.io.StringReader;\r\n\r\nimport javax.xml.parsers.DocumentBuilder;\r\nimport javax.xml.parsers.DocumentBuilderFactory;\r\n\r\nimport org.w3c.dom.Document;\r\nimport org.w3c.dom.Node;\r\nimport org.w3c.dom.NodeList;\r\nimport org.xml.sax.InputSource;\r\n\r\nimport android.util.Log;\r\n\r\nimport com.javacodegeeks.android.lbs.model.GeoCodeResult;\r\n\r\npublic class XmlParser {\r\n    \r\n    private final String TAG = getClass().getSimpleName();\r\n    \r\n    public GeoCodeResult parseXmlResponse(String response) {\r\n        \r\n        try {\r\n            \r\n            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();\r\n            DocumentBuilder db = dbf.newDocumentBuilder();\r\n            Document doc = db.parse(new InputSource(new StringReader(response)));\r\n            \r\n            NodeList resultNodes = doc.getElementsByTagName(\"Result\");            \r\n            Node resultNode = resultNodes.item(0);            \r\n            NodeList attrsList = resultNode.getChildNodes();\r\n            \r\n            GeoCodeResult result = new GeoCodeResult();\r\n            \r\n            for (int i=0; i < attrsList.getLength(); i++) {\r\n                \r\n                Node node = attrsList.item(i);                \r\n                Node firstChild = node.getFirstChild();\r\n                \r\n                if (\"line1\".equalsIgnoreCase(node.getNodeName()) && firstChild!=null) {\r\n                    result.line1 = firstChild.getNodeValue();\r\n                }\r\n                if (\"line2\".equalsIgnoreCase(node.getNodeName()) && firstChild!=null) {\r\n                    result.line2 = firstChild.getNodeValue();\r\n                }\r\n                if (\"line3\".equalsIgnoreCase(node.getNodeName()) && firstChild!=null) {\r\n                    result.line3 = firstChild.getNodeValue();\r\n                }\r\n                if (\"line4\".equalsIgnoreCase(node.getNodeName()) && firstChild!=null) {\r\n                    result.line4 = firstChild.getNodeValue();\r\n                }\r\n            }\r\n            \r\n            Log.d(TAG, result.toString());\r\n            \r\n            return result;\r\n            \r\n        }\r\n        catch (Exception e) {\r\n            e.printStackTrace();\r\n        }\r\n        \r\n        return null;\r\n        \r\n    }\r\n\r\n}\r\n<\/pre>\n
In short, we begin from the root element, we travel down to the \u201cResult\u201d node and then we get all this node’s children. From those, we sort out the elements we care about using the getNodeName<\/a> method and finally we retrieve the node value using the getNodeValue<\/a> method executed against the first child of the node.   The model class is populated accordingly and then returned back. The code for that class is: <\/p>\n
package com.javacodegeeks.android.lbs.model;\r\n\r\npublic class GeoCodeResult {\r\n    \r\n    public String line1;\r\n    public String line2;\r\n    public String line3;\r\n    public String line4;\r\n    \r\n    @Override\r\n    public String toString() {\r\n        \r\n        StringBuilder builder = new StringBuilder();\r\n        builder.append(\"Location:\");\r\n        \r\n        if (line1!=null)\r\n            builder.append(\"-\"+line1);\r\n        if (line2!=null)\r\n            builder.append(\"-\"+line2);\r\n        if (line3!=null)\r\n            builder.append(\"-\"+line3);\r\n        if (line4!=null)\r\n            builder.append(\"-\"+line4);\r\n        \r\n        return builder.toString();\r\n        \r\n    }\r\n    \r\n}\r\n<\/pre>\n
The final step is to add the permission required to access the internet, i.e. \u201candroid.permission.INTERNET<\/a>\u201d.  Launch the emulator using the already created<\/a> \u201cRun Configuration\u201d. Go to the DDMS view and set the coordinates to a known location. I used the ones that the PlaceFinder sample request<\/a> uses in order to make sure that a valid response will be generated.  \"\"<\/a> Hit \u201cSend\u201d in order to update the user’s last known location and then click the \u201cReverse Geocoding\u201d button of our application. First, the progress dialog appears, informing us about the background operation that takes place.  \"\"<\/a> After the data are retrieved and extracted from the API response, a Toast appears and let us know what the current address is, as shown below:  \"\"<\/a> That’s it! You can now build your location-aware applications and test them using the Android emulator. You can find the new version of the Eclipse project here<\/a>.  Happy mobile coding!!!  <\/p>\n
Related Articles :<\/i><\/strong><\/div>\n