Merge pull request #8 from crelies/dev

New property wrapper, Album bugfix, Photo.save for macOS

Author: Chris

README.md

@@ -381,6 +381,8 @@ This section gives you an overview of the currently available functionality. Mos
 
 The `Media` package also includes some generic property wrappers you can use to interact with the photo library.
 
+- `@FetchAllAssets(sort:fetchLimit:includeAllBurstAssets:includeHiddenAssets) var assets: [AnyMedia]`
+
 - `@FetchAssets(filter:sort:fetchLimit:includeAllBurstAssets:includeHiddenAssets) var assets: [ <Audio | LivePhoto | Photo | Video> ]`
 
   *Fetch audios, live photos, photos or videos matching the given filter and sorted by the given sort*

Sources/MediaCore/API/Album/Album.swift

@@ -11,8 +11,6 @@ import Photos
 /// Convenience wrapper type around `PHAssetCollection`
 ///
 public struct Album {
-    static var phAsset: PHAsset.Type = PHAsset.self
-
     let phAssetCollectionWrapper: PHAssetCollectionWrapper
 
     var phAssetCollection: PHAssetCollection? { phAssetCollectionWrapper.value }
@@ -37,51 +35,44 @@ public struct Album {
     /// All audios contained in the receiver
     /// sorted by `creationDate descending`
     ///
-    @FetchAssets(sort: [Media.Sort(key: .creationDate, ascending: false)])
+    @FetchAssets
     public var audios: [Audio]
 
     /// All photos contained in the receiver (including `LivePhoto`s)
     /// sorted by `creationDate descending`
     ///
-    @FetchAssets(sort: [Media.Sort(key: .creationDate, ascending: false)])
+    @FetchAssets
     public var photos: [Photo]
 
     /// All videos contained in the receiver
     /// sorted by `creationDate descending`
     ///
-    @FetchAssets(sort: [Media.Sort(key: .creationDate, ascending: false)])
+    @FetchAssets
     public var videos: [Video]
 
     /// All live photos contained in the receiver
     /// sorted by `creationDate descending`
     ///
-    @FetchAssets(filter: [.mediaSubtypes([.live])],
-                 sort: [Media.Sort(key: .creationDate, ascending: false)])
+    @FetchAssets
     public var livePhotos: [LivePhoto]
 
-    init(phAssetCollection: PHAssetCollection) {
-        phAssetCollectionWrapper = PHAssetCollectionWrapper(phAssetCollection: phAssetCollection)
-    }
-}
-
-public extension Album {
     /// All media (audios, live photos, photos, videos and more?) contained in the receiver
-    /// sorted by `creationDate descending`
+    /// sorted by `creationDate descending`.
     ///
-    var allMedia: [AnyMedia] {
-        guard let phAssetCollection = phAssetCollection else { return [] }
+    @FetchAllAssets
+    public var allMedia: [AnyMedia]
 
-        let options = PHFetchOptions()
-        options.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
-        let result = Self.phAsset.fetchAssets(in: phAssetCollection, options: options)
-        var media: [AnyMedia] = []
-        result.enumerateObjects { asset, _, _ in
-            guard let anyMedia = asset.anyMedia else {
-                return
-            }
-            media.append(anyMedia)
-        }
-        return media
+    init(phAssetCollection: PHAssetCollection) {
+        _audios = FetchAssets(in: phAssetCollection, sort: [Media.Sort(key: .creationDate, ascending: false)])
+        _photos = FetchAssets(in: phAssetCollection, sort: [Media.Sort(key: .creationDate, ascending: false)])
+        _videos = FetchAssets(in: phAssetCollection, sort: [Media.Sort(key: .creationDate, ascending: false)])
+        _livePhotos = FetchAssets(
+            in: phAssetCollection,
+            filter: [.mediaSubtypes([.live])],
+            sort: [Media.Sort(key: .creationDate, ascending: false)]
+        )
+        _allMedia = FetchAllAssets(in: phAssetCollection, sort: [Media.Sort(key: .creationDate, ascending: false)])
+        phAssetCollectionWrapper = PHAssetCollectionWrapper(phAssetCollection: phAssetCollection)
     }
 }
 

Sources/MediaCore/API/Models/UniversalImage.swift

@@ -0,0 +1,16 @@
+//
+//  UniversalImage.swift
+//  MediaCore
+//
+//  Created by Christian Elies on 25.01.21.
+//
+
+#if canImport(UIKit)
+import UIKit
+
+public typealias UniversalImage = UIImage
+#elseif canImport(AppKit)
+import AppKit
+
+public typealias UniversalImage = NSImage
+#endif

Sources/MediaCore/API/Photo/Photo.swift

@@ -162,7 +162,6 @@ public extension Photo {
 }
 #endif
 
-#if !os(macOS)
 public extension Photo {
     /// Data representation of the receiver
     ///
@@ -198,7 +197,6 @@ public extension Photo {
         }
     }
 }
-#endif
 
 #if canImport(UIKit)
 public extension Photo {
@@ -248,18 +246,16 @@ public extension Photo {
                                      completion)
     }
 
-    #if canImport(UIKit)
-    /// Saves the given `UIImage` if the access to the photo library is allowed
+    /// Saves the given `UIImage` / `NSImage` if the access to the photo library is allowed
     ///
     /// - Parameters:
     ///   - image: the `UIImage` which should be saved
     ///   - completion: a closure which gets a `Result` (`Photo` on `success` or `Error` on `failure`)
     ///
-    static func save(_ image: UIImage, completion: @escaping ResultPhotoCompletion) {
+    static func save(_ image: UniversalImage, completion: @escaping ResultPhotoCompletion) {
         PHAssetChanger.createRequest({ assetChangeRequest.creationRequestForAsset(from: image) },
                                      completion)
     }
-    #endif
 
     /// Updates the `favorite` state of the receiver
     ///

Sources/MediaCore/API/PropertyWrappers/FetchAllAssets.swift

@@ -0,0 +1,77 @@
+//
+//  FetchAllAssets.swift
+//  MediaCore
+//
+//  Created by Christian Elies on 13.02.21.
+//
+
+import Photos
+
+/// Property wrapper for fetching all assets from the photo library.
+/// Fetches the assets lazily (after accessing the property).
+///
+@propertyWrapper
+public struct FetchAllAssets {
+    static var phAsset: PHAsset.Type = PHAsset.self
+
+    private var assetCollection: PHAssetCollection?
+    private let options = PHFetchOptions()
+    private let defaultSort: Media.Sort<Media.SortKey> = Media.Sort(key: .creationDate, ascending: false)
+
+    /// Wrapped array of `AnyMedia` instances.
+    public var wrappedValue: [AnyMedia] {
+        let result: PHFetchResult<PHAsset>
+        if let assetCollection = assetCollection {
+            result = Self.phAsset.fetchAssets(in: assetCollection, options: options)
+        } else {
+            result = Self.phAsset.fetchAssets(with: options)
+        }
+        var media: [AnyMedia] = []
+        result.enumerateObjects { asset, _, _ in
+            guard let anyMedia = asset.anyMedia else {
+                return
+            }
+            media.append(anyMedia)
+        }
+        return media
+    }
+
+    /// Initializes the property wrapper using a default sort descriptor
+    /// (sort by `creationDate descending`).
+    ///
+    public init() {
+        options.sortDescriptors = [defaultSort.sortDescriptor]
+    }
+
+    /// Initializes the property wrapper using the given sort descriptors
+    /// to define the `PHFetchOptions`.
+    ///
+    /// - Parameters:
+    ///   - assetCollection: limits the fetch to a specific asset collection, by default all assets in the library are taken into account.
+    ///   - sort: a set of `Sort<MediaSortKey>` for sorting the assets
+    ///   - fetchLimit: a maximum number of results to fetch, defaults to 0 (no limit)
+    ///   - includeAllBurstAssets: a Boolean value that determines whether the fetch result includes all assets from burst photo sequences, defaults to false
+    ///   - includeHiddenAssets: a Boolean value that determines whether the fetch result includes assets marked as hidden, defaults to false
+    ///
+    public init(
+        in assetCollection: PHAssetCollection? = nil,
+        sort: Set<Media.Sort<Media.SortKey>> = [],
+        fetchLimit: Int = 0,
+        includeAllBurstAssets: Bool = false,
+        includeHiddenAssets: Bool = false
+    ) {
+        self.assetCollection = assetCollection
+
+        var sortKeys = sort
+        sortKeys.insert(defaultSort)
+
+        if !sortKeys.isEmpty {
+            let sortDescriptors = sortKeys.map { $0.sortDescriptor }
+            options.sortDescriptors = sortDescriptors
+        }
+
+        options.fetchLimit = fetchLimit
+        options.includeAllBurstAssets = includeAllBurstAssets
+        options.includeHiddenAssets = includeHiddenAssets
+    }
+}

Sources/MediaCore/API/PropertyWrappers/FetchAssets.swift

@@ -12,12 +12,19 @@ import Photos
 ///
 @propertyWrapper
 public struct FetchAssets<T: MediaProtocol> {
+    private var assetCollection: PHAssetCollection?
     private let options = PHFetchOptions()
     private let mediaTypePredicate: NSPredicate = NSPredicate(format: "mediaType = %d", T.type.rawValue)
     private let defaultSort: Media.Sort<Media.SortKey> = Media.Sort(key: .creationDate, ascending: false)
 
     /// Wrapped array of objects conforming to the `MediaProtocol`
-    public var wrappedValue: [T] { (try? PHAssetFetcher.fetchAssets(options: options)) ?? [] }
+    public var wrappedValue: [T] {
+        if let assetCollection = assetCollection {
+            return (try? PHAssetFetcher.fetchAssets(in: assetCollection, options: options)) ?? []
+        } else {
+            return (try? PHAssetFetcher.fetchAssets(options: options)) ?? []
+        }
+    }
 
     /// Initializes the property wrapper using a default sort descriptor
     /// (sort by `creationDate descending`)
@@ -31,17 +38,23 @@ public struct FetchAssets<T: MediaProtocol> {
     /// to define the `PHFetchOptions`
     ///
     /// - Parameters:
+    ///   - assetCollection: limits the fetch to a specific asset collection, by default all assets in the library are taken into account.
     ///   - filter: a set of `MediaFilter` for filtering the assets
     ///   - sort: a set of `Sort<MediaSortKey>` for sorting the assets
     ///   - fetchLimit: a maximum number of results to fetch, defaults to 0 (no limit)
     ///   - includeAllBurstAssets: a Boolean value that determines whether the fetch result includes all assets from burst photo sequences, defaults to false
     ///   - includeHiddenAssets: a Boolean value that determines whether the fetch result includes assets marked as hidden, defaults to false
     ///
-    public init(filter: Set<Media.Filter<T.MediaSubtype>> = [],
-                sort: Set<Media.Sort<Media.SortKey>> = [],
-                fetchLimit: Int = 0,
-                includeAllBurstAssets: Bool = false,
-                includeHiddenAssets: Bool = false) {
+    public init(
+        in assetCollection: PHAssetCollection? = nil,
+        filter: Set<Media.Filter<T.MediaSubtype>> = [],
+        sort: Set<Media.Sort<Media.SortKey>> = [],
+        fetchLimit: Int = 0,
+        includeAllBurstAssets: Bool = false,
+        includeHiddenAssets: Bool = false
+    ) {
+        self.assetCollection = assetCollection
+
         if !filter.isEmpty {
             let predicates = filter.map { $0.predicate }
             options.predicate = NSCompoundPredicate(andPredicateWithSubpredicates: predicates + [mediaTypePredicate])

Sources/MediaCore/API/Protocols/AssetChangeRequest.swift

@@ -6,23 +6,18 @@
 //
 
 import Photos
-#if canImport(UIKit)
-import UIKit
-#endif
 
 /// Defines the requirements for an
 /// asset change request
 ///
 public protocol AssetChangeRequest: class {
     /// A placeholder object for the asset that the change request creates.
     var placeholderForCreatedAsset: PHObjectPlaceholder? { get }
-    #if canImport(UIKit)
     /// Creates a request for adding a new image asset to the Photos library.
     ///
     /// - Parameter image: An image.
     ///
-    static func creationRequestForAsset(from image: UIImage) -> Self
-    #endif
+    static func creationRequestForAsset(from image: UniversalImage) -> Self
     /// Creates a request for adding a new image asset to the Photos library,
     /// using the image file at the specified URL.
     ///

Tests/MediaTests/Models/Album/AlbumTests.swift

@@ -13,7 +13,7 @@ final class AlbumTests: XCTestCase {
     lazy var album = Album(phAssetCollection: mockAssetCollection)
 
     override func setUp() {
-        Album.phAsset = MockPHAsset.self
+        FetchAllAssets.phAsset = MockPHAsset.self
         PHAssetFetcher.asset = MockPHAsset.self
         MockPHAsset.fetchResult.mockAssets.removeAll()
         AlbumFetcher.assetCollection = MockPHAssetCollection.self