Java Code Examples for android.accessibilityservice.AccessibilityServiceInfo#FEEDBACK_SPOKEN

@Override
    protected void onServiceConnected() {
        super.onServiceConnected();
        registerScreenReceiver();
        if (BuildConfig.DEBUG) {
            Log.d(TAG, "onServiceConnected: ");
        }
        sIsEnable = true;
        AccessibilityServiceInfo info = new AccessibilityServiceInfo();
        info.eventTypes = TYPE_WINDOW_CONTENT_CHANGED | TYPE_WINDOWS_CHANGED | TYPE_WINDOW_STATE_CHANGED | TYPE_NOTIFICATION_STATE_CHANGED;

        // If you only want this service to work with specific applications, set their
        // package names here.  Otherwise, when the service is activated, it will listen
        // to events from all applications.
        info.packageNames = new String[]{Constant.QQ_PKG};

        info.feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN;
//        info.flags = AccessibilityServiceInfo.DEFAULT;
        info.notificationTimeout = 100;

        this.setServiceInfo(info);
        setState(new IdleState(this));
    }
 

/**
 * Provides feedback to announce the screen state change. Such a change
 * is turning the screen on or off.
 *
 * @param feedbackIndex The index of the feedback in the statically
 *            mapped feedback resources.
 */
private void provideScreenStateChangeFeedback(int feedbackIndex) {
    // We take a specific action depending on the feedback we currently provide.
    switch (mProvidedFeedbackType) {
        case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
            String utterance = generateScreenOnOrOffUtternace(feedbackIndex);
            mHandler.obtainMessage(MESSAGE_SPEAK, utterance).sendToTarget();
            return;
        case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
            mHandler.obtainMessage(MESSAGE_PLAY_EARCON, feedbackIndex, 0).sendToTarget();
            return;
        case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
            mHandler.obtainMessage(MESSAGE_VIBRATE, feedbackIndex, 0).sendToTarget();
            return;
        default:
            throw new IllegalStateException("Unexpected feedback type "
                    + mProvidedFeedbackType);
    }
}
 

@Override
public boolean shouldShowFullScreen() {

    // Show full screen image stream if the app is in multi window or picture in picture mode
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        if (activity.isInMultiWindowMode() || activity.isInPictureInPictureMode()) {
            return true;
        }
    }

    // If there's a hardware keyboard attached show the picker in full screen mode
    final boolean hasHardwareKeyboard =
            activity.getResources().getConfiguration().keyboard != Configuration.KEYBOARD_NOKEYS;
    if (hasHardwareKeyboard) {
        return true;
    }

    // If there's an accessibility service enabled, show in full screen mode
    // Exclude AccessibilityServiceInfo.FEEDBACK_GENRICE this is used by password mangers.
    final AccessibilityManager manager = (AccessibilityManager) activity.getSystemService(Context.ACCESSIBILITY_SERVICE);
    if (manager != null) {
        int flags = AccessibilityServiceInfo.FEEDBACK_AUDIBLE | AccessibilityServiceInfo.FEEDBACK_SPOKEN
                | AccessibilityServiceInfo.FEEDBACK_VISUAL | AccessibilityServiceInfo.FEEDBACK_BRAILLE
                | AccessibilityServiceInfo.FEEDBACK_HAPTIC;
        final List<AccessibilityServiceInfo> enabledAccessibilityServiceList = manager.getEnabledAccessibilityServiceList(flags);

        if (enabledAccessibilityServiceList != null && enabledAccessibilityServiceList.size() > 0) {
            return true;
        }
    }

    return false;
}
 

/** Returns true if we should animate the Snackbar view in/out. */
boolean shouldAnimate() {
  int feedbackFlags = AccessibilityServiceInfo.FEEDBACK_SPOKEN;
  List<AccessibilityServiceInfo> serviceList =
      accessibilityManager.getEnabledAccessibilityServiceList(feedbackFlags);
  return serviceList != null && serviceList.isEmpty();
}
 

private void updateServiceInfoIfFeedbackTypeChanged() {
  boolean spokenFeedbackEnabled = SwitchAccessPreferenceUtils.isSpokenFeedbackEnabled(this);
  boolean hapticFeedbackEnabled = SwitchAccessPreferenceUtils.shouldPlayVibrationFeedback(this);
  boolean auditoryFeedbackEnabled = SwitchAccessPreferenceUtils.shouldPlaySoundFeedback(this);

  if ((spokenFeedbackEnabled == spokenFeedbackEnabledInServiceInfo)
      && (hapticFeedbackEnabled == hapticFeedbackEnabledInServiceInfo)
      && (auditoryFeedbackEnabled == auditoryFeedbackEnabledInServiceInfo)) {
    return;
  }

  AccessibilityServiceInfo serviceInfo = getServiceInfo();
  if (serviceInfo == null) {
    LogUtils.e(TAG, "Failed to update feedback type, service info was null");
    return;
  }

  if (spokenFeedbackEnabled) {
    serviceInfo.feedbackType |= AccessibilityServiceInfo.FEEDBACK_SPOKEN;
  } else {
    serviceInfo.feedbackType &= ~AccessibilityServiceInfo.FEEDBACK_SPOKEN;
  }
  if (hapticFeedbackEnabled) {
    serviceInfo.feedbackType |= AccessibilityServiceInfo.FEEDBACK_HAPTIC;
  } else {
    serviceInfo.feedbackType &= ~AccessibilityServiceInfo.FEEDBACK_HAPTIC;
  }
  if (auditoryFeedbackEnabled) {
    serviceInfo.feedbackType |= AccessibilityServiceInfo.FEEDBACK_AUDIBLE;
  } else {
    serviceInfo.feedbackType &= ~AccessibilityServiceInfo.FEEDBACK_AUDIBLE;
  }
  setServiceInfo(serviceInfo);

  spokenFeedbackEnabledInServiceInfo = spokenFeedbackEnabled;
  hapticFeedbackEnabledInServiceInfo = hapticFeedbackEnabled;
  auditoryFeedbackEnabledInServiceInfo = auditoryFeedbackEnabled;
}
 

@Override
protected void onServiceConnected() {
    super.onServiceConnected();
    AccessibilityServiceInfo info = new AccessibilityServiceInfo();
    info.packageNames = null; //监听过滤的包名 null to all
    info.eventTypes = AccessibilityEvent.TYPES_ALL_MASK; //监听哪些行为
    info.feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN; //反馈
    info.notificationTimeout = 100; //通知的时间
    setServiceInfo(info);
    Log.printStackTrace();
    Log.e("TestAccessibilitySerivce onServiceConnected");
}
 

/**
 * Returns the string representation of a feedback type. For example,
 * {@link AccessibilityServiceInfo#FEEDBACK_SPOKEN} is represented by the
 * string FEEDBACK_SPOKEN.
 *
 * @param feedbackType The feedback type.
 * @return The string representation.
 */
public static String feedbackTypeToString(int feedbackType) {
    StringBuilder builder = new StringBuilder();
    builder.append("[");
    while (feedbackType > 0) {
        final int feedbackTypeFlag = 1 << Integer.numberOfTrailingZeros(feedbackType);
        feedbackType &= ~feedbackTypeFlag;
        if (builder.length() > 1) {
            builder.append(", ");
        }
        switch (feedbackTypeFlag) {
            case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
                builder.append("FEEDBACK_AUDIBLE");
                break;
            case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
                builder.append("FEEDBACK_HAPTIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_GENERIC:
                builder.append("FEEDBACK_GENERIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
                builder.append("FEEDBACK_SPOKEN");
                break;
            case AccessibilityServiceInfo.FEEDBACK_VISUAL:
                builder.append("FEEDBACK_VISUAL");
                break;
        }
    }
    builder.append("]");
    return builder.toString();
}
 

/**
 * Returns the string representation of a feedback type. For example,
 * {@link AccessibilityServiceInfo#FEEDBACK_SPOKEN} is represented by the
 * string FEEDBACK_SPOKEN.
 *
 * @param feedbackType The feedback type.
 * @return The string representation.
 */
public static String feedbackTypeToString(int feedbackType) {
    StringBuilder builder = new StringBuilder();
    builder.append("[");
    while (feedbackType > 0) {
        final int feedbackTypeFlag = 1 << Integer.numberOfTrailingZeros(feedbackType);
        feedbackType &= ~feedbackTypeFlag;
        if (builder.length() > 1) {
            builder.append(", ");
        }
        switch (feedbackTypeFlag) {
            case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
                builder.append("FEEDBACK_AUDIBLE");
                break;
            case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
                builder.append("FEEDBACK_HAPTIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_GENERIC:
                builder.append("FEEDBACK_GENERIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
                builder.append("FEEDBACK_SPOKEN");
                break;
            case AccessibilityServiceInfo.FEEDBACK_VISUAL:
                builder.append("FEEDBACK_VISUAL");
                break;
        }
    }
    builder.append("]");
    return builder.toString();
}
 

/**
 * Returns the string representation of a feedback type. For example,
 * {@link AccessibilityServiceInfo#FEEDBACK_SPOKEN} is represented by the
 * string FEEDBACK_SPOKEN.
 *
 * @param feedbackType The feedback type.
 * @return The string representation.
 */
public static String feedbackTypeToString(int feedbackType) {
    StringBuilder builder = new StringBuilder();
    builder.append("[");
    while (feedbackType > 0) {
        final int feedbackTypeFlag = 1 << Integer.numberOfTrailingZeros(feedbackType);
        feedbackType &= ~feedbackTypeFlag;
        if (builder.length() > 1) {
            builder.append(", ");
        }
        switch (feedbackTypeFlag) {
            case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
                builder.append("FEEDBACK_AUDIBLE");
                break;
            case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
                builder.append("FEEDBACK_HAPTIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_GENERIC:
                builder.append("FEEDBACK_GENERIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
                builder.append("FEEDBACK_SPOKEN");
                break;
            case AccessibilityServiceInfo.FEEDBACK_VISUAL:
                builder.append("FEEDBACK_VISUAL");
                break;
        }
    }
    builder.append("]");
    return builder.toString();
}
 

/**
 * Returns the string representation of a feedback type. For example,
 * {@link AccessibilityServiceInfo#FEEDBACK_SPOKEN} is represented by the
 * string FEEDBACK_SPOKEN.
 *
 * @param feedbackType The feedback type.
 * @return The string representation.
 */
public static String feedbackTypeToString(int feedbackType) {
    StringBuilder builder = new StringBuilder();
    builder.append("[");
    while (feedbackType > 0) {
        final int feedbackTypeFlag = 1 << Integer.numberOfTrailingZeros(feedbackType);
        feedbackType &= ~feedbackTypeFlag;
        if (builder.length() > 1) {
            builder.append(", ");
        }
        switch (feedbackTypeFlag) {
            case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
                builder.append("FEEDBACK_AUDIBLE");
                break;
            case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
                builder.append("FEEDBACK_HAPTIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_GENERIC:
                builder.append("FEEDBACK_GENERIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
                builder.append("FEEDBACK_SPOKEN");
                break;
            case AccessibilityServiceInfo.FEEDBACK_VISUAL:
                builder.append("FEEDBACK_VISUAL");
                break;
        }
    }
    builder.append("]");
    return builder.toString();
}
 

/**
 * Returns the string representation of a feedback type. For example,
 * {@link AccessibilityServiceInfo#FEEDBACK_SPOKEN} is represented by the
 * string FEEDBACK_SPOKEN.
 *
 * @param feedbackType The feedback type.
 * @return The string representation.
 */
public static String feedbackTypeToString(int feedbackType) {
    StringBuilder builder = new StringBuilder();
    builder.append("[");
    while (feedbackType > 0) {
        final int feedbackTypeFlag = 1 << Integer.numberOfTrailingZeros(feedbackType);
        feedbackType &= ~feedbackTypeFlag;
        if (builder.length() > 1) {
            builder.append(", ");
        }
        switch (feedbackTypeFlag) {
            case AccessibilityServiceInfo.FEEDBACK_AUDIBLE:
                builder.append("FEEDBACK_AUDIBLE");
                break;
            case AccessibilityServiceInfo.FEEDBACK_HAPTIC:
                builder.append("FEEDBACK_HAPTIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_GENERIC:
                builder.append("FEEDBACK_GENERIC");
                break;
            case AccessibilityServiceInfo.FEEDBACK_SPOKEN:
                builder.append("FEEDBACK_SPOKEN");
                break;
            case AccessibilityServiceInfo.FEEDBACK_VISUAL:
                builder.append("FEEDBACK_VISUAL");
                break;
        }
    }
    builder.append("]");
    return builder.toString();
}
 

/**
 * Configures the service according to a ringer mode. Possible
 * configurations:
 * <p>
 *   1. {@link AudioManager#RINGER_MODE_SILENT}<br/>
 *   Goal:     Provide only custom haptic feedback.<br/>
 *   Approach: Take over the haptic feedback by configuring this service to provide
 *             such and do so. This way the system will not call the default haptic
 *             feedback service KickBack.<br/>
 *             Take over the audible and spoken feedback by configuring this
 *             service to provide such feedback but not doing so. This way the system
 *             will not call the default spoken feedback service TalkBack and the
 *             default audible feedback service SoundBack.
 * </p>
 * <p>
 *   2. {@link AudioManager#RINGER_MODE_VIBRATE}<br/>
 *   Goal:     Provide custom audible and default haptic feedback.<br/>
 *   Approach: Take over the audible feedback and provide custom one.<br/>
 *             Take over the spoken feedback but do not provide such.<br/>
 *             Let some other service provide haptic feedback (KickBack).
 * </p>
 * <p>
 *   3. {@link AudioManager#RINGER_MODE_NORMAL}
 *   Goal:     Provide custom spoken, default audible and default haptic feedback.<br/>
 *   Approach: Take over the spoken feedback and provide custom one.<br/>
 *             Let some other services provide audible feedback (SounBack) and haptic
 *             feedback (KickBack).
 * </p>
 *
 * @param ringerMode The device ringer mode.
 */
private void configureForRingerMode(int ringerMode) {
    if (ringerMode == AudioManager.RINGER_MODE_SILENT) {
        // When the ringer is silent we want to provide only haptic feedback.
        mProvidedFeedbackType = AccessibilityServiceInfo.FEEDBACK_HAPTIC;

        // Take over the spoken and sound feedback so no such feedback is provided.
        setServiceInfo(AccessibilityServiceInfo.FEEDBACK_HAPTIC
                | AccessibilityServiceInfo.FEEDBACK_SPOKEN
                | AccessibilityServiceInfo.FEEDBACK_AUDIBLE);

        // Use only an earcon to announce ringer state change.
        mHandler.obtainMessage(MESSAGE_PLAY_EARCON, INDEX_RINGER_SILENT, 0).sendToTarget();
    } else if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {
        // When the ringer is vibrating we want to provide only audible feedback.
        mProvidedFeedbackType = AccessibilityServiceInfo.FEEDBACK_AUDIBLE;

        // Take over the spoken feedback so no spoken feedback is provided.
        setServiceInfo(AccessibilityServiceInfo.FEEDBACK_AUDIBLE
                | AccessibilityServiceInfo.FEEDBACK_SPOKEN);

        // Use only an earcon to announce ringer state change.
        mHandler.obtainMessage(MESSAGE_PLAY_EARCON, INDEX_RINGER_VIBRATE, 0).sendToTarget();
    } else if (ringerMode == AudioManager.RINGER_MODE_NORMAL) {
        // When the ringer is ringing we want to provide spoken feedback
        // overriding the default spoken feedback.
        mProvidedFeedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN;
        setServiceInfo(AccessibilityServiceInfo.FEEDBACK_SPOKEN);

        // Use only an earcon to announce ringer state change.
        mHandler.obtainMessage(MESSAGE_PLAY_EARCON, INDEX_RINGER_NORMAL, 0).sendToTarget();
    }
}
 

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    Log.i(LOG_TAG, mProvidedFeedbackType + " " + event.toString());

    // Here we act according to the feedback type we are currently providing.
    if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_SPOKEN) {
        mHandler.obtainMessage(MESSAGE_SPEAK, formatUtterance(event)).sendToTarget();
    } else if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_AUDIBLE) {
        mHandler.obtainMessage(MESSAGE_PLAY_EARCON, event.getEventType(), 0).sendToTarget();
    } else if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_HAPTIC) {
        mHandler.obtainMessage(MESSAGE_VIBRATE, event.getEventType(), 0).sendToTarget();
    } else {
        throw new IllegalStateException("Unexpected feedback type " + mProvidedFeedbackType);
    }
}
 

@Override
public void onInterrupt() {
    // Here we act according to the feedback type we are currently providing.
    if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_SPOKEN) {
        mHandler.obtainMessage(MESSAGE_STOP_SPEAK).sendToTarget();
    } else if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_AUDIBLE) {
        mHandler.obtainMessage(MESSAGE_STOP_PLAY_EARCON).sendToTarget();
    } else if (mProvidedFeedbackType == AccessibilityServiceInfo.FEEDBACK_HAPTIC) {
        mHandler.obtainMessage(MESSAGE_STOP_VIBRATE).sendToTarget();
    } else {
        throw new IllegalStateException("Unexpected feedback type " + mProvidedFeedbackType);
    }
}
 

/**
     * Set the content this service should be receiving
     */
    private void setDynamicContent() {
        if (DEBUG) {
            MyLog.i(CLS_NAME, "setDynamicContent: interceptGoogle: " + initInterceptGoogle);
            MyLog.i(CLS_NAME, "setDynamicContent: announceNotifications: " + initAnnounceNotifications);
        }

        if (!initInterceptGoogle && !initAnnounceNotifications) {
            if (DEBUG) {
                MyLog.i(CLS_NAME, "setDynamicContent: none required: finishing");
            }

//            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
//                this.disableSelf();
//            }
//
//            this.stopSelf();

        } else {
            if (DEBUG) {
                MyLog.i(CLS_NAME, "setDynamicContent: updating content");
            }

            final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();

            serviceInfo.feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN;
            serviceInfo.flags = AccessibilityServiceInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS;
            serviceInfo.notificationTimeout = UPDATE_TIMEOUT;

            if (initInterceptGoogle && initAnnounceNotifications) {
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
                        | AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
                        | AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
            } else if (initInterceptGoogle) {
                serviceInfo.packageNames = new String[]{Installed.PACKAGE_NAME_GOOGLE_NOW};
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
                        | AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED;
            } else {
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
            }

            this.setServiceInfo(serviceInfo);
        }
    }