Java AccessibilityServiceInfo.FEEDBACK_HAPTIC属性代码示例

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

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

@Override
protected void onServiceConnected() {
	super.onServiceConnected();
	AccessibilityServiceInfo localAccessibilityServiceInfo = new AccessibilityServiceInfo();
	localAccessibilityServiceInfo.eventTypes = AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
	localAccessibilityServiceInfo.packageNames = null;
	localAccessibilityServiceInfo.feedbackType = AccessibilityServiceInfo.FEEDBACK_HAPTIC;
	localAccessibilityServiceInfo.notificationTimeout = 0L;
	setServiceInfo(localAccessibilityServiceInfo);
}
 

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

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