রুট API বর্তমানে পূর্বরূপ (প্রি-GA) এ রয়েছে। প্রাক-GA পণ্য এবং বৈশিষ্ট্যগুলির সীমিত সমর্থন থাকতে পারে এবং প্রাক-GA পণ্য এবং বৈশিষ্ট্যগুলির পরিবর্তনগুলি অন্যান্য প্রাক-GA সংস্করণগুলির সাথে সামঞ্জস্যপূর্ণ নাও হতে পারে। প্রাক-GA অফারগুলি Google মানচিত্র প্ল্যাটফর্ম পরিষেবার নির্দিষ্ট শর্তাবলী দ্বারা আচ্ছাদিত। আরও তথ্যের জন্য, লঞ্চ পর্যায়ের বিবরণ দেখুন।

একটি রুট গণনা

আপনি ComputeRoutes পদ্ধতিতে (REST) ​​একটি HTTP POST অনুরোধ পাঠিয়ে বা ComputeRoutes পদ্ধতিতে (gRPC) কল করে Routes API ব্যবহার করে একটি রুট গণনা করতে পারেন।

নিম্নলিখিত উদাহরণটি computeRoutes পদ্ধতিতে একটি REST অনুরোধের URL দেখায়:

https://routes.googleapis.com/directions/v2:computeRoutes

JSON অনুরোধের বডিতে আপনার অনুরোধের বিকল্পগুলি অন্তর্ভুক্ত করুন। রিকোয়েস্ট বডিতে সোর্স এবং গন্তব্যের অবস্থান এবং আপনি যে রুটে সেট করতে চান এমন যেকোনো বিকল্প রয়েছে। আরও তথ্যের জন্য, একটি অবস্থান এবং রুট বিকল্পগুলি নির্দিষ্ট করুন দেখুন।

প্রতিক্রিয়াটিতে URL প্যারামিটার $fields বা HTTP/gRPC হেডার X-Goog-FieldMask ব্যবহার করে field তথ্য ব্যবহার করে প্রতিক্রিয়া ক্ষেত্র মাস্কে যে ক্ষেত্রগুলি নির্দিষ্ট করেছেন তা রয়েছে৷ আরও তথ্যের জন্য, ফিরে আসার জন্য ক্ষেত্র চয়ন করুন দেখুন।

উদাহরণ HTTP রুট অনুরোধ

নিচের কোডটি দেখায় কিভাবে একটি কম্পিউটার রুটের অনুরোধের জন্য একটি রিকোয়েস্ট বডি তৈরি করতে হয়। এই উদাহরণে, আপনি উৎস এবং গন্তব্যের অবস্থান সেট করেন এবং উল্লেখ করেন:

  • DRIVE একটি travelMode এবং একটি ট্রাফিক-সচেতন ড্রাইভিং রুট।

  • একটি সেট প্রস্থান সময়.

  • imperial দূরত্ব ইউনিট সহ en-US একটি ভাষা।

  • X-Goog-FieldMask হেডারে একটি প্রতিক্রিয়া ক্ষেত্র মাস্ক যা প্রতিক্রিয়াতে নিম্নলিখিত ক্ষেত্রগুলিকে ফেরত দিতে নির্দিষ্ট করে:

    • routes.duration
    • routes.distanceMeters
    • routes.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'

উদাহরণ HTTP রুট প্রতিক্রিয়া বডি

উপরের কলটি নিম্নলিখিত JSON প্রতিক্রিয়া তৈরি করে:

{
  "routes": [
    {
      "distanceMeters": 772,
      "duration": "165s",
      "polyline": {
        "encodedPolyline": "ipkcFfichVnP@j@BLoFVwM{E?"
      }
    }
  ]
}

উদাহরণ gRPC অনুরোধ

gRPC হল একটি উচ্চ কর্মক্ষমতা, ওপেন সোর্স সার্বজনীন RPC ফ্রেমওয়ার্ক যা Google দ্বারা তৈরি করা হয়েছে। gRPC-তে, একটি ক্লায়েন্ট অ্যাপ্লিকেশন সরাসরি একটি ভিন্ন মেশিনে একটি সার্ভার অ্যাপ্লিকেশনে পদ্ধতিগুলিকে কল করতে পারে যেন এটি একটি স্থানীয় বস্তু।

নিম্নলিখিত একটি উদাহরণ gRPC অনুরোধ দেখায়.

যাওয়া

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)

}
    

জাভা

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# ব্যবহার করে একটি উদাহরণের জন্য, Google.Maps.Routing.V2 দেখুন।