ルート検索を開始する

try {
    routingEngine = new RoutingEngine();
} catch (InstantiationErrorException e) {
    throw new RuntimeException("Initialization of RoutingEngine failed: " + e.error.name());
}

try {
    routingEngine = RoutingEngine()
} catch (e: InstantiationErrorException) {
    throw RuntimeException("Initialization of RoutingEngine failed: " + e.error.name)
}

Waypoint startWaypoint = new Waypoint(startGeoCoordinates);
Waypoint destinationWaypoint = new Waypoint(destinationGeoCoordinates);

List<Waypoint> waypoints =
        new ArrayList<>(Arrays.asList(startWaypoint, destinationWaypoint));

routingEngine.calculateRoute(
        waypoints,
        new RoutingOptions(),
        new CalculateRouteCallback() {
            @Override
            public void onRouteCalculated(@Nullable RoutingError routingError, @Nullable List<Route> routes) {
                if (routingError == null) {
                    Route route = routes.get(0);
                    showRouteDetails(route);
                    showRouteOnMap(route);
                    logRouteViolations(route);
                } else {
                    showDialog("Error while calculating a route:", routingError.toString());
                }
            }
        });

val startWaypoint = Waypoint(startGeoCoordinates)
val destinationWaypoint = Waypoint(destinationGeoCoordinates)

val waypoints = arrayListOf(startWaypoint, destinationWaypoint)

private fun calculateRoute(waypoints: List<Waypoint>) {
    routingEngine?.calculateRoute(
        waypoints,
        RoutingOptions(),
        object : CalculateRouteCallback {
            override fun onRouteCalculated(routingError: RoutingError?, routes: List<Route>?) {
                if (routingError == null) {
                    val route: Route = routes!![0]
                    showRouteDetails(route)
                    showRouteOnMap(route)
                    logRouteViolations(route)
                } else {
                    showDialog("Error while calculating a route:", routingError.toString())
                }
            }
        })
}

// estimatedTravelTimeInSeconds includes traffic delay.
long estimatedTravelTimeInSeconds = route.getDuration().getSeconds();
// Get predictive traffic delay data.
long estimatedTrafficDelayInSeconds = route.getTrafficDelay().getSeconds();
int lengthInMeters = route.getLengthInMeters();

// estimatedTravelTimeInSeconds includes traffic delay.
val estimatedTravelTimeInSeconds: Long = route.duration.seconds
// Get predictive traffic delay data.
val estimatedTrafficDelayInSeconds: Long = route.trafficDelay.seconds
val lengthInMeters: Int = route.lengthInMeters

/**
 * Returns the ETA (as a string in ‘HH:mm’ format) in the current device’s timezone, derived from the estimatedTravelTimeInSeconds, which is sourced from the Route object.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the ETA in "HH:mm" format.
 */
public String getETAinDeviceTimeZone(Route route) {
    long estimatedTravelTimeInSeconds = route.getDuration().toSeconds();

    // Get an instance of the Calendar class initialized with the current date and time
    Calendar calendar = Calendar.getInstance();

    // Set the calendar's time to the current date and time
    calendar.setTime(new Date());

    // Add the estimated travel time (in seconds) to the current time
    calendar.add(Calendar.SECOND, (int) estimatedTravelTimeInSeconds);

    return getFormattedDate(calendar.getTime());
}

/**
 * Returns the ETA (as a string in ‘HH:mm’ format) in the current device’s timezone, derived from the estimatedTravelTimeInSeconds, which is sourced from the Route object.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the ETA in "HH:mm" format.
 */
fun getETAinDeviceTimeZone(route: Route): String {
    val estimatedTravelTimeInSeconds = route.duration.toSeconds()

    // Get an instance of the Calendar class initialized with the current date and time
    val calendar = Calendar.getInstance()

    // Set the calendar's time to the current date and time
    calendar.time = Date()

    // Add the estimated travel time (in seconds) to the current time
    calendar.add(Calendar.SECOND, estimatedTravelTimeInSeconds.toInt())

    return getFormattedDate(calendar.time)
}

/**
 * Calculates the estimated time of arrival (ETA) in the destination timezone for a given route.
 * It is possible that the destination can be in a different timezone compared to the source.
 * Therefore, we are also calculating the ETA in the destination timezone. For example, the source can be in Berlin and the destination can be in Dubai.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the estimated time of arrival in the destination timezone, formatted as "hh:mm".
 */
public String getETAinDestinationTimeZone(Route route) {
    LocationTime arrivalLocationTime = getArrivalLocationTime(route);
    Date destinationDate = arrivalLocationTime.localTime;

    // The timeOffset represents the difference between the local time at destination and Coordinated Universal Time (UTC) in minutes.
    int timeOffset = (int) arrivalLocationTime.utcOffset.toMinutes();

    return getFormattedDate(destinationDate, timeOffset);
}

/**
 * Calculates the estimated time of arrival (ETA) in the destination timezone for a given route.
 * It is possible that the destination can be in a different timezone compared to the source.
 * Therefore, we are also calculating the ETA in the destination timezone. For example, the source can be in Berlin and the destination can be in Dubai.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the estimated time of arrival in the destination timezone, formatted as "hh:mm".
 */
fun getETAinDestinationTimeZone(route: Route): String {
    val arrivalLocationTime = getArrivalLocationTime(route)
    val destinationDate = arrivalLocationTime!!.localTime

    // The timeOffset represents the difference between the local time at destination and Coordinated Universal Time (UTC) in minutes.
    val timeOffset = arrivalLocationTime.utcOffset.toMinutes().toInt()

    return getFormattedDate(destinationDate, timeOffset)
}

/**
 * Calculates the estimated time of arrival (ETA) in Coordinated Universal Time (UTC) for a given route.
 * UTC (Coordinated Universal Time) is the primary time standard by which the world regulates clocks and time.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the estimated time of arrival in UTC, formatted as "HH:mm".
 */
public String getEstimatedTimeOfArrivalInUTC(Route route) {
    Date utcDate = getArrivalLocationTime(route).utcTime;

    // The UTC offset represents the difference in hours and minutes between a specific time zone and Coordinated Universal Time (UTC).
    // It indicates whether the local time is ahead (+) or behind (-) UTC.
    // By using an offset of 0, we ensure that the time being represented is in Coordinated Universal Time (UTC).
    int utcTimeOffset = 0;
    return getFormattedDate(utcDate, utcTimeOffset);
}

/**
 * Calculates the estimated time of arrival (ETA) in Coordinated Universal Time (UTC) for a given route.
 * UTC (Coordinated Universal Time) is the primary time standard by which the world regulates clocks and time.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the estimated time of arrival in UTC, formatted as "HH:mm".
 */
fun getEstimatedTimeOfArrivalInUTC(route: Route): String {
    val utcDate = getArrivalLocationTime(route)!!.utcTime

    // The UTC offset represents the difference in hours and minutes between a specific time zone and Coordinated Universal Time (UTC).
    // It indicates whether the local time is ahead (+) or behind (-) UTC.
    // By using an offset of 0, we ensure that the time being represented is in Coordinated Universal Time (UTC).
    val utcTimeOffset = 0
    return getFormattedDate(utcDate, utcTimeOffset)
}

// Returns the arrival time at the final location of the route.
private LocationTime getArrivalLocationTime(Route route) {
    int lastSectionIndex = route.getSections().size() - 1;

    // The lastSection contains cumulative duration values that increase sequentially.
    // For instance, if there are two sections, each with a duration of 5 minutes, the first section will reflect a total duration of 5 minutes,
    // while the second section will show a total duration of 10 minutes.
    // This is because the total time includes the initial 5 minutes for the first section, followed by an additional 5 minutes to complete the second section, resulting in a cumulative travel time.
    Section lastSection = route.getSections().get(lastSectionIndex);
    return lastSection.getArrivalLocationTime();
}

// Returns the arrival time at the final location of the route.
private fun getArrivalLocationTime(route: Route): LocationTime? {
    val lastSectionIndex = route.sections.size - 1

    // The lastSection contains cumulative duration values that increase sequentially.
    // For instance, if there are two sections, each with a duration of 5 minutes, the first section will reflect a total duration of 5 minutes,
    // while the second section will show a total duration of 10 minutes.
    // This is because the total time includes the initial 5 minutes for the first section, followed by an additional 5 minutes to complete the second section, resulting in a cumulative travel time.
    val lastSection = route.sections[lastSectionIndex]
    return lastSection.arrivalLocationTime
}

/**
 * Formats the given date to a string representation based on the specified timezone offset.
 *
 * @param date   The Date object to be formatted.
 * @param offset The UTC offset in minutes for the desired timezone.
 * @return A string representing the formatted time in the specified timezone.
 */
private String getFormattedDate(Date date, int offset) {
    // Create a DateFormat instance that formats the time in a short format (e.g., "HH:mm a").
    java.text.DateFormat dateFormat = SimpleDateFormat.getTimeInstance(java.text.DateFormat.SHORT);

    // Retrieve the TimeZone object corresponding to the given UTC offset.
    TimeZone timeZone = getTimeZone(offset);

    // Set the DateFormat's timezone to the retrieved TimeZone.
    dateFormat.setTimeZone(timeZone);

    // Format the date using the configured DateFormat and return the result as a string.
    return dateFormat.format(date);
}

/**
 * Formats the given date to a string representation using the device's default timezone.
 *
 * @param date The Date object to be formatted.
 * @return     A string representing the formatted time in the default timezone.
 */
private String getFormattedDate(Date date) {
    // Create a DateFormat instance that formats the time in a short format (e.g., "HH:mm a").
    java.text.DateFormat dateFormat = SimpleDateFormat.getTimeInstance(java.text.DateFormat.SHORT);

    // Format the date using the configured DateFormat and return the result as a string.
    return dateFormat.format(date);
}

/**
 * Retrieves a TimeZone object based on the given UTC offset in minutes.
 *
 * @param utcOffsetInMinutes The UTC offset in minutes (can be positive or negative).
 * @return A TimeZone object representing the specified offset from GMT.
 */
private TimeZone getTimeZone(int utcOffsetInMinutes) {
    // Calculate the offset in hours.
    int hours = utcOffsetInMinutes / 60;

    // Calculate the remaining offset in minutes after converting to hours.
    int minutes = utcOffsetInMinutes % 60;

    // Create a string representing the time zone in GMT format (e.g., "GMT+05:30").
    String timeZoneId = String.format("GMT%+03d:%02d", hours, minutes);

    // Retrieve and return the TimeZone object corresponding to the constructed GMT time zone ID.
    return TimeZone.getTimeZone(timeZoneId);
}

/**
 * Formats the given date to a string representation based on the specified timezone offset.
 *
 * @param date   The Date object to be formatted.
 * @param offset The UTC offset in minutes for the desired timezone.
 * @return A string representing the formatted time in the specified timezone.
 */
private fun getFormattedDate(date: Date, offset: Int): String {
    // Create a DateFormat instance that formats the time in a short format (e.g., "HH:mm a").
    val dateFormat = SimpleDateFormat.getTimeInstance(DateFormat.SHORT)

    // Retrieve the TimeZone object corresponding to the given UTC offset.
    val timeZone = getTimeZone(offset)

    // Set the DateFormat's timezone to the retrieved TimeZone.
    dateFormat.timeZone = timeZone

    // Format the date using the configured DateFormat and return the result as a string.
    return dateFormat.format(date)
}

/**
 * Formats the given date to a string representation using the device's default timezone.
 *
 * @param date The Date object to be formatted.
 * @return     A string representing the formatted time in the default timezone.
 */
private fun getFormattedDate(date: Date): String {
    // Create a DateFormat instance that formats the time in a short format (e.g., "HH:mm a").
    val dateFormat = SimpleDateFormat.getTimeInstance(DateFormat.SHORT)

    // Format the date using the configured DateFormat and return the result as a string.
    return dateFormat.format(date)
}

/**
 * Retrieves a TimeZone object based on the given UTC offset in minutes.
 *
 * @param utcOffsetInMinutes The UTC offset in minutes (can be positive or negative).
 * @return A TimeZone object representing the specified offset from GMT.
 */
private fun getTimeZone(utcOffsetInMinutes: Int): TimeZone {
    // Calculate the offset in hours.
    val hours = utcOffsetInMinutes / 60

    // Calculate the remaining offset in minutes after converting to hours.
    val minutes = utcOffsetInMinutes % 60

    // Format the time zone as a GMT offset string, such as "GMT+05:30" or "GMT-04:00".
    val timeZoneId = "GMT%+03d:%02d".format(hours, minutes)

    // Retrieve and return the TimeZone object corresponding to the constructed GMT time zone ID.
    return TimeZone.getTimeZone(timeZoneId)
}

routeOptions.trafficOptimizationMode = TrafficOptimizationMode.DISABLED;

routeOptions.trafficOptimizationMode = TrafficOptimizationMode.DISABLED

for (RouteRailwayCrossing routeRailwayCrossing : route.getRailwayCrossings()) {
    // Coordinates of the route offset
    GeoCoordinates routeOffsetCoordinates = routeRailwayCrossing.coordinates;
    // Index of the corresponding route section. The start of the section indicates the start of the offset.
    int routeOffsetSectionIndex = routeRailwayCrossing.routeOffset.sectionIndex;
    // Offset from the start of the specified section to the specified location along the route.
    double routeOffsetInMeters = routeRailwayCrossing.routeOffset.offsetInMeters;

    Log.d(TAG, "A railway crossing of type " + routeRailwayCrossing.type.name() +
        "is situated " +
        routeOffsetInMeters + " m away from start of section: " +
        routeOffsetSectionIndex);
}

for (routeRailwayCrossing in route.railwayCrossings) {
    // Coordinates of the route offset
    val routeOffsetCoordinates: GeoCoordinates = routeRailwayCrossing.coordinates
    // Index of the corresponding route section. The start of the section indicates the start of the offset.
    val routeOffsetSectionIndex: Int = routeRailwayCrossing.routeOffset.sectionIndex
    // Offset from the start of the specified section to the specified location along the route.
    val routeOffsetInMeters: Double = routeRailwayCrossing.routeOffset.offsetInMeters

    Log.d(TAG, "A railway crossing of type " + routeRailwayCrossing.type.name +
        "is situated " +
        routeOffsetInMeters + " m away from start of section: " +
        routeOffsetSectionIndex)
}

// A route may contain several warnings, for example, when a certain route option could not be fulfilled.
// An implementation may decide to reject a route if one or more violations are detected.
private void logRouteViolations(Route route) {
    for (Section section : route.getSections()) {
        for (Span span : section.getSpans()) {
            List<GeoCoordinates> spanGeometryVertices = span.getGeometry().vertices;
            // This route violation spreads across the whole span geometry.
            GeoCoordinates violationStartPoint = spanGeometryVertices.get(0);
            GeoCoordinates violationEndPoint = spanGeometryVertices.get(spanGeometryVertices.size() - 1);
            for (int index : span.getNoticeIndexes()) {
                SectionNotice spanSectionNotice = section.getSectionNotices().get(index);
                // The violation code such as "VIOLATED_VEHICLE_RESTRICTION".
                String violationCode = spanSectionNotice.code.toString();
                Log.d(TAG, "The violation " + violationCode + " starts at " + toString(violationStartPoint) + " and ends at " + toString(violationEndPoint) + " .");
            }
        }
    }
}

// A route may contain several warnings, for example, when a certain route option could not be fulfilled.
// An implementation may decide to reject a route if one or more violations are detected.
private fun logRouteViolations(route: Route) {
    for (section in route.sections) {
        for (span in section.spans) {
            val spanGeometryVertices: List<GeoCoordinates> = span.geometry.vertices
            // This route violation spreads across the whole span geometry.
            val violationStartPoint: GeoCoordinates = spanGeometryVertices[0]
            val violationEndPoint: GeoCoordinates =
                spanGeometryVertices[spanGeometryVertices.size - 1]
            for (index in span.noticeIndexes) {
                val spanSectionNotice: SectionNotice = section.sectionNotices[index]
                // The violation code such as "VIOLATED_VEHICLE_RESTRICTION".
                val violationCode: String = spanSectionNotice.code.toString()
                Log.d(TAG, "The violation " + violationCode + " starts at "
                   + toString(violationStartPoint) + " and ends at " + toString(violationEndPoint) + " .")
            }
        }
    }
}