@Test
  public void exampleEquivalence() {
    TestScheduler scheduler = Schedulers.test();
    TestSubscriber<Object> testerJoin = new TestSubscriber<>();
    TestSubscriber<Object> testerGroupJoin = new TestSubscriber<>();

    Observable<Long> left = Observable.interval(100, TimeUnit.MILLISECONDS, scheduler);
    Observable<Long> right = Observable.interval(100, TimeUnit.MILLISECONDS, scheduler);

    left.join(
            right,
            i -> Observable.timer(150, TimeUnit.MILLISECONDS, scheduler),
            i -> Observable.timer(0, TimeUnit.MILLISECONDS, scheduler),
            (l, r) -> Tuple.create(l, r))
        .take(10)
        .subscribe(testerJoin);

    left.groupJoin(
            right,
            i -> Observable.timer(150, TimeUnit.MILLISECONDS, scheduler),
            i -> Observable.timer(0, TimeUnit.MILLISECONDS, scheduler),
            (l, rs) -> rs.map(r -> Tuple.create(l, r)))
        .flatMap(i -> i)
        .take(10)
        .subscribe(testerGroupJoin);

    scheduler.advanceTimeTo(600, TimeUnit.MILLISECONDS);
    testerJoin.assertReceivedOnNext(testerGroupJoin.getOnNextEvents());
  }
  @Test
  public void test() {
    TestSubscriber<Object> tester = new TestSubscriber<>();
    TestScheduler scheduler = Schedulers.test();

    Observable<Long> left = Observable.interval(100, TimeUnit.MILLISECONDS, scheduler).take(6);
    Observable<Long> right = Observable.interval(200, TimeUnit.MILLISECONDS, scheduler).take(3);

    left.groupJoin(
            right,
            i -> Observable.never(),
            i -> Observable.timer(0, TimeUnit.MILLISECONDS, scheduler),
            (l, rs) -> rs.toList().map(rl -> Tuple.create(l, rl)))
        .flatMap(i -> i)
        .subscribe(tester);

    scheduler.advanceTimeTo(600, TimeUnit.MILLISECONDS);
    tester.assertReceivedOnNext(
        Arrays.asList(
            Tuple.create(0L, Arrays.asList(0L, 1L, 2L)),
            Tuple.create(1L, Arrays.asList(0L, 1L, 2L)),
            Tuple.create(2L, Arrays.asList(1L, 2L)),
            Tuple.create(3L, Arrays.asList(1L, 2L)),
            Tuple.create(4L, Arrays.asList(2L)),
            Tuple.create(5L, Arrays.asList(2L))));
  }
  /**
   * Make sure we get a MissingBackpressureException propagated through when we have a fast temporal
   * (hot) producer.
   */
  @Test
  public void testHotOperatorBackpressure() {
    TestSubscriber<String> ts = new TestSubscriber<String>();
    Observable.timer(0, 1, TimeUnit.MICROSECONDS)
        .observeOn(Schedulers.computation())
        .map(
            new Func1<Long, String>() {

              @Override
              public String call(Long t1) {
                System.out.println(t1);
                try {
                  Thread.sleep(100);
                } catch (InterruptedException e) {
                }
                return t1 + " slow value";
              }
            })
        .subscribe(ts);

    ts.awaitTerminalEvent();
    System.out.println("Errors: " + ts.getOnErrorEvents());
    assertEquals(1, ts.getOnErrorEvents().size());
    assertEquals(MissingBackpressureException.class, ts.getOnErrorEvents().get(0).getClass());
  }
  private Observable<Void> handleHystrixRequest(final HttpServerResponse<O> response) {
    writeHeaders(response);

    final Subject<Void, Void> subject = PublishSubject.create();
    final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
    Subscription actionSubscription =
        Observable.timer(0, interval, TimeUnit.MILLISECONDS, Schedulers.computation())
            .subscribe(
                new Action1<Long>() {
                  @Override
                  public void call(Long tick) {
                    if (!response.getChannel().isOpen()) {
                      subscription.unsubscribe();
                      return;
                    }
                    try {
                      writeMetric(JsonMapper.toJson(metrics), response);
                    } catch (Exception e) {
                      subject.onError(e);
                    }
                  }
                });
    subscription.set(actionSubscription);
    return subject;
  }
  public void deleteAfterSomeTime(List<QuranRow> remove) {
    if (mPendingRemoval != null) {
      // handle a new delete request when one is already happening by adding those items to delete
      // now and un-subscribing from the old request.
      if (mItemsToRemove != null) {
        remove.addAll(mItemsToRemove);
      }
      cancelDeletion();
    }

    mItemsToRemove = remove;
    mPendingRemoval =
        Observable.timer(DELAY_DELETION_DURATION_IN_MS, TimeUnit.MILLISECONDS)
            .flatMap(
                new Func1<Long, Observable<BookmarkResult>>() {
                  @Override
                  public Observable<BookmarkResult> call(Long aLong) {
                    return removeItemsObservable();
                  }
                })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                new Action1<BookmarkResult>() {
                  @Override
                  public void call(BookmarkResult result) {
                    mPendingRemoval = null;
                    mCachedData = result;
                    if (mFragment != null) {
                      mFragment.onNewData(result);
                    }
                  }
                });
  }
  private void loadList(List<AppInfo> apps) {
    mRecyclerView.setVisibility(View.VISIBLE);

    Observable<AppInfo> appsSequence =
        Observable.interval(1000, TimeUnit.MILLISECONDS)
            .map(
                position -> {
                  App.L.debug("Position: " + position);
                  return apps.get(position.intValue());
                });
    Observable<Long> tictoc = Observable.interval(1000, TimeUnit.MILLISECONDS);

    appsSequence
        .join(
            tictoc,
            appInfo -> Observable.timer(2, TimeUnit.SECONDS),
            time -> Observable.timer(0, TimeUnit.SECONDS),
            this::updateTitle)
        .observeOn(AndroidSchedulers.mainThread())
        .take(10)
        .subscribe(
            new Observer<AppInfo>() {
              @Override
              public void onCompleted() {
                Toast.makeText(getActivity(), "Here is the list!", Toast.LENGTH_LONG).show();
              }

              @Override
              public void onError(Throwable e) {
                mSwipeRefreshLayout.setRefreshing(false);
                Toast.makeText(getActivity(), "Something went wrong!", Toast.LENGTH_SHORT).show();
              }

              @Override
              public void onNext(AppInfo appInfo) {
                if (mSwipeRefreshLayout.isRefreshing()) {
                  mSwipeRefreshLayout.setRefreshing(false);
                }
                mAddedApps.add(appInfo);
                int position = mAddedApps.size() - 1;
                mAdapter.addApplication(position, appInfo);
                mRecyclerView.smoothScrollToPosition(position);
              }
            });
  }
Example #7
0
  private void delayShowAll(long time) {
    Observable.timer(time, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
        .subscribe(
            new Subscriber<Long>() {
              public void onCompleted() {
                MainActivity.this.gotoNext();
              }

              public void onError(Throwable e) {}

              public void onNext(Long aLong) {}
            });
  }
Example #8
0
  private void showRedHeartLayout() {
    Observable.timer(400, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
        .subscribe(
            new Subscriber<Long>() {
              public void onCompleted() {
                mHeartLayout.setVisibility(View.VISIBLE);
                MainActivity.this.delayDo2();
              }

              public void onError(Throwable e) {}

              public void onNext(Long aLong) {}
            });
  }
  @Test
  public void testErrorPropagatesWhenNoOutstandingRequests() {
    Observable<Long> timer =
        Observable.timer(0, 1, TimeUnit.MICROSECONDS)
            .doOnEach(
                new Action1<Notification<? super Long>>() {

                  @Override
                  public void call(Notification<? super Long> n) {
                    //                                                System.out.println("BEFORE " +
                    // n);
                  }
                })
            .observeOn(Schedulers.newThread())
            .doOnEach(
                new Action1<Notification<? super Long>>() {

                  @Override
                  public void call(Notification<? super Long> n) {
                    try {
                      Thread.sleep(100);
                    } catch (InterruptedException e) {
                    }
                    //                                                System.out.println("AFTER " +
                    // n);
                  }
                });

    TestSubscriber<Long> ts = new TestSubscriber<Long>();

    Observable.combineLatest(
            timer,
            Observable.<Integer>never(),
            new Func2<Long, Integer, Long>() {

              @Override
              public Long call(Long t1, Integer t2) {
                return t1;
              }
            })
        .take(RxRingBuffer.SIZE * 2)
        .subscribe(ts);

    ts.awaitTerminalEvent();
    assertEquals(1, ts.getOnErrorEvents().size());
    assertEquals(MissingBackpressureException.class, ts.getOnErrorEvents().get(0).getClass());
  }
Example #10
0
  private void delayDo2() {
    Observable.timer(
            (long) this.mRandom2.nextInt(200),
            TimeUnit.MILLISECONDS,
            AndroidSchedulers.mainThread())
        .subscribe(
            new Subscriber<Long>() {
              public void onCompleted() {
                MainActivity.this.mHeartLayout.addHeart(MainActivity.this.randomColor());
                MainActivity.this.delayDo2();
              }

              public void onError(Throwable e) {}

              public void onNext(Long aLong) {}
            });
  }
Example #11
0
  private void delayDo() {
    Observable.timer(0, TimeUnit.SECONDS, AndroidSchedulers.mainThread())
        .subscribe(
            new Subscriber<Long>() {
              public void onCompleted() {
                MainActivity.this.mWhiteSnowView.setVisibility(View.GONE);
                MainActivity.this.mWebView.setVisibility(View.VISIBLE);
                MainActivity.this.delayShow(5100); // 延时显示显示打印机

                MainActivity.this.mWebView.loadUrl(MainActivity.URL);
              }

              public void onError(Throwable e) {}

              public void onNext(Long aLong) {}
            });
  }
  public void example() {
    Observable<String> left =
        Observable.interval(100, TimeUnit.MILLISECONDS).map(i -> "L" + i).take(6);
    Observable<String> right =
        Observable.interval(200, TimeUnit.MILLISECONDS).map(i -> "R" + i).take(3);

    left.groupJoin(
            right,
            i -> Observable.never(),
            i -> Observable.timer(0, TimeUnit.MILLISECONDS),
            (l, rs) -> rs.toList().subscribe(list -> System.out.println(l + ": " + list)))
        .subscribe();

    // L0: [R0, R1, R2]
    // L1: [R0, R1, R2]
    // L2: [R1, R2]
    // L3: [R1, R2]
    // L4: [R2]
    // L5: [R2]
  }
Example #13
0
  private void reSchedule(final Handler h) {
    System.out.println("reScheduling:" + backOff);
    logger.info("rescheduling in {} ms", backOff);
    Observable.timer(backOff, TimeUnit.MILLISECONDS)
        //                .flatMap(new Func1<Long, Observable<Long>>(){
        //
        //            @Override
        //            public Observable<Long> call(Long t) {
        //                System.out.println("call from flatmap -> doWork -> just " + t);
        //                doWork(h);
        //                return Observable.just(t);
        //            }
        //        })
        .subscribe(
            s -> {
              System.out.println("onENextCalled,round -> " + round);
              doWork(h);
            });
    //
    //                subscribeOn(Schedulers.computation())
    //                .subscribe((n)->{System.out.println("timerOnNext");},
    //                e -> {
    //                    logger.warn("failed to rescheduled.inc backoff",e);
    //                    backOff += waitOnEmtpyInMs;
    //                    reSchedule(h);
    //                });

    //        Observable.timer(backOff, TimeUnit.MILLISECONDS)
    //                .map(l -> {retunr })
    //                .subscribe(s -> {
    //                    doWork(h);
    //                }, e -> {
    //                    logger.warn("failed to rescheduled.inc backoff",e);
    //                    backOff += waitOnEmtpyInMs;
    //                    reSchedule(h);
    //                });
  }