Build an iOS Application

amplify add storage

? Please select from one of the below mentioned services:,accept the default Content (Images, audio, video, etc.) and press enter
? Please provide a friendly name for your resource that will be used to label this category in the project: type image and press enter
? Please provide bucket name:, accept the default and press enter
? Who should have access:, accept the default Auth users only and press enter
? What kind of access do you want for Authenticated users? select all three options create/update, read, delete using the space and arrows keys, then press enter
? Do you want to add a Lambda Trigger for your S3 Bucket?, accept the default No and press enter

Successfully added resource image locally

amplify push

✔ Successfully pulled backend environment amplify from the cloud.

// at the top of the file
import AWSS3StoragePlugin

// initialize amplify
do {
   try Amplify.add(plugin: AWSCognitoAuthPlugin())
   try Amplify.add(plugin: AWSAPIPlugin(modelRegistration: AmplifyModels()))
   try Amplify.add(plugin: AWSS3StoragePlugin())
   try Amplify.configure()
   print("Initialized Amplify");
} catch {
   print("Could not initialize Amplify: \(error)")
}

// MARK: - Image Storage
func storeImage(name: String, image: Data) {

    let options = StorageUploadDataRequest.Options(accessLevel: .private)
    let uploadTask = Amplify.Storage.uploadData(
        key: name, 
        data: image, 
        options: options
    )
    Task {
        for await progress in await uploadTask.progress {
            // optionally update a progress bar here
        }
        do {
            let data = try await uploadTask.value
            print("Image upload completed: \(data)")
        } catch {
            print("Image upload failed: \(error.errorDescription). \(error.recoverySuggestion)")
        }
    }
}
func retrieveImage(name: String, completed: @escaping (Data) -> Void) {

    let options = StorageDownloadDataRequest.Options(accessLevel: .private)
    let downloadTask = Amplify.Storage.downloadData(
        key: name, 
        options: options
    )
    Task {
        for await progress in await downloadTask.progress {
            // optionally update a progress bar here
        }
        do {
            let data = try await downloadTask.value
            print("Image \(name) loaded")
            completed(data)
        } catch {
            print("Can not download image: \(error.errorDescription). \(error.recoverySuggestion)")
        }
    }
}
func deleteImage(name: String) {

    let options = StorageRemoveRequest.Options(accessLevel: .private)
    Task {
        do {
            let key = try await Amplify.Storage.remove(key: name, options: options)
            print("Image \(key) deleted")
        } catch {
            print("Can not delete image: \(error.errorDescription). \(error.recoverySuggestion)")
        }
    }
}

// add a publishable's object property
@Published var image : Image?

// update init's code
convenience init(from data: NoteData) {
    self.init(id: data.id, name: data.name, description: data.description, image: data.image)

    if let name = self.imageName {
        // asynchronously download the image
               Backend.shared.retrieveImage(name: name) { (data) in
// update the UI on the main thread
MainActor.run {
                let uim = UIImage(data: data)
                self.image = Image(uiImage: uim!)
            }
        }
    }
    // store API object for easy retrieval later
    self._data = data
}

import Foundation
import UIKit
import SwiftUI

struct CaptureImageView {

  /// MARK: - Properties
  @Binding var isShown: Bool
  @Binding var image: UIImage?

  func makeCoordinator() -> Coordinator {
    return Coordinator(isShown: $isShown, image: $image)
  }
}

class Coordinator: NSObject, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
  @Binding var isCoordinatorShown: Bool
  @Binding var imageInCoordinator: UIImage?
  init(isShown: Binding<Bool>, image: Binding<UIImage?>) {
    _isCoordinatorShown = isShown
    _imageInCoordinator = image
  }
  func imagePickerController(_ picker: UIImagePickerController,
                didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
     guard let unwrapImage = info[UIImagePickerController.InfoKey.originalImage] as? UIImage else { return }
     imageInCoordinator = unwrapImage
     isCoordinatorShown = false
  }
  func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
     isCoordinatorShown = false
  }
}

extension CaptureImageView: UIViewControllerRepresentable {
    func makeUIViewController(context: UIViewControllerRepresentableContext<CaptureImageView>) -> UIImagePickerController {
        let picker = UIImagePickerController()
        picker.delegate = context.coordinator

        // picker.sourceType = .camera // on real devices, you can capture image from the camera
        // see https://medium.com/better-programming/how-to-pick-an-image-from-camera-or-photo-library-in-swiftui-a596a0a2ece

        return picker
    }

    func updateUIViewController(_ uiViewController: UIImagePickerController,
                                context: UIViewControllerRepresentableContext<CaptureImageView>) {

    }
}

// at the start of the Content View struct 
@State var image : UIImage? // replace the previous declaration of image
@State var showCaptureImageView = false

// in the view, replace the existing PICTURE section
Section(header: Text("PICTURE")) {
    VStack {
        Button(action: {
            self.showCaptureImageView.toggle()
        }) {
            Text("Choose photo")
        }.sheet(isPresented: $showCaptureImageView) {
            CaptureImageView(isShown: self.$showCaptureImageView, image: self.$image)
        }
        if (image != nil ) {
            HStack {
                Spacer()
                Image(uiImage: image!)
                    .resizable()
                    .frame(width: 250, height: 200)
                    .clipShape(Circle())
                    .overlay(Circle().stroke(Color.white, lineWidth: 4))
                    .shadow(radius: 10)
                Spacer()
            }
        }
    }
}

Section {
    Button(action: {
        self.isPresented = false

        let note = Note(id : UUID().uuidString,
                        name: self.$name.wrappedValue,
                        description: self.$description.wrappedValue)

        if let i = self.image  {
            note.imageName = UUID().uuidString
            note.image = Image(uiImage: i)

            // asynchronously store the image (and assume it will work)
            Backend.shared.storeImage(name: note.imageName!, image: (i.pngData())!)
        }

        // asynchronously store the note (and assume it will succeed)
        Backend.shared.createNote(note: note)

        // add the new note in our userdata, this will refresh UI
        withAnimation { self.userData.notes.append(note) }
    }) {
        Text("Create this note")
    }
}