RxJava | RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based prog | Reactive Programming library

I am not very familiar with Android programing, so sorry if I am missing something and make any mistake, but why don't you pass a reference to the EditText that has been focused to the getNewValue method?

Consider for instance:

Am not sure why you're using transform and not a map or flatMap, but according to the documentation you have to emit the value from within the transform function, so I'd assume it'd look like:

I had a hard time while trying to figure out the domain layer. The most common example of it is the use case.

Your viewmodel won't communicate directly to the repository. As you said, you need viewmodel 》domain 》repository.

You may think of a usecase as a abstraction for every repository method.

Let's say you have a Movies Repository where you call a method for a movie list, another method for movie details and a third method for related movies.

You'll have a usecase for every single method.

What's the purpose of it?

Let's say you have a DetailActivity that communicate with a Detail Viewmodel. Your viewmodel doesn't need to know all the repository (what's the purpose of calling a movie list method on you Detail screen?). So, all your DetailViewModel will know is "Detail Usecase " (that calls the Detail method in repository).

Google has updated the architecture documentation few hours ago, take a look! https://android-developers.googleblog.com/2021/12/rebuilding-our-guide-to-app-architecture.html?m=1&s=09

PS: Usecase is not a special android class, you do not need to inherent any behavior (as fragment, activity, viewmodel...) it's a normal class that will receive the repository as parameter.

You'll have something like:

Viewmodel:

The most obvious problem I see here is that you're using Flow for single values instead of suspend functions.

Coroutines makes the single-value use case much simpler by using suspend functions that return plain values or throw exceptions. You can of course also make them return Result-like classes to encapsulate errors instead of actually using exceptions, but the important part is that with suspend functions you are exposing a seemingly synchronous (thus convenient) API while still benefitting from asynchronous runtime.

In the provided examples you're not subscribing for updates anywhere, all flows actually just give a single element and complete, so there is no real reason to use flows and it complicates the code. It also makes it harder to read for people used to coroutines because it looks like multiple values are coming, and potentially collect being infinite, but it's not the case.

Each time you write flow { emit(x) } it should just be x.

Following the above, you're sometimes using flatMapMerge and in the lambda you create flows with a single element. Unless you're looking for parallelization of the computation, you should simply go for .map { ... } instead. So replace this:

My Gradle couldn't find the redacted-gradle-plugin but both of your classes compiles with this minimalistic build.gradle.kts:

We can tell the reactor to emit an element after a specific delay by using delayElements(Duration delay). It always tries to emit elements after a specific duration without blocking.

Put this URL in a google chrome browser or any other consumer client like curl instead of the postman.

Curl

Jitpack uses ./gradlew install for generating the artifacts.

Adding an install block and manually appending the dependencies to the pom file worked for me.

Here's the install block that I added to the module level build.gradle file:

First. You cannot (I believe) have a val detailList:List?, you need a single (not a List) item.

So (1) add a new Class that embodies the List e.g. :-