RxSwift Reload Tableview

Question

let officialAccountObservable : Observable<[SearchUser]> = SearchAPI.sharedAPI.suggestAccounts() 

     officialAccountObservable.bind(to: tableView.rx.items(cellIdentifier: "followcell", cellType: FollowCell.self)) { 
      (index, user , cell) in 
      if user.profileImagePath.isEmpty == false { 
       cell.profile.af_setImage(withURL: URL.init(string: user.profileImagePath)!) 
      }else { 
       cell.profile.image = UIImage.init(named: "icon_user_03") 
      } 
      cell.nickName.text = user.nickName 

      cell.follow.rx.tap 
       .debounce(0.3, scheduler: MainScheduler.instance) 
       .subscribe(onNext: { 
        [unowned self] in 
        cell.setFollow(user: user, completion: { (result) in 
         if(result == true){ 

         } 
        }) 
       }).addDisposableTo(self.disposeBag) 
     }.addDisposableTo(disposeBag) 

func suggestAccounts() -> Observable<[SearchUser]> { 

    let uri = Constants.VyrlSearchURL.suggestUsers 

    return Observable.create { observer in 
     let request = Alamofire.request(uri, method: .get, parameters: nil, encoding: JSONEncoding.default, headers: Constants.VyrlAPIConstants.getHeader()).responseArray { (response: DataResponse<[SearchUser]>) in 
      let value = response.result.value 

      observer.onNext(value!) 
      observer.onCompleted() 
     } 

     return Disposables.create(with: request.cancel) 
    } 
} 

Ich möchte die Tabellenansicht in Code (result == true) Für reload nachladen, OfficialAccountObservable empfangen werden müssen. Mein Code ist überall und ich frage mich, wie ich es in diesem Zustand aktualisieren kann.

Answer 1

Ich empfehle Ihnen, einen Refreshable Dekorateur zu erstellen.

class Refreshable<T>: ObservableType { 

    typealias E = T 
    func subscribe<O:ObserverType>(_ observer: O) -> Disposable where O.E == E { 
     return refreshMeans 
      .flatMapLatest{ [unowned self] in 
       return self.origin.asObservable() 
      } 
      .subscribe(observer) 
    } 

    private let disposeBag = DisposeBag() 
    private let origin: Observable<T> 
    init(origin: Observable<T>, updatedOn: Observable<Void> = .never()) { 
     self.origin = origin 
     updatedOn.bind(to: refreshMeans).disposed(by: disposeBag) 
    } 

    private let refreshMeans = BehaviorSubject<Void>(value:()) 

    func refresh() { 
     refreshMeans.on(.next()) 
    } 

} 

wickeln Ihre officialAccountObservable in ein Refreshable:

let officialAccountObservable : Refreshable<[SearchUser]> = Refreshable(origin: SearchAPI.sharedAPI.suggestAccounts()) 

und Refresh aufrufen, wenn Sie es aktualisieren müssen:

if(result == true){ 
    officialAccountObservable.refresh() 
} 

Answer 2

AFAIK ist dies der normale Weg, dies zu tun -

let source = PublishSubject<Observable<[SearchUser]>>() 
let officialAccountObservable: Observable<[SearchUser]> = source.switchLatest() 
source.onNext(suggestAccounts()) // every call will refresh your table 

Answer 3

Ich denke, das Problem, das Sie gerade haben, ist, dass wenn Sie das Observable erstellen, das den Alamofire-Aufruf bewirkt, wird es nur einmal ausgeführt, da Sie keine Möglichkeit haben, einen weiteren Anruf zu tätigen.

Was Sie tun möchten, ist etwas wie Maxim Volgin vorgeschlagen: Verwenden Sie ein Thema.

Ein Subjekt ist gleichzeitig ein Eingang und ein Ausgang. In Ihrem Fall wären die Daten die Daten für Ihre Tabellenansicht und Sie würden sie wie gewohnt binden.

Verwenden Sie dann den Pull zum Aktualisieren oder einen anderen geeigneten Mechanismus zum erneuten Laden, um den Web-Service aufzurufen und die Ergebnisse dem Subjekt zu veröffentlichen (was dann Ihre Tabellenansicht aktualisiert).

Denken Sie daran, dass die Subjekte auch die Aufrufe onError und onComplete für den Beobachter auffüllen, also stellen Sie sicher, dass Sie mögliche Fehler in Ihrem Web-Service-Aufruf behandeln, bevor Sie das Ergebnis an den Betreff senden.

fand ich diese Seite unglaublich hilfreich, um ein besseres Verständnis für RxSwift zu bekommen: http://swiftpearls.com/

Sie sollten check it out. Vor allem der RxSwift für Dummies ist großartig, um ein grundlegendes Verständnis dafür zu bekommen, wie die Dinge funktionieren sollen.