导言

忙忙碌碌又一天，最近学习了一个新项目，每天都是吭哧吭哧的去看项目中的各种源码，都来自于各路大神的奉献。每看到一块地方的时分都感觉触到了自己的知识鸿沟，然后又得吭哧吭哧的去查找。不知道大家的查找途径是什么，我的查找途径从以前的 Google -> -> 简书 -> Other（Baidu） 变成了 ChatGPT -> Google -> 其他。

最近在排查主线程耗时的一个任务，既然在主线程了，那还不好办，直接上 Trace 分析主线程中的耗时任务都有哪些不就完了。完了分析完一波后又无从下手啦。接下来考虑从 MainLooper 下手吧，看看哪些是长音讯，履行任务又比较耗时。

Handler

Looper

那么怎么做长音讯的耗时监控呐？这又遇到了一个问题，在以往许多都是经过 Looper 的 Printer 进行控制长音讯的检查，但是 Printer 也是有缺点的，便是无法知道它的 callback 来自于哪里，及时统计出来了时刻，也不满足需求。

一切的源头都应该从源码进行着手，经过阅览源码发现，在 Looper 中发现了 Observer，它是什么鬼？

public final class Looper {
    private static Observer sObserver;
    /**  
    * Set the transaction observer for all Loopers in this process.  
    *  
    * @hide  
    */  
    public static void setObserver(@Nullable Observer observer) {  
        sObserver = observer;  
    }
    public static void loop() {
        // ...此处省掉无关紧要的 code
        for (;;) {
            // ...此处省掉无关紧要的 code
            // This must be in a local variable, in case a UI event sets the logger  
            final Printer logging = me.mLogging;  
            if (logging != null) {  
            logging.println(">>>>> Dispatching to " + msg.target + " " +  
            msg.callback + ": " + msg.what);  
            }  
            // Make sure the observer won't change while processing a transaction.  
            final Observer observer = sObserver;
            // ...此处省掉无关紧要的 code
            Object token = null;
            // 在履行音讯履行音讯告诉
            if (observer != null) {  
                token = observer.messageDispatchStarting();  
            }  
            long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);  
            try {  
                msg.target.dispatchMessage(msg);  
                // 在音讯履行结束后又履行了音讯告诉
                if (observer != null) {  
                    observer.messageDispatched(token, msg);  
                }  
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;  
            } catch (Exception exception) {  
                // 音讯履行的进程中产生了异常的回调
                if (observer != null) {  
                    observer.dispatchingThrewException(token, msg, exception);  
                }  
                throw exception;  
            } finally {  
                ThreadLocalWorkSource.restore(origWorkSource);  
                if (traceTag != 0) {  
                    Trace.traceEnd(traceTag);  
                }  
            }
        }
    }
}

依据阅览源码来看，我觉得能够从这个地方下手搞工作。

/** {@hide} */
public interface Observer {  
    /**  
    * Called right before a message is dispatched.  
    *  
    * <p> The token type is not specified to allow the implementation to specify its own type.  
    *  
    * @return a token used for collecting telemetry when dispatching a single message.  
    * The token token must be passed back exactly once to either  
    * {@link Observer#messageDispatched} or {@link Observer#dispatchingThrewException}  
    * and must not be reused again.  
    *  
    */  
    Object messageDispatchStarting();  
    /**  
    * Called when a message was processed by a Handler.  
    *  
    * @param token Token obtained by previously calling  
    * {@link Observer#messageDispatchStarting} on the same Observer instance.  
    * @param msg The message that was dispatched.  
    */  
    void messageDispatched(Object token, Message msg);  
    /**  
    * Called when an exception was thrown while processing a message.  
    *  
    * @param token Token obtained by previously calling  
    * {@link Observer#messageDispatchStarting} on the same Observer instance.  
    * @param msg The message that was dispatched and caused an exception.  
    * @param exception The exception that was thrown.  
    */  
    void dispatchingThrewException(Object token, Message msg, Exception exception);  
}

Observer 是 Looper 的一个内部接口类，用来做事件的回调处理的。首要包含了三个函数 messageDispatchStarting、messageDispatched、dispatchingThrewException，别离会在某条音讯调度前、调度处理后、调度处理进程中产生异常时回调。需求注意的是 messageDispatchStarting 要求回来一个 Object 对象，对类型不做任何约束，每个音讯类型都对应一个 token，并且理应为独立且仅有。

于是乎，我兴高采烈的开端码起来了。

开搞开搞

先来介绍一会儿思路，咱们是不是能够直接经过反射调用 setObserver 的方法，是不是直接就能够设置Observer，既然都到了反射，为啥不直接操作 sObserver，提到这就开干。这儿运用的动态署理进行 hook Observer。

public class HandlerLoopHookHelper {
    /**  
    * Hook Looper 的 sObserver 调查音讯耗时  
    *  
    * @param context 上下文  
    */  
    public static void hookLooperObserver(@Nullable Context context) {  
        Log.d(TAG, "hookLoopObserver: " + Build.VERSION.SDK_INT);  
            try {  
                @SuppressLint("PrivateApi") final Class<?> sObserverClass = Class.forName("android.os.Looper$Observer");  
                final ObserverInvocation invocation = new ObserverInvocation();  
                final Object o = sObserverClass.cast(Proxy.newProxyInstance(sObserverClass.getClassLoader(), new Class[]{sObserverClass}, invocation));  
                final Class<?> looperClass = Class.forName("android.os.Looper");  
                @SuppressLint("BlockedPrivateApi") final Field sObserver = looperClass.getDeclaredField("sObserver");  
                sObserver.setAccessible(true);  
                sObserver.set(getMainLooper(), o);  
                getMainLooper().setMessageLogging(invocation.printer);  
            } catch (Throwable e) {  
                e.printStackTrace();  
            }  
        }
}
public class ObserverInvocation implements InvocationHandler {
    private long dispatchStart = 0;  
    private long dispatchEnd = 0;
    private static final long MESSAGE_WORK_TIME_300 = 300;  
    private static final long MESSAGE_WORK_TIME_100 = 100;  
    private static final long MESSAGE_WORK_TIME_50 = 50;  
    private static final long MESSAGE_WORK_TIME_10 = 10;
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        if (Looper.getMainLooper().isCurrentThread()) {  
            if ("messageDispatchStarting".equals(method.getName())) {  
                return messageDispatchStarting();  
            } else if ("messageDispatched".equals(method.getName())) {  
                messageDispatched((long) args[0], (Message) args[1]);  
            } else if ("dispatchingThrewException".equals(method.getName())) {  
                dispatchingThrewException((long) args[0], (Message) args[1], (Exception) args[2]);  
            }  
        }  
        return null;  
    }
    public Object messageDispatchStarting() {  
        dispatchStart = SystemClock.uptimeMillis();  
        final long token = atomicLong.getAndIncrement();  
        return token;  
    }  
    public void messageDispatched(Object token, Message msg) {  
        dispatchEnd = SystemClock.uptimeMillis();  
        getTime(msg, (long) token);  
    }  
    public void dispatchingThrewException(Object token, Message msg, Exception exception) {  
    }
    /**
     * 计时，可依据自己的需求进行具体的计
     */
    private void getTime(Message message, long token) {  
        // message 指定开端时刻，基于开机时刻  
        final long when = message.getWhen();  
        // 等候的时长：开端履行 - 指定开端时刻  
        final long wait = dispatchStart - when;  
        // 履行的时长：履行结束时刻 - 履行开端时刻  
        final long work = dispatchEnd - dispatchStart;  
        printRecord(message, token, wait, work);  
    }  
    private void printRecord(Message message, long token, long wait, long work) {  
        final StringBuilder stringBuilder = new StringBuilder();  
        if (work <= MESSAGE_WORK_TIME_10) {  
            stringBuilder.append("(可忽略)").append(dispatchStart).append("-").append(dispatchEnd)  
            .append(">>> token: ").append(token).append(message.toString())  
            .append(" wait: ").append(wait).append("ms")  
            .append(" work: ").append(work).append("ms");  
            Log.v(TAG, stringBuilder.toString());  
        } else if (work <= MESSAGE_WORK_TIME_50) {  
            stringBuilder.append("(看看就好)").append(dispatchStart).append("-").append(dispatchEnd)  
            .append(">>> token: ").append(token).append(message.toString())  
            .append(" wait: ").append(wait).append("ms")  
            .append(" work: ").append(work).append("ms");  
            Log.i(TAG, stringBuilder.toString());  
        } else if (work <= MESSAGE_WORK_TIME_100) {  
            stringBuilder.append("(需求重视一下)").append(dispatchStart).append("-").append(dispatchEnd)  
            .append(">>> token: ").append(token).append(message.toString())  
            .append(" wait: ").append(wait).append("ms")  
            .append(" work: ").append(work).append("ms");  
            Log.w(TAG, stringBuilder.toString());  
        } else if (work <= MESSAGE_WORK_TIME_300) {  
            stringBuilder.append("(需求处理啦~)").append(dispatchStart).append("-").append(dispatchEnd)  
            .append(">>> token: ").append(token).append(message.toString())  
            .append(" wait: ").append(wait).append("ms")  
            .append(" work: ").append(work).append("ms");  
            Log.d(TAG, stringBuilder.toString());  
        } else {  
            stringBuilder.append("(这个就超级严重啦~)").append(dispatchStart).append("-").append(dispatchEnd)  
            .append(">>> token: ").append(token).append(message.toString())  
            .append(" wait: ").append(wait).append("ms")  
            .append(" work: ").append(work).append("ms");  
            Log.e(TAG, stringBuilder.toString());  
        }  
    }
}

Coding 结束啦，这儿面的输出监控建议不要搞到线上，或许会比较的耗时，依据实际情况来确认怎么运用，定制监控的策略，能够考虑超越多长时刻来进行报警，或许上报等操作。废话不多说，run 一会儿吧，结果gg。

日志的大致意思是，这个类是被 @hide 的，对开发者是屏蔽调用及运用的。查阅相关代码得知，基于 Android 10 版别增加的 Observer，在规划之初就只是为了调查并统计体系服务的Looper音讯调度功用（能够查阅LooperStats与LooperStatsService），所以这个API只给自己内部运用。

只要是代码总会有处理的方案，能不能绕过去躲藏 API 呐？能，下来就看看看一下怎么如绕开躲藏API 。

绕开 Observer 躲藏 API

处理 Hidden API 的方法有许多种，或许某些在 Android 高版别体系重被官方封堵。不过因为 Android 体系是开源的，所以无论怎么封堵，仍是能够经过其他的方法绕过，毕竟体系是不会约束用户修正自身进程的内存。

在这儿我运用的方案是 FreeReflection，大致的思路是将自己伪装成体系类，然后就能够调用这些私有 API 了。具体的内容能够参阅作者博客里面的介绍。

另一种绕过 Android P以上非揭露API约束的方法

Android 14 无法加载`.dex`文件

在这儿提个醒，在Android 14及以上版别，关于动态代码的加载产生了一些更改，否则会产生如下内容过错。

经过阅览 DexClassLoader 与更安全的动态代码加载发现 Android 14 关于动态加载 .dex 文件做了安全策略的约束，Android 14 关于动态加载（DCL）功用，必须将所有动态加载的文件标记为只读。否则，体系将会抛出异常。

正确操作姿态，便是将 FreeReflection 三方库 Copy 下来，然后修正源码，完美处理在 Android 14 上面不能动态加载 .dex 问题。

然后再跑一会儿。完美处理。

正确的打开姿态

public class HandlerLoopHookHelper {
    private static volatile boolean isHooked = false;  
    private static final String TAG = "HandlerLoopHookHelper";  
    private static void checkHooked(Context context) {  
        if (!isHooked) {  
            Reflection.unseal(context);  
            isHooked = true;  
        }  
    }  
    /**  
    * Hook Looper 的 sObserver 调查音讯耗时  
    *  
    * @param context 上下文  
    */  
    public static void hookLooperObserver(@Nullable Context context) {  
        Log.d(TAG, "hookLoopObserver: " + Build.VERSION.SDK_INT);  
        try {  
            checkHooked(context);  
            @SuppressLint("PrivateApi") final Class<?> sObserverClass = Class.forName("android.os.Looper$Observer");  
            final ObserverInvocation invocation = new ObserverInvocation();  
            final Object o = sObserverClass.cast(Proxy.newProxyInstance(sObserverClass.getClassLoader(), new Class[]{sObserverClass}, invocation));  
            final Class<?> looperClass = Class.forName("android.os.Looper");  
            @SuppressLint("BlockedPrivateApi") final Field sObserver = looperClass.getDeclaredField("sObserver");  
            sObserver.setAccessible(true);  
            sObserver.set(getMainLooper(), o);  
            getMainLooper().setMessageLogging(invocation.printer);  
        } catch (Throwable e) {  
            e.printStackTrace();  
        }  
    }  
    /**  
    * 钩针活套调查者  
    *  
    * @param context 上下文  
    */  
    public static void unHookLooperObserver(@Nullable Context context) {  
        Log.d(TAG, "unHookLooperObserver: " + Build.VERSION.SDK_INT);  
        try {  
            checkHooked(context);  
            @SuppressLint("PrivateApi") final Class<?> sObserverClass = Class.forName("android.os.Looper$Observer");  
            final ObserverInvocation invocation = new ObserverInvocation();  
            final Object o = sObserverClass.cast(Proxy.newProxyInstance(sObserverClass.getClassLoader(), new Class[]{sObserverClass}, invocation));  
            final Class<?> looperClass = Class.forName("android.os.Looper");  
            @SuppressLint("BlockedPrivateApi") final Field sObserver = looperClass.getDeclaredField("sObserver");  
            sObserver.setAccessible(true);  
            sObserver.set(getMainLooper(), null);  
            getMainLooper().setMessageLogging(null);  
        } catch (Throwable e) {  
            e.printStackTrace();  
        }  
    }  
    /**  
    * 挂钩主活套音讯空闲处理程序  
    *  
    * @param context 上下文  
    */  
    public static void hookMainLooperMessageIdleHandlers(@Nullable Context context) {  
        Log.d(TAG, "hookMainLooperMessageIdleHandlers: " + Build.VERSION.SDK_INT);  
        try {  
            checkHooked(context);  
            final Class<?> looperClass = Class.forName("android.os.Looper");  
            final Field mQueueF = looperClass.getDeclaredField("mQueue");  
            mQueueF.setAccessible(true);  
            final Object mainMessageQueue = mQueueF.get(getMainLooper());  
            final Class<?> mQueueClass = Class.forName("android.os.MessageQueue");  
            final Field mainIdleHandlerF = mQueueClass.getDeclaredField("mIdleHandlers");  
            mainIdleHandlerF.setAccessible(true);  
            final Object o = mainIdleHandlerF.get(mainMessageQueue);  
            final ArrayList<MessageQueue.IdleHandler> mIdleHandlers = (ArrayList<MessageQueue.IdleHandler>) o;  
            Log.d(TAG, "hookMainLooperMessageIdleHandlers size: " + mIdleHandlers.size());  
            for (MessageQueue.IdleHandler mIdleHandler : mIdleHandlers) {  
                Log.d(TAG, "hookMainLooperMessageIdleHandlers content is: " + mIdleHandler.toString());  
            }  
        } catch (Throwable e) {  
            e.printStackTrace();  
        }  
    }  
}

小结

Observer 相比于 Printer 能够直接拿到 Message 对象，并且不需求设置 Printer 能够防止每个音讯调度时额定拼接字符串的成本。
处理开发阶段 Hidden API 访问约束，能够经过许多种方法绕过，也能够考虑经过 CompileOnly 一个 假工程 来完成，假工程 里面模仿相应的体系源码，从而完成 Observer 类的访问。不过我试过这种方法，同样也需求搞定体系的 hidden api 形似也是绕不过去的，如果运用这个库 FreeReflection 的话，那么 假工程 的方法也是能够完成，在这儿不做赘述，感兴趣的同学能够自己尝试。
Observer 机制是在 Anroid 10 开端增加的，因此低版别仍是需求用 Printer 的方法进行监听
Android 14 版别动态加载 .dex 文件需求设置 file 为只读模式，否则将会抛出安全异常。

Android 如何监控 Loop Message 长消息

导言

Handler

Looper

开搞开搞

绕开 Observer 躲藏 API

Android 14 无法加载`.dex`文件

正确的打开姿态

小结

作者信息

Android 如何监控 Loop Message 长消息

导言

Handler

Looper

开搞开搞

绕开 Observer 躲藏 API

Android 14 无法加载.dex文件

正确的打开姿态

小结

相关文章

【Android FrameWork】第一个启动的程序–init

Prompt工程师指南[应用篇]：Prompt应用、ChatGPT|Midjouney Prompt Engineering

sqlite wal 分析

百度iOS端长连接组件建设及应用实践

作者信息

Android 14 无法加载`.dex`文件