Handler从Java到Native

private Looper(boolean quitAllowed) {
  mQueue = new MessageQueue(quitAllowed);
  mThread = Thread.currentThread();
}

@UnsupportedAppUsage
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

public static void prepare() {
  prepare(true);
}

private static void prepare(boolean quitAllowed) {
  if (sThreadLocal.get() != null) {
      throw new RuntimeException("Only one Looper may be created per thread");
  }
  sThreadLocal.set(new Looper(quitAllowed));
}

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.");
    }

     me.mInLoop = true;

     for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
     }
}

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

class MyThread extends Thread {
    
    private Handler mHandler;
    
    @Override
    public void run() {
        super.run();
        Looper.prepare();
        mHandler = new Handler(Looper.myLooper());
        Looper.loop();
    }
}

@UnsupportedAppUsage
private static Looper sMainLooper;

@Deprecated
public static void prepareMainLooper() {
  prepare(false);
  synchronized (Looper.class) {
    if (sMainLooper != null) {
      throw new IllegalStateException("The main Looper has already been prepared.");
    }
    sMainLooper = myLooper();
  }
}

private Handler mMainHandler = new Handler(Looper.getMainLooper);

// 空参数构造方法，不建议使用
@Deprecated
public Handler() {
  this(null, false);
}

// 未提供Looper的构造方法，不建议使用
public Handler(@Nullable Callback callback, boolean async) {
  ...
  // 没有传入looper，直接从当前线程中获取Looper
  mLooper = Looper.myLooper();
  // 当前线程没有启用Looper，直接抛异常
  if (mLooper == null) {
    throw new RuntimeException(
      "Can't create handler inside thread " + Thread.currentThread()
          \+ " that has not called Looper.prepare()");
  }
  mQueue = mLooper.mQueue;
  mCallback = callback;
  mAsynchronous = async;
  mIsShared = false;
}

// 构造方法中传入Looper，推荐使用
public Handler(@NonNull Looper looper) {
  this(looper, null, false);
}

// 不允许app使用
@UnsupportedAppUsage
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
  this(looper, callback, async, /* shared= */ false);
}

// 不允许app使用
/** @hide */
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async,
    boolean shared) {
  mLooper = looper;
  mQueue = looper.mQueue;
  mCallback = callback;
  mAsynchronous = async;
  mIsShared = shared;
}

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
      long uptimeMillis) {
    // 消息的target赋值为当前handler，最终message会交给target执行的handler执行
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
       msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

public final class Message implements Parcelable {
    // 用于区分消息类型，用户自定义
    public int what;

    // 消息可携带简单参数
    public int arg1;
    public int arg2;

    // 消息可携带复杂对象
    public Object obj;

    // 标记当前消息是否正在被使用
    @UnsupportedAppUsage
    /*package*/ int flags;

    // 消息具体的需要被执行的时间点，消息队列中以此参数排序
    @UnsupportedAppUsage
    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
    public long when;

    // 消息应该由哪个Handler处理执行
    @UnsupportedAppUsage
    /*package*/ Handler target;

    // 当前消息是一个可执行的代码块逻辑
    @UnsupportedAppUsage
    /*package*/ Runnable callback;

    // 单链表指针
    @UnsupportedAppUsage
    /*package*/ Message next;
}

boolean enqueueMessage(Message msg, long when) {
    // 必须有target，正常发送的消息都有
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    synchronized (this) {
        // message已经被用过了，没有被回收
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }
        // 正在退出looper，直接回收msg
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
              msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }
        // 标记为已使用的状态，并设置消息的执行时机
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        // 是否需要唤醒Looper
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            // 队列中无数据，插入到表头
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            // 遍历消息队列，按时间顺序插入消息
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    // 需要执行的消息比当前消息早，则插入到它前面
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            // 插入到消息的前面
            msg.next = p;
            prev.next = msg;
        }
        // 唤醒Looper
        if (needWake) {
           nativeWake(mPtr);
        }
   }
   return true;
}

public static void loop() {
    ...
    for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
    }
}

private static boolean loopOnce(final Looper me,
            final long ident, final int thresholdOverride) {
    // 从消息队列中获取一个消息，可能会阻塞
    Message msg = me.mQueue.next();
    // 按照正常逻辑，msg不可能为空，因为获取不到消息时会阻塞，只有looper退出时才会返回null
    // 当msg为空，也就代表着loop方法的结束，整个消息机制的结束。
    if (msg == null) {
        return false;
    }

    // 通过Looper#setMessageLogging可以设置日志打印类，可以打印出每个消息的执行情况，
    // 我们可以通过这个记录每个Message的执行实际，执行耗时等信息，可用于监控线程是否卡顿
    final Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " "
                + msg.callback + ": " + msg.what);
    }
    // 这个类才是监控消息执行的，在消息执行前、执行后、以及发生异常时，都会有回调到
    // observer中，这个类可以帮助我们监控消息队列的执行情况，比前面的logging更好用。
    // 但是，它是hide的，我们正常情况下无法使用
    final Observer observer = sObserver;
    ...
    if (observer != null) {
        // 消息执行前的回调
        token = observer.messageDispatchStarting();
    }
    try {
        // 取出消息对应的handler，通过dispatchMessage处理消息
        msg.target.dispatchMessage(msg);
        // 消息执行后的回调
        if (observer != null) {
            observer.messageDispatched(token, msg);
        }
    } catch (Exception exception) {
        // 异常时的回调
        if (observer != null) {
            observer.dispatchingThrewException(token, msg, exception);
        }
        throw exception;
    } finally {
        ...
    }
    // 消息执行后的logging打印
    if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }
    // 回收消息，会将消息状态重置，并标记未使用，然后放回到消息池中等待复用
    msg.recycleUnchecked();
    // 返回true，因此在looper中会再次调用到loopOnce方法
    return true;
}

Message next() {
    // native的指针，用于阻塞和唤醒的
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }
    // idleHandler的个数，用来控制避免重复执行的
    int pendingIdleHandlerCount = -1;

    // 阻塞时间，当没有消息时取值为-1，表示一直阻塞；有消息时但是不能执行，说明该消息的
    // 执行时间是在未来的，因此取值为msg.when - now
    int nextPollTimeoutMillis = 0;

    // 这里也是一个死循环，说明如果取不到数据，是会继续循环去取，直到取到message为止，
    // 因此说这个方法的返回值不会为null，除非Looper被quit才会返回null。
    for (; ; ) {
        // 阻塞一段时间nextPollTimeoutMillis，第一次的时候该值为0不会被阻塞，
        // 后续就可能会被阻塞住，直到第一个消息的执行时间点到达
        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            // target为空，说明msg是一个消息屏障
            if (msg != null && msg.target == null) {
                // 遇到消息屏障后，该屏障后的所有普通消息不再执行，但是异步消息还是会执行的，
                // 因此这里使用循环查找消息屏障后的第一个异步消息返回
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                // 找到了消息，注意msg的初始值是mMessage，也就是消息队列的第一个值，因此
                // 走到这里说明拿到了一个可能是正常消息，也可能是异步消息的消息
                if (now < msg.when) {
                    // 消息的执行时间未到，则计算需要阻塞的时间
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 找到了消息并且可以执行，标记为非阻塞状态
                    mBlocked = false;
                    // 将消息从消息队列中取出来
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    msg.markInUse();
                    return msg;
                }
            } else {
                // 未找到消息，则将阻塞时间设置为一直阻塞
                nextPollTimeoutMillis = -1;
            }
            // 只有Looper.quit时，才会返回null
            if (mQuitting) {
                dispose();
                return null;
            }
            ...
        }

        // 执行pendingIntent
        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);
            }
            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
        ...
    }
}

public void dispatchMessage(@NonNull Message msg) {
    // 如果callback不为空，说明消息是个可执行代码块，直接执行即可
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        // 可以给Handler设置一个处理消息的callback，如果执行消息的话，就不会再去分发了
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 最后的执行消息的地方，是个空方法
        handleMessage(msg);
    }
}

private static void handleCallback(Message message) {
    message.callback.run();
}

// 使用方式一，构造Handler时传入Callback进行处理消息
private Handler mHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message msg) {
        boolean consumed = false;
        switch (msg.what) {
            case 1:
                consumed = true;
                break;
            default:
                break;
        }       
        return consumed;
    }
});

// 使用方式二，使用匿名内部类，重写handlerMessage方法来处理消息
private Handler mHandler2 = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        switch (msg.what) {
            case 1:
                consumed = true;
                break;
            default:
                break;
        }
    }
};

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

Message next() {
    ...
    for (;;) {
        nativePollOnce(ptr, nextPollTimeoutMillis);
        ...
    }
}

boolean enqueueMessage(Message msg, long when) {
    ...
    synchronized (this) {
        ...
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}


private native static long nativeInit();
private native static void nativeDestroy(long ptr);
@UnsupportedAppUsage
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
private native static void nativeWake(long ptr);