Server.java

package io.vertx.example.grpc.routeguide;

import io.grpc.examples.routeguide.Feature;
import io.grpc.examples.routeguide.Point;
import io.grpc.examples.routeguide.Rectangle;
import io.grpc.examples.routeguide.RouteGuideGrpc;
import io.grpc.examples.routeguide.RouteNote;
import io.grpc.examples.routeguide.RouteSummary;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.Promise;
import io.vertx.example.grpc.util.Runner;
import io.vertx.grpc.GrpcBidiExchange;
import io.vertx.grpc.GrpcReadStream;
import io.vertx.grpc.GrpcWriteStream;
import io.vertx.grpc.VertxServer;
import io.vertx.grpc.VertxServerBuilder;

import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static java.util.concurrent.TimeUnit.NANOSECONDS;

/**
 * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
 */
public class Server extends AbstractVerticle {

  public static void main(String[] args) {
    Runner.runExample(Server.class);
  }

  private List<Feature> features;
  private final Map<Point, List<RouteNote>> routeNotes = new HashMap<>();

  @Override
  public void start() throws Exception {

    URL featureFile = Util.getDefaultFeaturesFile();
    features = Util.parseFeatures(featureFile);

    VertxServer server = VertxServerBuilder.forAddress(vertx, "localhost", 8080).addService(new RouteGuideGrpc.RouteGuideVertxImplBase() {

      @Override
      public void getFeature(Point request, Promise<Feature> response) {
        response.complete(checkFeature(request));
      }

      @Override
      public void listFeatures(Rectangle request, GrpcWriteStream<Feature> response) {
        int left = Math.min(request.getLo().getLongitude(), request.getHi().getLongitude());
        int right = Math.max(request.getLo().getLongitude(), request.getHi().getLongitude());
        int top = Math.max(request.getLo().getLatitude(), request.getHi().getLatitude());
        int bottom = Math.min(request.getLo().getLatitude(), request.getHi().getLatitude());

        for (Feature feature : features) {
          if (!Util.exists(feature)) {
            continue;
          }

          int lat = feature.getLocation().getLatitude();
          int lon = feature.getLocation().getLongitude();
          if (lon >= left && lon <= right && lat >= bottom && lat <= top) {
            response.write(feature);
          }
        }
        response.end();
      }

      @Override
      public void recordRoute(GrpcReadStream<Point> request, Future<RouteSummary> response) {

        request.exceptionHandler(err -> {
          System.out.println("recordRoute cancelled");
        });

        RouteRecorder recorder = new RouteRecorder();

        request.handler(recorder::append);

        request.endHandler(v -> {
          response.complete(recorder.build());
        });
      }

      @Override
      public void routeChat(GrpcBidiExchange<RouteNote, RouteNote> exchange) {

        exchange.handler(note -> {
          List<RouteNote> notes = getOrCreateNotes(note.getLocation());

          // Respond with all previous notes at this location.
          for (RouteNote prevNote : notes.toArray(new RouteNote[0])) {
            exchange.write(prevNote);
          }

          // Now add the new note to the list
          notes.add(note);
        });

        exchange.exceptionHandler(err -> {
          System.out.println("routeChat cancelled");
        });

        exchange.endHandler(v -> exchange.end());
      }
    }).build();
    server.start(ar -> {
      if (ar.succeeded()) {
        System.out.println("gRPC service started");
      } else {
        System.out.println("Could not start server " + ar.cause().getMessage());
      }
    });
  }

  class RouteRecorder {

    int pointCount;
    int featureCount;
    int distance;
    Point previous;
    final long startTime = System.nanoTime();

    void append(Point point) {
      pointCount++;
      if (Util.exists(checkFeature(point))) {
        featureCount++;
      }
      // For each point after the first, add the incremental distance from the previous point to
      // the total distance value.
      if (previous != null) {
        distance += calcDistance(previous, point);
      }
      previous = point;
    }

    RouteSummary build() {
      long seconds = NANOSECONDS.toSeconds(System.nanoTime() - startTime);
      return RouteSummary.newBuilder().setPointCount(pointCount)
        .setFeatureCount(featureCount).setDistance(distance)
        .setElapsedTime((int) seconds).build();
    }
  }

  /**
   * Get the notes list for the given location. If missing, create it.
   */
  private List<RouteNote> getOrCreateNotes(Point location) {
    List<RouteNote> notes = Collections.synchronizedList(new ArrayList<RouteNote>());
    List<RouteNote> prevNotes = routeNotes.putIfAbsent(location, notes);
    return prevNotes != null ? prevNotes : notes;
  }

  /**
   * Gets the feature at the given point.
   *
   * @param location the location to check.
   * @return The feature object at the point. Note that an empty name indicates no feature.
   */
  private Feature checkFeature(Point location) {
    for (Feature feature : features) {
      if (feature.getLocation().getLatitude() == location.getLatitude()
        && feature.getLocation().getLongitude() == location.getLongitude()) {
        return feature;
      }
    }

    // No feature was found, return an unnamed feature.
    return Feature.newBuilder().setName("").setLocation(location).build();
  }

  /**
   * Calculate the distance between two points using the "haversine" formula.
   * This code was taken from http://www.movable-type.co.uk/scripts/latlong.html.
   *
   * @param start The starting point
   * @param end The end point
   * @return The distance between the points in meters
   */
  private static int calcDistance(Point start, Point end) {
    double lat1 = Util.getLatitude(start);
    double lat2 = Util.getLatitude(end);
    double lon1 = Util.getLongitude(start);
    double lon2 = Util.getLongitude(end);
    int r = 6371000; // meters
    double phi1 = Math.toRadians(lat1);
    double phi2 = Math.toRadians(lat2);
    double deltaPhi = Math.toRadians(lat2 - lat1);
    double deltaLambda = Math.toRadians(lon2 - lon1);

    double a = Math.sin(deltaPhi / 2) * Math.sin(deltaPhi / 2)
      + Math.cos(phi1) * Math.cos(phi2) * Math.sin(deltaLambda / 2) * Math.sin(deltaLambda / 2);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

    return (int) (r * c);
  }
}