Find a route and directions

namespace Esri::ArcGISRuntime {

class Map;

class MapQuickView;

class Graphic;
class GraphicsOverlay;
class PictureMarkerSymbol;
class RouteTask;

class Graphic;
class GraphicsOverlay;
class PictureMarkerSymbol;
class RouteTask;

}  // namespace Esri::ArcGISRuntime

enum RouteBuilderStatus
{
  NotStarted,
  SelectedStart,
  SelectedStartAndEnd,
};

enum RouteBuilderStatus
{
  NotStarted,
  SelectedStart,
  SelectedStartAndEnd,
};

#include <QObject>

#include "RouteParameters.h"
class QAbstractListModel;
Q_MOC_INCLUDE("QAbstractListModel")

Q_MOC_INCLUDE("MapQuickView.h")

class Display_a_map : public QObject
{
    Q_OBJECT

    Q_PROPERTY(Esri::ArcGISRuntime::MapQuickView* mapView READ mapView WRITE setMapView NOTIFY mapViewChanged)

    Q_PROPERTY(QAbstractListModel* directions MEMBER m_directions NOTIFY directionsChanged)

public:
    explicit Display_a_map(QObject* parent = nullptr);
    ~Display_a_map() override;

signals:
    void mapViewChanged();

    void directionsChanged();

private:
    Esri::ArcGISRuntime::MapQuickView* mapView() const;
    void setMapView(Esri::ArcGISRuntime::MapQuickView* mapView);

    void setupViewpoint();

    void setupRouteTask();
    void findRoute();
    void resetState();

    void setupRouteTask();
    void findRoute();
    void resetState();

    Esri::ArcGISRuntime::Map* m_map = nullptr;

    Esri::ArcGISRuntime::MapQuickView* m_mapView = nullptr;

    Esri::ArcGISRuntime::GraphicsOverlay* m_graphicsOverlay = nullptr;
    Esri::ArcGISRuntime::RouteTask* m_routeTask = nullptr;
    Esri::ArcGISRuntime::Graphic* m_startGraphic = nullptr;
    Esri::ArcGISRuntime::Graphic* m_endGraphic = nullptr;
    Esri::ArcGISRuntime::Graphic* m_lineGraphic = nullptr;
    QAbstractListModel* m_directions = nullptr;
    Esri::ArcGISRuntime::RouteParameters m_routeParameters;
    RouteBuilderStatus m_currentState;

#include "Display_a_map.h"
#include "Map.h"

#include "MapTypes.h"

#include "MapQuickView.h"

#include "Point.h"
#include "Viewpoint.h"
#include "SpatialReference.h"
#include <QFuture>

#include "DirectionManeuverListModel.h"
#include "Graphic.h"
#include "GraphicListModel.h"
#include "GraphicsOverlay.h"
#include "GraphicsOverlayListModel.h"
#include "Polyline.h"
#include "RouteTask.h"
#include "RouteResult.h"
#include "RouteParameters.h"
#include "Route.h"
#include "SimpleLineSymbol.h"
#include "SimpleMarkerSymbol.h"
#include "Stop.h"
#include "Symbol.h"
#include "SymbolTypes.h"
#include <QGeoPositionInfoSource>
#include <QList>
#include <QUrl>
#include <QUuid>

Display_a_map::Display_a_map(QObject* parent /* = nullptr */):

    QObject(parent),

    m_map(new Map(BasemapStyle::ArcGISStreets, this)),

    m_currentState(RouteBuilderStatus::NotStarted)

Display_a_map::Display_a_map(QObject* parent /* = nullptr */):

    QObject(parent),

    m_map(new Map(BasemapStyle::ArcGISStreets, this)),

    m_currentState(RouteBuilderStatus::NotStarted)

{

    setupRouteTask();

MapQuickView* Display_a_map::mapView() const
{
    return m_mapView;
}


void Display_a_map::setupViewpoint()
{

    const Point center(-118.24532, 34.05398, SpatialReference::wgs84());
    const Viewpoint viewpoint(center, 144447.638572);

void Display_a_map::setupViewpoint()
{

    const Point center(-118.24532, 34.05398, SpatialReference::wgs84());
    const Viewpoint viewpoint(center, 144447.638572);

    m_mapView->setViewpointAsync(viewpoint);

    // Connect the mouse click signal to handle user interactions for selecting start and end points.
    connect(m_mapView, &MapQuickView::mouseClicked, this, [this](QMouseEvent& mouse)
    {
        // Convert the screen coordinates of the mouse click to a map point.
        const Point mapPoint = m_mapView->screenToLocation(mouse.position().x(), mouse.position().y());

        // Handle the current state of the route builder and update the start and end points accordingly.
        switch (m_currentState)
        {
        case RouteBuilderStatus::NotStarted:

            // Reset the route and directions state.
            resetState();
            m_currentState = RouteBuilderStatus::SelectedStart;
            m_startGraphic->setGeometry(mapPoint);
            break;
        case RouteBuilderStatus::SelectedStart:

            // Set the end point graphic's geometry to the clicked map point.
            m_currentState = RouteBuilderStatus::SelectedStartAndEnd;
            m_endGraphic->setGeometry(mapPoint);
            findRoute();
            break;

        case RouteBuilderStatus::SelectedStartAndEnd:

            // Ignore touches while routing is in progress
            break;
        }
    });

        case RouteBuilderStatus::SelectedStartAndEnd:

            // Ignore touches while routing is in progress
            break;
        }
    });

    // Create the graphics overlay and add it to the map view. This overlay will hold the start,
    // end, and route line graphics.
    m_graphicsOverlay = new GraphicsOverlay(this);
    m_mapView->graphicsOverlays()->append(m_graphicsOverlay);

    // Create the start graphic with a diamond marker symbol and add it to the graphics overlay.
    SimpleLineSymbol* startOutlineSymbol = new SimpleLineSymbol(
        SimpleLineSymbolStyle::Solid, QColor("blue"), 2/*width*/, this);
    SimpleMarkerSymbol* startSymbol = new SimpleMarkerSymbol(
        SimpleMarkerSymbolStyle::Diamond, QColor("orange"), 12/*width*/, this);
    startSymbol->setOutline(startOutlineSymbol);
    m_startGraphic = new Graphic(this);
    m_startGraphic->setSymbol(startSymbol);

    // Create the end graphic with a square marker symbol and add it to the graphics overlay.
    SimpleLineSymbol* endOutlineSymbol = new SimpleLineSymbol(
        SimpleLineSymbolStyle::Solid, QColor("red"), 2/*width*/, this);
    SimpleMarkerSymbol* endSymbol = new SimpleMarkerSymbol(
        SimpleMarkerSymbolStyle::Square, QColor("green"), 12/*width*/, this);
    endSymbol->setOutline(endOutlineSymbol);
    m_endGraphic = new Graphic(this);
    m_endGraphic->setSymbol(endSymbol);

    // Create the route line graphic with a solid blue line symbol and add it to the graphics overlay.
    SimpleLineSymbol* lineSymbol = new SimpleLineSymbol(
        SimpleLineSymbolStyle::Solid, QColor("blue"), 4/*width*/, this);
    m_lineGraphic = new Graphic(this);
    m_lineGraphic->setSymbol(lineSymbol);

    // Add the start, end, and route line graphics to the graphics overlay.
    m_graphicsOverlay->graphics()->append(QList<Graphic*> {m_startGraphic, m_endGraphic, m_lineGraphic});

}

void Display_a_map::setupRouteTask()
{
    // Create the route task pointing to an online service.
    m_routeTask = new RouteTask(
        QUrl("https://route-api.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World"), this);

    // Create the default parameters which will load the route task implicitly.
    m_routeTask->createDefaultParametersAsync().then(this,[this](const RouteParameters& routeParameters)
    {
        // Store the resulting route parameters.
        m_routeParameters = routeParameters;
    });
}

void Display_a_map::findRoute()
{
    // Ensure the route task is loaded and the route parameters are available before attempting to find a route.
    if (m_routeTask->loadStatus() != LoadStatus::Loaded || m_routeParameters.isEmpty())
        return;

    // Set parameters to return directions.
    m_routeParameters.setReturnDirections(true);

    // Clear previous stops from the parameters.
    m_routeParameters.clearStops();

    // Set the stops to the parameters.
    const Stop stop1(Point(m_startGraphic->geometry()));
    const Stop stop2(Point(m_endGraphic->geometry()));
    m_routeParameters.setStops(QList<Stop> { stop1, stop2 });

    // Solve the route with the parameters.
    m_routeTask->solveRouteAsync(m_routeParameters).then(this,[this](const RouteResult& routeResult)
    {
        // Add the route graphic once the solve completes.
        const Route generatedRoute = routeResult.routes().at(0);
        Polyline routePolyline = generatedRoute.routeGeometry();
        m_lineGraphic->setGeometry(routePolyline);
        m_currentState = RouteBuilderStatus::NotStarted;

        // Set the direction maneuver list model.
        DirectionManeuverListModel* directionManeuverListModel = generatedRoute.directionManeuvers(this);
        m_directions = directionManeuverListModel;

        // Emit the signal to notify that the directions have changed.
        emit directionsChanged();
    });
}

void Display_a_map::resetState()
{
    // Resets the state of the route and directions, clearing all graphics and setting the status to NotStarted.
    m_startGraphic->setGeometry(Point());
    m_endGraphic->setGeometry(Point());
    m_lineGraphic->setGeometry(Point());
    m_directions = nullptr;
    m_currentState = RouteBuilderStatus::NotStarted;
}

import QtQuick
import QtQuick.Controls
import Esri.Display_a_map

import QtQuick.Shapes

    // Declare the C++ instance which creates the map etc. and supply the view.
    Display_a_map {
        id: model
        mapView: view
    }

    // Create window for displaying the route directions.
    Rectangle {
        id: directionWindow
        anchors {
            right: parent.right
            top: parent.top
            margins: 5
        }

        radius: 5
        visible: model.directions
        width: Qt.platform.os === "ios" || Qt.platform.os === "android" ? 250 : 350
        height: parent.height / 2
        color: "#FBFBFB"
        clip: true

        ListView {
            id: directionsView
            anchors {
                fill: parent
                margins: 5
            }
            header: Component {
                Text {
                    height: 40
                    text: "Directions:"
                    font.pixelSize: 22
                }
            }

            // Set the model to the DirectionManeuverListModel returned from the route.
            model: model.directions
            delegate: directionDelegate
        }
    }

    Component {
        id: directionDelegate
        Rectangle {
            id: rect
            width: parent.width
            height: textDirections.height
            color: directionWindow.color

            // separator for directions
            Shape {
                height: 2
                ShapePath {
                    strokeWidth: 1
                    strokeColor: "darkgrey"
                    strokeStyle: ShapePath.SolidLine
                    startX: 20; startY: 0
                    PathLine { x: parent.width - 20 ; y: 0 }
                }
            }

            Text {
                id: textDirections
                text: qsTr("%1 (%2 miles)".arg(directionText).arg((length * 0.00062137).toFixed(2)))
                wrapMode: Text.WordWrap
                anchors {
                    leftMargin: 5
                    left: parent.left
                    right: parent.right
                }
            }
        }
    }