How do I unsubscribe from an observable? - swift

Question

If I have something that looks like this:
func foo() -> Observable<Foo> {
return Observable.create { observer in
// ...
}
}
func bar() {
foo().observeOn(MainScheduler.instance)
.subscribeNext {
// ...
}
.addDisposableTo(disposeBag)
}
If I want to unsubscribe from the observable later on in bar, how would I do that?
Update
I'm aware I can call dispose, but according to the RxSwift docs:
Note that you usually do not want to manually call dispose; this is only educational example. Calling dispose manually is usually a bad code smell.
So is unsubscribe just not implemented? I've gone spelunking through the RxSwift code, and to the extent that I can understand what's going on, it doesn't look like the Disposable that is returned from the subscribe methods is ever anything with useful functionality (other than disposing).

Answer 1

You add the Observable returned by foo to disposeBag. It disposes the subscription when it's deallocated.
You can "manually" release the disposeBag by calling
disposeBag = nil
somewhere in your class.
After question edit: You want to selectively unsubscribe from some Observables, probably when some conditions are met. You can use another Observable which represents these conditions and use takeUntil operator to cancel the subscription as needed.
//given that cancellingObservable sends `next` value when the subscription to `foo` is no longer needed
foo().observeOn(MainScheduler.instance)
.takeUntil(cancellingObservable)
.subscribeNext {
// ...
}
.addDisposableTo(disposeBag)

Answer 2

Details
Xcode Version 11.0 (11A420a), iOS 13, Swift 5
RxSwift v 5.0.1
Solution
if you want to unsubscribe from observable you just need to reset disposeBag
// Way 1
private lazy var disposeBag = DisposeBag()
//...
disposeBag = DisposeBag()
// Way 2
private lazy var disposeBag: DisposeBag? = DisposeBag()
//...
disposeBag = nil
Full sample
import UIKit
import RxSwift
class Service {
private lazy var publishSubject = BehaviorSubject<Int>(value: count)
private lazy var count = 0
var counter: Observable<Int> { publishSubject }
func unsubscribeAll() { publishSubject.dispose() }
func increaseCounter() {
count += 1
publishSubject.onNext(count)
}
}
class ViewController: UIViewController {
private lazy var service = Service()
private lazy var disposeBag = DisposeBag()
private weak var navigationBar: UINavigationBar!
override func viewDidLoad() {
super.viewDidLoad()
setupNavigationBar()
subscribeToObservables()
}
}
// MARK: Work with subviews
extension ViewController {
private func setupNavigationBar() {
let navigationBar = UINavigationBar()
view.addSubview(navigationBar)
navigationBar.translatesAutoresizingMaskIntoConstraints = false
navigationBar.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor).isActive = true
navigationBar.leftAnchor.constraint(equalTo: view.safeAreaLayoutGuide.leftAnchor).isActive = true
navigationBar.rightAnchor.constraint(equalTo: view.safeAreaLayoutGuide.rightAnchor).isActive = true
let navigationItem = UINavigationItem()
var barButtons = [UIBarButtonItem]()
barButtons.append(createNavigationItemButton(title: "subscr.", action: #selector(subscribeButtonTapped)))
barButtons.append(createNavigationItemButton(title: "unsubscr.", action: #selector(unsubscribeButtonTapped)))
navigationItem.leftBarButtonItems = barButtons
navigationItem.rightBarButtonItem = createNavigationItemButton(title: "+", action: #selector(increaseCounterNavigationItemButtonTapped))
navigationBar.items = [navigationItem]
self.navigationBar = navigationBar
}
private func createNavigationItemButton(title: String, action: Selector?) -> UIBarButtonItem {
return UIBarButtonItem(title: title, style: .plain, target: self, action: action)
}
}
// MARK: Work with observers
extension ViewController {
private func subscribeToObservables() {
service.counter.subscribe { [weak self] value in
guard let value = value.element,
let navigationItem = self?.navigationBar?.items?.first else { return }
navigationItem.title = "Counter \(value)"
print(value)
}.disposed(by: disposeBag)
}
private func unsubscribeFromObservables() { disposeBag = DisposeBag() }
}
// MARK: Button actions
extension ViewController {
#objc func increaseCounterNavigationItemButtonTapped(_ source: UIBarButtonItem) { service.increaseCounter() }
#objc func subscribeButtonTapped(_ source: UIBarButtonItem) { subscribeToObservables() }
#objc func unsubscribeButtonTapped(_ source: UIBarButtonItem) { unsubscribeFromObservables() }
}
Screenshot of the sample app

Answer 3

Since above answer focuses on unsubscribing to the specific or particular observable, I will talk about unsubscribing all the observable together correctly and efficiently.
How to Subscribe:
this.myVariable$.pipe(takeUntil(this.ngUnsubscribe)).subscribe(value => {
// Do the thing you want to do after there is change in myVariable
});
How to Unsubscribe:
ngOnDestroy() {
this.ngUnsubscribe.next();
this.ngUnsubscribe.complete();
}
using the above ngOnDestroy you can unsubscribe from all the observable.

Answer 4

You could just override the disposeBag with a fresh one. If you need other observables to stay alive, create multiple disposeBags. If you think about it this is what happens when a class get's deallocated → Its disposeBag gets deallocated, releasing all subscriptions that class had.
Example:
Note: The example just shows the principle, I don't know why you would ever build something specifically as I have below. That being said, it may be interesting for clearing cells with prepareForReuse, depending on your architecture.
class MyClass {
var clearableDisposeBag = DisposeBag()
let disposeBag = DisposeBag()
let dependencies: Dependencies
let myObservable: MyObservable
var myOtherObservable: MyOtherObservable?
init(dependencies: Dependencies) {
self.dependencies = dependencies
self.myObservable = dependencies
.myObservable
.subscribe(onNext: doSomething)
.disposed(by: disposeBag)
}
private func doSomething() {/*...*/}
private func doSomethingElse() {/*...*/}
private func subscribeToChanges() {
/// clear previous subscription
clearableDisposeBag = DisposeBag()
/// subscribe again
myOtherObservable = dependencies
.myOtherObservable
.subscribe(onNext: doSomethingElse)
.disposed(by: clearableDisposeBag)
}
}

Answer 5

What I did was creating another DisposeBag
var tempBag = DisposeBag()
fun bar() {
foo().subscribe().addDisposable(tempBag)
}
so when you want to dispose you can just do tempBag = nil when you want to release. while you still have another DisposeBag that keep other disposables alive.