Java Code Examples for io.reactivex.subjects.ReplaySubject#create()

@Test public void shouldRedeliverSameResultsToDifferentSubscriber() {
  // Use case: When rotating an activity, ObservableManager will re-subscribe original request's
  // Observable to a new Observer, which is a member of the new activity instance. In this
  // case, we may want to redeliver any previous results (if the request is still being
  // managed by ObservableManager).
  TestObserver<String> observer = new TestObserver<>();
  ReplaySubject<String> subject = ReplaySubject.create();
  SubscriptionProxy<String> proxy = SubscriptionProxy.create(subject);

  proxy.subscribe(observer);

  subject.onNext("Avanti!");
  subject.onComplete();

  proxy.dispose();

  TestObserver<String> newSubscriber = new TestObserver<>();
  proxy.subscribe(newSubscriber);

  newSubscriber.awaitTerminalEvent(3, TimeUnit.SECONDS);
  newSubscriber.assertComplete();
  newSubscriber.assertValue("Avanti!");

  observer.assertComplete();
  observer.assertValue("Avanti!");
}
 

@Test public void testUnsubscribeBeforeEmit() {
  TestObserver<String> observer = new TestObserver<>();
  ReplaySubject<String> subject = ReplaySubject.create();
  SubscriptionProxy<String> proxy = SubscriptionProxy.create(subject);

  proxy.subscribe(observer);
  proxy.dispose();

  observer.assertNotComplete();
  observer.assertNoValues();

  subject.onNext("Avanti!");
  subject.onComplete();

  // disposable observables may not be resused in RxJava2
  observer = new TestObserver<>();
  proxy.subscribe(observer);
  observer.assertComplete();
  observer.assertValue("Avanti!");
}
 

private void doSomeWork() {

        ReplaySubject<Integer> source = ReplaySubject.create();

        source.subscribe(getFirstObserver()); // it will get 1, 2, 3, 4

        source.onNext(1);
        source.onNext(2);
        source.onNext(3);
        source.onNext(4);
        source.onComplete();

        /*
         * it will emit 1, 2, 3, 4 for second observer also as we have used replay
         */
        source.subscribe(getSecondObserver());

    }
 

@Test
public void testSubjectMulticastExample() {

    /*
     * Step 1: Create an observable that emits an integer
     * from 1 to 5. Each item is squared by itself before it is
     * emitted.
     *  */
    Observable<Integer> observable = Observable.range(1, 5)
            .subscribeOn(Schedulers.io())
            .map(integer -> {
                System.out.println(String.format("Squaring %d with itself", integer));
                return integer * integer;
            });

    /*
     * Step 2: Create a subject that observes
     * this emission from the observable.
     *  */
    ReplaySubject<Integer> subject = ReplaySubject.create();
    observable.subscribe(subject);


    /*
     * Step 3: We are subscribing two subscribers to the Subject.
     *  */
    subject.subscribe(s -> System.out.println("subscriber one: " + s));
    subject.subscribe(s -> System.out.println("subscriber two: " + s));
}
 

public AbstractDataSet(IPaged policy) {
	this.status = Status.CREATED;
	this.count = 0;
	this.tester = new LoggerUtil();
	this.max = policy.hasMax()
			? (policy.hasPerIteration() ? policy.perIteration() : 1) * policy.increment() * policy.max()
			: null;
	if (max != null) {
		this.subject = ReplaySubject.create(max > 1000 ? 1000 : max);
	}
}
 

@Test
public void testSubmitJobEventListenersEchoStderrWhenExecutorEchoesStderr() throws InterruptedException {
    final Subject<byte[]> stderr = ReplaySubject.create();
    final byte[] stderrBytes = generateRandomBytes();
    stderr.onNext(stderrBytes);

    final JobExecutor jobExecutor = MockJobExecutor.thatUses(Observable.never(), stderr);
    final JobManager jobManager = createManagerWith(jobExecutor);

    final Semaphore s = new Semaphore(1);
    s.acquire();

    final JobEventListeners listeners = JobEventListeners.createStderrListener(new Observer<byte[]>() {
        @Override
        public void onSubscribe(@NonNull Disposable disposable) {}

        @Override
        public void onNext(@NonNull byte[] bytes) {
            assertThat(bytes).isEqualTo(stderrBytes);
            s.release();
        }

        @Override
        public void onError(@NonNull Throwable throwable) {
            fail("Error from observable");
            s.release();
        }

        @Override
        public void onComplete() {}
    });

    jobManager.submit(STANDARD_VALID_REQUEST, listeners);

    if (!s.tryAcquire(1, SECONDS)) {
        fail("Timed out before any bytes received");
    }
}
 

public AbstractDataSet() {
	this.status = Status.CREATED;
	this.count = 0;
	this.tester = new LoggerUtil();
	this.max = null;
	this.subject = ReplaySubject.create();
}
 

public AbstractDataSet(Integer max) {
	this.status = Status.CREATED;
	this.count = 0;
	this.tester = new LoggerUtil();
	this.max = max;
	this.subject = ReplaySubject.create(max);
}
 

@Test
void replaySubject_test() {
    ReplaySubject<Object> replaySubject = ReplaySubject.create();
    replaySubject.onNext(1l);
    replaySubject.onNext(2l);
    replaySubject.subscribe(x -> log("一郎神: " + x),
            Throwable::printStackTrace,
            () -> System.out.println("Emission completed"),
            disposable -> System.out.println("onSubscribe")
    );
    replaySubject.onNext(10l);
    replaySubject.onComplete();

}
 

@Override
protected Subject<PageLifecycleEventInfo> createSubject() {
    return ReplaySubject.create();
}
 

public Data(){
	this.status = Status.CREATED;
	this.subject = ReplaySubject.create();
}
 

@Override
protected Subject<LeakInfo> createSubject() {
    return ReplaySubject.create();
}
 

@Override
protected Subject<LeakQueue.LeakMemoryInfo> createSubject() {
    return ReplaySubject.create();
}
 

@Override
protected Subject<List<CrashInfo>> createSubject() {
    return ReplaySubject.create();
}
 

public static RxJava2SubjProxy replaySubjectProxy() {
    return new RxJava2SubjProxy(ReplaySubject.create(), Roxy.TePolicy.PASS);
}
 

/**
 * Build a new {@link RxBleClientMock}.
 */
public Builder() {
    this.discoverableDevicesSubject = ReplaySubject.create();
    this.bondedDevices = new HashSet<>();
}
 

@Override
protected Subject<NetworkInfo> createSubject() {
    return ReplaySubject.create();
}
 

public static void main(String[] args) {
	// TODO Auto-generated method stub
	Observer<Long> observer=new Observer<Long>() {

		@Override
		public void onComplete() {
			// TODO Auto-generated method stub
			System.out.println("It's Done");
			
		}

		@Override
		public void onError(Throwable throwable) {
			// TODO Auto-generated method stub
			throwable.printStackTrace();
			
		}

		@Override
		public void onNext(Long value) {
			// TODO Auto-generated method stub
			System.out.println(":"+value);
		}

		@Override
		public void onSubscribe(Disposable disposable) {
			// TODO Auto-generated method stub
			System.out.println("onSubscribe");
			
		}
	};
	
	ReplaySubject<Long> replaySubject=ReplaySubject.create();
	replaySubject.onNext(1l);
	replaySubject.onNext(2l);
	replaySubject.subscribe(observer);
	replaySubject.onNext(10l);
	replaySubject.onComplete();
	

}
 

@Before
public void setup() throws Exception {
    super.setup();
    sessionPub = ReplaySubject.create();
    sessionPub.onNext(rxProcessSession);
    when(rxProcess.open()).thenAnswer(invocation -> {
        when(rxProcessSession.waitFor()).thenReturn(Single.create(e -> waitForEmitter = e));
        return sessionPub.firstOrError();
    });

    cmdStream = new MockOutputStream(new MockOutputStream.Listener() {
        @Override
        public void onNewLine(String line) {
            if (line.equals("exit" + LineReader.getLineSeparator())) {
                try {
                    cmdStream.close();
                } catch (IOException e) {
                    Timber.e(e);
                } finally {
                    waitForEmitter.onSuccess(0);
                }
            }
        }

        @Override
        public void onClose() {

        }
    });
    outputStream = new MockInputStream();
    errorStream = new MockInputStream();

    when(rxProcessSession.input()).thenReturn(cmdStream);
    when(rxProcessSession.output()).thenReturn(outputStream);
    when(rxProcessSession.error()).thenReturn(errorStream);
    when(rxProcessSession.isAlive()).thenReturn(Single.create(e -> e.onSuccess(cmdStream.isOpen())));

    when(rxProcessSession.destroy()).then(invocation -> Completable.create(e -> {
        cmdStream.close();
        waitForEmitter.onSuccess(1);
        e.onComplete();
    }));
}
 

public static RxJava2SubjProxy safeReplaySubjectProxy() {
    return new RxJava2SubjProxy(ReplaySubject.create(), Roxy.TePolicy.WRAP);
}