Learn how to save/change picture on iOS utilizing swift and PhotoKit

This looks as if tremendous straightforward job, however I battle to interchange picture after its edit.

First dummy UI to select picture from gallery:

import SwiftUI
import Photographs
import PhotosUI

struct ContentView: View {
    @State personal var selectedImage: UIImage? = nil
    @State personal var isPickerPresented: Bool = false

    var physique: some View {
        VStack {
            if let picture = selectedImage {
                Picture(uiImage: picture)
                    .resizable()
                    .scaledToFit()
                    .body(top: 300)
            } else {
                Textual content("No picture chosen")
            }

            Button(motion: {
                isPickerPresented = true
            }) {
                Textual content("Choose a Photograph")
            }

            Button(motion: {
                selectedImage = editPhoto(selectedImage!)
            }) {
                Textual content("Apply Filter")
            }

            Button(motion: {
                savePhoto(selectedImage!)
            }) {
                Textual content("Save Photograph")
            }

            Button(motion: {
                fetchPhotos().first.map { asset in
                    replacePhoto(asset: asset, with: selectedImage!)
                }
            }) {
                Textual content("Exchange Photograph")
            }
        }
        .onAppear {
            requestPhotoLibraryAccess()
        }
        .sheet(isPresented: $isPickerPresented) {
            PhotoPicker(selectedImage: $selectedImage)
        }
    }
}

struct PhotoPicker: UIViewControllerRepresentable {
    @Binding var selectedImage: UIImage?

    class Coordinator: NSObject, PHPickerViewControllerDelegate {
        var dad or mum: PhotoPicker

        init(dad or mum: PhotoPicker) {
            self.dad or mum = dad or mum
        }

        func picker(_ picker: PHPickerViewController, didFinishPicking outcomes: [PHPickerResult]) {
            picker.dismiss(animated: true)
            guard let end result = outcomes.first else { return }

            if end result.itemProvider.canLoadObject(ofClass: UIImage.self) {
                end result.itemProvider.loadObject(ofClass: UIImage.self) { picture, error in
                    DispatchQueue.most important.async {
                        if let picture = picture as? UIImage {
                            self.dad or mum.selectedImage = picture
                        }
                    }
                }
            }
        }
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(dad or mum: self)
    }

    func makeUIViewController(context: Context) -> PHPickerViewController {
        var configuration = PHPickerConfiguration()
        configuration.selectionLimit = 1
        configuration.filter = .pictures

        let picker = PHPickerViewController(configuration: configuration)
        picker.delegate = context.coordinator
        return picker
    }

    func updateUIViewController(_ uiViewController: PHPickerViewController, context: Context) {
        // No updates required
    }
}

getting permission:

func requestPhotoLibraryAccess() {
    PHPhotoLibrary.requestAuthorization { standing in
        change standing {
        case .licensed:
            print("Entry granted")
        case .restricted:
            print("Restricted entry granted")
        case .denied, .restricted:
            print("Entry denied")
        case .notDetermined:
            print("Not decided but")
        @unknown default:
            fatalError("Unhandled authorization standing")
        }
    }
}

whereas having this in information.plist

NSPhotoLibraryUsageDescription
We'd like entry to your photographs to can help you edit them.
NSPhotoLibraryAddUsageDescription
We'd like entry to save lots of the edited photographs again to your library.

Nonetheless not so essential methods easy methods to get picture/asset (for change), edit photograph

func fetchPhotos() -> [PHAsset] {
    var belongings: [PHAsset] = []
    let fetchOptions = PHFetchOptions()
    fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]

    let fetchResult = PHAsset.fetchAssets(with: .picture, choices: fetchOptions)
    fetchResult.enumerateObjects { asset, _, _ in
        belongings.append(asset)
    }
    return belongings
}

func editPhoto(_ picture: UIImage) -> UIImage? {
    return applyFilterWithFixedOrientation(
        picture: picture,
        filterName: "CIGaussianBlur",
        parameters: [kCIInputRadiusKey: 20.0]
    )
}

func applyFilterWithFixedOrientation(picture: UIImage, filterName: String, parameters: [String: Any] = [:]) -> UIImage? {
    guard let ciImage = CIImage(picture: picture) else { return nil }

    // Create the filter
    let filter = CIFilter(title: filterName)
    filter?.setValue(ciImage, forKey: kCIInputImageKey)

    // Set extra parameters if offered
    for (key, worth) in parameters {
        filter?.setValue(worth, forKey: key)
    }

    // Get the output picture
    if let outputImage = filter?.outputImage {
        let context = CIContext()
        if let cgImage = context.createCGImage(outputImage, from: outputImage.extent) {
            // Repair the orientation
            return UIImage(cgImage: cgImage, scale: picture.scale, orientation: picture.imageOrientation)
        }
    }
    return nil
}

func savePhoto(_ picture: UIImage) {
    PHPhotoLibrary.shared().performChanges({
        PHAssetChangeRequest.creationRequestForAsset(from: picture)
    }) { success, error in
        DispatchQueue.most important.async {
            if success {
                print("Photograph saved efficiently")
            } else {
                print("Failed to save lots of photograph: (error?.localizedDescription ?? "unknown error")")
            }
        }
    }
}

That is in all probability the not working half:

func replacePhoto(asset: PHAsset, with picture: UIImage) {
    PHPhotoLibrary.shared().performChanges({
        guard let contentEditingInput = getEditingInput(for: asset) else {
            print("Did not retrieve modifying enter.")
            return
        }

        // Put together modifying output
        let editingOutput = PHContentEditingOutput(contentEditingInput: contentEditingInput)

        // Save new picture information to the modifying output's URL
        if let jpegData = picture.jpegData(compressionQuality: 1.0) {
            attempt? jpegData.write(to: editingOutput.renderedContentURL, choices: .atomic)
        }

        // Replace the asset with the brand new modifying output
        let request = PHAssetChangeRequest(for: asset)
        request.contentEditingOutput = editingOutput
    }) { success, error in
        DispatchQueue.most important.async {
            if success {
                print("Picture changed efficiently.")
            } else {
                print("Failed to interchange picture: (error?.localizedDescription ?? "Unknown error")")
            }
        }
    }
}

func getEditingInput(for asset: PHAsset) -> PHContentEditingInput? {
    let semaphore = DispatchSemaphore(worth: 0)
    var editingInput: PHContentEditingInput?

    asset.requestContentEditingInput(with: nil) { enter, _ in
        editingInput = enter
        semaphore.sign()
    }

    semaphore.wait()
    return editingInput
}

As a result of when I attempt to change the photograph I’ve picked, I bought this error:

Failed to interchange picture: The operation couldn’t be accomplished. (PHPhotosErrorDomain error 3303.)

What am I lacking or why I can not reserve it to unique place?