|
|
Metode dan Algoritma | Menggambar Rute Peta Android, Google Map Direction dengan JSON . Anda bisa melakukan konsultasi tentang Menggambar Rute Peta Android, Google Map Direction dengan JSON melalui form di samping kanan !!!
Setelah bisa Membuat Peta Google Map di Android kali ini kita coba Membuat Rute pada Peta Google Map di Android, walaupun seharusnya kita pelajari dahulu cara Memberi Titik atau Marker di Peta GoogleMap tetapi karena artikel tersebut belum siap ya sudahlah artikel ini mendahului.
Pertama project android baru, ingat harus dipilih Build Target Google APIs.
Kemudian kita tambahkan class-class berikut ini :
XMLParser.java
package com.amijaya.androidgooglemapdirection;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public class XMLParser {
// names of the XML tags
protected static final String MARKERS = “markers”;
protected static final String MARKER = “marker”;
protected URL feedUrl;
protected XMLParser(final String feedUrl) {
try {
this.feedUrl = new URL(feedUrl);
} catch (MalformedURLException e) {
//Log.e(e.getMessage(), “XML parser – ” + feedUrl);
}
}
protected InputStream getInputStream() {
try {
return feedUrl.openConnection().getInputStream();
} catch (IOException e) {
//Log.e(e.getMessage(), “XML parser – ” + feedUrl);
return null;
}
}
}
Segment.java
package com.amijaya.androidgooglemapdirection;
import com.google.android.maps.GeoPoint;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public class Segment {
/** Points in this segment. **/
private GeoPoint start;
/** Turn instruction to reach next segment. **/
private String instruction;
/** Length of segment. **/
private int length;
/** Distance covered. **/
private double distance;
/**
* Create an empty segment.
*/
public Segment() {
}
/**
* Set the turn instruction.
* @param turn Turn instruction string.
*/
public void setInstruction(final String turn) {
this.instruction = turn;
}
/**
* Get the turn instruction to reach next segment.
* @return a String of the turn instruction.
*/
public String getInstruction() {
return instruction;
}
/**
* Add a point to this segment.
* @param point GeoPoint to add.
*/
public void setPoint(final GeoPoint point) {
start = point;
}
/** Get the starting point of this
* segment.
* @return a GeoPoint
*/
public GeoPoint startPoint() {
return start;
}
/** Creates a segment which is a copy of this one.
* @return a Segment that is a copy of this one.
*/
public Segment copy() {
final Segment copy = new Segment();
copy.start = start;
copy.instruction = instruction;
copy.length = length;
copy.distance = distance;
return copy;
}
/**
* @param length the length to set
*/
public void setLength(final int length) {
this.length = length;
}
/**
* @return the length
*/
public int getLength() {
return length;
}
/**
* @param distance the distance to set
*/
public void setDistance(double distance) {
this.distance = distance;
}
/**
* @return the distance
*/
public double getDistance() {
return distance;
}
}
package com.amijaya.androidgooglemapdirection;
import java.util.ArrayList;
import java.util.List;
import com.google.android.maps.GeoPoint;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public class Route {
private String name;
private final List
private List
private String copyright;
private String warning;
private String country;
private int length;
private String polyline;
public Route() {
points = new ArrayList
segments = new ArrayList
}
public void addPoint(final GeoPoint p) {
points.add(p);
}
public void addPoints(final List
this.points.addAll(points);
}
public List
return points;
}
public void addSegment(final Segment s) {
segments.add(s);
}
public List
return segments;
}
/**
* @param name the name to set
*/
public void setName(final String name) {
this.name = name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param copyright the copyright to set
*/
public void setCopyright(String copyright) {
this.copyright = copyright;
}
/**
* @return the copyright
*/
public String getCopyright() {
return copyright;
}
/**
* @param warning the warning to set
*/
public void setWarning(String warning) {
this.warning = warning;
}
/**
* @return the warning
*/
public String getWarning() {
return warning;
}
/**
* @param country the country to set
*/
public void setCountry(String country) {
this.country = country;
}
/**
* @return the country
*/
public String getCountry() {
return country;
}
/**
* @param length the length to set
*/
public void setLength(int length) {
this.length = length;
}
/**
* @return the length
*/
public int getLength() {
return length;
}
/**
* @param polyline the polyline to set
*/
public void setPolyline(String polyline) {
this.polyline = polyline;
}
/**
* @return the polyline
*/
public String getPolyline() {
return polyline;
}
}
package com.amijaya.androidgooglemapdirection;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public interface Parser {
public Route parse();
}
package com.amijaya.androidgooglemapdirection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import com.google.android.maps.GeoPoint;
import android.util.Log;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public class GoogleParser extends XMLParser implements Parser {
/** Distance covered. **/
private int distance;
public GoogleParser(String feedUrl) {
super(feedUrl);
}
/**
* Parses a url pointing to a Google JSON object to a Route object.
* @return a Route object based on the JSON object.
*/
public Route parse() {
// turn the stream into a string
final String result = convertStreamToString(this.getInputStream());
//Create an empty route
final Route route = new Route();
//Create an empty segment
final Segment segment = new Segment();
try {
//Tranform the string into a json object
final JSONObject json = new JSONObject(result);
//Get the route object
final JSONObject jsonRoute = json.getJSONArray(“routes”).getJSONObject(0);
//Get the leg, only one leg as we don’t support waypoints
final JSONObject leg = jsonRoute.getJSONArray(“legs”).getJSONObject(0);
//Get the steps for this leg
final JSONArray steps = leg.getJSONArray(“steps”);
//Number of steps for use in for loop
final int numSteps = steps.length();
//Set the name of this route using the start & end addresses
route.setName(leg.getString(“start_address”) + ” to ” + leg.getString(“end_address”));
//Get google’s copyright notice (tos requirement)
route.setCopyright(jsonRoute.getString(“copyrights”));
//Get the total length of the route.
route.setLength(leg.getJSONObject(“distance”).getInt(“value”));
//Get any warnings provided (tos requirement)
if (!jsonRoute.getJSONArray(“warnings”).isNull(0)) {
route.setWarning(jsonRoute.getJSONArray(“warnings”).getString(0));
}
/* Loop through the steps, creating a segment for each one and
* decoding any polylines found as we go to add to the route object’s
* map array. Using an explicit for loop because it is faster!
*/
for (int i = 0; i
//Get the individual step
final JSONObject step = steps.getJSONObject(i);
//Get the start position for this step and set it on the segment
final JSONObject start = step.getJSONObject(“start_location”);
final GeoPoint position = new GeoPoint((int) (start.getDouble(“lat”)*1E6),
(int) (start.getDouble(“lng”)*1E6));
segment.setPoint(position);
//Set the length of this segment in metres
final int length = step.getJSONObject(“distance”).getInt(“value”);
distance += length;
segment.setLength(length);
segment.setDistance(distance/1000);
//Strip html from google directions and set as turn instruction
segment.setInstruction(step.getString(“html_instructions”).replaceAll(““, “”));
//Retrieve & decode this segment’s polyline and add it to the route.
route.addPoints(decodePolyLine(step.getJSONObject(“polyline”).getString(“points”)));
//Push a copy of the segment to the route
route.addSegment(segment.copy());
}
} catch (JSONException e) {
Log.e(e.getMessage(), “Google JSON Parser – ” + feedUrl);
}
return route;
}
/**
* Convert an inputstream to a string.
* @param input inputstream to convert.
* @return a String of the inputstream.
*/
private static String convertStreamToString(final InputStream input) {
final BufferedReader reader = new BufferedReader(new InputStreamReader(input));
final StringBuilder sBuf = new StringBuilder();
String line = null;
try {
while ((line = reader.readLine()) != null) {
sBuf.append(line);
}
} catch (IOException e) {
Log.e(e.getMessage(), “Google parser, stream2string”);
} finally {
try {
input.close();
} catch (IOException e) {
Log.e(e.getMessage(), “Google parser, stream2string”);
}
}
return sBuf.toString();
}
/**
* Decode a polyline string into a list of GeoPoints.
* @param poly polyline encoded string to decode.
* @return the list of GeoPoints represented by this polystring.
*/
private List
int len = poly.length();
int index = 0;
List
int lat = 0;
int lng = 0;
while (index
int b;
int shift = 0;
int result = 0;
do {
b = poly.charAt(index++) – 63;
result |= (b & 0x1f)
shift += 5;
} while (b >= 0×20);
int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lat += dlat;
shift = 0;
result = 0;
do {
b = poly.charAt(index++) – 63;
result |= (b & 0x1f)
shift += 5;
} while (b >= 0×20);
int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lng += dlng;
decoded.add(new GeoPoint(
(int) (lat*1E6 / 1E5), (int) (lng*1E6 / 1E5)));
}
return decoded;
}
}
package com.amijaya.androidgooglemapdirection;
import java.util.Iterator;
import java.util.List;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapView;
import com.google.android.maps.Overlay;
import com.google.android.maps.Projection;
//http://cariprogram.blogspot.com
//nuramijaya@gmail.com
public class RouteOverlay extends Overlay {
/** GeoPoints representing this routePoints. **/
private final List
/** Colour to paint routePoints. **/
private int colour;
/** Alpha setting for route overlay. **/
private static final int ALPHA = 120;
/** Stroke width. **/
private static final float STROKE = 4.5f;
/** Route path. **/
private final Path path;
/** Point to draw with. **/
private final Point p;
/** Paint for path. **/
private final Paint paint;
/**
* Public constructor.
*
* @param route Route object representing the route.
* @param defaultColour default colour to draw route in.
*/
public RouteOverlay(final Route route, final int defaultColour) {
super();
routePoints = route.getPoints();
colour = defaultColour;
path = new Path();
p = new Point();
paint = new Paint();
}
@Override
public final void draw(final Canvas c, final MapView mv,
final boolean shadow) {
super.draw(c, mv, shadow);
paint.setColor(colour);
paint.setAlpha(ALPHA);
paint.setAntiAlias(true);
paint.setStrokeWidth(STROKE);
paint.setStyle(Paint.Style.STROKE);
redrawPath(mv);
c.drawPath(path, paint);
}
/**
* Set the colour to draw this route’s overlay with.
*
* @param c Int representing colour.
*/
public final void setColour(final int c) {
colour = c;
}
/**
* Clear the route overlay.
*/
public final void clear() {
routePoints.clear();
}
/**
* Recalculate the path accounting for changes to
* the projection and routePoints.
* @param mv MapView the path is drawn to.
*/
private void redrawPath(final MapView mv) {
final Projection prj = mv.getProjection();
path.rewind();
final Iterator
prj.toPixels(it.next(), p);
path.moveTo(p.x, p.y);
while (it.hasNext()) {
prj.toPixels(it.next(), p);
path.lineTo(p.x, p.y);
}
path.setLastPoint(p.x, p.y);
}
}
Kemudian pada program utama MainActivity.java kita tuliskan program berikut :
MainActivity.java :
package com.amijaya.androidgooglemapdirection;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
// http://cariprogram.blogspot.com
// nuramijaya@gmail.com
public class MainActivity extends MapActivity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
MapView mapView = (MapView) findViewById(R.id.mapView);
mapView.setBuiltInZoomControls(true);
MapController myMC = null;
mapView.setSatellite(false);
GeoPoint startPoint = new GeoPoint((int) (-7.782939 * 1E6), (int) (110.36705000000006 * 1E6));
GeoPoint endPoint = new GeoPoint((int) (-7.783130530640776 * 1E6), (int) (110.40135302698059 * 1E6));
//
myMC = mapView.getController();
myMC.setCenter(startPoint);
myMC.setZoom(14);
Route route = directions(startPoint, endPoint);
RouteOverlay routeOverlay = new RouteOverlay(route, Color.BLUE);
mapView.getOverlays().add(routeOverlay);
mapView.getController().animateTo(startPoint);
mapView.setBuiltInZoomControls(true);
mapView.displayZoomControls(true);
/*double lat = -6.2532592788520015;
double lng = 106.853239291777;
GeoPoint point = new GeoPoint((int) (lat *1E6),(int) (lng * 1E6));
mapView.getController().animateTo(point);
mapView.getController().setZoom(15);
Route route = directions(new GeoPoint((int)(26.2*1E6),(int)(50.6*1E6)), new GeoPoint((int)(26.3*1E6),(int)(50.7*1E6)));
RouteOverlay routeOverlay = new RouteOverlay(route, Color.BLUE);
mapView.getOverlays().add(routeOverlay);
mapView.invalidate();*/
}
private Route directions(final GeoPoint start, final GeoPoint dest) {
Parser parser;
//https://developers.google.com/maps/documentation/directions/#JSON
String jsonURL = “http://maps.googleapis.com/maps/api/directions/json?”;
final StringBuffer sBuf = new StringBuffer(jsonURL);
sBuf.append(“origin=”);
sBuf.append(start.getLatitudeE6()/1E6);
sBuf.append(‘,’);
sBuf.append(start.getLongitudeE6()/1E6);
sBuf.append(“&destination=”);
sBuf.append(dest.getLatitudeE6()/1E6);
sBuf.append(‘,’);
sBuf.append(dest.getLongitudeE6()/1E6);
sBuf.append(“&sensor=true&mode=driving”);
parser = new GoogleParser(sBuf.toString());
Route r = parser.parse();
return r;
}
@Override
protected boolean isRouteDisplayed() {
// TODO Auto-generated method stub
return false;
}
}
Lokasi koordinat Latitude dan Longitude bisa didapatkan dari aplikasi Google Earth atau dari Web Maps Google atau dari Web seperti MapJogja.com yang akan ditampilkan
Selanjutnya pada layout tampilan ganti isinya menjadi seperti ini, jangan lupa untuk mereplace API KEY dengan milik anda :
main.xml :
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”>
android:id=”@+id/mapView”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:enabled=”true”
android:clickable=”true”
android:apiKey=”0q1sXzzC7654y48XA8FH0vQPfmodfrpb0tB-EpA”
/>
Untuk AndroidManifest.xml harus ditambahkan library google maps api dan permission INTERNET seperti di bawah ini :
package=”com.amijaya.androidgooglemap”
android:versionCode=”1″
android:versionName=”1.0″>
android:label=”@string/app_name”>
Hasilnya :
Program selengkapnya dapat didownload di :
https://docs.google.com/open?id=0B4i1FYc_4RXzT2ptckpESkFiaFE
Selamat coding, semoga berhasil.
Menggambar Rute Peta Android, Google Map Direction dengan JSON
ActionScript AS3 ASP.NET AJAX C / C++ C# Clipper COBOL ColdFusion DataFlex Delphi Emacs Lisp Fortran FoxPro Java J2ME JavaScript JScript Lingo MATLAB Perl PHP PostScript Python SQL VBScript Visual Basic 6.0 Visual Basic .NET Flash MySQL Oracle Android
Rating: 100% based on 99998 ratings. 5 user reviews.
Ditulis Oleh hank2
{ 0 komentar... Views All / Send Comment! }
Posting Komentar