rx.subscriptions.Subscriptions Java Examples

public <T> Observable<T> get(final String key) {
    return Observable.create(new Observable.OnSubscribe<T>() {
        @Override
        public void call(final Subscriber<? super T> subscriber) {
            final DataChangeCallback<T> callback = new DataChangeCallback<T>(key) {
                @Override
                public void onDataChange(T value) {
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext(value);
                    }
                }
            };
            Chest.this.addOnDataChangeListener(callback);
            subscriber.add(Subscriptions.create(new Action0() {
                @Override
                public void call() {
                    Chest.this.removeListener(callback);
                }
            }));
            subscriber.onNext(Chest.this.<T>read(key));
        }
    }).compose(this.<T>applySchedulers());
}
 

private Observable<Map<String, Integer>> getCountLikersObservable(final List<String> userIds) {
    return Observable.create(new Observable.OnSubscribeFunc<Map<String, Integer>>() {
        @Override
        public Subscription onSubscribe(final Observer<? super Map<String, Integer>> observer) {
            likeDataSource.getCountLikesForUser(userIds, new GetCountLikesCallback() {
                @Override
                public void countUsers(Map<String, Integer> countLikers) {
                    observer.onNext(countLikers);
                    observer.onCompleted();
                }
            });

            return Subscriptions.empty();
        }
    });
}
 

public void loadArticle(String id) {
  articles.loadById(id).subscribe(new Action1<Article>() {
    @Override
    public void call(final Article article) {

      Subscription s = Subscriptions.from(
          title.bind(article.title),
          authorName.bind(article.author.name),
          authorThumbnailUrl.bind(article.author.thumbnailUrl),
          createdAt.bind(article.createdAt, TIMEAGO),
          contentHtml.bind(article.html())
      );

      add(s);

      authorUrl.set(article.author.url());
      contentUrl.set(article.url());
      tags.addAll(Objects.map(article.tags, tagMapper));

    }
  }, Rx.ERROR_ACTION_EMPTY);
}
 

@Override
protected Subscription onBind() {
  viewModel = viewModelHolder.get();
  commentListViewModel = CommentListViewModel.create(getContext());
  commentListViewModel.setArticleId(getArticleId());

  return Subscriptions.from(
      commentListViewModel,
      listAdapter.bind(commentListViewModel.items()),
      emptyText.bind(commentListViewModel.isEmpty(), RxActions.setVisibility()),
      progressBar.bind(commentListViewModel.isLoading(), RxActions.setVisibility()),
      authorText.bind(viewModel.authorName(), RxActions.setText()),
      authorImage.bind(viewModel.authorThumbnailUrl(), loadThumbnailAction()),
      tagList.bind(viewModel.tags())
  );
}
 

@Override
public void call(final Subscriber<? super T> subscriber) {
    if (state.casState(State.STATES.UNSUBSCRIBED, State.STATES.SUBSCRIBED)) {

        // drain queued notifications before subscription
        // we do this here before PassThruObserver so the consuming thread can do this before putting itself in
        // the line of the producer
        state.buffer.sendAllNotifications(subscriber);

        // register real observer for pass-thru ... and drain any further events received on first notification
        state.setObserverRef(new PassThruObserver<>(subscriber, state));
        subscriber.add(Subscriptions.create(new Action0() {
            @Override
            public void call() {
                state.setObserverRef(Subscribers.empty());
            }
        }));
    } else if (State.STATES.SUBSCRIBED.ordinal() == state.state) {
        subscriber.onError(new IllegalStateException("Content can only have one subscription. Use Observable.publish() if you want to multicast."));
    } else if (State.STATES.DISPOSED.ordinal() == state.state) {
        subscriber.onError(new IllegalStateException("Content stream is already disposed."));
    }
}
 

private static Observable getObservable() {
    return Observable.create(subscriber -> {
        frame.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                subscriber.onNext(e.getX());
            }
        });
        subscriber.add(Subscriptions.create(() -> {
            LOGGER.info("Clear resources");
            for (MouseListener listener : frame.getListeners(MouseListener.class)) {
                frame.removeMouseListener(listener);
            }
        }));
    });
}
 

private Single<String> createAsyncSingle() {
    return Single.create((SingleSubscriber<? super String> subscriber) -> {
        subscribed.incrementAndGet();
        Future<?> future = executorService.submit(() -> {
            try {
                taskStartedLatch.countDown();
                waitLatch.await();
                subscriber.onSuccess(VALUE);
            } catch (InterruptedException e) {
                subscriber.onError(e);
                throw new RuntimeException(e);
            }
        });
        subscriber.add(Subscriptions.from(future));
        assertTrue(this.futureTaskRef.compareAndSet(null, future));
    });
}
 

private static <T> OnSubscribe<T> onSubscribe(final ValueSource<T> valueSource) {
    return subscriber -> {
        valueSource.addCallbacks(value -> {
                if (!subscriber.isUnsubscribed()) {
                    try {
                        subscriber.onSuccess(value);
                    } catch (Throwable e) {
                        subscriber.onError(e);
                    }
                }
            },
            throwable -> {
                if (!subscriber.isUnsubscribed()) {
                    subscriber.onError(throwable);
                }
            });
        subscriber.add(Subscriptions.create(() -> valueSource.cancel(true)));
    };
}
 

private static Subscription unsubscribeInUiThread(final Action0 unsubscribe) {
    return Subscriptions.create(new Action0() {
        @Override public void call() {
            if (Looper.getMainLooper() == Looper.myLooper()) {
                unsubscribe.call();
            } else {
                final Scheduler.Worker inner = AndroidSchedulers.mainThread().createWorker();
                inner.schedule(new Action0() {
                    @Override public void call() {
                        unsubscribe.call();
                        inner.unsubscribe();
                    }
                });
            }
        }
    });
}
 

@Override
public void call(final Subscriber<? super Intent> subscriber) {
    final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            subscriber.onNext(intent);
        }
    };

    final Subscription subscription = Subscriptions.create(new Action0() {
        @Override
        public void call() {
            context.unregisterReceiver(broadcastReceiver);
        }
    });

    subscriber.add(subscription);
    context.registerReceiver(broadcastReceiver, intentFilter, broadcastPermission, schedulerHandler);

}
 

@Override
public void call(final Subscriber<? super FileEvent> subscriber) {
    final FileObserver observer = new FileObserver(pathToWatch) {
        @Override
        public void onEvent(int event, String file) {
            if(subscriber.isUnsubscribed()) {
                return;
            }

            FileEvent fileEvent = FileEvent.create(event, file);
            subscriber.onNext(fileEvent);

            if(fileEvent.isDeleteSelf()) {
                subscriber.onCompleted();
            }
        }
    };
    observer.startWatching(); //START OBSERVING

    subscriber.add(Subscriptions.create(new Action0() {
        @Override
        public void call() {
            observer.stopWatching();
        }
    }));
}
 

/**
 * Show an AlertDialog with the {@code title} and the {@code message}. The Alert dialog has an
 * "ok" button.
 *
 * @param title Title to apply on AlertDialog
 * @param message Message to asSnack on AlertDialog
 * @param resourceId
 *
 * @return A Observable that shows the dialog when subscribed and return the action made by
 * user. This action is represented by EResponse
 *
 * @see EResponse
 */
public static Observable<EResponse> createGenericOkCancelMessage(Context context, String title,
    String message, int resourceId) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    final AlertDialog dialog =
        new AlertDialog.Builder(new ContextThemeWrapper(context, resourceId)).setTitle(title)
            .setMessage(message)
            .setPositiveButton(android.R.string.ok, (listener, which) -> {
              subscriber.onNext(EResponse.YES);
              subscriber.onCompleted();
            })
            .setNegativeButton(android.R.string.cancel, (dialogInterface, i) -> {
              subscriber.onNext(EResponse.CANCEL);
              subscriber.onCompleted();
            })
            .create();
    // cleaning up
    subscriber.add(Subscriptions.create(() -> dialog.dismiss()));
    dialog.show();
  });
}
 

public static Observable<EResponse> createGenericOkCancelMessageWithColorButton(Context context,
    String title, String message, String okButton, String cancelButton) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    final AlertDialog dialog = new AlertDialog.Builder(context).setTitle(title)
        .setMessage(message)
        .setPositiveButton(okButton, (listener, which) -> {
          subscriber.onNext(EResponse.YES);
          subscriber.onCompleted();
        })
        .setNegativeButton(cancelButton, (dialogInterface, i) -> {
          subscriber.onNext(EResponse.CANCEL);
          subscriber.onCompleted();
        })
        .create();
    subscriber.add(Subscriptions.create(() -> dialog.dismiss()));
    dialog.show();
    dialog.getButton(AlertDialog.BUTTON_NEGATIVE)
        .setTextColor(Color.GRAY);
  });
}
 

public static Observable<EResponse> createGenericContinueMessage(Context context,
    @Nullable View view, String title, String message, @StringRes int buttonText,
    int resourceId) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    AlertDialog.Builder builder =
        new AlertDialog.Builder(new ContextThemeWrapper(context, resourceId)).setTitle(title)
            .setMessage(message)
            .setPositiveButton(buttonText, (dialogInterface, i) -> {
              subscriber.onNext(EResponse.YES);
              subscriber.onCompleted();
            });
    if (view != null) {
      builder.setView(view);
    }
    AlertDialog alertDialog = builder.create();
    subscriber.add(Subscriptions.create(() -> alertDialog.dismiss()));
    alertDialog.show();
  });
}
 

public static Observable<EResponse> createGenericContinueCancelMessage(Context context,
    String title, String message, int resourceId) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    final AlertDialog ad =
        new AlertDialog.Builder(new ContextThemeWrapper(context, resourceId)).setTitle(title)
            .setMessage(message)
            .setPositiveButton(android.R.string.ok, (dialog, which) -> {
              subscriber.onNext(EResponse.YES);
              subscriber.onCompleted();
            })
            .setNegativeButton(android.R.string.cancel, (dialogInterface, i) -> {
              subscriber.onNext(EResponse.NO);
              subscriber.onCompleted();
            })
            .setOnCancelListener(dialog -> {
              subscriber.onNext(EResponse.CANCEL);
              subscriber.onCompleted();
            })
            .create();
    // cleaning up
    subscriber.add(Subscriptions.create(() -> ad.dismiss()));
    ad.show();
  });
}
 

/**
 * Show an AlertDialog with the {@code title} and the {@code message}. The Alert dialog has an
 * "yes" button and a "no" button.
 *
 * @param title Title to apply on AlertDialog
 * @param message Message to asSnack on AlertDialog
 * @param resourceId
 *
 * @return A Observable that shows the dialog when subscribed and return the action made by
 * user. This action is represented by EResponse
 *
 * @see EResponse
 */
public static Observable<EResponse> createGenericYesNoCancelMessage(@NonNull Context context,
    @Nullable String title, @Nullable String message, int resourceId) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    final AlertDialog dialog =
        new AlertDialog.Builder(new ContextThemeWrapper(context, resourceId)).setTitle(title)
            .setMessage(message)
            .setPositiveButton(android.R.string.yes, (listener, which) -> {
              subscriber.onNext(EResponse.YES);
              subscriber.onCompleted();
            })
            .setNegativeButton(android.R.string.no, (listener, which) -> {
              subscriber.onNext(EResponse.NO);
              subscriber.onCompleted();
            })
            .setOnCancelListener(listener -> {
              subscriber.onNext(EResponse.CANCEL);
              subscriber.onCompleted();
            })
            .create();
    // cleaning up
    subscriber.add(Subscriptions.create(() -> dialog.dismiss()));
    dialog.show();
  })
      .subscribeOn(AndroidSchedulers.mainThread());
}
 

public static Observable<EResponse> createGenericOkCancelMessage(Context context, String title,
    @StringRes int message, @StringRes int okMessage, @StringRes int cancelMessage,
    int resourceId) {
  return Observable.create((Subscriber<? super EResponse> subscriber) -> {
    final AlertDialog ad =
        new AlertDialog.Builder(new ContextThemeWrapper(context, resourceId)).setTitle(title)
            .setMessage(message)
            .setPositiveButton(okMessage, (dialog, which) -> {
              subscriber.onNext(EResponse.YES);
              subscriber.onCompleted();
            })
            .setNegativeButton(cancelMessage, (dialogInterface, i) -> {
              subscriber.onNext(EResponse.NO);
              subscriber.onCompleted();
            })
            .setOnCancelListener(dialog -> {
              subscriber.onNext(EResponse.CANCEL);
              subscriber.onCompleted();
            })
            .create();
    // cleaning up
    subscriber.add(Subscriptions.create(() -> ad.dismiss()));
    ad.show();
  });
}
 

@Override public void call(final Subscriber<? super Intent> subscriber) {
  final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    @Override public void onReceive(Context context, Intent intent) {
      if (!subscriber.isUnsubscribed()) {
        subscriber.onNext(intent);
      }
    }
  };

  final Subscription subscription = Subscriptions.create(new Action0() {
    @Override public void call() {
      context.unregisterReceiver(broadcastReceiver);
    }
  });

  subscriber.add(subscription);
  context.registerReceiver(broadcastReceiver, intentFilter, broadcastPermission,
      schedulerHandler);
}
 

private <T> Observable<T> getQuery(Query query, Action2<Subscriber<? super T>, DataSnapshot> onNextAction, boolean subscribeForSingleEvent) {
    return Observable.create(subscriber -> {
        ValueEventListener eventListener = new ValueEventListener() {

            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                onNextAction.call(subscriber, dataSnapshot);
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
                subscriber.onError(new FirebaseException(databaseError.getMessage()));
            }
        };
        if (subscribeForSingleEvent) {
            query.addListenerForSingleValueEvent(eventListener);
        } else {
            query.addValueEventListener(eventListener);
        }
        subscriber.add(Subscriptions.create(() -> query.removeEventListener(eventListener)));
    });
}
 

private Observable<Void> change(String key) {
  return Observable.create(new Observable.OnSubscribe<Void>() {
    @Override public void call(Subscriber<? super Void> subscriber) {

      final SharedPreferences.OnSharedPreferenceChangeListener listener =
          new SharedPreferences.OnSharedPreferenceChangeListener() {
            @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
                String changedKey) {
              if (!subscriber.isUnsubscribed() && changedKey.equals(key)) {
                subscriber.onNext(null);
              }
            }
          };

      subscriber.add(Subscriptions.create(
          () -> preferences.unregisterOnSharedPreferenceChangeListener(listener)));

      preferences.registerOnSharedPreferenceChangeListener(listener);
    }
  });
}
 

private Subscription unsubscribeInUiThread(final Action0 unsubscribe) {
    return Subscriptions.create(new Action0() {

        @Override
        public void call() {
            if (Looper.getMainLooper() == Looper.myLooper()) {
                unsubscribe.call();
            } else {
                final Scheduler.Worker inner = AndroidSchedulers.mainThread().createWorker();
                inner.schedule(new Action0() {
                    @Override
                    public void call() {
                        unsubscribe.call();
                        inner.unsubscribe();
                    }
                });
            }
        }
    });
}
 

@Override
protected Subscription onBind() {
  return Subscriptions.from(
      viewModel,
      listAdapter.bind(viewModel.items()),
      progressBar.bind(viewModel.isLoading(), RxActions.setVisibility())
  );
}
 

@Override
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
    if (isUnsubscribed()) {
        return Subscriptions.unsubscribed();
    }
    ScheduledAction s = poolWorker.scheduleActual(action, delayTime, unit, timed);

    return s;
}
 

/**
 * Create a {@link Subscription} that always runs the specified {@code unsubscribe} on the
 * UI thread.
 */

public static Subscription unsubscribeInUiThread(final Action0 unsubscribe) {
    return Subscriptions.create(() -> {
        if (Looper.getMainLooper() == Looper.myLooper()) {
            unsubscribe.call();
        } else {
            final Scheduler.Worker inner = AndroidSchedulers.mainThread().createWorker();
            inner.schedule(() -> {
                unsubscribe.call();
                inner.unsubscribe();
            });
        }
    });
}
 

private Subscription createUnsubscriptionAction(final State state) {
    return Subscriptions.create(new Action0() {
        @Override
        public void call() {
            close(state);
        }
    });
}
 

private static <T> void setupUnsubscription(Subscriber<T> subscriber, final State state) {
    subscriber.add(Subscriptions.create(new Action0() {
        @Override
        public void call() {
            closeQuietly(state);
        }
    }));
}
 

@Override
protected Subscription onConnect() {
    return Subscriptions.from(super.onConnect(),

        Observable.interval(500, 500, TimeUnit.MILLISECONDS, mainThread())
            .subscribe(ignored -> {
                StringBuilder builder = new StringBuilder();
                builder.append("connections:\n");
                for (String key : ReconnectableMap.INSTANCE.keys())
                    builder.append(key).append("\n");
                TextView report = (TextView)findViewById(R.id.stationReport);
                report.setText(builder.toString());
            }));
}
 

@Override
protected Subscription onConnect() {
    return Subscriptions.from(super.onConnect(),

        channel(SINGLE_RESTARTABLE_ID, DeliveryMethod.SINGLE, new ExampleSingleObservableFactory())
            .subscribe(RxNotification.split(
                value -> {
                    log("SINGLE: onNext " + value);
                    onNext(value);
                },
                throwable -> log("SINGLE: onError " + throwable))));
}
 

@Override
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
    if (innerSubscription.isUnsubscribed()) {
        // don't schedule, we are unsubscribed
        return Subscriptions.empty();
    }
    
    ScheduledAction s = (ScheduledAction)innerWorker.schedule(action, delayTime, unit);
    innerSubscription.add(s);
    s.addParent(innerSubscription);
    return s;
}
 

@Override
protected Subscription onBind() {
  return Subscriptions.from(
      timeAgo.bind(viewModel.createdAt(), RxActions.setText()),
      title.bind(viewModel.title(), RxActions.setText())
  );
}