Investigate if we can easily use this:
https://developer.android.com/topic/libraries/architecture/viewmodel-savedstate

Alternatively support seeding the view model with the initial state and let the activity handle the state saving.

1. Add a DSL sanity check class to check for compilation issues in different operators combinations
2. Make sure current end-to-end test suite is complete
3. Add threading tests
4. Add Android lifecycle tests for attaching/detaching

Plugin for orbit 2 for RxJava 2 support. Adds:

1. Transformation functions for all base RxJava2 types (Completable, Maybe, Single, Observable)
2. Automatic execution on background thread for the above
3. Extension functions to expose container streams as Observable

Someone suggested for us to send through android lifecycle events into the android MVI system automatically. This should be possible once #22 is done.

We need to consider whether this would produce value. While there are cases when you e.g. need to refresh things with every onResume, this will only help in cases where no data is needed from the view itself.

Plugin for orbit 2 for LiveData support. Adds:

1. Extension functions to wrap the container streams as LiveData

We need the ability to release Orbit 1 and Orbit 2 separately under different version numbers.
The proposed solution is to tag in the form of:

project/version e.g. orbit2/1.0.0

These tags would be read during the gradle configuration stage and set up the distribution accordingly.

• Using generics in on
• Duplicate descriptions in perform

Readme missing for:

• Configuration
• Side effect caching
• Overall orbit behaviour

We should have the capability to enable debug logging. TBD what we want to log.

I am trying to use the SideEffect as signaling of some status update, and since I use seal class -> object and no need other property, the second post(MySideEffect()) is not observed by UI.

Proposing overload to post

fun post(event:SE, repost:Boolean=false)

in case when repost == true the stream will repeat the same Effect.

Unless I do not do something right - since I did start with use of Orbit recently.

Currently any unhandled errors anywhere in the flows will result in a broken rx cycle which leads to an unusable screen.
Think of ways of improving this.

We should make the DSL generic enough to be able to support both RxJava and coroutines flow.

Update to Gradle 6.0 by executing the following:

./gradlew wrapper --gradle-version=6.0 --distribution-type=all --gradle-distribution-sha256-sum=a1eb4439c0a85bc7e64a22658d862e43b7d0ddfbf69a7abf6256e0b7514295df

However, we cannot currently do this until the bintray-release plugin supports it, see novoda/bintray-release#298.

The core module for Orbit 2 establishes the framework on which the rest of the functionality will be built, as well as a complete, minimal implementation of the engine and DSL that already allows you to use MVI out of the box, albeit with no support for async/streaming frameworks. Additional functionality will be provided in separate libraries as plugins.

Included are:

1. Orbit container API
2. Plugin API
3. Functional orbit container implementation running on coroutines
4. Basic DSL (no coroutines or RxJava)

The project does not directly expose any coroutine or RxJava objects or APIs, instead wrapping the implementation details in a lightweight API.

Testing the middleware as a black box

In preparation for Orbit 2 we should ensure our dependencies are up-to-date.

In order to allow for custom conditional logic for side effects we should:

Merge sideEffect and postSideEffect together and add a post method in their receiver. This makes it optional to post a side effect and simplifies the DSL at the same time.

Currently you need to make sure you terminate a flow either with withReducer, loopback or ignoringEvents.

The last operation is really just a crutch to make this work without too much hassle but is unnecessary boilerplate. We should investigate if we can get rid of it.

https://central.sonatype.org/pages/requirements.html

Orbit 2 testing plugin. Addresses most of Orbit 1 testing issues by providing a simple to use DSL that takes care of things like threading, flow isolation etc. for you and allows you to focus on the behaviour of your flows.

1. Force sequential execution of flows
2. Isolation of flows
3. Testing DSL

Plugin for orbit 2 for Android SavedState support. Adds:

1. Extensions to the standard builder that allow you to pass the SavedStateHandle
2. Automatic state saving and restoration using the above handle

When releasing orbit2 v 2.0.0 with the simplified syntax we have forgotten to update the sample apps to use it.

This task is to refactor all our samples to use the simplified syntax.

Plugin for orbit 2 for coroutine support. Adds:

1. Suspend and flow DSL functions for transformations
2. Automatic execution on background thread for the above

Currently we use uber's Autodispose to auto-detach the view model from the view in onPause/onStop.

We should do this ourselves to drop the extra dependency and make orbit more portable for the future.

See Why Exception Handling with Kotlin Coroutines is hard and how to master it