避免使用onActivityResult，提高程式碼可讀性
Android中，通過startActivityForResult跳轉頁面獲取資料應該不必多說，但是這種所有獲取到的結果都需要到onActivityResult中處理的方式實在令人蛋疼。
試想一下，我們敲著程式碼唱著歌。突然，半路上跳出一群馬匪，讓我們到另一個頁面獲取一點資料，獲取後還不讓在當前程式碼位置處理邏輯，要去onActivityResult新增一個requestCode分支處理結果，處理完才讓回來，等這一切都做完回來難免就會陷入這樣的思考：我是誰，我在哪，我在幹什麼，我剛才寫到哪了……
再想一下，你跟同事的程式碼，跟到一個startActivityForResult，於是不耐煩地ctrl+f找到onActivityResult，發現裡面充斥著大量的requestCode分支，然後突然意識到剛才沒記下requestCode是什麼……
分析問題
問題的根源是所有處理結果的邏輯都要放到onActivityResult中，在裡面根據requestCode作不同處理。而我們渴望的是能在發起startActivityForResult的時候捎帶著把獲取結果後處理的邏輯也傳進去，並能在內部對requestCode判斷好，不用我們再判斷一遍。
2
解決問題嘗試一（不完美方式）
新建一個OnResultManager類，用來管理獲取結果的回撥，下面詳細說。
分析問題時說了，我們希望在發起startActivityForResult的時候就指定好處理結果的邏輯，這個簡單，在OnResultManager中建立一個Callback介面，裡面定義一個OnActivityResult方法，引數和Activity的OnActivityResult方法引數完全一樣，在發起start的時候除了intent和requestCode，再傳一個callback進去。而OnresultManager負責控制在系統的onActivityResult觸發時，呼叫對應callback的方法。
下面是OnResultManager的全部程式碼。
public class OnResultManager { private static final String TAG = "OnResultManager"; //HashMap的key Integer為requestCode private static WeakHashMap<Activity,HashMap<Integer,Callback>> mCallbacks = new WeakHashMap<>(); private WeakReference<Activity> mActivity; public OnResultManager(Activity activity) { mActivity = new WeakReference<Activity>(activity); } public void startForResult(Intent intent, int requestCode, Callback callback){ Activity activity = getActivity(); if(activity == null){ return; } addCallback(activity,requestCode,callback); activity.startActivityForResult(intent,requestCode); } public void trigger(int requestCode, int resultCode, Intent data){ Log.d(TAG,"----------- trigger"); Activity activity = getActivity(); if(activity == null){ return; } Callback callback = findCallback(activity,requestCode); if(callback != null){ callback.onActivityResult(requestCode,resultCode,data); } } //獲取該activity、該requestCode對應的callback private Callback findCallback(Activity activity,int requestCode){ HashMap<Integer,Callback> map = mCallbacks.get(activity); if(map != null){ return map.remove(requestCode); } return null; } private void addCallback(Activity activity,int requestCode,Callback callback){ HashMap<Integer,Callback> map = mCallbacks.get(activity); if(map == null){ map = new HashMap<>(); mCallbacks.put(activity,map); } map.put(requestCode,callback); } private Activity getActivity(){ return mActivity.get(); } public interface Callback{ void onActivityResult(int requestCode, int resultCode, Intent data); } }
邏輯很簡單，裡面持有一個mActivity，使用弱引用以防止記憶體洩漏，在構造器中為其賦值。
還有一個static的WeakHashMap<Activity,HashMap<Integer,Callback>> mCallbacks 用來存放所有的callback，先以activity分，在各個activity中又使用hashmap儲存requestCode和callback的對應關係。
在startForResult時，最終還是呼叫的activity的startActivityForResult，只不過在跳轉頁面之前，把callback存入了mCallbacks中。
而trigger方法則是根據activity和requestCode從mCallbacks中取出對應的callback，呼叫方法。
現在callback的存和取都搞定了，那麼問題來了，什麼時候觸發“取”的操作呢，即trigger方法怎麼觸發呢？
答案是在onActivityResult中呼叫，嫌麻煩可以在BaseActivity中呼叫。
使用示例：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
go.setOnClickListener {
val intent = Intent(this,SecondActivity::class.java)
onResultManager.startForResult(intent,REQUEST_CODE,{requestCode: Int, resultCode: Int, data: Intent? ->
if (resultCode == Activity.RESULT_OK){
val text = data?.getStringExtra("text")
Toast.makeText(this,"result -> "+text,Toast.LENGTH_SHORT).show()
}else{
Toast.makeText(this,"canceled",Toast.LENGTH_SHORT).show()
}
})
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
onResultManager.trigger(requestCode,resultCode,data)
}
可是這樣好蠢啊，你是不是覺得要是不用手動觸發，能自動觸發多好。
作者原文中還更新了一個 Hook的方式，避免手動去觸發，由於篇幅原因去掉了，感興趣原文檢視; Hook 的方案不建議使用，可以用於學習。
3
第二種方式（參考RxPermissions的做法）
前段時間又來了個小專案，領導扔給我了，然後在這個專案裡就把之前沒用過（沒錯，之前總用H5開發……）的rxjava、kotlin都加進來了。
有一天做動態許可權處理，驚奇地發現RxPermissions居然擺脫了Activity的onRequestPermissionsResult方法！！！
大家都知道，動態許可權大體就是先呼叫requestPermissions方法，然後授權的結果要到onRequestPermissionsResult中處理，簡直和startActivityForResult如出一轍。
那RxPermissions是怎麼做到的呢！！！
接著在前幾天不太忙的時候看了下RxPermissions的原始碼，發現它內部持有一個Fragment，這個fragment沒有檢視，只負責請求許可權和返回結果，相當於一個橋樑的作用，我們通過rxPermissions發起request的時候，其實並不是activity去request，而是通過這個fragment去請求，然後在fragment的onRequestPermissionsResult中把結果傳送出來，如此來避開activity的onRequestPermissionsResult方法。
當時，沒見過什麼大場面的我差點就給跪了。
RxPermissions的原始碼就不貼了，網上的講解應該也很多。
同樣，Fragment也有startActivityForResult方法啊，那我們也可以採取類似的方法，為所欲為。
這次取名叫AvoidOnResult，主要就是AvoidOnResult和AvoidOnResultFragment兩個類。先上程式碼：
AvoidOnResult
public class AvoidOnResult {
private static final String TAG = "AvoidOnResult";
private AvoidOnResultFragment mAvoidOnResultFragment;
public AvoidOnResult(Activity activity) {
mAvoidOnResultFragment = getAvoidOnResultFragment(activity);
}
public AvoidOnResult(Fragment fragment){
this(fragment.getActivity());
}
private AvoidOnResultFragment getAvoidOnResultFragment(Activity activity) {
AvoidOnResultFragment avoidOnResultFragment = findAvoidOnResultFragment(activity);
if (avoidOnResultFragment == null) {
avoidOnResultFragment = new AvoidOnResultFragment();
FragmentManager fragmentManager = activity.getFragmentManager();
fragmentManager
.beginTransaction()
.add(avoidOnResultFragment, TAG)
.commitAllowingStateLoss();
fragmentManager.executePendingTransactions();
}
return avoidOnResultFragment;
}
private AvoidOnResultFragment findAvoidOnResultFragment(Activity activity) {
return (AvoidOnResultFragment) activity.getFragmentManager().findFragmentByTag(TAG);
}
public Observable<ActivityResultInfo> startForResult(Intent intent, int requestCode) {
return mAvoidOnResultFragment.startForResult(intent, requestCode);
}
public Observable<ActivityResultInfo> startForResult(Class<?> clazz, int requestCode) {
Intent intent = new Intent(mAvoidOnResultFragment.getActivity(), clazz);
return startForResult(intent, requestCode);
}
public void startForResult(Intent intent, int requestCode, Callback callback) {
mAvoidOnResultFragment.startForResult(intent, requestCode, callback);
}
public void startForResult(Class<?> clazz, int requestCode, Callback callback) {
Intent intent = new Intent(mAvoidOnResultFragment.getActivity(), clazz);
startForResult(intent, requestCode, callback);
}
public interface Callback {
void onActivityResult(int requestCode, int resultCode, Intent data);
}
}
AvoidOnResultFragment
public class AvoidOnResultFragment extends Fragment {
private Map<Integer, PublishSubject<ActivityResultInfo>> mSubjects = new HashMap<>();
private Map<Integer, AvoidOnResult.Callback> mCallbacks = new HashMap<>();
public AvoidOnResultFragment() {
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
public Observable<ActivityResultInfo> startForResult(final Intent intent, final int requestCode) {
PublishSubject<ActivityResultInfo> subject = PublishSubject.create();
mSubjects.put(requestCode, subject);
return subject.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
startActivityForResult(intent, requestCode);
}
});
}
public void startForResult(Intent intent, int requestCode, AvoidOnResult.Callback callback) {
mCallbacks.put(requestCode, callback);
startActivityForResult(intent, requestCode);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
//rxjava方式的處理
PublishSubject<ActivityResultInfo> subject = mSubjects.remove(requestCode);
if (subject != null) {
subject.onNext(new ActivityResultInfo(requestCode, resultCode, data));
subject.onComplete();
}
//callback方式的處理
AvoidOnResult.Callback callback = mCallbacks.remove(requestCode);
if (callback != null) {
callback.onActivityResult(requestCode, resultCode, data);
}
}
}
先看AvoidOnResult，和RxPermissions一樣，也持有一個無檢視的fragment，在構造器中先去獲取這個AvoidOnResultFragment，getAvoidOnResultFragment、findAvoidOnResultFragment這兩個方法是從RxPermissions扒來的，大體就是先通過TAG獲取fragment，如果是null就新建一個並add進去。
這個類內部也定義了一個Callback介面，不必多說。
繼續，這個類有多個startForResult方法，主要看public void startForResult(Intent intent, int requestCode, Callback callback)，它本身不幹實事，只是呼叫fragment的同名方法，所有的邏輯都是fragment中處理，待會兒我們來看這個“同名方法”。
再看這個fragment，它持有一個mCallbacks，存著requestCode和callback的對應關係。然後找到上邊說的同名方法startForResult，只有兩行程式碼，
1、把callback存起來；
2、呼叫fragment的startActivityForResult。
繼續看fragment的onActivityResult方法，主要看註釋有“callback方式的處理”的程式碼，就是從mCallbacks中拿到requestCode對應的callback，呼叫callback的onActivityResult方法。總體的就是這樣了，是不是很簡單。
拓展
可以看到除了返回值為void的startForResult方法外，還有幾個返回值為Observable的，原理一樣，只不過fragment中不再是存callback，而是存subject，然後通過doOnSubscribe使它在subscribe的時候跳轉頁面，最後把得到的Observable返回。
對應的，在onActivityResult中拿到對應的subject，通過onNext把資料發出去。
使用示例：
CallBack 的方式：
callback.setOnClickListener {
AvoidOnResult(this).startForResult(FetchDataActivity::class.java, REQUEST_CODE_CALLBACK, object : AvoidOnResult.Callback {
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) =
if (resultCode == Activity.RESULT_OK) {
val text = data?.getStringExtra("text")
Toast.makeText([email protected], "callback -> " + text, Toast.LENGTH_SHORT).show()
} else {
Toast.makeText([email protected], "callback canceled", Toast.LENGTH_SHORT).show()
}
})
}
RxJava 的方式：
rxjava.setOnClickListener {
AvoidOnResult(this)
.startForResult(FetchDataActivity::class.java, REQUEST_CODE_RXJAVA)
//下面可自由變換
.filter { it.resultCode == Activity.RESULT_OK }
.flatMap {
val text = it.data.getStringExtra("text")
Observable.fromIterable(text.asIterable())
}
.subscribe({
Log.d("-------> ", it.toString())
}, {
Toast.makeText(this, "error", Toast.LENGTH_SHORT).show()
}, {
Toast.makeText(this, "complete", Toast.LENGTH_SHORT).show()
})
}
https://github.com/AnotherJack/AvoidOnResult
所有的工具類都是用java寫的，避免使用kotlin編寫，出現java無法呼叫kotlin的情況。測試程式碼用的kotlin，不過沒用太多kotlin的特性，所以即便沒接觸過kotlin的應該也很好看懂吧！