import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
public void showSuggestedApps() {
  appViewSimilarAppAnalytics.similarAppsIsShown();
  setSuggestedShowing(true);

  adsRepository.getAdsFromAppviewSuggested(getPackageName(), appViewModel.getKeywords())
      .onErrorReturn(throwable -> Collections.emptyList())
      .zipWith(requestFactoryCdnWeb.newGetRecommendedRequest(6, getPackageName())
          .observe(), (minimalAds, listApps) -> new AppViewSuggestedAppsDisplayable(minimalAds,
          removeCurrentAppFromSuggested(listApps.getDataList()
              // TODO: 04/10/2017 trinkes make some default thing for StoreContext.home
              .getList()), appViewSimilarAppAnalytics, navigationTracker, StoreContext.home))
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(appViewSuggestedAppsDisplayable -> {
        addDisplayableWithAnimation(1, appViewSuggestedAppsDisplayable);
      }, Throwable::printStackTrace);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@UiThread private void fetchRollbacks() {
  RollbackAccessor rollbackAccessor = AccessorFactory.getAccessorFor(
      ((AptoideApplication) getContext().getApplicationContext()
          .getApplicationContext()).getDatabase(), Rollback.class);
  rollbackAccessor.getConfirmedRollbacks()
      .observeOn(Schedulers.computation())
      .map(rollbacks -> createDisplayables(rollbacks))
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(rollbacks -> {
        if (rollbacks == null || rollbacks.isEmpty()) {
          emptyData.setText(AptoideUtils.StringU.getFormattedString(R.string.no_rollbacks_msg,
              getContext().getResources(), marketName));
          emptyData.setVisibility(View.VISIBLE);
        } else {
          emptyData.setVisibility(View.GONE);
          clearDisplayables().addDisplayables(rollbacks, true);
        }
        finishLoading();
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
  super.onViewCreated(view, savedInstanceState);

  // show updates
  updateRepository.getAll(false)
      //.buffer(750, TimeUnit.MILLISECONDS)
      //.flatMap(listOfUpdateList -> Observable.from(listOfUpdateList).takeLast(1))
      .sample(750, TimeUnit.MILLISECONDS)
      .observeOn(AndroidSchedulers.mainThread())
      .flatMap(updateList -> {
        clearDisplayables();
        setUpdates(updateList);
        showUpdateMessage(updateList);
        return fetchInstalled().doOnNext(apps -> setInstalled(apps));
      })
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(__ -> {
        finishLoading();
      }, err -> {
        Logger.e(TAG, "listing updates or installed threw an exception");
        CrashReport.getInstance()
            .log(err);
        finishLoading();
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@NonNull private Observable<LifecycleEvent> convertToEvent(FragmentEvent event) {
  switch (event) {
    case ATTACH:
    case CREATE:
      return Observable.empty();
    case CREATE_VIEW:
      return Observable.just(LifecycleEvent.CREATE);
    case START:
      return Observable.just(LifecycleEvent.START);
    case RESUME:
      return Observable.just(LifecycleEvent.RESUME);
    case PAUSE:
      return Observable.just(LifecycleEvent.PAUSE);
    case STOP:
      return Observable.just(LifecycleEvent.STOP);
    case DESTROY_VIEW:
      return Observable.just(LifecycleEvent.DESTROY);
    case DETACH:
    case DESTROY:
      return Observable.empty();
    default:
      throw new IllegalStateException("Unrecognized event: " + event.name());
  }
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
private void fetchScheduledDownloads() {
  scheduledDownloadRepository.getAllScheduledDownloads()
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(scheduledDownloads -> {
        updateUi(scheduledDownloads);
      }, t -> {
        CrashReport.getInstance()
            .log(t);
        emptyData.setText(R.string.no_sch_downloads);
        emptyData.setVisibility(View.VISIBLE);
        clearDisplayables();
        finishLoading();
      });

  // keep installing data when downloading were stoped
  //scheduledDownloadRepository.getAllScheduledDownloads().first().subscribe(scheduleds -> {
  //  ArrayList<Scheduled> installing = new ArrayList<>();
  //  for (Scheduled s : scheduleds) {
  //    if (s.isDownloading()) installing.add(s);
  //  }
  //  downloadAndInstallScheduledList(installing);
  //});

  //compositeSubscription.add(subscription);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override public void onCreateOptionsMenu(final Menu menu, final MenuInflater inflater) {
  super.onCreateOptionsMenu(menu, inflater);
  inflater.inflate(R.menu.menu_install, menu);
  installMenuItem = menu.findItem(R.id.menu_install);

  installedRepository.getInstalled(packageName)
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(installed -> {
        if (installed != null) {
          // app installed... update text
          installMenuItem.setTitle(R.string.reviewappview_button_open);
        }
      }, err -> {
        CrashReport.getInstance()
            .log(err);
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
public void setupThemeSelector() {

    themeSelectorView.setLayoutManager(
        new LinearLayoutManager(getActivity(), LinearLayoutManager.HORIZONTAL, false));
    PublishRelay<StoreTheme> storeThemePublishRelay = PublishRelay.create();
    themeSelectorAdapter =
        new ThemeSelectorViewAdapter(storeThemePublishRelay, StoreTheme.getThemesFromVersion(8));
    themeSelectorView.setAdapter(themeSelectorAdapter);

    themeSelectorAdapter.storeThemeSelection()
        .doOnNext(storeTheme -> currentModel.setStoreTheme(storeTheme))
        .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
        .subscribe();

    themeSelectorView.addItemDecoration(new DividerItemDecoration(getContext(), 8,
        DividerItemDecoration.LEFT | DividerItemDecoration.RIGHT));

    themeSelectorAdapter.selectTheme(currentModel.getStoreTheme());
  }
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
private Observable<Void> showStoreCommentFragment(final long storeId,
    @NonNull final String storeName, @NonNull final FragmentManager fragmentManager,
    @NonNull final View view) {

  return Observable.just(accountManager.isLoggedIn())
      .flatMap(isLoggedIn -> {

        if (isLoggedIn) {
          // show fragment CommentDialog
          CommentDialogFragment commentDialogFragment =
              CommentDialogFragment.newInstanceStoreComment(storeId, storeName);

          return commentDialogFragment.lifecycle()
              .doOnSubscribe(
                  () -> commentDialogFragment.show(fragmentManager, "fragment_comment_dialog"))
              .filter(event -> event.equals(FragmentEvent.DESTROY_VIEW))
              .flatMap(event -> Observable.empty());
        }

        return showSignInMessage(view).toObservable();
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
private Completable showStoreCommentFragment(final long storeId, @NonNull final Comment comment,
    @NonNull final String storeName, @NonNull final FragmentManager fragmentManager,
    @NonNull final View view, Observable<Void> reloadComments) {

  return accountManager.accountStatus()
      .first()
      .toSingle()
      .flatMapCompletable(account -> {
        if (account.isLoggedIn()) {
          // show fragment CommentDialog
          CommentDialogFragment commentDialogFragment =
              CommentDialogFragment.newInstanceStoreCommentReply(storeId, comment.getId(),
                  storeName);

          return commentDialogFragment.lifecycle()
              .doOnSubscribe(() -> commentDialogFragment.show(fragmentManager,
                  "fragment_comment_dialog_latest"))
              .filter(event -> event.equals(FragmentEvent.DESTROY_VIEW))
              .flatMap(event -> reloadComments)
              .toCompletable();
        }

        return showSignInMessage(view);
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
public Completable createNewCommentFragment(final String timelineArticleId,
    final long previousCommentId) {

  return accountManager.accountStatus()
      .first()
      .toSingle()
      .flatMapCompletable(account -> {
        if (account.isLoggedIn()) {
          // show fragment CommentDialog
          FragmentManager fm = CommentListFragment.this.getActivity()
              .getSupportFragmentManager();
          CommentDialogFragment commentDialogFragment =
              CommentDialogFragment.newInstanceTimelineArticleComment(timelineArticleId,
                  previousCommentId);
          commentDialogFragment.setCommentDialogCallbackContract(this);

          return commentDialogFragment.lifecycle()
              .doOnSubscribe(() -> commentDialogFragment.show(fm, "fragment_comment_dialog"))
              .filter(event -> event.equals(FragmentEvent.DESTROY_VIEW))
              .toCompletable();
        }

        return showSignInMessage();
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override public void onViewCreated(final View view, Bundle savedInstanceState) {
  super.onViewCreated(view, savedInstanceState);
  bindViews(view);
  setupSearchView();
  setupStoreSearch(searchView);
  RxView.clicks(addStoreButton)
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(click -> {
        addStoreAction();
        storeAnalytics.sendStoreTabInteractEvent("Add Store");
      });
  RxView.clicks(topStoresButton)
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(click -> topStoresAction());

  RxView.clicks(topStoreText1)
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(click -> topStoresAction());

  RxView.clicks(topStoreText2)
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(click -> topStoresAction());
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
private void registerForViewChanges() {
  AptoideAccountManager accountManager =
      ((AptoideApplication) getContext().getApplicationContext()).getAccountManager();

  Observable<Account> loginObservable = accountManager.accountStatus()
      .doOnNext(__ -> reloadData());

  Observable<List<Store>> storesObservable = storeRepository.getAll()
      .skip(1)
      .doOnNext(__ -> {
        Logger.d(TAG, "Store database changed, reloading...");
        reloadData();
      });

  //
  // until this fragment is destroyed we listen for DB changes and login state changes
  // to reload the stores that we are showing
  //
  Observable.merge(loginObservable, storesObservable)
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(__ -> {
      }, err -> CrashReport.getInstance()
          .log(err));
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override public void setupViews() {
  loginBottomSheet.state()
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(state -> {
        if (isInPortraitMode && LoginBottomSheet.State.EXPANDED.equals(state)) {
          skipOrNextLayout.setVisibility(View.GONE);
        } else if (LoginBottomSheet.State.COLLAPSED.equals(state)) {
          skipOrNextLayout.setVisibility(View.VISIBLE);
        }
      });

  final AptoideAccountManager accountManager =
      ((AptoideApplication) getContext().getApplicationContext()).getAccountManager();
  WizardPresenter presenter =
      new WizardPresenter(this, accountManager, CrashReport.getInstance());
  attachPresenter(presenter);
  viewPager.addOnPageChangeListener(presenter);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
public void showSuggestedApps() {
  appViewSimilarAppAnalytics.similarAppsIsShown();
  suggestedShowing = true;

  adsRepository.getAdsFromAppviewSuggested(packageName, keywords)
      .onErrorReturn(throwable -> Collections.emptyList())
      .zipWith(requestFactoryCdnWeb.newGetRecommendedRequest(6, packageName)
          .observe(), (minimalAds, listApps) -> new AppViewSuggestedAppsDisplayable(minimalAds,
          removeCurrentAppFromSuggested(listApps.getDataList()
              // TODO: 04/10/2017 trinkes make some default thing for StoreContext.home
              .getList()), appViewSimilarAppAnalytics, navigationTracker, StoreContext.home))
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(appViewSuggestedAppsDisplayable -> {
        addDisplayableWithAnimation(1, appViewSuggestedAppsDisplayable);
      }, Throwable::printStackTrace);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
private void openSocialLink(String packageName, String socialUrl, String pageTitle,
    Uri uriToOpenApp) {

  installedRepository.getInstalled(packageName)
      .first()
      .observeOn(AndroidSchedulers.mainThread())
      .compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
      .subscribe(installedFacebook -> {
        if (installedFacebook == null) {
          getFragmentNavigator().navigateTo(AptoideApplication.getFragmentProvider()
              .newSocialFragment(socialUrl, pageTitle), true);
        } else {
          Intent sharingIntent = new Intent(Intent.ACTION_VIEW, uriToOpenApp);
          getContext().startActivity(sharingIntent);
        }
      }, err -> {
        CrashReport.getInstance()
            .log(err);
      });
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
/**
 * Executes an observable subscription based on {@link RxLifecycle}
 * {@link LifecycleProvider}
 *
 * @param observable {@link rx.Observable} given observable for subscribe
 * @param event {@link FragmentEvent} a fragment on {@link RxLifecycle}
 * @param subscribers [OPTIONAL] {@link rx.Subscriber} custom subscriber
 * @param <T> any object for {@link rx.Observable}
 * @return {@link Subscription}
 */
@SafeVarargs protected final <T> Subscription bindUntilEvent(@NonNull Observable<T> observable,
    @NonNull FragmentEvent event, Subscriber<T>... subscribers) {
  if (subscribers.length > 1) {
    throw new IllegalArgumentException("You can pass only one Subscriber<T>");
  }
  if (subscribers.length == 0) {
    return composeUntilEvent(observable, event).subscribe(new DefaultSubscriber<T>());
  }
  return composeUntilEvent(observable, event).subscribe(subscribers[0]);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
/**
 * Helper methods, Composes a new {@link rx.Observable} based on a specific event
 *
 * @param observable {@link rx.Observable} given observable for subscribe
 * @param <T> any object for {@link rx.Observable}
 * @return {@link rx.Observable}
 */
@SuppressWarnings("unchecked")
private <T> Observable<T> composeLifecycle(@NonNull Observable<T> observable, Scheduler scheduler) {
  if (naviComponent instanceof Fragment) {
    return observable.doOnUnsubscribe(loggingUnsub)
        .compose(applySchedulers(scheduler))
        .compose(lifecycleProvider.<T>bindUntilEvent(FragmentEvent.DESTROY_VIEW));
  } else {
    return observable.doOnUnsubscribe(loggingUnsub)
        .compose(applySchedulers(scheduler))
        .compose(lifecycleProvider.<T>bindUntilEvent(ActivityEvent.DESTROY));
  }
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Test public void testActivityObservableBindUntilEvent() throws Exception {
  final Observable<Object> observable = PublishSubject.create().asObservable();

  TestSubscriber<Object> testSubscriber = TestSubscriber.create();
  NaviFragment fragment = new TestFragment();
  this.presenter.bind(fragment);

  startFragment(fragment);
  this.presenter.bindUntilEvent(observable, FragmentEvent.STOP, testSubscriber);

  fragment.onAttach(null);
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onCreate(null);
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onViewCreated(null, null);
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onStart();
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onResume();
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onPause();
  assertFalse(testSubscriber.isUnsubscribed());
  fragment.onStop();
  testSubscriber.assertCompleted();
  testSubscriber.assertUnsubscribed();
  fragment.onDestroyView();
  testSubscriber.assertCompleted();
  testSubscriber.assertUnsubscribed();
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override
protected void onDialogViewCreated() {
    textView.setText(text);
    progressBar.setIndeterminate(true);
    progressBar.setMax(1000);
    progress.compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
            .onErrorResumeNext(Observable.empty())
            .doAfterTerminate(this::dismiss)
            .subscribe(this::updateStatus);
}
 

import com.trello.rxlifecycle.android.FragmentEvent; //导入依赖的package包/类
@Override
protected void onDialogViewCreated() {
    progressBar.setIndeterminate(true);
    progressBar.setMax(1000);
    progress.compose(bindUntilEvent(FragmentEvent.DESTROY_VIEW))
            .onErrorResumeNext(Observable.empty())
            .doAfterTerminate(this::dismiss)
            .subscribe(this::updateStatus);
}