PhotoKit — vad är det, nyckelbegrepp och PHAsset

Vad är PhotoKit?

PhotoKit — Apples ramverk (introducerat i iOS 8, macOS 10.11), som tillhandahåller ett objektorienterat API för att arbeta med systemets mediebibliotek. Till skillnad från AssetsLibrary behandlar PhotoKit mediebiblioteket som en databas: frågor returnerar objekt PHAsset, PHCollection, PHCollectionList, som representerar innehåll och lagringsstruktur.

PhotoKit stöder alla mediatyper: foton (JPEG, HEIF, RAW), videor (MOV, MP4), Live Photos och serietagningar. Ramverket hanterar automatiskt iCloud-synkronisering: om en bild lagras i iCloud begär PhotoKit den via nätverket och rapporterar förlopp via PHImageRequestOptions.progressHandler.

Nyckelfunktionen i PhotoKit — datamodell baserad på PHObject med en lokal identifierare (localIdentifier), som förblir stabil mellan sessioner. Detta gör det möjligt att spara referenser till mediaobjekt och återställa dem efter omstart av appen utan en ny fråga.

Hur PhotoKit fungerar: datamodell och frågor

PhotoKit är byggt på tre nivåer: datamodell (PHObject), frågor (PHFetchResult) och ändringar (PHPhotoLibrary.performChanges). Datamodellen är hierarkisk: PHAsset (foto/video) finns inuti PHAssetCollection (album), album grupperas i PHCollectionList (mapp).

Utföra frågor

Frågor utförs via PHAsset.fetchAssets och PHAssetCollection.fetchAssetCollections. Alla fetch-metoder är synkrona och returnerar PHFetchResult, vars objekt omedelbart utför frågan mot mediebibliotekets databas. PHFetchResult stöder snabb åtkomst via index (object(at:)) och uppräkning via enumerateObjects.

• fetchAssets(with:options:) — fråga efter alla media med filtrering efter typ, datum, album
• fetchAssetCollections(with:subtype:options:) — fråga efter album och mappar
• fetchAssets(in:options:) — fråga efter media inom ett specifikt album

PHFetchOptions

PHFetchOptions — objekt för konfiguration av frågan: sortering (sortDescriptors), predikat (predicate), inkludering av dolda och borttagna media (includeHiddenAssets, includeAllBurstAssets). Fetch-alternativ möjliggör filtrering efter mediatyp: PHAssetMediaType.image, .video, .audio.

PhotoKits huvudklasser

PhotoKit innehåller en uppsättning klasser för åtkomst, frågor och ändring av mediebiblioteket. Att förstå var och en är nödvändigt för effektivt arbete med ramverket.

PHAsset

PHAsset — oföränderligt objekt som representerar ett enskilt mediainnehåll. Innehåller metadata: mediaType, mediaSubtypes, creationDate, location, pixelWidth, pixelHeight, duration (för video), isFavorite, burstIdentifier. LocalIdentifier — stabil textnyckel, tillgänglig även efter omstart av appen.

PHAssetCollection

PHAssetCollection — mediegrupp: systemalbum (Recents, Favorites, Selfies, Screenshots), användaralbum eller Moments (automatiskt grupperade efter tid och plats). Attribut: localizedTitle, assetCollectionType, assetCollectionSubtype, startDate, endDate.

PHCollectionList

PHCollectionList — mapp som innehåller album (PHAssetCollection) eller andra mappar. Används sällan, främst för att visa hierarki i användargränssnittet.

PHImageManager och cachning

PhotoKit returnerar inte UIImage direkt från PHAsset — du måste begära bilden via PHImageManager. Detta garanterar att bilden laddas med hänsyn till iCloud, cachning och önskad storlek.

PHImageManager stöder tre leveranslägen: opportunistic (först förminskad version, sedan full), highQualityFormat (endast full kvalitet) och fastFormat (snabbaste tillgängliga versionen). För samlingar använd alltid PHCachingImageManager med förladdning av bilder för synliga celler.

Exempel på PhotoKit-användning i Swift

PhotoKit används för att skapa anpassade gallerier, redigerare och appar för att arbeta med media. Låt oss titta på tre viktiga scenarier.

Fråga efter alla foton från mediebiblioteket

PHAsset.fetchAssets med PHFetchOptions och sortering efter skapelsedatum — grundläggande fråga för att bygga ett anpassat fotogalleri. PHFetchResult stöder lazy-loading och strömmande åtkomst.

let options = PHFetchOptions()
options.sortDescriptors = [NSSortDescriptor(
    key: "creationDate",
    ascending: .false
)]
options.predicate = NSPredicate(
    format: "mediaType == %d",
    PHAssetMediaType.image.rawValue
)

let allPhotos = PHAsset.fetchAssets(with: options)
print("Hittade \(allPhotos.count) foton")

allPhotos.enumerateObjects { asset, index, stop in
    print("Foto \(index): \(asset.localIdentifier)")
}

PHFetchResult — trådsäker behållare. Åtkomst till objekt via index via object(at:) blockerar inte UI, men bildbegäran via PHImageManager måste utföras asynkront.

Ladda bild med cachning

PHCachingImageManager — underklass till PHImageManager med metoderna startCachingImages och stopCachingImages för förladdning. Används i UICollectionView för mjuk scrollning.

let cachingManager = PHCachingImageManager()
let targetSize = CGSize(width: 200, height: 200)

// Förladdning för synliga celler
cachingManager.startCachingImages(
    for: visibleAssets,
    targetSize: targetSize,
    contentMode: .aspectFill,
    options: nil
)

// Bildbegäran via PHImageRequestOptions med iCloud fallback
let requestOptions = PHImageRequestOptions()
requestOptions.deliveryMode = .opportunistic
requestOptions.isNetworkAccessAllowed = .true
requestOptions.progressHandler = { progress, error, stop, info in
    DispatchQueue.main.async {
        print("Laddar ner från iCloud: \(progress * 100)%")
    }
}

let requestID = cachingManager.requestImage(
    for: asset,
    targetSize: targetSize,
    contentMode: .aspectFill,
    options: requestOptions
) { image, info in
    print("Bild mottagen: \(image?.size ?? .zero)")
}

Redigera mediebiblioteket: lägg till i favoriter

Ändringar i mediebiblioteket utförs via PHPhotoLibrary.shared().performChanges inuti changeRequest-blocket. Alla operationer grupperas och tillämpas transaktionsmässigt.

PHPhotoLibrary.shared().performChanges {
    let changeRequest = PHAssetChangeRequest(for: asset)
    changeRequest.isFavorite = .true
} completionHandler: { success, error in
    if success {
        print("Lades till i favoriter")
    }
}

Ändringar och observation via Change Tracking

PhotoKit tillhandahåller en mekanism för observation av ändringar i mediebiblioteket via protokollet PHPhotoLibraryChangeObserver. Vid varje ändring (skapa, ta bort, redigera) anropas metoden photoLibraryDidChange med ett PHChange-objekt.

PHChange innehåller changeDetails för varje frågetyp: PHFetchResultChangeDetails med removedIndexes, insertedIndexes, changedIndexes. Detta gör det möjligt att tillämpa ändringar i UI med animering: performBatchUpdates med move, insert, delete för UICollectionView.

class PhotosViewController: UIViewController {
    var fetchResult: PHFetchResult>PHAsset>?

    override func viewDidLoad() {
        super.viewDidLoad()
        PHPhotoLibrary.shared().register(self)
    }

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

extension PhotosViewController: PHPhotoLibraryChangeObserver {
    func photoLibraryDidChange(_ changeInstance: PHChange) {
        guard let fetchResult,
              let details = changeInstance.changeDetails(for: fetchResult)
        else { return }

        DispatchQueue.main.async {
            self.fetchResult = details.fetchResultAfterChanges
            // Tillämpa ändringar på collectionView
        }
    }
}

RAW-redigering och tillägg

PhotoKit stöder mediaredigering via mekanismen PHContentEditingInput och PHContentEditingOutput. Appen begär editingInput med originaldata, tillämpar ändringar och sparar resultatet via editingOutput. Ramverket bevarar automatiskt originalet, vilket gör att användaren kan ångra ändringar genom att återställa till original.

RAW-foton (DNG, CR2, NEF) stöds via PHAssetResourceManager, som ger åtkomst till den ursprungliga RAW-filen. För RAW-bearbetning rekommenderas att använda CoreImage med filtret CIRAWFilter, som stöder justering av temperatur, exponering och skärpa. PhotoKit stöder även redigeringstillägg via Photo Editing Extension (iOS) — appen kan anropas från systemredigeraren för att bearbeta valt foto eller video.

Optimering av arbete med PhotoKit

PhotoKit — ett kraftfullt men resurskrävande ramverk. Felaktig användning kan leda till fördröjningar vid scrollning och överdriven minnesanvändning. Följ rekommendationerna för optimal prestanda.

• Använd PHCachingImageManager för samlingar — förladdning av bilder för synliga +-1 skärms celler eliminerar fördröjningar vid scrollning
• Ställ in targetSize — begär aldrig PHImageManagerMaximumSize för miniatyrer. Använd en storlek lika med cellens fysiska storlek multiplicerad med skärmens scale
• Avbryt frågor vid återanvändning av cell — spara PHImageRequestID och anropa cancelImageRequest i prepareForReuse
• Begränsa iCloud-frågor — vid snabb scrollning ställ in isNetworkAccessAllowed = false och ladda iCloud-foton endast vid stopp
• Cacha PHFetchResult — upprepade fetchAssets med samma alternativ returnerar en ny PHFetchResult. Spara resultatet i en egenskap och uppdatera via Change Observer

PHLivePhoto — kräver en separat fråga via PHLivePhoto.request(with:targetSize:contentMode:options:resultHandler:). Begär inte Live Photo för celler där endast foto visas — använd PHLivePhotoBadge för indikation.