public class AutoDismissService extends AccessibilityService {
 @Override
 public void onAccessibilityEvent(AccessibilityEvent event) {
 if (event == null) {
 return;
 }
 
 // 自動將android系統(tǒng)彈出的其它crash dialog取消
 dismissAppErrorDialogIfExists(event);
 }
 
 private void dismissAppErrorDialogIfExists(AccessibilityEvent event) {
 // WINDOW視圖變化才進行對應操作
 if ((event.getEventType() == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
 && event.getPackageName().equals("android")) {
 // 查找?guī)в?OK"字符的可點擊Node
 AccessibilityNodeInfo nodeInfo = findViewByText("OK", true);
 if (nodeInfo != null) {
 // 查找到后執(zhí)行點擊操作
 performViewClick(nodeInfo);
 }
 }
 public AccessibilityNodeInfo findViewByText(String text, boolean clickable) {
 // 獲取當前窗口父節(jié)點
 AccessibilityNodeInfo accessibilityNodeInfo = getRootInActiveWindow();
 if (accessibilityNodeInfo == null) {
 return null;
 }
 // 獲取到滿足字符要求的節(jié)點
 List<AccessibilityNodeInfo> nodeInfoList = accessibilityNodeInfo.findAccessibilityNodeInfosByText(text);
 if (nodeInfoList != null && !nodeInfoList.isEmpty()) {
 for (AccessibilityNodeInfo nodeInfo : nodeInfoList) {
 if (nodeInfo != null && (nodeInfo.isClickable() == clickable)) {
  return nodeInfo;
 }
 }
 }
 return null;
 }
 
 public void performViewClick(AccessibilityNodeInfo nodeInfo) {
 if (nodeInfo == null) {
 return;
 }
 // 由下至上進行查詢，直到尋找到可點擊的節(jié)點
 while (nodeInfo != null) {
 if (nodeInfo.isClickable()) {
 nodeInfo.performAction(AccessibilityNodeInfo.ACTION_CLICK);
 break;
 }
 nodeInfo = nodeInfo.getParent();
 }
 }
}

private void setText(CharSequence text, BufferType type,
   boolean notifyBefore, int oldlen) {
 ...
 notifyViewAccessibilityStateChangedIfNeeded(AccessibilityEvent.CONTENT_CHANGE_TYPE_TEXT);
 ...   
}
public void notifyViewAccessibilityStateChangedIfNeeded(int changeType) {
 if (!AccessibilityManager.getInstance(mContext).isEnabled() || mAttachInfo == null) {
 return;
 }
 if (mSendViewStateChangedAccessibilityEvent == null) {
 // 本質上是一個Runnable，意味著這里的流程會進入異步處理
 mSendViewStateChangedAccessibilityEvent =
  new SendViewStateChangedAccessibilityEvent();
 }
 mSendViewStateChangedAccessibilityEvent.runOrPost(changeType);
}
private class SendViewStateChangedAccessibilityEvent implements Runnable {
 ...
 @Override
 public void run() {
 mPosted = false;
 mPostedWithDelay = false;
 mLastEventTimeMillis = SystemClock.uptimeMillis();
 if (AccessibilityManager.getInstance(mContext).isEnabled()) {
  final AccessibilityEvent event = AccessibilityEvent.obtain();
  event.setEventType(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
  event.setContentChangeTypes(mChangeTypes);
  // 最終TYPE_WINDOW_CONTENT_CHANGED事件在這里異步發(fā)送
  sendAccessibilityEventUnchecked(event);
 }
 mChangeTypes = 0;
 }
 ...
}
public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
 if (mAccessibilityDelegate != null) {
 mAccessibilityDelegate.sendAccessibilityEventUnchecked(this, event);
 } else {
 sendAccessibilityEventUncheckedInternal(event);
 }
}
public void sendAccessibilityEventUnchecked(View host, AccessibilityEvent event) {
 host.sendAccessibilityEventUncheckedInternal(event);
}
public void sendAccessibilityEventUncheckedInternal(AccessibilityEvent event) {
 if (!isShown()) {
 return;
 }
 ...
 // 此處交由TextView所在父View進行處理，為責任鏈模式，事件經(jīng)過層層向上傳遞，最終交由ViewRootImpl進行處理
 ViewParent parent = getParent();
 if (parent != null) {
 getParent().requestSendAccessibilityEvent(this, event);
 }
}

@Override
public boolean requestSendAccessibilityEvent(View child, AccessibilityEvent event) {
 ...
 // 本地調用到AccessibilityManager進行事件發(fā)送
 mAccessibilityManager.sendAccessibilityEvent(event);
 return true;
}

public void sendAccessibilityEvent(AccessibilityEvent event) {
 final IAccessibilityManager service;
 final int userId;
 synchronized (mLock) {
 // 獲取system_server的Accessibility實名服務
 service = getServiceLocked();
 ...
 }
 
 try {
 ...
 long identityToken = Binder.clearCallingIdentity();
 // binder call 到服務端，進行事件分發(fā)中轉
 doRecycle = service.sendAccessibilityEvent(event, userId);
 Binder.restoreCallingIdentity(identityToken);
 ...
 } catch (RemoteException re) {
 Log.e(LOG_TAG, "Error during sending " + event + " ", re);
 } finally {
 ...
 }
}

// binder call 到服務端，觸發(fā)事件派發(fā)
@Override
public boolean sendAccessibilityEvent(AccessibilityEvent event, int userId) {
 synchronized (mLock) {
 ...
 if (mSecurityPolicy.canDispatchAccessibilityEventLocked(event)) {
  ...
  notifyAccessibilityServicesDelayedLocked(event, false);
  notifyAccessibilityServicesDelayedLocked(event, true);
 }
 ...
 }
 return (OWN_PROCESS_ID != Binder.getCallingPid());
}
private void notifyAccessibilityServicesDelayedLocked(AccessibilityEvent event,
 boolean isDefault) {
 try {
 UserState state = getCurrentUserStateLocked();
 for (int i = 0, count = state.mBoundServices.size(); i < count; i++) {
  Service service = state.mBoundServices.get(i);
  if (service.mIsDefault == isDefault) {
  if (canDispatchEventToServiceLocked(service, event)) {
   // 調用內部服務，以觸發(fā)事件派發(fā)
   service.notifyAccessibilityEvent(event);
  }
  }
 }
 } catch (IndexOutOfBoundsException oobe) {
 ...
 }
}
class Service extends IAccessibilityServiceConnection.Stub
 implements ServiceConnection, DeathRecipient {
 public void notifyAccessibilityEvent(AccessibilityEvent event) {
 synchronized (mLock) {
  ...
  if ((mNotificationTimeout > 0)
   && (eventType != AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED)) {
  ...
  // 按照慣例，異步分發(fā)到客戶端進行派發(fā)
  message = mEventDispatchHandler.obtainMessage(eventType);
  } else {
  message = mEventDispatchHandler.obtainMessage(eventType, newEvent);
  }
  mEventDispatchHandler.sendMessageDelayed(message, mNotificationTimeout);
 }
 } 
}
public Handler mEventDispatchHandler = new Handler(mMainHandler.getLooper()) {
 @Override
 public void handleMessage(Message message) {
 final int eventType = message.what;
 AccessibilityEvent event = (AccessibilityEvent) message.obj;
 notifyAccessibilityEventInternal(eventType, event);
 }
};
private void notifyAccessibilityEventInternal(int eventType, AccessibilityEvent event) {
 IAccessibilityServiceClient listener;
 ...
 // mServiceInterface是通過bind客戶端的AccessibilityService，在onServiceConnected連接成功后，獲取到binder proxy轉化來的，以這種方式實現(xiàn)了system_server與客戶端的通信
 listener = mServiceInterface;
 ...
 try {
 listener.onAccessibilityEvent(event);
 if (DEBUG) {
  Slog.i(LOG_TAG, "Event " + event + " sent to " + listener);
 }
 } catch (RemoteException re) {
 Slog.e(LOG_TAG, "Error during sending " + event + " to " + listener, re);
 } finally {
 event.recycle();
 }
}

// 抽象方法，模板模式，被系統(tǒng)主動調用
public abstract void onAccessibilityEvent(AccessibilityEvent event);
// 該service是被system_server主動綁定的，獲取到IAccessibilityServiceClientWrapper的proxy來實現(xiàn)系統(tǒng)的主動調用
@Override
public final IBinder onBind(Intent intent) {
 return new IAccessibilityServiceClientWrapper(this, getMainLooper(), new Callbacks() {
 ...
 @Override
 public void onAccessibilityEvent(AccessibilityEvent event) {
  AccessibilityService.this.onAccessibilityEvent(event);
 }
 ...
 }
}
// 收到binder調用后，使用handler異步進行事件的處理
public void onAccessibilityEvent(AccessibilityEvent event) {
 Message message = mCaller.obtainMessageO(DO_ON_ACCESSIBILITY_EVENT, event);
 mCaller.sendMessage(message);
}
@Override
public void executeMessage(Message message) {
 switch (message.what) {
 case DO_ON_ACCESSIBILITY_EVENT: {
  AccessibilityEvent event = (AccessibilityEvent) message.obj;
  if (event != null) {
  AccessibilityInteractionClient.getInstance().onAccessibilityEvent(event);
  // 通過回調調用以觸發(fā)事件
  mCallback.onAccessibilityEvent(event);
  ...
  }
 } return;
 }
}

public AccessibilityNodeInfo getRootInActiveWindow() {
 // 查找父節(jié)點的操作沒有在自己的類中實現(xiàn)，而是交由了同一進程的Client管理類進行處理
 return AccessibilityInteractionClient.getInstance().getRootInActiveWindow(mConnectionId);
}

public AccessibilityNodeInfo getRootInActiveWindow(int connectionId) {
 return findAccessibilityNodeInfoByAccessibilityId(connectionId,
  AccessibilityNodeInfo.ACTIVE_WINDOW_ID, AccessibilityNodeInfo.ROOT_NODE_ID,
  false, AccessibilityNodeInfo.FLAG_PREFETCH_DESCENDANTS);
}
public AccessibilityNodeInfo findAccessibilityNodeInfoByAccessibilityId(int connectionId,
  int accessibilityWindowId, long accessibilityNodeId, boolean bypassCache,
  int prefetchFlags) {
 ...
 // 嘗試binder call到system_server，請求中轉到其它APP進程中查詢父節(jié)點信息，注意的是這里AccessibilityInteractionClient本身是個binder服務端，把this傳到system_server后，其它進程可以通過這個引用拿到binder proxy，以實現(xiàn)通信
 final boolean success = connection.findAccessibilityNodeInfoByAccessibilityId(
   accessibilityWindowId, accessibilityNodeId, interactionId, this,
   prefetchFlags, Thread.currentThread().getId());
 Binder.restoreCallingIdentity(identityToken);
 // If the scale is zero the call has failed.
 if (success) {
 // 調用成功后，這里會嘗試同步獲取結果
 List<AccessibilityNodeInfo> infos = getFindAccessibilityNodeInfosResultAndClear(
  interactionId);
 finalizeAndCacheAccessibilityNodeInfos(infos, connectionId);
 if (infos != null && !infos.isEmpty()) {
  return infos.get(0);
 }
 } 
 ... 
}

@Override
public boolean findAccessibilityNodeInfoByAccessibilityId(
 int accessibilityWindowId, long accessibilityNodeId, int interactionId,
 IAccessibilityInteractionConnectionCallback callback, int flags,
 long interrogatingTid) throws RemoteException {
 ...
 // 獲取到其他APP的節(jié)點獲取服務
 IAccessibilityInteractionConnection connection = null;
 ...
 resolvedWindowId = resolveAccessibilityWindowIdLocked(accessibilityWindowId);
 ...
 if (!permissionGranted) {
 return false;
 } else {
 connection = getConnectionLocked(resolvedWindowId);
 if (connection == null) {
  return false;
 }
 }
 ...
 // 這里的callback為之前應用的服務proxy句柄，將它傳入是為了之后的信息通信不再需要經(jīng)過system_server中轉，而是直接可以APP對APP的進行通信
 connection.findAccessibilityNodeInfoByAccessibilityId(accessibilityNodeId,
  partialInteractiveRegion, interactionId, callback, mFetchFlags | flags,
  interrogatingPid, interrogatingTid, spec);
 ...
}

@Override
public void findAccessibilityNodeInfoByAccessibilityId(long accessibilityNodeId,
 Region interactiveRegion, int interactionId,
 IAccessibilityInteractionConnectionCallback callback, int flags,
 int interrogatingPid, long interrogatingTid, MagnificationSpec spec) {
 ViewRootImpl viewRootImpl = mViewRootImpl.get();
 if (viewRootImpl != null && viewRootImpl.mView != null) {
 // 這里也只是委托給控制類進行細節(jié)操作的處理
 viewRootImpl.getAccessibilityInteractionController()
  .findAccessibilityNodeInfoByAccessibilityIdClientThread(accessibilityNodeId,
   interactiveRegion, interactionId, callback, flags, interrogatingPid,
   interrogatingTid, spec);
 } else {
 ...
 }
}

private void findAccessibilityNodeInfoByAccessibilityIdUiThread(Message message) {
 ...
 // 初始化將會返回的節(jié)點
 List<AccessibilityNodeInfo> infos = mTempAccessibilityNodeInfoList;
 infos.clear();
 try {
 if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) {
  return;
 }
 mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags;
 View root = null;
 if (accessibilityViewId == AccessibilityNodeInfo.UNDEFINED_ITEM_ID) {
  root = mViewRootImpl.mView;
 } else {
  root = findViewByAccessibilityId(accessibilityViewId);
 }
 ...
 } finally {
 try {
  ...
  adjustIsVisibleToUserIfNeeded(infos, interactiveRegion);
  // 通過callback binder proxy句柄，將節(jié)點信息binder回應用
  callback.setFindAccessibilityNodeInfosResult(infos, interactionId);
  infos.clear();
 } catch (RemoteException re) {
  /* ignore - the other side will time out */
 }
 ...
 }
}

public void setFindAccessibilityNodeInfosResult(List<AccessibilityNodeInfo> infos,
  int interactionId) {
 synchronized (mInstanceLock) {
 if (interactionId > mInteractionId) {
  if (infos != null) {
  ...
  // 設置應用的返回節(jié)點信息
  if (!isIpcCall) {
   mFindAccessibilityNodeInfosResult = new ArrayList<>(infos);
  } else {
   mFindAccessibilityNodeInfosResult = infos;
  }
  } else {
  mFindAccessibilityNodeInfosResult = Collections.emptyList();
  }
  mInteractionId = interactionId;
 }
 // 釋放鎖，停止等待，節(jié)點信息已經(jīng)取回
 mInstanceLock.notifyAll();
 }
}

public List<AccessibilityNodeInfo> findAccessibilityNodeInfosByText(String text) {
 ...
 // 一樣的流程，通過AccessibilityInteractionClient去獲取信息
 AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
 return client.findAccessibilityNodeInfosByText(mConnectionId, mWindowId, mSourceNodeId,
  text);
}
``` 

```java
private void performAccessibilityActionUiThread(Message message) {
 View target = null;
 if (accessibilityViewId != AccessibilityNodeInfo.UNDEFINED_ITEM_ID) {
 target = findViewByAccessibilityId(accessibilityViewId);
 } else {
 target = mViewRootImpl.mView;
 }
 if (target != null && isShown(target)) {
 AccessibilityNodeProvider provider = target.getAccessibilityNodeProvider();
 if (provider != null) {
  if (virtualDescendantId != AccessibilityNodeInfo.UNDEFINED_ITEM_ID) {
  // 在客戶端執(zhí)行performAction操作
  succeeded = provider.performAction(virtualDescendantId, action,
   arguments);
  } else {
  succeeded = provider.performAction(AccessibilityNodeProvider.HOST_VIEW_ID,
   action, arguments);
  }
 } else if (virtualDescendantId == AccessibilityNodeInfo.UNDEFINED_ITEM_ID) {
  succeeded = target.performAccessibilityAction(action, arguments);
 }
 }
}

public boolean performAccessibilityActionInternal(int action, Bundle arguments) {
 ...
 switch (action) {
 case AccessibilityNodeInfo.ACTION_CLICK: {
  if (isClickable()) {
  // 最終調用到我們熟悉的View.performClick方法
  performClick();
  return true;
  }
 } break;
 ...
}