How to merge 2 separate streams, buffer populated data from them and subsrcibe to it after some amout of time - kotlin

Question

I am trying to test situation like this:
I have 2 classess which just extends from the same Parent.
I am creating and Observables from the list of items for each of the class:
val listSomeClass1 = ArrayList<SomeClass1>()
val listSomeClass2 = ArrayList<SomeClass2>()
fun populateJust1() {
listSomeClass1.add(SomeClass1("23", 23))
listSomeClass1.add(SomeClass1("24", 24))
listSomeClass1.add(SomeClass1("25", 25))
}
fun populateJust2() {
listSomeClass2.add(SomeClass2(23.00))
listSomeClass2.add(SomeClass2(24.00))
listSomeClass2.add(SomeClass2(25.00))
}
populateItemsSomeClass1()
populateItemsSomeClass2()
Now i can create 2 observables:
val someClass1Observable = Observable.fromIterable(listSomeClass1)
val someClass2Observable = Observable.fromIterable(listSomeClass2)
And here, i want to merge emission from them, buffer it, and subscribe to it after 10 seconds:
Observable.merge(someClass1Observable, someClass2Observable)
.buffer(10, TimeUnit.SECONDS)
.doOnSubscribe { Log.v("parentObservable", "STARTED") }
.subscribe { t: MutableList<Parent> ->
Log.v("parentObservable", "onNext")
t.forEach { Log.v("onNext", it.toString()) }
}
However, the observable is not starting after 10 seconds as i expected, and just starts immedietaly with this data ready.
How to simulate something like this, that i will gather 2 separate streams and after 10 seconds i will be able to get the gathered data
I must point that i don't want to use any Subject.
UPDATE
I've done somehitng like this:
val list1 = listOf(SomeClass1("1", 1), SomeClass1("2", 2), SomeClass1("3", 3))
val list2 = listOf(SomeClass2(5.00), SomeClass2(4.00), SomeClass2(6.00))
val someClass1Observable = Observable
.fromIterable(list1)
.zipWith(Observable.interval(2, TimeUnit.SECONDS),
BiFunction { item: SomeClass1, _: Long -> item })
val someClass2Observable = Observable
.fromIterable(list2)
.zipWith(Observable.interval(1, TimeUnit.SECONDS),
BiFunction { item: SomeClass2, _: Long -> item })
someClass1Observable.subscribe {
Log.v("someClass1", it.toString())
}
someClass2Observable.subscribe {
Log.v("someClass2", it.toString())
}
Observable.merge(someClass1Observable, someClass2Observable)
.buffer(10, TimeUnit.SECONDS)
.delay(10, TimeUnit.SECONDS)
.doOnSubscribe { Log.v("parentObservable", "STARTED") }
.subscribe { t: MutableList<Parent> ->
Log.v("parentObservable", "onNext")
t.forEach { Log.v("onNext", it.toString()) }
}
Thread.sleep(13000)
someClass1Observable.subscribe {
Log.v("someClass1", it.toString())
}
someClass2Observable.subscribe {
Log.v("someClass2", it.toString())
}
Here, i want to just simulate 2 infinite streams of someClass1 and someclass2 Observables and same for the merge Observable.
Again, i want to have ability to merge those 2 streams, buffer populated data and do something with it after 10 seconds. If after 10 seconds those 2 streams will again populate some data, the merge Observable should clean previous buffer, and should again buffer new data and emit after 10 seconds and so on, infinite. However, my code is not working as i expected, what changes I need to do to make it as i described?

Answer 1

I think you're looking for the delay operator
http://reactivex.io/documentation/operators/delay.html
Delay
shift the emissions from an Observable forward in time by a particular amount
So something like:
.delay(10, TimeUnit.SECONDS)