如何獲得兩個地點之間的駕駛距離？

Question

我在我的應用程序中使用GoogleMapv2 api。我想繪製一個從源到目標的多邊形線。並顯示旅行時間以及地圖活動的距離，但我無法找到它。請幫幫我。 我的代碼片段是在這裏：

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類代碼如下.........

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

和類GET方向如下：

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

Answer 1

您可以通過以下代碼獲取Trvelling時間和距離..我已經在我的一個項目中使用了此代碼，希望這可以幫助您

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

}); 

這裏是CalculateDistanceTime類。

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

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

} 

Answer 2

我認爲下面的代碼可能會有所幫助。

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 
} 

在地圖活動添加以下代碼行。

@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>