Offline: Remove downloaded area and view details

OfflineMapAreasExample/OfflineMapAreasExample/OfflineMapAreasExampleView.swift

@@ -27,8 +27,25 @@ struct OfflineMapAreasExampleView: View {
     /// A Boolean value indicating whether the offline map ares view should be presented.
     @State private var isShowingOfflineMapAreasView = false
 
+    /// The height of the map view's attribution bar.
+    @State private var attributionBarHeight = 0.0
+
     var body: some View {
         MapView(map: selectedMap ?? onlineMap)
+            .onAttributionBarHeightChanged { newHeight in
+                withAnimation { attributionBarHeight = newHeight }
+            }
+            .overlay(alignment: .bottom) {
+                if selectedMap != nil {
+                    Button("Go Online") {
+                        selectedMap = nil
+                    }
+                    .padding()
+                    .background(.regularMaterial)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                    .padding(.vertical, 10 + attributionBarHeight)
+                }
+            }
             .toolbar {
                 ToolbarItem(placement: .bottomBar) {
                     Button("Offline Maps") {

Sources/ArcGISToolkit/Components/Offline/OfflineMapAreasView.swift

@@ -86,10 +86,10 @@ public struct OfflineMapAreasView: View {
         case .success(let models):
             if !models.isEmpty {
                 List(models) { preplannedMapModel in
-                    PreplannedListItemView(model: preplannedMapModel) { newMap in
-                        selectedMap = newMap
-                        dismiss()
-                    }
+                    PreplannedListItemView(model: preplannedMapModel, selectedMap: $selectedMap)
+                        .onChange(of: selectedMap) { _ in
+                            dismiss()
+                        }
                 }
             } else {
                 emptyPreplannedMapAreasView

Sources/ArcGISToolkit/Components/Offline/PreplannedListItemView.swift

@@ -21,8 +21,19 @@ struct PreplannedListItemView: View {
     /// The view model for the preplanned map.
     @ObservedObject var model: PreplannedMapModel
 
-    /// The closure to perform when the map selection changes.
-    let onMapSelectionChanged: (Map) -> Void
+    /// The currently selected map.
+    @Binding var selectedMap: Map?
+
+    /// A Boolean value indicating whether the metadata view is presented.
+    @State private var metadataViewIsPresented = false
+
+    /// A Boolean value indicating whether the selected map area is the same
+    /// as the map area from this model.
+    /// The title of a preplanned map area is guaranteed to be unique when it
+    /// is created.
+    var isSelected: Bool {
+        selectedMap?.item?.title == model.preplannedMapArea.title
+    }
 
     var body: some View {
         HStack(alignment: .center, spacing: 10) {
@@ -37,6 +48,20 @@ struct PreplannedListItemView: View {
                 statusView
             }
         }
+        .contentShape(.rect)
+        .swipeActions {
+            deleteButton
+        }
+        .onTapGesture {
+            if model.status.isDownloaded {
+                metadataViewIsPresented = true
+            }
+        }
+        .sheet(isPresented: $metadataViewIsPresented) {
+            NavigationStack {
+                PreplannedMetadataView(model: model)
+            }
+        }
         .task {
             await model.load()
         }
@@ -55,13 +80,23 @@ struct PreplannedListItemView: View {
             .font(.body)
     }
 
+    @ViewBuilder private var deleteButton: some View {
+        if model.status.allowsRemoval,
+           !isSelected {
+            Button("Delete") {
+                model.removeDownloadedPreplannedMapArea()
+            }
+            .tint(.red)
+        }
+    }
+
     @ViewBuilder private var downloadButton: some View {
         switch model.status {
         case .downloaded:
             Button {
                 Task {
-                    if let map = await model.loadMobileMapPackage() {
-                        onMapSelectionChanged(map)
+                    if let map = await model.map {
+                        selectedMap = map
                     }
                 }
             } label: {
@@ -71,6 +106,7 @@ struct PreplannedListItemView: View {
             }
             .buttonStyle(.bordered)
             .buttonBorderShape(.capsule)
+            .disabled(isSelected)
         case .downloading:
             if let job = model.job {
                 ProgressView(job.progress)
@@ -136,10 +172,10 @@ struct PreplannedListItemView: View {
 
 #Preview {
     struct MockPreplannedMapArea: PreplannedMapAreaProtocol {
-        var packagingStatus: PreplannedMapArea.PackagingStatus? = .complete
-        var title: String = "Mock Preplanned Map Area"
-        var description: String = "This is the description text"
-        var thumbnail: LoadableImage? = nil
+        var packagingStatus: PreplannedMapArea.PackagingStatus? { .complete }
+        var title: String { "Mock Preplanned Map Area" }
+        var description: String { "This is the description text" }
+        var thumbnail: LoadableImage? { nil }
 
         func retryLoad() async throws { }
         func makeParameters(using offlineMapTask: OfflineMapTask) async throws -> DownloadPreplannedOfflineMapParameters {
@@ -153,7 +189,8 @@ struct PreplannedListItemView: View {
             mapArea: MockPreplannedMapArea(),
             portalItemID: .init("preview")!,
             preplannedMapAreaID: .init("preview")!
-        )
-    ) { _ in }
+        ),
+        selectedMap: .constant(nil)
+    )
     .padding()
 }

Sources/ArcGISToolkit/Components/Offline/PreplannedMapModel.swift

@@ -22,17 +22,23 @@ class PreplannedMapModel: ObservableObject, Identifiable {
     /// The preplanned map area.
     let preplannedMapArea: any PreplannedMapAreaProtocol
 
+    /// The ID of the preplanned map area.
+    let preplannedMapAreaID: PortalItem.ID
+
+    /// The mobile map package directory URL.
+    private let mmpkDirectoryURL: URL
+
     /// The task to use to take the area offline.
     private let offlineMapTask: OfflineMapTask
 
     /// The ID of the web map.
     private let portalItemID: PortalItem.ID
 
-    /// The ID of the preplanned map area.
-    private let preplannedMapAreaID: PortalItem.ID
-
     /// The mobile map package for the preplanned map area.
-    private(set) var mobileMapPackage: MobileMapPackage?
+    private var mobileMapPackage: MobileMapPackage?
+
+    /// The file size of the preplanned map area.
+    private(set) var directorySize = 0
 
     /// The currently running download job.
     @Published private(set) var job: DownloadPreplannedOfflineMapJob?
@@ -43,6 +49,24 @@ class PreplannedMapModel: ObservableObject, Identifiable {
     /// A Boolean value indicating if a user notification should be shown when a job completes.
     let showsUserNotificationOnCompletion: Bool
 
+    /// The first map from the mobile map package.
+    var map: Map? { 
+        get async {
+            if let mobileMapPackage {
+                if mobileMapPackage.loadStatus != .loaded {
+                    do {
+                        try await mobileMapPackage.load()
+                    } catch {
+                        status = .mmpkLoadFailure(error)
+                    }
+                }
+                return mobileMapPackage.maps.first
+            } else {
+                return nil
+            }
+        }
+    }
+
     init(
         offlineMapTask: OfflineMapTask,
         mapArea: PreplannedMapAreaProtocol,
@@ -54,15 +78,20 @@ class PreplannedMapModel: ObservableObject, Identifiable {
         preplannedMapArea = mapArea
         self.portalItemID = portalItemID
         self.preplannedMapAreaID = preplannedMapAreaID
+        mmpkDirectoryURL = FileManager.default.preplannedDirectory(
+            forPortalItemID: portalItemID,
+            preplannedMapAreaID: preplannedMapAreaID
+        )
         self.showsUserNotificationOnCompletion = showsUserNotificationOnCompletion
 
         if let foundJob = lookupDownloadJob() {
             Logger.offlineManager.debug("Found executing job for area \(preplannedMapAreaID.rawValue, privacy: .public)")
             observeJob(foundJob)
         } else if let mmpk = lookupMobileMapPackage() {
             Logger.offlineManager.debug("Found MMPK for area \(preplannedMapAreaID.rawValue, privacy: .public)")
-            self.mobileMapPackage = mmpk
-            self.status = .downloaded
+            mobileMapPackage = mmpk
+            directorySize = FileManager.default.sizeOfDirectory(at: mmpkDirectoryURL)
+            status = .downloaded
         }
     }
 
@@ -98,14 +127,12 @@ class PreplannedMapModel: ObservableObject, Identifiable {
     }
 
     /// Updates the status based on the download result of the mobile map package.
-    func updateDownloadStatus(for downloadResult: Result<DownloadPreplannedOfflineMapResult, any Error>?) {
+    func updateDownloadStatus(for downloadResult: Result<DownloadPreplannedOfflineMapResult, any Error>) {
         switch downloadResult {
         case .success:
             status = .downloaded
         case .failure(let error):
             status = .downloadFailure(error)
-        case .none:
-            return
         }
     }
 
@@ -122,19 +149,6 @@ 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 {
@@ -143,16 +157,12 @@ class PreplannedMapModel: ObservableObject, Identifiable {
 
         do {
             let parameters = try await preplannedMapArea.makeParameters(using: offlineMapTask)
-            let mmpkDirectory = FileManager.default.preplannedDirectory(
-                forPortalItemID: portalItemID,
-                preplannedMapAreaID: preplannedMapAreaID
-            )
-            try FileManager.default.createDirectory(at: mmpkDirectory, withIntermediateDirectories: true)
+            try FileManager.default.createDirectory(at: mmpkDirectoryURL, withIntermediateDirectories: true)
 
             // Create the download preplanned offline map job.
             let job = offlineMapTask.makeDownloadPreplannedOfflineMapJob(
                 parameters: parameters,
-                downloadDirectory: mmpkDirectory
+                downloadDirectory: mmpkDirectoryURL
             )
 
             OfflineManager.shared.start(job: job)
@@ -162,6 +172,14 @@ class PreplannedMapModel: ObservableObject, Identifiable {
         }
     }
 
+    /// Removes the downloaded preplanned map area from disk and resets the status.
+    func removeDownloadedPreplannedMapArea() {
+        try? FileManager.default.removeItem(at: mmpkDirectoryURL)
+        // Reload the model after local files removal.
+        status = .notLoaded
+        Task { await load() }
+    }
+
     /// Sets the job property of this instance, starts the job, observes it, and
     /// when it's done, updates the status, removes the job from the job manager,
     /// and fires a user notification.
@@ -172,7 +190,10 @@ class PreplannedMapModel: ObservableObject, Identifiable {
             let result = await job.result
             guard let self else { return }
             self.updateDownloadStatus(for: result)
-            self.mobileMapPackage = try? result.map { $0.mobileMapPackage }.get()
+            if status.isDownloaded {
+                self.mobileMapPackage = try? result.get().mobileMapPackage
+                self.directorySize = FileManager.default.sizeOfDirectory(at: mmpkDirectoryURL)
+            }
             self.job = nil
         }
     }
@@ -223,6 +244,21 @@ extension PreplannedMapModel {
                 true
             }
         }
+
+        /// A Boolean value indicating whether the local files can be removed.
+        var allowsRemoval: Bool {
+            switch self {
+            case .downloaded, .mmpkLoadFailure, .downloadFailure, .loadFailure, .packageFailure:
+                true
+            default:
+                false
+            }
+        }
+
+        /// A Boolean value indicating whether the preplanned map area is downloaded.
+        var isDownloaded: Bool {
+            if case .downloaded = self { true } else { false }
+        }
     }
 }
 
@@ -286,24 +322,16 @@ extension PreplannedMapArea: PreplannedMapAreaProtocol {
     }
 }
 
-extension FileManager {
-    private static let mmpkPathExtension: String = "mmpk"
-    private static let offlineMapAreasPath: String = "OfflineMapAreas"
-    private static let packageDirectoryPath: String = "Package"
-    private static let preplannedDirectoryPath: String = "Preplanned"
-
+private extension FileManager {
     /// The path to the documents folder.
     private var documentsDirectory: URL {
         URL.documentsDirectory
     }
 
     /// The path to the offline map areas directory within the documents directory.
-    /// `Documents/OfflineMapAreas`
+    /// `Documents/OfflineMapAreas/`
     private var offlineMapAreasDirectory: URL {
-        documentsDirectory.appending(
-            path: Self.offlineMapAreasPath,
-            directoryHint: .isDirectory
-        )
+        documentsDirectory.appending(component: "OfflineMapAreas/")
     }
 
     /// The path to the web map directory for a specific portal item.
@@ -313,22 +341,33 @@ extension FileManager {
         offlineMapAreasDirectory.appending(path: portalItemID.rawValue, directoryHint: .isDirectory)
     }
 
+    /// Calculates the size of a directory and all its contents.
+    /// - Parameter url: The directory's URL.
+    /// - Returns: The total size in bytes.
+    func sizeOfDirectory(at url: URL) -> Int {
+        guard let enumerator = enumerator(at: url, includingPropertiesForKeys: [.fileSizeKey]) else { return 0 }
+        var accumulatedSize = 0
+        for case let fileURL as URL in enumerator {
+            guard let size = try? fileURL.resourceValues(forKeys: [.fileSizeKey]).fileSize else {
+                continue
+            }
+            accumulatedSize += size
+        }
+        return accumulatedSize
+    }
+
     /// The path to the preplanned map areas directory for a specific portal item.
-    /// `Documents/OfflineMapAreas/<Portal Item ID>/Preplanned/<Preplanned Area ID>`
-    /// - Parameter portalItemID: The ID of the web map portal item.
+    /// `Documents/OfflineMapAreas/<Portal Item ID>/Preplanned/<Preplanned Area ID>/`
+    /// - Parameters:
+    ///   - portalItemID: The ID of the web map portal item.
+    ///   - preplannedMapAreaID: The ID of the preplanned map area portal item.
+    /// - Returns: A URL to the preplanned map area directory.
     func preplannedDirectory(
         forPortalItemID portalItemID: PortalItem.ID,
         preplannedMapAreaID: PortalItem.ID
     ) -> URL {
         portalItemDirectory(forPortalItemID: portalItemID)
-            .appending(
-                path: Self.preplannedDirectoryPath,
-                directoryHint: .isDirectory
-            )
-            .appending(
-                path: preplannedMapAreaID.rawValue,
-                directoryHint: .isDirectory
-            )
+            .appending(components: "Preplanned", "\(preplannedMapAreaID)/")
     }
 
     /// Returns a Boolean value indicating if the specified directory is empty.