Swift 4 + CloudKit实现iCloud相册创建及分相册存图技术咨询

Hey there! As an iOS dev who’s built similar CloudKit-powered apps before, let’s walk through how to implement your password-protected photo album feature step by step. I’ll keep things straightforward since you’re new to this—no jargon overload!

1. Build the Password Verification Screen #

First, you’ll need a dedicated screen to gate access to album creation:

• Create a new UIViewController with a secure text field (set secureTextEntry = true to hide input) and a "Verify" button.
• Store your secret password securely: Never use UserDefaults (it’s plaintext!). Instead, use the Security framework to save/retrieve the password from Keychain—this keeps it safe even if the device is jailbroken.
  Example code for Keychain operations:

  import Security
  
  func savePasswordToKeychain(password: String) {
      let query: [CFString: Any] = [
          kSecClass: kSecClassGenericPassword,
          kSecAttrAccount: "PhotoAlbumAppPassword",
          kSecValueData: password.data(using: .utf8)!
      ]
      // Delete existing entry first to avoid duplicates
      SecItemDelete(query as CFDictionary)
      let status = SecItemAdd(query as CFDictionary, nil)
      if status != errSecSuccess {
          print("Failed to save password to Keychain")
      }
  }
  
  func getPasswordFromKeychain() -> String? {
      let query: [CFString: Any] = [
          kSecClass: kSecClassGenericPassword,
          kSecAttrAccount: "PhotoAlbumAppPassword",
          kSecReturnData: kCFBooleanTrue!,
          kSecMatchLimit: kSecMatchLimitOne
      ]
      var data: AnyObject?
      let status = SecItemCopyMatching(query as CFDictionary, &data)
      if status == errSecSuccess, let passwordData = data as? Data {
          return String(data: passwordData, encoding: .utf8)
      }
      return nil
  }
  

• When the user taps "Verify", compare their input to the password retrieved from Keychain. If it matches, push/present your album creation view controller.

2. Set Up CloudKit in Your Project #

Before storing data, configure CloudKit in Xcode:

• Go to your project target > "Signing & Capabilities" > Click "+ Capability" > Add "iCloud".
• Check "CloudKit" and select your iCloud container (create one if you don’t have it).
• Add NSUbiquitousContainersUsageDescription to your Info.plist with a message like "To store your photo albums securely in iCloud" (required for permission prompts).

3. Design Your CloudKit Data Model #

You’ll need two record types to organize your data:

• Album: Stores album metadata
  • Fields: title (String, the album name), creationDate (Date, auto-generated or set manually)
• Photo: Stores photo data and links to its parent album
  • Fields: imageAsset (CKAsset, ideal for large files like photos—better than raw Data), albumReference (CKRecord.Reference, links to the parent Album record), creationDate (Date)

Pro Tip: You can create these record types manually in the CloudKit Dashboard, or let CloudKit auto-generate them when you save your first record (just make sure field names match your code).

4. Implement Album Creation Flow #

Once the user passes password verification, let them create albums:

• In your album creation view controller, add a text field for the album name and a "Create Album" button.
• When the button is tapped, create an Album record and save it to CloudKit’s private database (since this is user-specific data):

  let privateDB = CKContainer.default().privateCloudDatabase
  
  func createAlbum(withTitle title: String) {
      let albumRecord = CKRecord(recordType: "Album")
      albumRecord["title"] = title
      albumRecord["creationDate"] = Date()
  
      privateDB.save(albumRecord) { record, error in
          DispatchQueue.main.async {
              if let error = error {
                  print("Failed to create album: \(error.localizedDescription)")
                  // Show a user-friendly alert here
                  return
              }
              // Success! Navigate to the album's photo list screen
              print("Album created successfully")
          }
      }
  }
  

5. Upload Photos to an Album #

To let users add photos to an album:

• Use UIImagePickerController to let the user select photos from their library. Don’t forget to add NSPhotoLibraryUsageDescription to Info.plist to request photo library permission.
• Convert the selected UIImage to a temporary local file (CKAsset requires a file URL):

  func saveImageToTempFile(image: UIImage) -> URL? {
      guard let imageData = image.jpegData(compressionQuality: 0.8) else { return nil }
      let tempDir = FileManager.default.temporaryDirectory
      let tempURL = tempDir.appendingPathComponent("\(UUID().uuidString).jpg")
      do {
          try imageData.write(to: tempURL)
          return tempURL
      } catch {
          print("Failed to save image to temp file: \(error)")
          return nil
      }
  }
  

• Create a Photo record linked to the album, then save it to CloudKit:

  func uploadPhoto(toAlbum albumRecord: CKRecord, image: UIImage) {
      guard let tempURL = saveImageToTempFile(image: image) else { return }
      let photoRecord = CKRecord(recordType: "Photo")
      photoRecord["imageAsset"] = CKAsset(fileURL: tempURL)
      // Link to the album—use .deleteSelf to auto-delete photos if the album is removed
      photoRecord["albumReference"] = CKRecord.Reference(record: albumRecord, action: .deleteSelf)
      photoRecord["creationDate"] = Date()
  
      privateDB.save(photoRecord) { record, error in
          DispatchQueue.main.async {
              // Clean up the temp file to save space
              try? FileManager.default.removeItem(at: tempURL)
              if let error = error {
                  print("Failed to upload photo: \(error.localizedDescription)")
                  // Show alert to user
                  return
              }
              print("Photo uploaded successfully")
          }
      }
  }
  

6. Key Additional Tips #

• Error Handling: Always handle CloudKit errors (network issues, permission denials) and show user-friendly alerts instead of just logging them.
• Biometric Authentication: For better UX, add Touch ID/Face ID support using the LocalAuthentication framework as an alternative to password entry.
• Fetching Albums/Photos: To display existing content, use CKQuery to fetch records. Example to fetch all albums sorted by creation date:

  func fetchAlbums() {
      let predicate = NSPredicate(value: true) // Fetch all albums
      let query = CKQuery(recordType: "Album", predicate: predicate)
      query.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
  
      privateDB.perform(query, inZoneWith: nil) { records, error in
          DispatchQueue.main.async {
              if let error = error {
                  print("Failed to fetch albums: \(error)")
                  return
              }
              // Use fetched records to populate your UI
              let albums = records ?? []
          }
      }
  }
  

• Syncing: CloudKit auto-syncs data across devices, but use CKDatabaseSubscription to get notified of changes and update your UI accordingly.

内容的提问来源于stack exchange，提问作者Ankit Tanna