App Academy

PhotoKit and PhotosUI are at the heart of iOS photo management, providing unparalleled access to, display of, and interaction with photo assets. These frameworks are indispensable for anyone aiming to replicate the functionality of the native Photos app or to innovate on photo library access within their iOS and macOS applications.

The Demo App: A Comprehensive Guide to Photos

This Swift UI demo app serves as an essential tool for demystifying photo library management. It showcases the capabilities of PhotosKit and PhotosUI, offering functionalities for browsing albums, viewing photos, and marking favorites. This app is not only a demonstration of technical implementation but also a valuable resource for developers looking to grasp and apply these frameworks effectively.

Deep Dive into Assets

Understanding the role of assets in photo management is crucial. The PHAsset class is more than a representation of images or videos; it encapsulates extensive metadata, such as creation dates and locations. This depth of information transforms PHAsset into a powerful tool for developers, far beyond a mere media loader.

struct AlbumView: View {
    let asset: PHAsset?
    ...
}

The framework, with PHAsset at its core, manages a rich dataset for each piece of media—ranging from geocoded location data to the asset’s favorite status and even encompassing LivePhotos and videos. This metadata depth transforms PHAsset into a versatile and powerful tool in the developer’s toolkit, far beyond a simple image loader.

PHAsset stands immutable, serving as a read-only reference to the media item’s metadata in the Photos library. It doesn’t house the media file itself but rather provides all the necessary information to retrieve it, including a wealth of metadata that makes it incredibly resourceful for any application working with photos and videos.

Furthermore, when dealing with collections of assets, PHAssetCollection comes into play, grouping assets in a manner that mirrors the organisation within the Photos app itself.

PHAsset and PHAssetCollection enable developers to access, display, and interact with the photo library’s contents, providing a solid foundation for building sophisticated photo management features in their applications.

E.g: AlbumViewModel

Asset Data Models and Efficient Data Handling

The PHFetchResult component is a linchpin in managing photo and album assets, functioning as an intelligent array that streamlines data fetching and caching. This not only enhances the app’s responsiveness but also provides a seamless user experience.

Here’s a closer look at how PHFetchResult elevates our app’s functionality:

@Published var allPhotos = PHFetchResult<PHAsset>()
@Published var smartAlbums = PHFetchResult<PHAssetCollection>()
@Published var userCollections = PHFetchResult<PHAssetCollection>()

   func fetchAssets() {
        let allPhotosOptions = PHFetchOptions()
        allPhotosOptions.sortDescriptors = [
            NSSortDescriptor(key: "creationDate", ascending: false)
        ]
        
        allPhotos = PHAsset.fetchAssets(with: allPhotosOptions)
        smartAlbums = PHAssetCollection.fetchAssetCollections(with: .smartAlbum, subtype: .albumRegular, options: nil)
        userCollections = PHAssetCollection.fetchAssetCollections(with: .album, subtype: .albumRegular, options: nil)
    }

At first glance, PHFetchResult might seem like a complex entity, but it can be thought of as an intelligent array. It shares common array functionalities, such as accessing its elements via count or index(of:), but with added capabilities tailored for working with the Photos library.

What sets PHFetchResult apart is its ability to manage data fetching, caching, and re-fetching by having the CoreData support behind the scenes, seamlessly, ensuring your app interacts with the photo library in the most efficient manner possible.

These PHFetchResult properties within AlbumViewModel act as dynamic containers for various asset types—whether individual photos (PHAsset) or groups of assets categorized into smart albums and user collections (PHAssetCollection). This setup not only streamlines the way the app accesses and displays photo library content but also minimizes redundant data fetching. The framework caches previously fetched results, reducing the need to repeatedly query the same assets.

It exemplifies efficient data handling, ensuring that the app remains responsive and data-rich, offering users a seamless experience as they navigate through their photos.

Fetching Assets and Asset Collections

Efficiently managing a vast photo library is made possible through strategic data fetching. By utilizing PHFetchOptions, the app ensures a curated and chronological viewing experience. This approach not only simplifies navigation but also highlights the framework’s flexibility in handling both individual assets and collections.
Let’s explore how this is achieved:

func fetchAssets() {
    let allPhotosOptions = PHFetchOptions()
    allPhotosOptions.sortDescriptors = [
        NSSortDescriptor(key: "creationDate", ascending: false)
    ]
    
    allPhotos = PHAsset.fetchAssets(with: allPhotosOptions)
    smartAlbums = PHAssetCollection.fetchAssetCollections(with: .smartAlbum, subtype: .albumRegular, options: nil)
    userCollections = PHAssetCollection.fetchAssetCollections(with: .album, subtype: .albumRegular, options: nil)
}

It uses PHFetchOptions to sort photo assets by creation date, ensuring a chronological viewing experience. It fetches not only individual photos using PHAsset.fetchAssets but also smart albums and user collections through PHAssetCollection.fetchAssetCollections. Smart albums like “Favorites” and “Recents” are system-generated, while user collections are manually created by the user. This strategy highlights the app’s efficient use of PhotosKit for a well-organized photo library exploration.

Modifying Asset Metadata for Personalization

The app introduces interactivity by allowing users to modify asset metadata, such as marking photos as favorites, directly reflecting users’ preferences and interactions.

func toggleFavorite() {
    PHPhotoLibrary.shared().performChanges({
        let request = PHAssetChangeRequest(for: self.asset)
        request.isFavorite = !self.isFavorite
    })
}

This function demonstrates the practical application of metadata modification, making the photo library a more personalized space.

Fetching Images from Assets

Displaying images from PHAsset instances is a key feature, achieved through requests to PHImageManager.

PHImageManager.default().requestImage(for: asset, targetSize: targetSize, contentMode: .aspectFit, options: options) { image, _ in
    self.image = Image(uiImage: image)
}

This code snippet is pivotal for visualising photos within the app, showcasing the seamless bridge between asset data and UI representation.

Performance Considerations and User Experience

Optimizing performance through intelligent data fetching and caching ensures a smooth user experience, even with extensive photo libraries. Observing library changes and dynamically updating the UI keeps the app current and responsive.

Observing Changes in the Photo Library

The app remains responsive to changes in the photo library, thanks to its registration as a change observer.

PHPhotoLibrary.shared().register(self)

By monitoring modifications, the app ensures that the displayed content is always up-to-date, reflecting any additions, deletions, or changes made by the user.

override init() {
    PHPhotoLibrary.shared().register(self)
}

deinit {
PHPhotoLibrary.shared().unregisterChangeObserver(self)
}

Properly managing the lifecycle of observers is crucial for maintaining app performance and ensuring timely updates.

To ensure the app remains responsive and current with the photo library’s state, it implements PHPhotoLibraryChangeObserver. This mechanism is crucial for detecting changes—like marking a photo as a favorite—and updating the app’s content accordingly.

extension AlbumViewModel: PHPhotoLibraryChangeObserver {
    func photoLibraryDidChange(_ changeInstance: PHChange) {
        DispatchQueue.main.sync {
            if let changeDetails = changeInstance.changeDetails(for: allPhotos) {
                allPhotos = changeDetails.fetchResultAfterChanges
            }

            if let changeDetails = changeInstance.changeDetails(for: smartAlbums) {
                smartAlbums = changeDetails.fetchResultAfterChanges
            }

            if let changeDetails = changeInstance.changeDetails(for: userCollections) {
                userCollections = changeDetails.fetchResultAfterChanges
            }
        }
    }
}

In this setup, AlbumViewModel listens for any updates to the photo library. When changes occur—such as an asset being marked as a favorite—the relevant collections (allPhotos, smartAlbums, userCollections) are updated to reflect these changes, ensuring the app’s view remains accurate and up-to-date. This approach exemplifies how developers can maintain synchronization between the app’s data model and the dynamic content of the iOS photo library.

References

• Code Example
• Documentation: https://developer.apple.com/documentation/photokit
• YPImagePicker