com.google.android.agera.Result Java Examples

private void setUpRepository() {
    mExecutor = Executors.newSingleThreadExecutor();
    mReservoir = Reservoirs.reservoir();
    Supplier<Result<Integer>> supplier = new Supplier<Result<Integer>>() {
        @NonNull
        @Override
        public Result<Integer> get() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mReservoir.get();// consume receiver
            return Result.success(++mCount);
        }
    };
    mRepository = Repositories.repositoryWithInitialValue(Result.<Integer>absent())
            .observe(mReservoir)
            .onUpdatesPerLoop()
            .goTo(mExecutor)
            .thenGetFrom(supplier)
            .compile();
}
 

@Test public void responseTypes() {
    Type oBodyClass = new TypeToken<Supplier<Result<String>>>() {}.getType();
    assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oBodyWildcard = new TypeToken<Supplier<Result<? extends String>>>() {}.getType();
    assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oBodyGeneric = new TypeToken<Supplier<Result<List<String>>>>() {}.getType();
    assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<List<String>>() {}.getType()));

    Type oResponseClass = new TypeToken<Supplier<Result<Response<String>>>>() {}.getType();
    assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oResponseWildcard
        = new TypeToken<Supplier<Result<Response<? extends String>>>>() {}.getType();
    assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));
}
 

@Test
public void shouldBindRepositoryPresenterOfResult() {
  final RepositoryPresenter<Result<String>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .handler(SECOND_HANDLER_ID, SECOND_HANDLER)
          .forResult();

  resultRepositoryPresenter.bind(STRING_RESULT, 0, viewHolder);

  verify(view).setTag(R.id.agera__rvdatabinding__item_id, ITEM_ID);
  verify(viewDataBinding).setVariable(ITEM_ID, STRING);
  verify(viewDataBinding).setVariable(HANDLER_ID, HANDLER);
  verify(viewDataBinding).setVariable(SECOND_HANDLER_ID, SECOND_HANDLER);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

@Test
public void shouldBindRepositoryPresenterOfResultList() {
  final RepositoryPresenter<Result<List<String>>> resultListRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .forResultList();

  resultListRepositoryPresenter.bind(STRING_LIST_RESULT, 1, viewHolder);

  verify(view).setTag(R.id.agera__rvdatabinding__item_id, ITEM_ID);
  verify(viewDataBinding).setVariable(ITEM_ID, SECOND_STRING);
  verify(viewDataBinding).setVariable(HANDLER_ID, HANDLER);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

@Test
public void shouldRecycleRepositoryPresenterOfResultListWithItemRecycling() {
  when(view.getTag(R.id.agera__rvdatabinding__item_id)).thenReturn(ITEM_ID);

  final RepositoryPresenter<Result<List<String>>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .handler(SECOND_HANDLER_ID, SECOND_HANDLER)
          .onRecycle(CLEAR_ITEM)
          .forResultList();

  resultRepositoryPresenter.recycle(viewHolder);

  verify(viewDataBinding).setVariable(ITEM_ID, null);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

@Test
public void shouldRecycleRepositoryPresenterOfResultListWithAllRecycling() {
  when(view.getTag(R.id.agera__rvdatabinding__item_id)).thenReturn(ITEM_ID);
  final RepositoryPresenter<Result<List<String>>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .handler(SECOND_HANDLER_ID, SECOND_HANDLER)
          .onRecycle(CLEAR_ALL)
          .forResultList();

  resultRepositoryPresenter.recycle(viewHolder);

  verify(viewDataBinding).setVariable(ITEM_ID, null);
  verify(viewDataBinding).setVariable(HANDLER_ID, null);
  verify(viewDataBinding).setVariable(SECOND_HANDLER_ID, null);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

@Test
public void shouldRecycleRepositoryPresenterOfResultListWithHandlerRecycling() {
  when(view.getTag(R.id.agera__rvdatabinding__item_id)).thenReturn(ITEM_ID);
  final RepositoryPresenter<Result<List<String>>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .handler(SECOND_HANDLER_ID, SECOND_HANDLER)
          .onRecycle(CLEAR_HANDLERS)
          .forResultList();

  resultRepositoryPresenter.recycle(viewHolder);

  verify(viewDataBinding).setVariable(HANDLER_ID, null);
  verify(viewDataBinding).setVariable(SECOND_HANDLER_ID, null);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

private void setUpRepository() {
    networkExecutor = Executors.newSingleThreadExecutor();

    mMutableRepository = Repositories.mutableRepository(mPagination);

    mLoadDataRepository = Repositories.repositoryWithInitialValue(Result.<ApiResult<GirlInfo>>absent())
            .observe(mMutableRepository)
            .onUpdatesPerLoop()
            .goTo(networkExecutor)
            .attemptGetFrom(new GirlsSupplier(mMutableRepository)).orSkip()
            .thenTransform(new Function<ApiResult<GirlInfo>, Result<ApiResult<GirlInfo>>>() {
                @NonNull
                @Override
                public Result<ApiResult<GirlInfo>> apply(@NonNull ApiResult<GirlInfo> input) {
                    return absentIfNull(input);
                }
            })
            .onDeactivation(RepositoryConfig.SEND_INTERRUPT)
            .compile();

}
 

@Override
public void update() {
    Result<ApiResult<GirlInfo>> result = mLoadDataRepository.get();

    result.ifSucceededSendTo(this)
            .ifFailedSendTo(new Receiver<Throwable>() {
                @Override
                public void accept(@NonNull Throwable value) {
                    Toast.makeText(ComplexRecycleViewActivity.this, "load data fail", Toast.LENGTH_LONG).show();
                    if (mPagination == 1) {
                        mRefreshRecyclerView.refreshComplete();
                    } else {
                        mRefreshRecyclerView.hideFooterView();
                    }
                    mRefreshRecyclerView.loadMoreComplete();
                }
            });

}
 

private void setUpRepository() {
    mObservable = new OnClickObservable() {
        @Override
        public void onClick( ) {
            dispatchUpdate();
        }
    };
    Supplier<Result<Integer>> supplier = new Supplier<Result<Integer>>() {
        @NonNull
        @Override
        public Result<Integer> get() {
            return Result.success(MockRandomData.getRandomColor());
        }
    };

    mRepository = Repositories.repositoryWithInitialValue(Result.<Integer>absent())
            .observe(mObservable)
            .onUpdatesPerLoop()
            .thenGetFrom(supplier)
            .compile();
}
 

@Test
public void shouldReturnStaticStableIdForRepositoryPresenterOfResult() {
  final RepositoryPresenter<Result<String>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .stableId(STABLE_ID)
          .forResult();
  assertThat(resultRepositoryPresenter.getItemId(STRING_RESULT, 0), is(STABLE_ID));
}
 

/**
 * Creates a sql query {@link Function}.
 */
@NonNull
public static <T> Function<SqlRequest, Result<List<T>>> databaseQueryFunction(
    @NonNull final Supplier<Result<SQLiteDatabase>> database,
    @NonNull Function<Cursor, T> rowMap) {
  return new DatabaseFunction<>(database, new DatabaseQueryMerger<>(rowMap));
}
 

@NonNull
@Override
public RepositoryPresenter<Result<List<Object>>> forResultList() {
  return new CompiledRepositoryPresenter(itemId, layoutFactory,
      stableIdForItem, handlers, recycleConfig, (Function) resultListAsList(), collectionId,
      keyForItem, detectMoves);
}
 

@Test
public void shouldGenerateLayoutForItemOfRepositoryPresenterOfResultList() {
  final RepositoryPresenter<Result<List<String>>> resultListRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layoutForItem(layoutForItem)
          .itemId(ITEM_ID)
          .forResultList();
  assertThat(resultListRepositoryPresenter.getLayoutResId(STRING_LIST_RESULT, 1),
      is(DYNAMIC_LAYOUT_ID));
}
 

@Test
public void shouldBindRepositoryPresenterOfResultList() {
  final RepositoryPresenter<Result<List<String>>> resultListRepositoryPresenter =
      repositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .bindWith(binder)
          .forResultList();
  resultListRepositoryPresenter.bind(STRING_LIST_RESULT, 1, viewHolder);
  verify(binder).bind(SECOND_STRING, view);
}
 

@Test
public void shouldNotRecycleRepositoryPresenterOfResultWithNoRecycling() {
  final RepositoryPresenter<Result<String>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .handler(HANDLER_ID, HANDLER)
          .handler(SECOND_HANDLER_ID, SECOND_HANDLER)
          .onRecycle(DO_NOTHING)
          .forResult();

  resultRepositoryPresenter.recycle(viewHolder);

  verifyNoMoreInteractions(viewDataBinding);
}
 

@Test
public void shouldGenerateItemIdForItemOfRepositoryPresenterOfResultList() {
  final RepositoryPresenter<Result<List<String>>> resultListRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemIdForItem(itemIdForItem)
          .forResultList();
  resultListRepositoryPresenter.bind(STRING_LIST_RESULT, 1, viewHolder);
}
 

@Override protected void initData() {
    SaveVolley saveVolley = SaveVolleys
        .<GankData>request(TEST_URL)
        .method(Method.GET)
        .parseStyle(GSON)
        .classOf(GankData.class)
        .createRequest()
        .context(this)
        .compile();

    final Repository<GankResultData> repository = Repositories.repositoryWithInitialValue(
        INITIAL_VALUE)
        .observe(saveVolley.getReservoir())
        .onUpdatesPerLoop()
        .goTo(executor)
        .attemptGetFrom(saveVolley.getReservoir())
        .orSkip()
        .thenAttemptTransform(new Function<Object, Result<GankResultData>>() {
            /**
             * Returns the result of applying this function to {@code input}.
             */
            @NonNull @Override public Result<GankResultData> apply(@NonNull Object input) {
                if (input instanceof GankData) {
                    return Result.success(((GankData) input).results.get(0));
                } else if (input instanceof VolleyError) {
                    return Result.failure((VolleyError) input);
                }
                return Result.failure();
            }
        })
        .orSkip()
        .compile();

    repository.addUpdatable(new Updatable() {
        @Override public void update() {
            getContentText.setText(repository.get().toString());
        }
    });
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_movies);
    ButterKnife.bind(this);
    setSupportActionBar(mToolbar);

    int columns = getResources().getInteger(R.integer.columns_count);
    RecyclerView.LayoutManager layoutManager = new GridLayoutManager(getApplicationContext(), columns);
    mMoviesRecycler.setLayoutManager(layoutManager);
    mAdapter = createAdapter();
    mMoviesRecycler.setAdapter(mAdapter);

    mMoviesRepository = Repositories.repositoryWithInitialValue(Result.<List<Movie>>absent())
            .observe()
            .onUpdatesPerLoop()
            .goTo(AsyncExecutor.EXECUTOR)
            .getFrom(() -> {
                try {
                    return ApiFactory.getMoviesService().popularMovies().execute().body();
                } catch (IOException e) {
                    return new MoviesResponse();
                }
            })
            .thenTransform(input -> Result.absentIfNull(input.getMovies()))
            .compile();
}
 

@Test
public void shouldBindRepositoryPresenterOfResult() {
  final RepositoryPresenter<Result<String>> resultRepositoryPresenter =
      repositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .bindWith(binder)
          .forResult();
  resultRepositoryPresenter.bind(STRING_RESULT, 0, viewHolder);
  verify(binder).bind(STRING, view);
}
 

@Override
@NonNull
public Result<HttpResponse> apply(@NonNull final HttpRequest request) {
  try {
    final HttpURLConnection connection =
        (HttpURLConnection) new URL(request.url).openConnection();
    try {
      return success(getHttpResponseResult(request, connection));
    } finally {
      connection.disconnect();
    }
  } catch (final IOException exception) {
    return failure(exception);
  }
}
 

@NonNull
@Override
public Result<String> apply(@NonNull final String contentType) {
  final String[] parameters = contentType.split(";");
  for (final String parameter : parameters) {
    final String trimmedLowerCaseParameter = parameter.trim().toLowerCase(US);
    if (trimmedLowerCaseParameter.startsWith(CHARSET)) {
      return present(trimmedLowerCaseParameter.substring(CHARSET.length()));
    }
  }
  return absent();
}
 

private void setUpRepository() {
  // Set up background executor
  networkExecutor = newSingleThreadExecutor();

  // Set up usernames repository
  usernamesRepository = Repositories
      .repositoryWithInitialValue(Result.<List<String>>absent())
      .observe(refreshObservable)
      .onUpdatesPerLoop()
      .goTo(networkExecutor)
      .thenGetFrom(new UsernamesSupplier())
      .compile();
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.calculator);
    if (savedInstanceState != null && savedInstanceState.containsKey(VALUE_1)){
        mValue1Repo.accept(savedInstanceState.getInt(VALUE_1));
        mValue2Repo.accept(savedInstanceState.getInt(VALUE_2));
        mOperationSelector.accept(Result.present(savedInstanceState.getInt(OPERATION_KEY)));
    }
    // For testing, the animation can be disabled via an Intent.
    if (getIntent().hasExtra(ANIMATIONS_ENABLED_KEY)) {
        mAnimationEnabled = getIntent().getBooleanExtra(ANIMATIONS_ENABLED_KEY, true);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.calculator);
    if (savedInstanceState != null && savedInstanceState.containsKey(VALUE_1)) {
        mValue1Repo.accept(savedInstanceState.getInt(VALUE_1));
        mValue2Repo.accept(savedInstanceState.getInt(VALUE_2));
        mOperationSelector.accept(Result.present(savedInstanceState.getInt(OPERATION_KEY)));
    }
}
 

@Test
public void shouldReturnZeroForCountOfRepositoryPresenterOfFailedResultList() {
  final RepositoryPresenter<Result<List<String>>> resultListRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .forResultList();
  assertThat(resultListRepositoryPresenter.getItemCount(LIST_FAILURE), is(0));
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.calculator);
    if (savedInstanceState !=  null && savedInstanceState.containsKey(VALUE_1)){
        mValue1Repo.accept(savedInstanceState.getInt(VALUE_1));
        mValue2Repo.accept(savedInstanceState.getInt(VALUE_2));
        mOperationSelector.accept(Result.present(savedInstanceState.getInt(OPERATION_KEY)));
    }
    // For testing, the animation can be disabled via an Intent.
    if (getIntent().hasExtra(ANIMATIONS_ENABLED_KEY)) {
        mAnimationEnabled = getIntent().getBooleanExtra(ANIMATIONS_ENABLED_KEY, true);
    }
}
 

private void setUpRepository() {
    mObservable = new OnClickObservable() {
        @Override
        public void onClick( ) {
            mRepository.accept(Result.success(MockRandomData.getRandomImage()));
        }
    };

    mRepository = Repositories.mutableRepository(Result.success(MockRandomData.getRandomImage()));

    //initialization
    //mRepository.accept(Result.success(MockRandomData.getRandomImage()));
}
 

@Test
public void shouldReturnStableIdForRepositoryPresenterOfResult() {
  final RepositoryPresenter<Result<String>> resultRepositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .stableIdForItem(Functions.<String, Long>staticFunction(STABLE_ID))
          .forResult();
  assertThat(resultRepositoryPresenter.getItemId(STRING_RESULT, 0), is(STABLE_ID));
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.calculator);
    if (savedInstanceState !=  null && savedInstanceState.containsKey(VALUE_1)){
        mValue1Repo.accept(savedInstanceState.getInt(VALUE_1));
        mValue2Repo.accept(savedInstanceState.getInt(VALUE_2));
        mOperationSelector.accept(Result.present(savedInstanceState.getInt(OPERATION_KEY)));
    }
    // For testing, the animation can be disabled via an Intent.
    if (getIntent().hasExtra(ANIMATIONS_ENABLED_KEY)) {
        mAnimationEnabled = getIntent().getBooleanExtra(ANIMATIONS_ENABLED_KEY, true);
    }
}