How to get driving distance between two locations?

问题:

I am using GoogleMapv2 api in my app. I want to draw a polygon line from source to destination. and show the travel time as well as distance on map activity but I am unable to find it. Please help me. My code snippet is here :

public class NavigationActivity extends FragmentActivity {
    public static final String TAG_SLAT = "sourcelat";
    public static final String TAG_SLONG = "sourcelong";
    public static final String TAG_DLAT = "destinationlat";
    public static final String TAG_DLONG = "destinationg";

    private static LatLng Source = null;
    private static LatLng Destination = null;

    private GoogleMap map;
    private SupportMapFragment fragment;
    private LatLngBounds latlngBounds;
    private Button bNavigation;
    private Polyline newPolyline;
    private Marker smarker;
    private  Marker dmarker;

    private boolean isTraveling = false;
    private int width, height;
    private String sourcelat;
    private String sourcelong;
    private String destinationg;
    private String destinationlat;
    double slat;
    double slong;
    double dlat;
    double dlong;
    TextView tvDistanceDuration;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_navigation);
        tvDistanceDuration = (TextView) findViewById(R.id.tv_distance_time);
        Intent in = getIntent();
        sourcelat = in.getStringExtra(TAG_SLAT);
        destinationlat = in.getStringExtra(TAG_DLAT);
        destinationg = in.getStringExtra(TAG_DLONG);
        sourcelong = in.getStringExtra(TAG_SLONG);


         slat=Double.parseDouble(sourcelat);
         slong=Double.parseDouble(sourcelong);
         dlat=Double.parseDouble(destinationlat);
         dlong=Double.parseDouble(destinationg);
        Source = new LatLng(slat,slong);
        Destination = new LatLng(dlat,dlong);

        getSreenDimanstions();
        fragment = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map));
        map = fragment.getMap();


                if (!isTraveling) {
                    isTraveling = true;


                    findDirections(Source.latitude, Source.longitude, Destination.latitude, Destination.longitude, GMapV2Direction.MODE_DRIVING);
                    DecimalFormat df1 = new DecimalFormat("#.0000");
                    double dLat = Math.toRadians(dlat - slat);
                    double dLon = Math.toRadians(dlong - slong);
                    double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
                            + Math.cos(Math.toRadians(slat))
                            * Math.cos(Math.toRadians(dlat)) * Math.sin(dLon / 2)
                            * Math.sin(dLon / 2);
                    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
                    double tempDistance = 6371 * c;
                    Log.v("sds...", String.valueOf(tempDistance));
                } else {
                    isTraveling = false;

                }

    }

    @Override
    protected void onResume() {

        super.onResume();
        latlngBounds = createLatLngBoundsObject(Source, Destination);
        map.moveCamera(CameraUpdateFactory.newLatLngBounds(latlngBounds, width, height, 150));

    }

    public void handleGetDirectionsResult(ArrayList<LatLng> directionPoints) {
        PolylineOptions rectLine = new PolylineOptions().width(5).color(Color.RED);
        MarkerOptions marker = new MarkerOptions().position(Source).icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN));
        MarkerOptions marker1 = new MarkerOptions().position(Destination).icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN));


        for(int i = 0 ; i < directionPoints.size() ; i++)
        {          
            rectLine.add(directionPoints.get(i));


        }
        if (newPolyline != null)
        {
            newPolyline.remove();
        }
        newPolyline = map.addPolyline(rectLine);
        smarker = map.addMarker(marker);
        dmarker = map.addMarker(marker1);
        if (isTraveling)
        {

            latlngBounds = createLatLngBoundsObject(Source, Destination);
            map.animateCamera(CameraUpdateFactory.newLatLngBounds(latlngBounds, width, height, 150));
        }
        else
        {

            map.animateCamera(CameraUpdateFactory.newLatLngBounds(latlngBounds, width, height, 150));
        }

    }

    private void getSreenDimanstions()
    {
        Display display = getWindowManager().getDefaultDisplay();
        width = display.getWidth(); 
        height = display.getHeight(); 
    }

    private LatLngBounds createLatLngBoundsObject(LatLng firstLocation, LatLng secondLocation)
    {
        if (firstLocation != null && secondLocation != null)
        {
            LatLngBounds.Builder builder = new LatLngBounds.Builder();    
            builder.include(firstLocation).include(secondLocation);

            return builder.build();
        }
        return null;
    }


    public void findDirections(double fromPositionDoubleLat, double fromPositionDoubleLong, double toPositionDoubleLat, double toPositionDoubleLong, String mode)
    {
        Map<String, String> map = new HashMap<String, String>();
        map.put(GetDirectionsAsyncTask.USER_CURRENT_LAT, String.valueOf(fromPositionDoubleLat));
        map.put(GetDirectionsAsyncTask.USER_CURRENT_LONG, String.valueOf(fromPositionDoubleLong));
        map.put(GetDirectionsAsyncTask.DESTINATION_LAT, String.valueOf(toPositionDoubleLat));
        map.put(GetDirectionsAsyncTask.DESTINATION_LONG, String.valueOf(toPositionDoubleLong));
        map.put(GetDirectionsAsyncTask.DIRECTIONS_MODE, mode);

        GetDirectionsAsyncTask asyncTask = new GetDirectionsAsyncTask(this);
        asyncTask.execute(map);
    }
}

Asynctask class code as follow.........

public class GetDirectionsAsyncTask extends AsyncTask<Map<String, String>, Object, ArrayList<LatLng>>
{
    public static final String USER_CURRENT_LAT = "user_current_lat";
    public static final String USER_CURRENT_LONG = "user_current_long";
    public static final String DESTINATION_LAT = "destination_lat";
    public static final String DESTINATION_LONG = "destination_long";
    public static final String DIRECTIONS_MODE = "directions_mode";
    private NavigationActivity activity;
    private Exception exception;
    private ProgressDialog progressDialog;

    public GetDirectionsAsyncTask(NavigationActivity activity)
    {
        super();
        this.activity = activity;
    }

    public void onPreExecute()
    {
        progressDialog = new ProgressDialog(activity);
        progressDialog.setMessage("Calculating directions");
        progressDialog.show();
    }

    @Override
    public void onPostExecute(ArrayList result)
    {
        progressDialog.dismiss();
        if (exception == null)
        {
            activity.handleGetDirectionsResult(result);
        }
        else
        {
            processException();
        }
    }

    @Override
    protected ArrayList<LatLng> doInBackground(Map<String, String>... params)
    {
        Map<String, String> paramMap = params[0];
        try
        {
            LatLng fromPosition = new LatLng(Double.valueOf(paramMap.get(USER_CURRENT_LAT)) , Double.valueOf(paramMap.get(USER_CURRENT_LONG)));
            LatLng toPosition = new LatLng(Double.valueOf(paramMap.get(DESTINATION_LAT)) , Double.valueOf(paramMap.get(DESTINATION_LONG)));
            GMapV2Direction md = new GMapV2Direction();
            Document doc = md.getDocument(fromPosition, toPosition, paramMap.get(DIRECTIONS_MODE));
            ArrayList<LatLng> directionPoints = md.getDirection(doc);
            return directionPoints;
        }
        catch (Exception e)
        {
            exception = e;
            return null;
        }
    }

    private void processException()
    {
        Toast.makeText(activity, "Error retrieving data",Toast.LENGTH_SHORT).show();
    }
}

and class for get direction is as follow :

public class GMapV2Direction {
    public final static String MODE_DRIVING = "driving";
    public final static String MODE_WALKING = "walking";

    public GMapV2Direction() { }

    public Document getDocument(LatLng start, LatLng end, String mode) {
        String url = "http://maps.googleapis.com/maps/api/directions/xml?" 
                + "origin=" + start.latitude + "," + start.longitude  
                + "&destination=" + end.latitude + "," + end.longitude 
                + "&sensor=false&units=metric&mode=driving";

        try {
            HttpClient httpClient = new DefaultHttpClient();
            HttpContext localContext = new BasicHttpContext();
            HttpPost httpPost = new HttpPost(url);
            HttpResponse response = httpClient.execute(httpPost, localContext);
            InputStream in = response.getEntity().getContent();
            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            Document doc = builder.parse(in);
            return doc;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getDurationText (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("duration");
        Node node1 = nl1.item(0);
        NodeList nl2 = node1.getChildNodes();
        Node node2 = nl2.item(getNodeIndex(nl2, "text"));
        Log.i("DurationText", node2.getTextContent());
        return node2.getTextContent();
    }

    public int getDurationValue (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("duration");
        Node node1 = nl1.item(0);
        NodeList nl2 = node1.getChildNodes();
        Node node2 = nl2.item(getNodeIndex(nl2, "value"));
        Log.i("DurationValue", node2.getTextContent());
        return Integer.parseInt(node2.getTextContent());
    }

    public String getDistanceText(Document doc) {
        NodeList nl1 = doc.getElementsByTagName("distance");
        int i;

        //get the last tag from XML

        for(i = 0;i<nl1.getLength();i++){

        }

        if(i==i){
            i--;
        }

        Node node1 = nl1.item(i);
        NodeList nl2 = node1.getChildNodes();
        Node node2 = nl2.item(getNodeIndex(nl2, "text"));
        Log.i("DistanceText", node2.getTextContent());
        return node2.getTextContent();
    }

    public int getDistanceValue (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("distance");
        Node node1 = nl1.item(0);
        NodeList nl2 = node1.getChildNodes();
        Node node2 = nl2.item(getNodeIndex(nl2, "value"));
        Log.i("DistanceValue", node2.getTextContent());
        return Integer.parseInt(node2.getTextContent());
    }

    public String getStartAddress (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("start_address");
        Node node1 = nl1.item(0);
        Log.i("StartAddress", node1.getTextContent());
        return node1.getTextContent();
    }

    public String getEndAddress (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("end_address");
        Node node1 = nl1.item(0);
        Log.i("StartAddress", node1.getTextContent());
        return node1.getTextContent();
    }

    public String getCopyRights (Document doc) {
        NodeList nl1 = doc.getElementsByTagName("copyrights");
        Node node1 = nl1.item(0);
        Log.i("CopyRights", node1.getTextContent());
        return node1.getTextContent();
    }

    public ArrayList<LatLng> getDirection (Document doc) {
        NodeList nl1, nl2, nl3;
        ArrayList<LatLng> listGeopoints = new ArrayList<LatLng>();
        nl1 = doc.getElementsByTagName("step");
        if (nl1.getLength() > 0) {
            for (int i = 0; i < nl1.getLength(); i++) {
                Node node1 = nl1.item(i);
                nl2 = node1.getChildNodes();

                Node locationNode = nl2.item(getNodeIndex(nl2, "start_location"));
                nl3 = locationNode.getChildNodes();
                Node latNode = nl3.item(getNodeIndex(nl3, "lat"));
                double lat = Double.parseDouble(latNode.getTextContent());
                Node lngNode = nl3.item(getNodeIndex(nl3, "lng"));
                double lng = Double.parseDouble(lngNode.getTextContent());
                listGeopoints.add(new LatLng(lat, lng));

                locationNode = nl2.item(getNodeIndex(nl2, "polyline"));
                nl3 = locationNode.getChildNodes();
                latNode = nl3.item(getNodeIndex(nl3, "points"));
                ArrayList<LatLng> arr = decodePoly(latNode.getTextContent());
                for(int j = 0 ; j < arr.size() ; j++) {
                    listGeopoints.add(new LatLng(arr.get(j).latitude, arr.get(j).longitude));
                }

                locationNode = nl2.item(getNodeIndex(nl2, "end_location"));
                nl3 = locationNode.getChildNodes();
                latNode = nl3.item(getNodeIndex(nl3, "lat"));
                lat = Double.parseDouble(latNode.getTextContent());
                lngNode = nl3.item(getNodeIndex(nl3, "lng"));
                lng = Double.parseDouble(lngNode.getTextContent());
                listGeopoints.add(new LatLng(lat, lng));
            }
        }

        return listGeopoints;
    }

    private int getNodeIndex(NodeList nl, String nodename) {
        for(int i = 0 ; i < nl.getLength() ; i++) {
            if(nl.item(i).getNodeName().equals(nodename))
                return i;
        }
        return -1;
    }

    private ArrayList<LatLng> decodePoly(String encoded) {
        ArrayList<LatLng> poly = new ArrayList<LatLng>();
        int index = 0, len = encoded.length();
        int lat = 0, lng = 0;
        while (index < len) {
            int b, shift = 0, result = 0;
            do {
                b = encoded.charAt(index++) - 63;
                result |= (b & 0x1f) << shift;
                shift += 5;
            } while (b >= 0x20);
            int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
            lat += dlat;
            shift = 0;
            result = 0;
            do {
                b = encoded.charAt(index++) - 63;
                result |= (b & 0x1f) << shift;
                shift += 5;
            } while (b >= 0x20);
            int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
            lng += dlng;

            LatLng position = new LatLng((double) lat / 1E5, (double) lng / 1E5);
            poly.add(position);
        }
        return poly;
    }

回答1:

You can get Trvelling time and distance with following code.. i have already use this code in one of my project hope this will help you

CalculateDistanceTime distance_task = new CalculateDistanceTime(getActivity());

distance_task.getDirectionsUrl(startLatLng, endLatLng);

distance_task.setLoadListener(new CalculateDistanceTime.taskCompleteListener() {
           @Override
           public void taskCompleted(String[] time_distance) {
                   approximate_time.setText("" + time_distance[1]);
                   approximate_diatance.setText("" + time_distance[0]);
           }

 });

and here is the CalculateDistanceTime class.

    import android.content.Context;
    import android.os.AsyncTask;
    import android.util.Log;

    import com.google.android.gms.maps.model.LatLng;

    import org.json.JSONObject;

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;

    public class CalculateDistanceTime {

        private taskCompleteListener mTaskListener;
        private Context mContext;


        public CalculateDistanceTime(Context context) {
            mContext = context;
        }

        public void setLoadListener(taskCompleteListener taskListener) {
            mTaskListener = taskListener;
        }


        public void getDirectionsUrl(LatLng origin, LatLng dest) {

            // Origin of route
            String str_origin = "origin=" + origin.latitude + "," + origin.longitude;

            // Destination of route
            String str_dest = "destination=" + dest.latitude + "," + dest.longitude;


            // Sensor enabled
            String sensor = "sensor=false";

            // Building the parameters to the web service
            String parameters = str_origin + "&" + str_dest + "&" + sensor;

            // Output format
            String output = "json";

            // Building the url to the web service
            String url = "https://maps.googleapis.com/maps/api/directions/" + output + "?" + parameters;


            DownloadTask downloadTask = new DownloadTask();

            // Start downloading json data from Google Directions API

            downloadTask.execute(url);
        }

        private String downloadUrl(String strUrl) throws IOException {
            String data = "";
            InputStream iStream = null;
            HttpURLConnection urlConnection = null;
            try {
                URL url = new URL(strUrl);

                // Creating an http connection to communicate with url
                urlConnection = (HttpURLConnection) url.openConnection();

                // Connecting to url
                urlConnection.connect();

                // Reading data from url
                iStream = urlConnection.getInputStream();

                BufferedReader br = new BufferedReader(new InputStreamReader(iStream));

                StringBuffer sb = new StringBuffer();

                String line = "";
                while ((line = br.readLine()) != null) {
                    sb.append(line);
                }

                data = sb.toString();

                br.close();

            } catch (Exception e) {
                Log.d("Exception while downloading url", e.toString());
            } finally {
                iStream.close();
                urlConnection.disconnect();
            }
            return data;
        }


        public interface taskCompleteListener {
            void taskCompleted(String[] time_distance);
        }

        private class DownloadTask extends AsyncTask<String, Void, String> {

            // Downloading data in non-ui thread
            @Override
            protected String doInBackground(String... url) {

                // For storing data from web service
                String data = "";

                try {
                    // Fetching the data from web service
                    data = downloadUrl(url[0]);
                } catch (Exception e) {
                    Log.d("Background Task", e.toString());
                }
                return data;
            }

            // Executes in UI thread, after the execution of
            // doInBackground()
            @Override
            protected void onPostExecute(String result) {
                super.onPostExecute(result);

                ParserTask parserTask = new ParserTask();

                // Invokes the thread for parsing the JSON data
                parserTask.execute(result);

            }
        }

        private class ParserTask extends AsyncTask<String, Integer, List<HashMap<String, String>>> {

            // Parsing the data in non-ui thread
            @Override
            protected List<HashMap<String, String>> doInBackground(String... jsonData) {

                JSONObject jObject;
                List<HashMap<String, String>> routes = null;

                try {
                    jObject = new JSONObject(jsonData[0]);
                    DistanceTimeParser parser = new DistanceTimeParser();

                    // Starts parsing data
                    routes = parser.parse(jObject);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return routes;
            }

            // Executes in UI thread, after the parsing process
            @Override
            protected void onPostExecute(List<HashMap<String, String>> result) {

                String distance = "";
                String duration_distance = "";


                if (result.size() < 1) {
                    Log.e("Error : ", "No Points found");
                    return;
                }


                String[] date_dist = new String[2];

                // Traversing through all the routes
                for (int i = 0; i < result.size(); i++) {

                    // Fetching i-th route
                    HashMap<String, String> tmpData = result.get(i);
                    Set<String> key = tmpData.keySet();
                    Iterator it = key.iterator();
                    while (it.hasNext()) {
                        String hmKey = (String) it.next();
                        duration_distance = tmpData.get(hmKey);

                        System.out.println("Key: " + hmKey + " & Data: " + duration_distance);

                        it.remove(); // avoids a ConcurrentModificationException
                    }

                    date_dist[i] = duration_distance;
                }

                mTaskListener.taskCompleted(date_dist);
            }
        }
    }

and DistanceTimeparser

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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class DistanceTimeParser {

    public List<HashMap<String, String>> parse(JSONObject jObject) {


        List<HashMap<String, String>> routes = new ArrayList<HashMap<String, String>>();
        JSONArray jRoutes = null;
        JSONArray jLegs = null;

        JSONObject jDistance = null;
        JSONObject jDuration = null;

        try {

            jRoutes = jObject.getJSONArray("routes");

            jLegs = ((JSONObject) jRoutes.get(0)).getJSONArray("legs");

            List<HashMap<String, String>> path = new ArrayList<HashMap<String, String>>();


            /** Getting distance from the json data */
            jDistance = ((JSONObject) jLegs.get(0)).getJSONObject("distance");
            HashMap<String, String> hmDistance = new HashMap<String, String>();
            hmDistance.put("distance", jDistance.getString("text"));

            /** Getting duration from the json data */
            jDuration = ((JSONObject) jLegs.get(0)).getJSONObject("duration");
            HashMap<String, String> hmDuration = new HashMap<String, String>();
            hmDuration.put("duration", jDuration.getString("text"));

            routes.add(hmDistance);

            routes.add(hmDuration);

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

        return routes;
    }

}

回答2:

I think the following code could help.

Routing.java

public class Routing extends AsyncTask<LatLng, Void, Route>
{
private final GoogleMap map;
private LatLng start;
private LatLng dest;
private final LatLngBounds.Builder builder = new LatLngBounds.Builder();;
private final int[] lineColor = { Color.GREEN };
private final int pos;

public Routing(final Activity activity, final GoogleMap map) {
super();
this.map = map;
this.pos = 0;
}

private TextView txtDistance;

public Routing(final Activity activity, final GoogleMap map, final TextView txtDistance) {
super();
this.map = map;
this.pos = 0;
this.txtDistance = txtDistance;
}

@Override
protected Route doInBackground(final LatLng... points) {
try {
    start = points[0];
    dest = points[1];
    Parser parser;
    final String jsonURL = "http://maps.googleapis.com/maps/api/directions/json?";
    final StringBuffer sBuf = new StringBuffer(jsonURL);
    sBuf.append("origin=");
    sBuf.append(start.latitude);
    sBuf.append(',');
    sBuf.append(start.longitude);
    sBuf.append("&destination=");
    sBuf.append(dest.latitude);
    sBuf.append(',');
    sBuf.append(dest.longitude);
    sBuf.append("&sensor=true&mode=driving");
    System.out.println("sbuf: " + sBuf.toString());
    parser = new GoogleParser(sBuf.toString());
    final Route route = parser.parse();
    return route;
} catch (final Exception e) {}
return null;
}

@Override
protected void onPreExecute() {
/** Empty Method */
}// end onPreExecute method

@SuppressLint("ResourceAsColor")
@Override
protected void onPostExecute(final Route result) {
try {
    if (result == null) {
    map.moveCamera(CameraUpdateFactory.newLatLngZoom(dest, 15));
    map.animateCamera(CameraUpdateFactory.zoomTo(18), 2000, null);
    } else {
    final String text = result.getTextLength();
    final String startAddress = result.getStartAddress().toString().trim().replaceAll(", ", ",\n");
    final String endAddress = result.getEndAddress().toString().trim().replaceAll(", ", ",\n");
    txtDistance.setVisibility(View.GONE);
    if (text != null) {
        txtDistance.setVisibility(View.VISIBLE);
        txtDistance.setBackgroundResource(android.R.color.holo_orange_light);
        txtDistance.setText(" Total Distance : " + text + "\n Total Duration : " + result.getDuration() + "  ");
    }
    final List<LatLng> directionPoint = result.getPoints();
    final PolylineOptions rectLine = new PolylineOptions().width(10).color(lineColor[pos]);
    for (int i = 0; i < directionPoint.size(); i++) {
        rectLine.add(directionPoint.get(i));
    }
    map.addPolyline(rectLine);

    final Marker startLocation = map.addMarker(new MarkerOptions().position(start).title(startAddress).snippet("Main Location").icon(BitmapDescriptorFactory.fromResource(R.drawable.markera)));
    final Marker endLocation = map.addMarker(new MarkerOptions().position(dest).title(endAddress).snippet("Destination Location").icon(BitmapDescriptorFactory.fromResource(R.drawable.markerb)));
    builder.include(startLocation.getPosition());
    builder.include(endLocation.getPosition());
    final LatLngBounds bounds = builder.build();

    // Pan to see all markers in view.
    final int padding = 100; // offset from edges of the map in pixels
    final CameraUpdate cup = CameraUpdateFactory.newLatLngBounds(bounds, padding);

    map.moveCamera(cup);
    map.animateCamera(cup);

    }
} catch (final Exception e) {
    e.printStackTrace();
}
}// end onPostExecute method
}

In your map activity add the following lines.

  @Override
protected void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (Utils.isGPSTurnOn(getApplicationContext())) {
        onResume();
    }
}
@Override
protected void onResume() {
    super.onResume();
    if (Utils.isConnected(getApplicationContext())) {
        mMap = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();
        mMap.setMyLocationEnabled(true);
        final TextView txtDistance = (TextView) findViewById(R.id.txtSpeed);
        new Routing(getParent(), mMap, txtDistance).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, start, end);
    }
}

Utils.java

public class Utils
{
/**
 * @Method used to checks if device having network connection or not.
 * @param context the context
 * @return <code>true</code> if the phone is connected
 */
public static boolean isConnected(final Context context) {
try {
    final ConnectivityManager connMngr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

    final NetworkInfo wifiNetwork = connMngr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
    if (wifiNetwork != null && wifiNetwork.isConnectedOrConnecting()) { return true; }

    final NetworkInfo mobileNetwork = connMngr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
    if (mobileNetwork != null && mobileNetwork.isConnectedOrConnecting()) { return true; }

    final NetworkInfo activeNetwork = connMngr.getActiveNetworkInfo();
    if (activeNetwork != null && activeNetwork.isConnectedOrConnecting()) { return true; }
} catch (final Exception e) {
    e.printStackTrace();
}
return false;
}

public static boolean isGPSTurnOn(final Context context) {
final LocationManager manager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
return manager.isProviderEnabled(LocationManager.GPS_PROVIDER);
}

}

activity_map.xml

<RelativeLayout  xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >

<fragment
    android:id="@+id/map"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    class="com.google.android.gms.maps.MapFragment" />

<TextView
    android:id="@+id/txtSpeed"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:visibility="gone"
    android:textStyle="bold"
    android:text="@string/hello_world" />
 </RelativeLayout>