Offline: Remove downloaded area and view details

Sources/ArcGISToolkit/Components/Offline/OfflineMapAreasView.swift

@@ -89,6 +89,8 @@ public struct OfflineMapAreasView: View {
                     PreplannedListItemView(model: preplannedMapModel) { newMap in
                         selectedMap = newMap
                         dismiss()
+                    } onDeletion: {
+                        selectedMap = nil
                     }
                 }
             } else {

Sources/ArcGISToolkit/Components/Offline/PreplannedListItemView.swift

@@ -21,8 +21,13 @@ struct PreplannedListItemView: View {
     /// The view model for the preplanned map.
     @ObservedObject var model: PreplannedMapModel
 
+    /// A Boolean value indicating whether the metadata view is presented.
+    @State private var metadataViewIsPresented = false
+
     /// The closure to perform when the map selection changes.
     let onMapSelectionChanged: (Map) -> Void
+    /// The closure to perform when the map is removed from local disk.
+    let onDeletion: () -> Void
 
     var body: some View {
         HStack(alignment: .center, spacing: 10) {
@@ -37,6 +42,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,6 +74,16 @@ struct PreplannedListItemView: View {
             .font(.body)
     }
 
+    @ViewBuilder private var deleteButton: some View {
+        if model.status.allowsRemoval {
+            Button("Delete") {
+                model.removeDownloadedPreplannedMapArea()
+                onDeletion()
+            }
+            .tint(.red)
+        }
+    }
+
     @ViewBuilder private var downloadButton: some View {
         switch model.status {
         case .downloaded:
@@ -136,10 +165,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 {
@@ -154,6 +183,6 @@ struct PreplannedListItemView: View {
             portalItemID: .init("preview")!,
             preplannedMapAreaID: .init("preview")!
         )
-    ) { _ in }
+    ) { _ in } onDeletion: { }
     .padding()
 }

Sources/ArcGISToolkit/Components/Offline/PreplannedMapModel.swift

@@ -22,6 +22,9 @@ class PreplannedMapModel: ObservableObject, Identifiable {
     /// The preplanned map area.
     let preplannedMapArea: any PreplannedMapAreaProtocol
 
+    /// The mobile map package directory URL.
+    private let mmpkDirectoryURL: URL
+
     /// The task to use to take the area offline.
     private let offlineMapTask: OfflineMapTask
 
@@ -34,6 +37,9 @@ class PreplannedMapModel: ObservableObject, Identifiable {
     /// The mobile map package for the preplanned map area.
     private(set) 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?
 
@@ -54,15 +60,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 +109,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
         }
     }
 
@@ -143,16 +152,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 +167,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 +185,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 +239,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 +317,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 +336,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.

Sources/ArcGISToolkit/Components/Offline/PreplannedMetadataView.swift

@@ -0,0 +1,109 @@
+// Copyright 2024 Esri
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import ArcGIS
+import SwiftUI
+
+struct PreplannedMetadataView: View {
+    /// The view model for the preplanned map.
+    @ObservedObject var model: PreplannedMapModel
+
+    /// The action to dismiss the view.
+    @Environment(\.dismiss) private var dismiss
+
+    var body: some View {
+        Form {
+            Section {
+                if let image = model.preplannedMapArea.thumbnail {
+                    HStack {
+                        Spacer()
+                        LoadableImageView(loadableImage: image)
+                            .clipShape(.rect(cornerRadius: 10))
+                            .padding(.vertical, 10)
+                        Spacer()
+                    }
+                }
+                VStack(alignment: .leading) {
+                    Text("Name")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Text(model.preplannedMapArea.title)
+                        .font(.subheadline)
+                }
+                VStack(alignment: .leading) {
+                    Text("Description")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    if model.preplannedMapArea.description.isEmpty {
+                        Text("This area has no description.")
+                            .font(.subheadline)
+                            .foregroundStyle(.tertiary)
+                    } else {
+                        Text(model.preplannedMapArea.description)
+                            .font(.subheadline)
+                    }
+                }
+                VStack(alignment: .leading) {
+                    Text("Size")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Text(Int64(model.directorySize), format: .byteCount(style: .file, allowedUnits: [.kb, .mb]))
+                        .font(.subheadline)
+                }
+            }
+            Section {
+                HStack {
+                    Image(systemName: "trash.circle.fill")
+                        .symbolRenderingMode(.palette)
+                        .foregroundStyle(.red, .gray.opacity(0.1))
+                        .font(.title)
+                    Button("Delete Map Area", role: .destructive) {
+                        dismiss()
+                        model.removeDownloadedPreplannedMapArea()
+                    }
+                }
+            }
+        }
+        .navigationTitle(model.preplannedMapArea.title)
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar {
+            ToolbarItem(placement: .confirmationAction) {
+                Button("Done") { dismiss() }
+            }
+        }
+    }
+}
+
+#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 }
+
+        func retryLoad() async throws { }
+        func makeParameters(using offlineMapTask: OfflineMapTask) async throws -> DownloadPreplannedOfflineMapParameters {
+            DownloadPreplannedOfflineMapParameters()
+        }
+    }
+
+    return PreplannedMetadataView(
+        model: PreplannedMapModel(
+            offlineMapTask: OfflineMapTask(onlineMap: Map()),
+            mapArea: MockPreplannedMapArea(),
+            portalItemID: .init("preview")!,
+            preplannedMapAreaID: .init("preview")!
+        )
+    )
+}