     func observeAlbums(handler: @escaping ([PhotoLibraryAlbum]) -> ()) {
         executeAfterSetup {
             self.onAlbumsChange = handler
-            handler(self.fetchResult?.albums ?? [])
+            handler(self.fetchResults.flatMap { $0.albums } ?? [])
         }
     }
     

        fetchResultQueue.async {
            
            let options = self.phFetchOptions()
            
            let assetCollectionsFetchResult = PHAssetCollection.fetchAssetCollections(
                with: .album,
                subtype: .any,
                options: options
            )
            
            var albums = [
                self.photoLibraryAlbum(
                    identifier: "ru.avito.Paparazzo.PhotoLibraryAlbum.identifier.allPhotos",
                    title: localized("All photos"),
                    fetchResult: PHAsset.fetchAssets(with: .image, options: options)
                )
            ]
            
            assetCollectionsFetchResult.enumerateObjects(using: { assetCollection, _, _ in
                albums.append(self.photoLibraryAlbum(from: assetCollection, fetchOptions: options))
            })
            
            self.fetchResult = PhotoLibraryFetchResult(albums: albums, phFetchResult: assetCollectionsFetchResult)
            self.photoLibrary.register(self)

            DispatchQueue.main.async(execute: completion)

    func photoLibraryDidChange(_ change: PHChange) {
        
        fetchResultQueue.async {
            guard self.fetchResults.count > 0 else { return }
            
            var needToReportAlbumsChange = false
            
            self.fetchResults.forEach { fetchResult in
                
                // We need to enumerate all the fetched albums:
                // 1) to keep their content in sync with photo library without refething
                // 2) to check if album cover has changed
                fetchResult.albums = fetchResult.albums.map { album in
                    guard let changeDetails = change.changeDetails(for: album.fetchResult) else { return album }
                    
                    var album = album
                    album.fetchResult = changeDetails.fetchResultAfterChanges
                    
                    let lastAssetImageSource = album.fetchResult.lastObject.flatMap { PHAssetImageSource(asset: $0) }
                    
                    if album.coverImage != lastAssetImageSource {
                        // Album cover need to be changed
                        album = album.changingCoverImage(to: lastAssetImageSource)
                        needToReportAlbumsChange = true
                    }
                    
                    if album == self.observedAlbum {
                        // Report changes in the observed album
                        DispatchQueue.main.async {
                            self.callObserverHandler(changes: changeDetails)
                        }
                    }
                    
                    return album
                }
                
                if let changeDetails = change.changeDetails(for: fetchResult.phFetchResult) {
                    
                    let fetchOptions = self.phFetchOptions()
                    
                    fetchResult.phFetchResult = changeDetails.fetchResultAfterChanges
                    
                    changeDetails.removedIndexes?.reversed().forEach { index in
                        fetchResult.albums.remove(at: index + 1)  // +1, because album 0 is "All photos"
                    }
                    
                    changeDetails.insertedIndexes?.enumerated()
                        .map { ($1, changeDetails.insertedObjects[$0]) }
                        .forEach { insertionIndex, assetCollection in
                            let album = self.photoLibraryAlbum(from: assetCollection, fetchOptions: fetchOptions)
                            fetchResult.albums.insert(album, at: insertionIndex + 1)  // +1, because album 0 is "All photos"
                    }
                    
                    // Updates: it's not possible to rename albums in iOS as for now
                    // Moves: seems like iOS doesn't generate them for photo albums
                    
                    needToReportAlbumsChange = true
                }
            }
            
            if needToReportAlbumsChange {
                let albums = self.fetchResults.flatMap { $0.albums }
                DispatchQueue.main.async {
                    self.onAlbumsChange?(albums)
                }
            }
        }
