io.reactivex.subjects.BehaviorSubject Java Examples

@Before
public void setUp() throws Exception {
    List<ViewModel> vms = TestViewModel.dummyViewModels(INITIAL_COUNT);

    viewModelsSource = BehaviorSubject.createDefault(vms);
    testViewProvider = new TestViewProvider();
    testBinder = new TestViewModelBinder();
    subscriptionCounter = new SubscriptionCounter<>();
    sut = new RecyclerViewAdapter(viewModelsSource.compose(subscriptionCounter),
            testViewProvider, testBinder);

    notifyCallCount = 0;
    defaultObserver = new RecyclerView.AdapterDataObserver() {
        @Override
        public void onChanged() {
            notifyCallCount++;
        }
    };
    sut.registerAdapterDataObserver(defaultObserver);
}
 

@Override
public <T extends Notification<?>> Flowable<T> subscribe(
        Request request, String unsubscribeMethod, Class<T> responseType) {
    // We can't use usual Observer since we can call "onError"
    // before first client is subscribed and we need to
    // preserve it
    BehaviorSubject<T> subject = BehaviorSubject.create();

    // We need to subscribe synchronously, since if we return
    // an Flowable to a client before we got a reply
    // a client can unsubscribe before we know a subscription
    // id and this can cause a race condition
    subscribeToEventsStream(request, subject, responseType);

    return subject.doOnDispose(() -> closeSubscription(subject, unsubscribeMethod))
            .toFlowable(BackpressureStrategy.BUFFER);
}
 

@Override
public <T extends Notification<?>> Flowable<T> subscribe(
        Request request, String unsubscribeMethod, Class<T> responseType) {
    // We can't use usual Observer since we can call "onError"
    // before first client is subscribed and we need to
    // preserve it
    BehaviorSubject<T> subject = BehaviorSubject.create();

    // We need to subscribe synchronously, since if we return
    // an Flowable to a client before we got a reply
    // a client can unsubscribe before we know a subscription
    // id and this can cause a race condition
    subscribeToEventsStream(request, subject, responseType);

    return subject.doOnDispose(() -> closeSubscription(subject, unsubscribeMethod))
            .toFlowable(BackpressureStrategy.BUFFER);
}
 

@Test
public void testClose_waitForCommands() {
    BehaviorSubject<Boolean> idler = BehaviorSubject.createDefault(false);
    when(cmdProcessor.isIdle()).thenReturn(idler);

    RxCmdShell shell = new RxCmdShell(builder, rxShell);
    shell.open().test().awaitDone(1, TimeUnit.SECONDS).assertNoTimeout().values().get(0);
    shell.isAlive().test().awaitDone(1, TimeUnit.SECONDS).assertNoTimeout().assertValue(true);

    shell.close().test().awaitDone(1, TimeUnit.SECONDS).assertTimeout();

    idler.onNext(true);

    shell.close().test().awaitDone(1, TimeUnit.SECONDS).assertNoTimeout().assertValue(0);

    verify(cmdProcessor).isIdle();
    verify(rxShellSession).close();
}
 

@Override
public Observable<ConnectableState> connect() {
  if (sharedConnectionState != null) {
    return sharedConnectionState;
  }

  connectionStateSubject = BehaviorSubject.create();

  sharedConnectionState =
      connectionStateSubject
          .doOnNext(state -> connectedRelay.accept(state == CONNECTED))
          .doOnSubscribe(disposable -> processConnect())
          .doFinally(() -> disconnect())
          .replay(1)
          .refCount(); // Don't do this on normal disconnect status 0 / 8

  return sharedConnectionState;
}
 

public SearchTEPresenter(SearchTEContractsModule.View view,
                         D2 d2,
                         SearchRepository searchRepository,
                         SchedulerProvider schedulerProvider,
                         AnalyticsHelper analyticsHelper,
                         @Nullable String initialProgram) {
    this.view = view;
    this.searchRepository = searchRepository;
    this.d2 = d2;
    this.schedulerProvider = schedulerProvider;
    this.analyticsHelper = analyticsHelper;
    compositeDisposable = new CompositeDisposable();
    queryData = new HashMap<>();
    queryProcessor = PublishProcessor.create();
    mapProcessor = PublishProcessor.create();
    enrollmentMapProcessor = PublishProcessor.create();
    selectedProgram = initialProgram != null ? d2.programModule().programs().uid(initialProgram).blockingGet() : null;
    currentProgram = BehaviorSubject.createDefault(initialProgram != null ? initialProgram : "");
}
 

@Test
public void test() {
    BehaviorSubject<Integer> subject = BehaviorSubject.create();

    Observable<Integer> observable = subject
            .doOnNext(e -> { 
                System.out.println("This emits for second subscriber"); 
            })
            .doOnSubscribe(s -> System.out.println("OnSubscribe"))
            .doOnDispose(() -> System.out.println("OnDispose"))
            .replay(1)
            .refCount()
            .doOnNext(e -> { System.out.println("This does NOT emit for second subscriber"); });

    System.out.println("Subscribe-1");
    // This line causes the test to fail.
    observable.takeUntil(Observable.just(1)).test();

    subject.onNext(2);

    System.out.println("Subscribe-2");
    TestObserver<Integer> subscriber = observable.take(1).test();
    Assert.assertTrue(subscriber.awaitTerminalEvent(2, TimeUnit.SECONDS));
}
 

public static Observable<String> fromSearchView(@NonNull final SearchView searchView) {
    final BehaviorSubject<String> subject = BehaviorSubject.create();

    searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {

        @Override
        public boolean onQueryTextSubmit(String query) {
            subject.onNext(query);
            subject.onComplete();
            searchView.clearFocus();
            return true;
        }

        @Override
        public boolean onQueryTextChange(String newText) {
            subject.onNext(newText);
            return true;
        }
    });

    return subject;
}
 

@Inject
public LocationManager(
    Application app,
    PermissionsManager permissionsManager,
    SettingsManager settingsManager,
    RxFusedLocationProviderClient locationClient) {
  this.permissionsManager = permissionsManager;
  this.settingsManager = settingsManager;
  this.locationClient = locationClient;
  this.locationUpdates = BehaviorSubject.create();
  this.locationUpdateCallback = RxLocationCallback.create(locationUpdates);
}
 

private <T extends Notification<?>> String getSubscriptionId(BehaviorSubject<T> subject) {
    return subscriptionForId
            .entrySet()
            .stream()
            .filter(entry -> entry.getValue().getSubject() == subject)
            .map(Map.Entry::getKey)
            .findFirst()
            .orElse(null);
}
 

boolean processRound(BehaviorSubject<String> addToConsoleOutput) throws Exception {
    if (roundProcessed) {
        throw new InvalidOperationException("This round has already been processed!");
    }
    boolean processed = gameRoundProcessor.processRound(gameMap, commandsToProcess);

    ArrayList<String> errorList = gameRoundProcessor.getErrorList();
    String errorListText = "Error List: " + Arrays.toString(errorList.toArray());
    addToConsoleOutput.onNext(errorListText);

    roundProcessed = true;

    return processed;
}
 

public GameEngineRunner() {
    this.unsubscribe = BehaviorSubject.create();
    this.addToConsoleOutput = BehaviorSubject.create();
    this.addToConsoleOutput
            .takeUntil(this.unsubscribe)
            .subscribe(text -> consoleOutput += text);
}
 

private <T extends Notification<?>> void processSubscriptionResponse(
        EthSubscribe subscriptionReply, BehaviorSubject<T> subject, Class<T> responseType) {
    if (!subscriptionReply.hasError()) {
        establishSubscription(subject, responseType, subscriptionReply);
    } else {
        reportSubscriptionError(subject, subscriptionReply);
    }
}
 

private <T extends Notification<?>> void establishSubscription(
        BehaviorSubject<T> subject, Class<T> responseType, EthSubscribe subscriptionReply) {
    log.debug("Subscribed to RPC events with id {}", subscriptionReply.getSubscriptionId());
    subscriptionForId.put(
            subscriptionReply.getSubscriptionId(),
            new WebSocketSubscription<>(subject, responseType));
}
 

private <T extends Notification<?>> void reportSubscriptionError(
        BehaviorSubject<T> subject, BcosSubscribe subscriptionReply) {
    Response.Error error = subscriptionReply.getError();
    log.error("Subscription request returned error: {}", error.getMessage());
    subject.onError(
            new IOException(
                    String.format(
                            "Subscription request failed with error: %s", error.getMessage())));
}
 

private <T extends Notification<?>> String getSubscriptionId(BehaviorSubject<T> subject) {
    return subscriptionForId.entrySet().stream()
            .filter(entry -> entry.getValue().getSubject() == subject)
            .map(Map.Entry::getKey)
            .findFirst()
            .orElse(null);
}
 

private <T extends Notification<?>> void reportSubscriptionError(
        BehaviorSubject<T> subject, EthSubscribe subscriptionReply) {
    Response.Error error = subscriptionReply.getError();
    log.error("Subscription request returned error: {}", error.getMessage());
    subject.onError(
            new IOException(
                    String.format(
                            "Subscription request failed with error: %s", error.getMessage())));
}
 

@Test
void behaviorSubject_test() {
    BehaviorSubject<Object> behaviorSubject = BehaviorSubject.create();

    behaviorSubject.onNext(1L);
    behaviorSubject.onNext(2L);
    behaviorSubject.subscribe(x -> log("一郎神: " + x),
            Throwable::printStackTrace,
            () -> System.out.println("Emission completed"),
            disposable -> System.out.println("onSubscribe")
    );
    behaviorSubject.onNext(10L);
    behaviorSubject.onComplete();
}
 

private <T extends Notification<?>> void subscribeToEventsStream(
        Request request, BehaviorSubject<T> subject, Class<T> responseType) {

    subscriptionRequestForId.put(
            request.getId(), new WebSocketSubscription<>(subject, responseType));
    try {
        send(request, EthSubscribe.class);
    } catch (IOException e) {
        log.error("Failed to subscribe to RPC events with request id {}", request.getId());
        subject.onError(e);
    }
}
 

private <T extends Notification<?>> void closeSubscription(
        BehaviorSubject<T> subject, String unsubscribeMethod) {
    String subscriptionId = getSubscriptionId(subject);
    if (subscriptionId != null) {
        subscriptionForId.remove(subscriptionId);
        unsubscribeFromEventsStream(subscriptionId, unsubscribeMethod);
    } else {
        log.warn("Trying to unsubscribe from a non-existing subscription. Race condition?");
    }
}
 

/**
 * Constructs a new GoogleAccount instance.
 */

GoogleAccount(Context context, @Nullable Account account, GoogleSignInAccount googleSignInAccount) {
  super(context);
  accountSubject =
      (account != null) ? BehaviorSubject.createDefault(account) : BehaviorSubject.create();
  this.googleSignInAccount = googleSignInAccount;
  this.account = googleSignInAccount.getAccount();
  setAccount(account);
  this.accountKey = AccountsUtils.makeAccountKey(NAMESPACE, this.googleSignInAccount.getId());
}
 

public AbstractAccountsProvider(Context context) {
  applicationContext = context.getApplicationContext();
  usageTracker = WhistlePunkApplication.getUsageTracker(applicationContext);
  NonSignedInAccount nonSignedInAccount = NonSignedInAccount.getInstance(applicationContext);
  addAccount(nonSignedInAccount);
  currentAccount = nonSignedInAccount;
  observableCurrentAccount = BehaviorSubject.createDefault(nonSignedInAccount);
}
 

private void addServiceObserverIfNeeded(
    final String sensorId,
    final List<SensorTrigger> activeTriggers,
    SensorRegistry sensorRegistry) {
  if (!latestValues.containsKey(sensorId)) {
    latestValues.put(sensorId, BehaviorSubject.<ScalarReading>create());
  }

  if (!serviceObservers.containsKey(sensorId)) {
    String serviceObserverId =
        registry.putListeners(
            sensorId,
            (timestamp, data) -> {
              if (!ScalarSensor.hasValue(data)) {
                return;
              }
              double value = ScalarSensor.getValue(data);

              // Remember latest value
              latestValues.get(sensorId).onNext(new ScalarReading(timestamp, value, sensorId));

              // Fire triggers.
              for (SensorTrigger trigger : activeTriggers) {
                if (!isRecording() && trigger.shouldTriggerOnlyWhenRecording()) {
                  continue;
                }
                if (trigger.isTriggered(value)) {
                  fireSensorTrigger(trigger, timestamp, sensorRegistry);
                }
              }
            },
            null);
    serviceObservers.put(sensorId, serviceObserverId);
  }
}
 

private MaybeSource<SensorSnapshot> makeSnapshot(String sensorId, SensorRegistry sensorRegistry)
    throws Exception {
  BehaviorSubject<ScalarReading> subject = latestValues.get(sensorId);
  if (subject == null) {
    return Maybe.empty();
  }
  final GoosciSensorSpec.SensorSpec spec = getSensorSpec(sensorId, sensorRegistry);
  return subject.firstElement().map(value -> generateSnapshot(spec, value));
}
 

@Test
public void firstElementAsBehaviorSubjectChanges() {
  BehaviorSubject<String> subject = BehaviorSubject.create();
  TestObserver<String> beforeTest = subject.firstElement().test();

  subject.onNext("A");
  TestObserver<String> firstTest = subject.firstElement().test();
  firstTest.assertValue("A").assertComplete();
  beforeTest.assertValue("A").assertComplete();

  subject.onNext("B");
  TestObserver<String> secondTest = subject.firstElement().test();
  secondTest.assertValue("B").assertComplete();
}
 

@Before
public void setUp() throws Exception {
    viewModelsSource = BehaviorSubject.createDefault(TestViewModel.dummyViewModels(INITIAL_COUNT));
    testViewProvider = new TestViewProvider();
    testBinder = new TestViewModelBinder();
    subscriptionCounter = new SubscriptionCounter<>();
    sut = new TestViewPagerAdapter(viewModelsSource.compose(subscriptionCounter),
            testViewProvider, testBinder);

    connection = sut.connect();
}
 

@Before
public void setUp() throws Exception {
    sourceSubject = BehaviorSubject.createDefault(INITIAL_VALUE);
    subscriptionCounter = new SubscriptionCounter<>();
    Observable<Integer> source = sourceSubject.compose(subscriptionCounter);
    sut = ReadOnlyField.create(source);
}
 

@Test
public void bothInit() {
    BehaviorSubject<String> s1 = BehaviorSubject.createDefault("");
    BehaviorSubject<String> s2 = BehaviorSubject.createDefault("");
    
    s1.withLatestFrom(s2, (a, b) -> true)
    .test()
    .assertValue(true);
}
 

@Test
public void secondInit() {
    BehaviorSubject<String> s1 = BehaviorSubject.create();
    BehaviorSubject<String> s2 = BehaviorSubject.createDefault("");

    TestObserver<Boolean> to = s1.withLatestFrom(s2, (a, b) -> true)
    .test();

    to.assertEmpty();

    s1.onNext("");

    to.assertValue(true);
}
 

/**
 * Creates a new Presenter with the initial view state
 *
 * @param initialViewState initial view state (must be not null)
 */
public MviBasePresenter(@NonNull VS initialViewState) {
    if (initialViewState == null) {
        throw new NullPointerException("Initial ViewState == null");
    }

    viewStateBehaviorSubject = BehaviorSubject.createDefault(initialViewState);
    reset();
}