Search for an address

Before starting this tutorial:

1. You need an ArcGIS Location Platform or ArcGIS Online account.

2. Your system meets the system requirements.

3. The ArcGIS Maps SDK for Qt, version 300.0.0 or later is installed.

4. The Qt 6.8.2 software development framework or later is installed.

Option 1: Develop the code

To start the tutorial, complete the Display a map tutorial. This creates a map to display the Santa Monica Mountains in California using the topographic basemap from the ArcGIS Basemap Styles service The ArcGIS Basemap Styles service, also referred to as the Basemap Styles service, is a location service that provides basemap styles and data for the world. It returns styles as Mapbox styles and web maps, and data as vector tiles and/or map tiles. It supports all of the styles in the ArcGIS Basemap style and Open Basemap style family. An ArcGIS Location Platform or ArcGIS Online account is required to use the service. Learn more .

Open a Qt Creator project

1. Open the project you created by completing the Display a map tutorial.
2. Continue with the following instructions to add a search bar to the user interface and search for an address or place using the ArcGIS Geocoding service A geocoding service is a service that can search for addresses, place addresses, businesses, reverse geocode coordinates to addresses, provide suggestions for places, and perform bulk geocoding. It is hosted by Esri as the ArcGIS Geocoding service and can also be hosted in ArcGIS Enterprise. Learn more .

Declare classes, member variables, functions, and signals

1. Double click on Headers > Display_a_map.h to open the file. Declare the classes shown.

   Display_a_map.h

   namespace Esri::ArcGISRuntime {
   
   class Map;
   
   class MapQuickView;
   
   class GraphicsOverlay;
   class Graphic;
   class LocatorTask;
   class GeocodeResult;
   class SuggestResult;
   class TextSymbol;

2. Staying in the same file, add the following two #include statements as shown.

   Display_a_map.h

   #include <QObject>
   
   Q_MOC_INCLUDE("MapQuickView.h")
   
   #include <QAbstractListModel>
   #include "GeocodeParameters.h"

3. Continuing in the same file, add a Q_PROPERTY for the member variable suggestions.

   Display_a_map.h

   class Display_a_map : public QObject
   {
     Q_OBJECT
   
     Q_PROPERTY(Esri::ArcGISRuntime::MapQuickView* mapView READ mapView WRITE setMapView NOTIFY mapViewChanged)
   
     Q_PROPERTY(QAbstractListModel* suggestions READ suggestions NOTIFY suggestionsChanged)

4. Add the following public member functions with the Q_INVOKABLE macro to allow these to be invokable from the GUI.

   Display_a_map.h

   public:
     explicit Display_a_map(QObject* parent = nullptr);
     ~Display_a_map() override;
   
     Q_INVOKABLE void geocode(const QString& query);
     Q_INVOKABLE void clearGraphics();
     Q_INVOKABLE void setSuggestions(const QString& text);

5. Add two new signal declarations.

   Display_a_map.h

   signals:
     void mapViewChanged();
   
     void suggestionsChanged();
     void hideSuggestionView();

6. Declare the setupLocatorTask private method.

   Display_a_map.h

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

7. Finally in the Display_a_map.h file, add the following six private member functions and variables. Then save the file.

   Display_a_map.h

   private:
     Esri::ArcGISRuntime::MapQuickView* mapView() const;
     void setMapView(Esri::ArcGISRuntime::MapQuickView* mapView);
   
     void setupViewpoint();
   
     void setupLocatorTask();
   
     Esri::ArcGISRuntime::Map* m_map = nullptr;
   
     Esri::ArcGISRuntime::MapQuickView* m_mapView = nullptr;
   
     void configureGraphic();
     QAbstractListModel* suggestions() const;
     Esri::ArcGISRuntime::GraphicsOverlay* m_graphicsOverlay = nullptr;
     Esri::ArcGISRuntime::LocatorTask* m_locatorTask = nullptr;
     Esri::ArcGISRuntime::Graphic* m_graphicResultLocation = nullptr;
     Esri::ArcGISRuntime::Graphic* m_graphicResultText = nullptr;
     Esri::ArcGISRuntime::TextSymbol* m_textSymbol = nullptr;
     QAbstractListModel* m_suggestListModel = nullptr;
     Esri::ArcGISRuntime::GeocodeParameters m_geocodeParams;

Include header files to access needed classes

1. In Projects, double click on Sources > Display_a_map.cpp to open the file and add the following #include statements.

   Display_a_map.cpp

   #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 "AttributeListModel.h"
   #include "Envelope.h"
   #include "GeocodeResult.h"
   #include "Graphic.h"
   #include "GraphicListModel.h"
   #include "GraphicsOverlay.h"
   #include "GraphicsOverlayListModel.h"
   #include "LocatorTask.h"
   #include "SimpleMarkerSymbol.h"
   #include "SimpleRenderer.h"
   #include "SymbolTypes.h"
   #include "SuggestParameters.h"
   #include "SuggestListModel.h"
   #include "TextSymbol.h"

2. Continuing in the same file, include the following Qt classes.

   Display_a_map.cpp

   #include "AttributeListModel.h"
   #include "Envelope.h"
   #include "GeocodeResult.h"
   #include "Graphic.h"
   #include "GraphicListModel.h"
   #include "GraphicsOverlay.h"
   #include "GraphicsOverlayListModel.h"
   #include "LocatorTask.h"
   #include "SimpleMarkerSymbol.h"
   #include "SimpleRenderer.h"
   #include "SymbolTypes.h"
   #include "SuggestParameters.h"
   #include "SuggestListModel.h"
   #include "TextSymbol.h"
   
   #include <QAbstractListModel>
   #include <QGeoPositionInfoSource>
   #include <QUrl>
   #include <QUuid>

Create a locator task with geocode parameters

Geocoding is implemented with a locator A locator is an ArcGIS dataset that stores address information and the rules for translating descriptions of places (such as street addresses or place names) into spatial data that can be displayed on a map. Learn more , typically created by referencing a service such as the Geocoding service A geocoding service is a service that can search for addresses, place addresses, businesses, reverse geocode coordinates to addresses, provide suggestions for places, and perform bulk geocoding. It is hosted by Esri as the ArcGIS Geocoding service and can also be hosted in ArcGIS Enterprise. Learn more or, for offline geocoding, by referencing locator data contained in a mobile package A mobile package is a stand-alone Mobile Map Package (MMPK) or Mobile Scene Package (MSPK) file for use in offline applications built with ArcGIS Maps SDKs for Native Apps. Learn more . Geocoding parameters can be used to fine-tune the results, such as setting the maximum number of results or requesting additional attributes in the results.

1. Staying in the Display_a_map.cpp file, add the call to setupLocatorTask. This method will be implemented next.

   Display_a_map.cpp

   Display_a_map::Display_a_map(QObject* parent /* = nullptr */):
   
       QObject(parent),
   
       m_map(new Map(BasemapStyle::ArcGISTopographic, this))
   {
   
       setupLocatorTask();

2. Continuing in the same file, add code to begin implementing the setupLocatorTask method and initialize the auto-suggestion list. Within the method body, create a new LocatorTask based on the Geocoding service, and set it to the m_locatorTask member variable. Additionally, create a SuggestParameters, instance and initialize it with three categories as shown. Then set max results to limit for the number of returned suggestion results to 5. Finally, configure GeocodeParameters, (m_geocodeParams). Add code to set the minimum match score and the attribute names for the results to be returned. Call suggestions on m_locatorTask and assign to m_suggestListModel.

   Display_a_map.cpp

   Display_a_map::~Display_a_map() = default;
   
   void Display_a_map::setupLocatorTask()
   {
       const QUrl geocode_service("https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer");
       m_locatorTask = new LocatorTask(geocode_service, this);
   
       SuggestParameters suggestParams;
       const QStringList categories{"Address", "POI", "Populated Place"};
       suggestParams.setCategories(categories);
       suggestParams.setMaxResults(5);
       m_locatorTask->suggestions()->setSuggestParameters(suggestParams);
   
       m_geocodeParams.setMinScore(75);
       m_geocodeParams.setResultAttributeNames(QStringList {"Place_addr", "Match_addr"});
       m_suggestListModel = m_locatorTask->suggestions();
       emit suggestionsChanged();
   }

   A locator task is used to convert an address to a point (geocode) or vice-versa (reverse geocode). An address includes any type of information that distinguishes a place. A locator A locator is an ArcGIS dataset that stores address information and the rules for translating descriptions of places (such as street addresses or place names) into spatial data that can be displayed on a map. Learn more involves finding matching locations for a given address. Reverse-geocoding is the opposite and finds the closest address for a given location.

Create the auto-suggestion feature

1. Staying in the Display_a_map.cpp file, towards the bottom of the file, add a new setSuggestions(const QString& text) method to implement the auto-suggestion feature. This generates a list of suggested addresses based on the user’s input in the GUI text field.

   Display_a_map.cpp

       setupViewpoint();
       emit mapViewChanged();
   }
   
   void Display_a_map::setSuggestions(const QString& text)
   {
       if (!m_suggestListModel)
           return;
   
       SuggestListModel* suggestListModel = dynamic_cast<SuggestListModel*>(m_suggestListModel);
   
       if (!suggestListModel)
           return;
   
       suggestListModel->setSearchText(text);
   }

2. Update the setupViewpoint method to respond to the user’s mouse selection of an address from the list of suggested addresses. Inject the following code immediately after the open curly braces but before the other code in the function.

   Display_a_map.cpp

   void Display_a_map::setupViewpoint()
   {
   
       connect(m_mapView, &MapQuickView::mousePressed, this, [this](QMouseEvent& /* event */)
       {
           emit hideSuggestionView();
       });
   
       const Point center(-118.80543, 34.02700, SpatialReference::wgs84());
       const Viewpoint viewpoint(center, 100000.0);
       m_mapView->setViewpointAsync(viewpoint);
   
   }

Add text and marker graphics to identify location on map

1. Continuing in the Display_a_map.cpp file, towards the bottom of the file, again update the setupViewpoint method to add the call to configureGraphic(), which will be implemented in the next step.

   Display_a_map.cpp

   void Display_a_map::setupViewpoint()
   {
   
       connect(m_mapView, &MapQuickView::mousePressed, this, [this](QMouseEvent& /* event */)
       {
           emit hideSuggestionView();
       });
   
       const Point center(-118.80543, 34.02700, SpatialReference::wgs84());
       const Viewpoint viewpoint(center, 100000.0);
       m_mapView->setViewpointAsync(viewpoint);
   
       configureGraphic();
   
   }

2. Still working in the Display_a_map.cpp file, implement the configureGraphic public method. Create a SimpleMarkerSymbol (blue square), initialize a Graphic and add that to a GraphicsOverlay. Then create TextSymbol, initialize a Graphic with that, and add it to the GraphicsOverlay. Then add the GraphicsOverlay to MapView.

   Display_a_map.cpp

       if (!suggestListModel)
           return;
   
       suggestListModel->setSearchText(text);
   }
   
   void Display_a_map::configureGraphic()
   {
       if (m_graphicResultLocation)
           return;
   
       // create graphics overlay and add to map view
       m_graphicsOverlay = new GraphicsOverlay(this);
   
       // set a renderer on the graphics overlay
       SimpleRenderer* simpleRenderer = new SimpleRenderer(this);
   
       // Create a graphic and symbol to display the result location.
       SimpleMarkerSymbol* simpleMarkerSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbolStyle::Square, QColor("blue"), 12.0, this);
       simpleRenderer->setSymbol(simpleMarkerSymbol);
       m_graphicResultLocation = new Graphic(this);
       m_graphicResultLocation->setSymbol(simpleMarkerSymbol);
       m_graphicsOverlay->graphics()->append(m_graphicResultLocation);
   
       // Create a graphic and symbol to display a label next to the result location
       m_textSymbol = new TextSymbol("", QColor("red"), 18.0, HorizontalAlignment::Center, VerticalAlignment::Bottom, this);
       m_graphicResultText = new Graphic(this);
       m_graphicResultText->setSymbol(m_textSymbol);
   
       m_graphicsOverlay->graphics()->append(m_graphicResultText);
   
       m_mapView->graphicsOverlays()->append(m_graphicsOverlay);
   }

Add the Geocode method

An asynchronous geocode operation is required to find and return the location candidates for a given address and geocode parameters.

1. Staying in the Display_a_map.cpp file, add the geocode(const QString& query) method to geocode an address when the user clicks on that address in the auto-suggestion list. This method will invoke the geocode with parameters async method on the LocatorTask. Within the body of the if statement, the code checks for geocoding results and verifies that the graphic exists. If both conditions are met, the result location is set as the graphic’s geometry and the attributes provided by the result are copied to the graphic. The map view display is centered on the graphic before making it visible. In the final block of code, the text symbol is set, the text graphic geometry for the geocoding result display location is set, the attributes for the text graphic is set, and graphic is made visible.

   Display_a_map.cpp

       m_graphicsOverlay->graphics()->append(m_graphicResultText);
   
       m_mapView->graphicsOverlays()->append(m_graphicsOverlay);
   }
   
   void Display_a_map::geocode(const QString& query)
   {
   
       m_locatorTask->geocodeWithParametersAsync(query, m_geocodeParams).then(this,[this](const QList<GeocodeResult>& geocodeResults)
       {
           if (!geocodeResults.isEmpty() && m_graphicResultLocation)
           {
               // display geocode result label and position
               const GeocodeResult geocodeResult = geocodeResults.at(0);
               m_graphicResultLocation->setGeometry(geocodeResult.displayLocation());
               m_graphicResultLocation->attributes()->setAttributesMap(geocodeResult.attributes());
               constexpr double scale = 8000.0;
   
               m_mapView->setViewpointCenterAsync(geocodeResult.extent().center(), scale);
   
               m_graphicResultLocation->setVisible(true);
               m_textSymbol->setText(geocodeResult.label());
               m_graphicResultText->setGeometry(geocodeResult.displayLocation());
               m_graphicResultText->attributes()->setAttributesMap(geocodeResult.attributes());
               m_graphicResultLocation->setVisible(true);
           }
       });
   
   }

2. Add the suggestions method to register the value of m_suggestListModel as the value of the QML property suggestions.

   Display_a_map.cpp

               m_graphicResultLocation->setVisible(true);
               m_textSymbol->setText(geocodeResult.label());
               m_graphicResultText->setGeometry(geocodeResult.displayLocation());
               m_graphicResultText->attributes()->setAttributesMap(geocodeResult.attributes());
               m_graphicResultLocation->setVisible(true);
           }
       });
   
   }
   
   QAbstractListModel* Display_a_map::suggestions() const
   {
       return m_suggestListModel;
   }

3. Finally in the Display_a_map.cpp file, add the clearGraphics method. Then save the file.

   Display_a_map.cpp

   QAbstractListModel* Display_a_map::suggestions() const
   {
       return m_suggestListModel;
   }
   
   void Display_a_map::clearGraphics()
   {
       m_graphicResultLocation->setGeometry(Point());
       m_graphicResultText->setGeometry(Point());
   }

Create the application GUI

The GUI will let you enter partial or full addresses into a field, see a list of matching addresses, click an address and zoom to that location, and clear the address field.

1. In Projects, click on Resources > qml\qml.qrc > /qml. Then open the file Display_a_mapForm.qml

2. Add the following import statement.

   Display_a_mapForm.qml

   import QtQuick
   import QtQuick.Controls
   import Esri.Display_a_map
   
   import QtQuick.Layouts

3. Change the line of code for the MapView component id from: model to search. See the yellow changed line.

   Display_a_mapForm.qml

       // Create MapQuickView here, and create its Map etc. in C++ code
       MapView {
           id: view
           anchors.fill: parent
           // set focus to enable keyboard navigation
           focus: true
       }
   
       // Declare the C++ instance that creates the map etc. and supply the view
       Display_a_map {
   
           id: search
   
           mapView: view
       }

4. Add the following QML code to implement the app GUI.

   Display_a_mapForm.qml

       // Declare the C++ instance that creates the map etc. and supply the view
       Display_a_map {
   
           id: search
   
           mapView: view
       }
   
       Rectangle {
           // add rectangle for gui code
           id: searchRect
           width: parent.width
           height: childrenRect.height
           property int cellHeight: 40;
   
           Column {
               anchors {
                   fill: parent
                   margins: 10
               }
               Rectangle {
                   color: "#f7f8fa"
                   border {
                       color: "#7B7C7D"
                   }
                   radius: 2
                   width: parent.width
                   height: childrenRect.height
   
                   GridLayout {
                       width: parent.width
                       columns: 4
                       TextField {
                           id: textField
                           Layout.margins: 5
                           Layout.fillWidth: true
                           font.pixelSize: 14
                           placeholderText: "Type in an address"
                           selectByMouse: true
   
                           onTextChanged: {
                               if (text.length > 0 && suggestView)
                                   suggestView.visible = true;
                               search.setSuggestions(text);
                           }
   
                           onAccepted: {
                               suggestView.visible = false;
                               search.geocode(textField.text);
                               Qt.inputMethod.hide();
                           }
                       }
   
                       Rectangle {
                           Layout.margins: 5
                           width: height
                           height: textField.height
                           color: "#f7f8fa"
                           visible: textField.length === 0
                           enabled: visible
   
                           Button {
                               anchors.fill: parent
                               text: "X"
                               font.pixelSize: 16
                               MouseArea {
                                   anchors.fill: parent
                                   onClicked: {
                                       textField.focus = true;
                                       suggestView.visible = !suggestView.visible;
                                   }
                               }
                           }
                       }
   
                       Rectangle {
                           Layout.margins: 5
                           width: height
                           color: "transparent"
                           height: textField.height
                           visible: textField.length !== 0
                           enabled: visible
   
   
                           Button {
                               anchors.fill: parent
                               text: "X"
                               font.pixelSize: 16
                               MouseArea {
                                   anchors.fill: parent
                                   onClicked: {
                                       textField.text = "";
                                       search.clearGraphics();
                                   }
                               }
                           }
                       }
                   }
               }
   
               //Tutorial add ListView to display suggested location results and bind it to the locator task list model.
   
               ListView {
                   id: suggestView
                   height: 20 * searchRect.cellHeight
                   width: textField.width
                   model: search.suggestions
                   visible: false
                   clip: true
                   delegate: Component {
                       Rectangle {
                           id: rect
                           width: textField.width
                           height: searchRect.cellHeight
                           color: "#f7f8fa"
   
                           Text {
                               anchors {
                                   verticalCenter: parent.verticalCenter
                                   leftMargin: 5
                                   rightMargin: 5
                               }
   
                               font {
                                   weight: Font.Black
                                   pixelSize: 16
                               }
   
                               width: textField.width
                               text: label
                               elide: Text.ElideRight
                               color: "black"
                           }
   
                           MouseArea {
                               anchors.fill: parent
                               onClicked: {
                                   textField.text = label;
                                   suggestView.visible = false;
                                   search.geocode(label);
                                   Qt.inputMethod.hide();
                               }
                           }
                       }
                   }
               }
           }
       }

Set developer credentials

For the final steps of this tutorial, click the tab below that corresponds to the authentication type (API key authentication or User authentication) that you chose when you completed the Display a map tutorial.

Be sure to also provide the same authentication (API key or user authentication Client ID/Redirect URL) that you used for the Display a map tutorial.

ARCGIS_RUNTIME_VERSION = 300.0.0
include($$PWD/arcgisruntime.pri)

# TODO: You need to replace the <path_to_toolkit_repo> with a valid location where the Qt Toolkit
# resides on your system, example: C:/arcgis-maps-sdk-toolkit-qt/uitools/toolkitcpp/toolkitcpp.pri
# This block determines whether you've cloned your toolkit
PATH_TO_TOOLKIT = "<path_to_toolkit_repo>/uitools/toolkitcpp/toolkitcpp.pri"

exists($${PATH_TO_TOOLKIT}) {
  message("Toolkit found")
  DEFINES += TOOLKIT_FOUND

  # include the toolkitcpp.pri, which contains all the toolkit resources
  include($${PATH_TO_TOOLKIT})

  qtHaveModule(webenginequick) {
    QT += webenginequick
  }
} else {
  message("Toolkit not found in provided path. Either set PATH_TO_TOOLKIT or use an API Key")
}

{

#ifdef TOOLKIT_FOUND

    // Define the Redirect URL string obtained when creating the OAuth credentials.
    // TODO: You need to replace the "REDIRECT_URL" with your own valid string,
    // ex: "urn:ietf:wg:oauth:2.0:oob"
    const auto qStringRedirectUrl = QString{"REDIRECT_URL"};

    // Define the URL of the portal to authenticate with.
    const QUrl qUrlPortal = QUrl{"https://www.arcgis.com/"};

    // Define a unique identifier associated with an application registered with the
    // portal that assists with client/server OAuth authentication.
    // TODO: You need to replace the "CLIENT_ID" with your own valid string.
    const QString qStringClientId = QString{"CLIENT_ID"};

    // Create a new OAuth user configuration using: the Url to mapping web service, the Client ID
    // string, and the Redirect Url string.
    auto* oAuthUserConfiguration = new OAuthUserConfiguration(qUrlPortal, qStringClientId,
                                                              qStringRedirectUrl, this);

    // Call the Toolkit's OAuthUserConfigurationManager static `addConfiguration`
    // method to use the OAuth dialog. This will tell the Authenticator to use OAuth for the provided configuration.
    Toolkit::OAuthUserConfigurationManager::addConfiguration(oAuthUserConfiguration);
#endif // TOOLKIT_FOUND

Press Ctrl + R to run the app.

You should see a map A map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more centered on the Santa Monica Mountains in California, with an address search bar at the top. Input an address in the search bar and the app will present a list of suggested addresses (not limited to the displayed map area). Click an address to zoom to that address location.

Option 2: Download the solution

1. Click the Download solution link under Solution and unzip the file to a location on your machine.

2. Open the .pro project file in Qt Creator.

Since the downloaded solution does not contain authentication credentials, you must add the developer credentials that you created in the Set up authentication section.

For the final steps of this tutorial, click the tab below that corresponds to the authentication type (API key authentication or User authentication) that you chose when you completed the Display a map tutorial.

Be sure to also provide the same authentication (API key or user authentication Client ID/Redirect URL) that you used for the Display a map tutorial.

Set developer credentials in the solution

ARCGIS_RUNTIME_VERSION = 300.0.0
include($$PWD/arcgisruntime.pri)

# TODO: You need to replace the <path_to_toolkit_repo> with a valid location where the Qt Toolkit
# resides on your system, example: C:/arcgis-maps-sdk-toolkit-qt/uitools/toolkitcpp/toolkitcpp.pri
# This block determines whether you've cloned your toolkit
PATH_TO_TOOLKIT = "<path_to_toolkit_repo>/uitools/toolkitcpp/toolkitcpp.pri"

exists($${PATH_TO_TOOLKIT}) {
  message("Toolkit found")
  DEFINES += TOOLKIT_FOUND

  # include the toolkitcpp.pri, which contains all the toolkit resources
  include($${PATH_TO_TOOLKIT})

  qtHaveModule(webenginequick) {
    QT += webenginequick
  }
} else {
  message("Toolkit not found in provided path. Either set PATH_TO_TOOLKIT or use an API Key")
}

{

#ifdef TOOLKIT_FOUND

    // Define the Redirect URL string obtained when creating the OAuth credentials.
    // TODO: You need to replace the "REDIRECT_URL" with your own valid string,
    // ex: "urn:ietf:wg:oauth:2.0:oob"
    const auto qStringRedirectUrl = QString{"REDIRECT_URL"};

    // Define the URL of the portal to authenticate with.
    const QUrl qUrlPortal = QUrl{"https://www.arcgis.com/"};

    // Define a unique identifier associated with an application registered with the
    // portal that assists with client/server OAuth authentication.
    // TODO: You need to replace the "CLIENT_ID" with your own valid string.
    const QString qStringClientId = QString{"CLIENT_ID"};

    // Create a new OAuth user configuration using: the Url to mapping web service, the Client ID
    // string, and the Redirect Url string.
    auto* oAuthUserConfiguration = new OAuthUserConfiguration(qUrlPortal, qStringClientId,
                                                              qStringRedirectUrl, this);

    // Call the Toolkit's OAuthUserConfigurationManager static `addConfiguration`
    // method to use the OAuth dialog. This will tell the Authenticator to use OAuth for the provided configuration.
    Toolkit::OAuthUserConfigurationManager::addConfiguration(oAuthUserConfiguration);
#endif // TOOLKIT_FOUND

Run the app

Press Ctrl + R to run the app.

You should see a map A map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more centered on the Santa Monica Mountains in California, with an address search bar at the top. Input an address in the search bar and the app will present a list of suggested addresses (not limited to the displayed map area). Click an address to zoom to that address location.