RXJava handling nested calls

Question

Imagine I have a service to retrieve some authors (id, firstname, lastname, birthday, nationality) and a second service to retrieve an author's book (title, summary, number of pages). I would like my network call to return me a list of authors with their books.

To illustrate, my services would return me AuthorOResponse and BookResponse and I would like to emit an Observable of AuthorObject.

public class AuthorResponse {
    private String id;
    private String firstname;
    private String lastname;
    private Date birthday;
    private String nationality;
}

public class BookResponse {
    private String title;
    private String summary;
    private int pageNumber;
}

public class AuthorObject {
    private String id;
    private String firstname;
    private String lastname;
    private Date birthday;
    private String nationality;
    private List<BookObject> books
}

My services would be something like

Observable<List<AuthorResponse>> getAuthors()
Observable<List<BookResponse>> getAuthorBooks(String authorId)

I would like to use them to emit an Observable but cannot figure out how to do it since each of my calls to getAuthorBooks need an author.

I came up with something looking like this but I have an issue since my concatMap make me "loose" my author.

myServices.getAuthors()
                .map(author -> createAuthor())
                .concatMap(author -> mWebService.getAuthorBooks(author.getId())
                .flatMapIterable(data -> data.items)
                .map(book -> addBook())

Does someone know how I could do this ?

score 6 · Accepted Answer · edited May 23 '17 at 11:54

6

You could use special flatMap overload designed for such cases:

myServices.getAuthors()
    .map(author -> createAuthor())
    .flatMap(author -> mWebService.getAuthorBooks(author.getId()),
            (author, data) -> {
                author.setBooks(data.items));
                return Observable.just(author);
            })
    .toList() //here is your Observable<List<Author>>

edited May 23 '17 at 11:54

Community

1
1

answered Feb 23 '17 at 12:09

Maksim Ostrovidov

10,720
8
42
57

1

That seems really great. Since I want to emit an Observable I will have the flatMap return my author but it work well. Thank ! – Tibo Feb 23 '17 at 12:26

score 2 · Answer 2 · answered Feb 23 '17 at 11:26

Maybe something like this:

getAuthors.map(new Func1<List<AuthorResponse>, AuthorObject>() {
        @Override
        public AuthorObject call(List<AuthorResponse> authorResponses) {
            return createAuthor();
        }
    }).flatMap(new Func1<AuthorObject, Observable<AuthorObject>>() {
        @Override
        public Observable<AuthorObject> call(final AuthorObject authorObject) {
            return getAuthorBooks(authorObject.id)
                    .map(new Func1<List<BookResponse>, AuthorObject>() {
                        @Override
                        public AuthorObject call(List<BookResponse> bookResponses) {
                            authorObject.books = parseBooks(bookResponses);
                            return authorObject;
                        }
                    });
        }
    });

Query the Authors, map each AuthorResponse to AuthorObject, then using flatMap query books for each Author, and map it in order to add parsed books to the generated earlier AuthorObject. at the end you'll get an Observable that emits AuthorObject with their books list populated.

RXJava handling nested calls

2 Answers2