带有RxSwift的MVVM

Question

I'm trying to understand mvvm + RxSwift but I got some questions.

I'm currently using this approach which I'm not sure if is the right or can be better. How can I do to like grouping the methods, I mean, maybe something like doFirst(loading = true).doNext(getData).doLast(loading = false).catch(apiError) then subscribe to this event? It's possible?

ViewController:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        viewModel = UsersViewModel(apiService: apiService)
        configureBindings()
    }

    func configureBindings() {

        tableView.delegate = nil
        tableView.dataSource = nil

        viewModel.isLoading.bind(to: loadingView.rx.isAnimating)
            .disposed(by: disposeBag)

        viewModel.models
            .bind(to: tableView.rx.items(cellIdentifier: "userCell", cellType: UserCell.self)) {(_, _, cell) in
                print("Binding the cell items")
            }.disposed(by: disposeBag)

        tableView.rx.modelSelected(User.self).subscribe(onNext: { value in
            print(value)
        }).disposed(by: disposeBag)

        viewModel.error.filterNil().subscribe(onNext: { (err) in
            self.tableView.backgroundView = EmptyView(title: "No Users", description: "No users found")
            print("Showing empty view...")
            print(err)
        }).disposed(by: disposeBag)
    }
}

Then in my UsersViewModel:

class UsersViewModel {

    var models: Observable<[User]> {
        return modelsVariable.asObservable()
    }

    var isLoading: Observable<Bool> {
        return isLoadingVariable.asObservable()
    }

    var error: Observable<ApiError?> {
        return errorVariable.asObservable()
    }

    private var modelsVariable = BehaviorRelay<[User]>(value: [])
    private var isLoadingVariable = BehaviorRelay<Bool>(value: false)
    private var errorVariable = BehaviorRelay<ApiError?>(value: nil)

    // MARK: - Data Manager
    var apiService: API

    required init(apiService: API) {
        self.apiService = apiService

        isLoadingVariable.accept(true)

        apiService.GET(EndPoints.USER_LIST, type: Several<User>.self)
            .subscribe(onNext: { (model) in
                self.isLoadingVariable.accept(false)
                self.modelsVariable.accept(model.items)
            }, onError: { (err) in
                self.isLoadingVariable.accept(false)
                self.errorVariable.accept(err as? ApiError)
            })
    }
}

My 'GET' function just returns a Observable<Several<User>>.

Several:

struct Several {
    var items: [User]
}

Is there any improvements that I can do?

Answer 1

It's a little hard to understand what you're asking, but if you're concerned about the imperative nature of your init method, and want to wrap your API call into a continuous Observable sequence that can be repeated, you could do something like this:

class UsersViewModel {

    //...

    var fetchUsersObserver: AnyObserver<Void> {
        return fetchUsersSubject.asObserver()
    }

    //...

    private let fetchUsersSubject = PublishSubject<Void>()        
    private let disposeBag = DisposeBag()

    //...

    required init(apiService: API) {
        self.apiService = apiService
        bindFetchUsers()
    }

    private func bindFetchUsers() {
        fetchUsersSubject
            .asObservable()
            .do(onNext: { [weak self] _ in self?.isLoadingVariable.accept(true) })
            .flatMap(self.fetchUsers)
            .do(onNext: { [weak self] _ in self?.isLoadingVariable.accept(false) })
            .bind(to: modelsVariable)
            .disposed(by: disposeBag)
    }

    private func fetchUsers() -> Observable<[User]> {
        return apiService
            .GET(EndPoints.USER_LIST, type: Several<User>.self)
            .map { $0.items }
            .catchError { [weak self] error in
                self?.errorVariable.accept(error as? ApiError)
                return .just([])
            }
    }
}

Then, you need only bind a control to this AnyObserver , or send it an event manually:

func configureBindings() {
    // from a control, such as UIButton
    someButton
        .rx
        .tap
        .bind(to: viewModel.fetchUsersObserver)
        .disposed(by: disposeBag)

    // manually
    viewModel.fetchUsersObserver.onNext(())
}

Footnote 1: I typically like to make my view models struct s so that I don't have to worry about all the [weak self] statements.

Footnote 2: Notice how the fetchUsers() function catches any errors thrown and does not let the error propagate to the outer Observable sequence. This is important because if this outer Observable emits an error event, it can never emit another next event.