RxSwift verfolgt mehr Observablen Aktivität

Question

Ich habe folgenden Code:

let categoriesRequest = APIService.MappableRequest(Category.self, resource: .categories) 
let categoriesRequestResult = api.subscribeArrayRequest(categoriesRequest, from: actionRequest, disposedBy: disposeBag) 

let newCategories = categoriesRequestResult 
    .map { $0.element } 
    .filterNil() 

let categoriesUpdateData = DatabaseService.UpdateData(newObjectsObservable: newCategories) 
let categoriesDatabaseResult = database.subscribeUpdates(from: categoriesUpdateData, disposedBy: disposeBag) 

let latestTopicsRequest = APIService.MappableRequest(Topic.self, resource: .latestTopics) 
let latestTopicsRequestResult = api.subscribeArrayRequest(latestTopicsRequest, from: actionRequest, disposedBy: disposeBag) 

let newLastTopics = latestTopicsRequestResult 
    .map { $0.element } 
    .filterNil() 

let latestTopicsUpdateData = DatabaseService.UpdateData(newObjectsObservable: newLastTopics) 
let latestTopicsDatabaseResult = database.subscribeUpdates(from: latestTopicsUpdateData, disposedBy: disposeBag) 

Es gibt zwei Anforderungen, die aus dem gleichen beginnt Gegenstand nach diesen Anfragen actionRequest und zwei Datenbank-Updates veröffentlichen.

Ich brauche etwas wie isActive, bool Wert, der true zurückgibt, wenn eine der API/Datenbank-Task in Bearbeitung ist. Ist es möglich? Ich sah ActivityIndicator in RxSwift Beispiele, aber ich weiß nicht, ist es möglich, es in meinem Fall zu verwenden.

-Code von api/Datenbank bei Bedarf:

// API 
func subscribeArrayRequest<T>(_ request: MappableRequest<T>, 
           from triggerObservable: Observable<Void>, 
           disposedBy disposeBag: DisposeBag) -> Observable<Event<[T]>> { 
    let result = ReplaySubject<Event<[T]>>.create(bufferSize: 1) 

    triggerObservable 
     .flatMapLatest { 
      SessionManager 
       .jsonArrayObservable(with: request.urlRequest, isSecured: request.isSecured) 
       .mapResponse(on: APIService.mappingSheduler) { Mapper<T>().mapArray(JSONArray: $0) } 
       .materialize() 
     } 
     .subscribe(onNext: { [weak result] event in 
      result?.onNext(event) 
     }) 
     .disposed(by: disposeBag) 

    return result 
} 

// Database 
func subscribeUpdates<N, P>(from data: UpdateData<N, P>, disposedBy disposeBag: DisposeBag) -> Observable<Void> { 
    let result = PublishSubject<Void>() 

    data.newObjectsObservable 
     .observeOn(DatabaseService.writingSheduler) 
     .subscribe(onNext: { [weak result] newObjects in 
      // update db 

      DispatchQueue.main.async { 
       result?.onNext(()) 
      } 
     }) 
     .disposed(by: disposeBag) 

    return result 
} 

Dank.

Answer 1

Gefunden folgende Lösung: ActivityIndicator Instanz Dienste Methoden übergeben und es wie folgt verwendet werden:

func bindArrayRequest<T>(_ request: MappableRequest<T>, 
         from triggerObservable: Observable<Void>, 
         trackedBy indicator: RxActivityIndicator, 
         disposedBy disposeBag: DisposeBag) -> Observable<Event<[T]>> { 
    let result = ReplaySubject<Event<[T]>>.create(bufferSize: 1) 

    triggerObservable 
     .flatMapLatest { 
      SessionManager 
       .jsonArrayObservable(with: request.urlRequest, isSecured: request.isSecured) 
       .mapResponse(on: APIService.mappingSheduler) { Mapper<T>().mapArray(JSONArray: $0) } 
       .materialize() 
       .trackActivity(indicator) 
     } 
     .bind(to: result) 
     .disposed(by: disposeBag) 

    return result 
} 

auch Datenbank-Update-Logik in beobachtbare wickeln und es mit .trackActivity(indicator) in flatMapLatest wie in api verwenden.

Dann api/Datenbank-Methoden wie folgt verwenden:

let indicator = RxActivityIndicator() 
isUpdatingData = indicator.asObservable() // needed bool observable 

let categoriesRequest = APIService.MappableRequest(Category.self, resource: .categories) 

let categoriesRequestResult = 
    api.bindArrayRequest(categoriesRequest, 
         from: actionRequest, 
         trackedBy: indicator, 
         disposedBy: disposeBag) 

let newCategories = categoriesRequestResult 
    .map { $0.element } 
    .filterNil() 

let categoriesUpdateData = DatabaseService.UpdateData(newObjectsObservable: newCategories) 

let categoriesDatabaseResult = 
    database.bindUpdates(from: categoriesUpdateData, 
         trackedBy: indicator, 
         disposedBy: disposeBag) 

let latestTopicsRequest = APIService.MappableRequest(Topic.self, resource: .latestTopics) 

let latestTopicsRequestResult = 
    api.bindArrayRequest(latestTopicsRequest, 
         from: actionRequest, 
         trackedBy: indicator, 
         disposedBy: disposeBag) 

let newLastTopics = latestTopicsRequestResult 
    .map { $0.element } 
    .filterNil() 

let latestTopicsUpdateData = DatabaseService.UpdateData(newObjectsObservable: newLastTopics) 

let latestTopicsDatabaseResult = 
    database.bindUpdates(from: latestTopicsUpdateData, 
         trackedBy: indicator, 
         disposedBy: disposeBag) 

isUpdatingData beobachtbar ist das, was ich brauchte.