Java Code Examples for android.accessibilityservice.AccessibilityServiceInfo#FEEDBACK_AUDIBLE

/**
 * 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;
}
 

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;
}
 

protected void initServiceInfo() {
	mInfo.eventTypes = AccessibilityEvent.TYPES_ALL_MASK;
    mInfo.notificationTimeout = 100;
    
    // This is the KEY (to KeyEvents)! Sweet deal.
    mInfo.flags = AccessibilityServiceInfo.FLAG_REQUEST_FILTER_KEY_EVENTS;

	// We'll respond with a popup (visual), and possibly a noise (audible)
	// and/ or a vibration (haptic). No spoken feedback here!
    mInfo.feedbackType = (AccessibilityServiceInfo.FEEDBACK_VISUAL	|
    					  AccessibilityServiceInfo.FEEDBACK_AUDIBLE	|
    					  AccessibilityServiceInfo.FEEDBACK_HAPTIC	);
    
    setServiceInfo(mInfo);
}
 

/**
 * 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();
}
 

protected void initServiceInfo() {
	mInfo.eventTypes = AccessibilityEvent.TYPES_ALL_MASK;
    mInfo.notificationTimeout = 100;
    
    // This is the KEY (to KeyEvents)! Sweet deal.
    mInfo.flags = AccessibilityServiceInfo.FLAG_REQUEST_FILTER_KEY_EVENTS;

	// We'll respond with a popup (visual), and possibly a noise (audible)
	// and/ or a vibration (haptic). No spoken feedback here!
    mInfo.feedbackType = (AccessibilityServiceInfo.FEEDBACK_VISUAL	|
    					  AccessibilityServiceInfo.FEEDBACK_AUDIBLE	|
    					  AccessibilityServiceInfo.FEEDBACK_HAPTIC	);
    
    setServiceInfo(mInfo);
}
 

/**
 * 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);
    }
}