Using Data Actions With Runtime Data Sources In ArcGIS

Hey guys! Ever wondered how to make your ArcGIS Experience Builder apps even more dynamic and interactive? One cool way to do this is by leveraging data actions with runtime data sources. If you're scratching your head wondering what that even means, don't worry! We're going to break it down in a way that's super easy to understand, even if you're not a coding whiz.

Understanding Runtime Data Sources and Data Actions

So, first things first, let's define our terms. A runtime data source is essentially a data source that's generated on-the-fly, usually from a URL or some other external source. Think of it as data that's not pre-defined within your app but rather fetched dynamically as the app is running. This is super useful when you need to display data that's constantly being updated, like real-time sensor readings or live traffic information.

Now, what about data actions? These are the things you can do with your data. Imagine clicking on a feature on a map and having its attributes pop up in a table, or adding new data points directly from your app. That's the power of data actions! They allow you to interact with your data in meaningful ways, making your app more engaging and functional.

The big question, then, is how do we hook these two things up? How do we make our widgets respond to the data coming from these runtime sources? That's what we're diving into today.

The Challenge: Connecting Runtime Data to Widgets

One of the tricky parts about runtime data sources is that they don't behave exactly like your standard, pre-defined data sources. In ArcGIS Experience Builder, you can easily select a pre-defined data source for widgets like lists and tables. This allows these widgets to automatically display and interact with the data. However, runtime data sources don't have this direct connection. They exist in the app's memory, but they aren't automatically available for other widgets to use. That's where data actions come to the rescue!

The key difference lies in how the data source schema is handled. For a predefined data source, you define the schema in the settings and save it to the app configuration. This allows the Builder to understand the structure of the data and make it available to other widgets. Runtime data sources, on the other hand, don't require a predefined schema. This makes them flexible but also means we need a way to explicitly connect them to our widgets.

The Solution: <DataActionList /> to the Rescue!

The secret sauce to using runtime data sources with data actions is the <DataActionList /> component. This is a special component in the ArcGIS Experience Builder SDK that acts as a bridge between your runtime data source and other widgets. It essentially tells the Builder, "Hey, this data source has these actions available, and other widgets can use them!".

Think of <DataActionList /> as a data action hub. It lets you define which data actions are available for a given data source and makes them accessible to other widgets in your application. This is how you can push data from your runtime data source into a table, a list, or any other widget that can display data.

Here's a basic example of how you might use it:

<DataActionList widgetId={widgetId} dataSets={[{
 dataSource: ds,
 records: [],
 name: ds.getLabel()
 }]} />

Let's break down what's happening here:

• widgetId: This is the ID of the widget that's generating the runtime data source. This tells the <DataActionList /> which widget's data source we're working with.
• dataSets: This is an array of objects, each representing a data source and its associated actions.
  • dataSource: This is the actual runtime data source object.
  • records: This is an array of records. In this case, it's initialized as an empty array ([]), but you might populate it with initial data if needed.
  • name: This is a human-readable name for the data source, often taken from the data source's label (ds.getLabel()).

By including this <DataActionList /> component in your widget, you're essentially advertising the availability of your runtime data source to the rest of the application. Other widgets can then subscribe to data actions from this data source and react accordingly.

Key Benefits of Using <DataActionList />

• Flexibility: It allows you to use runtime data sources with widgets that traditionally only work with pre-defined data sources.
• Interactivity: It enables you to create dynamic interactions between widgets, such as updating a table when a feature is selected on a map.
• Reusability: You can reuse the same runtime data source across multiple widgets, making your app more efficient.

A Practical Example: Displaying Data in a Table

Let's walk through a common scenario: displaying data from a runtime data source in a table widget. Imagine you have a widget that fetches data from an external API and creates a runtime data source. You want to display this data in a table so users can easily view and sort it.

Here's how you might approach this:

1. Create a widget that generates the runtime data source: This widget would handle fetching the data from the API and creating the data source object. Make sure this widget implemented <DataActionList /> as described above.
2. Add a Table widget to your experience: This is where your data will be displayed.
3. Configure the Table widget to use the data actions from the runtime data source: The exact steps for this will depend on the specific implementation of the Table widget and the data actions you've defined. But, the general idea is that you'll tell the Table widget to listen for data action events from the widget generating the runtime data source.
4. Define data actions (if needed): You might need to define specific data actions, such as "Select Record" or "Add Record," depending on the level of interactivity you want to achieve. These data actions would be triggered by user interactions within the Table widget or other widgets in the experience.

By following these steps, you can create a seamless flow of data from your runtime data source to your Table widget, allowing users to interact with the data in a meaningful way.

Runtime Data Source vs. Predefined Output Data Source: Key Differences

It's worth taking a moment to highlight the key differences between runtime data sources and predefined output data sources. Understanding these differences will help you choose the right approach for your specific needs.

In essence, runtime data sources are great for situations where you need to work with data that's generated on the fly or doesn't have a fixed schema. Predefined output data sources are more suitable when you have a clear data structure and want to easily connect it to multiple widgets in your experience.

Wrapping Up: Unleashing the Power of Dynamic Data

So, there you have it! Using data actions with runtime data sources might seem a bit complex at first, but with the <DataActionList /> component, it becomes a powerful way to create dynamic and interactive ArcGIS Experience Builder apps. By understanding the differences between runtime and predefined data sources and leveraging the power of data actions, you can unlock a whole new level of flexibility in your app development.

Remember, the key is to think about the flow of data in your application and how you want users to interact with it. With a little experimentation and practice, you'll be building amazing, data-driven experiences in no time! Happy coding, guys!