public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
      ...
      if ((mWindowAttributes.inputFeatures
          & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
          mInputChannel = new InputChannel(); //創(chuàng)建InputChannel對(duì)象
      }
      //通過(guò)Binder調(diào)用，進(jìn)入system進(jìn)程的Session[見(jiàn)小節(jié)2.4]
      res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                  getHostVisibility(), mDisplay.getDisplayId(),
                  mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                  mAttachInfo.mOutsets, mInputChannel);
      ...
      if (mInputChannel != null) {
          if (mInputQueueCallback != null) {
              mInputQueue = new InputQueue();
              mInputQueueCallback.onInputQueueCreated(mInputQueue);
          }
          //創(chuàng)建WindowInputEventReceiver對(duì)象[見(jiàn)3.1]
          mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                  Looper.myLooper());
      }
    }
}

status_t InputChannel::openInputChannelPair(const String8& name,
        sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {
    int sockets[2];
    //真正創(chuàng)建socket對(duì)的地方【核心】
    if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
        ...
        return result;
    }

    int bufferSize = SOCKET_BUFFER_SIZE; //32k
    setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
    setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));

    String8 serverChannelName = name;
    serverChannelName.append(" (server)");
    //創(chuàng)建InputChannel對(duì)象
    outServerChannel = new InputChannel(serverChannelName, sockets[0]);

    String8 clientChannelName = name;
    clientChannelName.append(" (client)");
    //創(chuàng)建InputChannel對(duì)象
    outClientChannel = new InputChannel(clientChannelName, sockets[1]);
    return OK;
}

public InputEventReceiver(InputChannel inputChannel, Looper looper) {
    if (inputChannel == null) {
        throw new IllegalArgumentException("inputChannel must not be null");
    }
    if (looper == null) {
        throw new IllegalArgumentException("looper must not be null");
    }

    mInputChannel = inputChannel;
    mMessageQueue = looper.getQueue();
    mReceiverPtr = nativeInit(new WeakReference<InputEventReceiver>(this),
            inputChannel, mMessageQueue);

    mCloseGuard.open("dispose");
}

 public int subWindowTypeToLayerLw(int type) {
       switch (type) {
       case TYPE_APPLICATION_PANEL:
       case TYPE_APPLICATION_ATTACHED_DIALOG:
           return APPLICATION_PANEL_SUBLAYER;//返回值是1
       case TYPE_APPLICATION_MEDIA:
           return APPLICATION_MEDIA_SUBLAYER;//返回值是-2  
       case TYPE_APPLICATION_MEDIA_OVERLAY:
           return APPLICATION_MEDIA_OVERLAY_SUBLAYER;//返回值是-1  
       case TYPE_APPLICATION_SUB_PANEL:
           return APPLICATION_SUB_PANEL_SUBLAYER;//返回值是2 
       case TYPE_APPLICATION_ABOVE_SUB_PANEL:
           return APPLICATION_ABOVE_SUB_PANEL_SUBLAYER;//返回值是3  
       }
       Log.e(TAG, "Unknown sub-window type: " + type);
       return 0;
   }

public void appNotResponding(@NonNull final String reason) {
    try {
        getService().appNotResponding(reason);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

public class AnrMonitorDialog extends Dialog {

    private static HandlerThread AnrMonitorThread = new HandlerThread("ANR-Monitor");

    static {
        AnrMonitorThread.start();
    }

    private static Handler sAnrMonitorHandler = new Handler(AnrMonitorThread.getLooper());
    private final Window.Callback mHost;
    private final Handler mainHandler;
    private boolean isFullScreen = false;

    AnrMonitorDialog(Context context, Window hostWindow) {
        super(context);
        this.mainHandler = new Handler(Looper.getMainLooper());
        this.mHost = hostWindow.getCallback();
        this.isFullScreen = (WindowManager.LayoutParams.FLAG_FULLSCREEN & hostWindow.getAttributes().flags) != 0;
    }


  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Window window = getWindow();
        window.requestFeature(Window.FEATURE_NO_TITLE);
        View view = new View(getContext());
        view.setFocusableInTouchMode(false);
        view.setFocusable(false);
        setContentView(view);
        if (isFullScreen) {
            window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
        } else {
            window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
        }
        WindowManager.LayoutParams attributes = window.getAttributes();
        attributes.format = PixelFormat.TRANSPARENT;
        attributes.dimAmount = 0f;
        attributes.flags |= FLAG_NOT_FOCUSABLE;
        window.setBackgroundDrawable(new ColorDrawable(0x00000000));
        window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT);

        setCancelable(false);
        setCanceledOnTouchOutside(false);

    }


    public static void hideDialog(DialogInterface dialog) {
        if (dialog == null) return;
        sAnrMonitorHandler.post(new Runnable() {
            @Override
            public void run() {
                dialog.dismiss();
            }
        });
    }


    public static void showDialog(final Activity activity, final Window window, OnShowListener onShowListener) {
        sAnrMonitorHandler.post(new Runnable() {
            @Override
            public void run() {
          
                if(activity.isFinishing()){
                    return;
                }
                AnrMonitorDialog anrMonitorDialog = new AnrMonitorDialog(activity, window);
                anrMonitorDialog.setOnShowListener(onShowListener);
                anrMonitorDialog.show();
            }
        });
    }
    
   // 省略一堆關(guān)鍵代碼
}

/**
 *  fixed Lenovo/Sharp Device 
 *
 */
@Keep
public boolean dispatchFnKeyEvent(KeyEvent event) {
    //可以利用MethodHandle調(diào)用父類的方法
    return false;
}

@Override
public boolean dispatchTouchEvent(final MotionEvent event) {
    final Waiter waiter = new Waiter();

    final MotionEvent targetEvent = copyMotionEvent(event);
    mainHandler.post(new Runnable() {
        @Override
        public void run() {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    break;
                case MotionEvent.ACTION_UP:
                case MotionEvent.ACTION_CANCEL:
                    break;
            }
            boolean isHandled = mHost.dispatchTouchEvent(targetEvent);
            targetEvent.recycle();  //自己拷貝的事件，需要主動(dòng)回收
            waiter.countDown(isHandled);
        }
    });
    try {
        if(!waiter.await(4000, TimeUnit.MILLISECONDS)){
            sAnrMonitorHandler.postAtTime(mAnrTimeoutTask, SystemClock.uptimeMillis() + 2000L);
            mainHandler.postAtFrontOfQueue(mCancelAnrTimeoutTask);
        }
    } catch (InterruptedException e) {
        e.printStackTrace();

    }

    return waiter.isHandled;
}

private Runnable mAnrTimeoutTask = new Runnable() {
    @Override
    public void run() {
        sendAppNotResponding("Dispatching Timeout");
    }
};

private Runnable mCancelAnrTimeoutTask = new Runnable() {
    @Override
    public void run() {
        sAnrMonitorHandler.removeCallbacks(mAnrTimeoutTask);
    }
};

static class Waiter extends CountDownLatch {
    boolean isHandled = false;
    public Waiter() {
        super(1);
    }

    public void countDown(boolean isHandled){
        this.isHandled = isHandled;
        super.countDown();
    }
    @Override
    public void countDown() {
         throw new Exception("I like along, don't call me");
    }
}

AnrMonitorDialog.showDialog(this, getWindow(), new DialogInterface.OnShowListener() {
    @Override
    public void onShow(DialogInterface dialog) {
        anrMonitorDialog = dialog;  
         //由于是異步返回的的dialog，這里要做二次檢測(cè)，防止InputChannel泄漏
        postToMain(new Runnable(){
          if(actvitiyIsFinish()){ 
              AnrMonitorDialog.hideDialog(anrMonitorDialog);
              anrMonitorDialog = null;
           
          }
        });
    }
});

@Override
protected void onDestroy() {
    AnrMonitorDialog.hideDialog(anrMonitorDialog);
    super.onDestroy();
}

      @Override
        public void onInputEvent(InputEvent event) {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "processInputEventForCompatibility");
            List<InputEvent> processedEvents;
            try {
                processedEvents =
                    mInputCompatProcessor.processInputEventForCompatibility(event);
            } finally {
                Trace.traceEnd(Trace.TRACE_TAG_VIEW);
            }
            if (processedEvents != null) {
                if (processedEvents.isEmpty()) {
                    // InputEvent consumed by mInputCompatProcessor
                    finishInputEvent(event, true);
                } else {
                    for (int i = 0; i < processedEvents.size(); i++) {
                        enqueueInputEvent(
                                processedEvents.get(i), this,
                                QueuedInputEvent.FLAG_MODIFIED_FOR_COMPATIBILITY, true);
                    }
                }
            } else {
                enqueueInputEvent(event, this, 0, true);
            }
        }

package android.view;
public class ViewRootImpl {  
}

package android.view;  
  
import android.content.Context;  
import java.util.List;  
  
public class InputEventCompatProcessor {  
    protected Context mContext;  
    public InputEventCompatProcessor(Context context) {  
        mContext = context;  
    }  

    public List<InputEvent> processInputEventForCompatibility(InputEvent e) {  
        return null;  
    }  
    public InputEvent processInputEventBeforeFinish(InputEvent e) {  
        // No changes needed  
        return e;  
    }  
}

public class WindowInputEventCompatProcessor extends InputEventCompatProcessor {

    private final InputEventCompatProcessor processor;
    private final InputEventReceiver eventReceiver;
    private ViewRootImpl viewRootImpl;
    final Handler mainHandler;
    private static final AtomicInteger mNextSeq = new AtomicInteger();
    private SparseIntArray eventMaps = new SparseIntArray();
    private Method enqueueInputEvent;
    public static final int FLAG_MODIFIED_FOR_COMPATIBILITY = 1 << 6;
    private Handler anrHandler;

    private String TAG = "WindowInputEventCompatProcessor";
    private Method finishInputEvent;

    public WindowInputEventCompatProcessor(Context context, InputEventCompatProcessor processor, ViewRootImpl viewRootImpl, InputEventReceiver eventReceiver) {
        super(context);
        this.processor = processor;
        this.mainHandler = new Handler(Looper.getMainLooper());
        this.viewRootImpl = viewRootImpl;
        this.eventReceiver = eventReceiver;
    }

    @Override
    public List<InputEvent> processInputEventForCompatibility(InputEvent e) {

        if (anrHandler == null) {
            anrHandler = new Handler(Looper.myLooper());
        }

        InputEvent copyEvent = null;
        if(e instanceof KeyEvent){
            copyEvent =  KeyEvent.changeFlags((KeyEvent) e,((KeyEvent) e).getFlags());
        }else if( e instanceof MotionEvent){
            copyEvent = MotionEvent.obtain((MotionEvent) e);
        }

        if(copyEvent == null){
            return Collections.emptyList();
        }

        final InputEvent event = copyEvent;

        if(Looper.myLooper() == Looper.getMainLooper()){
            anrHandler.post(new Runnable() {
              @Override
              public void run() {
                  finishInputEvent(e,true);
              }
          });
          anrHandler.postAtTime(mAnrTimeoutTask,event, SystemClock.uptimeMillis() + 6000L);
          mainHandler.post(new Runnable() {
              @Override
              public void run() {
                  anrHandler.removeCallbacks(mAnrTimeoutTask,event);
              }
          });
          List<InputEvent> processedEvents = processor.processInputEventForCompatibility(event);
            if(processedEvents == null){
                processedEvents = new ArrayList<>();
            }
            if(processedEvents.isEmpty()){
                processedEvents.add(event);
            }
      
          return processedEvents;
        }

        eventMaps.append(event.hashCode(), mNextSeq.getAndIncrement());
        anrHandler.postAtTime(mAnrTimeoutTask,event, SystemClock.uptimeMillis() + 6000L);
        mainHandler.post(new Runnable() {
            @Override
            public void run() {

                anrHandler.removeCallbacks(mAnrTimeoutTask,event);

                List<InputEvent> processedEvents = processor.processInputEventForCompatibility(event);

                if (processedEvents != null) {
                    if (processedEvents.isEmpty()) {
                        // InputEvent consumed by mInputCompatProcessor
                        // finishInputEvent(event, true);
                        //這里一定不要調(diào)用哦，防止外部重復(fù)調(diào)用
                    } else {
                        for (int i = 0; i < processedEvents.size(); i++) {
                            enqueueInputEvent(
                                    processedEvents.get(i), eventReceiver,
                                    FLAG_MODIFIED_FOR_COMPATIBILITY, true);
                        }
                    }
                } else {
                    //修改事件flag
                    enqueueInputEvent(event, eventReceiver, FLAG_MODIFIED_FOR_COMPATIBILITY, true);
                }

            }
        });

        return Collections.emptyList();
    }

    private void finishInputEvent(InputEvent event, boolean isHandled) {
        try {
            if (finishInputEvent == null) {
                finishInputEvent = Class.forName(InputEventReceiver.class.getName()).getDeclaredMethod("finishInputEvent", InputEvent.class, boolean.class);
                finishInputEvent.setAccessible(true);
            }
            finishInputEvent.invoke(eventReceiver, event,isHandled);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private void enqueueInputEvent(InputEvent event, InputEventReceiver eventReceiver, int flags, boolean processImmediately) {
        try {
            if (enqueueInputEvent == null) {
                enqueueInputEvent = ViewRootImpl.class.getDeclaredMethod("enqueueInputEvent", InputEvent.class, InputEventReceiver.class, int.class, boolean.class);
                enqueueInputEvent.setAccessible(true);
            }
            enqueueInputEvent.invoke(viewRootImpl, event, eventReceiver, flags, processImmediately);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public InputEvent processInputEventBeforeFinish(final InputEvent e) {
        final int hashCode = e.hashCode();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                int keyIndex = eventMaps.indexOfKey(hashCode);
                if (keyIndex >= 0) {
                    eventMaps.removeAt(keyIndex);
                }
                processor.processInputEventBeforeFinish(e);
            }
        };
        if(Looper.myLooper() == anrHandler.getLooper()){
            runnable.run();
        }else {
            anrHandler.post(runnable);
        }
        return null;
    }


    private Runnable mAnrTimeoutTask = new Runnable() {
        @Override
        public void run() {
            AppManager.sendAppNotResponding("Dispatching Timeout");
        }
    };

}

public class AnrInterceptor {

    static final HandlerThread handlerThread = new HandlerThread("ANR-Looper");
    static {
        if(Build.VERSION.SDK_INT > Build.VERSION_CODES.P){
            handlerThread.start();
        }

    }
    public static void monitor(final Activity activity){

        if(Build.VERSION.SDK_INT <= Build.VERSION_CODES.P){
            return;
        }

        final View decorView = activity.getWindow().getDecorView();
        decorView.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
            @Override
            public void onViewAttachedToWindow(@NonNull View decorView) {
                ViewRootImpl viewRootImpl = (ViewRootImpl) decorView.getParent();
                try {
                    Class ViewRootImplKlass = viewRootImpl.getClass();
                    Field mInputCompatProcessorField = ViewRootImplKlass.getDeclaredField("mInputCompatProcessor");
                    mInputCompatProcessorField.setAccessible(true);
                    InputEventCompatProcessor inputEventCompatProcessor = (InputEventCompatProcessor) mInputCompatProcessorField.get(viewRootImpl);

                    if(inputEventCompatProcessor instanceof WindowInputEventCompatProcessor){
                        return;
                    }

                    Field mInputEventReceiverField = ViewRootImplKlass.getDeclaredField("mInputEventReceiver");
                    mInputEventReceiverField.setAccessible(true);
                    InputEventReceiver receiver = (InputEventReceiver) mInputEventReceiverField.get(viewRootImpl);

                    Class<?> WindowInputEventReceiverClass = receiver.getClass();
                    Field inputChannelField = Class.forName(InputEventReceiver.class.getName()).getDeclaredField("mInputChannel");
                    inputChannelField.setAccessible(true);
                    InputChannel inputChannel = (InputChannel) inputChannelField.get(receiver);

                    Constructor WindowInputEventReceiverConstructor = WindowInputEventReceiverClass.getDeclaredConstructor(ViewRootImpl.class,InputChannel.class, Looper.class);
                    WindowInputEventReceiverConstructor.setAccessible(true);
                    InputEventReceiver inputEventReceiver = (InputEventReceiver) WindowInputEventReceiverConstructor.newInstance(viewRootImpl,inputChannel,handlerThread.getLooper());

                    InputEventCompatProcessor WindowInputEventCompatProcessor =  new WindowInputEventCompatProcessor(activity,inputEventCompatProcessor,viewRootImpl,inputEventReceiver);
                    mInputEventReceiverField.set(viewRootImpl,inputEventReceiver);
                    mInputCompatProcessorField.set(viewRootImpl,WindowInputEventCompatProcessor);

                    receiver.dispose();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onViewDetachedFromWindow(@NonNull View v) {

            }
        });
    }
}

override fun onCreate(savedInstanceState: Bundle?) {  
    enableEdgeToEdge(statusBarStyle = SystemBarStyle.dark(Color.TRANSPARENT))  
    super.onCreate(savedInstanceState)  

    AnrInterceptor.monitor(this)
}