FromTo

FromTo is a helper library that makes it simple to handle asynchronous actions with views for Android and Java/Kotlin.

This library is written in Kotlin. But it's interoperable with Java.

Installation

Set to your build.gradle.

repositories {
    jcenter()
}

dependencies {
    compile 'io.github.importre:fromto:<version>'
}

Getting Started

// make your job
val job = Observable.just(1)
        .subscribeOn(Schedulers.newThread())

// define an action and handlers you want
val action1 = FtAction.Builder<Int>()
        .from(job)
        .to { println(it) }
        .build()

val fromTo = FromTo.create(action1/*, more if you want */)

// attach `view`(FtView) related with fromTo's lifecycle
fromTo.attach(view).execute()

// you can know `loading` state via `view`

// detach when `view` is destroyed
fromTo.detach()

Basically FromTo has an FtAction or more.
(You can think that FtAction is a wrapper class of rx.Observable.)
Given some actions, FromTo can execute all actions asynchronously. And FromTo notifies corresponding view of the loading state via FtView interface.

• Synchronous or asynchronous action
  • Actually it's up to observable's schedule as you know.
• The state is true if one of actions is working.

See details in Kotlin example

Example

See examples.

• Kotlin example
  • Check comments ????
• Java example

Test

./gradlew test

Why should I use it?

FromTo is useful when developing an app, which has lifecycle by itself.
In Android world, for example, An Activity(or a Fragment) can take some heavy tasks such as Network, DB, File I/O and/or something.

Assume that you are in two conditions.

• two tasks are working asynchronously,
• you have to show ProgressBar if started, hide it if finished.

In these cases, how do you resolve this problem if your screen is rotated?
I know and you know some solutions.

• Do nothing.
  • Easy but bad UX. Everything will be always reloaded.
• Prevent recreating activity.
  • Using android:configChanges of <activity> element. It's very easy but the layout is not flexible(on tablet especially).
• Use AsyncTask, Handler or whatever. And Store/Restore data
  • Inconvenient, verbose ????
• Set Fragment.setRetainInstance(true)
  • The fragment is not recreated/destroyed. So the fragment can store what you want although parent activity is recreated.
  • It's good. But some guys wouldn't like to use Fragment.
• Use RxJava
  • Observable's cache() is a blessing. ????
  • See Lifecycle section of this post.

I thought that RxJava is the best solution because it's very simple and convenient.
But I realized that there are still boilerplate codes. So I implemented FromTo simply.

License

Apache 2.0 © Jaewe Heo