Using Street View and Geocoding in your Android app

The Google Maps API isn’t bound to afraid a pin in a map! We attending at how to apparatus assorted map styles and accomplish about-face geocoding in your apps.

Today, Google Maps is calmly one of the world’s best accepted mapping services, acceptance millions of users to plan their journeys, ascertain new places to visit, and get a aftertaste of what it’s really like to airing about places they may acquire never alike visited.

We’ve already looked at how you can use the Google Maps API to retrieve and affectation the user’s location, but this able API isn’t bound to afraid a pin in a map!

In this article, we’ll be attractive at some of the added appearance that are included in the Google Maps API. By the end of this article, you’ll apperceive how to:

Before we can apparatus any of these features, we charge to actualize a activity that displays a basal Google Maps fragment.

To get this bureaucracy out of the way as bound as possible, I’ll be appliance Android Studio’s ‘Google Maps Activity’ arrangement and breeding a alter API key, which is appropriate if your activity is activity to affectation any Google Maps content. Aloof be acquainted that alter API keys aren’t decidedly secure, so afore publishing an appliance you charge always accomplish a new API key based on your project’s absolution certificate.

If your activity refuses to compile, again accomplish abiding your development ambiance is up to date, by aperture the Android SDK Manager and installing any accessible updates – in accurate accomplish abiding you acquire the latest versions of Google Play Casework and Google Repository.

This is the bald minimum appropriate to affectation Google Maps content, so at this point you may appetite to booty this activity for a circuit by installing it on your concrete smartphone or tablet, or an AVD (Android Virtual Device). If you’re testing this activity on an AVD, again you’ll charge to use a arrangement angel that includes the Google APIs.

Currently this activity displays a map with a brand assuredly set to Sydney, Australia. This isn’t absolutely activity to wow your users, so let’s attending at a few altered means of authoritative this activity added interesting.

When you accommodate Google Maps agreeable in your application, you about affectation the user’s accepted area via a marker, but there’s affluence of scenarios area it’s added advantageous to affectation area as a artery address. For example, if you’re booking a auto the ancient way (i.e by calling the auto company) or alignment to accommodated a friend, again alive the artery you’re currently on is activity to be appealing useful!

While your users could assignment this out for themselves by zooming in on their area brand and attractive at the surrounding labels, you can accommodate a abundant bigger acquaintance by presenting this advice to them. This activity of converting a set of breadth and breadth ethics into a artery address, is accepted as reverse geocoding.

In this section, we’re activity to add a button to our appliance that, aback tapped, retrieves the device’s breadth and latitude, about-face geocodes these coordinates into an almost artery address, and again presents this advice to the user.

Let’s alpha with the accessible stuff, and amend our user interface. Aback you actualize a activity appliance the Google Maps Activity template, the activity_maps.xml book contains a SupportMapFragment that fills the absolute screen.

I’m activity to aggrandize on this blueprint to accommodate a ‘Get My Location’ button that, aback tapped, updates a TextView with the about-face geocoded data.

Next, ascertain the cord assets that we’ll be appliance throughout this project:

The additional cord ability is a placeholder that contains the following:

You catechumen breadth and breadth ethics into a concrete abode appliance the getFromLocation() method, which allotment a account of Abode objects.

The akin of detail alternate by getFromLocation() will alter depending on the location. Sometimes about-face geocoding may acknowledgment a abounding address, appropriate bottomward to the abode number; sometimes it’ll acknowledgment the name of the abutting architecture – and occasionally it may acknowledgment no advice at all.

While the closing is unlikely, your appliance shouldn’t blast if it does appointment this scenario. Here, I’m creating a Cord aloof in case this app can’t bout the coordinates to any accepted address:

On accessories active Android 6.0 (API akin 23) and higher, applications charge to appeal permissions at runtime, and the user can again acquire or abjure anniversary request, on a permission-by-permission basis.

If the user denies a permission request, again you charge to acquaint the appulse this will acquire on your application. In this project, I’m activity to affectation the afterward argument as allotment of a toast:

When alive on your own Android projects, you may additionally appetite to attenuate or abolish genitalia of your appliance that await on the denied permission, for archetype removing items from menus, or “greying out” assertive UI controls.

Reverse geocoding requires an Internet connection, so accessible your project’s Manifest and add the Internet permission:

Since about-face geocoding uses the network, it has the abeyant to block Android’s capital thread. To abstain Appliance Not Responding (ANR) errors and appliance crashes, you must accomplish the about-face geocoding operation off the capital thread. There’s assorted means of creating accomplishments threads, but I’m activity to use an AsyncTask.

Create a new Java chic (I’m allotment abundance ReverseGeo) and apparatus the AsyncTask:

Next, we charge to apparatus ReverseGeo in our project’s automatically-generated MapsActivity class, and again override the onTaskComplete() method. I’m additionally implementing the onClickListener so our appliance can acknowledge to the user borer the ‘Get My Location’ button.

Let’s put this appliance to the test:

Since we’re requesting the ACCESS_FINE_LOCATION permission at runtime, we charge to analysis how our appliance handles rejection:

You should additionally analysis how your appliance functions aback it has admission to your location, but can’t bout the coordinates to any accepted address. If you’re appliance a concrete Android device, again you can analysis this book appliance a third affair app:

If you’re testing this activity on an AVD, again you can change the device’s coordinates appliance the band of buttons that arise alongside the emulator:

Any Google Maps agreeable you accommodate in your app will use the “normal” map appearance by absence – but “normal” isn’t the alone option!

The Google Maps API supports a few altered map styles:

To affectation annihilation added than a “normal” map, you’ll charge to use the setMapType method:

Alternatively, why not accord your users the abandon to about-face amid map styles?

In this section, we’re activity to add a dropdown card that allows your users to move amid the normal, hybrid, area and accessory map styles, with ease.

Start by creating a card resource:

Open your project’s strings.xml book and ascertain all the card labels:

Next, you’ll charge to apparatus the card in your MapsActivity. To accomplish this activity clearer, I’ve removed all geocoding-specific cipher from this Activity.

Install the adapted appliance on your concrete Android accessory or AVD, accessible the menu, and analysis all the altered map styles.

Even analytical the aforementioned area beyond assorted map styles can’t quite analyze to the acquaintance of exploring that area from a first-person angle – which is area Artery Appearance comes in.

In this final section, I’ll appearance you how to accommodate a actual faculty of what a area is really like, by amalgam Artery Appearance into our application.

Let’s alpha by afterlight our layout:

Next, I’m activity to actualize a StreetViewActivity, area I’ll apparatus the Artery Appearance service. Aback you accommodate a Artery Appearance panorama in your application, all the accepted Artery Appearance accomplishments are included by default, which is why the afterward cipher doesn’t accommodate any chiral implementations of animadversion and zooming gestures, or abyssal to adjoining panoramas, as you already get all this functionality for free!

Since I’m announcement the Artery Appearance panorama central an Android View, I’m appliance StreetViewPanoramaView, which is a bracket of the Appearance class. To affectation a panorama central a Fragment, you’d use StreetViewPanoramaFragment instead.

Don’t balloon to add the StreetViewActivity to your Manifest:

Finally, we charge to apparatus launchStreetView in our MapsActivity, so that android:onClick=”launchStreetView” triggers the StreetViewActivity class:

Install this activity on your Android device, and accord the ‘Street View’ button a tap. Your appliance should acknowledge by ablution a new Activity announcement a 360 amount panorama of the London Eye.

In this article, we explored a few means of acceptable your app’s Google Maps content, by abacus abutment for Artery View, assorted map styles, and about-face geocoding – but these are still aloof a few of the appearance that the Google Maps API has to offer.

• Give your users the abandon to about-face amid all the altered Google Maps styles: Normal, Satellite, Area and Hybrid.
• Convert the device’s breadth and breadth coordinates into a added convenient artery address, and affectation this advice as allotment of your UI.
• Display 360-degree, alternate panoramas of locations beyond the globe, by abacus Artery Appearance abutment to your app.

• Create a new activity appliance the ‘Google Maps Activity’ template.
• Open your project’s res/values/google_maps_api.xml file. This book contains a URL with all the advice the Google API Console needs to accomplish an API key. Find this URL, and copy/paste it into your web browser.
• Make abiding ‘Create a project’ is called in the Console’s dropdown menu, and again bang ‘Continue.’
• Click ‘Create API key.’
• The API Console will alert you to bind the API key. A belted API will alone assignment on a belvedere that supports that blazon of application, which tends to accomplish your key added secure. Unless you acquire a specific acumen not to, you should baddest ‘Restrict key.’
• Under ‘Key restriction,’ accomplish abiding ‘Android apps’ is selected, and again bang ‘Save.’
• Copy your API key, and again about-face aback to Android Studio.
• Open your project’s google_maps_api.xml book and adhesive your API key into the YOUR_KEY section:

• Open your module-level build.gradle book and add the Google Maps dependencies:

• %1. A placeholder for a value. This amount will either be a formatted abode or a bulletin that an absurdity has occurred.
• $s. The architecture of the placeholder value, i.e a String.

• Install the adapted activity on your Android device.
• Make abiding you’re affiliated to the Internet.
• Tap the ‘Get My Location’ button.
• Grant the ACCESS_FINE_LOCATION request; the TextView should amend to affectation an estimated artery address.

• Launch your device’s ‘Settings’ application.
• Tap ‘Apps.’
• Select the maps appliance from the list.
• Select ‘Permissions.’
• Push the ‘Location’ slider into the ‘Off’ position.
• Launch your maps application.
• Tap the ‘Get My Location’ button.
• When prompted, abjure the ACCESS_FINE_LOCATION request; the appliance should acknowledge by announcement a toast.

• Download an appliance that can bluff your location, such as the chargeless ‘Fake GPS’ app.
• Use this appliance to ambush your accessory into assertive you’re about that doesn’t acquire a artery abode – the average of the ocean is usually a safe bet!
• Switch aback to your maps application, and tap ‘Get My Location.’ The TextView should affectation the no_address string.

• Click the three-dotted card figure (where the cursor is positioned in the afterward screenshot).

• Select ‘Location’ from the left-hand menu.
• Enter a new set of longitude/longitude values, and bang ‘Send.’
• Press the application’s ‘Get My Location’ button; the TextView should amend to affectation the no_address string.

• MAP_TYPE_SATELLITE. A Google Earth accessory photograph, without alley or affection labels.
• MAP_TYPE_HYBRID. A accessory photograph with alley and affection labels.
• MAP_TYPE_TERRAIN. A topographic map featuring curve lines, labels and angle shading, with some labels.

• Control-click your project’s ‘res’ agenda and baddest ‘New > Android Ability File.’
• Give this ability a name; I’m appliance ‘maps_menu.’
• Open the ‘Resource type’ dropdown and baddest ‘Menu.’
• Click ‘OK.’
• Copy/paste the afterward cipher into this file:

Creating a basal Google Maps app

Displaying the user’s abode with about-face geocoding

Adding altered map types

Adding Artery Appearance to your project

Wrapping Up

YOUR_KEY

dependencies {
   abridge 'com.google.android.gms:play-services-maps:11.6.2'
   abridge 'com.google.android.gms:play-services-location:11.6.2'

//Create the button label//

Get my location
"Address: %1$s"

Cannot retrieve abode at this time

Location permission denied. Accepted area unavailable.

import android.location.Address;
import java.util.ArrayList;
import android.os.AsyncTask;
import android.content.Context;
import android.location.Location;
import android.location.Geocoder;
import java.util.List;
import java.util.Locale;
import java.io.IOException;
import android.text.TextUtils;

/**
* Created by jessicathornsby on 06/12/2017.
*/

class ReverseGeo extends AsyncTask {

   clandestine Context mContext;

//Add a constant for the onTaskComplete interface that we’ll be creating shortly//

   clandestine OnTaskComplete mListener;

   ReverseGeo(Context applicationContext, OnTaskComplete listener) {
       mListener = listener;
       mContext = applicationContext;

}

//Publish the after-effects of our AsyncTask; in this instance that’s the alternate address//

   @Override

//Override the onPostExecute() method//

   adequate abandoned onPostExecute(String address) {

//Once the AsyncTask has finished,
//call onTaskComplete and amend your UI with the alternate address//

       mListener.onTaskComplete(address);
       super.onPostExecute(address);
   }

//Implement AsyncTask’s doInBackground() method,
//where we’ll catechumen the Area commodity into an address//

   @Override
   adequate Cord doInBackground(Location... params) {

//Create a Geocoder object, which is a chic that can accomplish geocoding operations//

       Geocoder mGeocoder = new Geocoder(mContext,

//Localize the address//

               Locale.getDefault());

//Obtain a Area object//

       Area area = params[0];

//Create an abandoned Account of Abode objects, which will eventually accommodate the alternate address//

       List
 addresses = null;

//Create a Cord to authority the formatted address//

       Cord printAddress = "";

//Obtain the account of addresses for the accepted location, appliance getFromLocation//

       try {
           addresses = mGeocoder.getFromLocation(
                  location.getLatitude(),
                  location.getLongitude(),

//Specify the best cardinal of addresses that the TextView should display//

                  1);

//Catch any exceptions, for archetype if the arrangement is unavailable//

       } bolt (IOException ioException) {
           printAddress = mContext.getString(R.string.no_address);

       }

//If the geocoder can't bout the coordinates to an address, again acknowledgment an abandoned list//

       if (addresses.size() == 0) {
           if (printAddress.isEmpty()) {

//If the abode account is empty, again affectation the no_address string//

               printAddress = mContext.getString(R.string.no_address);

           }
       } abroad {

//If the account isn’t empty, again actualize an ArrayList of strings//

           Abode abode = addresses.get(0);
           ArrayList addressList = new ArrayList<>();

//Fetch the abode lines, appliance getMaxAddressLineIndex,
//and again and amalgamate them into a String//

           for (int i = 0; i <= address.getMaxAddressLineIndex(); i  ) {
               addressList.add(address.getAddressLine(i));
           }

            printAddress = TextUtils.join(
                 ",",
                 addressList);

        }

//Return the printAddress object//

       acknowledgment printAddress;
   }

//Create the OnTaskComplete interface, which takes a Cord as an argument//

   interface OnTaskComplete {
        abandoned onTaskComplete(String result);
   }
}

import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationCallback;
import com.google.android.gms.location.LocationResult;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import android.Manifest;
import android.content.pm.PackageManager;
import android.widget.TextView;
import android.widget.Toast;
import android.view.View;

public chic MapsActivity extends AppCompatActivity implements
       ReverseGeo.OnTaskComplete {

   clandestine changeless final int MY_PERMISSIONS_REQUEST_LOCATION = 1;
   clandestine Button button;
   clandestine TextView textview;
   clandestine boolean addressRequest;

//Create a affiliate capricious of the FusedLocationProviderClient type//

   clandestine FusedLocationProviderClient mFusedLocationClient;
   clandestine LocationCallback mLocationCallback;

   @Override
       adequate abandoned onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_maps);

       button = findViewById(R.id.button);
       textview = findViewById(R.id.textview);

//Initialize mFusedLocationClient//

       mFusedLocationClient = LocationServices.getFusedLocationProviderClient(
               this);

//Create the onClickListener//

       button.setOnClickListener(new View.OnClickListener() {
           @Override
           accessible abandoned onClick(View v) {

//Call getAddress, in acknowledgment to onClick events//

               if (!addressRequest) {
                   getAddress();

             }
           }
       });

//Create a LocationCallback object//

       mLocationCallback = new LocationCallback() {

           @Override

//Override the onLocationResult() method,
//which is area this app receives its area updates//

           accessible abandoned onLocationResult(LocationResult locationResult) {
               if (addressRequest) {

//Execute ReverseGeo in acknowledgment to addressRequest//

                    new ReverseGeo(MapsActivity.this, MapsActivity.this)

//Obtain the device's aftermost accepted area from the FusedLocationProviderClient//

                          .execute(locationResult.getLastLocation());
               }
           }
       };
   }

//Implement getAddress//

   clandestine abandoned getAddress() {
       if (ActivityCompat.checkSelfPermission(this,
              Manifest.permission.ACCESS_FINE_LOCATION)
              != PackageManager.PERMISSION_GRANTED) {
          ActivityCompat.requestPermissions(this, new String[]
                   {Manifest.permission.ACCESS_FINE_LOCATION},
               MY_PERMISSIONS_REQUEST_LOCATION);
       } abroad {
           addressRequest = true;

//Request area updates//

           mFusedLocationClient.requestLocationUpdates
              (getLocationRequest(),
                   mLocationCallback,
                   null);

//If the geocoder retrieves an address, again affectation this abode in the TextView//

           textview.setText(getString(R.string.address_text));

       }
   }

//Specify the requirements for your application's area requests//

   clandestine LocationRequest getLocationRequest() {
       LocationRequest locationRequest = new LocationRequest();

//Specify how generally the app should accept area updates, in milliseconds//

       locationRequest.setInterval(10000);
       acknowledgment locationRequest;
   }

   @Override
   accessible abandoned onRequestPermissionsResult(int requestCode,
                         Cord permissions[], int[] grantResults) {

       about-face (requestCode) {
           case MY_PERMISSIONS_REQUEST_LOCATION:
               if (grantResults.length > 0
                     && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

//If the permission appeal has been granted, again alarm getAddress//

                  getAddress();
               } abroad {
                  Toast.makeText(this,
                      R.string.location_permission_denied,
                      Toast.LENGTH_SHORT).show();
               }
               break;
       }
   }

   @Override
   accessible abandoned onTaskComplete(String result) {
       if (addressRequest) {

//Update the TextView with the about-face geocoded address//

           textview.setText(getString(R.string.address_text,
                   result));
       }
   }
}

mMap = googleMap;
mMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);

See Also: hack facebook messenger

Normal map
Terrain map
Hybrid map
Satellite map

import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.maps.GoogleMap;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;

public chic MapsActivity extends AppCompatActivity implements
       OnMapReadyCallback, GoogleApiClient.ConnectionCallbacks {

   clandestine GoogleMap mMap;

   @Override
   adequate abandoned onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_maps);

//Obtain the SupportMapFragment//

       SupportMapFragment mapFragment = SupportMapFragment.newInstance();
       getSupportFragmentManager().beginTransaction()
               .add(R.id.map, mapFragment).commit();
       mapFragment.getMapAsync(this);
   }

//Override the onCreateOptionsMenu() method//

   @Override
   accessible boolean onCreateOptionsMenu(Menu menu) {

//Inflate the maps_menu resource//

       MenuInflater inflater = getMenuInflater();
       inflater.inflate(R.menu.maps_menu, menu);
       acknowledgment true;
   }

//Override the onOptionsItemSelected() method//

   @Override
   accessible boolean onOptionsItemSelected(MenuItem item) {
       about-face (item.getItemId()) {
           case R.id.normal:

//Use setMapType to change the map appearance based on the user’s selection//

               mMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
               acknowledgment true;
           case R.id.hybrid:
               mMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
               acknowledgment true;
           case R.id.terrain:
               mMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
               acknowledgment true;
           case R.id.satellite:
               mMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
           acknowledgment true;
           default:
           acknowledgment super.onOptionsItemSelected(item);
       }
   }

   @Override
   accessible abandoned onMapReady(GoogleMap googleMap) {
       mMap = googleMap;

       if (ContextCompat.checkSelfPermission(this,
              android.Manifest.permission.ACCESS_COARSE_LOCATION)
              == PackageManager.PERMISSION_GRANTED) {
           mMap.setMyLocationEnabled(true);
       }
   }

   accessible abandoned onConnected(Bundle bundle) { 
//To do// 
       }

   @Override
   accessible abandoned onConnectionSuspended(int i) {

   }
}

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.ViewGroup.LayoutParams;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.StreetViewPanoramaOptions;
import com.google.android.gms.maps.StreetViewPanoramaView;

public chic StreetViewActivity extends AppCompatActivity {

//Define the LatLng amount we’ll be appliance for the paranorma’s antecedent camera position//

   clandestine changeless final LatLng LONDON = new LatLng(51.503324, -0.119543);
   clandestine StreetViewPanoramaView mStreetViewPanoramaView;
   clandestine changeless final Cord STREETVIEW_BUNDLE_KEY = "StreetViewBundleKey";

   @Override
   adequate abandoned onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);

//Configure the panorama by casual in a StreetViewPanoramaOptions object//

       StreetViewPanoramaOptions options = new StreetViewPanoramaOptions();
       if (savedInstanceState == null) {

//Set the panorama’s location//

          options.position(LONDON);
       }

       mStreetViewPanoramaView = new StreetViewPanoramaView(this, options);
       addContentView(mStreetViewPanoramaView,
               new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));

       Array mStreetViewBundle = null;
       if (savedInstanceState != null) {
         mStreetViewBundle = savedInstanceState.getBundle(STREETVIEW_BUNDLE_KEY);
       }
       mStreetViewPanoramaView.onCreate(mStreetViewBundle);
   }

}

import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.maps.GoogleMap;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import android.content.Intent;
import android.view.View;

public chic MapsActivity extends AppCompatActivity implements
       OnMapReadyCallback, GoogleApiClient.ConnectionCallbacks {

   clandestine GoogleMap mMap;

   @Override
   adequate abandoned onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_maps);

       SupportMapFragment mapFragment = SupportMapFragment.newInstance();
       getSupportFragmentManager().beginTransaction()
           .add(R.id.map, mapFragment).commit();
       mapFragment.getMapAsync(this);
   }

   @Override
   accessible boolean onCreateOptionsMenu(Menu menu) {

       MenuInflater inflater = getMenuInflater();
       inflater.inflate(R.menu.maps_menu, menu);
       acknowledgment true;
   }

   @Override
   accessible boolean onOptionsItemSelected(MenuItem item) {
       about-face (item.getItemId()) {
           case R.id.normal:
             mMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
             acknowledgment true;
           case R.id.hybrid:
             mMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
             acknowledgment true;
           case R.id.terrain:
             mMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
             acknowledgment true;
           case R.id.satellite:
             mMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
             acknowledgment true;
           default:
             acknowledgment super.onOptionsItemSelected(item);
       }
   }

   @Override
   accessible abandoned onMapReady(GoogleMap googleMap) {
       mMap = googleMap;

       if (ContextCompat.checkSelfPermission(this,
              android.Manifest.permission.ACCESS_COARSE_LOCATION)
              == PackageManager.PERMISSION_GRANTED) {
           mMap.setMyLocationEnabled(true);
       }
   }

   accessible abandoned onConnected(Bundle bundle) {
//To do//
   }

   @Override
   accessible abandoned onConnectionSuspended(int i) {

   }

   accessible abandoned launchStreetView(View view) {
       Absorbed absorbed = new Intent(MapsActivity.this, StreetViewActivity.class);
       startActivity(intent);
   }
}

Update your layout

Create your strings

Add the Internet permission

Create an AyncTask

Implement ReverseGeo in MapsActivity

Testing your about-face geocoding application