RxSwift suivre les activités multiples

Question

observables Je code suivant:

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) 

Il y a deux demandes qui commence à partir du même sujet actionRequest, publier et deux mises à jour de base de données après ces demandes.

J'ai besoin de quelque chose comme isActive, valeur booléenne qui retournera true si une tâche API/base de données est en cours. C'est possible? J'ai vu ActivityIndicator dans les exemples de RxSwift, mais je ne sais pas s'il est possible de l'utiliser dans mon cas.

code de api/base de données si nécessaire:

// 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 
} 

Merci.

Answer 1

Trouvé solution suivante: passer ActivityIndicator exemple aux méthodes de services et de l'utiliser comme ceci:

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 
} 

enveloppent également une logique de mise à jour de base de données dans observables et l'utiliser avec .trackActivity(indicator) en flatMapLatest comme dans api.

Ensuite, utiliser des méthodes api/base de données comme ceci:

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 observable est ce que je avais besoin.