RxSwift Simple background task example

Question

I have a method as following

public static func createAlbum(named: String, completion: (album: PHAssetCollection?) -> ()) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)) {

      }) { success, error in


                completion(album: album)
          }
       }
}

How can i do the background task using RxSwift

complete code

https://gist.github.com/sazzadislam-dsi/d347909d284674c936e397ac423703cf

Answer 1

@XFreire answer is right, but for Swift 3 and RxSwift 3.1.0 I would add an extension to PHAssetCollection:

extension Reactive where Base: PHPhotoLibrary {
    func createAlbum(named name: String) -> Observable<PHAssetCollection?> {
        return Observable.create { observer in
            self.base.performChanges({ 
                // ...
            }, completionHandler: { success, error in
                if success {
                    // Your success logic goes here
                    let album = PHAssetCollection()
                    // ...
                    observer.on(.next(album))
                    observer.on(.completed)
                } else if let error = error {
                    observer.on(.error(error))
                } else {
                    // Your error type
                    observer.on(.error(MyErrors.Unknown))
                }
            })

            return Disposables.create()
        }
    }
}

Then you can use the method like this:

PHPhotoLibrary
    .shared().rx.createAlbum(named: "MyAlbum")
    .subscribe(onNext: { collection in
        // ...
    }, onError: { error in
        // ...
    })
    .addDisposableTo(disposeBag)

Answer 2

First, your function must return an Observable.

public static func rx_createAlbum(named: String)-> Observable<PHAssetCollection?>

Second, when there is an error, your function will return onError, and when success is true, your function will return onNext(album) and onCompleted().

Code:

public static func rx_createAlbum(named: String)-> Observable<PHAssetCollection?> {
    return Observable.create { observer in

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)) {

            // ...

            }) { success, error in

                if error {
                    observer.onError(error)
                }
                else {
                    var album: PHAssetCollection?
                    if success {
                        let collectionFetchResult = PHAssetCollection.fetchAssetCollectionsWithLocalIdentifiers([placeholder?.localIdentifier ?? ""], options: nil)
                        album = collectionFetchResult.firstObject as? PHAssetCollection

                    }

                    observer.onNext(album)
                    observer.onCompleted()
                }

            }
        }

        return Disposables.create()

    }
}