diff --git a/.gitignore b/.gitignore
index 0f885ac8..74c05caa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,53 @@
-.gradle
-/local.properties
-/.idea/workspace.xml
+# built application files
+*.apk
+*.ap_
+
+# files for the dex VM
+*.dex
+
+# Java class files
+*.class
+
+# generated files
+bin/
+gen/
+build/
+
+# Gradle files
+.gradle/
+subProjects/facebook/build
+
+# Buck files
+buck-out/
+.buckd/
+
+# Intellij project files
+.idea/
+.idea/libraries
+.idea/.name
+.idea/compiler.xml
+.idea/gradle.xml
+.idea/modules.xml
+.idea/runConfigurations.xml
+.idea/vcs.xml
+.idea/workspace.xml
+.idea/misc.xml
+gen-external-apklibs/
+*.iml
+*.iws
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Mac-specific stuff
.DS_Store
-/build
+
+#Maven
+target
+release.properties
+pom.xml.*
+
+#Ant
+build.xml
+ant.properties
+profiles_settings.xml
diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
new file mode 100644
index 00000000..3682ebc2
--- /dev/null
+++ b/.idea/codeStyleSettings.xml
@@ -0,0 +1,236 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Android-RxJava.iml b/Android-RxJava.iml
deleted file mode 100644
index 0bb6048a..00000000
--- a/Android-RxJava.iml
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/README.md b/README.md
index 30b9a407..0f796a1a 100644
--- a/README.md
+++ b/README.md
@@ -1,46 +1,281 @@
Learning RxJava for Android by example
==============
-I've read and watched a lot on Rx. Most examples either use the J8 lambda notations/Scala/Groovy or some other awesome language that us Android developers are constantly envious of.
+This is a repository with real-world useful examples of using RxJava with Android. [It usually will be in a constant state of "Work in Progress" (WIP)](https://kau.sh/blog/learning-rxjava-with-android-by-example/).
-Unfortunately i could never find real-world simple examples in Android, that could show me how to use RxJava in Android. This repo is a solution to that problem. Below are a list of examples with a little more deatils on the approach:
+I've also been giving talks about Learning Rx using many of the examples listed in this repo.
+
+* [Learning RxJava For Android by Example : Part 1](https://www.youtube.com/watch?v=k3D0cWyNno4) \[[slides](https://speakerdeck.com/kaushikgopal/learning-rxjava-for-android-by-example)\] (SF Android Meetup 2015)
+* [Learning Rx by Example : Part 2](https://vimeo.com/190922794) \[[slides](https://speakerdeck.com/kaushikgopal/learning-rx-by-example-2)\] (Øredev 2016)
## Examples:
-### 1. Concurrency using schedulers
+1. [Background work & concurrency (using Schedulers)](#1-background-work--concurrency-using-schedulers)
+2. [Accumulate calls (using buffer)](#2-accumulate-calls-using-buffer)
+3. [Instant/Auto searching text listeners (using Subjects & debounce)](#3-instantauto-searching-text-listeners-using-subjects--debounce)
+4. [Networking with Retrofit & RxJava (using zip, flatmap)](#4-networking-with-retrofit--rxjava-using-zip-flatmap)
+5. [Two-way data binding for TextViews (using PublishSubject)](#5-two-way-data-binding-for-textviews-using-publishsubject)
+6. [Simple and Advanced polling (using interval and repeatWhen)](#6-simple-and-advanced-polling-using-interval-and-repeatwhen)
+7. [Simple and Advanced exponential backoff (using delay and retryWhen)](#7-simple-and-advanced-exponential-backoff-using-delay-and-retrywhen)
+8. [Form validation (using combineLatest)](#8-form-validation-using-combinelatest)
+9. [Pseudo caching : retrieve data first from a cache, then a network call (using concat, concatEager, merge or publish)](#9-pseudo-caching--retrieve-data-first-from-a-cache-then-a-network-call-using-concat-concateager-merge-or-publish)
+10. [Simple timing demos (using timer, interval or delay)](#10-simple-timing-demos-using-timer-interval-and-delay)
+11. [RxBus : event bus using RxJava (using RxRelay (never terminating Subjects) and debouncedBuffer)](#11-rxbus--event-bus-using-rxjava-using-rxrelay-never-terminating-subjects-and-debouncedbuffer)
+12. [Persist data on Activity rotations (using Subjects and retained Fragments)](#12-persist-data-on-activity-rotations-using-subjects-and-retained-fragments)
+13. [Networking with Volley](#13-networking-with-volley)
+14. [Pagination with Rx (using Subjects)](#14-pagination-with-rx-using-subjects)
+15. [Orchestrating Observable: make parallel network calls, then combine the result into a single data point (using flatmap & zip)](#15-orchestrating-observable-make-parallel-network-calls-then-combine-the-result-into-a-single-data-point-using-flatmap--zip)
+16. [Simple Timeout example (using timeout)](#16-simple-timeout-example-using-timeout)
+17. [Setup and teardown resources (using `using`)](#17-setup-and-teardown-resources-using-using)
+18. [Multicast playground](#18-multicast-playground)
+
+## Description
-A common requirement is to offload lengthy heavy I/O intensive operations to a background thread (non-UI thread), and feed the results on completion, back into the UI/main thread. This is a demo of how long running operations can be offloaded to a background thread. After the operation is done, we resume back on the main thread. All using RxJava!
+### 1. Background work & concurrency (using Schedulers)
-The long operation is simulated by a blocking Thread.sleep call. But since it's in a background thread, our UI is never interrupted.
+A common requirement is to offload lengthy heavy I/O intensive operations to a background thread (non-UI thread) and feed the results back to the UI/main thread, on completion. This is a demo of how long-running operations can be offloaded to a background thread. After the operation is done, we resume back on the main thread. All using RxJava! Think of this as a replacement to AsyncTasks.
-To really see this shine. Hit the button multiple times and see how the button click which is a ui operation is never blocked because the long operation only runs in the background
+The long operation is simulated by a blocking Thread.sleep call (since this is done in a background thread, our UI is never interrupted).
+To really see this example shine. Hit the button multiple times and see how the button click (which is a UI operation) is never blocked because the long operation only runs in the background.
-### 2. Accumulate calls using buffer (wip)
+### 2. Accumulate calls (using buffer)
This is a demo of how events can be accumulated using the "buffer" operation.
A button is provided and we accumulate the number of clicks on that button, over a span of time and then spit out the final results.
-If you hit the button once. you'll get message saying the button was hit once. If you hit it 5 times continuosly within a span of 2 seconds, then you get a single log, saying you hit that button 5 times (vs 5 individual logs saying Button hit once).
+If you hit the button once, you'll get a message saying the button was hit once. If you hit it 5 times continuously within a span of 2 seconds, then you get a single log, saying you hit that button 5 times (vs 5 individual logs saying "Button hit once").
+
+Note:
+
+If you're looking for a more foolproof solution that accumulates "continuous" taps vs just the number of taps within a time span, look at the [EventBus Demo](https://github.com/kaushikgopal/Android-RxJava/blob/master/app/src/main/java/com/morihacky/android/rxjava/rxbus/RxBusDemo_Bottom3Fragment.java) where a combo of the `publish` and `buffer` operators is used. For a more detailed explanation, you can also have a look at this [blog post](https://kau.sh/blog/debouncedbuffer-with-rxjava/).
+
+### 3. Instant/Auto searching text listeners (using Subjects & debounce)
+
+This is a demo of how events can be swallowed in a way that only the last one is respected. A typical example of this is instant search result boxes. As you type the word "Bruce Lee", you don't want to execute searches for B, Br, Bru, Bruce, Bruce, Bruce L ... etc. But rather intelligently wait for a couple of moments, make sure the user has finished typing the whole word, and then shoot out a single call for "Bruce Lee".
+
+As you type in the input box, it will not shoot out log messages at every single input character change, but rather only pick the lastly emitted event (i.e. input) and log that.
+
+This is the debounce/throttleWithTimeout method in RxJava.
+
+### 4. Networking with Retrofit & RxJava (using zip, flatmap)
+
+[Retrofit from Square](http://square.github.io/retrofit/) is an amazing library that helps with easy networking (even if you haven't made the jump to RxJava just yet, you really should check it out). It works even better with RxJava and these are examples hitting the GitHub API, taken straight up from the android demigod-developer Jake Wharton's talk at Netflix. You can [watch the talk](https://www.youtube.com/watch?v=aEuNBk1b5OE#t=2480) at this link. Incidentally, my motivation to use RxJava was from attending this talk at Netflix.
+
+(Note: you're most likely to hit the GitHub API quota pretty fast so send in an OAuth-token as a parameter if you want to keep running these examples often).
+
+### 5. Two-way data binding for TextViews (using PublishSubject)
+
+Auto-updating views are a pretty cool thing. If you've dealt with Angular JS before, they have a pretty nifty concept called "two-way data binding", so when an HTML element is bound to a model/entity object, it constantly "listens" to changes on that entity and auto-updates its state based on the model. Using the technique in this example, you could potentially use a pattern like the [Presentation View Model pattern](http://martinfowler.com/eaaDev/PresentationModel.html) with great ease.
+
+While the example here is pretty rudimentary, the technique used to achieve the double binding using a `Publish Subject` is much more interesting.
+
+### 6. Simple and Advanced polling (using interval and repeatWhen)
+
+This is an example of polling using RxJava Schedulers. This is useful in cases, where you want to constantly poll a server and possibly get new data. The network call is "simulated" so it forces a delay before return a resultant string.
+
+There are two variants for this:
+
+1. Simple Polling: say when you want to execute a certain task every 5 seconds
+2. Increasing Delayed Polling: say when you want to execute a task first in 1 second, then in 2 seconds, then 3 and so on.
+
+The second example is basically a variant of [Exponential Backoff](https://github.com/kaushikgopal/RxJava-Android-Samples#exponential-backoff).
+
+Instead of using a RetryWithDelay, we use a RepeatWithDelay here. To understand the difference between Retry(When) and Repeat(When) I wouuld suggest Dan's [fantastic post on the subject](http://blog.danlew.net/2016/01/25/rxjavas-repeatwhen-and-retrywhen-explained/).
+
+An alternative approach to delayed polling without the use of `repeatWhen` would be using chained nested delay observables. See [startExecutingWithExponentialBackoffDelay in the ExponentialBackOffFragment example](https://github.com/kaushikgopal/RxJava-Android-Samples/blob/master/app/src/main/java/com/morihacky/android/rxjava/fragments/ExponentialBackoffFragment.java#L111).
+
+### 7. Simple and Advanced exponential backoff (using delay and retryWhen)
+
+[Exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff) is a strategy where based on feedback from a certain output, we alter the rate of a process (usually reducing the number of retries or increasing the wait time before retrying or re-executing a certain process).
+
+The concept makes more sense with examples. RxJava makes it (relatively) simple to implement such a strategy. My thanks to [Mike](https://twitter.com/m_evans10) for suggesting the idea.
+
+#### Retry (if error) with exponential backoff
+
+Say you have a network failure. A sensible strategy would be to NOT keep retrying your network call every 1 second. It would be smart instead (nay... elegant!) to retry with increasing delays. So you try at second 1 to execute the network call, no dice? try after 10 seconds... negatory? try after 20 seconds, no cookie? try after 1 minute. If this thing is still failing, you got to give up on the network yo!
+
+We simulate this behaviour using RxJava with the [`retryWhen` operator](http://reactivex.io/documentation/operators/retry.html).
+
+`RetryWithDelay` code snippet courtesy:
+
+* http://stackoverflow.com/a/25292833/159825
+* Another excellent implementation via @[sddamico](https://github.com/sddamico) : https://gist.github.com/sddamico/c45d7cdabc41e663bea1
+* This one includes support for jittering, by @[leandrofavarin](https://github.com/leandrofavarin) : http://leandrofavarin.com/exponential-backoff-rxjava-operator-with-jitter
+
+Also look at the [Polling example](https://github.com/kaushikgopal/RxJava-Android-Samples#polling-with-schedulers) where we use a very similar Exponential backoff mechanism.
+
+#### "Repeat" with exponential backoff
+
+Another variant of the exponential backoff strategy is to execute an operation for a given number of times but with delayed intervals. So you execute a certain operation 1 second from now, then you execute it again 10 seconds from now, then you execute the operation 20 seconds from now. After a grand total of 3 times you stop executing.
+
+Simulating this behavior is actually way more simpler than the prevoius retry mechanism. You can use a variant of the `delay` operator to achieve this.
+
+
+### 8. Form validation (using [`.combineLatest`](http://reactivex.io/documentation/operators/combinelatest.html))
+
+Thanks to Dan Lew for giving me this idea in the [fragmented podcast - episode #4](http://fragmentedpodcast.com/episodes/4/) (around the 4:30 mark).
+
+`.combineLatest` allows you to monitor the state of multiple observables at once compactly at a single location. The example demonstrated shows how you can use `.combineLatest` to validate a basic form. There are 3 primary inputs for this form to be considered "valid" (an email, a password and a number). The form will turn valid (the text below turns blue :P) once all the inputs are valid. If they are not, an error is shown against the invalid inputs.
+
+We have 3 independent observables that track the text/input changes for each of the form fields (RxAndroid's `WidgetObservable` comes in handy to monitor the text changes). After an event change is noticed from **all** 3 inputs, the result is "combined" and the form is evaluated for validity.
+
+Note that the `Func3` function that checks for validity, kicks in only after ALL 3 inputs have received a text change event.
+
+The value of this technique becomes more apparent when you have more number of input fields in a form. Handling it otherwise with a bunch of booleans makes the code cluttered and kind of difficult to follow. But using `.combineLatest` all that logic is concentrated in a nice compact block of code (I still use booleans but that was to make the example more readable).
+
+
+### 9. Pseudo caching : retrieve data first from a cache, then a network call (using concat, concatEager, merge or publish)
+
+We have two source Observables: a disk (fast) cache and a network (fresh) call. Typically the disk Observable is much faster than the network Observable. But in order to demonstrate the working, we've also used a fake "slower" disk cache just to see how the operators behave.
+
+This is demonstrated using 4 techniques:
+
+1. [`.concat`](http://reactivex.io/documentation/operators/concat.html)
+2. [`.concatEager`](http://reactivex.io/RxJava/javadoc/rx/Observable.html#concatEager(java.lang.Iterable))
+3. [`.merge`](http://reactivex.io/documentation/operators/merge.html)
+4. [`.publish`](http://reactivex.io/RxJava/javadoc/rx/Observable.html#publish(rx.functions.Func1)) selector + merge + takeUntil
+
+The 4th technique is probably what you want to use eventually but it's interesting to go through the progression of techniques, to understand why.
+
+`concat` is great. It retrieves information from the first Observable (disk cache in our case) and then the subsequent network Observable. Since the disk cache is presumably faster, all appears well and the disk cache is loaded up fast, and once the network call finishes we swap out the "fresh" results.
+
+The problem with `concat` is that the subsequent observable doesn't even start until the first Observable completes. That can be a problem. We want all observables to start simultaneously but produce the results in a way we expect. Thankfully RxJava introduced `concatEager` which does exactly that. It starts both observables but buffers the result from the latter one until the former Observable finishes. This is a completely viable option.
+
+Sometimes though, you just want to start showing the results immediately. Assuming the first observable (for some strange reason) takes really long to run through all its items, even if the first few items from the second observable have come down the wire it will forcibly be queued. You don't necessarily want to "wait" on any Observable. In these situations, we could use the `merge` operator. It interleaves items as they are emitted. This works great and starts to spit out the results as soon as they're shown.
+
+Similar to the `concat` operator, if your first Observable is always faster than the second Observable you won't run into any problems. However the problem with `merge` is: if for some strange reason an item is emitted by the cache or slower observable *after* the newer/fresher observable, it will overwrite the newer content. Click the "MERGE (SLOWER DISK)" button in the example to see this problem in action. @JakeWharton and @swankjesse contributions go to 0! In the real world this could be bad, as it would mean the fresh data would get overridden by stale disk data.
+
+To solve this problem you can use merge in combination with the super nifty `publish` operator which takes in a "selector". I wrote about this usage in a [blog post](https://kau.sh/blog/rxjava-tip-for-the-day-share-publish-refcount-and-all-that-jazz/) but I have [Jedi JW](https://twitter.com/JakeWharton/status/786363146990649345) to thank for reminding of this technique. We `publish` the network observable and provide it a selector which starts emitting from the disk cache, up until the point that the network observable starts emitting. Once the network observable starts emitting, it ignores all results from the disk observable. This is perfect and handles any problems we might have.
+
+Previously, I was using the `merge` operator but overcoming the problem of results being overwritten by monitoring the "resultAge". See the old `PseudoCacheMergeFragment` example if you're curious to see this old implementation.
+
+### 10. Simple timing demos (using timer, interval and delay)
+
+This is a super simple and straightforward example which shows you how to use RxJava's `timer`, `interval` and `delay` operators to handle a bunch of cases where you want to run a task at specific intervals. Basically say NO to Android `TimerTask`s.
+
+Cases demonstrated here:
+
+1. run a single task after a delay of 2s, then complete
+2. run a task constantly every 1s (there's a delay of 1s before the first task fires off)
+3. run a task constantly every 1s (same as above but there's no delay before the first task fires off)
+4. run a task constantly every 3s, but after running it 5 times, terminate automatically
+5. run a task A, pause for sometime, then execute Task B, then terminate
+
+### 11. RxBus : event bus using RxJava (using RxRelay (never terminating Subjects) and debouncedBuffer)
+
+There are accompanying blog posts that do a much better job of explaining the details on this demo:
+
+1. [Implementing an event bus with RxJava](https://kau.sh/blog/implementing-an-event-bus-with-rxjava-rxbus/)
+2. [DebouncedBuffer used for the fancier variant of the demo](https://kau.sh/blog/debouncedbuffer-with-rxjava/)
+3. [share/publish/refcount](https://kau.sh/blog/rxjava-tip-for-the-day-share-publish-refcount-and-all-that-jazz/)
+
+### 12. Persist data on Activity rotations (using Subjects and retained Fragments)
+
+A common question that's asked when using RxJava in Android is, "how do i resume the work of an observable if a configuration change occurs (activity rotation, language locale change etc.)?".
+
+This example shows you one strategy viz. using retained Fragments. I started using retained fragments as "worker fragments" after reading this [fantastic post by Alex Lockwood](http://www.androiddesignpatterns.com/2013/04/retaining-objects-across-config-changes.html) quite sometime back.
+
+Hit the start button and rotate the screen to your heart's content; you'll see the observable continue from where it left off.
+
+*There are certain quirks about the "hotness" of the source observable used in this example. Check [my blog post](https://kau.sh/blog/a-note-about-the-warmth-share-operator/) out where I explain the specifics.*
+
+I have since rewritten this example using an alternative approach. While the [`ConnectedObservable` approach worked](https://github.com/kaushikgopal/RxJava-Android-Samples/blob/master/app/src/main/java/com/morihacky/android/rxjava/fragments/RotationPersist1WorkerFragment.java#L20) it enters the lands of "multicasting" which can be tricky (thread-safety, .refcount etc.). Subjects on the other hand are far more simple. You can see it rewritten [using a `Subject` here](https://github.com/kaushikgopal/RxJava-Android-Samples/blob/master/app/src/main/java/com/morihacky/android/rxjava/fragments/RotationPersist2WorkerFragment.java#L22).
+
+I wrote [another blog post](https://tech.instacart.com/how-to-think-about-subjects-part-1/) on how to think about Subjects where I go into some specifics.
+
+
+### 13. Networking with Volley
+
+[Volley](http://developer.android.com/training/volley/index.html) is another networking library introduced by [Google at IO '13](https://www.youtube.com/watch?v=yhv8l9F44qo). A kind citizen of github contributed this example so we know how to integrate Volley with RxJava.
+
+### 14. Pagination with Rx (using Subjects)
+
+I leverage the simple use of a Subject here. Honestly, if you don't have your items coming down via an `Observable` already (like through Retrofit or a network request), there's no good reason to use Rx and complicate things.
+
+This example basically sends the page number to a Subject, and the subject handles adding the items. Notice the use of `concatMap` and the return of an `Observable` from `_itemsFromNetworkCall`.
+
+For kicks, I've also included a `PaginationAutoFragment` example, this "auto-paginates" without us requiring to hit a button. It should be simple to follow if you got how the previous example works.
+
+Here are some other fancy implementations (while i enjoyed reading them, i didn't land up using them for my real world app cause personally i don't think it's necessary):
+
+* [Matthias example of an Rx based pager](https://gist.github.com/mttkay/24881a0ce986f6ec4b4d)
+* [Eugene's very comprehensive Pagination sample](https://github.com/matzuk/PaginationSample)
+* [Recursive Paging example](http://stackoverflow.com/questions/28047272/handle-paging-with-rxjava)
+
+### 15. Orchestrating Observable: make parallel network calls, then combine the result into a single data point (using flatmap & zip)
+
+The below ascii diagram expresses the intention of our next example with panache. f1,f2,f3,f4,f5 are essentially network calls that when made, give back a result that's needed for a future calculation.
+
+
+ (flatmap)
+ f1 ___________________ f3 _______
+ (flatmap) | (zip)
+ f2 ___________________ f4 _______| ___________ final output
+ \ |
+ \____________ f5 _______|
+
+The code for this example has already been written by one Mr.skehlet in the interwebs. Head over to [the gist](https://gist.github.com/skehlet/9418379) for the code. It's written in pure Java (6) so it's pretty comprehensible if you've understood the previous examples. I'll flush it out here again when time permits or I've run out of other compelling examples.
+
+### 16. Simple Timeout example (using timeout)
+
+This is a simple example demonstrating the use of the `.timeout` operator. Button 1 will complete the task before the timeout constraint, while Button 2 will force a timeout error.
+
+Notice how we can provide a custom Observable that indicates how to react under a timeout Exception.
+
+### 17. Setup and teardown resources (using `using`)
+
+The [operator `using`](http://reactivex.io/documentation/operators/using.html) is relatively less known and notoriously hard to Google. It's a beautiful API that helps to setup a (costly) resource, use it and then dispose off in a clean way.
+
+The nice thing about this operator is that it provides a mechansim to use potentially costly resources in a tightly scoped manner. using -> setup, use and dispose. Think DB connections (like Realm instances), socket connections, thread locks etc.
+
+### 18. Multicast Playground
+
+Multicasting in Rx is like a dark art. Not too many folks know how to pull it off without concern. This example condiers two subscribers (in the forms of buttons) and allows you to add/remove subscribers at different points of time and see how the different operators behave under those circumstances.
+
+The source observale is a timer (`interval`) observable and the reason this was chosen was to intentionally pick a non-terminating observable, so you can test/confirm if your multicast experiment will leak.
+
+_I also gave a talk about [Multicasting in detail at 360|Andev](https://speakerdeck.com/kaushikgopal/rx-by-example-volume-3-the-multicast-edition). If you have the inclination and time, I highly suggest watching that talk first (specifically the Multicast operator permutation segment) and then messing around with the example here._
+
+## Rx 2.x
+
+All the examples here have been migrated to use RxJava 2.X.
+
+* Have a look at [PR #83 to see the diff of changes between RxJava 1 and 2](https://github.com/kaushikgopal/RxJava-Android-Samples/pull/83/files)
+* [What's different in Rx 2.x](https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0)
+
+We use [David Karnok's Interop library](https://github.com/akarnokd/RxJava2Interop) in some cases as certain libraries like RxBindings, RxRelays, RxJava-Math etc. have not been ported yet to 2.x.
+
+## Contributing:
+
+I try to ensure the examples are not overly contrived but reflect a real-world usecase. If you have similar useful examples demonstrating the use of RxJava, feel free to send in a pull request.
+
+I'm wrapping my head around RxJava too so if you feel there's a better way of doing one of the examples mentioned above, open up an issue explaining how. Even better, send a pull request.
+
+
+## Sponsorship (Memory Management/Profiling)
-### 3. Instant/Auto searching (using a subject and debounce)
+Rx threading is messy business. To help, this project uses YourKit tools for analysis.
-This is a demo of how events can be swallowed in a way that only the last one is respected. A typical example of this is instant search result boxes. As you type the word "Bruce Lee", you don't want to execute searches for B, Br, Bru, Bruce, Bruce , Bruce L ... etc. But rather intelligently wait for a couple of moments, make sure the user has finished typing the whole word, and then shoot out a single call for "Bruce Lee".
+
-As you type in the input box, it will not shoot out log messages at every single input character change, but rather only pick the lastly emitted event (i.e. input) and log that. \n\nThis is the debounce/throttleWithTimeout method in RxJava.
-### 4. Working examples of github from JakeWharton's Retrofit preso at Netflix (wip)
+YourKit supports open source projects with innovative and intelligent tools
+for monitoring and profiling Java applications. YourKit is the creator of YourKit Java Profiler.
-https://www.youtube.com/watch?v=aEuNBk1b5OE#t=2480
-https://speakerdeck.com/jakewharton/2014-1
+## License
-### 5. Pagination (zip) (wip)
+Licensed under the Apache License, Version 2.0 (the "License").
+You may obtain a copy of the License at
-a. Simple pagination
-b. Optimized pagination
+ http://www.apache.org/licenses/LICENSE-2.0
-### 6. Replacing your event Bus (wip)
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
-http://stackoverflow.com/questions/19266834/rxjava-and-random-sporadic-events-on-android
+You agree that all contributions to this repository, in the form of fixes, pull-requests, new examples etc. follow the above-mentioned license.
diff --git a/app/app.iml b/app/app.iml
deleted file mode 100644
index ada02266..00000000
--- a/app/app.iml
+++ /dev/null
@@ -1,78 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/app/build.gradle b/app/build.gradle
index fba2bd6e..edbcd31c 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -1,38 +1,93 @@
+buildscript {
+ repositories {
+// mavenCentral()
+ jcenter()
+ }
+ dependencies {
+ classpath 'me.tatarka:gradle-retrolambda:3.6.0'
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
+ }
+
+ // Exclude the lombok version that the android plugin depends on.
+ configurations.classpath.exclude group: 'com.android.tools.external.lombok'
+}
+
apply plugin: 'com.android.application'
+apply plugin: 'me.tatarka.retrolambda'
+apply plugin: 'com.f2prateek.javafmt'
+apply plugin: 'kotlin-android'
dependencies {
- compile 'com.android.support:support-v13:20.0.+'
+ compile 'com.android.support:multidex:1.0.1'
+ compile "com.android.support:support-v13:${supportLibVersion}"
+ compile "com.android.support:appcompat-v7:${supportLibVersion}"
+ compile "com.android.support:recyclerview-v7:${supportLibVersion}"
+
+ compile 'com.github.kaushikgopal:CoreTextUtils:c703fa12b6'
+ compile "com.jakewharton:butterknife:${butterKnifeVersion}"
+ kapt "com.jakewharton:butterknife-compiler:${butterKnifeVersion}"
+ compile 'com.jakewharton.timber:timber:4.5.1'
+ compile "com.squareup.retrofit2:retrofit:${retrofitVersion}"
+ compile "com.squareup.retrofit2:converter-gson:${retrofitVersion}"
+ compile "com.squareup.okhttp3:okhttp:${okhttpVersion}"
+ compile "com.squareup.okhttp3:okhttp-urlconnection:${okhttpVersion}"
+ compile 'com.mcxiaoke.volley:library:1.0.19'
+
+ compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
+ compile "com.nhaarman:mockito-kotlin:${mockitoKotlinVersion}"
+
+ compile "android.arch.lifecycle:runtime:${archComponentsVersion}"
+ compile "android.arch.lifecycle:extensions:${archComponentsVersion}"
+ kapt "android.arch.lifecycle:compiler:${archComponentsVersion}"
+
+ // ----------------------------------
+ // Rx dependencies
+
+ compile 'io.reactivex.rxjava2:rxjava:2.0.7'
- compile 'com.google.guava:guava:17.+'
+ // Because RxAndroid releases are few and far between, it is recommended you also
+ // explicitly depend on RxJava's latest version for bug fixes and new features.
+ compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
- compile 'com.jakewharton:butterknife:5.1.1'
- compile 'com.jakewharton.timber:timber:2.2.2'
- compile 'com.netflix.rxjava:rxjava-android:0.17.+'
- compile 'com.squareup.okhttp:okhttp:1.6.+'
- compile 'com.squareup.okhttp:okhttp-urlconnection:1.6.+'
- compile 'com.squareup.retrofit:retrofit:1.5.+'
+ compile 'com.jakewharton.rx:replaying-share-kotlin:2.0.0'
+ compile "com.github.akarnokd:rxjava2-extensions:0.16.0"
+ compile 'com.jakewharton.rxrelay2:rxrelay:2.0.0'
+ compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
+ compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
+
+ // ----------------------------------
+
+ debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.1'
+ releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.1'
}
android {
- compileSdkVersion 19
- buildToolsVersion '19.1.0'
+ compileSdkVersion sdkVersion
+ buildToolsVersion buildToolsVrs
defaultConfig {
applicationId "com.morihacky.android.rxjava"
- minSdkVersion 14
- targetSdkVersion 19
- versionCode 1
- versionName "1.0"
+ minSdkVersion 15
+ targetSdkVersion sdkVersion
+ versionCode 2
+ versionName "1.2"
+ multiDexEnabled true
}
buildTypes {
release {
- runProguard false
+ minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
-}
-
-dependencies {
- compile fileTree(dir: 'libs', include: ['*.jar'])
-}
+ sourceSets {
+ main.java.srcDirs += 'src/main/kotlin'
+ }
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+ packagingOptions {
+ pickFirst 'META-INF/rxjava.properties'
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index dfddcbe4..3b469d7c 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,21 +1,28 @@
+ package="com.morihacky.android.rxjava"
+ >
+ android:theme="@style/AppTheme"
+ >
+ android:label="@string/app_name"
+ >
-
+
-
+
+
+
+
diff --git a/app/src/main/java/com/morihacky/android/rxjava/BufferDemoFragment.java b/app/src/main/java/com/morihacky/android/rxjava/BufferDemoFragment.java
deleted file mode 100644
index 55bfd879..00000000
--- a/app/src/main/java/com/morihacky/android/rxjava/BufferDemoFragment.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package com.morihacky.android.rxjava;
-
-import android.content.Context;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.Looper;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ArrayAdapter;
-import android.widget.ListView;
-
-import com.morihacky.android.rxjava.app.R;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import butterknife.ButterKnife;
-import butterknife.InjectView;
-import butterknife.OnClick;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscriber;
-import rx.android.schedulers.AndroidSchedulers;
-import rx.schedulers.Schedulers;
-import timber.log.Timber;
-
-public class BufferDemoFragment
- extends Fragment {
-
- @InjectView(R.id.list_threading_log) ListView _logsList;
-
- private LogAdapter _adapter;
- private List _logs;
- private int _tapCount = 0;
-
- private Observable> _bufferedObservable;
- private Observer> _observer;
-
- @Override
- public void onActivityCreated(@Nullable Bundle savedInstanceState) {
- super.onActivityCreated(savedInstanceState);
- _setupLogger();
-
- _bufferedObservable = _getBufferedObservable();
- _observer = _getObserver();
- }
-
-
- @OnClick(R.id.btn_start_operation)
- public void onButtonTapped() {
- Timber.d("--------- GOT A TAP");
- _tapCount += 1;
- _log("GOT A TAP");
- _bufferedObservable.subscribeOn(Schedulers.io())
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe(_observer);
- }
-
- // -----------------------------------------------------------------------------------
- // Main Rx entities
-
- private Observable> _getBufferedObservable() {
- return Observable.create(new Observable.OnSubscribe() {
-
-
- @Override
- public void call(Subscriber subscriber) {
- subscriber.onNext(1);
- }
-
- }).buffer(2, TimeUnit.SECONDS);
- }
-
- private Observer> _getObserver() {
- return new Observer>() {
-
-
- @Override
- public void onCompleted() {
- _log(String.format("%d taps", _tapCount));
- _tapCount = 0;
- }
-
- @Override
- public void onError(Throwable e) {
- Timber.e(e, "--------- Woops on error!");
- _log(String.format("Dang error. check your logs"));
- }
-
- @Override
- public void onNext(List integers) {
- Timber.d("--------- onNext");
-
- if (integers.size() > 0) {
- for (int i : integers) {
- _tapCount += i;
- }
- onCompleted();
- } else {
- Timber.d("--------- No taps received ");
- }
- }
- };
- }
-
- // -----------------------------------------------------------------------------------
- // Method that help wiring up the example (irrelevant to RxJava)
-
- @Override
- public View onCreateView(LayoutInflater inflater,
- @Nullable ViewGroup container,
- @Nullable Bundle savedInstanceState) {
- View layout = inflater.inflate(R.layout.fragment_buffer, container, false);
- ButterKnife.inject(this, layout);
- return layout;
- }
-
- private void _setupLogger() {
- _logs = new ArrayList();
- _adapter = new LogAdapter(getActivity(), new ArrayList());
- _logsList.setAdapter(_adapter);
- }
-
- private void _log(String logMsg) {
-
- if (_isCurrentlyOnMainThread()) {
- _logs.add(0, logMsg + " (main thread) ");
- _adapter.clear();
- _adapter.addAll(_logs);
-
- } else {
- _logs.add(0, logMsg + " (NOT main thread) ");
-
- // You can only do below stuff on main thread.
- new Handler(Looper.getMainLooper()).post(new Runnable() {
-
-
- @Override
- public void run() {
- _adapter.clear();
- _adapter.addAll(_logs);
- }
- });
- }
- }
-
- private boolean _isCurrentlyOnMainThread() {
- return Looper.myLooper() == Looper.getMainLooper();
- }
-
-
- private class LogAdapter
- extends ArrayAdapter {
-
- public LogAdapter(Context context, List logs) {
- super(context, R.layout.item_log, R.id.item_log, logs);
- }
- }
-}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/ConcurrencyWithSchedulersDemoFragment.java b/app/src/main/java/com/morihacky/android/rxjava/ConcurrencyWithSchedulersDemoFragment.java
deleted file mode 100644
index 2e4ef885..00000000
--- a/app/src/main/java/com/morihacky/android/rxjava/ConcurrencyWithSchedulersDemoFragment.java
+++ /dev/null
@@ -1,181 +0,0 @@
-package com.morihacky.android.rxjava;
-
-import android.content.Context;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.Looper;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ArrayAdapter;
-import android.widget.ListView;
-import android.widget.ProgressBar;
-
-import com.morihacky.android.rxjava.app.R;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import butterknife.ButterKnife;
-import butterknife.InjectView;
-import butterknife.OnClick;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.android.observables.AndroidObservable;
-import rx.android.schedulers.AndroidSchedulers;
-import rx.schedulers.Schedulers;
-import timber.log.Timber;
-
-public class ConcurrencyWithSchedulersDemoFragment
- extends Fragment {
-
-
- @InjectView(R.id.progress_operation_running) ProgressBar _progress;
- @InjectView(R.id.list_threading_log) ListView _logsList;
-
- private LogAdapter _adapter;
- private List _logs;
- private Subscription _subscription;
-
- @OnClick(R.id.btn_start_operation)
- public void startLongOperation() {
-
- _progress.setVisibility(View.VISIBLE);
- _log("Button Clicked");
-
- _subscription = AndroidObservable.bindFragment(this, _getObservable()) // Observable
- .subscribeOn(Schedulers.io())
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe(_getObserver()); // Observer
- }
-
- // -----------------------------------------------------------------------------------
- // Main Rx entities
-
- private Observable _getObservable() {
- return Observable.create(new Observable.OnSubscribe() {
-
-
- @Override
- public void call(Subscriber observer) {
-
- _log("Within Observable");
-
- _doSomeLongOperation_thatBlocksCurrentThread();
- observer.onNext(true);
- observer.onCompleted();
- }
- });
- }
-
- /**
- * Observer that handles the result List from Observable
- * through the 3 important actions:
- *
- * 1. onCompleted
- * 2. onError
- * 3. onNext
- */
- private Observer _getObserver() {
- return new Observer() {
-
-
- @Override
- public void onCompleted() {
- _log("On complete");
- _progress.setVisibility(View.INVISIBLE);
- }
-
- @Override
- public void onError(Throwable e) {
- Timber.e(e, "Error in RxJava Demo concurrency");
- _log(String.format("Boo Error %s", e.getMessage()));
- _progress.setVisibility(View.INVISIBLE);
- }
-
- @Override
- public void onNext(Boolean aBoolean) {
- _log(String.format("onNext with return value \"%b\"", aBoolean));
- }
- };
- }
-
- @Override
- public void onDestroy() {
- super.onDestroy();
- _subscription.unsubscribe();
- }
-
- private void _log(String logMsg) {
-
- if (_isCurrentlyOnMainThread()) {
- _logs.add(0, logMsg + " (main thread) ");
- _adapter.clear();
- _adapter.addAll(_logs);
-
- } else {
- _logs.add(0, logMsg + " (NOT main thread) ");
-
- // You can only do below stuff on main thread.
- new Handler(Looper.getMainLooper()).post(new Runnable() {
-
-
- @Override
- public void run() {
- _adapter.clear();
- _adapter.addAll(_logs);
- }
- });
- }
- }
-
- // -----------------------------------------------------------------------------------
- // Method that help wiring up the example (irrelevant to RxJava)
-
- private void _doSomeLongOperation_thatBlocksCurrentThread() {
- _log("performing long operation");
-
- try {
- Thread.sleep(3000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
-
- @Override
- public void onActivityCreated(@Nullable Bundle savedInstanceState) {
- super.onActivityCreated(savedInstanceState);
- _setupLogger();
- }
-
- @Override
- public View onCreateView(LayoutInflater inflater,
- @Nullable ViewGroup container,
- @Nullable Bundle savedInstanceState) {
- View layout = inflater.inflate(R.layout.fragment_concurrency_schedulers, container, false);
- ButterKnife.inject(this, layout);
- return layout;
- }
-
- private void _setupLogger() {
- _logs = new ArrayList();
- _adapter = new LogAdapter(getActivity(), new ArrayList());
- _logsList.setAdapter(_adapter);
- }
-
- private boolean _isCurrentlyOnMainThread() {
- return Looper.myLooper() == Looper.getMainLooper();
- }
-
- private class LogAdapter
- extends ArrayAdapter {
-
- public LogAdapter(Context context, List logs) {
- super(context, R.layout.item_log, R.id.item_log, logs);
- }
- }
-}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/MainActivity.java b/app/src/main/java/com/morihacky/android/rxjava/MainActivity.java
index 1c509657..068a393d 100644
--- a/app/src/main/java/com/morihacky/android/rxjava/MainActivity.java
+++ b/app/src/main/java/com/morihacky/android/rxjava/MainActivity.java
@@ -1,26 +1,59 @@
package com.morihacky.android.rxjava;
import android.os.Bundle;
-import android.support.v4.app.FragmentActivity;
+import android.support.v4.app.Fragment;
+import android.support.v7.app.AppCompatActivity;
+import com.morihacky.android.rxjava.fragments.MainFragment;
+import com.morihacky.android.rxjava.fragments.RotationPersist1WorkerFragment;
+import com.morihacky.android.rxjava.fragments.RotationPersist2WorkerFragment;
+import com.morihacky.android.rxjava.rxbus.RxBus;
-import com.morihacky.android.rxjava.app.R;
+public class MainActivity extends AppCompatActivity {
-import timber.log.Timber;
+ private RxBus _rxBus = null;
-public class MainActivity
- extends FragmentActivity {
+ @Override
+ public void onBackPressed() {
+ super.onBackPressed();
+ _removeWorkerFragments();
+ }
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
- Timber.plant(new Timber.DebugTree());
+ if (savedInstanceState == null) {
+ getSupportFragmentManager()
+ .beginTransaction()
+ .replace(android.R.id.content, new MainFragment(), this.toString())
+ .commit();
+ }
+ }
+
+ // This is better done with a DI Library like Dagger
+ public RxBus getRxBusSingleton() {
+ if (_rxBus == null) {
+ _rxBus = new RxBus();
+ }
+
+ return _rxBus;
+ }
+
+ private void _removeWorkerFragments() {
+ Fragment frag =
+ getSupportFragmentManager()
+ .findFragmentByTag(RotationPersist1WorkerFragment.class.getName());
+
+ if (frag != null) {
+ getSupportFragmentManager().beginTransaction().remove(frag).commit();
+ }
+
+ frag =
+ getSupportFragmentManager()
+ .findFragmentByTag(RotationPersist2WorkerFragment.class.getName());
- getSupportFragmentManager().beginTransaction()
- .addToBackStack(this.toString())
-// .replace(R.id.activity_main, new MainFragment(), this.toString())
- .replace(R.id.activity_main, new SubjectDebounceSearchEmitterFragment(), this.toString())
- .commit();
+ if (frag != null) {
+ getSupportFragmentManager().beginTransaction().remove(frag).commit();
}
+ }
}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/MainFragment.java b/app/src/main/java/com/morihacky/android/rxjava/MainFragment.java
deleted file mode 100644
index 402a07da..00000000
--- a/app/src/main/java/com/morihacky/android/rxjava/MainFragment.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package com.morihacky.android.rxjava;
-
-import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.morihacky.android.rxjava.app.R;
-
-import butterknife.ButterKnife;
-import butterknife.OnClick;
-
-public class MainFragment
- extends Fragment {
-
- @Override
- public View onCreateView(LayoutInflater inflater,
- @Nullable ViewGroup container,
- @Nullable Bundle savedInstanceState) {
- View layout = inflater.inflate(R.layout.fragment_main, container, false);
- ButterKnife.inject(this, layout);
- return layout;
- }
-
- @OnClick(R.id.btn_demo_schedulers)
- public void demoConcurrencyWithSchedulers() {
- getActivity().getSupportFragmentManager()
- .beginTransaction()
- .addToBackStack(this.toString())
- .replace(R.id.activity_main,
- new ConcurrencyWithSchedulersDemoFragment(),
- this.toString())
- .commit();
- }
-
- @OnClick(R.id.btn_demo_buffer)
- public void demoBuffer() {
- getActivity().getSupportFragmentManager()
- .beginTransaction()
- .addToBackStack(this.toString())
- .replace(R.id.activity_main,
- new BufferDemoFragment(),
- this.toString())
- .commit();
- }
-
- @OnClick(R.id.btn_demo_subject_debounce)
- public void demoThrottling() {
- getActivity().getSupportFragmentManager()
- .beginTransaction()
- .addToBackStack(this.toString())
- .replace(R.id.activity_main,
- new SubjectDebounceSearchEmitterFragment(),
- this.toString())
- .commit();
- }
-
-}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/MyApp.java b/app/src/main/java/com/morihacky/android/rxjava/MyApp.java
new file mode 100644
index 00000000..23a90b23
--- /dev/null
+++ b/app/src/main/java/com/morihacky/android/rxjava/MyApp.java
@@ -0,0 +1,43 @@
+package com.morihacky.android.rxjava;
+
+import android.support.multidex.MultiDexApplication;
+import com.morihacky.android.rxjava.volley.MyVolley;
+import com.squareup.leakcanary.LeakCanary;
+import com.squareup.leakcanary.RefWatcher;
+import timber.log.Timber;
+
+public class MyApp extends MultiDexApplication {
+
+ private static MyApp _instance;
+ private RefWatcher _refWatcher;
+
+ public static MyApp get() {
+ return _instance;
+ }
+
+ public static RefWatcher getRefWatcher() {
+ return MyApp.get()._refWatcher;
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+
+ if (LeakCanary.isInAnalyzerProcess(this)) {
+ // This process is dedicated to LeakCanary for heap analysis.
+ // You should not init your app in this process.
+ return;
+ }
+
+ _instance = (MyApp) getApplicationContext();
+ _refWatcher = LeakCanary.install(this);
+
+ // for better RxJava debugging
+ //RxJavaHooks.enableAssemblyTracking();
+
+ // Initialize Volley
+ MyVolley.init(this);
+
+ Timber.plant(new Timber.DebugTree());
+ }
+}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/SubjectDebounceSearchEmitterFragment.java b/app/src/main/java/com/morihacky/android/rxjava/SubjectDebounceSearchEmitterFragment.java
deleted file mode 100644
index a81d80ba..00000000
--- a/app/src/main/java/com/morihacky/android/rxjava/SubjectDebounceSearchEmitterFragment.java
+++ /dev/null
@@ -1,185 +0,0 @@
-package com.morihacky.android.rxjava;
-
-import android.content.Context;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.Looper;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ArrayAdapter;
-import android.widget.ListView;
-
-import com.morihacky.android.rxjava.app.R;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import butterknife.ButterKnife;
-import butterknife.InjectView;
-import butterknife.OnTextChanged;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.android.observables.AndroidObservable;
-import rx.android.schedulers.AndroidSchedulers;
-import rx.schedulers.Schedulers;
-import rx.subjects.PublishSubject;
-import timber.log.Timber;
-
-
-/**
- * The reason we use a Subject for tracking the search query is because it emits observables.
- * Because a Subject subscribes to an Observable, it will trigger that Observable to begin emitting items
- * (if that Observable is "cold" — that is, if it waits for a subscription before it begins to emit items).
- * This can have the effect of making the resulting Subject a "hot" Observable variant of the original "cold" Observable.
- *
- * This allows us to create the subject and subscription one time onActivity creation
- * Subsequently we send in Observables to the Subject's subscriber onTextChanged
- *
- * (unlike the way it's done in {@link com.morihacky.android.rxjava.ConcurrencyWithSchedulersDemoFragment#startLongOperation()})
- * where we create the subscription on every single event change (OnClick or OnTextchanged) which is
- *
- * wasteful! : not really since we anyway unsubscribe in OnDestroyView)
- * less-elegant : as a concept for sure
- * simpler actually : adds one more step in the 3 step subscription process, where we create emitter, and then send observables to that emitter)
- * incapable of debounce : this is the primary reason, since creating new observable everytime in subscription disregards debounce on subsequent calls
- */
-public class SubjectDebounceSearchEmitterFragment
- extends Fragment {
-
- @InjectView(R.id.list_threading_log) ListView _logsList;
-
- private LogAdapter _adapter;
- private List _logs;
-
- private Subscription _subscription;
- private PublishSubject> _searchTextEmitterSubject;
-
- @Override
- public void onActivityCreated(@Nullable Bundle savedInstanceState) {
- super.onActivityCreated(savedInstanceState);
- _setupLogger();
-
- _searchTextEmitterSubject = PublishSubject.create();
- _subscription = AndroidObservable.bindFragment(SubjectDebounceSearchEmitterFragment.this,
- Observable.switchOnNext(_searchTextEmitterSubject))
- .debounce(400, TimeUnit.MILLISECONDS, Schedulers.io())
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe(_getSearchObserver());
- }
-
- private Observer _getSearchObserver() {
- return new Observer() {
-
-
- @Override
- public void onCompleted() {
- Timber.d("--------- onComplete");
- }
-
- @Override
- public void onError(Throwable e) {
- Timber.e(e, "--------- Woops on error!");
- _log(String.format("Dang error. check your logs"));
- }
-
- @Override
- public void onNext(String searchText) {
- _log(String.format("onNext You searched for %s", searchText));
- onCompleted();
- }
- };
- }
-
- @OnTextChanged(R.id.input_txt_subject_debounce)
- public void onTextEntered(CharSequence charsEntered) {
- Timber.d("---------- text entered %s", charsEntered);
- _searchTextEmitterSubject.onNext(_getASearchObservableFor(charsEntered.toString()));
- }
-
- // -----------------------------------------------------------------------------------
- // Main Rx entities
-
- /**
- * @param searchText search text entered onTextChange
- *
- * @return a new observable which searches for text searchText, explicitly say you want subscription to be done on a a non-UI thread, otherwise it'll default to the main thread.
- */
- private Observable _getASearchObservableFor(final String searchText) {
- return Observable.create(new Observable.OnSubscribe() {
-
-
- @Override
- public void call(Subscriber subscriber) {
-
- Timber.d("----------- inside the search observable");
- subscriber.onNext(searchText);
- // subscriber.onCompleted(); This seems to have no effect.
- }
- }).subscribeOn(Schedulers.io());
- }
-
- @Override
- public void onDestroy() {
- super.onDestroy();
- _subscription.unsubscribe();
- }
-
- // -----------------------------------------------------------------------------------
- // Method that help wiring up the example (irrelevant to RxJava)
-
- @Override
- public View onCreateView(LayoutInflater inflater,
- @Nullable ViewGroup container,
- @Nullable Bundle savedInstanceState) {
- View layout = inflater.inflate(R.layout.fragment_subject_debounce, container, false);
- ButterKnife.inject(this, layout);
- return layout;
- }
-
- private void _setupLogger() {
- _logs = new ArrayList();
- _adapter = new LogAdapter(getActivity(), new ArrayList());
- _logsList.setAdapter(_adapter);
- }
-
- private void _log(String logMsg) {
-
- if (_isCurrentlyOnMainThread()) {
- _logs.add(0, logMsg + " (main thread) ");
- _adapter.clear();
- _adapter.addAll(_logs);
-
- } else {
- _logs.add(0, logMsg + " (NOT main thread) ");
-
- // You can only do below stuff on main thread.
- new Handler(Looper.getMainLooper()).post(new Runnable() {
-
-
- @Override
- public void run() {
- _adapter.clear();
- _adapter.addAll(_logs);
- }
- });
- }
- }
-
- private boolean _isCurrentlyOnMainThread() {
- return Looper.myLooper() == Looper.getMainLooper();
- }
-
- private class LogAdapter
- extends ArrayAdapter {
-
- public LogAdapter(Context context, List logs) {
- super(context, R.layout.item_log, R.id.item_log, logs);
- }
- }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/morihacky/android/rxjava/fragments/BaseFragment.java b/app/src/main/java/com/morihacky/android/rxjava/fragments/BaseFragment.java
new file mode 100644
index 00000000..4ce242f3
--- /dev/null
+++ b/app/src/main/java/com/morihacky/android/rxjava/fragments/BaseFragment.java
@@ -0,0 +1,15 @@
+package com.morihacky.android.rxjava.fragments;
+
+import android.support.v4.app.Fragment;
+import com.morihacky.android.rxjava.MyApp;
+import com.squareup.leakcanary.RefWatcher;
+
+public class BaseFragment extends Fragment {
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ RefWatcher refWatcher = MyApp.getRefWatcher();
+ refWatcher.watch(this);
+ }
+}
diff --git a/app/src/main/java/com/morihacky/android/rxjava/fragments/BufferDemoFragment.java b/app/src/main/java/com/morihacky/android/rxjava/fragments/BufferDemoFragment.java
new file mode 100644
index 00000000..bf51b85c
--- /dev/null
+++ b/app/src/main/java/com/morihacky/android/rxjava/fragments/BufferDemoFragment.java
@@ -0,0 +1,160 @@
+package com.morihacky.android.rxjava.fragments;
+
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.support.annotation.Nullable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ListView;
+
+import com.jakewharton.rxbinding2.view.RxView;
+import com.morihacky.android.rxjava.R;
+import com.morihacky.android.rxjava.wiring.LogAdapter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import butterknife.Unbinder;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.observers.DisposableObserver;
+import timber.log.Timber;
+
+/**
+ * This is a demonstration of the `buffer` Observable.
+ *
+ *
The buffer observable allows taps to be collected only within a time span. So taps outside the
+ * 2s limit imposed by buffer will get accumulated in the next log statement.
+ *
+ *
If you're looking for a more foolproof solution that accumulates "continuous" taps vs a more
+ * dumb solution as show below (i.e. number of taps within a timespan) look at {@link
+ * com.morihacky.android.rxjava.rxbus.RxBusDemo_Bottom3Fragment} where a combo of `publish` and
+ * `buffer` is used.
+ *
+ *