@Override public MaybeSource<Object> apply(Maybe<Object> m) throws Exception { return m.observeOn(Schedulers.single()); } });
private void onPlaylistSelected(@NonNull LocalPlaylistManager manager, @NonNull PlaylistMetadataEntry playlist, @NonNull List<StreamEntity> streams) { if (getStreams() == null) return; @SuppressLint("ShowToast") final Toast successToast = Toast.makeText(getContext(), R.string.playlist_add_stream_success, Toast.LENGTH_SHORT); manager.appendToPlaylist(playlist.uid, streams) .observeOn(AndroidSchedulers.mainThread()) .subscribe(ignored -> successToast.show()); getDialog().dismiss(); } }
private void changeThumbnailUrl(final String thumbnailUrl) { if (playlistManager == null) return; final Toast successToast = Toast.makeText(getActivity(), R.string.playlist_thumbnail_change_success, Toast.LENGTH_SHORT); Log.d(TAG, "Updating playlist id=[" + playlistId + "] with new thumbnail url=[" + thumbnailUrl + "]"); final Disposable disposable = playlistManager .changePlaylistThumbnail(playlistId, thumbnailUrl) .observeOn(AndroidSchedulers.mainThread()) .subscribe(ignore -> successToast.show(), this::onError); disposables.add(disposable); }
protected void savePlaybackState(final StreamInfo info, final long progress) { if (info == null) return; final Disposable stateSaver = recordManager.saveStreamState(info, progress) .observeOn(AndroidSchedulers.mainThread()) .onErrorComplete() .subscribe( ignored -> {/* successful */}, error -> Log.e(TAG, "savePlaybackState() failure: ", error) ); databaseUpdateReactor.add(stateSaver); }
@Test(expected = NullPointerException.class) public void subscribeOnNull() { Maybe.just(1).observeOn(null); }
private void changePlaylistName(final String name) { if (playlistManager == null) return; this.name = name; setTitle(name); Log.d(TAG, "Updating playlist id=[" + playlistId + "] with new name=[" + name + "] items"); final Disposable disposable = playlistManager.renamePlaylist(playlistId, name) .observeOn(AndroidSchedulers.mainThread()) .subscribe(longs -> {/*Do nothing on success*/}, this::onError); disposables.add(disposable); }
@Test(expected = NullPointerException.class) public void observeOnNull() { Maybe.just(1).observeOn(null); }
@NonNull @Override public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) { if (getStreams() == null) return super.onCreateDialog(savedInstanceState); View dialogView = View.inflate(getContext(), R.layout.dialog_playlist_name, null); EditText nameInput = dialogView.findViewById(R.id.playlist_name); final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(getContext()) .setTitle(R.string.create_playlist) .setView(dialogView) .setCancelable(true) .setNegativeButton(R.string.cancel, null) .setPositiveButton(R.string.create, (dialogInterface, i) -> { final String name = nameInput.getText().toString(); final LocalPlaylistManager playlistManager = new LocalPlaylistManager(NewPipeDatabase.getInstance(getContext())); final Toast successToast = Toast.makeText(getActivity(), R.string.playlist_creation_success, Toast.LENGTH_SHORT); playlistManager.createPlaylist(name, getStreams()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(longs -> successToast.show()); }); return dialogBuilder.create(); } }
private void saveImage() { if (ContextCompat.checkSelfPermission(mContext, Permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { requestPermission(); } else { final String url = mImgList.get(mViewPager.getCurrentItem()); Maybe.create((MaybeOnSubscribe<Boolean>) emitter -> emitter.onSuccess(DownloadUtil.saveImage(url, mContext))) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .as(this.bindAutoDispose()) .subscribe(b -> { String s = b ? getString(R.string.saved) : getString(R.string.error); Toast.makeText(mContext, s, Toast.LENGTH_SHORT).show(); }, ErrorAction.error()); } }
@Test public void observeOnDispose2() { TestHelper.checkDisposed(Maybe.empty().observeOn(Schedulers.single())); }
@Override public void onNext(SubscriptionEntity subscriptionEntity) { if (!itemsLoaded.contains(subscriptionEntity.getServiceId() + subscriptionEntity.getUrl())) { subscriptionService.getChannelInfo(subscriptionEntity) .observeOn(AndroidSchedulers.mainThread()) .onErrorComplete( (@io.reactivex.annotations.NonNull Throwable throwable) -> FeedFragment.super.onError(throwable)) .subscribe( getChannelInfoObserver(subscriptionEntity.getServiceId(), subscriptionEntity.getUrl())); } else { requestFeed(1); } }
@Test public void observeOnSuccess() { String main = Thread.currentThread().getName(); Maybe.just(1) .observeOn(Schedulers.single()) .map(new Function<Integer, String>() { @Override public String apply(Integer v) throws Exception { return v + ": " + Thread.currentThread().getName(); } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertOf(TestHelper.observerSingleNot("1: " + main)) ; }
@Test public void observeOnCompleteThread() { String main = Thread.currentThread().getName(); final String[] name = { null }; Maybe.empty().observeOn(Schedulers.single()) .doOnComplete(new Action() { @Override public void run() throws Exception { name[0] = Thread.currentThread().getName(); } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult() ; assertNotEquals(main, name[0]); }
@SuppressWarnings("unchecked") @Test public void noWinnerSuccessDispose() throws Exception { for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch cdl = new CountDownLatch(1); Maybe.ambArray( Maybe.just(1) .subscribeOn(Schedulers.single()) .observeOn(Schedulers.computation()), Maybe.never() ) .subscribe(new Consumer<Object>() { @Override public void accept(Object v) throws Exception { interrupted.set(Thread.currentThread().isInterrupted()); cdl.countDown(); } }); assertTrue(cdl.await(500, TimeUnit.SECONDS)); assertFalse("Interrupted!", interrupted.get()); } }
@Test public void observeOnComplete() { Maybe.empty() .observeOn(Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult() ; }
@Test public void observeOnErrorThread() { String main = Thread.currentThread().getName(); final String[] name = { null }; Maybe.error(new TestException()).observeOn(Schedulers.single()) .doOnError(new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { name[0] = Thread.currentThread().getName(); } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TestException.class) ; assertNotEquals(main, name[0]); }
@SuppressWarnings("unchecked") @Test public void noWinnerCompleteDispose() throws Exception { for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch cdl = new CountDownLatch(1); Maybe.ambArray( Maybe.empty() .subscribeOn(Schedulers.single()) .observeOn(Schedulers.computation()), Maybe.never() ) .subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() { @Override public void run() throws Exception { interrupted.set(Thread.currentThread().isInterrupted()); cdl.countDown(); } }); assertTrue(cdl.await(500, TimeUnit.SECONDS)); assertFalse("Interrupted!", interrupted.get()); } }
@SuppressWarnings("unchecked") @Test public void noWinnerErrorDispose() throws Exception { final TestException ex = new TestException(); for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch cdl = new CountDownLatch(1); Maybe.ambArray( Maybe.error(ex) .subscribeOn(Schedulers.single()) .observeOn(Schedulers.computation()), Maybe.never() ) .subscribe(Functions.emptyConsumer(), new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { interrupted.set(Thread.currentThread().isInterrupted()); cdl.countDown(); } }); assertTrue(cdl.await(500, TimeUnit.SECONDS)); assertFalse("Interrupted!", interrupted.get()); } }
@Test public void observeOnDispose() throws Exception { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); final CountDownLatch cdl = new CountDownLatch(1); Maybe.just(1) .observeOn(Schedulers.single()) .doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { if (!cdl.await(5, TimeUnit.SECONDS)) { throw new TimeoutException(); } } }) .toFlowable().subscribe(ts); Thread.sleep(250); ts.cancel(); ts.awaitDone(5, TimeUnit.SECONDS) .assertFailure(InterruptedException.class); }
@Test public void observeOnError() { Maybe.error(new TestException()) .observeOn(Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TestException.class) ; }