更新,强迫症福音,onActivityResult方法hook到了
这里感谢一下@world_hello的提醒,十分感谢。
之前看到ActivityThread的mH的时候总想着弄个代理继承它,然后重写handleMessage方法,来获取结果信息,可是却苦于继承不了,其实我一直忽视了Handler内部的一个Callback接口,其实完全不用代理。下面详细讲解一下。
先说一下Handler,我们一般使用的时候大多是继承自Handler,然后重写handleMessage方法,在里面处理接收消息。其实Handler还有个构造函数可以接收一个Handler.Callback(不要和我们自己定义的callback搞混了啊),在Handler.Callback的handleMessage方法中处理消息。
看一下Handler源码:
/**
- Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
可以看到,如果mCallback不为null,就会执行mCallback的handleMessage方法。如果这个handleMessage方法的返回值为true,就会直接return,如果为false,就会继续执行Handler本身的handleMessage方法。
下面打开Activity源码,startActivityForResult方法中有这么一段
if (ar != null) {
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
ar是ActivityResult,如果不为null,就调用mMainThread的sendActivityResult方法,这个mMainThread就是ActivityThread类型的,所以继续打开ActivityThread源码,找到这个方法,顺着这个方法一直找一直找,这里中间的方法我就不贴了,最后会找到一个叫sendMessage的方法,这个方法最后一行是
mH.sendMessage(msg);
这个mH是一个Handler的子类,所以很明显,activityresult在这个环节是通过handler传递的。
在H的handleMessage方法中有这样一个case分支
case SEND_RESULT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “activityDeliverResult”);
handleSendResult((ResultData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
不用再多说了吧,就是这里了。它调用了handleSendResult((ResultData)msg.obj),所以这个ResultData应该就是存放了我们需要的东西。只要能拦截到它,拿出我们需要的数据,那就算是hook到了onActivityResult了,那么怎么拿到呢?现在就要提到我们刚才提的Handler.Callback了,我们创建一个callback,并记得让handleMessage的方法返回false,以免影响mH本身的handleMessage方法的执行,然后通过反射把这个callback给mH set进去。下面需要您对反射有一点点了解。
public class HookUtil {
public static void hookActivityThreadHandler() throws Exception {
// 先获取到当前的ActivityThread对象
final Class<?> activityThreadClass = Class.forName(“android.app.ActivityThread”);
Field currentActivityThreadField = activityThreadClass.getDeclaredField(“sCurrentActivityThread”);
currentActivityThreadField.setAccessible(true);
final Object currentActivityThread = currentActivityThreadField.get(null);
// 由于ActivityThread一个进程只有一个,我们获取这个对象的mH
Field mHField = activityThreadClass.getDeclaredField(“mH”);
mHField.setAccessible(true);
Handler mH = (Handler) mHField.get(currentActivityThread);
Handler.Callback mHCallback = new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
if(msg.what == 108){
Log.d(“hook-------”,“onActivityResult”);
try{
Object resultData = msg.obj;
Field mActivitiesField = activityThreadClass.getDeclaredField(“mActivities”);
mActivitiesField.setAccessible(true);
ArrayMap mActivities = (ArrayMap) mActivitiesField.get(currentActivityThread);
Class<?> resultDataClass = Class.forName(“android.app.ActivityThread$ResultData”);
Field tokenField = resultDataClass.getDeclaredField(“token”);
tokenField.setAccessible(true);
IBinder token = (IBinder) tokenField.get(resultData);
//r是ActivityClientRecord类型的
Object r = mActivities.get(token);
Class<?> ActivityClientRecordClass = Class.forName(“android.app.ActivityThread$ActivityClientRecord”);
Field activityField = ActivityClientRecordClass.getDeclaredField(“activity”);
activityField.setAccessible(true);
Activity activity = (Activity) activityField.get®; //至此,终于拿到activity了
Field resultsField = resultDataClass.getDeclaredField(“results”);
resultsField.setAccessible(true);
List results = (List) resultsField.get(resultData);
//ResultInfo类型
Object resultInfo = results.get(0);
Class<?> resultInfoClass = Class.forName(“android.app.ResultInfo”);
Field mRequestCodeField = resultInfoClass.getDeclaredField(“mRequestCode”);
mRequestCodeField.setAccessible(true);
int mRequestCode = (int) mRequestCodeField.get(resultInfo); //拿到requestCode
Field mResultCodeField = resultInfoClass.getDeclaredField(“mResultCode”);
mResultCodeField.setAccessible(true);
int mResultCode = (int) mResultCodeField.get(resultInfo); //拿到resultCode
Field mDataField = resultInfoClass.getDeclaredField(“mData”);
mDataField.setAccessible(true);
Intent mData = (Intent) mDataField.get(resultInfo); //拿到intent
new OnResultManager(activity).trigger(mRequestCode,mResultCode,mData);
}catch (Exception e){
e.printStackTrace();
}
}
return false;
}
};
Field mCallBackField = Handler.class.getDeclaredField(“mCallback”);
mCallBackField.setAccessible(true);
mCallBackField.set(mH, mHCallback);
}
}
hookActivityThreadHandler方法中就是先获取到ActivityThread对象,再通过activityThread获取到mH,然后创建了一个Handler.Callback,最后用反射把这个callback set给mH。
相比之下,Handler.Callback中的handleMessage方法看起来更长一些,但其实并不复杂,只是反射使它变得面目全非了,它主要就是为了获取我们OnResultManager的trigger方法需要的数据,一个activity,以及requestCode、resultCode、data。
msg.what==108的判断,这里108就是SEND_RESULT,我图方便直接写死了,源码里看着为108,当然通过反射动态获取SEND_RESULT更规范一点,大家别在意这些细节。
先看activity怎么获取,主要看ActivityThread的handleSendResult方法,它的第一行
private void handleSendResult(ResultData res) {
ActivityClientRecord r = mActivities.get(res.token);
这个res就是msg.obj,而获取到ActivityClientRecord之后,它有一个名为activity的field,获取的就是我们需要的activity对象了。本身很简单,只不过这短短的一行代码要用反射一点一点获取,就繁琐一些了。
另外三个数据都在一起,在ResultData里有个名为results的Field,它是一个List,里面就一个元素(可能有误,但我打断点看它一直都是一个),是ResultInfo类型,我们需要的requestCode、resultCode、data就都在这个resultInfo里面了,所以,继续反射。
都获取完了,调用
new OnResultManager(activity).trigger(mRequestCode,mResultCode,mData);
就是把我们之前手动写在onActivityResult中的那句放到这里自动触发。
现在方法写完了,还要写个自定义Application,在onCreate中调用
HookUtil.hookActivityThreadHandler()
大功告成啦!,赶紧测试一下吧,现在终于不用再在onActivityResult中手动触发啦!github上代码已经更新。
按理说我们该在OnResultManager中定义个init方法,然后在init方法中去调hookActivityThreadHandler貌似更规范一些,不过这只算个demo,就不考虑这么多了。
还有,这种通过反射hook的方法在稳定性和兼容性上都无法保证,所以这算是一种仅供娱乐的方式吧!领略一下hook的魅力。
下面是world_hello实现的hook,虽然思路是一样的,但是编写的要比我的容易看懂得多,自愧不如,在此强烈推荐大家看一下。
第二种方式(参考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两个类。先上代码:
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 startForResult(Intent intent, int requestCode) {
return mAvoidOnResultFragment.startForResult(intent, requestCode);
}
public Observable 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);
}
}
public class AvoidOnResultFragment extends Fragment {
private Map<Integer, PublishSubject> 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 startForResult(final Intent intent, final int requestCode) {
PublishSubject subject = PublishSubject.create();
mSubjects.put(requestCode, subject);
return subject.doOnSubscribe(new Consumer() {
@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 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
先看AvoidOnResult,和RxPermissions一样,也持有一个无视图的fragment,在构造器中先去获取这个AvoidOnResultFragment,getAvoidOnResultFragment、findAvoidOnResultFragment这两个方法是从RxPermissions扒来的,大体就是先通过TAG获取fragment,如果是null就新建一个并add进去。
这个类内部也定义了一个Callback接口,不必多说。
继续,这个类有多个startForResult方法,主要看public void startForResult(Intent intent, int requestCode, Callback callback),它本身不干实事,只是调用fragment的同名方法,所有的逻辑都是fragment中处理,待会儿我们来看这个“同名方法”。
AvoidOnResultFragment
再看这个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(this@MainActivity, "callback -> " + text, Toast.LENGTH_SHORT).show()
} else {
Toast.makeText(this@MainActivity, “callback canceled”, Toast.LENGTH_SHORT).show()
}
})
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
![](https://i-blog.csdnimg.cn/blog_migrate/d5d1d88a10aa650331033c9332bf68ef.jpeg)
学习宝典
对我们开发者来说,一定要打好基础,随时准备战斗。不论寒冬是否到来,都要把自己的技术做精做深。虽然目前移动端的招聘量确实变少了,但中高端的职位还是很多的,这说明行业只是变得成熟规范起来了。竞争越激烈,产品质量与留存就变得更加重要,我们进入了技术赋能业务的时代。
不论遇到什么困难,都不应该成为我们放弃的理由!
很多人在刚接触这个行业的时候或者是在遇到瓶颈期的时候,总会遇到一些问题,比如学了一段时间感觉没有方向感,不知道该从那里入手去学习,对此我针对Android程序员,我这边给大家整理了一套学习宝典!包括不限于高级UI、性能优化、移动架构师、NDK、混合式开发(ReactNative+Weex)微信小程序、Flutter等全方面的Android进阶实践技术;希望能帮助到大家,也节省大家在网上搜索资料的时间来学习,也可以分享动态给身边好友一起学习!
【Android核心高级技术PDF文档,BAT大厂面试真题解析】
【算法合集】
【延伸Android必备知识点】
【Android部分高级架构视频学习资源】
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
上搜索资料的时间来学习,也可以分享动态给身边好友一起学习!
【Android核心高级技术PDF文档,BAT大厂面试真题解析】
[外链图片转存中…(img-7oubSZFi-1713030913374)]
【算法合集】
[外链图片转存中…(img-OHEL0Z6A-1713030913374)]
【延伸Android必备知识点】
[外链图片转存中…(img-CxUrQMpn-1713030913374)]
【Android部分高级架构视频学习资源】
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!