Examples with Observable io.reactivex.Observable used on opensource projects

Example 41 with Observable

use of io.reactivex.Observable in project RxJava-Android-Samples by kaushikgopal.

the class PseudoCacheFragment method getCachedDiskData.

private Observable<Contributor> getCachedDiskData() {
    List<Contributor> list = new ArrayList<>();
    Map<String, Long> map = dummyDiskData();
    for (String username : map.keySet()) {
        Contributor c = new Contributor();
        c.login = username;
        c.contributions = map.get(username);
        list.add(c);
    }
    return //
    Observable.fromIterable(list).doOnSubscribe((data) -> //
    new Handler(Looper.getMainLooper()).post(//
    () -> adapterSubscriptionInfo.add("(disk) cache subscribed"))).doOnComplete(() -> //
    new Handler(Looper.getMainLooper()).post(() -> adapterSubscriptionInfo.add("(disk) cache completed")));
}

Example 42 with Observable

use of io.reactivex.Observable in project RxJava-Android-Samples by kaushikgopal.

the class PseudoCacheFragment method getFreshNetworkData.

private Observable<Contributor> getFreshNetworkData() {
    String githubToken = getResources().getString(R.string.github_oauth_token);
    GithubApi githubService = GithubService.createGithubService(githubToken);
    return githubService.contributors("square", "retrofit").flatMap(Observable::fromIterable).doOnSubscribe((data) -> //
    new Handler(Looper.getMainLooper()).post(//
    () -> adapterSubscriptionInfo.add("(network) subscribed"))).doOnComplete(() -> //
    new Handler(Looper.getMainLooper()).post(() -> adapterSubscriptionInfo.add("(network) completed")));
}

Example 43 with Observable

use of io.reactivex.Observable in project RxCache by VictorAlbertos.

the class BrewJavaFile method getActionProvider.

private MethodSpec getActionProvider(ClassName providersClassName, ProvidersClass.Method method) {
    String methodName = method.name;
    TypeName list = ClassName.get(method.enclosingTypeObservable);
    TypeName enclosingTypeList = ClassName.get(method.enclosingTypeObservable.getTypeArguments().get(0));
    String enclosingTypeListName = enclosingTypeList.toString();
    ParameterizedTypeName action = ParameterizedTypeName.get(ClassName.get(ActionsList.class), enclosingTypeList);
    ParameterizedTypeName evict = ParameterizedTypeName.get(ClassName.get(ActionsList.Evict.class), enclosingTypeList);
    ParameterizedTypeName arrayList = ParameterizedTypeName.get(ClassName.get(ArrayList.class), enclosingTypeList);
    ParameterizedTypeName observable = ParameterizedTypeName.get(ClassName.get(Observable.class), list);
    ParameterSpec rxProvidersInstance = ParameterSpec.builder(providersClassName, "proxy").addModifiers(Modifier.FINAL).build();
    MethodSpec.Builder builder = MethodSpec.methodBuilder(methodName).addModifiers(Modifier.PUBLIC, Modifier.STATIC).addParameter(rxProvidersInstance).returns(action);
    if (method.hasDynamicKey) {
        builder.addParameter(DynamicKey.class, "dynamicKey", Modifier.FINAL);
    } else if (method.hasDynamicKeyGroup) {
        builder.addParameter(DynamicKeyGroup.class, "dynamicKeyGroup", Modifier.FINAL);
    }
    builder.beginControlFlow("$T evict = new $T()", evict, evict).beginControlFlow("@Override public $T call($T elements)", observable, observable);
    if (method.hasDynamicKey) {
        setReturnEvictForEvictDynamicKey(builder, methodName);
    } else if (method.hasDynamicKeyGroup) {
        setReturnEvictForEvictDynamicKeyGroup(builder, methodName);
    } else {
        setReturnEvictForEvictProvider(builder, methodName);
    }
    builder.endControlFlow().endControlFlow(";");
    if (method.hasDynamicKey) {
        setCacheForEvictDynamicKey(builder, observable, arrayList, methodName, enclosingTypeListName);
    } else if (method.hasDynamicKeyGroup) {
        setCacheForEvictDynamicKeyGroup(builder, observable, arrayList, methodName, enclosingTypeListName);
    } else {
        setCacheForEvictProvider(builder, observable, arrayList, methodName, enclosingTypeListName);
    }
    builder.addStatement("return ActionsList.with(evict, oCache)");
    return builder.build();
}

Example 44 with Observable

use of io.reactivex.Observable in project requery by requery.

the class PeopleActivity method onCreate.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getSupportActionBar() != null) {
        getSupportActionBar().setTitle("People");
    }
    setContentView(R.layout.activity_people);
    RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
    data = ((PeopleApplication) getApplication()).getData();
    executor = Executors.newSingleThreadExecutor();
    adapter = new PersonAdapter();
    adapter.setExecutor(executor);
    recyclerView.setAdapter(adapter);
    recyclerView.setLayoutManager(new LinearLayoutManager(this));
    data.count(Person.class).get().single().subscribe(new Consumer<Integer>() {

        @Override
        public void accept(Integer integer) {
            if (integer == 0) {
                Observable.fromCallable(new CreatePeople(data)).flatMap(new Function<Observable<Iterable<Person>>, Observable<?>>() {

                    @Override
                    public Observable<?> apply(Observable<Iterable<Person>> o) {
                        return o;
                    }
                }).observeOn(Schedulers.computation()).subscribe(new Consumer<Object>() {

                    @Override
                    public void accept(Object o) {
                        adapter.queryAsync();
                    }
                });
            }
        }
    });
}

Example 45 with Observable

use of io.reactivex.Observable in project retrofit by square.

the class RxJava2CallAdapterFactoryTest method rawResponseTypeThrows.

@Test
public void rawResponseTypeThrows() {
    Type observableType = new TypeToken<Observable<Response>>() {
    }.getType();
    try {
        factory.get(observableType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
    Type singleType = new TypeToken<Single<Response>>() {
    }.getType();
    try {
        factory.get(singleType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
    Type maybeType = new TypeToken<Maybe<Response>>() {
    }.getType();
    try {
        factory.get(maybeType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
    Type flowableType = new TypeToken<Flowable<Response>>() {
    }.getType();
    try {
        factory.get(flowableType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
}