Trouble with contextMenu previewing high resolution images

[Seek-Connections]

Body

When using a contextMenu in SwiftUI to show a preview of a PHAsset’s full-size image via PHCachingImageManager.requestImage(), memory usage increases with each image preview interaction. The memory is not released, leading to eventual app crash due to memory exhaustion.
The thumbnail loads and behaves as expected, but each call to fetch the full-size image (1000x1000) for the contextMenu preview does not release memory, even after cancelImageRequest() is called and fullSizePreviewImage is set to nil.
The issue seems to stem from the contextMenu lifecycle behavior, it triggers .onAppear unexpectedly, and the full-size image is repeatedly fetched without releasing the previously loaded images.
The question is, where do I request to the get the full-size image to show it in the context menu preview?

https://github.com/luisazmouz/contextMenu

Guidelines

• I have read and understood this category's guidelines before making this post.

[eggduzao]

This is a classic "context menu preview + Photos" lifecycle trap. What you're seeing is SwiftUI's strange behaviour on contextMenu reusing views and re-triggering lifecycle events in ways that make it look like a leak if you tie image requests to the wrong place.

Below is a battle-tested approach that (a) requests the full-size only for the preview, (b) guarantees exactly one request per preview, (c) cancels on teardown, and (d) avoids Photos caching runaway growth.

---

What's going on

• contextMenu (and the preview view) is not guaranteed to have a clean onAppear/onDisappear pairing. SwiftUI may:
  • Build multiple preview views during gesture transitions.
  • Recreate the preview when the gesture state changes.
  • Keep the source cell alive (so your .onAppear on the cell can fire again for reasons unrelated to the menu).

If your full-size request lives in the cell or a parent, you'll accumulate UIImages and PHImageRequestIDs faster than you release them. Canceling with cancelImageRequest(_:) helps, but if you've fired multiple requests (because .onAppear ran multiple times), you'll miss some.

---

Design that stays lean

Rule of thumb: Make the preview responsible for its own image lifecycle.
Create a tiny preview view with a dedicated @StateObject view model. Request once when the preview is presented; cancel & release when it's dismissed/deinitialized.

Key tricks:

• Scope the request inside the preview view, not the grid/cell.
• Use .task(id:) (or onAppear) inside the preview so it runs once per asset id.
• Keep the command queue on the PHCachingImageManager minimal:
  • Use requestImage(for:targetSize:contentMode:options:) with a bounded targetSize (e.g., 1000×1000) so it doesn't decode a 12 MP original.
  • Pair any startCachingImages with stopCachingImages immediately after dismiss.
• Hold the PHImageRequestID and cancel in deinit and/or onDisappear.
• Nil out the UIImage and use autoreleasepool to encourage timely reclaim.
• Give the preview view a stable .id(asset.localIdentifier) to help SwiftUI tear it down.

---

Minimal working pattern

import SwiftUI
import Photos
import PhotosUI

struct AssetCell: View {
    let asset: PHAsset
    private let manager = PHCachingImageManager.default()

    var body: some View {
        // Your thumbnail (fast, tiny memory)
        ThumbnailView(asset: asset, manager: manager)
            .contextMenu {
                Button("Do something") { /* menu actions */ }
            } preview: {
                // Put the heavy request *here*, scoped to the preview only.
                FullSizePreview(asset: asset, manager: manager)
                    // Ensure SwiftUI tears down between different assets:
                    .id(asset.localIdentifier)
            }
    }
}

struct FullSizePreview: View {
    let asset: PHAsset
    let manager: PHCachingImageManager

    @StateObject private var vm = FullSizePreviewVM()

    var body: some View {
        ZStack {
            if let image = vm.image {
                Image(uiImage: image).resizable().scaledToFit()
            } else {
                ProgressView()
            }
        }
        .task(id: asset.localIdentifier) {
            await vm.loadFullSize(asset: asset, manager: manager)
        }
        .onDisappear {
            vm.teardown(manager: manager)
        }
    }
}

@MainActor
final class FullSizePreviewVM: ObservableObject {
    @Published var image: UIImage? = nil
    private var requestID: PHImageRequestID?
    private var isLoaded = false

    func loadFullSize(asset: PHAsset, manager: PHCachingImageManager) async {
        guard !isLoaded else { return }
        isLoaded = true

        // Target ~1000x1000 to avoid huge decodes. Use asset pixel ratio for crispness.
        let target = CGSize(width: 1000, height: 1000)

        let options = PHImageRequestOptions()
        options.isNetworkAccessAllowed = true
        options.deliveryMode = .highQualityFormat
        options.resizeMode = .fast
        options.isSynchronous = false

        // Optional: pre-cache just this one, then stop later.
        manager.startCachingImages(
            for: [asset],
            targetSize: target,
            contentMode: .aspectFit,
            options: options
        )

        self.requestID = manager.requestImage(
            for: asset,
            targetSize: target,
            contentMode: .aspectFit,
            options: options
        ) { [weak self] img, info in
            guard let self else { return }

            // Avoid holding onto large images if the request was degraded/cancelled
            let cancelled = (info?[PHImageCancelledKey] as? Bool) == true
            let degraded  = (info?[PHImageResultIsDegradedKey] as? Bool) == true
            if cancelled { return }
            if let img, !degraded {
                // Encourage early release of intermediates
                autoreleasepool {
                    self.image = img
                }
            }
        }
    }

    func teardown(manager: PHCachingImageManager) {
        if let id = requestID {
            manager.cancelImageRequest(id)
            requestID = nil
        }
        // Stop caching what we started for this preview
        // (We don't hold a reference to the asset here, so the caller can do it;
        // or pass the asset in teardown if you prefer.)
        image = nil
    }

    deinit {
        // Belt-and-suspenders; if you want to cancel here, you need
        // a reference to the manager. Common pattern: store a weak manager.
        image = nil
    }
}

// Fast thumbnail view (kept tiny)
struct ThumbnailView: View {
    let asset: PHAsset
    let manager: PHCachingImageManager
    @State private var thumb: UIImage?

    var body: some View {
        Group {
            if let thumb {
                Image(uiImage: thumb).resizable().scaledToFill()
            } else {
                Color.secondary.opacity(0.1)
                    .overlay { ProgressView().controlSize(.mini) }
            }
        }
        .frame(width: 100, height: 100)
        .clipped()
        .task(id: asset.localIdentifier) {
            await requestThumb()
        }
    }

    @MainActor
    private func requestThumb() async {
        let size = CGSize(width: 200, height: 200)
        let opts = PHImageRequestOptions()
        opts.deliveryMode = .fastFormat
        opts.resizeMode = .fast
        opts.isSynchronous = false

        _ = manager.requestImage(for: asset, targetSize: size, contentMode: .aspectFill, options: opts) { img, _ in
            if let img {
                autoreleasepool { self.thumb = img }
            }
        }
    }
}

---

Additional guardrails

• One request per preview: guard with a boolean (isLoaded) or make the task keyed by asset.localIdentifier.
• Cancel everything: keep the PHImageRequestID from requestImage and cancel in onDisappear and during teardown.
• Bound memory early:
• Avoid requestImageDataAndOrientation for previews unless you need the bytes; it decodes the whole original.
• Always pass a bounded targetSize. If you pass .zero or PHImageManagerMaximumSize, you'll pay in RAM.
• No global caches: If you startCachingImages, make sure you stopCachingImages on the same asset when the menu dismisses.
• Preview reusability: Using .id(asset.localIdentifier) on the preview view helps SwiftUI rebuild/tear down as assets change.
• Autorelease pools: Wrap publishes of large UIImages in autoreleasepool {} to flush intermediates faster.

---

Answer to "where do I request the full-size image?"

Inside the preview view that you pass to contextMenu's preview: closure, not in the cell or parent list. That localizes the lifetime to the menu interaction, guarantees cancellation on dismiss, and prevents hidden re-entrancy from onAppear in the grid.

[Seek-Connections]

Wow! Appreciate it. I've implemented and it’s working pretty well, the memory is being released. The only issue now is you can't preview the same image twice, the second time we get an endless progressIndicator, unless you scroll out of the view and back to it. Other than that it’s working really smoothly, can’t thank you enough.

import Foundation
import SwiftUI
import Photos
import UIKit


struct PhotoGridView: View {
    
    @State private var recentAssets: [PHAsset] = []
    @State private var isAuthorized = false
    static let cachingManager = PHCachingImageManager()
    
    let columns = [
        GridItem(.flexible()),
        GridItem(.flexible()),
        GridItem(.flexible())
    ]
    
    var body: some View {
        
        NavigationView {
            ZStack {
                if isAuthorized {
                    ScrollView {
                        LazyVGrid(columns: columns, spacing: 12) {
                            ForEach(recentAssets, id: \.localIdentifier) { asset in
                                AssetCell(asset: asset)
                            }
                        }
                    }
                } else {
                    VStack {
                        Text("Requesting photo library access...")
                            .onAppear {
                                requestPhotoAccess()
                            }
                    }
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .navigationTitle("Photos")
        }
        
    }
    
    func requestPhotoAccess() {
        PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
            if status == .authorized || status == .limited {
                DispatchQueue.main.async {
                    self.isAuthorized = true
                    self.fetchLast200Photos()
                }
            }
        }
    }
    
    func fetchLast200Photos() {
        let fetchOptions = PHFetchOptions()
        fetchOptions.sortDescriptors = [
            NSSortDescriptor(key: "creationDate", ascending: false)
        ]
        fetchOptions.fetchLimit = 1200
        fetchOptions.predicate = NSPredicate(format: "mediaType == %d", PHAssetMediaType.image.rawValue)

        let result = PHAsset.fetchAssets(with: .image, options: fetchOptions)
        var assets: [PHAsset] = []
        result.enumerateObjects { asset, _, _ in
            assets.append(asset)
        }

        DispatchQueue.main.async {
            self.recentAssets = assets
        }
    }
}



struct AssetCell: View {
    let asset: PHAsset
    private let manager = PHCachingImageManager.default()

    var body: some View {
        // Your thumbnail (fast, tiny memory)
        ThumbnailView(asset: asset, manager: manager as! PHCachingImageManager)
            .contextMenu {
                Button("Do something") { /* menu actions */ }
            } preview: {
                // Put the heavy request *here*, scoped to the preview only.
                FullSizePreview(asset: asset, manager: manager as! PHCachingImageManager)
                    // Ensure SwiftUI tears down between different assets:
                    .id(asset.localIdentifier)
            }
    }
}

struct FullSizePreview: View {
    let asset: PHAsset
    let manager: PHCachingImageManager

    @StateObject private var vm = FullSizePreviewVM()

    var body: some View {
        ZStack {
            if let image = vm.image {
                Image(uiImage: image).resizable().scaledToFit()
            } else {
                ProgressView()
            }
        }
        .task(id: asset.localIdentifier) {
            await vm.loadFullSize(asset: asset, manager: manager)
        }
        .onDisappear {
            vm.teardown(manager: manager)
        }
    }
}

@MainActor
final class FullSizePreviewVM: ObservableObject {
    @Published var image: UIImage? = nil
    private var requestID: PHImageRequestID?
    private var isLoaded = false

    func loadFullSize(asset: PHAsset, manager: PHCachingImageManager) async {
        guard !isLoaded else { return }
        isLoaded = true

        // Target ~1000x1000 to avoid huge decodes. Use asset pixel ratio for crispness.
        let target = CGSize(width: 1000, height: 1000)

        let options = PHImageRequestOptions()
        options.isNetworkAccessAllowed = true
        options.deliveryMode = .highQualityFormat
        options.resizeMode = .fast
        options.isSynchronous = false

        // Optional: pre-cache just this one, then stop later.
        manager.startCachingImages(
            for: [asset],
            targetSize: target,
            contentMode: .aspectFit,
            options: options
        )

        self.requestID = manager.requestImage(
            for: asset,
            targetSize: target,
            contentMode: .aspectFit,
            options: options
        ) { [weak self] img, info in
            guard let self else { return }

            // Avoid holding onto large images if the request was degraded/cancelled
            let cancelled = (info?[PHImageCancelledKey] as? Bool) == true
            let degraded  = (info?[PHImageResultIsDegradedKey] as? Bool) == true
            if cancelled { return }
            if let img, !degraded {
                // Encourage early release of intermediates
                autoreleasepool {
                    self.image = img
                }
            }
        }
    }

    func teardown(manager: PHCachingImageManager) {
        if let id = requestID {
            manager.cancelImageRequest(id)
            requestID = nil
        }
        // Stop caching what we started for this preview
        // (We don't hold a reference to the asset here, so the caller can do it;
        // or pass the asset in teardown if you prefer.)
        image = nil
    }

    deinit {
        // Belt-and-suspenders; if you want to cancel here, you need
        // a reference to the manager. Common pattern: store a weak manager.
//        image = nil
    }
}

// Fast thumbnail view (kept tiny)
struct ThumbnailView: View {
    let asset: PHAsset
    let manager: PHCachingImageManager
    let screenWidth: CGFloat = UIScreen.main.bounds.width
    @State private var thumb: UIImage?

    var body: some View {
        Group {
            if let thumb {
                Image(uiImage: thumb).resizable().scaledToFill()
            } else {
                Color.secondary.opacity(0.1)
                    .overlay { ProgressView().controlSize(.mini) }
            }
        }
        .scaledToFit()
        .frame(width: screenWidth * 0.3, height: screenWidth * 0.3)
        .clipped()
        .task(id: asset.localIdentifier) {
            await requestThumb()
        }
    }

    @MainActor
    private func requestThumb() async {
        let size = CGSize(width: 200, height: 200)
        let opts = PHImageRequestOptions()
        opts.deliveryMode = .opportunistic
        opts.resizeMode = .fast
        opts.isSynchronous = false

        _ = manager.requestImage(for: asset, targetSize: size, contentMode: .aspectFill, options: opts) { img, _ in
            if let img {
                autoreleasepool { self.thumb = img }
            }
        }
    }
}