2016-08-05 21 views
0

Angenommen, ich begann meine Reise vom grünen Marker und beendete meine Reise am roten Marker. Wie kann ich die Entfernung und die Zeit berechnen, die ich brauche, um die Reise zu beenden? enter image description hereWie finde ich die Entfernung und die Zeit, die ich brauche, um zwischen zwei Orten zu reisen?

Mein Code geht dies wie:

public class MainActivity extends FragmentActivity implements OnMapReadyCallback, LocationListener { 

    GoogleMap map; 
    LocationManager locationManager; 
    ArrayList<LatLng> markerPoints; 
    TextView tvDistanceDuration; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     tvDistanceDuration = (TextView) findViewById(R.id.tv_distance_time); 

     // Initializing 
     markerPoints = new ArrayList<LatLng>(); 

     // Getting reference to SupportMapFragment of the activity_main 
     SupportMapFragment fm = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map); 

     // Getting Map for the SupportMapFragment 
     fm.getMapAsync(this); 

    } 

    private String 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; 


     return url; 
    } 

    /** 
    * A method to download json data from 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("error downloading url", e.toString()); 
     } finally { 
      iStream.close(); 
      urlConnection.disconnect(); 
     } 
     return data; 
    } 

    @Override 
    public void onMapReady(GoogleMap googleMap) { 
     map = googleMap; 
     if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) { 
      if (checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && checkSelfPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
       // TODO: Consider calling 
       // Activity#requestPermissions 
       // here to request the missing permissions, and then overriding 
       // public void onRequestPermissionsResult(int requestCode, String[] permissions, 
       //           int[] grantResults) 
       // to handle the case where the user grants the permission. See the documentation 
       // for Activity#requestPermissions for more details. 
       return; 
      } 
     } 
     map.setMyLocationEnabled(true); 

     LocationManager locationManager = (LocationManager) getSystemService(LOCATION_SERVICE); 
     Criteria criteria = new Criteria(); 
     String bestProvider = locationManager.getBestProvider(criteria, true); 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
      if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
       // TODO: Consider calling 
       // Activity#requestPermissions 
       // here to request the missing permissions, and then overriding 
       // public void onRequestPermissionsResult(int requestCode, String[] permissions, 
       //           int[] grantResults) 
       // to handle the case where the user grants the permission. See the documentation 
       // for Activity#requestPermissions for more details. 
       return; 
      } 
     } 
     Location location = locationManager.getLastKnownLocation(bestProvider); 
     if (location != null) { 
      onLocationChanged(location); 
     } 
     locationManager.requestLocationUpdates(bestProvider, 20000, 0, this); 


     // Setting onclick event listener for the map 
     map.setOnMapClickListener(new OnMapClickListener() { 

      @Override 
      public void onMapClick(LatLng point) { 

       // Already two locations 
       if (markerPoints.size() > 1) { 
        markerPoints.clear(); 
        map.clear(); 
       } 

       // Adding new item to the ArrayList 
       markerPoints.add(point); 

       // Creating MarkerOptions 
       MarkerOptions options = new MarkerOptions(); 

       // Setting the position of the marker 
       options.position(point); 

       /** 
       * For the start location, the color of marker is GREEN and 
       * for the end location, the color of marker is RED. 
       */ 
       if (markerPoints.size() == 1) { 
        options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN)); 
       } else if (markerPoints.size() == 2) { 
        options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED)); 
       } 


       // Add new marker to the Google Map Android API V2 
       map.addMarker(options); 

       // Checks, whether start and end locations are captured 
       if (markerPoints.size() >= 2) { 
        LatLng origin = markerPoints.get(0); 
        LatLng dest = markerPoints.get(1); 

        // Getting URL to the Google Directions API 
        String url = getDirectionsUrl(origin, dest); 

        DownloadTask downloadTask = new DownloadTask(); 

        // Start downloading json data from Google Directions API 
        downloadTask.execute(url); 
       } 

      } 
     }); 
    } 

    @Override 
    public void onLocationChanged(Location location) { 

     double latitude = location.getLatitude(); 
     double longitude = location.getLongitude(); 
     LatLng latLng = new LatLng(latitude, longitude); 
     map.setMapType(GoogleMap.MAP_TYPE_NORMAL); 
     map.setTrafficEnabled(true); 
     map.setBuildingsEnabled(true); 
     map.setIndoorEnabled(true); 
     map.getUiSettings().isCompassEnabled(); 
     map.getUiSettings().isMyLocationButtonEnabled(); 
     map.moveCamera(CameraUpdateFactory.newLatLng(latLng)); 
     map.animateCamera(CameraUpdateFactory.zoomTo(16)); 
    } 

    @Override 
    public void onStatusChanged(String s, int i, Bundle bundle) { 

    } 

    @Override 
    public void onProviderEnabled(String s) { 

    } 

    @Override 
    public void onProviderDisabled(String s) { 

    } 


    // Fetches data from url passed 
    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); 

     } 
    } 

    /** 
    * A class to parse the Google Places in JSON format 
    */ 
    private class ParserTask extends AsyncTask<String, Integer, List<List<HashMap<String, String>>>> { 

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

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

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

       // 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<List<HashMap<String, String>>> result) { 
      ArrayList<LatLng> points = null; 
      PolylineOptions lineOptions = null; 
      MarkerOptions markerOptions = new MarkerOptions(); 
      String distance = ""; 
      String duration = ""; 


      if (result.size() < 1) { 
       Toast.makeText(getBaseContext(), "No Points", Toast.LENGTH_SHORT).show(); 
       return; 
      } 


      // Traversing through all the routes 
      for (int i = 0; i < result.size(); i++) { 
       points = new ArrayList<LatLng>(); 
       lineOptions = new PolylineOptions(); 

       // Fetching i-th route 
       List<HashMap<String, String>> path = result.get(i); 

       // Fetching all the points in i-th route 
       for (int j = 0; j < path.size(); j++) { 
        HashMap<String, String> point = path.get(j); 

        if (j == 0) { // Get distance from the list 
         distance = (String) point.get("distance"); 
         continue; 
        } else if (j == 1) { // Get duration from the list 
         duration = (String) point.get("duration"); 
         continue; 
        } 

        double lat = Double.parseDouble(point.get("lat")); 
        double lng = Double.parseDouble(point.get("lng")); 
        LatLng position = new LatLng(lat, lng); 

        points.add(position); 
       } 

       // Adding all the points in the route to LineOptions 
       lineOptions.addAll(points); 
       lineOptions.width(8); 
       lineOptions.color(Color.RED); 

      } 

      tvDistanceDuration.setText("Distance:" + distance + ", Duration:" + duration); 

      // Drawing polyline in the Google Map for the i-th route 
      map.addPolyline(lineOptions); 
     } 
    } 


    @Override 
    public boolean onCreateOptionsMenu(Menu menu) { 
     // Inflate the menu; this adds items to the action bar if it is present. 
     getMenuInflater().inflate(R.menu.main, menu); 
     return true; 
    } 
} 

Antwort

0

Abstand zu finden:

locationA.distanceTo(locationB); 

Zur Zeit vergangen zu finden:

location.getTime(); 
1

können Sie diese tutorial über überprüfen „Distance und Reisedauer zwischen zwei Orten in Google Map Android API ". Die Google Maps Directions API ist ein Dienst, der Richtungen zwischen Standorten berechnet. Sie können nach Richtungen für verschiedene Transportmittel suchen, einschließlich Transit, Fahren, Gehen oder Radfahren. Im Grunde müssen Sie einen HTTP-Aufruf an den Google Map-Dienst senden, der JSON zurückgibt und dann Ihren JSON in lesbaren Text für die Verwendung in Java sortiert.

Von diesen thread:

Zum Beispiel Richtungen von Montreal to Toronto:

GET http://maps.googleapis.com/maps/api/directions/json?origin=Toronto&destination=Montreal&sensor=false 

Sie werden mit einigen JSON enden. In routes[].legs[].distance, werden Sie ein Objekt wie folgt erhalten:

 "legs" : [ 
     { 
      "distance" : { 
       "text" : "542 km", 
       "value" : 542389 
      }, 

Sie können auch die Polylinie Informationen direkt aus der Antwort Objekt erhalten.

Sie können dies auch überprüfen related SO question. Hoffe das hilft!