首页 > 解决方案 > Android 振动不适用于版本 10 及更高版本

问题描述

成功扫描后,我正在使用 ZBarScannerView 扫描条形码我想使用振动。所以我使用下面的代码并在清单文件中提到。但它不起作用

<uses-permission android:name="android.permission.VIBRATE"/>

 Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            v.vibrate(VibrationEffect.createOneShot(500, VibrationEffect.DEFAULT_AMPLITUDE));
        } else {
            //deprecated in API 26
            v.vibrate(500);
        }

这是我应用振动器的代码

 private void submitQRcode(String houseid) {

    Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        v.vibrate(VibrationEffect.createOneShot(500, VibrationEffect.DEFAULT_AMPLITUDE));
    } else {
        //deprecated in API 26
        v.vibrate(500);
    }
    Log.d(TAG, "submitQRcode: " + houseid);
    if (houseid.substring(0, 2).matches("^[HhPp]+$"))
        validateTypeOfCollection(houseid);
    else if (houseid.substring(0, 2).matches("^[GgPp]+$"))
        startSubmitQRAsyncTask(houseid, -1, null);
    else if (houseid.substring(0, 2).matches("^[DdYy]+$"))
        getDumpYardDetails(houseid);
    else {
        AUtils.warning(QRcodeScannerActivity.this, mContext.getResources().getString(R.string.qr_error));
        restartPreview();
    }
}

标签: androidandroid-studioandroid-notificationsandroid-vibration

解决方案


此解决方案适用于所有设备和所有操作系统,请检查并应用解决方案。

利用HapticManager class:

    public class HapticManager {

    public static final String TAG = "HapticManager";

    private static HapticManager hapticManager;

    // Context
    private Context _context;

    private static AudioManager audioManager;

    private static Vibrator vibrator;

    public static final int VIBRATION_TYPE_DEFAULT = 0;
    public static final int VIBRATION_TYPE_LIGHT = 1;
    public static final int VIBRATION_TYPE_MEDIUM = 2;
    public static final int VIBRATION_TYPE_HEAVY = 3;
    public static final int VIBRATION_TYPE_SELECTION = 4;
    public static final int VIBRATION_TYPE_SUCCESS = 5;
    public static final int VIBRATION_TYPE_WARNING = 6;
    public static final int VIBRATION_TYPE_ERROR = 7;
    public static final int VIBRATION_TYPE_PATTERN_VIBRATE_1 = 8;
    public static final int VIBRATION_TYPE_PATTERN_VIBRATE_2 = 9;
    public static final int VIBRATION_TYPE_PATTERN_VIBRATE_3 = 10;
    public static final int VIBRATION_TYPE_VIRTUAL_KEY = 11;
    public static final int VIBRATION_TYPE_LONG_PRESS = 12;
    public static final int VIBRATION_TYPE_SUCCESS_SOUND = 13;
    public static final int VIBRATION_TYPE_DEFAULT_VIBRATION_SOUND = 14;

    private final int LIGHT_VIBRATE = 20;
    private final int MEDIUM_VIBRATE = 40;
    private final int HEAVY_VIBRATE = 100;
    private final int SELECTION_VIBRATE = 25;
    private final int SUCCESS_VIBRATE = 50;
    private final int WARNING_VIBRATE = 250;
    private final int ERROR_VIBRATE = 500;
    private final long[] PATTERN_VIBRATE_1 = {0, 60, 10, 60, 10, 60};
    private final long[] PATTERN_VIBRATE_2 = {0, 100, 200, 100, 1000, 100, 200, 100};
    private final long[] PATTERN_VIBRATE_3 = {0, 100, 300, 100, 300, 100};
    private final long[] PATTERN_VIBRATE_4 = {0, 60, 20, 60, 100, 60, 20, 60, 100, 60, 20, 60};

    private static MediaPlayer mediaPlayer;

    public static HapticManager getInstance() {
        if (hapticManager == null) {
            hapticManager = new HapticManager();
        }

        return hapticManager;
    }

    public void initHapticManager(Context context) {
        this._context = context;
        audioManager = (AudioManager) _context.getSystemService(Context.AUDIO_SERVICE);
        vibrator = (Vibrator) _context.getSystemService(VIBRATOR_SERVICE);
    }

    public AudioManager getHapticAudioManager() {
        return audioManager;
    }

    public Vibrator getHapticVibrator() {
        return vibrator;
    }

    /* set only vibration */
    public void playVibrationHaptic(View view, int type_of_vibration) {

        boolean isNormalModeEnable = true;
        boolean isVibrateModeEnable = true;

        if(audioManager != null) {
            switch (audioManager.getRingerMode()) {
                case AudioManager.RINGER_MODE_NORMAL:
                    ObLogger.i(TAG, "NormalMode: RINGER_MODE_NORMAL ");
                    isNormalModeEnable = true;
                    isVibrateModeEnable = true;
                    break;

                case AudioManager.RINGER_MODE_VIBRATE:
                    ObLogger.i(TAG, "NormalMode: RINGER_MODE_VIBRATE ");
                    isNormalModeEnable = false;
                    isVibrateModeEnable = true;
                    break;

                case AudioManager.RINGER_MODE_SILENT:
                    ObLogger.i(TAG, "NormalMode: RINGER_MODE_SILENT ");

                    isNormalModeEnable = false;
                    isVibrateModeEnable = false;
                    break;
            }
        }


            if (getHapticVibrator() != null && getHapticVibrator().hasVibrator() /*&& isEnable*/)
                switch (type_of_vibration) {
                    case VIBRATION_TYPE_DEFAULT:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            if (view != null) {
                                view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
                            }
                        }
                        break;
                    case VIBRATION_TYPE_LIGHT:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(LIGHT_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_MEDIUM:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(MEDIUM_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_HEAVY:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(HEAVY_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_SELECTION:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(SELECTION_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_SUCCESS:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(SUCCESS_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_WARNING:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(WARNING_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_ERROR:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(ERROR_VIBRATE);
                        }
                        break;
                    case VIBRATION_TYPE_PATTERN_VIBRATE_1:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(PATTERN_VIBRATE_1, -1);
                        }
                        break;
                    case VIBRATION_TYPE_PATTERN_VIBRATE_2:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(PATTERN_VIBRATE_2, -1);
                        }
                        break;
                    case VIBRATION_TYPE_PATTERN_VIBRATE_3:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(PATTERN_VIBRATE_3, -1);
                        }
                        break;
                    case VIBRATION_TYPE_VIRTUAL_KEY:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
                        }
                        break;
                    case VIBRATION_TYPE_LONG_PRESS:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            if (view != null) {
                                view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
                            }
                        }
                        break;
                    case VIBRATION_TYPE_DEFAULT_VIBRATION_SOUND:
                    default:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            if (view != null) {
                                view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
                            }
                        }

                        if(isNormalModeEnable) {
                            if (!isSoundEffectEnable()) {
                                getHapticAudioManager().playSoundEffect(SoundEffectConstants.CLICK, 0.5f);
                            }
                        }
                        break;

                    case VIBRATION_TYPE_SUCCESS_SOUND:
                        if(isNormalModeEnable || isVibrateModeEnable) {
                            getHapticVibrator().vibrate(PATTERN_VIBRATE_4, -1);
                        }
                        break;


                }

    }

    /* both are set vibration and touch sound */
    public void playCustomMusicwithVibration(View view, int vibration_type, int touch_sound_rawId) {

        playCustomMusicHaptic(touch_sound_rawId);

        playVibrationHaptic(view, vibration_type);

    }

    /* set only Touch Sound */
    public void playCustomMusicHaptic(int touch_sound_rawId) {
        if (!isSoundEffectEnable() && isValidContext(_context)) {

            boolean isNormalModeEnable = true;

            if(audioManager != null) {
                switch (audioManager.getRingerMode()) {
                    case AudioManager.RINGER_MODE_NORMAL:
                        ObLogger.i(TAG, "NormalMode: RINGER_MODE_NORMAL ");
                        isNormalModeEnable = true;
                        break;

                    case AudioManager.RINGER_MODE_VIBRATE:
                        ObLogger.i(TAG, "NormalMode: RINGER_MODE_VIBRATE ");
                        isNormalModeEnable = false;
                        break;

                    case AudioManager.RINGER_MODE_SILENT:
                        ObLogger.i(TAG, "NormalMode: RINGER_MODE_SILENT ");
                        isNormalModeEnable = false;
                        break;
                }
            }

            if(isNormalModeEnable) {
                mediaPlayer = MediaPlayer.create(_context, touch_sound_rawId);
                mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                    @Override
                    public void onPrepared(MediaPlayer mp) {
                        mp.start();
                    }
                });
                mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                    public void onCompletion(MediaPlayer mp) {
                        mp.release();
                    }
                });
            }
        }
    }

    private boolean isSoundEffectEnable() {
        if (isValidContext(_context)) {
            int enabled = Settings.System.getInt(_context.getContentResolver(), Settings.System.SOUND_EFFECTS_ENABLED, 0);
            return (enabled == 1);
        }
        return false;
    }

    public static boolean isValidContext(final Context context) {

        if (context == null) {
            return false;
        }
        if (context instanceof Activity) {
            final Activity activity = (Activity) context;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                return !activity.isDestroyed() && !activity.isFinishing();
            } else {
                return !activity.isFinishing();
            }
        }
        return true;

    }
}

调用函数:

private void submitQRcode(String houseid, View view) {

    HapticManager.getInstance().playVibrationHaptic(view, HapticManager.getInstance().VIBRATION_TYPE_DEFAULT_VIBRATION_SOUND);


    Log.d(TAG, "submitQRcode: " + houseid);
    if (houseid.substring(0, 2).matches("^[HhPp]+$"))
        validateTypeOfCollection(houseid);
    else if (houseid.substring(0, 2).matches("^[GgPp]+$"))
        startSubmitQRAsyncTask(houseid, -1, null);
    else if (houseid.substring(0, 2).matches("^[DdYy]+$"))
        getDumpYardDetails(houseid);
    else {
        AUtils.warning(QRcodeScannerActivity.this, mContext.getResources().getString(R.string.qr_error));
        restartPreview();
    }
}

推荐阅读