Take a utility network offline

    // Create a new offline map task.
    m_offlineMapTask = new OfflineMapTask(map, this);

    // Get the generate offline map parameters from the offline map task via the
    // create default generate offline map parameters async method (QFuture).
    m_offlineMapTask->createDefaultGenerateOfflineMapParametersAsync(envelope).then(this, [this]
        (const GenerateOfflineMapParameters& defaultParams)
    {
        // Create a modifiable version of the generate offline map parameters.

        GenerateOfflineMapParameters params = defaultParams;

        // Set the include basemap as false for the modifiable version of the generate offline map parameters.
        params.setIncludeBasemap(false);

        // Define the path to download the geodatabase to.
        const QString gdbPath = m_tempPath.path() + "/OfflineMapWithUtilityNetwork";

        // Get the generate offline map job from the offline map task.
        GenerateOfflineMapJob* m_generateOfflineMapJob = m_offlineMapTask->
            generateOfflineMap(params, gdbPath);

        // Test if we have a valid (non null) generate offline map job.
        if (m_generateOfflineMapJob)
        {
            // When the generate offline map job's status has changed, continue processing.
            connect(m_generateOfflineMapJob, &Job::statusChanged, this,
                &UtilityNetworks::generateOfflineMapJobStatusChanged);

            // Start the enerate offline map job.
            m_generateGdbJob->start();
        }
    });
}

// Function to execute when the generate offline map job status has changed.
void UtilityNetworks::generateOfflineMapJobStatusChanged()
{
    // Get the job status.
    switch (m_generateOfflineMapJob->jobStatus())
    {
    case JobStatus::Succeeded: // Job status succeeded.
    {
        // Get the resulting geodatabase from the generate offline map job.
        GenerateOfflineMapResult* offlineMapResult = m_generateOfflineMapJob->result();

        // Get the offline map from the offline map result.
        Map* mapOffline = offlineMapResult->offlineMap();

        // Get the utility network list model from the offline map.
        UtilityNetworkListModel* utilityNetworkListModel = mapOffline->utilityNetworks();

        // Only continue if we have a valid offline map result or the utility network is empty.
        if (!offlineMapResult || utilityNetworkListModel->isEmpty())
            return;

        // Get and load the utility network.
        m_utilityNetwork = utilityNetworkListModel->first();

        // Load the utility network.
        m_utilityNetwork->load();
        break;
    }

    // Create a new GeodatabaseSyncTask to download the mobile geodatabase.
    m_geodatabaseSyncTask = new GeodatabaseSyncTask(featureServerUrl, this);

    // Get the generate geodatabase parameters from the geodatabase sync task via the
    // create default generate geodatabase parameters async method (QFuture).
    m_geodatabaseSyncTask->createDefaultGenerateGeodatabaseParametersAsync(envelope).then(this,
        [this](const GenerateGeodatabaseParameters& defaultParams)
    {
        // Create an modifiable version of the generate geodatabase parameters.
        GenerateGeodatabaseParameters params = defaultParams;

        // Set utility network system tables to be synchronized.
        params.setUtilityNetworkSyncMode(UtilityNetworkSyncMode::SyncSystemTables);

        // Define the path to download the geodatabase to.
        const QString gdbPath = m_tempPath.path() + "/offline_utility_network.geodatabase";

        // Create a generate geodatabase job to generate a geodatabase.
        m_generateGdbJob = m_geodatabaseSyncTask->generateGeodatabase(params, gdbPath);

        // Test of the generate geodatabase job is not null.
        if (m_generateGdbJob)
        {
            // When the generate geodatabase job's status has changed, continue processing.
            connect(m_generateGdbJob, &Job::statusChanged, this,
                &UtilityNetworks::generateGeodatabaseJobStatusChanged);

            // Start the generate geodatabase job.
            m_generateGdbJob->start();
        }
    });
}

// Function to execute when the generate geodatabase job status has changed.
void UtilityNetworks::generateGeodatabaseJobStatusChanged()
{
    // Get the job status.
    switch (m_generateGdbJob->jobStatus())
    {
    case JobStatus::Succeeded: // Job status succeeded.
    {
        // Get the resulting geodatabase from this job.
        Geodatabase* gdb = m_generateGdbJob->result();

        // Test if the geodatabase is not null or the utility network is empty.
        if (!gdb || gdb->utilityNetworks().isEmpty())
            return;

        // Get the QList of utility networks from the geodatabase.
        const QList<UtilityNetwork*> utilityNetworks = gdb->utilityNetworks();

        // Get the first utility network from the QList of utility networks.
        m_utilityNetwork = utilityNetworks.first();

        // Load the utility network.
        m_utilityNetwork->load();
        break;
    }