活动演示者将更新选项卡布局片段

Question

我有一个活动1，其TabLayout由两个片段组成（每个片段都有一个演示者）。一旦我单击工具栏上的按钮，一个新的 Activity2 就会启动（使用 startActivityWithResults），其中包含一个简单的列表。在选择列表中的一个项目时，活动 2 将选定的字符串返回到上一个活动 1（具有 TabLayout 的活动 1）。

现在，一旦在 Activity1 中调用了 onActivityResult，这个 API 将调用一个 API（使用演示器），该 API 将获得新结果，然后它应该更新 TabLayout 中的两个片段。我想用RxJava来做这件事，但我不知道从哪里开始。

活动1：

public class Activity1 extends BaseActivity {
@Inject
Actvity1Presenter mPresenter;
public static Intent newIntent(Context packageContext) {
    return new Intent(packageContext, Activity1.class);
}
@LayoutRes
protected int getLayoutRedIs() {
    return R.layout.app_bar_activity1;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(getLayoutRedIs());
    FwApplication.component(this).inject(this);
    mPresenter.attachView(this);
    Toolbar tb = (Toolbar) findViewById(R.id.toolbar_chips);
    setSupportActionBar(tb);
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    getSupportActionBar().setHomeAsUpIndicator(R.drawable.ic_back_arrow);
    mTabLayout = (TabLayout) findViewById(R.id.tab_layout);
    mTabLayout.addTab(mTabLayout.newTab().setText("TAB1"));
    mTabLayout.addTab(mTabLayout.newTab().setText("TAB2"));
    mTabLayout.setTabGravity(TabLayout.GRAVITY_FILL);
    mViewPager = (ViewPager) findViewById(R.id.viewpager);
    mViewPager.setAdapter(new PagerAdapter(getSupportFragmentManager(),
            mTabLayout.getTabCount()));
    mViewPager.addOnPageChangeListener(new TabLayout.TabLayoutOnPageChangeListener(mTabLayout));
    mTabLayout.setOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
        @Override
        public void onTabSelected(TabLayout.Tab tab) {
            mViewPager.setCurrentItem(tab.getPosition());
        }
        @Override
        public void onTabUnselected(TabLayout.Tab tab) {
        }
        @Override
        public void onTabReselected(TabLayout.Tab tab) {
        }
    });
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == PICK_ITEM_CODE) {
        if (resultCode == RESULT_OK) {
            mPresenter.updateResults(data);
        }
        if (resultCode == RESULT_CANCELED) {
        }
    }
}

还有寻呼机：

public class PagerAdapter extends FragmentPagerAdapter {
int mNumOfTabs;
public PagerAdapter(FragmentManager fm, int NumOfTabs) {
    super(fm);
    this.mNumOfTabs = NumOfTabs;
}
@Override
public Fragment getItem(int position) {
    switch (position) {
      case 0:
        return Fragment1.newInstance();
        break;
      case 1:
        return Fragment2.newInstance();
        break;
    }
}
@Override
public int getCount() {
    return mNumOfTabs;
}
}

编辑

活动演示者：

public class ActivityPresenter implements Presenter<ActivityView>,
    Interactor.OnFinishedListener<Response> {
private static final String TAG = "FW.ActivityPresenter";
@Inject
QueryPreferences mQueryPreferences;
private Interactor mInteractor;
private ActivityView mView;
private NetworkService mNetworkService;
private boolean mUseCache;
private String mQuery;
private int mPage;
private PublishSubject<Response> mPublishSubject =   PublishSubject.create();
Observable<Response> getObservableResults() {
   return mPublishSubject;
}
@Inject
public ActivityPresenter(NetworkService networkService) {
    mNetworkService = networkService;
    mInteractor = new InteractorImpl(mNetworkService);
}
public void onSearchQueryListener(String query, int page) {
    mQuery = mQueryPreferences.getStoredQuery();
    mUseCache = query.equals(mQuery);
    if (!mUseCache) {
        mQueryPreferences.setStoredQuery(query);
        Log.d(TAG, "Query added to cache: " + query);
    }
    mPage = page;
    mInteractor.loadResults(this, query, false, page);
}
@Override
public void onFinished(Response response) {
    if (mView != null) {
       mPublishSubject.onNext(response);
    }
}
@Override
public void onError(Throwable throwable) {
    if (mView != null) {
        mView.showMessage(throwable.getMessage());
    }
}
@Override
public void attachView(ActivityView mvpView) {
    mView = mvpView;
}
@Override
public void detachView() {
    mView = null;
    mInteractor.unSubscribe();
}
}

交互器：

public class InteractorImpl implements Interactor {
private static final String TAG = "FW.InteractorImpl";
private NetworkService mNetworkService;
private Subscription mSubscription;
public InteractorImpl(NetworkService networkService) {
    mNetworkService = networkService;
}
@Override
public void loadResults(final OnFinishedListener listener, String query, boolean useCache, int page) {
    Observable<Response> responseObservable = (Observable<Response>)
            mNetworkService.getObservable(mNetworkService.getAPI().getResponseObservable(query, page), Response.class, true, useCache);
    mSubscription = responseObservable.subscribe(new Observer<Response>() {
        @Override
        public void onCompleted() {
        }
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.getMessage());
            listener.onError(e);
        }
        @Override
        public void onNext(Response response) {
            listener.onFinished(response);
        }
    });
}
public void unSubscribe() {
    if(mSubscription != null && !mSubscription.isUnsubscribed()) {
        mSubscription.unsubscribe();
    }
}
}

片段演示者：

public class FragmentPresenter implements Presenter<FragmentView>,
    Interactor.OnFinishedListener<Response> {
private static final String TAG = "FW.FragmentPres";
@Inject
QueryPreferences mQueryPreferences;
private Interactor mInteractor;
private FragmentView mView;
private NetworkService mNetworkService;
private ActivityPresenter mActvityPresenter;
@Inject
public FragmentPresenter(NetworkService networkService) {
    mNetworkService = networkService;
    mInteractor = new InteractorImpl(mNetworkService);
}
void attachRecipeActivityPresenter(ActivityPresenter activityPresenter) {
    mActvityPresenter = activityPresenter;
    mActvityPresenter.getObservableResults().subscribe(data -> showData(data));
}
private void showData(Response response) {
    if (response.getResults().getModels().isEmpty() && mPage == 0) {
        mView.showNoResults();
    } else {
        mView.showResults(response.getResults().getModels());
    }
}
@Override
public void onError(Throwable throwable) {
    if (mView != null) {
        mView.hideProgressBar();
        mView.showMessage(throwable.getMessage());
    }
}
@Override
public void attachView(FragmentView mvpView) {
    mView = mvpView;
}
@Override
public void detachView() {
    mView = null;
    mInteractor.unSubscribe();
}
}

Answer 1

使用 Retrofit2 和 RxAndroid，您的方法将如下所示：

public void updateResults(String data) {
    yourRetrofitAPI.getSomething(data)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnSubscribe(() -> {
                // show your progress dialog
            })
            .subscribe(result -> {
                // pass result to your view
            }, error -> {
                // hide your progress dialog
                // get error message and send to your view
            }, () -> {
                // hide your progress dialog
            });
}
interface YourRetrofitAPI {
    @GET("/yourResource/{data}")
    Observable<String> getSomething(@Path("data") String data);
}

因此，关于通知片段，使用 MVP，您可以让演示者片段观察来自活动演示者的流，因此当您查询结束时，这两个片段都将收到通知。

public class ExampleUnitTest {
    @Test
    public void testSample() throws Exception {
        ActivityPresenter activityPresenter = new ActivityPresenter();
        Fragment1Presenter fragment1Presenter = new Fragment1Presenter();
        Fragment2Presenter fragment2Presenter = new Fragment2Presenter();
        fragment1Presenter.attachActivityPresenter(activityPresenter);
        fragment2Presenter.attachActivityPresenter(activityPresenter);
        Observable.range(1, 10)
                .delay(2, TimeUnit.SECONDS, Schedulers.immediate())
                .subscribe(integer -> activityPresenter.queryData("query: " + integer));
    }
    class ActivityPresenter {
        PublishSubject<String> publishSubject = PublishSubject.create();
        Observable<String> serverDataAsObservable() {
            return publishSubject.map(s -> String.format("%d - %s", System.currentTimeMillis(), s));
        }
        void queryData(String input) {
            // based on your input you should query data from server
            // and then emit those data with publish subject
            // then all subscribers will receive changes
            publishSubject.onNext(input);
        }
    }
    class Fragment1Presenter {
        private ActivityPresenter activityPresenter;
        void attachActivityPresenter(ActivityPresenter activityPresenter) {
            this.activityPresenter = activityPresenter;
            this.activityPresenter.serverDataAsObservable()
                    .subscribe(data -> showData(data));
        }
        private void showData(String data) {
            System.out.println("showing data on fragment1 with " + data);
        }
    }
    class Fragment2Presenter {
        private ActivityPresenter activityPresenter;
        void attachActivityPresenter(ActivityPresenter activityPresenter) {
            this.activityPresenter = activityPresenter;
            this.activityPresenter.serverDataAsObservable()
                    .subscribe(data -> showData(data));
        }
        private void showData(String data) {
            System.out.println("showing data on fragment2 with " + data);
        }
    }
}

希望它有帮助。

此致敬意。