public Object newAccessiblityStatechangelistener(final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(new AccessibilityStatechangelistenerBridge() {
        public void onAccessibilityStateChanged(boolean enabled) {
            listener.onAccessibilityStateChanged(enabled);
        }
    });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

@Override
public Object newAccessiblityStatechangelistener(
        final AccessibilityStatechangelistenerCompat listener) {
    return AccessibilityManagerCompatIcs.newAccessibilityStatechangelistener(
        new AccessibilityStatechangelistenerBridge() {
            public void onAccessibilityStateChanged(boolean enabled) {
                listener.onAccessibilityStateChanged(enabled);
            }
        });
}

public void onInitializeAccessibilityNodeInfo(View host,AccessibilityNodeInfoCompat info) {
    if (DrawerLayout.CAN_HIDE_DESCENDANTS) {
        super.onInitializeAccessibilityNodeInfo(host,info);
    } else {
        AccessibilityNodeInfoCompat superNode = AccessibilityNodeInfoCompat.obtain(info);
        super.onInitializeAccessibilityNodeInfo(host,superNode);
        info.setSource(host);
        ViewParent parent = ViewCompat.getParentForAccessibility(host);
        if (parent instanceof View) {
            info.setParent((View) parent);
        }
        copyNodeInfoNoChildren(info,superNode);
        superNode.recycle();
        addChildrenForAccessibility(info,(ViewGroup) host);
    }
    info.setClassName(DrawerLayout.class.getName());
    info.setFocusable(false);
    info.setFocused(false);
    info.removeAction(AccessibilityActionCompat.ACTION_FOCUS);
    info.removeAction(AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
}

public void onInitializeAccessibilityNodeInfo(View host,(ViewGroup) host);
    }
    info.setClassName(DrawerLayout.class.getName());
    info.setFocusable(false);
    info.setFocused(false);
    info.removeAction(AccessibilityActionCompat.ACTION_FOCUS);
    info.removeAction(AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
}

/**
 * Returns {@code true} if the node supports the specified action. This method supports actions
 * introduced in API level 21 and later. However,it does not support bitmasks.
 *
 */
public static boolean supportsAction(AccessibilityNodeInfoCompat node,int action) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        // New actions in >= API 21 won't appear in getActions() but in getActionList().
        // On Lollipop+ devices,pre-API 21 actions will also appear in getActionList().
        List<AccessibilityActionCompat> actions = node.getActionList();
        int size = actions.size();
        for (int i = 0; i < size; ++i) {
            AccessibilityActionCompat actionCompat = actions.get(i);
            if (actionCompat.getId() == action) {
                return true;
            }
        }
        return false;
    } else {
        // On < API 21,actions aren't guaranteed to appear in getActionsList(),so we need to
        // check getActions() instead.
        return (node.getActions() & action) == action;
    }
}

@Test
public void performActionWithArgs_actionAndArgsReceivedByNode() {
    String argsKey = "test";
    Bundle args = new Bundle();
    args.putBoolean(argsKey,true);
    assertTrue(args.getBoolean(argsKey));
    AccessibilityNodeActionNode accessibilityNodeActionNode = new AccessibilityNodeActionNode(
            mNodeInfoCompat,new AccessibilityActionCompat(ACTION_ID,ACTION_NAME),args);
    accessibilityNodeActionNode.performAction();
    AccessibilityNodeInfo info = (AccessibilityNodeInfo) mNodeInfoCompat.getInfo();
    ShadowAccessibilityNodeInfo shadowInfo =
            (ShadowAccessibilityNodeInfo) ShadowExtractor.extract(info);

    List<Pair<Integer,Bundle>> performedActions = shadowInfo.getPerformedActionsWithArgs();
    assertEquals(1,performedActions.size());
    assertEquals(ACTION_ID,performedActions.get(0).first.intValue());
    assertNotNull(performedActions.get(0).second);
    assertTrue(performedActions.get(0).second.getBoolean(argsKey));
    accessibilityNodeActionNode.recycle();
}

@Override
public void onInitializeAccessibilityNodeInfo(View host,AccessibilityNodeInfoCompat info) {
    if (CAN_HIDE_DESCENDANTS) {
        super.onInitializeAccessibilityNodeInfo(host,info);
    } else {
        // Obtain a node for the host,then manually generate the list
        // of children to only include non-obscured views.
        final AccessibilityNodeInfoCompat superNode =
                AccessibilityNodeInfoCompat.obtain(info);
        super.onInitializeAccessibilityNodeInfo(host,superNode);

        info.setSource(host);
        final ViewParent parent = ViewCompat.getParentForAccessibility(host);
        if (parent instanceof View) {
            info.setParent((View) parent);
        }
        copyNodeInfoNoChildren(info,superNode);
        superNode.recycle();

        addChildrenForAccessibility(info,(ViewGroup) host);
    }

    info.setClassName(DrawerLayout.class.getName());

    // This view reports itself as focusable so that it can intercept
    // the back button,but we should prevent this view from reporting
    // itself as focusable to accessibility services.
    info.setFocusable(false);
    info.setFocused(false);
    info.removeAction(AccessibilityActionCompat.ACTION_FOCUS);
    info.removeAction(AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
}

@Override
protected void onPopulateNodeForVirtualView(
    int virtualViewId,AccessibilityNodeInfoCompat node) {
  if (hasCloseIcon()) {
    node.setContentDescription(
        getContext().getString(R.string.mtrl_chip_close_icon_content_description));
    node.setBoundsInParent(getCloseIconTouchBoundsInt());
    node.addAction(AccessibilityActionCompat.ACTION_CLICK);
    node.setEnabled(isEnabled());
  } else {
    node.setContentDescription("");
  }
}

public static List<AccessibilityActionCompat> getCustomActions(
        AccessibilityNodeInfoCompat node) {
    List<AccessibilityActionCompat> customActions = new ArrayList<>();
    for (AccessibilityActionCompat action : node.getActionList()) {
        if (isCustomAction(action)) {
            // We don't use custom actions that doesn't have a label
            if (!TextUtils.isEmpty(action.getLabel())) {
                customActions.add(action);
            }
        }
    }

    return customActions;
}

/**
 * Populates a menu with the context menu items for a node,searching up its ancestor
 * hierarchy if the current node has no custom actions.
 */
private void recursivelyPopulateMenuItemsForNode(TalkBackService service,ContextMenuItemBuilder menuItemBuilder,AccessibilityNodeInfoCompat node,List<ContextMenuItem> menu) {
    if (node == null) {
        return;
    }

    for (AccessibilityActionCompat action : AccessibilityNodeInfoUtils.getCustomActions(node)) {
        CharSequence label = action.getLabel();
        int id = action.getId();
        if (TextUtils.isEmpty(label)) {
            continue;
        }

        ContextMenuItem item = menuItemBuilder.createMenuItem(service,Menu.NONE,id,label);
        item.setonMenuItemClickListener(new CustomMenuItem(id,AccessibilityNodeInfoCompat.obtain(node)));
        item.setCheckable(false);
        menu.add(item);
    }

    if (menu.isEmpty()) {
      recursivelyPopulateMenuItemsForNode(service,menuItemBuilder,node.getParent(),menu);
    }
}

@Before
public void setUp() {
    ShadowAccessibilityNodeInfo.resetobtainedInstances();
    mNodeInfoCompat = new SwitchAccessNodeCompat(AccessibilityNodeInfo.obtain());
    ShadowAccessibilityNodeInfo shadowInfo =
            (ShadowAccessibilityNodeInfo) ShadowExtractor.extract(mNodeInfoCompat.getInfo());
    shadowInfo.setBoundsInScreen(NODE_BOUNDS);
    mAccessibilityNodeActionNode = new AccessibilityNodeActionNode(
            mNodeInfoCompat,ACTION_NAME));
}

@Test
public void getActionLabel_withdisambiguationNumber_shouldReturnChangedname() {
    AccessibilityNodeActionNode accessibilityNodeActionNode = new AccessibilityNodeActionNode(
            mNodeInfoCompat,ACTION_NAME));
    accessibilityNodeActionNode.setNumberToAppendToDuplicateAction(5);
    CharSequence actionLabel = accessibilityNodeActionNode.getActionLabel(mContext);
    assertFalse(TextUtils.equals(ACTION_NAME,actionLabel));
    assertTrue(TextUtils.indexOf(actionLabel,ACTION_NAME) != -1);
    accessibilityNodeActionNode.recycle();
}

@Override
protected void onPopulateNodeForVirtualView(int virtualViewId,AccessibilityNodeInfoCompat node) {
    final boolean hasBounds = getBoundsForDay(virtualViewId,mTempRect);

    if (!hasBounds) {
        // The day is invalid,kill the node.
        mTempRect.setEmpty();
        node.setContentDescription("");
        node.setBoundsInParent(mTempRect);
        node.setVisibletoUser(false);
        return;
    }

    node.setText(getDayText(virtualViewId));
    node.setContentDescription(getDayDescription(virtualViewId));
    node.setBoundsInParent(mTempRect);

    final boolean isDayEnabled = isDayEnabled(virtualViewId);
    if (isDayEnabled) {
        node.addAction(AccessibilityActionCompat.ACTION_CLICK);
    }

    node.setEnabled(isDayEnabled);

    if (virtualViewId == mActivatedDay) {
        // Todo: This should use activated once that's supported.
        node.setChecked(true);
    }

}

public final void onInitializeAccessibilityNodeInfo(View paramView,AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat)
{
  if (DrawerLayout.CAN_HIDE_DESCENDANTS) {
    super.onInitializeAccessibilityNodeInfo(paramView,paramAccessibilityNodeInfoCompat);
  }
  for (;;)
  {
    paramAccessibilityNodeInfoCompat.setClassName(DrawerLayout.class.getName());
    paramAccessibilityNodeInfoCompat.setFocusable(false);
    paramAccessibilityNodeInfoCompat.setFocused(false);
    paramAccessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_FOCUS);
    paramAccessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
    return;
    AccessibilityNodeInfoCompat localAccessibilityNodeInfoCompat = AccessibilityNodeInfoCompat.obtain(paramAccessibilityNodeInfoCompat);
    super.onInitializeAccessibilityNodeInfo(paramView,localAccessibilityNodeInfoCompat);
    AccessibilityNodeInfoCompat.IMPL.setSource(paramAccessibilityNodeInfoCompat.mInfo,paramView);
    ViewParent localViewParent = ViewCompat.getParentForAccessibility(paramView);
    if ((localViewParent instanceof View)) {
      paramAccessibilityNodeInfoCompat.setParent((View)localViewParent);
    }
    Rect localRect = this.mTmpRect;
    localAccessibilityNodeInfoCompat.getBoundsInParent(localRect);
    AccessibilityNodeInfoCompat.IMPL.setBoundsInParent(paramAccessibilityNodeInfoCompat.mInfo,localRect);
    localAccessibilityNodeInfoCompat.getBoundsInScreen(localRect);
    AccessibilityNodeInfoCompat.IMPL.setBoundsInScreen(paramAccessibilityNodeInfoCompat.mInfo,localRect);
    boolean bool1 = AccessibilityNodeInfoCompat.IMPL.isVisibletoUser(localAccessibilityNodeInfoCompat.mInfo);
    AccessibilityNodeInfoCompat.IMPL.setVisibletoUser(paramAccessibilityNodeInfoCompat.mInfo,bool1);
    CharSequence localCharSequence1 = localAccessibilityNodeInfoCompat.getPackageName();
    AccessibilityNodeInfoCompat.IMPL.setPackageName(paramAccessibilityNodeInfoCompat.mInfo,localCharSequence1);
    paramAccessibilityNodeInfoCompat.setClassName(localAccessibilityNodeInfoCompat.getClassName());
    CharSequence localCharSequence2 = localAccessibilityNodeInfoCompat.getContentDescription();
    AccessibilityNodeInfoCompat.IMPL.setContentDescription(paramAccessibilityNodeInfoCompat.mInfo,localCharSequence2);
    boolean bool2 = localAccessibilityNodeInfoCompat.isEnabled();
    AccessibilityNodeInfoCompat.IMPL.setEnabled(paramAccessibilityNodeInfoCompat.mInfo,bool2);
    boolean bool3 = localAccessibilityNodeInfoCompat.isClickable();
    AccessibilityNodeInfoCompat.IMPL.setClickable(paramAccessibilityNodeInfoCompat.mInfo,bool3);
    paramAccessibilityNodeInfoCompat.setFocusable(localAccessibilityNodeInfoCompat.isFocusable());
    paramAccessibilityNodeInfoCompat.setFocused(localAccessibilityNodeInfoCompat.isFocused());
    boolean bool4 = AccessibilityNodeInfoCompat.IMPL.isAccessibilityFocused(localAccessibilityNodeInfoCompat.mInfo);
    AccessibilityNodeInfoCompat.IMPL.setAccessibilityFocused(paramAccessibilityNodeInfoCompat.mInfo,bool4);
    boolean bool5 = localAccessibilityNodeInfoCompat.isSelected();
    AccessibilityNodeInfoCompat.IMPL.setSelected(paramAccessibilityNodeInfoCompat.mInfo,bool5);
    boolean bool6 = localAccessibilityNodeInfoCompat.isLongClickable();
    AccessibilityNodeInfoCompat.IMPL.setLongClickable(paramAccessibilityNodeInfoCompat.mInfo,bool6);
    paramAccessibilityNodeInfoCompat.addAction(localAccessibilityNodeInfoCompat.getActions());
    AccessibilityNodeInfoCompat.IMPL.recycle(localAccessibilityNodeInfoCompat.mInfo);
    ViewGroup localViewGroup = (ViewGroup)paramView;
    int i = localViewGroup.getChildCount();
    for (int j = 0; j < i; j++)
    {
      View localView = localViewGroup.getChildAt(j);
      if (DrawerLayout.access$400(localView)) {
        AccessibilityNodeInfoCompat.IMPL.addChild(paramAccessibilityNodeInfoCompat.mInfo,localView);
      }
    }
  }
}

public static boolean isCustomAction(AccessibilityActionCompat action) {
    return action.getId() > SYstem_ACTION_MAX;
}

@Override
public boolean accept(TalkBackService service,AccessibilityNodeInfoCompat node) {
    List<AccessibilityActionCompat> actions = node.getActionList();
    return actions != null && !actions.isEmpty();
}

public ClickActionDelegate(Context context,int resId) {
    mClickAction = new AccessibilityActionCompat(
            AccessibilityNodeInfoCompat.ACTION_CLICK,context.getString(resId));
}

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    int eventType = event.getEventType();
    switch (eventType) {
        case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
        case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
        case AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED:
            for (String id : installBtnId) {
                AccessibilityNodeInfo node = AccessibilityNodeUtil.findNodeById(event.getSource(),id);
                if (node != null) {
                    AccessibilityNodeUtil.click(node);
                    Toast.makeText(this,"安装成功",Toast.LENGTH_SHORT).show();
                    break;
                }
            }
            break;
        default:
            break;
    }
}

/**
 * Update whether or not the current native tab and/or web contents are
 * currently visible (from an accessibility perspective),or whether
 * they're obscured by another view.
 */
public void updateAccessibilityVisibility() {
    View view = getView();
    if (view != null) {
        int importantForAccessibility = isObscuredByAnotherViewForAccessibility()
                ? View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
                : View.IMPORTANT_FOR_ACCESSIBILITY_YES;
        if (view.getImportantForAccessibility() != importantForAccessibility) {
            view.setImportantForAccessibility(importantForAccessibility);
            view.sendAccessibilityEvent(
                    AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
        }
    }

    ContentViewCore cvc = getContentViewCore();
    if (cvc != null) {
        boolean isWebContentObscured = isObscuredByAnotherViewForAccessibility()
                || isShowingSadTab();
        cvc.setobscuredByAnotherView(isWebContentObscured);
    }
}

private void setCurrentActivityName(AccessibilityEvent event) {
    if (event.getEventType() != AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
        return;
    }

    try {
        ComponentName componentName = new ComponentName(
                event.getPackageName().toString(),event.getClassName().toString()
        );

        getPackageManager().getActivityInfo(componentName,0);
        currentActivityName = componentName.flattenToShortString();
    } catch (PackageManager.NameNotFoundException e) {
        currentActivityName = WECHAT_LUCKMONEY_GENERAL_ACTIVITY;
    }
}

@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    // dispatch scroll events from this ViewPager.
    if (event.getEventType() == AccessibilityEventCompat.TYPE_VIEW_SCROLLED) {
        return super.dispatchPopulateAccessibilityEvent(event);
    }

    // dispatch all other accessibility events from the current page.
    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() == VISIBLE) {
            final YViewPagerNew.ItemInfo ii = infoForChild(child);
            if (ii != null && ii.position == mCurItem
                    && child.dispatchPopulateAccessibilityEvent(event)) {
                return true;
            }
        }
    }

    return false;
}

/**
 * 内容改变
 *
 * @param event
 */

private void contentChange(AccessibilityEvent event) {
    AccessibilityNodeInfo root = getRootInActiveWindow();
    if (root == null) {
        return;
    }
    if (WechatVersionUtils.canFindViewById(context) && WechatVersionUtils.canRobWechatVersion(context)) {

        List<AccessibilityNodeInfo> exitNodeInfos = root.findAccessibilityNodeInfosByViewId(WechatVersionUtils.getWechatExitId(context));

        if (exitNodeInfos != null && exitNodeInfos.size() > 0) {
            // 是聊天界面
            if (isWechatAlway) {
            }
        } else {
            isWechatAlway = false;
        }
    }
}

public void autochat(AccessibilityEvent event,AccessibilityNodeInfo node,WeixinAutoService context,Map<String,String> record){
    int eventType = event.getEventType();
    //1、消息列表获取信息头像
    List<AccessibilityNodeInfo> msgNumImages= node.findAccessibilityNodeInfosByViewId("com.tencent.mm:id/i4");
    if(msgNumImages!=null&&msgNumImages.size()>0){
        AutoUtil.performClick(AutoUtil.fineNodeByIdAndText(context.getRootInActiveWindow(),"com.tencent.mm:id/afv","杰"),record,"杰",1000);
        sendMsg(context.getRootInActiveWindow(),context,record);
        AutoUtil.performClick(AutoUtil.fineNodeByIdAndText(context.getRootInActiveWindow(),"LSan"),"LSan",record);
        AutoUtil.performClick(AutoUtil.fineNodeByIdAndText(node,"华"),"华",1000);
        sendMsg(node,"Aoo"),"Aoo","曼婷"),"苏苏"),"zh琪"),record);
    }
}

void dispatchOnDrawerOpened(View drawerView) {
  final LayoutParams lp = (LayoutParams) drawerView.getLayoutParams();
  if (!lp.kNownopen) {
    lp.kNownopen = true;
    if (mListener != null) {
      mListener.onDrawerOpened(drawerView);
    }

    updateChildrenImportantForAccessibility(drawerView,true);

    // Only send WINDOW_STATE_CHANGE if the host has window focus.
    if (hasWindowFocus()) {
      sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
    }

    drawerView.requestFocus();
  }
}

@TargetApi(16)
@Override
public boolean performAccessibilityAction(int action,Bundle args) {
  if (super.performAccessibilityAction(action,args)) {
    return true;
  }
  if (duration <= 0) {
    return false;
  }
  if (action == AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD) {
    if (scrubIncrementally(-getPositionIncrement())) {
      stopScrubbing(false);
    }
  } else if (action == AccessibilityNodeInfo.ACTION_SCROLL_FORWARD) {
    if (scrubIncrementally(getPositionIncrement())) {
      stopScrubbing(false);
    }
  } else {
    return false;
  }
  sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
  return true;
}

@Override
public void onInitializeAccessibilityEvent(View host,AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(host,event);
    event.setClassName(DirectionalViewpager.class.getName());
    AccessibilityRecordCompat recordCompat = null;
    if (isHorizontal()) {
        recordCompat =
                AccessibilityEventCompat.asRecord(event);
    } else {
        recordCompat = AccessibilityRecordCompat.obtain();
    }
    recordCompat.setScrollable(canScroll());
    if (event.getEventType() == AccessibilityEventCompat.TYPE_VIEW_SCROLLED
            && mAdapter != null) {
        recordCompat.setItemCount(mAdapter.getCount());
        recordCompat.setFromIndex(mCurItem);
        recordCompat.setToIndex(mCurItem);
    }
}

public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    event.setClassName(getClass().getName());
    event.setPackageName(getPackageName());

    LayoutParams params = getwindow().getAttributes();
    boolean isFullScreen = (params.width == LayoutParams.MATCH_PARENT) &&
            (params.height == LayoutParams.MATCH_PARENT);
    event.setFullScreen(isFullScreen);

    CharSequence title = getTitle();
    if (!TextUtils.isEmpty(title)) {
        event.getText().add(title);
    }

    return true;
}

@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    // dispatch scroll events from this ViewPager.
    if (event.getEventType() == AccessibilityEventCompat.TYPE_VIEW_SCROLLED) {
        return super.dispatchPopulateAccessibilityEvent(event);
    }

    // dispatch all other accessibility events from the current page.
    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() == VISIBLE) {
            final ItemInfo ii = infoForChild(child);
            if (ii != null && ii.position == mCurItem &&
                    child.dispatchPopulateAccessibilityEvent(event)) {
                return true;
            }
        }
    }

    return false;
}

private void sendScrollAccessibilityEvent() {
    AccessibilityManager am =
            (AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
    if (am.isEnabled()) {
        if (mCurrentPage != getNextPage()) {
            AccessibilityEvent ev =
                    AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED);
            ev.setScrollable(true);
            ev.setScrollX(getScrollX());
            ev.setScrollY(getScrollY());
            ev.setMaxScrollX(mMaxScrollX);
            ev.setMaxScrollY(0);

            sendAccessibilityEventUnchecked(ev);
        }
    }
}

@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    final boolean result = super.dispatchPopulateAccessibilityEvent(event);
    final List<CharSequence> text = event.getText();
    text.clear();
    // Populate event with a fake title based on the current state.
    if (mState == State.APPS) {
        text.add(getString(R.string.all_apps_button_label));
    } else if (mState == State.WIDGETS) {
        text.add(getString(R.string.widget_button_text));
    } else if (mWorkspace != null) {
        text.add(mWorkspace.getCurrentPageDescription());
    } else {
        text.add(getString(R.string.all_apps_home_button_label));
    }
    return result;
}

@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    if (getChildCount() > 0) {
        final AccessibilityRecordCompat record = AccessibilityEventCompat
                .asRecord(event);
        final View start = findFirstVisibleItemClosestToStart(false,true);
        final View end = findFirstVisibleItemClosestToEnd(false,true);
        if (start == null || end == null) {
            return;
        }
        final int startPos = getPosition(start);
        final int endPos = getPosition(end);
        if (startPos < endPos) {
            record.setFromIndex(startPos);
            record.setToIndex(endPos);
        } else {
            record.setFromIndex(endPos);
            record.setToIndex(startPos);
        }
    }
}

public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    boolean populated = false;
    if (event.getEventType() == 8) {
        event.setEventType(4);
    }
    View selectedView = getSelectedView();
    if (selectedView != null) {
        populated = selectedView.dispatchPopulateAccessibilityEvent(event);
    }
    if (!populated) {
        if (selectedView != null) {
            event.setEnabled(selectedView.isEnabled());
        }
        event.setItemCount(getCount());
        event.setCurrentItemIndex(getSelectedItemPosition());
    }
    return populated;
}

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {

    SharedPreferences settings = getSharedPreferences(data,0);
    settingRoom = settings.getString(settingRoomField,"");
    settingDevices = settings.getString(settingDevicesField,"");

    if (settingRoom.equals("") || settingDevices.equals("")) {
        tellUser("配置檔不完整");
        return;
    }

    int eventType = event.getEventType();
    if (eventType == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED) {
        preProcess(event);
        Log.i(TAG,"onAccessibilityEvent");
    }

}

public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    if (getChildCount() > 0) {
        AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
        View start = findFirstVisibleItemClosestToStart(false,true);
        View end = findFirstVisibleItemClosestToEnd(false,true);
        if (start != null && end != null) {
            int startPos = getPosition(start);
            int endPos = getPosition(end);
            if (startPos < endPos) {
                record.setFromIndex(startPos);
                record.setToIndex(endPos);
                return;
            }
            record.setFromIndex(endPos);
            record.setToIndex(startPos);
        }
    }
}

@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    // dispatch scroll events from this ViewPager.
    if (event.getEventType() == AccessibilityEventCompat.TYPE_VIEW_SCROLLED) {
        return super.dispatchPopulateAccessibilityEvent(event);
    }

    // dispatch all other accessibility events from the current page.
    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() == VISIBLE) {
            final YViewPagerOrigin.ItemInfo ii = infoForChild(child);
            if (ii != null && ii.position == mCurItem
                    && child.dispatchPopulateAccessibilityEvent(event)) {
                return true;
            }
        }
    }

    return false;
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
private void openHongBao(AccessibilityEvent event)
{
    CharSequence className = event.getClassName();

    checkScreen(getApplicationContext());

    if ("com.tencent.mm.plugin.luckymoney.ui.LuckyMoneyReceiveUI".equals(className))
    {
        // 点中了红包，下一步就是去拆红包
        checkKey1();
    } else if ("com.tencent.mm.ui.LauncherUI".equals(className) || "com.tencent.mobileqq.activity.ChatActivity".equals(className))
    {
        // 在聊天界面,去点中红包
        checkKey2();
    } else
    {
        // 在聊天界面,去点中红包
        checkKey2();
    }
}

/**
 */
@Override
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public void onInitializeAccessibilityEvent(@NonNull AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    event.setClassName(GridViewWidget.class.getName());
}

public void autoFetchFrData(AccessibilityEvent event,String> record){
    if(node==null){
        LogUtil.d("autoFetchFrData","node 为空；");
        node = context.getRootInActiveWindow();
        return;
    }
    Set<String> set = new HashSet<String>();
    //if(node.getChildCount()>0){
        List<AccessibilityNodeInfo> items = new ArrayList<AccessibilityNodeInfo>();
        List<AccessibilityNodeInfo> items0 = node.findAccessibilityNodeInfosByViewId("com.tencent.mm:id/b66");
        List<AccessibilityNodeInfo> items1 = node.findAccessibilityNodeInfosByViewId("com.tencent.mm:id/mo");
        if(items0==null&&items1==null){ LogUtil.d("autoFetchFrData","列表数据为空");return;}
        items.addAll(items0);
        items.addAll(items1);
        if(items!=null&&items.size()>0){
            for(AccessibilityNodeInfo item:items){
                String text = item.getText().toString();
                set.add(text);
                if(isExist(strs,text)){
                    System.out.println("重复---->"+text);
                }else{
                    LogUtil.d("autoFetchFrData",text);
                }
            }
        }
   // }
    int waitTimes = 4000+(int) (Math.random()*1200);
    AutoUtil.sleep(waitTimes);
    AccessibilityNodeInfo nodeInfo2 = AutoUtil.findNodeInfosById(node,"com.tencent.mm:id/csl");//listView
    if(nodeInfo2!=null){
        nodeInfo2.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
    }
}

@TargetApi(14)
public boolean onRequestSendAccessibilityEvent(View child,AccessibilityEvent event) {
    if (!super.onRequestSendAccessibilityEvent(child,event)) {
        return false;
    }
    AccessibilityEvent record = AccessibilityEvent.obtain();
    onInitializeAccessibilityEvent(record);
    child.dispatchPopulateAccessibilityEvent(record);
    event.appendRecord(record);
    return true;
}

@Override
public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
    if (shouldDeferAccessibilityEvent(event)) {
        return;
    }
    super.sendAccessibilityEventUnchecked(event);
}

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    //虚拟手机按键处理，优先级高于是否点击分词的判断
    if ((event.getEventType() == TYPE_VIEW_LONG_CLICKED) && ("com.android.systemUI".equals(event.getPackageName())))
    {
        if (TextUtils.isEmpty(event.getContentDescription())){
            return;
        }
        //长按虚拟机触发的，需要转到按键处理去
        if (!TextUtils.isEmpty(back) && event.getContentDescription().equals(back)){
            KeypressedTipViewController.getInstance().onKeyLongPress(KeyEvent.KEYCODE_BACK);
        }else if (!TextUtils.isEmpty(home) && event.getContentDescription().equals(home)){
            KeypressedTipViewController.getInstance().onKeyLongPress(KeyEvent.KEYCODE_HOME);
        }else if (!TextUtils.isEmpty(recent) && event.getContentDescription().equals(recent)){
            KeypressedTipViewController.getInstance().onKeyLongPress(KeyEvent.KEYCODE_APP_SWITCH);
        }
    }
    if (!isRun){
        return;
    }
    LogUtil.d(TAG,"onAccessibilityEvent:"+event);
    int type=event.getEventType();
    switch (type){
        case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
            mWindowClassName = event.getClassName();
            mCurrentPackage = event.getPackageName()==null?"":event.getPackageName().toString();
            Integer selectType=selections.get(mCurrentPackage);
            mCurrentType = selectType==null?TYPE_VIEW_NONE:(selectType+1);
            if ("com.tencent.mm.plugin.sns.ui.SnsTimeLineUI".equals(mWindowClassName)){
                setCapabilities(true);
            }else {
                setCapabilities(false);
            }
            break;
        case TYPE_VIEW_CLICKED:
        case TYPE_VIEW_LONG_CLICKED:
            getText(event);
            break;
    }
}

@Override
public boolean dispatchPopulateAccessibilityEvent( AccessibilityEvent event ) {
    View selectedView = getSelectedView();
    if ( selectedView != null && selectedView.getVisibility() == VISIBLE
            && selectedView.dispatchPopulateAccessibilityEvent( event ) ) {
        return true;
    }
    return false;
}

public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    if (getChildCount() > 0) {
        AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
        record.setFromIndex(findFirstVisibleItemPosition());
        record.setToIndex(findLastVisibleItemPosition());
    }
}

@Override
public void onInitializeAccessibilityEvent(View host,event);
    event.setClassName(ViewPager.class.getName());
    final AccessibilityRecordCompat recordCompat = AccessibilityRecordCompat.obtain();
    recordCompat.setScrollable(canScroll());
    if (event.getEventType() == AccessibilityEventCompat.TYPE_VIEW_SCROLLED
            && mAdapter != null) {
        recordCompat.setItemCount(mAdapter.getCount());
        recordCompat.setFromIndex(mCurItem);
        recordCompat.setToIndex(mCurItem);
    }
}

public boolean requestSendAccessibilityEvent(ViewParent parent,View child,AccessibilityEvent event) {
    if (child == null) {
        return false;
    }
    ((AccessibilityManager) child.getContext().getSystemService("accessibility")).sendAccessibilityEvent(event);
    return true;
}

@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    event.setScrollable(isScrollableForAccessibility());
    View selectedView = getSelectedView();
    if (selectedView != null) {
        event.setEnabled(selectedView.isEnabled());
    }
    event.setCurrentItemIndex(getSelectedItemPosition());
    event.setFromIndex(getFirstVisiblePosition());
    event.setToIndex(getLastVisiblePosition());
    event.setItemCount(getCount());
}

private void onViewFocused(AccessibilityEvent event,AccessibilityNodeInfo rootNode) {

        if(mEvent != null && event != null) {
            // Store Text Input.
            AccEvent accEvent = new AccEvent(event,rootNode);
            accEvent.setFieldValue(AccEvent.TEXT,mEvent.text);
            this.output(accEvent);
        }
        this.mEvent = null;
    }

public void onInitializeAccessibilityEvent(View host,event);
    event.setClassName(ViewPager.class.getName());
    AccessibilityRecordCompat recordCompat = AccessibilityEventCompat.asRecord(event);
    recordCompat.setScrollable(canScroll());
    if (event.getEventType() == 4096 && ViewPager.this.mAdapter != null) {
        recordCompat.setItemCount(ViewPager.this.mAdapter.getCount());
        recordCompat.setFromIndex(ViewPager.this.mCurItem);
        recordCompat.setToIndex(ViewPager.this.mCurItem);
    }
}

private void dispatchContentChangedIfNecessary() {
    int flags = this.mEatenAccessibilityChangeFlags;
    this.mEatenAccessibilityChangeFlags = 0;
    if (flags != 0 && isAccessibilityEnabled()) {
        AccessibilityEvent event = AccessibilityEvent.obtain();
        event.setEventType(2048);
        AccessibilityEventCompat.setContentChangeTypes(event,flags);
        sendAccessibilityEventUnchecked(event);
    }
}

@Override
public void onAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
    int eventType = accessibilityEvent.getEventType();
    switch (eventType) {
        case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
            if (mForceStopManager.isForceStopRequested()) {
                mForceStopManager.onAccessibilityEvent(accessibilityEvent);
            }
            break;
    }
}

private void sendAccessibilityEventForVirtualText(int eventType) {
    if (((AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE)).isEnabled()) {
        AccessibilityEvent event = AccessibilityEvent.obtain(eventType);
        mInputText.onInitializeAccessibilityEvent(event);
        mInputText.onPopulateAccessibilityEvent(event);
        event.setSource(NumberPicker.this,VIRTUAL_VIEW_ID_INPUT);
        requestSendAccessibilityEvent(NumberPicker.this,event);
    }
}

private void onTimeChanged() {
    mDelegator.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
    if (mOnTimeChangedListener != null) {
        mOnTimeChangedListener.onTimeChanged(mDelegator,getHour(),getMinute());
    }
    if (mAutoFillchangelistener != null) {
        mAutoFillchangelistener.onTimeChanged(mDelegator,getMinute());
    }
}

public boolean onRequestSendAccessibilityEvent(View paramView,AccessibilityEvent paramAccessibilityEvent) {
    if (super.onRequestSendAccessibilityEvent(paramView,paramAccessibilityEvent)) {
        AccessibilityEvent localAccessibilityEvent = AccessibilityEvent.obtain();
        onInitializeAccessibilityEvent(localAccessibilityEvent);
        paramView.dispatchPopulateAccessibilityEvent(localAccessibilityEvent);
        paramAccessibilityEvent.appendRecord(localAccessibilityEvent);
        return true;
    }
    return false;
}

AccEvent(AccessibilityEvent accessibilityEvent,AccessibilityNodeInfo rootNode) {
    this.setFieldValue(EVENT,accessibilityEvent);
    this.setFieldValue(EVENT_TIME,accessibilityEvent.getEventTime());
    this.setFieldValue(ROOT_NODE,rootNode);
    this.setFieldValue(EVENT_TYPE,accessibilityEvent.getEventType());
    CharSequence charSequence = accessibilityEvent.getPackageName();
    String packageName = charSequence == null ? "" : charSequence.toString();
    this.setFieldValue(PACKAGE_NAME,packageName);
}

/**
 */
@Override
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public void onInitializeAccessibilityEvent(@NonNull AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    event.setClassName(FrameLayoutWidget.class.getName());
}

private AccessibilityEvent createEvent(int virtualViewId,int eventType) {
    switch (virtualViewId) {
        case -1:
            return createEventForHost(eventType);
        default:
            return createEventForChild(virtualViewId,eventType);
    }
}

@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);
    if (getChildCount() > 0) {
        final AccessibilityRecordCompat record = AccessibilityEventCompat
                .asRecord(event);
        record.setFromIndex(findFirstVisibleItemPosition());
        record.setToIndex(findLastVisibleItemPosition());
    }
}