Para conseguir uma rota, envie uma solicitação HTTP POST para o método computeRoutes (REST) ou chame o método ComputeRoutes (gRPC).
O exemplo a seguir mostra o URL de uma solicitação REST para o método
computeRoutes:
https://routes.googleapis.com/directions/v2:computeRoutes
Inclua suas opções no corpo do JSON. O corpo da solicitação contém os locais de origem e destino e todas as opções que você quer definir no trajeto. Para mais informações, consulte Especificar locais e Opções de trajeto disponíveis.
A resposta contém os campos especificados na máscara de campo de resposta
usando as informações do parâmetro de URL $fields ou field usando o
cabeçalho gRPC HTTP X-Goog-FieldMask. Para mais detalhes, consulte
Escolher quais informações retornar.
Confira um exemplo de solicitação de trajeto de transporte público em Exemplo: descobrir um trajeto no transporte público.
Exemplo: solicitação de rota HTTP
O código a seguir mostra como construir um corpo para uma solicitação computeRoutes. Neste exemplo, você define os locais de origem e destino e também especifica:
Um
travelModedeDRIVEe um trajeto de carro com reconhecimento de trânsito.Um horário de partida definido.
Um idioma do
en-UScom unidades de distância deimperial.Uma máscara de campo de resposta no cabeçalho
X-Goog-FieldMaskque especifica o retorno dos seguintes campos na resposta:routes.durationroutes.distanceMetersroutes.polyline.encodedPolyline
curl -X POST -d '{
"origin":{
"location":{
"latLng":{
"latitude": 37.419734,
"longitude": -122.0827784
}
}
},
"destination":{
"location":{
"latLng":{
"latitude": 37.417670,
"longitude": -122.079595
}
}
},
"travelMode": "DRIVE",
"routingPreference": "TRAFFIC_AWARE",
"departureTime": "2023-10-15T15:01:23.045123456Z",
"computeAlternativeRoutes": false,
"routeModifiers": {
"avoidTolls": false,
"avoidHighways": false,
"avoidFerries": false
},
"languageCode": "en-US",
"units": "IMPERIAL"
}' \
-H 'Content-Type: application/json' -H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline.encodedPolyline' \
'https://routes.googleapis.com/directions/v2:computeRoutes'
Exemplo: corpo de resposta de rota HTTP
A chamada acima gera a seguinte resposta JSON:
{
"routes": [
{
"distanceMeters": 772,
"duration": "165s",
"polyline": {
"encodedPolyline": "ipkcFfichVnP@j@BLoFVwM{E?"
}
}
]
}
Exemplo: solicitação gRPC
O gRPC é uma biblioteca RPC universal de código aberto de alto desempenho desenvolvida pelo Google. No gRPC, um aplicativo cliente pode chamar métodos diretamente em um aplicativo servidor de uma outra máquina, como se fosse um objeto local.
Veja a seguir um exemplo de solicitação gRPC.
Go
package main
import (
"context"
"crypto/tls"
"fmt"
"log"
"time"
routespb "google.golang.org/genproto/googleapis/maps/routing/v2"
"google.golang.org/genproto/googleapis/type/latlng"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
const (
fieldMask = "*"
apiKey = "INSERT_API_KEY_HERE"
serverAddr = "routes.googleapis.com:443"
)
func main() {
config := tls.Config{}
conn, err := grpc.Dial(serverAddr,
grpc.WithTransportCredentials(credentials.NewTLS(&config)))
if err != nil {
log.Fatalf("Failed to connect: %v", err)
}
defer conn.Close()
client := routespb.NewRoutesClient(conn)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-Api-Key", apiKey)
ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-Fieldmask", fieldMask)
defer cancel()
// create the origin using a latitude and longitude
origin := &routespb.Waypoint{
LocationType: &routespb.Waypoint_Location{
Location: &routespb.Location{
LatLng: &latlng.LatLng{
Latitude: 37.417670,
Longitude: -122.0827784,
},
},
},
}
// create the destination using a latitude and longitude
destination := &routespb.Waypoint{
LocationType: &routespb.Waypoint_Location{
Location: &routespb.Location{
LatLng: &latlng.LatLng{
Latitude: 37.417670,
Longitude: -122.079595,
},
},
},
}
req := &routespb.ComputeRoutesRequest{
Origin: origin,
Destination: destination,
TravelMode: routespb.RouteTravelMode_DRIVE,
RoutingPreference: routespb.RoutingPreference_TRAFFIC_AWARE,
ComputeAlternativeRoutes: true,
Units: routespb.Units_METRIC,
RouteModifiers: &routespb.RouteModifiers{
AvoidTolls: false,
AvoidHighways: true,
AvoidFerries: true,
},
PolylineQuality: routespb.PolylineQuality_OVERVIEW,
}
// execute rpc
resp, err := client.ComputeRoutes(ctx, req)
if err != nil {
// "rpc error: code = InvalidArgument desc = Request contains an invalid
// argument" may indicate that your project lacks access to Routes
log.Fatal(err)
}
fmt.Printf("Response: %v", resp)
}
Java
package com.example;
import com.google.maps.routing.v2.*;
import com.google.type.LatLng;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ClientInterceptors;
import io.grpc.ForwardingClientCall;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.StatusRuntimeException;
import io.grpc.netty.NettyChannelBuilder;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
public class RoutesClient {
// For more detail on inserting API keys, see:
// https://cloud.google.com/endpoints/docs/grpc/restricting-api-access-with-api-keys#java
// For more detail on system parameters (such as FieldMask), see:
// https://cloud.google.com/apis/docs/system-parameters
private static final class RoutesInterceptor implements ClientInterceptor {
private final String apiKey;
private static final Logger logger = Logger.getLogger(RoutesInterceptor.class.getName());
private static Metadata.Key API_KEY_HEADER = Metadata.Key.of("x-goog-api-key",
Metadata.ASCII_STRING_MARSHALLER);
private static Metadata.Key FIELD_MASK_HEADER = Metadata.Key.of("x-goog-fieldmask",
Metadata.ASCII_STRING_MARSHALLER);
public RoutesInterceptor(String apiKey) {
this.apiKey = apiKey;
}
@Override
public ClientCall interceptCall(MethodDescriptor method,
CallOptions callOptions, Channel next) {
logger.info("Intercepted " + method.getFullMethodName());
ClientCall call = next.newCall(method, callOptions);
call = new ForwardingClientCall.SimpleForwardingClientCall(call) {
@Override
public void start(Listener responseListener, Metadata headers) {
headers.put(API_KEY_HEADER, apiKey);
// Note that setting the field mask to * is OK for testing, but discouraged in
// production.
// For example, for ComputeRoutes, set the field mask to
// "routes.distanceMeters,routes.duration,routes.polyline.encodedPolyline"
// in order to get the route distances, durations, and encoded polylines.
headers.put(FIELD_MASK_HEADER, "*");
super.start(responseListener, headers);
}
};
return call;
}
}
private static final Logger logger = Logger.getLogger(RoutesClient.class.getName());
private final RoutesGrpc.RoutesBlockingStub blockingStub;
public RoutesClient(Channel channel) {
blockingStub = RoutesGrpc.newBlockingStub(channel);
}
public static Waypoint createWaypointForLatLng(double lat, double lng) {
return Waypoint.newBuilder()
.setLocation(Location.newBuilder().setLatLng(LatLng.newBuilder().setLatitude(lat).setLongitude(lng)))
.build();
}
public void computeRoutes() {
ComputeRoutesRequest request = ComputeRoutesRequest.newBuilder()
.setOrigin(createWaypointForLatLng(37.420761, -122.081356))
.setDestination(createWaypointForLatLng(37.420999, -122.086894)).setTravelMode(RouteTravelMode.DRIVE)
.setRoutingPreference(RoutingPreference.TRAFFIC_AWARE).setComputeAlternativeRoutes(true)
.setRouteModifiers(
RouteModifiers.newBuilder().setAvoidTolls(false).setAvoidHighways(true).setAvoidFerries(true))
.setPolylineQuality(PolylineQuality.OVERVIEW).build();
ComputeRoutesResponse response;
try {
logger.info("About to send request: " + request.toString());
response = blockingStub.withDeadlineAfter(2000, TimeUnit.MILLISECONDS).computeRoutes(request);
} catch (StatusRuntimeException e) {
logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
return;
}
logger.info("Response: " + response.toString());
}
public void computeRouteMatrix() {
ComputeRouteMatrixRequest request = ComputeRouteMatrixRequest.newBuilder()
.addOrigins(RouteMatrixOrigin.newBuilder().setWaypoint(createWaypointForLatLng(37.420761, -122.081356))
.setRouteModifiers(RouteModifiers.newBuilder().setAvoidTolls(false).setAvoidHighways(true)
.setAvoidFerries(true)))
.addOrigins(RouteMatrixOrigin.newBuilder().setWaypoint(createWaypointForLatLng(37.403184, -122.097371)))
.addDestinations(RouteMatrixDestination.newBuilder()
.setWaypoint(createWaypointForLatLng(37.420999, -122.086894)))
.addDestinations(RouteMatrixDestination.newBuilder()
.setWaypoint(createWaypointForLatLng(37.383047, -122.044651)))
.setTravelMode(RouteTravelMode.DRIVE).setRoutingPreference(RoutingPreference.TRAFFIC_AWARE).build();
Iterator elements;
try {
logger.info("About to send request: " + request.toString());
elements = blockingStub.withDeadlineAfter(2000, TimeUnit.MILLISECONDS).computeRouteMatrix(request);
} catch (StatusRuntimeException e) {
logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
return;
}
while (elements.hasNext()) {
logger.info("Element response: " + elements.next().toString());
}
}
public static void main(String[] args) throws Exception {
String apiKey = System.getenv("INSERT_API_KEY_HERE");
// The standard TLS port is 443
Channel channel = NettyChannelBuilder.forAddress("routes.googleapis.com", 443).build();
channel = ClientInterceptors.intercept(channel, new RoutesInterceptor(apiKey));
RoutesClient client = new RoutesClient(channel);
client.computeRoutes();
client.computeRouteMatrix();
}
}
C#
Para um exemplo usando C#, consulte Google.Maps.Routing.V2.