Offline: Open a preplanned map area

OfflineMapAreasExample/OfflineMapAreasExample/OfflineMapAreasExampleView.swift

@@ -19,13 +19,16 @@ import SwiftUI
 @MainActor
 struct OfflineMapAreasExampleView: View {
     /// The map of the Naperville water network.
-    @State private var map = Map(item: PortalItem.naperville())
+    @State private var onlineMap = Map(item: PortalItem.naperville())
+
+    /// The selected map.
+    @State private var selectedMap: Map?
 
     /// A Boolean value indicating whether the offline map ares view should be presented.
     @State private var isShowingOfflineMapAreasView = false
 
     var body: some View {
-        MapView(map: map)
+        MapView(map: selectedMap ?? onlineMap)
             .toolbar {
                 ToolbarItem(placement: .bottomBar) {
                     Button("Offline Maps") {
@@ -34,7 +37,10 @@ struct OfflineMapAreasExampleView: View {
                 }
             }
             .sheet(isPresented: $isShowingOfflineMapAreasView) {
-                OfflineMapAreasView(map: map)
+                OfflineMapAreasView(
+                    onlineMap: onlineMap,
+                    selectedMap: $selectedMap
+                )
             }
     }
 }

Sources/ArcGISToolkit/Components/Offline/OfflineMapAreasView.swift

@@ -28,10 +28,19 @@ public struct OfflineMapAreasView: View {
     /// A Boolean value indicating whether the preplanned map areas are being reloaded.
     @State private var isReloadingPreplannedMapAreas = false
 
+    /// The currently selected map.
+    private var selectedMap: Binding<Map?>
+
     /// Creates an `OfflineMapAreasView` with a given web map.
-    /// - Parameter map: The web map.
-    public init(map: Map) {
-        _mapViewModel = StateObject(wrappedValue: MapViewModel(map: map))
+    /// - Parameters:
+    ///   - onlineMap: The web map.
+    ///   - selectedMap: A binding to the currently selected map.
+    public init(
+        onlineMap: Map,
+        selectedMap: Binding<Map?>
+    ) {
+        _mapViewModel = StateObject(wrappedValue: MapViewModel(map: onlineMap))
+        self.selectedMap = selectedMap
     }
 
     public var body: some View {
@@ -83,6 +92,10 @@ public struct OfflineMapAreasView: View {
                     PreplannedListItemView(
                         model: preplannedMapModel
                     )
+                    .onMapSelectionChanged { newMap in
+                        selectedMap.wrappedValue = newMap
+                        dismiss()
+                    }
                 }
             } else {
                 emptyPreplannedMapAreasView
@@ -114,12 +127,21 @@ public struct OfflineMapAreasView: View {
 }
 
 #Preview {
-    OfflineMapAreasView(
-        map: Map(
-            item: PortalItem(
-                portal: .arcGISOnline(connection: .anonymous),
-                id: PortalItem.ID("acc027394bc84c2fb04d1ed317aac674")!
+    @MainActor
+    struct OfflineMapAreasViewPreview: View {
+        @State private var map: Map?
+
+        var body: some View {
+            OfflineMapAreasView(
+                onlineMap: Map(
+                    item: PortalItem(
+                        portal: .arcGISOnline(connection: .anonymous),
+                        id: PortalItem.ID("acc027394bc84c2fb04d1ed317aac674")!
+                    )
+                ),
+                selectedMap: $map
             )
-        )
-    )
+        }
+    }
+    return OfflineMapAreasViewPreview()
 }

Sources/ArcGISToolkit/Components/Offline/PreplannedListItemView.swift

@@ -17,10 +17,13 @@ import ArcGIS
 
 @MainActor
 @preconcurrency
-public struct PreplannedListItemView: View {
+struct PreplannedListItemView: View {
     /// The view model for the preplanned map.
     @ObservedObject var model: PreplannedMapModel
 
+    /// The closure to perform when the map selection changes.
+    var onMapSelectionChanged: ((Map) -> Void)?
+
     public var body: some View {
         HStack(alignment: .center, spacing: 10) {
             thumbnailView
@@ -55,8 +58,21 @@ public struct PreplannedListItemView: View {
     @ViewBuilder private var downloadButton: some View {
         switch model.status {
         case .downloaded:
-            Image(systemName: "checkmark.circle")
-                .foregroundStyle(.secondary)
+            Button {
+                Task {
+                    if let map = await model.loadMobileMapPackage() {
+                        onMapSelectionChanged?(map)
+                    }
+                }
+            } label: {
+                Text("Open")
+                    .font(.system(.headline, weight: .bold))
+                    .foregroundStyle(Color.accentColor)
+                    .frame(width: 76, height: 32)
+                    .background(Color(.tertiarySystemFill))
+                    .clipShape(.rect(cornerRadius: 16))
+            }
+            .buttonStyle(.plain)
         case .downloading:
             if let job = model.job {
                 ProgressView(job.progress)
@@ -73,7 +89,7 @@ public struct PreplannedListItemView: View {
             }
             .buttonStyle(.plain)
             .disabled(!model.status.allowsDownload)
-            .foregroundColor(.accentColor)
+            .foregroundStyle(Color.accentColor)
         }
     }
 
@@ -95,7 +111,7 @@ public struct PreplannedListItemView: View {
             switch model.status {
             case .notLoaded, .loading:
                 Text("Loading")
-            case .loadFailure:
+            case .loadFailure, .mmpkLoadFailure:
                 Image(systemName: "exclamationmark.circle")
                 Text("Loading failed")
             case .packaging:
@@ -118,6 +134,15 @@ public struct PreplannedListItemView: View {
         .font(.caption2)
         .foregroundStyle(.tertiary)
     }
+
+    /// Sets the closure to call when the map selection changes.
+    public func onMapSelectionChanged(
+        perform action: @escaping (_ newMap: Map) -> Void
+    ) -> Self {
+        var copy = self
+        copy.onMapSelectionChanged = action
+        return copy
+    }
 }
 
 #Preview {

Sources/ArcGISToolkit/Components/Offline/PreplannedMapModel.swift

@@ -122,6 +122,19 @@ class PreplannedMapModel: ObservableObject, Identifiable {
         return MobileMapPackage.init(fileURL: fileURL)
     }
 
+    /// Loads the mobile map package and updates the status.
+    /// - Returns: The mobile map package map.
+    func loadMobileMapPackage() async -> Map? {
+        guard let mobileMapPackage else { return nil }
+
+        do {
+            try await mobileMapPackage.load()
+        } catch {
+            status = .mmpkLoadFailure(error)
+        }
+        return mobileMapPackage.maps.first
+    }
+
     /// Downloads the preplanned map area.
     /// - Precondition: `canDownload`
     func downloadPreplannedMapArea() async {
@@ -186,12 +199,14 @@ extension PreplannedMapModel {
         case downloaded
         /// Preplanned map area failed to download.
         case downloadFailure(Error)
+        /// Downloaded mobile map package failed to load.
+        case mmpkLoadFailure(Error)
 
         /// A Boolean value indicating whether the model is in a state
         /// where it needs to be loaded or reloaded.
         var needsToBeLoaded: Bool {
             switch self {
-            case .loading, .packaging, .packaged, .downloading, .downloaded:
+            case .loading, .packaging, .packaged, .downloading, .downloaded, .mmpkLoadFailure:
                 false
             default:
                 true
@@ -202,7 +217,7 @@ extension PreplannedMapModel {
         var allowsDownload: Bool {
             switch self {
             case .notLoaded, .loading, .loadFailure, .packaging, .packageFailure,
-                    .downloading, .downloaded:
+                    .downloading, .downloaded, .mmpkLoadFailure:
                 false
             case .packaged, .downloadFailure:
                 true
@@ -211,6 +226,26 @@ extension PreplannedMapModel {
     }
 }
 
+extension PreplannedMapModel.Status: Equatable {
+    static func == (lhs: PreplannedMapModel.Status, rhs: PreplannedMapModel.Status) -> Bool {
+        return switch (lhs, rhs) {
+        case (.notLoaded, .notLoaded),
+            (.loading, .loading),
+            (.loadFailure, .loadFailure),
+            (.packaged, .packaged),
+            (.packaging, .packaging),
+            (.packageFailure, .packageFailure),
+            (.downloading, .downloading),
+            (.downloaded, .downloaded),
+            (.downloadFailure, .downloadFailure),
+            (.mmpkLoadFailure, .mmpkLoadFailure):
+            true
+        default:
+            false
+        }
+    }
+}
+
 private extension PreplannedMapModel.Status {
     init(packagingStatus: PreplannedMapArea.PackagingStatus) {
         self = switch packagingStatus {

Tests/ArcGISToolkitTests/PreplannedMapModelStatusTests.swift

@@ -17,27 +17,31 @@ import ArcGIS
 @testable import ArcGISToolkit
 
 class PreplannedMapModelStatusTests: XCTestCase {
+    private typealias Status = PreplannedMapModel.Status
+
     func testNeedsToBeLoaded() {
-        XCTAssertFalse(PreplannedMapModel.Status.loading.needsToBeLoaded)
-        XCTAssertFalse(PreplannedMapModel.Status.packaging.needsToBeLoaded)
-        XCTAssertFalse(PreplannedMapModel.Status.packaged.needsToBeLoaded)
-        XCTAssertFalse(PreplannedMapModel.Status.downloading.needsToBeLoaded)
-        XCTAssertFalse(PreplannedMapModel.Status.downloaded.needsToBeLoaded)
-        XCTAssertTrue(PreplannedMapModel.Status.notLoaded.needsToBeLoaded)
-        XCTAssertTrue(PreplannedMapModel.Status.downloadFailure(NSError()).needsToBeLoaded)
-        XCTAssertTrue(PreplannedMapModel.Status.loadFailure(NSError()).needsToBeLoaded)
-        XCTAssertTrue(PreplannedMapModel.Status.packageFailure.needsToBeLoaded)
+        XCTAssertFalse(Status.loading.needsToBeLoaded)
+        XCTAssertFalse(Status.packaging.needsToBeLoaded)
+        XCTAssertFalse(Status.packaged.needsToBeLoaded)
+        XCTAssertFalse(Status.downloading.needsToBeLoaded)
+        XCTAssertFalse(Status.downloaded.needsToBeLoaded)
+        XCTAssertFalse(Status.mmpkLoadFailure(CancellationError()).needsToBeLoaded)
+        XCTAssertTrue(Status.notLoaded.needsToBeLoaded)
+        XCTAssertTrue(Status.downloadFailure(CancellationError()).needsToBeLoaded)
+        XCTAssertTrue(Status.loadFailure(CancellationError()).needsToBeLoaded)
+        XCTAssertTrue(Status.packageFailure.needsToBeLoaded)
     }
 
     func testAllowsDownload() {
-        XCTAssertFalse(PreplannedMapModel.Status.notLoaded.allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.loading.allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.loadFailure(NSError()).allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.packaging.allowsDownload)
-        XCTAssertTrue(PreplannedMapModel.Status.packaged.allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.packageFailure.allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.downloading.allowsDownload)
-        XCTAssertFalse(PreplannedMapModel.Status.downloaded.allowsDownload)
-        XCTAssertTrue(PreplannedMapModel.Status.downloadFailure(NSError()).allowsDownload)
+        XCTAssertFalse(Status.notLoaded.allowsDownload)
+        XCTAssertFalse(Status.loading.allowsDownload)
+        XCTAssertFalse(Status.loadFailure(CancellationError()).allowsDownload)
+        XCTAssertFalse(Status.packaging.allowsDownload)
+        XCTAssertTrue(Status.packaged.allowsDownload)
+        XCTAssertFalse(Status.packageFailure.allowsDownload)
+        XCTAssertFalse(Status.downloading.allowsDownload)
+        XCTAssertFalse(Status.downloaded.allowsDownload)
+        XCTAssertTrue(Status.downloadFailure(CancellationError()).allowsDownload)
+        XCTAssertFalse(Status.mmpkLoadFailure(CancellationError()).allowsDownload)
     }
 }