Java ActivityEvent类代码示例

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
/**
 * 获取快递信息
 *
 * @param type   快递类型
 * @param postid 快递单号
 */
public void getExpressInfo(String type, String postid) {
    isShowLoading.set(true);

    dataManager.getExpressInfo(type, postid)
            .subscribeOn(Schedulers.io()) // 在子线程中进行Http访问
            .observeOn(AndroidSchedulers.mainThread()) // UI线程处理返回接口
            .compose(getProvider().<ExpressInfo>bindUntilEvent(ActivityEvent.DESTROY)) // onDestroy取消订阅
            .subscribe(new DefaultObserver<ExpressInfo>() {  // 订阅
                @Override
                public void onNext(@NonNull ExpressInfo expressInfo) {
                    ExpressViewModel.this.expressInfo.setExpressInfo(expressInfo);
                }

                @Override
                public void onError(@NonNull Throwable e) {
                    errorMessage.set(e.getMessage());
                    isShowLoading.set(false);
                }

                @Override
                public void onComplete() {
                    isShowLoading.set(false);
                }
            });
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    button = (Button) findViewById(R.id.button2);

    RetrofitHelper.creatApi(ApiService.class).getMessage("yuantong","200382770316")
            .compose(MainActivity.this.<Result<List<Message>>>bindUntilEvent(ActivityEvent.DESTROY))
            .compose(SchedulerTransformer.<Result<List<Message>>>transformer())
            .map(new ServerResponseFun<List<Message>>())
            .onErrorResumeNext(new HttpResponseFunc<List<Message>>())
            .subscribe(new ApiSubscriber<List<Message>>(MainActivity.this,true,false) {
                @Override
                public void onNext(@NonNull List<Message> messages) {
                    button.setText(messages.toString());
                }
            });


}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
/**
 * 获取快递信息
 *
 * @param type   快递类型
 * @param postid 快递单号
 */
public void getExpressInfo(String type, String postid) {
    expressView.showProgressDialog();

    dataManager.getExpressInfo(type, postid)
            .subscribeOn(Schedulers.io()) // 在子线程中进行Http访问
            .observeOn(AndroidSchedulers.mainThread()) // UI线程处理返回接口
            .compose(getProvider().<ExpressInfo>bindUntilEvent(ActivityEvent.DESTROY)) // onDestroy取消订阅
            .subscribe(new DefaultObserver<ExpressInfo>() {  // 订阅
                @Override
                public void onNext(@NonNull ExpressInfo expressInfo) {
                    expressView.updateView(expressInfo);
                }

                @Override
                public void onError(@NonNull Throwable e) {
                    expressView.showError(e.getMessage());
                    expressView.hideProgressDialog();
                }

                @Override
                public void onComplete() {
                    expressView.hideProgressDialog();
                }
            });
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
/**
 * 获取被监听者
 * 备注:网络请求Observable构建
 * data:网络请求参数
 * <h1>补充说明</h1>
 * 传入LifecycleProvider<ActivityEvent>手动管理生命周期,避免内存溢出
 * 备注:需要继承RxActivity,RxAppCompatActivity,RxFragmentActivity
 *
 * @author ZhongDaFeng
 */
public static Observable getObservable(Observable<HttpResponse> apiObservable, LifecycleProvider<ActivityEvent> lifecycle, ActivityEvent event) {
   // showLog(request);
    Observable observable;
    if (lifecycle != null) {
        //手动管理移除监听生命周期.eg:ActivityEvent.STOP
        observable = apiObservable
                .map(new ServerResultFunction())
                .compose(lifecycle.bindUntilEvent(event))//需要在这个位置添加
                .onErrorResumeNext(new HttpResultFunction<>())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    } else {
        observable = getObservable(apiObservable);
    }
    return observable;
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    lifecycleSubject.onNext(ActivityEvent.CREATE);
    super.onCreate(savedInstanceState);

    //兼容DataBinding的方式的时候就不需要设置了
    if (getLayoutId() != 0) {
        setContentView(getLayoutId());
    }

    // base setup
    Bundle extras = getIntent().getExtras();
    if (null != extras) {
        getBundleExtras(extras);
    }

    mHandler = new MyHandler(this);

    initSpecialView(savedInstanceState);
    initViews(savedInstanceState);
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Override
protected void onResume() {
    super.onResume();
    lifecycleSubject.onNext(ActivityEvent.RESUME);
    if (isRequestPermissionOnResume()) {
        checkPermission();
    } else {
        if (!isFirstResume) {
            checkPermission();
        } else {
            isFirstResume = false;
        }
    }

    if (getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
private void refreshProfile() {
    mDataManager.profile().compose(this.<Response<Me>>bindUntilEvent(ActivityEvent.DESTROY)).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new SubscriberCallBack<Me>() {
        @Override
        public void onSuccess(Me me) {
            Hawk.put("ME_PROFILE", me);
            TCAgent.onLogin(me.uid, TDAccount.AccountType.REGISTERED, me.username);

            Intent intent = new Intent(LoginActivity.this, MainActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
            startActivity(intent);
            supportFinishAfterTransition();
        }

        @Override
        public void onFailure(Throwable t) {

        }

        @Override
        public void onCompleted() {
            mLoginProgress.setVisibility(View.GONE);
        }
    });
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Override
public void initView(Bundle savedInstanceState) {
    if (!isTaskRoot()) {
        return;
    }
    if (!StatusBarUtil.isSupportStatusBarFontChange()) {
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); //隐藏状态栏
    }
    mContentView.setBackgroundColor(Color.WHITE);
    tvVersion.setText("V" + FastUtil.getVersionName(mContext));
    RxJavaManager.getInstance().setTimer(2000, new RxJavaManager.TimerListener() {
        @Override
        public void timeEnd() {
            FastUtil.startActivity(mContext, MainActivity.class);
            finish();
        }
    }).compose(bindUntilEvent(ActivityEvent.DESTROY));
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Override
@NonNull
public ActivityEvent apply(Event.Type type) throws Exception {
    switch (type) {
        case CREATE:
            return ActivityEvent.CREATE;
        case START:
            return ActivityEvent.START;
        case RESUME:
            return ActivityEvent.RESUME;
        case PAUSE:
            return ActivityEvent.PAUSE;
        case STOP:
            return ActivityEvent.STOP;
        case DESTROY:
            return ActivityEvent.DESTROY;
        default:
            throw new IllegalArgumentException("Cannot map " + type + " to a ActivityEvent.");
    }
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Test
public void testLifecycle() {
    NaviEmitter activity = NaviEmitter.createActivityEmitter();
    LifecycleProvider<ActivityEvent> provider = NaviLifecycle.createActivityLifecycleProvider(activity);

    TestObserver<ActivityEvent> testObserver = provider.lifecycle().test();

    activity.onCreate(null);
    activity.onStart();
    activity.onResume();
    activity.onPause();
    activity.onStop();
    activity.onDestroy();

    testObserver.assertValues(
        ActivityEvent.CREATE,
        ActivityEvent.START,
        ActivityEvent.RESUME,
        ActivityEvent.PAUSE,
        ActivityEvent.STOP,
        ActivityEvent.DESTROY
    );
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Test
public void testBindUntilEvent() {
    NaviEmitter activity = createActivityEmitter();
    LifecycleProvider<ActivityEvent> provider = createActivityLifecycleProvider(activity);

    Observable<Object> observable = create().hide();
    TestObserver<Object> testObserver = observable.compose(provider.bindUntilEvent(STOP)).test();

    activity.onCreate(null);
    testObserver.assertNotComplete();
    activity.onStart();
    testObserver.assertNotComplete();
    activity.onResume();
    testObserver.assertNotComplete();
    activity.onPause();
    testObserver.assertNotComplete();
    activity.onStop();
    testObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Test
public void testLeakFree() {
    NaviEmitter activity = NaviEmitter.createActivityEmitter();
    LifecycleProvider<ActivityEvent> provider = NaviLifecycle.createActivityLifecycleProvider(activity);
    WeakReference<NaviEmitter> activityRef = new WeakReference<>(activity);
    WeakReference<LifecycleProvider<ActivityEvent>> providerRef = new WeakReference<>(provider);

    Observable<Object> observable = PublishSubject.create().hide();
    TestObserver<Object> testObserver = observable.compose(provider.bindUntilEvent(ActivityEvent.STOP)).test();

    activity.onCreate(null);
    activity.onStart();
    activity.onResume();
    activity.onPause();
    activity.onStop();
    activity.onDestroy();

    activity = null;
    provider = null;
    TestUtil.cleanGarbage();

    assertNull(activityRef.get());
    assertNull(providerRef.get());
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
private void testLifecycle(ActivityController<? extends LifecycleProvider<ActivityEvent>> controller) {
    LifecycleProvider<ActivityEvent> activity = controller.get();

    TestObserver<ActivityEvent> testObserver = activity.lifecycle().test();

    controller.create();
    controller.start();
    controller.resume();
    controller.pause();
    controller.stop();
    controller.destroy();

    testObserver.assertValues(
        ActivityEvent.CREATE,
        ActivityEvent.START,
        ActivityEvent.RESUME,
        ActivityEvent.PAUSE,
        ActivityEvent.STOP,
        ActivityEvent.DESTROY
    );
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
private void testBindUntilEvent(ActivityController<? extends LifecycleProvider<ActivityEvent>> controller) {
    LifecycleProvider<ActivityEvent> activity = controller.get();

    TestObserver<Object> testObserver = observable.compose(activity.bindUntilEvent(STOP)).test();

    controller.create();
    testObserver.assertNotComplete();
    controller.start();
    testObserver.assertNotComplete();
    controller.resume();
    testObserver.assertNotComplete();
    controller.pause();
    testObserver.assertNotComplete();
    controller.stop();
    testObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.ActivityEvent; //导入依赖的package包/类
@Test
public void testBindUntilActivityEvent() {
    BehaviorSubject<ActivityEvent> lifecycle = BehaviorSubject.create();

    TestObserver<Object> testObserver =
        observable.compose(RxLifecycle.bindUntilEvent(lifecycle, ActivityEvent.STOP)).test();

    lifecycle.onNext(ActivityEvent.CREATE);
    testObserver.assertNotComplete();
    lifecycle.onNext(ActivityEvent.START);
    testObserver.assertNotComplete();
    lifecycle.onNext(ActivityEvent.RESUME);
    testObserver.assertNotComplete();
    lifecycle.onNext(ActivityEvent.PAUSE);
    testObserver.assertNotComplete();
    lifecycle.onNext(ActivityEvent.STOP);
    testObserver.assertComplete();
}