Android Handler实现原理

Handler 部分的讲解计划分两篇博客讲完实现原理，一篇主要介绍 Java 层的实现，另一篇介绍 Native 相关的实现，本篇介绍前者。

讲解完实现原理之后，会再新开几篇博客讲解其在系统源码中的主要使用场景等相关内容。

本篇主要内容有：

1. MessageQueue 的基本运作流程，包括入队、出队、消息处理等实现原理
2. 同步屏障和异步消息
3. IdleHandler
4. Message池管理

如果这篇文章对你有帮助，请关注点赞加收藏。

还可以关注我的微信公众号“ZZH的Android”，还有更多 Android 系统源码解析的干货文章等着你。

1、Handler 作用

(1) 在线程之间互发消息，实现线程间通信

(2) 发送延时消息，延时执行任务

2、类图

3、Handler-Looper-MessageQueue 模型

整个模型的运行步骤如下：

1. 创建 MessageQueue 队列
2. 将 Message 对象入队
3. 将 Message 对象出队
4. 处理出队的 Message 后面跟代码流程时，可以跟着这个图来看，方便理解。

以上运行步骤依赖于 Handler、Looper 和 MessageQueue 三个核心类实现。

4、实现原理

在 Looper.java 文件的开头，给了一段 Looper 使用的示例代码，如下

class LooperThread extends Thread {
    public Handler mHandler;
 
    public void run() {
       // 创建MessageQueue对象
       Looper.prepare();
 
       mHandler = new Handler(Looper.myLooper()) {
           public void handleMessage(Message msg) {
               // process incoming messages here
           }
       };
       // 启动MessageQueue的循环运转
       Looper.loop();
    }
}

其中，Looper.prepare()创建 MessageQueue 对象；

Looper.loop()启动 MessageQueue 队列的循环运转；

Handler 负责发送消息和处理消息。

此处需要注意的是，子线程中并不是必须要创建消息处理机制的这几个对象的，只有当有业务需要才创建即可。

主线程必须创建，而且是由系统在进程启动时创建的，不需要 App 开发者再手动创建。

Looper 给主线程单独定义了专门的方法 prepareMainLooper，代码位置如下：

// frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {
    ......
    // 创建主线程的MessageQueue
    Looper.prepareMainLooper();
 
    ......
 
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
 
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
 
    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }
 
    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    // 启动MessageQueue循环运转
    Looper.loop();
 
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

4.1 Looper.prepare()→MessageQueue 的创建

当 Looper 执行其 prepare()函数时会创建 MessageQueue 对象。MessageQueue 是一个包含 Message 元素的队列， 从其名字翻译为队列，实际上是一个单向链表，因为每个 Message 对象中的 next 成员会指向下一个 Message 对象。

创建 MessageQueue 代码的如下：

// frameworks/base/core/java/android/os/Looper.java
public static void prepare() {
    // 这里的true表示MessageQueue队列可以手动停止运转。
    // 调用Looper的quit方法可以停止运转。
    prepare(true);
}
 
// 注意这个函数是private方法，App无法使用。说明子线程的
// quitAllowed一定为true。
// 这里使用了ThreadLocal，表明每个线程都有专属的一个唯一的Looper对象
private static void prepare(boolean quitAllowed) {
    // 如果重复执行prepare方法，就会提示错误。
    // 说明每个线程只能创建一个Looper对象
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
 
    // 创建Looper对象，并保存到sThreadLocal里,
    // 这里quitAllowed=true。
    sThreadLocal.set(new Looper(quitAllowed));
}

可以通过 Looper 的 myLooper()函数获取当前线程的 Looper 对象：

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

再看下给主线程使用的 prepareMainLooper 函数：

// 这个方法不允许应用再调用
public static void prepareMainLooper() {
    // 这里传入了false，说明主线程的消息循环不允许被停止。
    // 原因是主线程中有很多核心的功能是由Handler实现的，
    // 比如Activity生命周期的回调。
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        // 主线程的Looper对象也会保存在sMainLooper中，
        // 这样的获取，获取主线程的Looper对象就不用再从
        // sThreadLocal 中拿了，可以节省时间，提高性能。
 
        // 当需要创建基于主线程的Handler对象时，可以直接
        // 使用Looper的getMainLooper方法获取主线程Looper对象。
        sMainLooper = myLooper();
    }
}

Looper 的构造函数

// 创建MessageQueue对象，保存在mQueue变量中；
// 并且将当前线程保存在mThread变量中。
// 这里可以看到quitAllowed最终传递给了MessageQueue
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

下面看下 MessageQueue 的构造函数

// frameworks/base/core/java/android/os/MessageQueue.java
MessageQueue(boolean quitAllowed) {
    // 是否可以被手动停止
    // 主线程必须为false
    // 子线程默认为true，也只能为true
    mQuitAllowed = quitAllowed;
    // 创建NativeMessageQueue对象，并保存其引用。
    mPtr = nativeInit();
}

下面看下 nativeInit()的实现。

// frameworks/base/core/jni/android_os_MessageQueue.cpp
// 可以看到nativeInit()对应实现为android_os_MessageQueue_nativeInit
static const JNINativeMethod gMessageQueueMethods[] = {
    /* name, signature, funcPtr */
    { "nativeInit", "()J", (void*)android_os_MessageQueue_nativeInit },
    ......
};
 
// 看下android_os_MessageQueue_nativeInit实现
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    // 创建NativeMessageQueue对象
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return 0;
    }
 
    // 增加强引用计数，确保该对象不会被释放
    nativeMessageQueue->incStrong(env);
    // 将nativeMessageQueue的指针返回到java层。
    return reinterpret_cast<jlong>(nativeMessageQueue);
}
 
// 下面再看下NativeMessageQueue的构造函数，
// 创建了Native的Looper对象。
// Native Handler相关的另起一篇文章单独介绍
NativeMessageQueue::NativeMessageQueue() :
        mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}

再看下 Looper.quit 方法，这个方法是用来结束消息队列处理流程的。

可以看到有两个方法，最终都调用了 mQueue.quit，传递的参数不同而已。

public void quit() {
    mQueue.quit(false);
}
 
public void quitSafely() {
    mQueue.quit(true);
}

MessageQueue 的 quit

void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }
 
    synchronized (this) {
        if (mQuitting) {
            return;
        }
        // 将mQuitting为true，这个变量在MessageQueue循环处理消息时
        // 会做判断，如果是true，则停止 循环处理。
        mQuitting = true;
 
        // 参数的不同，会分别调用下面的两个方法。
        // 这两个方法涉及到队列的操作，后面我们讲完入队和出队后
        // 再分析下面两个函数的实现。
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }
 
        // We can assume mPtr != 0 because mQuitting was previously false.
        // 唤醒线程，这样就可以循环起来然后拿到mQuitting做判断退出。
        nativeWake(mPtr);
    }
}

小结

1. Looper 的静态方法 prepare 函数里面创建了 Looper 对象，并且将 Looper 对象保存在了 sThreadLocal 中，这样可以保证每个线程都有一个自己的 Looper 对象。
2. 主线程有特殊的创建 Looper 对象的方法 prepareMainLooper，并且创建完成后除了保存在 sThreadLocal 中外，还保存在了一个静态变量 sMainLooper 中。
3. Looper 有个 MessageQueue 类型成员 mQueue，在 Looper 的构造函数中进行创建，最终创建了一个 Native 对象 NativeMessageQueue，并且 java 层拿到了它的指针。
4. Looper 的 quit 和 quitSafely 方法可以停止消息循环，其最终调用的都是 MessageQueue 的 quit 方法。
5. MessageQueue 有个成员 mQuitAllowed，由 Looper 的私有方法 prepare 传入，表示消息循环是否可以通过调用 quit 被停止。子线程可以被停止，主线程不能被停止。

可以推测出的结论

1. 每个线程最多只有一个 Looper 对象和一个 MessageQueue 对象。

上面讲完 MessageQueue 队列的创建，下面开始讲入队和出队。

4.2 MessageQueue 入队操作

入队操作由 Handler 完成。

4.2.1 Handler 的创建

// frameworks/base/core/java/android/os/Handler.java
/**
 * Default constructor associates this handler with the {@link Looper} for the
 * current thread.
 *
 * If this thread does not have a looper, this handler won't be able to receive messages
 * so an exception is thrown.
 *
 * @deprecated Implicitly choosing a Looper during Handler construction can lead to bugs
 *   where operations are silently lost (if the Handler is not expecting new tasks and quits),
 *   crashes (if a handler is sometimes created on a thread without a Looper active), or race
 *   conditions, where the thread a handler is associated with is not what the author
 *   anticipated. Instead, use an {@link java.util.concurrent.Executor} or specify the Looper
 *   explicitly, using {@link Looper#getMainLooper}, {link android.view.View#getHandler}, or
 *   similar. If the implicit thread local behavior is required for compatibility, use
 *   {@code new Handler(Looper.myLooper())} to make it clear to readers.
 *
 */
@Deprecated
public Handler() {
    this(null, false);
}

以上不带参数的默认构造函数已经被弃用，注释里写了一堆原因，总结就是这么用会带来很多问题。如果要用，就显式指定其依赖的 Looper 对象。

/**
 * Use the provided {@link Looper} instead of the default one.
 *
 * @param looper The looper, must not be null.
 */
public Handler(@NonNull Looper looper) {
    this(looper, null, false);
}
 
/**
 * Use the provided {@link Looper} instead of the default one and take a callback
 * interface in which to handle messages.
 *
 * @param looper The looper, must not be null.
 * @param callback The callback interface in which to handle messages, or null.
 */
public Handler(@NonNull Looper looper, @Nullable Callback callback) {
    this(looper, callback, false);
}

上面两个构造函数最终都会到下面的 hide 方法。

/**
 * @hide
 */
@UnsupportedAppUsage
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
    // 下面三个主要变量赋值，比较好理解
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    //是否为异步消息
    mAsynchronous = async;
}

1. 第一个 Looper 参数是 NonNull，通过 Looper.myLooper()方法获取，如果没有调用过 Looper 的 prepare 方法，则会报错。
2. 第二个参数 Callback 是 Handler 的内部接口，如果传入了这个参数不是空，则消息出队后将不会执行 Handler 的 handleMessage 方法，而是会执行实现了 Callback 接口对象的 handleMessage 方法。这样的话就不需要重写 Handler 的 handleMessage 了。

/**
 * Callback interface you can use when instantiating a Handler to avoid
 * having to implement your own subclass of Handler.
 */
public interface Callback {
    /**
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    boolean handleMessage(@NonNull Message msg);
}

1. 第三个参数表示，由这个 Handler 发送的消息是否为异步消息。

异步消息

上面 Handler 的构造函数中，其中最后一个参数需要特别注意一下。

它表示由这个 Handler 发送的 Message 消息是否为异步消息。

如果参数是 false，则表示此 Handler 发送的消息都是同步消息；如果参数是 true，则表示此 Handler 发送的消息都是异步消息。

从上面 Handler 的构造函数可以看出，普通应用的话这个参数默认为 false，也就是只能创建同步消息。

对于系统进程，则可以直接调用，指定 Handler 发送的消息是同步还是异步消息。

这里第一次出现异步消息这个概念，我们现在先理解为异步消息会比同步消息优先执行。

普通应用如何创建异步消息的 Handler

那么普通应用有办法创建异步消息的 Handler 吗？答案是有。

Handler 提供了两个静态方法，如下： 可以看到其最后一个参数为 true，表示异步。

@NonNull
public static Handler createAsync(@NonNull Looper looper) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    return new Handler(looper, null, true);
}
 
@NonNull
public static Handler createAsync(@NonNull Looper looper, @NonNull Callback callback) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    if (callback == null) throw new NullPointerException("callback must not be null");
    return new Handler(looper, callback, true);
}

关于异步消息我们先讲这么多，后面在用到的时候会继续讲解。

4.2.2 Handler 发送 Message 入队

Handler 有一系列的 postXXX 和 sendXXX 函数，最终都会调用到 sendMessageAtTime 函数。

不同的方法给下面的函数的两个参数赋值不同而已。

uptimeMillis:表示消息的延时时间，如果函数不带 Delay 或者要插入队头的则赋值为 0；

msg: Message 对象，调用不同的 post 或者 send 方法，对其不同成员进行赋值。

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    // mQueue是构造Handler时由传入的Looper对象提供。
    MessageQueue queue = mQueue;
    // 如果没有MessageQueue对象，直接报异常退出。
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    // 继续执行Message入队操作
    return enqueueMessage(queue, msg, uptimeMillis);
}
 
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    // Message类中有个target成员，其类型为Handler，
    // 这里将其赋值为当前Handler对象，后续消息出队后
    // 可能交给Handler处理消息。
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();
 
    // 是否为异步消息，这里可以看到，如果构造Handler时mAsynchronous为true，
    // 则将Message设置为异步标志。这样的话使用这个Handler发送的Message将
    // 都是异步Message。
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    // 调用MessageQueue的enqueueMessage方法入队
    return queue.enqueueMessage(msg, uptimeMillis);
}

上面使用到了 Message 的 setAsynchronous 方法，我们看下其实现：

// frameworks/base/core/java/android/os/Message.java
public void setAsynchronous(boolean async) {
    if (async) {
        flags |= FLAG_ASYNCHRONOUS;
    } else {
        flags &= ~FLAG_ASYNCHRONOUS;
    }
}

同时 Message 还提供了一个判断自己是否为异步消息点方法：

// frameworks/base/core/java/android/os/Message.java
public boolean isAsynchronous() {
    return (flags & FLAG_ASYNCHRONOUS) != 0;
}

FLAG_ASYNCHRONOUS 的值：

// frameworks/base/core/java/android/os/Message.java
static final int FLAG_ASYNCHRONOUS = 1 << 1;

消息入队

这里要敲黑板了，第一个重点部分来了。

MessageQueue 的入队操作，其实就是按照 Message 的延时执行时间参数 when 来进行排序入队。

// frameworks/base/core/java/android/os/MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
    // 通过Handler进行入队的话这个参数是不会为空的。
    // 这里要注意一下，并不是所有的在队列中的msg的target
    // 都不是null，有一类Message叫做同步屏障，它的target就必须为null，
    // 只不过它不是通过这个方法进行入队的。所以后面我们看到代码还有
    // msg.target == null的判断时不要惊讶。至于什么是同步屏障，
    // 后面会讲到的。
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
 
    // 入队一个Message时加锁
    synchronized (this) {
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }
 
        // 如果此时调用了Looper的quit函数，则说明取消了MessageQueue队列的运转，直接退出。
        // 这里说明，当quit后，将不能再入队新的Message。
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            // 释放msg
            msg.recycle();
            return false;
        }
 
        // 标记为正在使用状态
        msg.markInUse();
        // when就是此msg延时多久执行
        msg.when = when;
        // mMessage初始为空，表示的是队列的队头
        Message p = mMessages;
        // 当消息入队但是还未到其执行时间时，线程会进入阻塞，
        // 这里的needWake用来判断是否需要唤醒线程进行出队
        boolean needWake;
        // 这里的三个条件满足其一都会将当前Message插入队头
        // p == null,说明当前队列为空，新来的Message自然作为队头
        // when = 0,说明此Message没有延时需要立即执行，所以也放在队头
        // when < p.when,说明当前Message的延时小于队头Message的延时，所以放在队头
        if (p == null || when == 0 || when < p.when) {
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            // 这里的mBlocked表示MessageQueue的出队函数next()是否阻塞。
            // 如果是阻塞状态，则队头Message变化时要将其唤醒，表明这个时候
            // 可能有消息需要出队处理了，特别是当when == 0 的时候。
            needWake = mBlocked;
        } else {
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
            // 这里的p实际上是队头的Message，但是这里对其target == null做了判断，
            // 但是该函数的开头却有target == null的话会直接抛异常退出，那么这里会是null吗？
            // 除非有一种可能，那就是这个target为null的Message不是通过本方法入队的。
            // 这里又引入了一个新的概念：同步屏障（synchronization barriers），
            // 同步屏障我们先理解为一个target为null的Message，下面会详细介绍。
 
            // 如果队头是一个同步屏障且当前入队的消息是异步消息，且mBlocked为true，则
            // 需要唤醒当前线程来。
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            // 下面的操作是真正入队的操作，从队头开始遍历
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                // p == null 表示遍历到了队尾
                // when < p.when 表示队列按延时时间排序
                // 延时时间越小的越靠前，越靠近队头
                if (p == null || when < p.when) {
                    break;
                }
                // 如果队列中有异步消息，则将needWake置为false。
                //
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            // 将当前msg插入队列，插入p的前面
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }
 
        // We can assume mPtr != 0 because mQuitting is false.
        // 如果needWake为true，则唤醒线程
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

同步屏障

上面我们又遇见了一个新的概念：同步屏障，或者叫做同步屏障机制。在这个机制中，包含一个 target 为 null 的 Message，这个 Message 并不是通过上面的 enqueueMessage 方法入队的，而是另有他法。

插入同步屏障 Message 的方法 MessageQueue 的 postSyncBarrier

// frameworks/base/core/java/android/os/MessageQueue.java
/**
 * Posts a synchronization barrier to the Looper's message queue.
 * @hide
 */
@UnsupportedAppUsage
@TestApi
public int postSyncBarrier() {
    return postSyncBarrier(SystemClock.uptimeMillis());
}
 
private int postSyncBarrier(long when) {
    // Enqueue a new sync barrier token.
    // We don't need to wake the queue because the purpose of a barrier is to stall it.
    synchronized (this) {
        // mNextBarrierToken 表示每个同步屏障Message的token，
        // 初始值为0，从1开始记录
        final int token = mNextBarrierToken++;
        // 这里队Message赋值，可以看到并没有给target赋值，所以msg.targt=null
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token;
 
        // 将同步屏障msg入队，这里按照when的大小排序入队
        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) { // invariant: p == prev.next
            // 将msg插到p的前面
            msg.next = p;
            prev.next = msg;
        } else {
            // msg插入队头的情况
            msg.next = p;
            mMessages = msg;
        }
        // 返回值为msg的token
        return token;
    }
}

移除同步屏障 Message 的方法 removeSyncBarrier(int token)， 参数为 postSyncBarrier 时返回的 token 值。

/**
 * Removes a synchronization barrier.
 *
 * @param token The synchronization barrier token that was returned by
 * {@link #postSyncBarrier}.
 *
 * @throws IllegalStateException if the barrier was not found.
 *
 * @hide
 */
@UnsupportedAppUsage
@TestApi
public void removeSyncBarrier(int token) {
    // Remove a sync barrier token from the queue.
    // If the queue is no longer stalled by a barrier then wake it.
    synchronized (this) {
        Message prev = null;
        Message p = mMessages;
        while (p != null && (p.target != null || p.arg1 != token)) {
            prev = p;
            p = p.next;
        }
        // 如果p为空，说明没找到需要移除的同步屏障Message
        if (p == null) {
            throw new IllegalStateException("The specified message queue synchronization "
                    + " barrier token has not been posted or has already been removed.");
        }
        // 如果p != null，则说明p就是需要移除的msg
        final boolean needWake;
        if (prev != null) {
            // 要移除的msg不是队头
            prev.next = p.next;
            needWake = false;
        } else {
            // 要移除的msg是队头
            mMessages = p.next;
            // 队头发生变更，且队头是同步消息，needWake为true
            needWake = mMessages == null || mMessages.target != null;
        }
        // 释放移除掉的Message p
        p.recycleUnchecked();
 
        // If the loop is quitting then it is already awake.
        // We can assume mPtr != 0 when mQuitting is false.
        if (needWake && !mQuitting) {
            nativeWake(mPtr);
        }
    }
}

到目前为止，我们已经接触并分别简单介绍了同步屏障和异步消息两个概念了。

他们是两个 Message 对象，同步屏障的特点是 msg.target=null，异步消息的特点是 isAsynchronous 为 true。

那么这两者的作用究竟是什么呢？其实他们两个是一起发生作用的，或者说，同步屏障的作用是为了保证异步消息可以优先执行。当出队遇到队头为同步屏障时，则其后面的同步消息将不会被执行，只会执行异步消息，除非将同步屏障移除。

需要说明的是，添加和移除同步屏障是 hide 方法，只能系统进程使用。

下面的出队操作将会看到同步屏障和异步消息的处理逻辑和其作用。

4.3 MessageQueue 的流转-出队

详细流程图点击这里

4.3.1 Looper.loop()

Looper.loop()方法执行后消息队列开始运转，按规则进行出队操作。

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
@SuppressWarnings("AndroidFrameworkBinderIdentity")
public static void loop() {
    // 对Looper进行检查
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    if (me.mInLoop) {
        Slog.w(TAG, "Loop again would have the queued messages be executed"
                + " before this one completed.");
    }
 
    // loop开始后设置mInLoop为true
    me.mInLoop = true;
 
    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
 
    // Allow overriding a threshold with a system prop. e.g.
    // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
    // 这里可以通过属性设置一个消息处理时间的阈值，如果消息处理超过这个时间，将会
    // 有警告级别日志打印，默认这个属性是没有的，调试的时候可以自己设置这个属性来
    // 测试消息处理时间。
    // Looper是有专门的接口设置这个时间阈值的，如果同时设置了这个属性值，那么Looper接口
    // 设置的值会被这个属性值覆盖，后面代码可以看到。
    final int thresholdOverride =
            SystemProperties.getInt("log.looper."
                    + Process.myUid() + "."
                    + Thread.currentThread().getName()
                    + ".slow", 0);
 
    // 这个值默认为false，表示msg的投递时间未超过设置的阈值
    me.mSlowDeliveryDetected = false;
 
    // 这里进入了for循环，如果loopOnce返回false，则会退出循环，
    // 也就表示MessageQueue不工作了，除非再次调用loop方法，
    // 当调用quit方法后，loopOnce将会返回false
    for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
    }
}

下面看下 loopOnce 方法的实现

/**
 * Poll and deliver single message, return true if the outer loop should continue.
 */
@SuppressWarnings("AndroidFrameworkBinderIdentity")
private static boolean loopOnce(final Looper me,
        final long ident, final int thresholdOverride) {
    // 执行MessageQueue的next()函数，返回下一个将要处理的Message，
    // 如果下一个Message时间未到，next()方法则会阻塞等待。
    // 这个函数下面会详细分析。
    Message msg = me.mQueue.next(); // might block
    // 如果调用了Looper的quit方法，那么next()函数将会返回null。
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return false;
    }
 
    // This must be in a local variable, in case a UI event sets the logger
    // 这里是打印Message的处理日志的，这里的mLogging可以通过Looper的
    // setMessageLogging方法设置，默认为null。
    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.
    // sObserver可以通过Looper的setObserver方法设置，是用来监听回调
    // Message的处理状态的。
    final Observer observer = sObserver;
 
    // Looper的setTraceTag方法可以设置mTraceTag
    // 用来记录trace信息。此方法为hide方法，普通应用无法使用。
    final long traceTag = me.mTraceTag;
    // Looper的setSlowLogThresholdMs方法用来设置这两个值，也是hide方法。
    // 到这里需要解释一下这两个值的含义了。
    // mSlowDispatchThresholdMs: 消息时间的阈值，或者理解为处理完一个消息的时间阈值。
    // 如果消息处理时间比这个大，说明消息处理的比预期慢了，可能发生了异常。
    // mSlowDeliveryThresholdMs: 表示消息投递的时间差阈值，比如我的Message是延时500毫秒
    // 执行的，实际开始处理的时间（后面的dispatchStart）是550毫秒后，这就差了50毫秒，如果我们
    // 设置的阈值小于50，就说明消息投递的时间误差超出预期，可能发生异常。
    long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
    long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
    // thresholdOverride前面我们讲过，是调试时需要手动设置的属性值。
    // 如果这个值大于0，则覆盖setSlowLogThresholdMs方法设置的两个值。
    if (thresholdOverride > 0) {
        slowDispatchThresholdMs = thresholdOverride;
        slowDeliveryThresholdMs = thresholdOverride;
    }
    // 是否打印警告日志的开关
    final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
    final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
 
    final boolean needStartTime = logSlowDelivery || logSlowDispatch;
    final boolean needEndTime = logSlowDispatch;
 
    // 记录开始处理msg的trace
    if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
        Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
    }
 
    // 记录消息派发的开始时间
    final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
    final long dispatchEnd;
    Object token = null;
    if (observer != null) {
        // observer回调开始派发消息
        token = observer.messageDispatchStarting();
    }
    long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
    try {
        // 执行Handler的dispatchMessage函数
        msg.target.dispatchMessage(msg);
        if (observer != null) {
            // observer回调派发消息结束
            observer.messageDispatched(token, msg);
        }
        // 记录消息派发的结束时间
        dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
    } catch (Exception exception) {
        if (observer != null) {
            // observer回调派发消息发生异常
            observer.dispatchingThrewException(token, msg, exception);
        }
        throw exception;
    } finally {
        ThreadLocalWorkSource.restore(origWorkSource);
        if (traceTag != 0) {
            // 记录处理完成msg的trace
            Trace.traceEnd(traceTag);
        }
    }
    if (logSlowDelivery) {
        // 前面说过，mSlowDeliveryDetected初始化为false
        if (me.mSlowDeliveryDetected) {
            if ((dispatchStart - msg.when) <= 10) {
                Slog.w(TAG, "Drained");
                me.mSlowDeliveryDetected = false;
            }
        } else {
            // showSlowLog函数用来计算dispatchStart-msg.when是否大于slowDeliveryThresholdMs，
            // 如果是，则打印警告日志。
            if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                    msg)) {
                // Once we write a slow delivery log, suppress until the queue drains.
                // 并且将mSlowDeliveryDetected赋值true，用来表示队列中有一个消息投递的慢了，
                // 直到遇见下一个投递时间差没有超出10毫秒，再将其赋值false，也就是上面的if条件语句。
                me.mSlowDeliveryDetected = true;
            }
        }
    }
    if (logSlowDispatch) {
        // 如果消息派发处理时间超出阈值，打印警告日志。
        showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
    }
 
    // 如果我们设置了Printf,则打印处理完毕的日志
    if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }
 
    // Make sure that during the course of dispatching the
    // identity of the thread wasn't corrupted.
    final long newIdent = Binder.clearCallingIdentity();
    if (ident != newIdent) {
        Log.wtf(TAG, "Thread identity changed from 0x"
                + Long.toHexString(ident) + " to 0x"
                + Long.toHexString(newIdent) + " while dispatching to "
                + msg.target.getClass().getName() + " "
                + msg.callback + " what=" + msg.what);
    }
 
    // 对已经处理完的消息对象进行回收
    msg.recycleUnchecked();
 
    return true;
}

上面有两个方法我们没有展开将，一个是 MessageQueue 的 next()方法，一个是 Handler 的 dispatchMessage 方法，下面开始讲解。

4.3.2 MessageQueue 的 next()

需要注意的是，此时的 MessageQueue 里面的 Message 已经按照其延时时间 when 从小到大排序完成，when 越小越靠前靠近队头。

Message next() {
    // Return here if the message loop has already quit and been disposed.
    // This can happen if the application tries to restart a looper after quit
    // which is not supported.
    // 调用quit方法后，mPtr会赋值0，这里就会返回null，结束队列的循环运转。
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }
 
    // 这里又出现一个新名词，IdleHandler
    // 后面会详细解释
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    // 下一个消息执行还需要等待的时间
    int nextPollTimeoutMillis = 0;
    // 使用一个for循环寻找下一个要执行的Message，
    // 找到后将Message返回。
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
 
        // 这里是线程阻塞时间
        nativePollOnce(ptr, nextPollTimeoutMillis);
 
        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            // 获取当前时间
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            // 如果遇到同步屏障，则其后面的同步消息将都会略过不执行，
            // 只执行异步消息，除非调用removeSyncBarrier移除同步屏障，
            // 这种情况只有当同步屏障成为队头时，也就是如果同步屏障前面有
            // 同步消息，则会先执行前面的同步消息。
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            // 找到了要执行的msg
            if (msg != null) {
                // 如果当前时间now还小于msg的执行时间，则计算下还需要等待的时间
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    // 否则msg已经到了可以执行的时间，需要返回
                    // 同时mBlocked置为false
                    mBlocked = false;
                    if (prevMsg != null) {
                        // 走到这里说明找到的是异步msg
                        // 从队列中移除找到的msg
                        prevMsg.next = msg.next;
                    } else {
                        // 走到这里说明找到的msg是队头，
                        // 将msg的下一个元素置为新的队头。
                        mMessages = msg.next;
                    }
 
                    // 这里将msg标志为正在使用，然后返回。
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // 如果msg为null，说明队列中没有要执行的消息了，
                // 或者此时表头为同步屏障，但是队列中没有异步消息
                // No more messages.
                // 阻塞，直到下个Message入队
                nextPollTimeoutMillis = -1;
            }
 
            // 如果在运行过程中，有地方调用了Looper的quit方法，则退出loop循环操作。
            // 此后所有的msg都将不会执行，除非再次调用Looper.loop()启动运行
            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                // dispose函数用于释放
                dispose();
                return null;
            }
 
            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
 
            // 从这里开始都next()函数结束，剩下的代码都是IdleHandler相关的了。
            // 请注意，这里的代码还在上面的for循环里，for循环开始前pendingIdleHandlerCount赋值了-1。
            // 所以，第一次for循环 或者 队头msg为空（mMessages == null）
            // 或者队头的msg还未到执行时间(now < mMessages.when),
            // 就以mIdleHandlers的size重新赋值pendingIdleHandlerCount。
            // 其中mIdleHandlers是IdleHandler的一个列表，初始为空。
            // IdleHandler是一个接口类型，其有一个方法boolean queueIdle().
            // 列表mIdleHandlers需要通过MessageQueue的addIdleHandler方法添加元素，
            // 通过MessageQueue的removeIdleHandler方法删除元素。
            // IdleHandler存在的意义是当MessageQueue空闲时可以执行一些额外的任务。
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            // 如果pendingIdleHandlerCount<=0，说明没有需要执行的IdleHandler
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }
 
            // mPendingIdleHandler是IdleHandler类型的数组，其最小长度为4。
            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            // 将mPendingIdleHandlers中的元素赋值到mPendingIdleHandlers数组中
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }
 
        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        // 遍历mPendingIdleHandlers数组，执行其queueIdle()函数。
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler
 
            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }
 
            // 如果queueIdle()函数返回false，则将其IdleHandler从列表中移除。
            // 这样下次执行next()时，将不会再执行这个IdleHandler的queueIdle()方法
            // 否则若queueIdle()函数返回true，则下次next()时就还会执行其
            // queueIdle()函数。
            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
 
        // 到这里，如果有IdleHandler的话，则已经执行完一轮。
        // 此时需要重置pendingIdleHandlerCount = 0
        // 这样下次for循环时，就不会再执行其queueIdle函数了。
        // 下次执行要在下一次next()函数执行时继续按照上面的规则判定是否执行。
        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;
 
        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        // 走到这里说明队列空闲时执行了额外的IdleHandler任务，此时可能已经到了下一个Message需要
        // 执行的时间，所以将休眠唤醒时间赋值为0，也就是下次for循环时直接唤醒线程。
        nextPollTimeoutMillis = 0;
    }
}

4.3.3 Handler 的 dispatchMessage

dispatchMessage 是 Message 出队后的最后一步，进行消息处理。

public void dispatchMessage(@NonNull Message msg) {
    // 如果是通过post Runnable发送的消息，则会回调Runnable的run方法
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        // 如果构造Handler时传入了Callback参数，则回调
        // Callback的handleMessage方法
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //如果以上callback都没有，最后才是执行Handler的
        // handleMessage方法
        handleMessage(msg);
    }
}

5、Looper quit

最后分析一下 quit 方法的实现，前面讲过，quit 有两个方法，分别是 quit() 和 quitSafely()，其最终会调用到 MessageQueue 的 quit 方法中

void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }
 
    synchronized (this) {
        if (mQuitting) {
            return;
        }
        mQuitting = true;
 
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }
 
        // We can assume mPtr != 0 because mQuitting was previously false.
        nativeWake(mPtr);
    }
}

5.1 removeAllMessagesLocked

这个比较简单，遍历队列，对每个 Message 进行回收，最后将队头 mMessages 赋值为 null。

private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {
        Message n = p.next;
        p.recycleUnchecked();
        p = n;
    }
    mMessages = null;
}

5.2 removeAllFutureMessagesLocked

这个函数相比 removeAllMessagesLocked 多了一个 Future 字段，字面意思是未来，我们猜测这个函数移除的是还未到执行时间的 Message，如果 Message 已经到了执行时间，在投递阶段，还未派发完成，则需要执行完成。

下面看下实现跟我们猜测是否一样。

private void removeAllFutureMessagesLocked() {
    final long now = SystemClock.uptimeMillis();
    Message p = mMessages;
    if (p != null) {
        // 队头还未到执行时间，那所有Message都未到，
        // 队列里的Message都属于Future Message，
        // 直接调用removeAllMessagesLocked即可。
        if (p.when > now) {
            removeAllMessagesLocked();
        } else {
            //
            Message n;
            for (;;) {
                n = p.next;
                // 到这里说明，队列中的Message都在投递状态，
                // 都不属于Future Message，所以直接return。
                if (n == null) {
                    return;
                }
                // 找到了还未到执行时间的msg,
                // 那么它后面的肯定也都是Future msg
                // 退出遍历循环即可。
                if (n.when > now) {
                    break;
                }
                //
                p = n;
            }
            // 此时的n属于找到的第一个Future Message
            // 此时p 是 n的前一个Message
            // 下面要把p后面，从n开始的msg全部回收
            p.next = null;
            do {
                p = n;
                n = p.next;
                p.recycleUnchecked();
            } while (n != null);
        }
    }
}

6、 Message 池管理

最后有必要再看下 Message 的池管理。

有一个池子，里面原来是空的，当我们创建一个 Message 使用完进行回收后，并没有把这个 Message 对象销毁，而是放到了这个池子里，这个池子最大能容纳 50 个 Message 对象。当需要创建 Message 对象使用时，可以查看下池子是否为空，如果不是，就取一个拿出来使用。这样可以避免创建更多的 Message 对象，一定程度上达到节省内存和申请对象带来的开销。

Message 池也使用了单项链表的数据结构。

// frameworks/base/core/java/android/os/Message.java
 
// 下面几个变量是管理Message池子的一些工具变量
/** @hide */
public static final Object sPoolSync = new Object();
// sPool是池子的表头元素
private static Message sPool;
// 池子中的Message元素个数
private static int sPoolSize = 0;
// 最大能存放50个Message元素
private static final int MAX_POOL_SIZE = 50;
 
// Android 5.0之后这个值都为true
private static boolean gCheckRecycle = true;
 
 
/**
 * Return a new Message instance from the global pool. Allows us to
 * avoid allocating new objects in many cases.
 */
public static Message obtain() {
    // 如果池子不是空的，则将其表头Message拿出来返回
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            // 清楚使用标志
            m.flags = 0; // clear in-use flag
            // 个数减一
            sPoolSize--;
            return m;
        }
    }
    // 如果池子是空的，就需要创建新的对象
    return new Message();
}

Message 的回收函数

public void recycle() {
    // 如果回收正在使用的msg，则抛出异常
    if (isInUse()) {
        if (gCheckRecycle) {
            throw new IllegalStateException("This message cannot be recycled because it "
                    + "is still in use.");
        }
        return;
    }
    recycleUnchecked();
}
 
void recycleUnchecked() {
    // Mark the message as in use while it remains in the recycled object pool.
    // Clear out all other details.
    // 回收过程中设置为正在使用状态
    flags = FLAG_IN_USE;
    // 成员变量值重置
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = UID_NONE;
    workSourceUid = UID_NONE;
    when = 0;
    target = null;
    callback = null;
    data = null;
 
    // 如果当前线程池的Message数量小于MAX_POOL_SIZE，
    // 则将当前回收的Message放入表头，sPoolSize递增
    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

参考文档

https://zhuanlan.zhihu.com/p/679062875

@startuml
class android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface {
+ {static} int STATISTICS_MODE_NONE
+ {static} int STATISTICS_MODE_AVERAGE
+ {static} int STATISTICS_MODE_HISTORY
+ {static} int STATISTICS_MODE_DISTRIBUTION
- {static} boolean sInitialized
- {static} Object sInitLockObject
- {static} Class<?> sE2EScenarioClass
- {static} Constructor<?> sE2EScenarioConstructor
- {static} Class<?> sE2EScenarioSettingsClass
- {static} Constructor<?> sE2EScenarioSettingsConstructor
- {static} Method sE2EScenarioSettingsMethodSetStatisticsMode
- {static} Method sE2EScenarioSettingsMethodSetHistoryLimitPerDay
- {static} Method sE2EScenarioSettingsMethodEnableAutoAnalysis
- {static} Class<?> sE2EScenarioPayloadClass
- {static} Constructor<?> sE2EScenarioPayloadConstuctor
- {static} Method sE2EScenarioPayloadMethodPutValues
- {static} Method sE2EScenarioPayloadMethodPutAll
- {static} Class<?> sE2EScenarioPerfTracerClass
- {static} Method sBeginScenarioWithTagAndPayload
- {static} Method sAsyncBeginScenarioWithTagAndPayload
- {static} Method sAbortMatchingScenarioWithTag
- {static} Method sAbortSpecificScenario
- {static} Method sFinishMatchingScenarioWithTagAndPayload
- {static} Method sFinishSpecificScenarioWithPayload
+ {static} void init()
+ {static} boolean isUsable()
+ {static} E2EScenario createE2EScenario(String,String,String)
+ {static} E2EScenarioSettings createE2EScenarioSettings()
+ {static} E2EScenarioPayload createE2EScenarioPayload()
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,String)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,E2EScenarioPayload)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,String,E2EScenarioPayload)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,String)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,E2EScenarioPayload)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,String,E2EScenarioPayload)
+ {static} void abortScenario(E2EScenario)
+ {static} void abortScenario(E2EScenario,String)
+ {static} void abortScenario(Bundle)
+ {static} void finishScenario(E2EScenario)
+ {static} void finishScenario(E2EScenario,E2EScenarioPayload)
+ {static} void finishScenario(E2EScenario,String)
+ {static} void finishScenario(E2EScenario,String,E2EScenarioPayload)
+ {static} void finishScenario(Bundle)
+ {static} void finishScenario(Bundle,E2EScenarioPayload)
}
 
 
class android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenario {
- Object scenario
}
 
class android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenarioSettings {
- Object scenarioSettings
+ void setStatisticsMode(int)
+ void setHistoryLimitPerDay(int)
+ void enableAutoAnalysis(int,int)
}
 
 
class android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenarioPayload {
- Object payload
+ void putValues(Object)
+ void putAll(Map)
}
 
 
class android.os.updater.HttpUtils {
- {static} String TAG
- {static} boolean DEBUG
- {static} String httpResponse(HttpURLConnection)
- {static} void addCommonAndHeader(HttpURLConnection,HashMap<String,String>)
- {static} String httpResponseWithDecodeData(HttpURLConnection,String)
- {static} String decodeData(String,InputStream)
+ {static} String decodeData(String,String)
+ {static} String encodeData(String,String)
+ {static} String httpPost(String,HashMap<String,String>,ArrayMap<String,String>,String)
- {static} HttpURLConnection handlePostRequest(String,HashMap<String,String>,ArrayMap<String,String>)
+ {static} Cipher newAESCipher(String,int)
+ {static} Cipher newAESCipherWithIV(String,int,byte[])
}
 
 
class android.os.spc.MemoryCleanInfo {
+ long time
+ long beforeMemFree
+ long beforeMemAvail
+ long afterMemFree
+ long afterMemAvail
+ long neededMemory
+ long memTotal
+ long swapTotal
+ ArrayList<String> killedApps
+ String targetListData
+ String toString()
+ Bundle toBundle()
+ {static} MemoryCleanInfo fromBundle(Bundle)
+ JSONObject toJson()
}
 
 
class android.os.MiuiBinderTransaction {
}
class android.os.MiuiBinderTransaction$IActivityManager {
+ {static} String ACTIVITYMANAGER_DESCRIPTOR
+ {static} int TRANSACT_ID_GET_PACKAGE_HOLD_ON
+ {static} int TRANSACT_ID_SET_PACKAGE_HOLD_ON
+ {static} int GET_LAST_RESUMED_ACTIVITY_TRANSACTION
+ {static} int SET_LAST_SPLIT_ACTIVITY_TRANSACTION
+ {static} int GET_LAST_SPLIT_ACTIVITY_TRANSACTION
+ {static} int ADD_TO_ENTRY_STACK_TRANSACTION
+ {static} int CLEAR_ENTRY_STACK_TRANSACTION
+ {static} int REMOVE_FROM_ENTRY_STACK_TRANSACTION
+ {static} int IS_TOP_SPLIT_ACTIVITY_TRANSACTION
+ {static} int GET_TOP_SPLIT_ACTIVITY_TRANSACTION
+ {static} int GET_SPLIT_TASK_INFO_TRANSACTION
}
 
class android.os.MiuiBinderTransaction$IWindowManager {
+ {static} int TRANSACT_ID_SWITCH_RESOLUTION
+ {static} int TRANSACT_ID_SHOW_FLOAT_WINDOW
+ {static} int TRANSACT_ID_SIMULATE_SLIDE_EVENT
+ {static} int TRANSACT_ID_SET_SPLITTABLE
}
 
class android.os.MiuiBinderTransaction$ITelephonyRegistry {
+ {static} String DESCRIPTOR
+ {static} int TRANSACT_ID_GET_MIUI_TELEPHONY
}
 
class android.os.MiuiBinderTransaction$IDisplayManager {
+ {static} String INTERFACE_DESCRIPTOR
+ {static} int TRANSACT_ID_RESET_SHORT_MODEL
+ {static} int TRANSACT_ID_SET_BRIGHTNESS_RATE
+ {static} int TRANSACT_ID_GET_SCREEN_EFFECT_DISPLAY
+ {static} int TRANSACT_ID_GET_SCREEN_EFFECT_DISPLAY_INDEX
+ {static} int TRANSACT_ID_SET_VIDEO_INFORMATION
+ {static} int TRANSACT_ID_SET_BRIGHTNESS
+ {static} int TRANSACT_ID_SET_SCENE_FRAME_RATE
+ {static} int TRANSACT_ID_GET_DOZE_BRIGHTNESS_THRESHOLD
+ {static} int TRANSACT_ID_UPDATE_CINE_LOOK_BOOST_STATE
+ {static} int TRANSACT_ID_SET_BRIGHTNESS_BOOST
+ {static} int TRANSACT_ID_SET_MULTI_DISPLAYS_LIMIT
+ {static} int TRANSACT_ID_NOTIFY_SCREEN_OFF_ANIMATOR_END
+ {static} int TRANSACT_ID_GET_BRIGHTNESS_ANIMATE_VALUE
+ {static} int TRANSACT_ID_SET_TEMPORARY_SLIDER_VALUE
+ {static} int TRANSACT_ID_SET_SLIDER_VALUE
+ {static} int TRANSACT_ID_GET_SLIDER_VALUE
+ {static} int TRANSACT_ID_SET_MANUAL_MAX_BRIGHTNESS
+ {static} int TRANSACT_ID_SET_GRAYSCALE_HIST
+ {static} int TRANSACT_ID_GET_CURRENT_GRAYSCALE_VALUE
+ {static} int TRANSACT_ID_GET_ACCUMULATED_GRAY_VALUE
+ {static} int TRANSACT_ID_SET_IPA_POWER
}
 
class android.os.MiuiBinderTransaction$ITofManager {
+ {static} String INTERFACE_DESCRIPTOR
+ {static} int TRANSACT_ID_SET_APP_AIR_GESTURE_ENABLE
+ {static} int TRANSACT_ID_GET_AIR_GESTURE_SETTINGS_APP_LIST
}
 
class android.os.MiuiBinderTransaction$IOpsCallback {
+ {static} int ASK_OPERATION
+ {static} int GET_DEFAULT_OP
+ {static} int IS_APP_PERMISSION_CONTROL_OPEN
+ {static} int ON_APP_APPLY_OPERATION
+ {static} int UPDATE_PROCESSSTATE
+ {static} int APP_PERM_FLAGS_MODIFIED
}
 
class android.os.MiuiBinderTransaction$IUiModeManager {
+ {static} String DESCRIPTOR
+ {static} int SET_APP_DARK_MODE_ENABLE
+ {static} int GET_APP_DARK_MODE_ENABLE
+ {static} int REGISTER_APP_DARK_MODE_OBSERVER
+ {static} int GET_FORCE_DARK_CONFIG_INFO
+ {static} int GET_FORCE_DARK_SETTINGS_APP_LIST
+ {static} int GET_FORCE_DARK_CHECK_APP_ORIGIN_STATE
+ {static} int GET_SHOULD_INTERCEPT_RELAUNCH
+ {static} int GET_FORCE_DARK_FOR_SPLASH_SCREEN
}
 
class android.os.MiuiBinderTransaction$IInputMethodManager {
+ {static} String DESCRIPTOR
+ {static} int CODE_INPUT_TEXT
+ {static} int CODE_REGISTER_MONITER
+ {static} int CODE_UNREGISTER_MONITER
+ {static} int CODE_SYNERGY_OPERATE
+ {static} int CODE_INPUT_REMOTE
+ {static} int CODE_HIDE_IME_SELF
}
 
class android.os.MiuiBinderTransaction$IMiuiSynergy {
+ {static} String DESCRIPTOR
+ {static} int CODE_INPUT_STATUS
}
 
class android.os.MiuiBinderTransaction$IMiuiHeartRate {
+ {static} String DESCRIPTOR
+ {static} int HEARTBEAT_RATE_SEND_CMD
+ {static} int HEARTBEAT_RATE_REGISTER
+ {static} int HEARTBEAT_RATE_UNREGISTER
+ {static} int HEARTBEAT_RATE_DATA
}
 
class android.os.MiuiBinderTransaction$ILockSettings {
+ {static} String DESCRIPTOR
+ {static} int CHECK_PRIVACY_PASSWORD_PATTERN
+ {static} int SAVE_PRIVACY_PASSWORD_PATTERN
}
 
class android.os.MiuiBinderTransaction$IClipboard {
+ {static} String DESCRIPTOR
+ {static} int GET_CLIPBOARD_CLICKTRACE
}
 
class android.os.MiuiBinderTransaction$IMiuiFaceManager {
+ {static} String SERVICE_NAME
+ {static} String SERVICE_DESCRIPTOR
+ {static} String RECEIVER_DESCRIPTOR
+ {static} int CODE_PRE_INIT_AUTHEN
+ {static} int CODE_AUTHENTICATE
+ {static} int CODE_CANCEL_AUTHENTICATE
+ {static} int CODE_ENROLL
+ {static} int CODE_CANCEL_ENROLL
+ {static} int CODE_REMOVE
+ {static} int CODE_RENAME
+ {static} int CODE_GET_ENROLLED_FACE_LIST
+ {static} int CODE_PRE_ENROLL
+ {static} int CODE_POST_ENROLL
+ {static} int CODE_HAS_ENROLLED_FACES
+ {static} int CODE_GET_AUTHENTICATOR_ID
+ {static} int CODE_RESET_TIMEOUT
+ {static} int CODE_ADD_LOCKOUT_RESET_CALLBACK
+ {static} int CODE_GET_VENDOR_INFO
+ {static} int CODE_EXT_CMD
+ {static} int RECEIVER_ON_ENROLL_RESULT
+ {static} int RECEIVER_ON_ON_ACQUIRED
+ {static} int RECEIVER_ON_AUTHENTICATION_SUCCEEDED
+ {static} int RECEIVER_ON_AUTHENTICATION_FAILED
+ {static} int RECEIVER_ON_ERROR
+ {static} int RECEIVER_ON_REMOVED
+ {static} int RECEIVER_ON_PRE_INIT
+ {static} int RECEIVER_ON_LOCKOUT_RESET
+ {static} int RECEIVER_ON_EXT_CMD
}
 
abstract class android.os.statistics.MicroscopicEvent {
+ {static} int SCHED_POLICY_UNKNOWN
}
 
class android.os.statistics.MicroscopicEvent$MicroEventFields {
+ int threadId
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MicroscopicEvent$BlockedEventFields {
+ int schedPolicy
+ int schedPriority
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MicroscopicEvent$BlockerEventFields {
+ String threadName
+ int schedPolicy
+ int schedPriority
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MicroscopicEvent$MeasurementEventFields {
+ int schedPolicy
+ int schedPriority
+ int runningTimeMs
+ int runnableTimeMs
+ int sleepingTimeMs
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MicroscopicEvent$RootEventFields {
+ String processName
+ String packageName
+ String threadName
+ int schedPolicy
+ int schedPriority
+ int runningTimeMs
+ int runnableTimeMs
+ int sleepingTimeMs
+ long endRealTimeMs
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.updater.ValidateChecker {
- {static} String TAG
- {static} String VALIDATE_URL
- {static} String SALT
- {static} String JSON_CODE
- {static} String JSON_DATA
- {static} int REQUEST_SUCCESS
- {static} int REQUEST_FAILED
- {static} int REQUEST_DEFAULT
- {static} String REQUEST_STRING_DEFAULT
- Context mContext
- File mPkgFile
- boolean mProcessed
- String mMd5
+ String checkValidate()
- String parseResultFromString(String)
- String getValidateJsonString()
- ArrayMap<String,String> getParams(String)
}
 
 
class android.os.updater.CheckerUtils {
- {static} String TAG
- {static} int ROM_ZONE_CHINA
- {static} String ROM_DIR
- {static} String DEBUG_CONFIG_PATH
- {static} String IS_XIAOMI
+ {static} int INSTALL_SUCCESS
+ {static} int INSTALL_NO_FILE
+ {static} int INSTALL_VERIFY_FAILURE
+ {static} int INSTALL_ERROR
+ {static} int INSTALL_CORRUPT
+ {static} int INSTALL_UNKNOWN
+ {static} int INSTALL_NONE
+ {static} int INSTALL_NO_STATUS
- {static} HashMap<String,Integer> sRecoveryResultStrings
- {static} Object GET_MEMORY_LOCK
+ {static} String UPDATE_STABLE_VERSION_ONLY
+ {static} int UPDATE_STABLE_VERSION_ONLY_DEFAULT
- {static} String EMPTY_STRING
- {static} String getSerialNumFromProp()
+ {static} String getSerialNum()
+ {static} String getLanguage()
+ {static} String getMIUIVersion()
+ {static} String getIncrementalVersion()
+ {static} String getCodebase()
+ {static} String getCodebaseSimplify()
+ {static} String getDeviceName()
+ {static} boolean isFinalUserBuild()
+ {static} boolean isUpdateStableVersionOnly(Context)
+ {static} String getBranchCode(Context)
+ {static} String getRegion()
+ {static} String getCarrier()
+ {static} int getRomZone()
+ {static} boolean isXiaomi()
+ {static} String getModel()
+ {static} boolean isInternationalBuild()
+ {static} String getAndroidId(Context,String)
+ {static} boolean isDebug()
}
 
 
class android.os.MiPerf {
- {static} String TAG
- {static} boolean isLoadMiPerfJni
- {static} boolean isMiperfEnableProp
- {static} int FILEEXPLOR_SCENE_COPY_START
- {static} int FILEEXPLOR_SCENE_COPY_END
- {static} int FILEEXPLOR_SCENE_UNZIP_START
- {static} int FILEEXPLOR_SCENE_UNZIP_END
- {static} ArrayList<Integer> listOfScene
+ {static} int nativePerfAcqXml(int,String,String,String)
+ {static} HashMap<String,HashMap<String,String>> nativeGetXmlHashMap()
+ {static} HashMap<String,String> nativeGetThermalMap()
+ {static} int nativeUpdateConfig()
+ {static} void receiveCloud(String)
- {static} boolean isEnableMiperf()
- {static} boolean checkPackageHaveSceneBoost(int)
- {static} String getSceneBoostMode(int)
- {static} String getSceneActivity(int)
+ {static} HashMap<String,HashMap<String,String>> miPerfGetXmlMap()
+ {static} HashMap<String,String> getThermalMap()
+ {static} int miPerfSystemBoostAcquire(int,String,String,String)
+ {static} int miPerfSceneBoostAcquire(String,int)
}
 
 
class android.os.MiuiBinderProxy {
- String TAG
- IBinder mService
- String mDescriptor
+ int callOneWayTransact(int,Object)
+ Object callNonOneWayTransact(int,Class<?>,Object)
+ int callNonOneWayTransact(int,Object)
+ Object callTransact(int,int,Class<?>,Object)
}
 
 
class android.os.statistics.E2EScenarioPerfTracer {
- {static} int VERSION
- {static} ThreadPoolExecutor executor
+ {static} int getVersion()
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,String)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,E2EScenarioPayload)
+ {static} Bundle beginScenario(E2EScenario,E2EScenarioSettings,String,E2EScenarioPayload)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,String)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,E2EScenarioPayload)
+ {static} void asyncBeginScenario(E2EScenario,E2EScenarioSettings,String,E2EScenarioPayload)
+ {static} void abortScenario(E2EScenario)
+ {static} void abortScenario(E2EScenario,String)
+ {static} void abortScenario(Bundle)
+ {static} void finishScenario(E2EScenario)
+ {static} void finishScenario(E2EScenario,E2EScenarioPayload)
+ {static} void finishScenario(E2EScenario,String)
+ {static} void finishScenario(E2EScenario,String,E2EScenarioPayload)
+ {static} void finishScenario(Bundle)
+ {static} void finishScenario(Bundle,E2EScenarioPayload)
}
 
 
class android.os.statistics.EventLogSuperviser {
- {static} int[] supervisedEventLogTags
- {static} String[] emptyEventValueStrs
- {static} boolean isSupervised(int)
+ {static} void notifyEvent(int,int)
+ {static} void notifyEvent(int,long)
+ {static} void notifyEvent(int,float)
+ {static} void notifyEvent(int,String)
+ {static} void notifyEvent(int,Object)
- {static} void notifyEventWithObject(int,Object)
}
 
 
class android.os.statistics.EventLogSuperviser$EventLogTags {
+ {static} int POWER_SCREEN_STATE
+ {static} int AM_RESUME_ACTIVITY
+ {static} int AM_ANR
+ {static} int AM_ACTIVITY_LAUNCH_TIME
+ {static} int AM_PROC_START
+ {static} int AM_LOW_MEMORY
+ {static} int AM_RELAUNCH_RESUME_ACTIVITY
+ {static} int AM_CREATE_SERVICE
+ {static} int AM_PROVIDER_LOST_PROCESS
+ {static} int AM_PROCESS_START_TIMEOUT
+ {static} int AM_CRASH
+ {static} int AM_SWITCH_USER
+ {static} int AM_MEMINFO
+ {static} int AM_MEM_FACTOR
+ {static} int AM_START_SERVICE
+ {static} int AM_BIND_SERVICE
+ {static} int AM_ACTIVITY_LAUNCH_TIME_MIUI
+ {static} int CONTENT_QUERY_SAMPLE
+ {static} int CONTENT_UPDATE_SAMPLE
}
 
class android.os.statistics.EventLogSuperviser$SingleEventLogItem {
+ {static} Parcelable.Creator<SingleEventLogItem> CREATOR
}
 
class android.os.statistics.EventLogSuperviser$EventLogFields {
- {static} String FIELD_EVENT_LOG_TIME
- {static} String FIELD_EVENT_LOG_TAG_ID
- {static} String FIELD_EVENT_LOG_TAG_NAME
- {static} String FIELD_EVENT_LOG_VALUE_STRS
+ long currentTimeMillis
+ int eventLogTagId
+ String eventLogTagName
+ String[] eventLogValueStrs
+ Object eventLogValueObject
+ void fillIn(JniParcel)
+ void resolveLazyInfo()
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.OsUtils {
+ {static} int SCHED_GROUP_UNKNOWN
- {static} boolean sDoneFindIsRenderThreadMethod
- {static} Method sIsRenderThreadMethod
+ {static} int decodeThreadSchedulePolicy(int)
+ {static} int getThreadSchedulePolicy(int)
- {static} int getThreadScheduler(int)
+ {static} void getThreadSchedStat(long[])
+ {static} boolean isHighPriority(int,int)
+ {static} boolean isLowPriority(int,int)
+ {static} int getSchedGroup(int)
+ {static} boolean isHighSchedGroup(int)
+ {static} boolean isRenderThread(int)
+ {static} void setThreadPriorityUnconditonally(int,int)
+ {static} long getCoarseUptimeMillisFast()
+ {static} long getDeltaToUptimeMillis()
+ {static} boolean isIsolatedProcess()
+ {static} long getRunningTimeMs()
+ {static} String translateKernelAddress(long)
}
 
 
class android.os.statistics.PerfSupervisionSettings {
- {static} String TAG
+ {static} int PERF_SUPERVISION_OFF
+ {static} int PERF_SUPERVISION_ON_NORMAL
+ {static} int PERF_SUPERVISION_ON_HEAVY
+ {static} int PERF_SUPERVISION_ON_TEST
+ {static} int MIN_SOFT_THRESHOLD_MS
+ {static} int MIN_PEER_WAIT_TIME_RATIO_POWER
+ {static} int MIN_HARD_THRESHOLD_MS
+ {static} int MAX_EVENT_THRESHOLD_MS
- {static} int DEFAULT_LEVEL
- {static} int DEFAULT_SOFT_THRESHOLD_MS
- {static} int DEFAULT_DIVISION_RATIO
- {static} int DEFAULT_GLOBAL_PERF_EVENT_QUEUE_LENGTH
- {static} boolean DEFAULT_AUTO_ANALYSIS_ON_STATE
- {static} int sPerfSupervisionLevel
+ {static} int sPerfSupervisionSoftThreshold
+ {static} int sPerfSupervisionHardThreshold
+ {static} int sPerfSupervisionDivisionRatio
+ {static} int sMinPerfEventDurationMillis
+ {static} int sMinOverlappedDurationMillis
+ {static} int sGlobalPerfEventQueueLength
+ {static} boolean sIsAutoAnalysisOn
- {static} boolean sReadySupervision
- {static} boolean sIsSystemServer
- {static} boolean sIsMiuiDaemon
~ {static} int parseIntWithDefault(String,int)
+ {static} void init()
+ {static} int getSupervisionLevel()
+ {static} boolean isSupervisionOn()
+ {static} boolean isSystemServer()
+ {static} boolean isPerfEventReportable()
+ {static} boolean isInHeavyMode()
+ {static} boolean isInTestMode()
+ {static} boolean isAboveHardThreshold(long)
+ {static} void notifySupervisionReady(boolean,boolean)
}
 
 
class android.os.statistics.SingleJniMethod {
+ {static} Parcelable.Creator<SingleJniMethod> CREATOR
+ boolean isMeaningful()
}
 
 
class android.os.statistics.SingleJniMethod$JniMethodFields {
- {static} String FIELD_STACK
- {static} String[] exceptionalJniMethodFullNames
- {static} HashMap<Class<?>,ArrayList<String>> exceptionalClassMethodSimpleNames
+ String[] stackTrace
+ void fillInStackTrace(Class[],StackTraceElement[],NativeBackTrace)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
- {static} String[] buildStackTrace(StackTraceElement[],Class[])
}
 
 
class android.os.updater.MD5 {
+ {static} String calculateMD5(File)
+ {static} String getMd5Digest(String)
+ {static} String getMd5Digest(byte[])
}
 
class android.os.updater.UrlUtil {
+ {static} String HTTP_PROTOCOL
+ {static} String HTTPS_PROTOCOL
+ {static} String UPDATE_PROTOCOL
- {static} String UPDATE_HOST_HOST
- {static} String UPDATE_GLOBAL_HOST
- {static} String UPDATE_TEST_HOST
+ {static} String UPDATE_HOST
+ {static} String UPDATE_KEY
}
 
class android.os.statistics.FilteringPerfEventFactory {
+ {static} FilteringPerfEvent createFilteringPerfEvent(int,int,long,long,long,long,long,long)
+ {static} FilteringPerfEvent createFilteringPerfEvent(PerfEvent)
}
 
class android.os.spc.PSIMonitorSetting {
+ {static} String PSI_MEMORY_NODE
+ {static} String PSI_IO_NODE
+ {static} String PSI_CPU_NODE
+ {static} String TAG
+ {static} boolean DEBUG
+ {static} int MONITOR_MEMORY_SOME
+ {static} int MONITOR_MEMORY_FULL
+ {static} int MONITOR_IO_SOME
+ {static} int MONITOR_IO_FULL
+ {static} int MONITOR_CPU_SOME
+ {static} int MONITOR_TYPE_COUNT
+ {static} int JANK_TYPE
+ int id
+ String name
+ int monitorType
+ long thresholdMillis
+ long windowMillis
+ {static} PSIMonitorSetting[] PSI_MONITORS
+ int getMonitorId()
+ {static} int getEventType(int)
+ {static} String getTypeName(int)
+ String getPSINode()
+ String generateMonitorCommand()
}
 
 
class android.os.updater.DigestUtils {
- {static} int BUFFER_SIZE
+ {static} String ALGORITHM_MD5
+ {static} String ALGORITHM_SHA_1
+ {static} String ALGORITHM_SHA_256
- {static} char[] HEX_DIGITS
+ {static} byte[] get(CharSequence,String)
+ {static} byte[] get(byte[],String)
+ {static} byte[] get(InputStream,String)
+ {static} void toHexReadable(byte[],Appendable)
+ {static} String toHexReadable(byte[])
}
 
 
class android.os.statistics.JniParcel {
- long[] numbers
- int numbersCount
- int readPosOfNumbers
- Object[] objects
- int objectsCount
- int readPosOfObjects
+ void reset()
+ int readInt()
+ long readLong()
+ Object readObject()
+ String readString()
- void writeLong1(long)
- void writeLong2(long,long)
- void writeLong3(long,long,long)
- void writeLong4(long,long,long,long)
- void writeLong5(long,long,long,long,long)
- void writeLong6(long,long,long,long,long,long)
- void writeLong7(long,long,long,long,long,long,long)
- void writeLong8(long,long,long,long,long,long,long,long)
- void writeLong9(long,long,long,long,long,long,long,long,long)
- void writeLong10(long,long,long,long,long,long,long,long,long,long)
- void writeLong11(long,long,long,long,long,long,long,long,long,long,long)
- void writeLong12(long,long,long,long,long,long,long,long,long,long,long,long)
- void writeObject1(Object)
- void writeObject2(Object,Object)
- void writeObject3(Object,Object,Object)
- void writeObject4(Object,Object,Object,Object)
- void writeObject5(Object,Object,Object,Object,Object)
- void writeObject6(Object,Object,Object,Object,Object,Object)
- void writeObject7(Object,Object,Object,Object,Object,Object,Object)
- void writeObject8(Object,Object,Object,Object,Object,Object,Object,Object)
- void writeObject9(Object,Object,Object,Object,Object,Object,Object,Object,Object)
}
 
 
class android.os.HapticPlayer {
- {static} String TAG
- {static} int USAGE_DYNAMICEFFECT
- {static} ExecutorService mExcutor
- boolean mStarted
- DynamicEffect mEffect
- IVibratorManagerService mService
- String mPackageName
- Binder mToken
- boolean mAvailable
- int displayId
- VibrationAttributes mAttributes
+ void setDataSource(DynamicEffect)
+ {static} boolean isAvailable()
+ {static} String getVersion()
+ void start()
+ void start(int)
+ void start(int,int,int)
+ void start(int,int,int,int)
+ void stop()
+ void start(DynamicEffect)
}
 
 
class android.os.statistics.PerfEventSocket {
+ {static} int sendPerfEvent(int,Parcel,long,int)
+ {static} int waitForPerfEventArrived(int)
+ {static} int receivePerfEvents(int,Parcel,long,int,FilteringPerfEvent[])
}
 
class android.os.statistics.FilteringPerfEvent {
+ int eventType
+ int eventFlags
+ long beginUptimeMillis
+ long endUptimeMillis
+ long inclusionId
+ long synchronizationId
+ long eventSeq
+ long detailsPtr
+ PerfEvent event
+ int durationMillis
~ int matchedPeerWaitDuration
~ int enoughPeerWaitDuration
~ long sortingUptimeMillis
# void finalize()
+ void set(PerfEvent)
+ void resolve(Parcel,long)
+ void resolveTo(PerfEvent,Parcel,long)
+ void dispose()
+ void writeToParcel(Parcel,long)
- {static} void nativeResolve(PerfEvent,long,int,Parcel,long)
- {static} void nativeDipose(long,int)
- {static} void nativeWriteToParcel(Parcel,long,int,int,long,long,long,long,long,long)
}
 
 
abstract class android.os.statistics.MacroscopicEvent {
}
class android.os.statistics.LooperMessageSuperviser {
+ {static} void beginLooperMessage(ILooperMonitorable,Message)
+ {static} void endLooperMessage(ILooperMonitorable,Message,long)
- {static} void nativeBeginLooperMessage()
- {static} void nativeEndLooperMessage(String,int,String,long)
}
 
class android.os.statistics.LooperMessageSuperviser$SingleLooperMessage {
+ {static} Parcelable.Creator<SingleLooperMessage> CREATOR
}
 
class android.os.statistics.LooperMessageSuperviser$SingleLooperMessageFields {
- {static} String FIELD_MESSAGE_NAME
- {static} String FIELD_PLAN_UPTIME
+ String messageName
+ String messageTarget
+ int messageWhat
+ String messageCallback
+ long planUptimeMillis
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.PerfEventFilter {
+ {static} int MAX_TIME_SPAN_MILLIS
+ {static} int APP_MAX_FILTER_INTERVAL_MILLIS
+ {static} int APP_ONE_BATCH_MAX_EVENT_COUNT
+ {static} int SYSTEM_SERVER_ONE_BATCH_MAX_EVENT_COUNT
+ {static} int DAEMON_MAX_FILTER_INTERVAL_MILLIS
+ {static} int DAEMON_ONE_BATCH_MAX_EVENT_COUNT
- boolean isAppSideFilter
- int maxFilterIntervalMillis
- int minWaitTimeMillis
- LeveledCheckingEventList effectivePerfEvents
- LeveledCheckingEventList effectivePerfEventsWaitingPeer
- LeveledCheckingEventList suspectedPerfEvents
- long latestBatchBeginUptimeMillis
- long latestBatchEndUptimeMillis
- long[] tempBatchTimestampMillis
- {static} int getCeilingOfPowerByTwo(int)
+ boolean hasPendingPerfEvents()
+ void send(FilteringPerfEventList,FilteringPerfEventList)
- void moveNewArrivedPerfEvents(FilteringPerfEventList,LeveledCheckingEventList)
+ void filter(TimeslicedCompletedEventList,long)
- void checkEffectivePerfEvents(TimeslicedCompletedEventList)
- void checkEffectiveLevel(TimeslicedCheckingEventList,TimeslicedCompletedEventList)
- void completeEffectiveSlice(TimeslicedCheckingEventList,FilteringPerfEventList,TimeslicedCompletedEventList)
- void checkEffectiveSlice(TimeslicedCheckingEventList,FilteringPerfEventList,TimeslicedCompletedEventList)
- void checkEffectiveEvent(FilteringPerfEvent,TimeslicedCompletedEventList)
- boolean checkBlockedEffectiveMicroEvent(FilteringPerfEvent)
- boolean checkBlockedEffectiveMicroEventWithSuspectedLevel(FilteringPerfEvent,TimeslicedCheckingEventList)
- boolean checkBlockedEffectiveMicroEventWithSuspectedSlice(FilteringPerfEvent,TimeslicedCheckingEventList,FilteringPerfEventList)
- boolean checkNonBlockedEffectiveMicroEvent(FilteringPerfEvent)
- void checkNonBlockedEffectiveMicroEventWithSuspectedLevel(FilteringPerfEvent,TimeslicedCheckingEventList)
- void checkNonBlockedEffectiveMicroEventWithSuspectedSlice(FilteringPerfEvent,TimeslicedCheckingEventList,FilteringPerfEventList)
- boolean checkEffectiveMacroEvent(FilteringPerfEvent)
- void checkEffectiveMacroEventWithSuspectedLevel(FilteringPerfEvent,TimeslicedCheckingEventList)
- void checkEffectiveMacroEventWithSuspectedSlice(FilteringPerfEvent,TimeslicedCheckingEventList,FilteringPerfEventList)
- void checkSuspectedPerfEvents(long)
- void checkLevelSuspectedPerfEvents(TimeslicedCheckingEventList,long)
- void recycleSuspectedSlice(TimeslicedCheckingEventList,FilteringPerfEventList)
- void checkSuspectedSlice(TimeslicedCheckingEventList,FilteringPerfEventList,long)
}
 
 
abstract class android.os.statistics.PerfEventFilter$TimeslicedFilteringPerfEventList {
+ FilteringPerfEventList outDatedPerfEvents
+ int timesliceMillisPower
+ int timesliceMillis
+ int timesliceCount
+ int firstSliceIndex
+ long firstSliceUptimeMillis
+ FilteringPerfEventList[] timeslicedPerfEvents
+ int inclusiveMinPerfEventDurationMillis
+ int exclusiveMaxPerfEventDurationMillis
+ Comparator<FilteringPerfEvent> secondaryComparator
+ int perfEventCount
+ void add(FilteringPerfEvent)
+ void remove(FilteringPerfEventList,FilteringPerfEvent)
}
 
 
class android.os.statistics.PerfEventFilter$TimeslicedCompletedEventList {
}
class android.os.statistics.PerfEventFilter$TimeslicedCheckingEventList {
}
class android.os.statistics.PerfEventFilter$LeveledCheckingEventList {
+ int longLevelFloorMillis
+ int shortLevelDeltaMillisPower
+ int shortLevelDeltaMillis
+ int shortLevelCount
+ int longLevelDeltaMillisPower
+ int longLevelDeltaMillis
+ int longLevelCount
+ TimeslicedCheckingEventList[] shortPerfEventsByLevel
+ TimeslicedCheckingEventList[] longPerfEventsByLevel
+ int perfEventCount
+ void add(FilteringPerfEvent)
+ void remove(TimeslicedCheckingEventList,FilteringPerfEventList,FilteringPerfEvent)
}
 
 
class android.os.spc.PressureStateSettings {
+ {static} String TAG
- {static} String PROPERTY_PREFIX
+ {static} boolean DEBUG_ALL
+ {static} long MEM_PRESSURE_WINDOW_NS
+ {static} boolean PROCESS_CLEANER_ENABLED
+ {static} long PROC_CLEAN_PSS_KB
+ {static} long PROC_CLEAN_MIN_INTERVAL_MS
+ {static} long PROC_COMMON_USED_PSS_LIMIT_KB
+ {static} long PROC_COMMON_USED_SWAPPSS_LIMIT_KB
+ {static} long PROC_MEM_EXCEPTION_PSS_LIMIT_KB
+ {static} boolean PROC_CPU_EXCEPTION_ENABLE
+ {static} int PROC_CPU_EXCEPTION_THRESHOLD
+ {static} boolean ONLY_KILL_ONE_PKG
+ {static} String WHITE_LIST_PKG
+ {static} boolean PROCESS_RESTART_INTERCEPT_ENABLE
+ {static} int SCREEN_OFF_PROCESS_ACTIVE_THRESHOLD
+ {static} int SCREEN_OFF_PROCESS_ACTIVE_MIX_THRESHOLD
+ {static} int PREVIOUS_PROTECT_CRITICAL_COUNT
+ {static} int PREVIOUS_FORCE_PROTECT_COUNT
+ {static} int PROTECT_RECENT_SYSTEM_APP_COUNT
+ {static} int PROTECT_RECENT_APP_COUNT
+ {static} int RECENT_SP_APP_PROTECT_TIME
+ {static} boolean PROCESS_TRACKER_ENABLE
+ {static} long PKG_REGULAR_CHECK_INTERVAL
}
 
class android.os.LooperMonitor {
- boolean mEnableMonitor
+ boolean isMonitorLooper()
+ void enableMonitor(boolean)
}
 
 
class android.os.statistics.MonitorSuperviser {
+ {static} int CONDITION_AWAKEN_NOTIFIED
+ {static} int COMDITION_AWAKEN_TIMEDOUT
+ {static} int COMDITION_AWAKEN_INTERRUPTED
}
 
class android.os.statistics.MonitorSuperviser$SingleLockHold {
+ {static} Parcelable.Creator<SingleLockHold> CREATOR
}
 
class android.os.statistics.MonitorSuperviser$SingleLockWait {
+ {static} Parcelable.Creator<SingleLockWait> CREATOR
}
 
class android.os.statistics.MonitorSuperviser$SingleConditionAwaken {
+ {static} Parcelable.Creator<SingleConditionAwaken> CREATOR
}
 
class android.os.statistics.MonitorSuperviser$SingleConditionWait {
+ {static} Parcelable.Creator<SingleConditionWait> CREATOR
}
 
class android.os.statistics.MonitorSuperviser$SingleMonitorWaitFields {
- {static} String FIELD_MONITOR_ID
- {static} String FIELD_STACK
+ long monitorId
+ String[] stackTrace
+ void fillIn(JniParcel)
+ void fillInStackTrace(Class[],StackTraceElement[],NativeBackTrace)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MonitorSuperviser$SingleMonitorReadyFields {
- {static} String FIELD_MONITOR_ID
- {static} String FIELD_STACK
+ long monitorId
+ String[] stackTrace
+ void fillIn(JniParcel)
+ void fillInStackTrace(Class[],StackTraceElement[],NativeBackTrace)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MonitorSuperviser$SingleConditionWaitFields {
- {static} String FIELD_AWAKEN_REASON
+ int awakenReason
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MonitorSuperviser$SingleConditionAwakenFields {
- {static} String FIELD_PEER_THREAD_ID
+ int peerThreadId
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.spc.PSIEvent {
+ int id
+ long timeNs
+ long growthNs
+ int type
+ {static} PSIEvent parse(String)
+ String toString()
+ String toBriefString()
}
 
 
class android.os.RecoverySystemInjector {
- {static} String TAG
+ {static} String calculateMD5(String)
+ {static} String checkForValidate(Context,String,boolean,String)
}
 
 
class android.os.statistics.SchedSuperviser {
}
class android.os.statistics.SchedSuperviser$SchedWaitFields {
- {static} String FIELD_WAKING_PID
- {static} String FIELD_WAKING_THREAD_ID
- {static} String FIELD_WCHAN
- {static} String FIELD_WAIT_REASON
- {static} String FIELD_INTERRUPTIBLE
+ int version
+ int wakingPid
+ int wakingThreadId
+ long wchan
+ String waitReason
+ boolean interruptible
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void resolveKernelLazyInfo()
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.SchedSuperviser$SchedWait {
+ {static} Parcelable.Creator<SchedWait> CREATOR
}
 
class android.os.statistics.SchedSuperviser$SchedWakeFields {
- {static} String FIELD_AWAKEN_PID
- {static} String FIELD_AWAKEN_THREAD_ID
+ String processName
+ int version
+ int awakenPid
+ int awakenThreadId
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.SchedSuperviser$SchedWake {
+ {static} Parcelable.Creator<SchedWake> CREATOR
}
 
class android.os.statistics.PerfEventConstants {
+ {static} int MAX_PERF_EVENT_PARCEL_SIZE
+ {static} int FLAG_ROOT_EVENT
+ {static} int FLAG_INITIATOR_POSITION_UNKNOWN
+ {static} int FLAG_INITIATOR_POSITION_SLAVE
+ {static} int FLAG_INITIATOR_POSITION_MASTER
+ {static} int FLAG_INITIATOR_POSITION_MASK
+ {static} int FLAG_HAS_PROC_LAZYINFO
+ {static} int FLAG_PROC_LAZYINFO_RESOLVED
+ {static} int FLAG_HAS_KERNEL_LAZYINFO
+ {static} int FLAG_KERNEL_LAZYINFO_RESOLVED
+ {static} int FLAG_BLOCKED
+ {static} int FLAG_BLOCKED_BY_SAME_PROCESS
+ {static} int FLAG_BLOCKED_BY_CROSS_PROCESS
+ {static} int FLAG_BLOCKED_BY_ONE_INCLUSIVE_BLOCKER
+ {static} int FLAG_BLOCKED_BY_ONE_COINCIDED_BLOCKER
+ {static} int FLAG_BLOCKED_BY_ONE_OVERLAPPED_BLOCKER
+ {static} int FLAG_BLOCKED_BY_MULTIBPLE_BLOCKER
+ {static} int FLAG_BLOCKER
+ {static} int FLAG_BLOCKER_TO_SAME_PROCESS
+ {static} int FLAG_BLOCKER_TO_CROSS_PROCESS
+ {static} int FLAG_USER_PERCEPTIBLE
+ {static} int FLAG_DETAILS_SOURCE_MASK
+ {static} int FLAG_NO_CHECK
+ {static} String FIELD_EVENT_TYPE
+ {static} String FIELD_EVENT_TYPE_NAME
+ {static} String FIELD_EVENT_FLAGS
+ {static} String FIELD_BEGIN_TIME
+ {static} String FIELD_END_TIME
+ {static} String FIELD_EVENT_SEQ
+ {static} String FIELD_PID
+ {static} String FIELD_PROCESS_NAME
+ {static} String FIELD_PACKAGE_NAME
+ {static} String FIELD_THREAD_ID
+ {static} String FIELD_THREAD_NAME
+ {static} String FIELD_SCHED_POLICY
+ {static} String FIELD_SCHED_PRIORITY
+ {static} String FIELD_RUNNING_TIME
+ {static} String FIELD_RUNNABLE_TIME
+ {static} String FIELD_SLEEPING_TIME
+ {static} String FIELD_END_REAL_TIME
+ {static} String FIELD_OCCUR_TIME
+ {static} int MICRO_EVENT_TYPE_START
+ {static} int TYPE_SINGLE_LOCK_HOLD
+ {static} int TYPE_SINGLE_LOCK_WAIT
+ {static} int TYPE_SINGLE_CONDITION_AWAKEN
+ {static} int TYPE_SINGLE_CONDITION_WAIT
+ {static} int TYPE_SINGLE_BINDER_CALL
+ {static} int TYPE_SINGLE_BINDER_EXECUTION
+ {static} int TYPE_SINGLE_TRACE_POINT
+ {static} int TYPE_SINGLE_SYSTEM_TRACE_EVENT
+ {static} int TYPE_SINGLE_LOOPER_MESSAGE
+ {static} int TYPE_SINGLE_INPUT_EVENT
+ {static} int TYPE_SINGLE_JNI_METHOD
+ {static} int TYPE_LOOPER_ONCE
+ {static} int TYPE_LOOPER_CHECKPOINT
+ {static} int TYPE_SCHED_WAIT
+ {static} int TYPE_SCHED_WAKE
+ {static} int TYPE_MM_SLOWPATH
+ {static} int MICRO_EVENT_TYPE_COUNT
+ {static} int MACRO_EVENT_TYPE_START
+ {static} int TYPE_SINGLE_EVENT_LOG_ITEM
+ {static} int TYPE_PLACE_HOLDER_1
+ {static} int TYPE_SINGLE_JANK_RECORD
+ {static} int TYPE_PLACE_HOLDER_2
+ {static} int TYPE_BINDER_STARVATION
+ {static} int TYPE_E2ESCENARIO_ONCE
+ {static} int TYPE_MEMORY_SLOWPATH
+ {static} int MACRO_EVENT_TYPE_COUNT
- {static} SparseArray<String> EVENT_TYPE_MAPPING
- {static} HashMap<String,Integer> EVENT_TYPE_CODE_MAPPING
+ {static} String getTypeName(int)
+ {static} int getTypeCode(String)
+ {static} boolean isBlockedBy(int,int)
}
 
 
class android.os.statistics.FilteringPerfEventCache {
- {static} int maxSize
- {static} int curSize
- {static} FilteringPerfEventListNode head
- {static} Object lock
+ {static} void setCapacity(int)
+ {static} FilteringPerfEvent obtain()
+ {static} void recycle(FilteringPerfEvent)
+ {static} void recycleUnchecked(FilteringPerfEvent)
+ {static} void recycleAllUnchecked(FilteringPerfEventList)
+ {static} void compact()
}
 
 
abstract class android.os.statistics.LooperCheckPointDetector {
- {static} int MESSAGE_DETECTING_CHECKPOINT
- {static} int FIRST_TIME_DETECT_DELAY_TIME_MS
- {static} int LATER_DETECT_DELAY_TIME_MS
- {static} HandlerThread mDetectingThread
- {static} DetectingHandler mDetectingHandler
~ {static} void start()
+ {static} void beginLoopOnce(int,long)
+ {static} void endLooperOnce()
}
 
 
class android.os.statistics.LooperCheckPointDetector$DetectingHandler {
- Object lockObject
- ArrayList<Thread> detectingThreads
+ void beginLoopOnce(int,long)
+ void endLooperOnce()
+ void handleMessage(Message)
- Message obtainDetectMessage(Thread,int,long)
- Thread decodeDetectingThread(Message)
- int decodeDetectingTid(Message)
- long decodeDetectingBeginUptimeMs(Message)
}
 
 
class android.os.AnrMonitor {
+ {static} boolean DBG
- {static} boolean MONITOR_MSG_EXECUTION
- {static} boolean NOT_CTS_BUILD
- {static} boolean sSystemBootCompleted
- {static} String TAG
- {static} String MONITOR_TAG
- {static} String DUMP_TRACE_TAG
- {static} String TRACE_DIR
- {static} java.util.Date DATE
- {static} SimpleDateFormat DATE_FORMATTER
- {static} String LINE_SEPARATOR
- {static} long MESSAGE_UPLOAD_CHECK_TIME
+ {static} long MESSAGE_MONITOR_TIMEOUT
+ {static} long MESSAGE_EXECUTION_TIMEOUT
+ {static} long LT_MESSAGE_CHECK_TIME
+ {static} int DEFAULT_MESSAGE_HISTORY_DUMP_DURATION
+ {static} int MAX_MESSAGE_SUMMARY_HISTORY
+ {static} long BINDER_CALL_MONITOR_TIMEOUT
+ {static} long PERF_EVENT_LOGGING_TIMEOUT
+ {static} long INPUT_MONITOR_TIMEOUT
+ {static} int INPUT_DISPATCHING_TIMEOUT
- {static} long DEFAULT_LOCK_WAIT_THRESHOLD
+ {static} long LOCK_WAIT_THRESHOLD
+ {static} int ANR_TRACES_LIMIT
+ {static} int ANR_INFO_LIMIT
+ {static} String ANR_DIRECTORY
+ {static} String ANR_INFO_HEAD
+ {static} String TRACES_HEAD
+ {static} String TRACES_FILE_TYPE
+ {static} long MAX_TIMEOUT
+ {static} long DUMP_MESSAGE_TIMEOUT
- {static} String sPkgName
- {static} String sProcessName
- {static} String sVersionName
- {static} int sVersionCode
- {static} Boolean sIsSystemApp
- {static} Object sInstanceSync
- {static} WorkHandler sWorkHandler
+ {static} String SEPARATOR
+ {static} String DUMP_APP_TRACE_TAG
- {static} int CHECK_PARCEL_SIZE_KB
- {static} boolean CHECK_PARCEL_SIZE_ENABLE
- {static} int sMsgRecordIndex
- {static} UploadInfo[] sUploadMsgRecords
- {static} int sInputRecordIndex
- {static} UploadInfo[] sUploadInputRecords
- {static} int sBinderRecordIndex
- {static} UploadInfo[] sUploadBinderRecords
- {static} SparseLongArray mInputEvnetStartTimeSeqMap
- {static} ArrayList<String> sMonitorList
- {static} String SCREEN_HAND_PROP
- {static} int SCREEN_HANG_TIMEOUT
- {static} Runnable mScreenHangRunnable
+ {static} boolean canMonitorAnr()
+ {static} String toCalendarTime(long)
+ {static} File createFile(String)
+ {static} File createFile(String,boolean)
+ {static} boolean isFileAvailable(File)
+ {static} void readFileToWriter(String,Writer)
+ {static} String readFile(File)
+ {static} void dumpBinderInfo(int,Writer)
+ {static} void dumpCpuInfo(int,Writer)
- {static} String getAnrPath(boolean,String)
+ {static} File dumpAnrInfo(StringBuilder,String,String,int,ArrayList<Integer>,SparseArray<Boolean>,String[],boolean,boolean)
- {static} boolean isAllowedMonitor(BaseLooper)
+ {static} boolean isAllowedMonitorBinderCallSize(int)
+ {static} boolean isAllowedMonitorBinderCall(BaseLooper)
+ {static} boolean isAllowedMonitorInput(BaseLooper)
+ {static} boolean isLongTimeMsg(BaseLooper.MessageMonitorInfo)
+ {static} void checkMsgTime(Message,BaseLooper.MessageMonitorInfo)
- {static} void addMessageToHistory(Message,BaseLooper.MessageMonitorInfo)
+ {static} void checkInputTime(long,InputEvent)
+ {static} void checkInputTime(InputEvent,InputEventReceiver,InputChannel)
+ {static} void dispatchInputEventStart(InputEvent)
- {static} void addInputToHistory(InputEvent,InputEventReceiver,InputChannel,long)
- {static} String inputEventToString(InputEvent)
- {static} String inputChannelToString(InputChannel)
+ {static} String currentPackageName()
~ {static} boolean isSystemServer()
~ {static} boolean isSystemApp()
~ {static} String currentProcessName()
~ {static} String currentThreadName()
~ {static} int currentVersionCode()
~ {static} String currentVersionName()
~ {static} void startMonitor(Message,BaseLooper.MessageMonitorInfo)
~ {static} void finishMonitor(Message,BaseLooper.MessageMonitorInfo)
~ {static} boolean canMonitorMessage()
+ {static} Handler getWorkHandler()
+ {static} void checkBinderCallTime(long)
- {static} void addBinderCallTimeToHistory(long)
- {static} String binderCallToString()
+ {static} void doDump(String)
- {static} boolean isSystemBootCompleted()
+ {static} void logAnr(String,Throwable)
+ {static} void logPerfEvent(String,PerfEvent)
+ {static} void logDumpTrace(String,Throwable)
+ {static} void renameTraces(String)
- {static} void deleteUnnecessaryFileIfNeeded(File,String,int)
+ {static} void screenHangMonitor(int,boolean,long)
}
 
 
class android.os.AnrMonitor$WorkHandler {
~ {static} int MONITOR_EXECUTION_TIMEOUT_MSG
~ {static} int REPORT_RECORDS
+ void handleMessage(Message)
}
 
 
class android.os.AnrMonitor$UploadInfo {
- {static} String JSON_PROCESS_NAME_TAG
- {static} String JSON_PACKAGE_NAME_TAG
- {static} String JSON_VERSION_NAME_TAG
- {static} String JSON_VERSION_CODE_TAG
- {static} String JSON_BASE_INFO_TAG
- {static} String JSON_INFO_ARRAY_TAG
- {static} String JSON_INFO_TAG
- {static} String JSON_THREAD_NAME_TAG
- {static} String JSON_TOOKTIME_TAG
~ String info
~ String processName
~ String packageName
~ String versionName
~ String versionCode
~ String threadName
~ long tookTime
+ String getInfo()
+ String getProcessName()
+ String getPackageName()
+ String getVersionName()
+ String getVersionCode()
+ String getThreadName()
+ long getTookTime()
+ String getKeyWord()
- {static} String createJsonString(UploadInfo[])
+ {static} String getMatchTag(UploadInfo)
+ {static} String getSaveContent(UploadInfo)
+ {static} UploadInfo getInfoByJsonString(String)
+ {static} String getBaseInfo(String)
+ {static} UploadInfo[] getInfoArray(String)
+ String toString()
}
 
 
class android.os.AnrMonitor$TimerThread {
- long timeout
- boolean completed
+ void run()
+ void finishRun()
+ void startAndWait()
}
 
 
class android.os.AnrMonitor$FileInfo {
- File mFile
- long mModifiedTime
+ File getFile()
+ long getModifiedTime()
+ int compareTo(FileInfo)
+ int compareTo(long,long)
}
 
 
class android.os.statistics.FilteringPerfEventListNode {
+ FilteringPerfEventListNode next
+ FilteringPerfEventListNode previous
+ FilteringPerfEvent value
}
 
class android.os.statistics.SystemTraceSuperviser {
+ {static} void beginTrace(long,String)
+ {static} void endTrace(long)
+ {static} void beginSupervisedTrace(long,String)
+ {static} void endSupervisedTrace(long,String,Object)
+ {static} void asyncBeginTrace(long,String,int)
+ {static} void asyncEndTrace(long,String,int)
+ {static} void asyncBeginSupervisedTrace(long,String,int)
+ {static} void asyncEndSupervisedTrace(long,String,int,Object)
}
 
abstract class android.os.statistics.PerfEvent {
+ {static} int TYPE_UNKNOWN
+ int eventType
+ int eventFlags
+ long beginUptimeMillis
+ long endUptimeMillis
+ long inclusionId
+ long synchronizationId
+ long eventSeq
- T details
- long persistentId
+ int describeContents()
+ void fillIn(int,long,long,long,long,long,JniParcel,Class[],StackTraceElement[],NativeBackTrace)
+ void fillInSeq(long)
+ void fillInDetails(JniParcel,Class[],StackTraceElement[],NativeBackTrace)
+ void resolveLazyInfo()
+ boolean isMeaningful()
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void readDetailsFromParcel(Parcel)
+ void resolveKernelLazyInfo()
+ JSONObject toJson()
+ void writeToJson(JSONObject)
+ T getDetailsFields()
+ long getPersistentId()
+ void setPersistentId(long)
+ void clearDetailFields()
+ {static} long generateCoordinationId(int,int)
+ {static} long generateCoordinationId(int)
}
 
 
class android.os.statistics.PerfEvent$DetailFields {
+ boolean needStackTrace
+ int pid
+ void fillIn(JniParcel)
+ void fillInStackTrace(Class[],StackTraceElement[],NativeBackTrace)
+ void resolveLazyInfo()
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void resolveKernelLazyInfo()
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.E2EScenario {
+ {static} String DEFAULT_CATEGORY
- {static} long serialVersionUID
+ String namespace
+ String category
+ String name
+ {static} Parcelable.Creator<E2EScenario> CREATOR
+ void normalize(String)
+ boolean equals(Object)
+ int hashCode()
+ boolean isValid()
+ int describeContents()
+ void writeToParcel(Parcel,int)
+ JSONObject toJson()
}
 
 
class android.os.statistics.E2EScenarioOnce {
+ {static} Parcelable.Creator<E2EScenarioOnce> CREATOR
}
 
class android.os.statistics.E2EScenarioOnce$E2EScenarioOnceDetails {
+ long scenarioOnceId
+ E2EScenario scenario
+ E2EScenarioSettings settings
+ String tag
+ E2EScenarioPayload payload
+ boolean isCharging
+ int batteryLevel
+ int batteryTemperature
+ long beginWalltimeMillis
+ int beginPid
+ int beginTid
+ String beginProcessName
+ String beginPackageName
+ long endWalltimeMillis
+ int endPid
+ int endTid
+ String endProcessName
+ String endPackageName
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.InputEventSuperviser {
+ {static} void beginInputEvent(InputEvent)
+ {static} void beginInputEvent(InputEvent,int)
+ {static} void endInputEvent(InputEvent,InputEventReceiver,InputChannel)
+ {static} void endInputEvent(InputEvent,int,InputEventReceiver,InputChannel)
}
 
class android.os.statistics.StackUtils {
+ {static} String[] emptyStack
+ {static} JSONArray emptyJsonedStack
- {static} int MAX_STACK_DEPTH
- {static} int MAX_STACK_LENGH
- {static} String[] suggestedStackTopMethodFullNames
- {static} Class[] topClasses
- {static} ArrayList[] topClassMethodSimpleNames
- {static} StringBuilder sStackTraceStringBuilder
- {static} AtomicBoolean sStackTraceStringBuilderBusy
+ {static} String[] getStackTrace(StackTraceElement[],Class[],String[])
+ {static} String[] getStackTrace(JSONArray)
}
 
 
class android.os.MiuiMonitorThread {
- {static} String TAG
- {static} MiuiMonitorThread mInstance
- {static} Handler mHandler
- {static} void ensureThreadLocked()
+ {static} MiuiMonitorThread getThread()
+ {static} Handler getHandler()
}
 
 
class android.os.DynamicEffect {
+ {static} String TAG
- {static} int PARCEL_TOKEN_DYNAMIC
+ {static} int INTENSITY
+ {static} int SHARPNESS
- {static} int TRANSIENT
- {static} int CONTINUOUS
- {static} int VERSION_MIHAPTIC
- {static} int VERSION_VHAPTIC
+ int mLoop
+ int mInterval
+ int version
+ int globalIntensity
+ int globalSharpness
+ ArrayList<Curve> mGlobalCurve
+ ArrayList<PrimitiveEffect> mEffects
- {static} String vhapticVersion
- int[] patternHeInfo
- {static} AtomicInteger mSeq
- {static} String PATTERN_KEY_PATTERN
- {static} String EVENT_TYPE_HE_CONTINUOUS_NAME
- {static} String EVENT_TYPE_HE_TRANSIENT_NAME
- {static} String EVENT_KEY_EVENT
- {static} String EVENT_KEY_RELATIVE_TIME
- {static} String EVENT_KEY_DURATION
- {static} String EVENT_KEY_HE_TYPE
- {static} String EVENT_KEY_HE_PARAMETERS
- {static} String EVENT_KEY_HE_INTENSITY
- {static} String EVENT_KEY_HE_FREQUENCY
- {static} String EVENT_KEY_HE_CURVE
- {static} String EVENT_KEY_HE_CURVE_POINT_TIME
- {static} int CONTINUOUS_EVENT
- {static} int TRANSIENT_EVENT
- {static} int MAX_PATERN_EVENT_LAST_TIME
- {static} int MAX_PATERN_LAST_TIME
- {static} int MAX_INTENSITY
- {static} int MAX_FREQ
- {static} int MAX_EVENT_COUNT
- {static} int MAX_POINT_COUNT
- {static} String PATTERN_KEY_PATTERN_LIST
- {static} String HE_META_DATA_KEY
- {static} String HE_VERSION_KEY
- {static} String PATTERN_KEY_PATTERN_ABS_TIME
- {static} String PATTERN_KEY_EVENT_VIB_ID
- {static} boolean DEBUG
- int[] encapsulated
+ {static} Parcelable.Creator<DynamicEffect> CREATOR
+ {static} PrimitiveEffect createTransient(float,float)
+ {static} PrimitiveEffect createContinuous(float,float,float)
+ DynamicEffect addPrimitive(float,PrimitiveEffect)
+ DynamicEffect addParameter(float,Parameter)
+ {static} Parameter createParameter(int,float[],float[])
+ {static} DynamicEffect create()
+ void clear()
- {static} boolean between(int,int,int)
- {static} PrimitiveEffect parsePrimitive(JSONObject)
- {static} Parameter parseParameter(JSONObject)
+ {static} DynamicEffect create(String,float)
- {static} int[] generateSerializationDataHe(int,int,int,Pattern[])
- {static} int[] getSerializationDataHe_1_0(String,int,int)
- {static} int[] getSerializationDataHe_2_0(String,int,int)
+ {static} DynamicEffect create(String)
+ {static} DynamicEffect create(int[])
+ long getDuration()
+ long getDuration(SparseArray<VibratorInfo>)
+ void validate()
+ boolean hasVendorEffects()
+ boolean equals(Object)
+ int hashCode()
+ String toString()
+ int[] encapsulate()
+ void writeToParcel(Parcel,int)
+ DynamicEffect scale(float)
+ DynamicEffect resolve(int)
+ int describeContents()
+ boolean hasVibrator(int)
+ CombinedVibration adapt(VibratorAdapter)
+ String toDebugString()
+ CombinedVibration transform(VibrationEffect.Transformation<ParamT>,ParamT)
}
 
 
class android.os.DynamicEffect$PrimitiveEffect {
+ int mType
+ int mRelativeTime
+ int mIntensity
+ int mSharpness
+ int mDuration
+ List<Curve> mCurves
+ PrimitiveEffect addParameter(Parameter)
+ boolean equals(Object)
}
 
 
class android.os.DynamicEffect$Curve {
+ int mType
+ int mRelativeTime
+ ArrayList<Integer> mTimings
+ ArrayList<Integer> mValues
+ boolean equals(Object)
}
 
 
class android.os.DynamicEffect$Parameter {
+ Curve mCurve
}
 
abstract class android.os.Event {
~ int mType
~ int mLen
~ int mVibId
~ int mRelativeTime
~ int mIntensity
~ int mFreq
~ int mDuration
~ {abstract}int[] generateData()
+ String toString()
}
 
 
class android.os.TransientEvent {
~ int[] generateData()
}
 
class android.os.Point {
~ int mTime
~ int mIntensity
~ int mFreq
}
 
class android.os.ContinuousEvent {
~ int mPointNum
~ Point[] mPoint
~ int[] generateData()
+ String toString()
}
 
 
class android.os.Pattern {
~ int CONTINUOUS_EVENT
~ int TRANSIENT_EVENT
~ int mRelativeTime
~ Event[] mEvent
~ int getPatternEventLen()
~ int getPatternDataLen()
~ int[] generateSerializationPatternData(int)
}
 
 
class android.os.MiuiProcess {
+ {static} int BACKUP_UID
+ {static} int THEME_UID
+ {static} int UPDATER_UID
+ {static} int FINDDEVICE_UID
+ {static} int CAMERAMIND_UID
+ {static} int HYPERENGINE_UID
+ {static} int THREAD_GROUP_DEFAULT
+ {static} int THREAD_GROUP_FOREGROUND
+ {static} int THREAD_GROUP_TOP_APP
+ {static} int THREAD_GROUP_FG_SERVICE
+ {static} int THREAD_GROUP_FG_LIMITED
+ {static} int SCHED_RESET_ON_FORK
- {static} String TAG
+ {static} int SCHED_MODE_NORMAL
+ {static} int SCHED_MODE_ANIMATOR_RT
+ {static} int SCHED_MODE_TOUCH_RT
+ {static} int SCHED_MODE_ALWAYS_RT
+ {static} int SCHED_MODE_HOME_ANIMATION
+ {static} int SCHED_MODE_UNLOCK
+ {static} int SCHED_MODE_SCROLL_NOTIFICATION
+ {static} int SCHED_MODE_BIND_BIG_CORE
+ {static} int SCHED_MODE_COLD_START
+ {static} int SCHED_MODE_SYS_ANIM
+ {static} int SCHED_MODE_LANDSCAPE_TO_RECENT_ANIM
+ {static} int SCHED_MODE_ONE_KEY_CLEAN_ANIM
+ {static} int SCHED_MODE_SET_RT
+ {static} int SCHED_MODE_RESET_RT
+ {static} int SCHED_MODE_START_WIN_RT
+ {static} int SCHED_MODE_BOOST_GPU_FREQ
+ {static} int SCHED_MODE_APP_START_QOS
+ {static} int SCHED_MODE_BOTH_RT
+ {static} long LAUNCH_RT_SCHED_DURATION_MS
+ {static} long MAX_RT_SCHED_DURATION_MS
+ {static} long LITE_ANIM_SCHED_DURATION_MS
+ {static} long TOUCH_RT_SCHED_DURATION_MS
+ {static} long SCROLL_RT_SCHED_DURATION_MS
+ {static} int PROPERTY_CPU_CORE_COUNT
+ {static} int[] BIG_CORES_INDEX
+ {static} int[] BIG_PRIME_CORES_INDEX
+ {static} boolean setThreadPriority(int,int,String)
+ {static} void setThreadPriority(int,String)
+ {static} int getThreadPriority(int,String)
+ {static} boolean scheduleAsFifoAndForkPriority(int,boolean)
+ {static} boolean scheduleAsFifoPriority(int,int,boolean)
+ {static} boolean is32BitApp(Context,String)
+ {static} int schedCodeToOpcode(int)
- {static} int[] loadCoresProperty(String)
}
 
 
class android.os.MiuiProcess$Boost {
+ {static} int WARM_LAUNCH
+ {static} int COLD_LAUNCH
}
 
class android.os.NativeTurboSchedManager {
- {static} String TAG
+ {static} int nativeOpenDevice(String)
+ {static} void nativeCloseDevice(int)
+ {static} void nativeIoctlDevice(int,int)
+ {static} void nativeSetDynamicVip(int,int,int,int)
+ {static} void nativeCleanDynamicVip(int,int,int)
+ {static} void nativeTaskBoost(int,int,int)
+ {static} void nativeSetNotification(int,int)
+ {static} void nativeMiGroupAppStatusChange(int,int,int,int)
+ {static} void nativeMiGroupCreateLatencyGroup(int,int,int,int,int)
+ {static} void nativeMiGroupDestoryLatencyGroup(int,int)
+ {static} void nativeMiGroupChangeLatencyGroup(int,int,int,int)
+ {static} void nativeMiGroupFgAppFpsChange(int,int,int)
+ {static} void nativeMiGroupTaskFpsChange(int,int,int)
+ {static} void nativeMiFrameVsyncTouch(int)
+ {static} void nativeMiFrameFpsChange(int,int,int)
}
 
 
class android.os.spc.PSIEventSocketReader {
+ {static} int MAX_BUFFER_SIZE
- ParcelFileDescriptor mPSISockFd
- PSIEventListener mListener
+ void startMonitor()
- boolean readDataFromSocket(InputStream)
}
 
 
interface android.os.spc.PSIEventSocketReader$PSIEventListener {
~ void onReceive(PSIEvent)
}
 
class android.os.StrictModeInjector {
- {static} ArrayList<String> mWhiteList
+ {static} boolean isSkipStrictModeCheck(Throwable)
- {static} List<String> parseStack(Throwable)
}
 
 
class android.os.statistics.E2EScenarioPayload {
- {static} long serialVersionUID
- HashMap<String,String> values
+ {static} Parcelable.Creator<E2EScenarioPayload> CREATOR
+ void mergeFrom(E2EScenarioPayload)
+ Object clone()
+ boolean isEmpty()
+ void putValues(Object)
+ void putAll(Map)
+ void put(Object,Object)
+ String get(String)
+ int describeContents()
+ void writeToParcel(Parcel,int)
+ JSONObject toJson()
+ void writeToBundle(android.os.Bundle)
}
 
 
class android.os.statistics.E2EScenarioSettings {
+ {static} int STATISTICS_MODE_NONE
+ {static} int STATISTICS_MODE_AVERAGE
+ {static} int STATISTICS_MODE_HISTORY
+ {static} int STATISTICS_MODE_DISTRIBUTION
+ {static} int STATISTICS_MODE_ALL
- {static} long serialVersionUID
+ int statisticsMode
+ int historyLimitPerDay
+ boolean isAutoAnalysisEnabled
+ int slownessFloorThresholdMillis
+ int timeoutMillisOfAutoAnalysis
+ {static} Parcelable.Creator<E2EScenarioSettings> CREATOR
+ boolean isValid()
+ Object clone()
+ void setStatisticsMode(int)
+ void setHistoryLimitPerDay(int)
+ void enableAutoAnalysis(int,int)
+ int describeContents()
+ void writeToParcel(Parcel,int)
}
 
 
class android.os.statistics.PerfSuperviser {
+ {static} String TAG
+ {static} boolean DEBUGGING
+ {static} int MY_PID
+ {static} String processName
+ {static} String packageName
- {static} boolean sInitialized
- {static} boolean sStarted
+ {static} void init(boolean,boolean)
+ {static} void start(boolean)
+ {static} void start(boolean,String)
+ {static} void updateProcessInfo(String,String)
- {static} void nativeInit(boolean,boolean,int,int,int,int,int)
- {static} void nativeStart(boolean,boolean,int)
- {static} void nativeUpdateProcessInfo(String,String)
+ {static} void setThreadPerfSupervisionOn(boolean)
}
 
 
class android.os.statistics.LooperCheckPoint {
+ {static} Parcelable.Creator<LooperOnce> CREATOR
}
 
class android.os.statistics.PerfTracer {
+ {static} void beginTracePoint(String)
+ {static} void endTracePoint(String)
+ {static} void endTracePoint(String,int)
+ {static} void endTracePoint(String,long)
+ {static} void endTracePoint(String,long,int)
+ {static} void endTracePoint(String,Object)
+ {static} void endTracePoint(String,Object,int)
+ {static} void endTracePoint(String,long,Object)
+ {static} void endTracePoint(String,long,Object,int)
}
 
class android.os.statistics.ParcelUtils {
- {static} String TAG
- {static} int MAX_STRING_ARRAY_LENGTH
+ {static} void writeStringArray(Parcel,String[])
+ {static} String[] readStringArray(Parcel)
}
 
 
class android.os.statistics.SingleJankRecord {
+ {static} Parcelable.Creator<SingleJankRecord> CREATOR
}
 
class android.os.statistics.SingleJankRecord$JankRecordFields {
- {static} String FIELD_RENDER_THREAD_ID
- {static} String FIELD_WINDOW_NAME
- {static} String FIELD_APP_CAUSE
- {static} String FIELD_SYS_CAUSE
- {static} String FIELD_CONCLUSION
- {static} String FIELD_TOTAL_DURATION
- {static} String FIELD_MAX_FRAME_DURATION
- {static} String FIELD_RECEIVED_UPTIME
- {static} String FIELD_RECEIVED_CURRENT_TIME
- {static} String FIELD_NUM_FRAMES
- {static} String FIELD_CHARGING
- {static} String FIELD_BATTERY_LEVEL
- {static} String FIELD_BATTERY_TEMP
+ String processName
+ String packageName
+ int renderThreadTid
+ long totalDuration
+ long maxFrameDuration
+ long numFrames
+ String windowName
+ String appCause
+ String sysCause
+ String conclusion
+ long receivedUptimeMillis
+ long receivedCurrentTimeMillis
+ boolean isCharging
+ int batteryLevel
+ int batteryTemperature
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.BinderServerMonitor {
+ {static} String PERFSHIELDER_SERVICE_NAME
- {static} String TAG
- {static} boolean DEBUG
- {static} int MAX_RECORDS_QUEUE_CAPACITY
- {static} boolean isEnabled
- {static} int mExcessiveCpuUsageThershold
- {static} HashMap<Integer,Long> mBinderClientCpuUsages
- {static} LinkedList<Bundle> mExcessiveCpuUsageRecords
- {static} IPerfShielder mPerfService
+ {static} void start()
+ {static} int getExcessiveCpuUsageThreshold()
+ {static} void updateBinderClientCpuUsages()
+ {static} HashMap<Integer,Long> getBinderClientCpuUsages()
+ {static} void recordExcessiveCpuUsage(String,int,int,int,long,long,long,boolean)
+ {static} int computeCpuUsage(long,long)
+ {static} long clearBinderClientCpuTimeUsed(int)
~ {static} void dumpBinderClientCpuTimeUsed(HashMap)
~ {static} void nativeStart()
}
 
 
class android.os.statistics.BinderServerMonitor$CpuUsageInfo {
+ int pid
+ int uid
+ String procName
+ int procState
+ long duration
+ long runningTime
+ long binderCpuTime
+ double cpuUsage
+ long currentTimeMills
+ String toString()
+ Bundle toBundle()
}
 
 
class android.os.statistics.PerfEventFactory {
- {static} int MACRO_EVENT_TYPE_INDEX_OFFSET
+ {static} PerfEvent createPerfEvent(int,int,long,long,long,long,long,JniParcel,Class[],StackTraceElement[],NativeBackTrace)
+ {static} PerfEvent createPerfEvent(int,int,long,long,long,long,long)
+ {static} PerfEvent createPerfEvent(int)
}
 
 
class android.os.statistics.LooperOnce {
+ {static} Parcelable.Creator<LooperOnce> CREATOR
}
 
class android.os.statistics.BinderSuperviser {
- {static} String getInterfaceDescriptor(Object)
}
 
class android.os.statistics.BinderSuperviser$BinderWrapper {
- long mObject
+ String getInterfaceDescriptor()
# void finalize()
- void destroy()
}
 
 
class android.os.statistics.BinderSuperviser$BinderStarvationDetails {
- {static} String FIELD_MAX_THREADS
+ int maxThreads
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.BinderSuperviser$BinderStarvation {
+ {static} Parcelable.Creator<BinderStarvation> CREATOR
}
 
class android.os.statistics.BinderSuperviser$BinderCallFields {
- {static} String FIELD_INTERFACE_DESCRIPTOR
- {static} String FIELD_CODE
- {static} String FIELD_STACK
- {static} Class<?> sBinderProxyClass
+ String processName
+ String packageName
+ String interfaceDescriptor
+ int code
+ String[] stackTrace
+ void fillIn(JniParcel)
+ void fillInStackTrace(Class[],StackTraceElement[],NativeBackTrace)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
- {static} void initClasses()
- {static} boolean isJavaBinderCall(StackTraceElement[],Class[])
}
 
 
class android.os.statistics.BinderSuperviser$SingleBinderCall {
+ {static} Parcelable.Creator<SingleBinderCall> CREATOR
}
 
class android.os.statistics.BinderSuperviser$BinderExecutionFields {
- {static} String FIELD_INTERFACE_DESCRIPTOR
- {static} String FIELD_CODE
- {static} String FIELD_CALLING_PID
+ String interfaceDescriptor
+ int code
+ int callingPid
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.BinderSuperviser$SingleBinderExecution {
+ {static} Parcelable.Creator<SingleBinderExecution> CREATOR
}
 
class android.os.statistics.StringDictTree {
+ boolean find(String)
}
 
class android.os.statistics.TreeNode {
- HashMap<Character,TreeNode> mChildNodes
- String mString
~ void insert(String,int)
- void insertToChild(String,int)
~ boolean find(String,int)
~ boolean isTerminal()
}
 
 
class android.os.statistics.DeviceKernelPerfEvents {
+ {static} boolean initDeviceKernelPerfEvents()
+ {static} boolean waitForDeviceKernelPerfEventArrived(int)
+ {static} int fetchDeviceKernelPerfEvents(FilteringPerfEvent[])
}
 
class android.os.statistics.MemorySuperviser {
}
class android.os.statistics.MemorySuperviser$SlowpathFields {
- {static} String FIELD_ORDER
+ int version
+ int order
+ void fillIn(JniParcel)
+ void writeToParcel(Parcel,int)
+ void readFromParcel(Parcel)
+ void writeToJson(JSONObject)
}
 
 
class android.os.statistics.MemorySuperviser$Slowpath {
+ {static} Parcelable.Creator<Slowpath> CREATOR
}
 
class android.os.statistics.PerfEventReporter {
- {static} boolean DEBUGGING
- {static} int MAX_RETRY_WRITE_COUNT
~ {static} void start()
+ {static} void report(PerfEvent)
+ {static} long getEarliestBeginUptimeMillisOfExecutingRootEvents()
- {static} void nativeReport(int,PerfEvent)
- {static} void waitForPerfEventArrived(int)
- {static} int fetchProcUserspacePerfEvents(FilteringPerfEvent[])
- {static} int fetchProcKernelPerfEvents(FilteringPerfEvent[])
}
 
 
class android.os.statistics.PerfEventReporter$ProcPerfEventReaderThread {
- {static} ProcPerfEventReaderThread sInstance
- int myTid
- FilteringPerfEvent[] mPerfEventFetchingBuffer
- long latestSendUptimeMillis
- int maxEventCountOfOneBatch
- FilteringPerfEventList mEffectivePerfEvents
- FilteringPerfEventList mSuspectedPerfEvents
+ {static} ProcPerfEventReaderThread getInstance()
+ boolean hasPendingPerfEvents()
+ void run()
- void loopOnce()
- void fetchPerfEventsFromBuffer(FilteringPerfEventList,FilteringPerfEventList)
- void dividePerfEventsFromBuffer(int,FilteringPerfEventList,FilteringPerfEventList)
}
 
 
class android.os.statistics.PerfEventReporter$ProcPerfEventFilterThread {
- {static} ProcPerfEventFilterThread sInstance
- ParcelFileDescriptor mPerfEventSocketFd
- int mPerfEventSocketFdNo
- Parcel mSendingParcel
- long mSendingParcelNativePtr
- int myTid
- long mEarliestBeginUptimeMillisOfExecutingRootEvents
- FilteringPerfEventList mReceivedEffectiveEvents
- FilteringPerfEventList mReceivedSuspectedEvents
- boolean mNeedFilter
- Object mLock
- TimeslicedCompletedEventList tempCompletedEvents
- PerfEventFilter perfEventFilter
- PerfEvent[] mPerfEventObjectCache
- {static} int MACRO_EVENT_TYPE_INDEX_OFFSET
+ {static} ProcPerfEventFilterThread getInstance()
+ void send(FilteringPerfEventList,FilteringPerfEventList,long)
+ void run()
- void loopOnce()
- void obtainPerfEventSocketFd()
- void sendPerfEvents(TimeslicedCompletedEventList)
- void sendPerfEvents(TimeslicedCompletedEventList,FilteringPerfEventList)
- void sendPerfEvent(FilteringPerfEvent)
- PerfEvent obtainPerfEvent(int)
- boolean sendPerfEventParcel(Parcel,long)
}
 
 
abstract class android.os.BaseLooper {
- {static} boolean DEBUG
- {static} String TAG
- {static} String TAG_LOOPER
- {static} int THREASHOLD_LATE_ACTIVITY_MS
- {static} int THREASHOLD_LATE_FRAME_MS
- {static} int THREASHOLD_MSG_PROCESS_MS
- {static} int THRESHOLD_SLOW_INPUT_MS
- {static} int DELAY_NUMS
- {static} int DELAY_BLKIO_INDEX
- {static} int DELAY_SWAPIN_INDEX
- {static} int DELAY_FREEPAGES_INDEX
- {static} int DELAY_RUNNING_TIME_INDEX
- {static} int DELAY_RUNNABLE_TIME_INDEX
- {static} int MSG_QUEUE_SIZE
- {static} int DEFAULT_MESSAGE_HISTORY_DUMP_DURATION
- Message mRunningMessage
- MessageMonitorInfo mRunningMessageInfo
- MessageMonitorInfo[] mLongMsgHistoryQueue
- int mLongMsgIndexNext
- MessageMonitorInfo[] mMsgHistoryQueue
- int mMsgIndexNext
- Object mMsgLock
- long mNextSeq
- boolean mEnableMonitor
- boolean mEnableMonitorMessage
- boolean mEnableAnrMonitor
- {static} ArrayList<WeakReference<BaseLooper>> sCallbacks
- {static} Object sCallbacksLock
+ boolean isMonitorLooper()
+ void enableMonitor(boolean)
+ void enableMonitorMessage(boolean)
~ boolean isMonitorAnr()
~ void enableAnrMonitor(boolean)
- void updateCallbackIfNeed(boolean)
~ void markDispatch(Message,MessageMonitorInfo)
~ void markFinish(Message,MessageMonitorInfo)
- void checkMsg(Message,MessageMonitorInfo)
- void checkEssentialMsg(Message,MessageMonitorInfo)
- {static} boolean isDoFrame(Message)
- void checkDoFrame(Message,MessageMonitorInfo)
- {static} boolean isActivityTrancaction(Message)
- void checkActivityLifecycle(Message,MessageMonitorInfo)
+ void checkInputEvent(InputEvent)
- void addMessageToHistoryIfNeed(MessageMonitorInfo)
- {static} int ringAdvance(int,int,int)
- List<MessageMonitorInfo> getHistoryMsgInfos(long)
+ {static} String formatCurrentTime(long)
+ {abstract}MessageQueue getQueue()
- void dumpLtMessageHistory(PrintWriter,String,long)
- void dumpRunningMessage(PrintWriter,String)
- void dumpMessageQueue(PrintWriter,String)
- void dumpInternal(PrintWriter,String,long,boolean)
+ void dumpAllLoopers(PrintWriter,String)
+ String dumpAll(String)
+ String dumpAll(String,long)
+ void logLateFrameIfNeed(long,long)
~ {static} String messageToString(Message)
+ {static} long nGetThreadCpuTime()
+ {static} void nGetThreadDelay(long[])
}
 
 
class android.os.BaseLooper$MessageMonitorInfo {
~ String targetName
~ String callbackName
~ int msgWhat
# long mSeq
~ long planTime
~ long planCurrentTime
~ long dispatchTime
~ long dispatchCurrentTime
~ long finishTime
~ long dispatchBlkioDelay
~ long finishBlkioDelay
~ long dispatchSwapinDelay
~ long finishSwapinDelay
~ long dispatchReclaimDelay
~ long finishReclaimDelay
~ long dispatchRunningTime
~ long finishRunningTime
~ long dispatchRunnableTime
~ long finishRunnableTime
+ {static} Parcelable.Creator<MessageMonitorInfo> CREATOR
~ void init(Message,long)
~ void reset()
~ void markDispatch(Message)
~ void markFinish(Message)
~ boolean isFinished()
~ long getLatencyMillis()
~ long getWallMillis()
~ long getTotalMillis()
~ long getBlkioDelay()
~ long getSwapinDelay()
~ long getReclaimDelay()
~ long getRunningTime()
~ long getRunnableTime()
+ String toString()
~ String getShortTime()
~ String toShortString()
~ long getTookTime()
~ long getTookTimeAfterDispatch()
~ String getMessageSummary(Message)
~ String createMonitorDigest()
~ String getMonitorMessage()
~ String getMonitorDigest()
+ int describeContents()
+ void writeToParcel(Parcel,int)
}
 
 
class android.os.statistics.FilteringPerfEventList {
+ int size
+ void detachElements()
+ void addLast(FilteringPerfEvent)
+ void addAfter(FilteringPerfEventListNode,FilteringPerfEvent)
+ void remove(FilteringPerfEvent)
+ FilteringPerfEvent pollFirst()
~ FilteringPerfEvent pollFirstUnchecked()
+ void moveAllFrom(FilteringPerfEventList)
}
 
 
class android.os.statistics.NativeBackTrace {
- {static} boolean nativeBacktraceMapUpdated
- long mNativePtr
# void finalize()
+ void dispose()
+ String[] resolve()
- {static} void nativeDispose(long)
- {static} int nativeUpdateBacktraceMap()
- {static} String[] nativeResolve(long)
+ {static} String[] resolve(NativeBackTrace)
+ {static} int updateBacktraceMap()
+ {static} void reset()
}
 
 
class android.os.spc.PressureState {
+ {static} long NS_PER_MS
- PressureListener mListener
- Object mQueueLock
- LinkedList<PSIEvent> mEventQueue
- long mPressureStallDurationMillis
- State mCurState
- String mName
- long mWindowNs
- long mPressureThreshold
+ String getName()
+ void setListener(PressureListener)
+ void addPSIEvent(PSIEvent)
+ void clearPSIEvents()
- void pruneLatencyEvents(long)
- void updateCurrentState()
}
 
 
enum android.os.spc.State {
+  NON_PRESSURE
+  HIGH_PRESSURE
}
 
interface android.os.spc.PressureState$PressureListener {
+ void onStateChanged(State,State)
}
 
interface android.os.ILooperMonitorable {
+ boolean isMonitorLooper()
+ void enableMonitor(boolean)
}
 
class android.os.NativeMiuiMemReclaimer {
- {static} String TAG
+ {static} void compactProcess(int,int)
}
 
 
 
 
android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface +.. android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenario
android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface +.. android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenarioSettings
android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface +.. android.os.statistics.appinterfaceexample.E2EScenarioPerfTracerInterface$E2EScenarioPayload
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IActivityManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IWindowManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$ITelephonyRegistry
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IDisplayManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$ITofManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IOpsCallback
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IUiModeManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IInputMethodManager
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IMiuiSynergy
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IMiuiHeartRate
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$ILockSettings
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IClipboard
android.os.MiuiBinderTransaction +.. android.os.MiuiBinderTransaction$IMiuiFaceManager
android.os.statistics.PerfEvent <|-- android.os.statistics.MicroscopicEvent
android.os.statistics.MicroscopicEvent +.. android.os.statistics.MicroscopicEvent$MicroEventFields
android.os.statistics.DetailFields <|-- android.os.statistics.MicroscopicEvent$MicroEventFields
android.os.statistics.MicroscopicEvent +.. android.os.statistics.MicroscopicEvent$BlockedEventFields
android.os.statistics.MicroEventFields <|-- android.os.statistics.MicroscopicEvent$BlockedEventFields
android.os.statistics.MicroscopicEvent +.. android.os.statistics.MicroscopicEvent$BlockerEventFields
android.os.statistics.MicroEventFields <|-- android.os.statistics.MicroscopicEvent$BlockerEventFields
android.os.statistics.MicroscopicEvent +.. android.os.statistics.MicroscopicEvent$MeasurementEventFields
android.os.statistics.MicroEventFields <|-- android.os.statistics.MicroscopicEvent$MeasurementEventFields
android.os.statistics.MicroscopicEvent +.. android.os.statistics.MicroscopicEvent$RootEventFields
android.os.statistics.MicroEventFields <|-- android.os.statistics.MicroscopicEvent$RootEventFields
android.os.statistics.EventLogSuperviser +.. android.os.statistics.EventLogSuperviser$EventLogTags
android.os.statistics.EventLogSuperviser +.. android.os.statistics.EventLogSuperviser$SingleEventLogItem
android.os.statistics.MacroscopicEvent <|-- android.os.statistics.EventLogSuperviser$SingleEventLogItem
android.os.statistics.EventLogSuperviser +.. android.os.statistics.EventLogSuperviser$EventLogFields
android.os.statistics.DetailFields <|-- android.os.statistics.EventLogSuperviser$EventLogFields
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.SingleJniMethod
android.os.statistics.SingleJniMethod +.. android.os.statistics.SingleJniMethod$JniMethodFields
android.os.statistics.MicroEventFields <|-- android.os.statistics.SingleJniMethod$JniMethodFields
android.os.statistics.FilteringPerfEventListNode <|-- android.os.statistics.FilteringPerfEvent
android.os.statistics.PerfEvent <|-- android.os.statistics.MacroscopicEvent
android.os.statistics.LooperMessageSuperviser +.. android.os.statistics.LooperMessageSuperviser$SingleLooperMessage
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.LooperMessageSuperviser$SingleLooperMessage
android.os.statistics.LooperMessageSuperviser +.. android.os.statistics.LooperMessageSuperviser$SingleLooperMessageFields
android.os.statistics.RootEventFields <|-- android.os.statistics.LooperMessageSuperviser$SingleLooperMessageFields
android.os.statistics.PerfEventFilter +.. android.os.statistics.PerfEventFilter$TimeslicedFilteringPerfEventList
android.os.statistics.PerfEventFilter +.. android.os.statistics.PerfEventFilter$TimeslicedCompletedEventList
android.os.statistics.TimeslicedFilteringPerfEventList <|-- android.os.statistics.PerfEventFilter$TimeslicedCompletedEventList
android.os.statistics.PerfEventFilter +.. android.os.statistics.PerfEventFilter$TimeslicedCheckingEventList
android.os.statistics.TimeslicedFilteringPerfEventList <|-- android.os.statistics.PerfEventFilter$TimeslicedCheckingEventList
android.os.statistics.PerfEventFilter +.. android.os.statistics.PerfEventFilter$LeveledCheckingEventList
android.os.ILooperMonitorable <|.. android.os.LooperMonitor
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleLockHold
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.MonitorSuperviser$SingleLockHold
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleLockWait
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.MonitorSuperviser$SingleLockWait
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleConditionAwaken
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.MonitorSuperviser$SingleConditionAwaken
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleConditionWait
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.MonitorSuperviser$SingleConditionWait
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleMonitorWaitFields
android.os.statistics.BlockedEventFields <|-- android.os.statistics.MonitorSuperviser$SingleMonitorWaitFields
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleMonitorReadyFields
android.os.statistics.BlockerEventFields <|-- android.os.statistics.MonitorSuperviser$SingleMonitorReadyFields
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleConditionWaitFields
android.os.statistics.SingleMonitorWaitFields <|-- android.os.statistics.MonitorSuperviser$SingleConditionWaitFields
android.os.statistics.MonitorSuperviser +.. android.os.statistics.MonitorSuperviser$SingleConditionAwakenFields
android.os.statistics.SingleMonitorReadyFields <|-- android.os.statistics.MonitorSuperviser$SingleConditionAwakenFields
android.os.statistics.SchedSuperviser +.. android.os.statistics.SchedSuperviser$SchedWaitFields
android.os.statistics.BlockedEventFields <|-- android.os.statistics.SchedSuperviser$SchedWaitFields
android.os.statistics.SchedSuperviser +.. android.os.statistics.SchedSuperviser$SchedWait
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.SchedSuperviser$SchedWait
android.os.statistics.SchedSuperviser +.. android.os.statistics.SchedSuperviser$SchedWakeFields
android.os.statistics.BlockerEventFields <|-- android.os.statistics.SchedSuperviser$SchedWakeFields
android.os.statistics.SchedSuperviser +.. android.os.statistics.SchedSuperviser$SchedWake
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.SchedSuperviser$SchedWake
android.os.statistics.LooperCheckPointDetector +.. android.os.statistics.LooperCheckPointDetector$DetectingHandler
android.os.statistics.Handler <|-- android.os.statistics.LooperCheckPointDetector$DetectingHandler
android.os.AnrMonitor +.. android.os.AnrMonitor$WorkHandler
android.os.Handler <|-- android.os.AnrMonitor$WorkHandler
android.os.AnrMonitor +.. android.os.AnrMonitor$UploadInfo
android.os.AnrMonitor +.. android.os.AnrMonitor$TimerThread
android.os.Thread <|-- android.os.AnrMonitor$TimerThread
android.os.AnrMonitor +.. android.os.AnrMonitor$FileInfo
android.os.Comparable <|.. android.os.AnrMonitor$FileInfo
android.os.Parcelable <|.. android.os.statistics.PerfEvent
android.os.statistics.PerfEvent +.. android.os.statistics.PerfEvent$DetailFields
android.os.Parcelable <|.. android.os.statistics.E2EScenario
java.io.Serializable <|.. android.os.statistics.E2EScenario
android.os.statistics.MacroscopicEvent <|-- android.os.statistics.E2EScenarioOnce
android.os.statistics.E2EScenarioOnce +.. android.os.statistics.E2EScenarioOnce$E2EScenarioOnceDetails
android.os.statistics.DetailFields <|-- android.os.statistics.E2EScenarioOnce$E2EScenarioOnceDetails
android.os.HandlerThread <|-- android.os.MiuiMonitorThread
android.os.Parcelable <|.. android.os.DynamicEffect
android.os.CombinedVibration <|-- android.os.DynamicEffect
android.os.DynamicEffect +.. android.os.DynamicEffect$PrimitiveEffect
android.os.DynamicEffect +.. android.os.DynamicEffect$Curve
android.os.DynamicEffect +.. android.os.DynamicEffect$Parameter
android.os.Event <|-- android.os.TransientEvent
android.os.Event <|-- android.os.ContinuousEvent
android.os.MiuiProcess +.. android.os.MiuiProcess$Boost
android.os.spc.PSIEventSocketReader +.. android.os.spc.PSIEventSocketReader$PSIEventListener
android.os.Parcelable <|.. android.os.statistics.E2EScenarioPayload
android.os.statistics.Cloneable <|.. android.os.statistics.E2EScenarioPayload
java.io.Serializable <|.. android.os.statistics.E2EScenarioPayload
android.os.Parcelable <|.. android.os.statistics.E2EScenarioSettings
android.os.statistics.Cloneable <|.. android.os.statistics.E2EScenarioSettings
java.io.Serializable <|.. android.os.statistics.E2EScenarioSettings
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.LooperCheckPoint
android.os.statistics.MacroscopicEvent <|-- android.os.statistics.SingleJankRecord
android.os.statistics.SingleJankRecord +.. android.os.statistics.SingleJankRecord$JankRecordFields
android.os.statistics.DetailFields <|-- android.os.statistics.SingleJankRecord$JankRecordFields
android.os.statistics.BinderServerMonitor +.. android.os.statistics.BinderServerMonitor$CpuUsageInfo
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.LooperOnce
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$BinderWrapper
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$BinderStarvationDetails
android.os.statistics.DetailFields <|-- android.os.statistics.BinderSuperviser$BinderStarvationDetails
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$BinderStarvation
android.os.statistics.MacroscopicEvent <|-- android.os.statistics.BinderSuperviser$BinderStarvation
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$BinderCallFields
android.os.statistics.BlockedEventFields <|-- android.os.statistics.BinderSuperviser$BinderCallFields
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$SingleBinderCall
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.BinderSuperviser$SingleBinderCall
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$BinderExecutionFields
android.os.statistics.RootEventFields <|-- android.os.statistics.BinderSuperviser$BinderExecutionFields
android.os.statistics.BinderSuperviser +.. android.os.statistics.BinderSuperviser$SingleBinderExecution
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.BinderSuperviser$SingleBinderExecution
android.os.statistics.TreeNode <|-- android.os.statistics.StringDictTree
android.os.statistics.MemorySuperviser +.. android.os.statistics.MemorySuperviser$SlowpathFields
android.os.statistics.MeasurementEventFields <|-- android.os.statistics.MemorySuperviser$SlowpathFields
android.os.statistics.MemorySuperviser +.. android.os.statistics.MemorySuperviser$Slowpath
android.os.statistics.MicroscopicEvent <|-- android.os.statistics.MemorySuperviser$Slowpath
android.os.statistics.PerfEventReporter +.. android.os.statistics.PerfEventReporter$ProcPerfEventReaderThread
android.os.statistics.Thread <|-- android.os.statistics.PerfEventReporter$ProcPerfEventReaderThread
android.os.statistics.PerfEventReporter +.. android.os.statistics.PerfEventReporter$ProcPerfEventFilterThread
android.os.statistics.Thread <|-- android.os.statistics.PerfEventReporter$ProcPerfEventFilterThread
android.os.ILooperMonitorable <|.. android.os.BaseLooper
android.os.BaseLooper +.. android.os.BaseLooper$MessageMonitorInfo
android.os.Parcelable <|.. android.os.BaseLooper$MessageMonitorInfo
android.os.Cloneable <|.. android.os.BaseLooper$MessageMonitorInfo
android.os.statistics.FilteringPerfEventListNode <|-- android.os.statistics.FilteringPerfEventList
android.os.spc.PressureState +.. android.os.spc.PressureState$PressureListener
@enduml