lifecycle | life cycle of your exported functions | Development Tools library

This is exactly the reason why coroutines were invented and how they differ from threaded concurrency. Coroutines don't block, but suspend (well, they can do both). And "suspend" isn't just another name for "block". When they suspend (e.g. by invoking join()), they effectively free the thread that runs them, so it can do something else somewhere else. And yes, it sounds like something that is technically impossible, because we are in the middle of executing the code of some function and we have to wait there, but well... welcome to coroutines :-)

You can think of it as the function is being cut into two parts: before join() and after it. First part schedules the background operation and immediately returns. When background operation finishes, it schedules the second part on the main thread. This is not how coroutines works internally (functions aren't really cut, they create continuations), but this is how you can easily imagine them working if you are familiar with executors or event loops.

delay() is also a suspending function, so it frees the thread running it and schedules execution of the code below it after a specified duration.

I'm assuming you have missing dependencies on your code generation class path. Once you update your question, I'll update my answer.

jOOQ won't support your generated composite types in generated code out of the box, you'll still have to add forced type configurations for that, possibly embeddable type configurations:

• https://www.jooq.org/doc/latest/manual/code-generation/codegen-advanced/codegen-config-database/codegen-database-forced-types/
• https://www.jooq.org/doc/latest/manual/code-generation/codegen-embeddable-types/

Note that the JPADatabase offers a quick win by integrating with simple JPA defined schemas very quickly. It has its caveats. For best results, I recommend going DDL first (and generate both jOOQ code and JPA model from that), because it will be much easier to put your schema change management under version control, e.g. via Flyway or Liquibase.

First make a Repository class and make an instance of your DAO

Try to take advantage from the old value which is 2nd parameter of the watch handler :

You need to upgrade to Fragment 1.2.0 or higher.

As per the Lifecycle 2.2.0 release notes, the new ViewModelProvider APIs that Hilt uses under the hood only apply when using Fragment 1.2.0 or higher. When using an older version of Fragments, those APIs are not connected to fragments and therefore your Hilt enabled ViewModel factory is not used when you use by viewModels().

You should upgrade to Fragment 1.2.5 (the last version of the Fragment 1.2.X set) or to Fragment 1.3.0, both of which contain the necessary API hooks to get Hilt working.

You are using scalatest version 2.2.6:

I didn't know there is an override mechanise in UI5 and it looks over-engineered... My guess is you are on an older version without proper support.

Anyhow, js-inheritance works out of the box. You need to call "super".

Apparently the problem was solved by removing custom listener of this loading overlay in onDestroy() method, because it was trying to get a reference for this and a related view before the fragment was in Resumed state.

Keeping the whole discussion aside of LiveData vs SharedFlow or StateFlow. Coming onto ViewModels as you asked. If we are to go by documentation

The ViewModel class is designed to store and manage UI-related data in a lifecycle conscious way. The ViewModel class allows data to survive configuration changes such as screen rotations.

UI controllers such as activities and fragments are primarily intended to display UI data, react to user actions, or handle operating system communication, such as permission requests. Requiring UI controllers to also be responsible for loading data from a database or network adds bloat to the class. Assigning excessive responsibility to UI controllers can result in a single class that tries to handle all of an app's work by itself, instead of delegating work to other classes. Assigning excessive responsibility to the UI controllers in this way also makes testing a lot harder.

It's easier and more efficient to separate out view data ownership from UI controller logic.

I guess this sums it up quite well. It is true that lifeCycleScope can eliminate the need of ViewModel in a way, but ViewModel does more than just being a holder for LiveData.

Even if you want to use SharedFlow or StateFlow over LiveData I would suggest you still make use of ViewModel and inside it use a viewModelScope instead to still perform the usual and required separation of concerns between UI and data.