Wie kann ich die Ausführung von RxJava-Diagrammen visualisieren?

Question

Angenommen, ich habe einige komplexe Ketten von Single, Maybe und Observable Objekte, die einige Aufgaben ausführen.

Zum Beispiel:

// Download, unzip and parse a release 
public static Single<Release> fetchRelease(final Release release) { 
    final Path cachePath = getCachePath(release); 
    return download(release.url, cachePath, true).ignoreElements() 
     .andThen(hash(cachePath)) 
     .flatMap(fileHash -> unzip(cachePath) 
      .andThen(parseFile(unzipTargetPath))); 
} 

Diese Ketten könnten über mehrere Threads ausgeführt werden.

Das Problem ist, dass ich den Fortschritt dieser Aufgaben an den Benutzer rendern möchten, ohne ihre Logik wo möglich matschig.

Zum Beispiel könnte die obige Aufgabe zeigen:

+-Fetching release 1.0... Done 
    +-Downloading https://www.example.com/v1.0.0.zip 100% 
    +-Hashing Library/Caches/Example/v1.0.0.zip... Done 
    +-Unpacking Library/Caches/Example/v1.0.0.zip 
    +-src.. Done 
    +-tests... Done 
    +-resources... Done 
    +-Parsing release... Done 

Idealerweise würde ich auch die Hierarchie von Aufgaben angezeigt werden mag. Dies wird derzeit nur im Java-Aufrufdiagramm codiert.

Mein aktueller Denken ist:

• ändern jeder Single zu einem Observable, wo das letzte Element ist das Ergebnis und die anderen sind Fortschritte Updates.
• Schreiben Sie Ereignisklassen für jede Phase der Aufgabe.

Ich denke, das wird den Code weniger lesbar machen und zu vielen Boiler-Plate führen.

public final class DownloadProgress { 
    public final float progress; 
    // etc.. 
} 

// etc... 

public final class FetchReleaseProgress { 
    public final Variant<DownloadProgress, HashingProgress, UnpackProgress, ParseProgress> progress; 
    // etc... 
} 

Was ist der empfohlene Ansatz?

Answer 1

Sie auf dem richtigen Weg sind, können Sie ein komplettes ui Modell schreiben, die die ui Ereignisse darstellt, die Sie interessiert sind, werde ich Ihren Fall hier als Beispiel

+-Fetching release 1.0... Done 
    +-Downloading https://www.example.com/v1.0.0.zip 100% 
    +-Hashing Library/Caches/Example/v1.0.0.zip... Done 
    +-Unpacking Library/Caches/Example/v1.0.0.zip 
    +-src.. Done 
    +-tests... Done 
    +-resources... Done 
    +-Parsing release... Done 

und nehmen Modell könnte so dass somthing sein:

final class DownloadUiModel { 
private float progress; 
private String hashing; 
private String downloading; 
private String unpacking; 
private String done; 

private DownloadUiModel(float progress, String hashing //..etc) { 
} 
//getters 
//setters 
} 

dann mit Rxjava könnten Sie das Vorgängermodell wie folgt verwenden:

download(release.url, cachePath, true) 
.ignoreElements() 
.map(response -> downloadUiModel.setDownloading(release.url)) 
.andThen(hash(cachePath)) 
.map(response -> downloadUiModel.setHashing(cachePath)) 
.flatMap(fileHash -> unzip(cachePath) 
.andThen(parseFile(unzipTargetPath))) 
.map(response -> downloadUiModel.setUnzipping(unzipTargetPath)) 
... 

dann bei der Anmeldung, können Sie dieses ui Modell, das Sie wie

so ui zu aktualisieren verwenden

downloadObservable.subscribe(model -> 
if(model.getProgress()!= 100){ 
Timber.d(model.getDownloading()) 
Timber.d(model.getHashing()) 
Timber.d(model.getUnpacking)) 
//... 
} 

das schöne Teil über diese Art und Weise, die Ihre ui Logik von Ihrer Anforderungslogik getrennt ist, und Sie können easly Android Haupt-Thread wechseln sicher.