精华内容
下载资源
问答
  • Android vibrator方法关闭和打开振动功能,通过Android vibrator方法设置不同的参数,来关闭和打开手机振动功能:  ToggleButton tb2 = (ToggleButton)findViewById(R.id.tb2); //获得ToggleButton对象  tb2....
  • <uses android:name=”android.permission.VIBRATE”/> //振动器实例化 private Vibrator mVibrator1; mVibrator1=(Vibrator) getApplication().getSystemService(Service.VIBRATOR_SERVICE);   //等待100ms后,按...
  • Android Vibrator 框架总结

    千次阅读 2019-03-06 11:20:22
    前言 振动器小模块框架总结 基于 MTK 7.0 源码 驱动 内核配置:kernel-3.18\arch\arm64\configs\E266L_debug_defconfig ...// Vibrator_drv.c (kernel-3.18\drivers\misc\mediatek\vibrator) module_init(vib_...

    前言

    振动器小模块框架总结
    基于 MTK 7.0 源码

    驱动

    内核配置:kernel-3.18\arch\arm64\configs\E266L_debug_defconfig
    CONFIG_MTK_VIBRATOR=y
    
    驱动初始化流程:
    // Vibrator_drv.c (kernel-3.18\drivers\misc\mediatek\vibrator)
    module_init(vib_mod_init);
    static int vib_mod_init(void)
            /
            // 1. 获得 dts 设置,配置 PMIC 电压输出
            vibr_power_set();
                    /
                    // 获得 dts 中相应的配置 
                    // E266L.dts (kernel-3.18\arch\arm64\boot\dts)
                    //      vibrator0:vibrator@0 {
                    //          compatible = "mediatek,vibrator";
                    //          vib_timer = <25>;
                    //          vib_limit = <9>;
                    //      
                    //          vib_vol= <6>;
                    //              //
                    //              // hw->vib_vol:  Voltage selection
                    //              // 3'b000: 1.2V
                    //              // 3'b001: 1.3V
                    //              // 3'b010: 1.5V
                    //              // 3'b011: 1.8V
                    //              // 3'b100: 2.0V, if PMIC6353, 2.5V
                    //              // 3'b101: 2.8V
                    //              // 3'b110: 3.0V
                    //              // 3'b111: 3.3V
                    //      };
                    struct vibrator_hw *hw = get_cust_vibrator_dtsi();
                                                        struct device_node *led_node = NULL;
                                                        pvib_cust = kmalloc(sizeof(struct vibrator_hw), GFP_KERNEL);
                                                        led_node = of_find_compatible_node(NULL, NULL, "mediatek,vibrator");
                                                        ret = of_property_read_u32(led_node, "vib_timer",&(pvib_cust->vib_timer));
                                                        ret =of_property_read_u32(led_node, "vib_limit",&(pvib_cust->vib_limit));        
                                                        ret =of_property_read_u32(led_node, "vib_vol",&(pvib_cust->vib_vol));    
                    // 设置 vibrator 电压  
                    pmic_set_register_value(PMIC_RG_VIBR_VOSEL, hw->vib_vol);
                    
            ///
            // 2. 注册平台设备 
            //      static struct platform_device vibrator_device = {
            //          .name = "mtk_vibrator",
            //          .id = -1,
            //      };
            ret = platform_device_register(&vibrator_device);
            
            ///
            // 3. 创建工作队列
            vibrator_queue = create_singlethread_workqueue(VIB_DEVICE);
            INIT_WORK(&vibrator_work, update_vibrator);
            
            ///
            // 4. 创建定时器
            hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
            vibe_timer.function = vibrator_timer_func;
            
            ///
            // 5. 【核心】创建一个定时输出设备?使用 sys 实现的 Android 特有驱动
            //      static struct timed_output_dev mtk_vibrator = {
            //          .name = "vibrator",
            //          .get_time = vibrator_get_time,
            //          .enable = vibrator_enable,
            //      };
            
            // 生成节点路径:
            //      /sys/class/timed_output/vibrator 
            //      /sys/devices/virtual/timed_output/vibrator 
            timed_output_dev_register(&mtk_vibrator);
                    // 先看这个目录有没有,没有 sys 下目录的话,创建一个:/sys/devices/virtual/timed_output/
                    ret = create_timed_output_class();
                                // Timed_output.c (kernel-3.18\drivers\staging\android)
                                static int create_timed_output_class(void)
                                        // 创建 sys/class/timed_output/ 类目录 
                                        timed_output_class = class_create(THIS_MODULE, "timed_output");
                                        atomic_set(&device_count, 0);
                                        timed_output_class->dev_groups = timed_output_groups;
                    // 引用加 1             
                    tdev->index = atomic_inc_return(&device_count);
                    
                    // 创建 /sys/devices/virtual/timed_output/vibrator 目录 
                    tdev->dev = device_create(timed_output_class, NULL,MKDEV(0, tdev->index), NULL, "%s", tdev->name);                            
                                                    dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
                                                                return device_create_groups_vargs(class, parent, devt, drvdata, NULL,fmt, args);
                                                                                retval = device_add(dev);
                                                                                        error = device_create_file(dev, &dev_attr_uevent);
                                                                                        if (MAJOR(dev->devt))
                                                                                            error = device_create_file(dev, &dev_attr_dev);
                                                                                            error = device_create_sys_dev_entry(dev);
                                                                                            devtmpfs_create_node(dev);
                                                                                        //
                                                                                        // 一系列调用之后,添加了 class 的 dev_groups,他已经有两个默认属性了 
                                                                                        error = device_add_groups(dev, class->dev_groups);
                                                                                                    if (class)
                                                                                                        error = device_add_groups(dev, class->dev_groups);                                                                                              
                                                                                                    
                                                                                        error = bus_add_device(dev);
                                                                                        error = dpm_sysfs_add(dev);
                                                                                        device_pm_add(dev);
                                                                                        
                                                                                        
                    
                    dev_set_drvdata(tdev->dev, tdev);
            
            
            
            
            ///
            // 6. 注册平台驱动
            //      static struct platform_driver vibrator_driver = {
            //          .probe = vib_probe,
            //          .remove = vib_remove,
            //          .shutdown = vib_shutdown,
            //          .driver = {
            //                 .name = VIB_DEVICE,
            //                 .owner = THIS_MODULE,
            //                 },
            //      };
            ret = platform_driver_register(&vibrator_driver);
                        /
                        // 进入对应的 probe 函数,为空的?作用?
            
            
            // 7. 创建 sys 属性节点: /sys/class/timed_output/vibrator/vibr_on
            ret = device_create_file(mtk_vibrator.dev, &dev_attr_vibr_on);
            
            
           
    
    //
    // 上层调用流程:
    // 目前 HAL 层是通过 sys/class/timed_output/vibrator/enable 节点来控制马达的启停的 
    // 初始化的时候此节点已设置为 timed_output 类的操作操作 
    
    
    ///
    // 1. 打开马达
    //      echo 时间 > sys/class/timed_output/vibrator/enable
    // Timed_output.c (kernel-3.18\drivers\staging\android)
    static ssize_t enable_store(struct device *dev, struct device_attribute *attr,const char *buf, size_t size)
                    struct timed_output_dev *tdev = dev_get_drvdata(dev);
                    rc = kstrtoint(buf, 0, &value);
                    tdev->enable(tdev, value);
                            //
                            // 本驱动的 enable 函数 
                            static void vibrator_enable(struct timed_output_dev *dev, int value)
                                                struct vibrator_hw *hw = mt_get_cust_vibrator_hw();
                                                while (hrtimer_cancel(&vibe_timer))
                                                // limit 配置项的使用 
                                                if (value > hw->vib_limit && value < hw->vib_timer)
                                                    value = hw->vib_timer;
                            
                                                value = (value > 15000 ? 15000 : value);
                                                vibe_state = 1;
                                                // 启动了定时器 
                                                hrtimer_start(&vibe_timer,ktime_set(value / 1000, (value % 1000) * 1000000), HRTIMER_MODE_REL);
                                                
                                                // 调用工作队列打开马达?
                                                queue_work(vibrator_queue, &vibrator_work);
                                                        static void update_vibrator(struct work_struct *work)
                                                                            	if (!vibe_state)
                                                                                    vibr_Disable();
                                                                                else
                                                                                    vibr_Enable();
                                                                                            if (!ldo_state)
                                                                                                vibr_Enable_HW();
                                                                                                        ///
                                                                                                        // 调用 PMIC 操作函数打开马达 
                                                                                                        pmic_set_register_value(PMIC_LDO_VIBR_EN, 1);     // [bit 1]: VIBR_EN,  1=enable 
                                                                                                ldo_state = 1;
                                
                            
    ///
    // 2. 获得振动剩余时间 
    //      cat sys/class/timed_output/vibrator/enable                        
    static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)                        
                    int remaining = tdev->get_time(tdev);
                            //
                            // 本驱动的 get_time 函数 
                            static int vibrator_get_time(struct timed_output_dev *dev)
                                            if (hrtimer_active(&vibe_timer))
                                                ktime_t r = hrtimer_get_remaining(&vibe_timer);
                                                return ktime_to_ms(r);
    

    HAL

     振动器的 HAL 库实现还是蛮简单的,主要是往节点:
        /sys/class/timed_output/vibrator/enable
    写入振动时间就行了。
    
    文件位置:
    Vibrator.c (hardware\libhardware\modules\vibrator)
    【初始化流程】
    struct hw_module_t HAL_MODULE_INFO_SYM = {
        .tag = HARDWARE_MODULE_TAG,
        .module_api_version = VIBRATOR_API_VERSION,
        .hal_api_version = HARDWARE_HAL_API_VERSION,
        .id = VIBRATOR_HARDWARE_MODULE_ID,
        .name = "Default vibrator HAL",
        .author = "The Android Open Source Project",
        .methods = &vibrator_module_methods,
                    //
                    // static struct hw_module_methods_t vibrator_module_methods = {
                    //     .open = vibra_open,
                    // };
    };
    //
    static int vibra_open(const hw_module_t* module, const char* id __unused,hw_device_t** device __unused)
                    ///
                    // 1. 判断是否有振动器设备存在,open() 打开设备
                    vibra_exists()
                            //
                            // static const char THE_DEVICE[] = "/sys/class/timed_output/vibrator/enable";
                            static int vibra_exists()
                                    fd = TEMP_FAILURE_RETRY(open(THE_DEVICE, O_RDWR));
                                    close(fd);
    
                    // 
                    // 2. 分配设置 vibrator_device_t 结构体 
                    vibrator_device_t *vibradev = calloc(1, sizeof(vibrator_device_t)); 
                    vibradev->common.tag = HARDWARE_DEVICE_TAG;
                    vibradev->common.module = (hw_module_t *) module;
                    vibradev->common.version = HARDWARE_DEVICE_API_VERSION(1,0);
                    vibradev->common.close = vibra_close;
                    //振动器操作函数 
                    vibradev->vibrator_on = vibra_on;
                                    ///
                                    // 打开振动器 
                                    static int vibra_on(vibrator_device_t* vibradev __unused, unsigned int timeout_ms) 
                                                    return sendit(timeout_ms);
                    vibradev->vibrator_off = vibra_off;
                                    ///
                                    // 关闭振动器 
                                    static int vibra_off(vibrator_device_t* vibradev __unused)
                                                    /
                                                    // 此函数直接往:/sys/class/timed_output/vibrator/enable 写振动时间就行了
                                                    return sendit(0);
                                                            fd = TEMP_FAILURE_RETRY(open(THE_DEVICE, O_RDWR));
                                                            to_write = snprintf(value, sizeof(value), "%u\n", timeout_ms);
                                                            written = TEMP_FAILURE_RETRY(write(fd, value, to_write));
                                                            close(fd);
                                    
                                    
                    ///
                    // 3. 返回 hw_device_t 结构体给 jni 层调用 
                    *device = (hw_device_t *) vibradev;        
    

    Framework

    本文件位置:frameworks\base\services\core\java\com\android\server\VibratorService.java
    
    
    【服务启动流程】:
    // frameworks\base\services\java\com\android\server\SystemServer.java
    public final class SystemServer
            startBootstrapServices();
            startCoreServices();
            startOtherServices();
                    ///
                    // 1. 创建一个 VibratorService 对象 
                    VibratorService vibrator = null;
                    vibrator = new VibratorService(context);
                                        /
                                        // frameworks\base\services\core\java\com\android\server\VibratorService.java
                                        // 头文件一看就是个 aidl 接口继承实现 binder 通信的货
                                        // aidl 位置: frameworks\base\core\java\android\os\IVibratorService.aidl
                                        //          interface IVibratorService
                                        //          {   // 这些定义的都是服务端需要提交实现的接口
                                        //              boolean hasVibrator();
                                        //              void vibrate(int uid, String opPkg, long milliseconds, int usageHint, IBinder token);
                                        //              void vibratePattern(int uid, String opPkg, in long[] pattern, int repeat, int usageHint, IBinder token);
                                        //              void vibrateLevel(int uid, String opPkg, long milliseconds, int usageHint, int level, int category, IBinder token);
                                        //              void vibratePatternLevel(int uid, String opPkg, in long[] pattern, int repeat, int usageHint, int level, int category, IBinder token);
                                        //              void cancelVibrate(IBinder token);
                                        //          }
                                        public class VibratorService extends IVibratorService.Stub implements InputManager.InputDeviceListener
                                        {
                                            //
                                            // 构造函数 
                                            VibratorService(Context context)
                                            {
                                                /
                                                // 调用对应的 jni 初始化函数 
                                                // com_android_server_VibratorService.cpp (frameworks\base\services\core\jni)
                                                
                                                // 获得 HAL 层实现库 
                                                vibratorInit();
                                                        int err = hw_get_module(VIBRATOR_HARDWARE_MODULE_ID, (hw_module_t const**)&gVibraModule);
                                                        vibrator_open(gVibraModule, &gVibraDevice);
                                                                return module->methods->open(module, VIBRATOR_DEVICE_ID_MAIN, (struct hw_device_t**)device);
                                                                
                                                // 关闭振动器,即向 /sys/class/timed_output/vibrator/enable 写 0  
                                                vibratorOff();                                                    
                                                        int err = gVibraDevice->vibrator_off(gVibraDevice);
                                                
                                                
                                                
                                                
                                                
                                                PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
                                                
                                                /
                                                // 获得华硕添加的 setting 震动设置
                                                mRingstoneVibLevel = Settings.System.getInt(mContext.getContentResolver(),
                                                        Settings.System.VIBRATION_LEVEL_RINGTONE, AudioAttributes.LEVEL_GENERAL_0);
    
                                                mNotificationVibLevel = Settings.System.getInt(mContext.getContentResolver(),
                                                        Settings.System.VIBRATION_LEVEL_NOTIFICATION, AudioAttributes.LEVEL_GENERAL_0);
    
                                                mTouchVibLevel = Settings.System.getInt(mContext.getContentResolver(),
                                                        Settings.System.VIBRATION_LEVEL_TOUCH, AudioAttributes.LEVEL_GENERAL_0);
                                               
                                                /
                                                // 注册了一个广播接收者,接收屏幕关闭广播
                                                IntentFilter filter = new IntentFilter();
                                                filter.addAction(Intent.ACTION_SCREEN_OFF);
                                                context.registerReceiver(mIntentReceiver, filter);
                                                
                                            }
                                            
                                        }
                    
                    ///
                    // 2. 将本服务添加到 servicemanager 中进行管理
                    ServiceManager.addService("vibrator", vibrator);
    
                    。。。 // 一系列其他初始化函数  
                    
                    ///
                    // 3. 将本服务添加到 servicemanager 中进行管理
                    vibrator.systemReady();
                                //
                                // frameworks\base\services\core\java\com\android\server\VibratorService.java
                                public void systemReady()
                                                /
                                                // 1. 监听手机设置 setting 的相关变化,变化后都是调用
                                                //    updateInputDeviceVibrators() 来更新马达状态 
                                                mSettingObserver = new SettingsObserver(mH);
                                                //+++ aras_yin: add vibrator level feature
                                                mVibLvRingtoneObserver = new VibLvRingtoneObserver(mH);
                                                mVibLvNotificationObserver = new VibLvNotificationObserver(mH);
                                                mVibLvTouchObserver = new VibLvTouchObserver(mH);
                                                //--- aras_yin
                                                
                                                //
                                                // 2. 注册了一系列需要状态变化,改变马达 
                                                mPowerManagerInternal.registerLowPowerModeObserver(
                                                        new PowerManagerInternal.LowPowerModeListener() {
                                                    @Override
                                                    public void onLowPowerModeChanged(boolean enabled) {
                                                        updateInputDeviceVibrators();
                                                    }
                                                });
    
                                                mContext.getContentResolver().registerContentObserver(
                                                        Settings.System.getUriFor(Settings.System.VIBRATE_INPUT_DEVICES),
                                                        true, mSettingObserver, UserHandle.USER_ALL);
    
                                                mContext.registerReceiver(new BroadcastReceiver() {
                                                    @Override
                                                    public void onReceive(Context context, Intent intent) {
                                                        updateInputDeviceVibrators();
                                                    }
                                                }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mH);
            
                                                 //+++ aras_yin: add vibrator level feature
                                                mContext.getContentResolver().registerContentObserver(
                                                        Settings.System.getUriFor(Settings.System.VIBRATION_LEVEL_RINGTONE),
                                                        true, mVibLvRingtoneObserver, UserHandle.USER_ALL);
                                                mContext.getContentResolver().registerContentObserver(
                                                        Settings.System.getUriFor(Settings.System.VIBRATION_LEVEL_NOTIFICATION),
                                                        true, mVibLvNotificationObserver, UserHandle.USER_ALL);
                                                mContext.getContentResolver().registerContentObserver(
                                                        Settings.System.getUriFor(Settings.System.VIBRATION_LEVEL_TOUCH),
                                                        true, mVibLvTouchObserver, UserHandle.USER_ALL);
                                                //--- aras_yin
                                                
                                                //
                                                // 3. 马达输入设备?看不懂,看完输入子系统再看
                                                updateInputDeviceVibrators();
                                                            doCancelVibrateLocked();
                                                                    doVibratorOff();
                                                                        
                                                                        // 调用 native 层关马达 
                                                                        vibratorOff();
            
                                                            synchronized (mInputDeviceVibrators)
                                                            { // 一票输入设备相关操作  }
                                                            
                                                            
                                                            startNextVibrationLocked();
                                                                    startVibrationLocked(mVibrations.getFirst());
                                                                                if (vib.mTimeout != 0)
                                                                                        doVibratorOn(vib.mTimeout, vib.mUid, vib.mUsageHint, vib.mVibrationLevel, vib.mVibrationCategory);
                                                                                                /
                                                                                                // 调用 HAL 层开马达 
                                                                                                vibratorOn(millis);
                                                                                                
                                                                                        // 振动一段时间后,再来更新马达状态         
                                                                                        mH.postDelayed(mVibrationRunnable, vib.mTimeout);
            
                                                                                else
                                                                                    // 这里创建了一个 VibrateThread 线程 
                                                                                    mThread = new VibrateThread(vib);
                                                                                    mThread.start();
                                                                                            /
                                                                                            // 启动线程操作:
                                                                                             private class VibrateThread extends Thread
                                                                                             {
                                                                                                public void run()
                                                                                                {
                                                                                                    Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);
                                                                                                    while (!mDone)
                                                                                                    {
                                                                                                        // sleep until it is time to start the vibrator
                                                                                                        delay(duration);
                                                                                                        
                                                                                                        // 启动马达 
                                                                                                        VibratorService.this.doVibratorOn(duration, uid, usageHint, vibLevel, vibCate);
                                                                                                        
                                                                                                        // 本次振动结束,开始处理下一个 
                                                                                                        if (!mDone) {
                                                                                                            // If this vibration finished naturally, start the next
                                                                                                            // vibration.
                                                                                                            unlinkVibration(mVibration);
                                                                                                            startNextVibrationLocked();
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                                 
                                                                                             }
    

    App

    【马达的应用进程的使用】:
    代码位置:vendor\mediatek\proprietary\packages\apps\Emode\src\com\wind\emode\testcase\VibratorStressTest.java
        
        // 1. 导入库,声明变量
        import android.os.Vibrator;
        private Vibrator mVibrator;
        
        
        // 2. 获得马达服务
        mVibrator = ((Vibrator) getSystemService(Context.VIBRATOR_SERVICE));
    
        
        // 3. 启动马达 
        mVibrator.vibrate(array, 0);
                    //
                    //  @param pattern an array of longs of times for which to turn the vibrator on or off.
                    //  @param repeat the index into pattern at which to repeat, or -1 if you don't want to repeat.
                    public void vibrate(long[] pattern, int repeat) 
    
        
        // 4. 关闭马达 
        mVibrator.cancel();
    
    展开全文
  • 在手机App中的一些业务场景,如用户点击按钮操作震动提示一下或者是扫码环节中扫码成功震动提示一下用户,是一个不错的细节处理,本文章给大家分享一下 Android 中的代码实现。 一.清单文件中添加权限 在清单文件 A.

    在码农的世界里,优美的应用体验,来源于程序员对细节的处理以及自我要求的境界,年轻人也是忙忙碌碌的码农中一员,每天、每周,都会留下一些脚印,就是这些创作的内容,有一种执着,就是不知为什么,如果你迷茫,不妨来瞅瞅码农的轨迹。

    如果你有兴趣可以关注一下公众号 biglead 来获取更多分享内容。

    在手机App中的一些业务场景,如用户点击按钮操作震动提示一下或者是扫码环节中扫码成功震动提示一下用户,是一个不错的细节处理,本文章给大家分享一下 Android 中的代码实现。

    一.清单文件中添加权限

    在清单文件 AndroidManifest.xml 中添加权限如下

    <uses-permission android:name="android.permission.VIBRATE" />
    
    2.获取系统服务

    在你的 Activity 中获取 Vibrator :

      import android.os.Vibrator;
      private Vibrator mVibrator;
     // 震动效果的系统服务
      mVibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
    
    3.震动提示效果

    如在业务应用场景中扫码成功,震动提示一下用户:

     /*
       * 震动的方式
       */
      // vibrator.vibrate(2000);//振动两秒
      // 下边是可以使震动有规律的震动  -1:表示不重复 0:循环的震动
      long[] pattern = {200, 200 };
      mVibrator.vibrate(pattern, -1);
    

    对于 pattern ,如有定义为new int[200,400,600,800]

    200:指示在打开振动器之前等待的毫秒数。 0.2秒。

    400:表示在关闭振动器之前保持振动器处于开启状态的毫秒数,0.4秒。

    600,800:几毫秒之间交替,以关闭振动器或打开振动器,0.6-0.8秒。

    4.最后

    Vibrator(振动器),是手机自带的振动器,是Android给我们提供的用于机身震动的一个服务。 比如当手机收到推送消息的时候我们可以设置震动 提醒。再或者登录页面功能时,用户输入密码或是用户名错误,可以给个提示然后震动一下下。

    展开全文
  • android Vibrator开启振动功能

    千次阅读 2017-08-01 16:05:13
    前言Android开启振动主要运用了Vibrator(振动器),系统中有一个Vibrator抽象类,我们可以通过获取Vibrator实例调用里面的方法来完成振动功能。Vibrator vibrator = (Vibrator) getSystemServic(Service.VIBRATOR_...

    前言

    Android开启振动主要运用了Vibrator(振动器),系统中有一个Vibrator抽象类,我们可以通过获取Vibrator实例调用里面的方法来完成振动功能。

    Vibrator vibrator = (Vibrator) getSystemServic(Service.VIBRATOR_SERVICE);
    

    记得加权限

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

    方法和参数

    vibrator.vibrate(1000);  //设置手机振动
    vibrator.hasVibrator();  //判断手机硬件是否有振动器
    vibrator.cancel();//关闭振动
    

    这里主要讲解一下vibrator.vibrate(),如下图所示:

    vibrate ( long milliseconds )

    vibrator.vibrate(1000); //立刻振动,持续时间为1s
    

    vibrate ( long milliseconds, AudioAttributes attributes )

    Api文档中对第二个参数的解释是:

    attributes: AudioAttributes corresponding to the vibration. For example,specify 
    USAGE_ALARM for alarm vibrations or USAGE_NOTIFICATION_RINGTONE for vibrations
    associated with incoming calls.
    
    意思就是说我们可以指定振动对应的属性
    
    指定 USAGE_NOTIFICATION_RINGTONE 则是来电铃声振动
    
    USAGE_ALARM  闹钟振动
    

    使用

    //api 21加入的
    AudioAttributes audioAttributes = new AudioAttributes.Builder()
            .setUsage(AudioAttributes.USAGE_ALARM).build();
    vibrator.vibrate(1000, audioAttributes);
    

    vibrate ( long [ ] pattern , int repeat )

    pattern long类型数组
    API解释:an array of longs of times for  which to turn 
    the vibrator on or off;
    
    官方文档对pattern中元素的详细说明:
    Pass in an array of ints that are the durations for which to turn on or off 
    the vibrator in milliseconds.The first value indicates the number of milliseconds 
    to wait before turning the vibrator on. The next value indicates the number of 
    milliseconds for which to keep the vibrator on before turning it off.Subsequent 
    values alternate between durations in milliseconds to turn the vibrator off or to 
    turn the vibrator on.
    大致意思:数组中的整数用来打开或关闭振动器,第一个值表示在打开振动器之前要等待的毫秒数下一个值
    表示在关闭振动器之前保持振动器的毫秒数,随后的值交替执行。
    
    
    repeat 振动重复的模式:   -1 为不重复
                            0 为一直重复振动
                            1 则是指从数组中下标为1的地方开始重复振动(不是振动一次!!!)       
                            2 从数组中下标为2的地方开始重复振动。
                            .....
    
    //下面的pattern[]我们可以理解为 开启振动后 等待0.1s振动 振动2s 等待1s 振动1s 等待3s
    long pattern[] = {100, 2000, 1000, 1000,3000};
    vibrator.vibrate(pattern,-1); 
    

    对于上面repeat和pattern的关系的还是依照上图来说吧,
    图片刚好和long pattern[] = {100, 2000, 1000, 1000,3000}数组对应(为了方便解释 
    我将等待振动时间和振动时间当做一组)
    
    当repeat为0 的时候会一直振动 此时会一直走 (0,1),(2,3)
    下标4刚好是等待时间 依然会执行 然后本次重复结束,开启下一次重复。
    
    当repeat 为1 的时候 第一次振动会(0,1),(2,3),然后等待3s,本次振动结束,然后从下标为1的地方
    开始重复振动, 此时会走(1,2),(3,4),(1,2),(3,4);
    
    当repeat为2的时候 第一次振动会(0,1),(2,3),然后等待3s,本次振动结束,从下标为2的
    地方开始重复振动,此时为(2,3),然后等待3s,结束本次重复,开启下次(2,3)....
    

    **总结:pattern [ ] 数组中第一位为振动等待时间,重复执行时指定的下标为重复振动的第一位,亦为等待时间。
    数组中个数为奇数时,最后一位为等待时间,依旧会执行**。

    vibrate ( long[ ] pattern, int repeat, AudioAttributes attributes )

    这个就不做过多解释,上面都有涉及到。
    

    结束

    本篇文章主要介绍了一下振动器常见API和使用,比较简单。但都是亲自测试所得。

    展开全文
  • android 对硬件的权限使用控制的越来越严格,android R 之前的灭屏震动不知道有没有特别设置,本文只讨论Android R上的应用。 正文 1,在AndroidManifest.xml中添加使用到的控制权限,为什么需要?阅读源码可以...

    背景

    vibrator 是手机上的一个硬件功能,也是常用的提示功能,在开发过程中,遇到一个需求,需要实现灭屏震动提示,搜集网上博客,没有找到想要的案例,所以自己花了点时间研究了,记录下实现

    android 对硬件的权限使用控制的越来越严格,android R 之前的灭屏震动不知道有没有特别设置,本文只讨论Android R上的应用。

    正文

    1,在AndroidManifest.xml中添加使用到的控制权限,为什么需要?阅读源码可以看到调用vibrate方法的时候会对权限检查,如果没有申请,那么将会导致应用crash

     /** 
         * Vibrate with a given pattern.                                                                                                                                                                        
         *
         * <p>
         * Pass in an array of ints that are the durations for which to turn on or off
         * the vibrator in milliseconds.  The first value indicates the number of milliseconds
         * to wait before turning the vibrator on.  The next value indicates the number of milliseconds
         * for which to keep the vibrator on before turning it off.  Subsequent values alternate
         * between durations in milliseconds to turn the vibrator off or to turn the vibrator on.
         * </p><p>
         * To cause the pattern to repeat, pass the index into the pattern array at which
         * to start the repeat, or -1 to disable repeating.
         * </p>
         *
         * @param pattern    an array of longs of times for which to turn the vibrator on or off.
         * @param repeat     the index into pattern at which to repeat, or -1 if
         *                   you don't want to repeat.
         * @param attributes {@link AudioAttributes} corresponding to the vibration. For example,
         *                   specify {@link AudioAttributes#USAGE_ALARM} for alarm vibrations or
         *                   {@link AudioAttributes#USAGE_NOTIFICATION_RINGTONE} for
         *                   vibrations associated with incoming calls.
         * @deprecated Use {@link #vibrate(VibrationEffect, AudioAttributes)} instead.
         */
    
        @Deprecated
        @RequiresPermission(android.Manifest.permission.VIBRATE)
        public void vibrate(long[] pattern, int repeat, AudioAttributes attributes) {
            // This call needs to continue throwing ArrayIndexOutOfBoundsException but ignore all other
            // exceptions for compatibility purposes
            if (repeat < -1 || repeat >= pattern.length) {
                Log.e(TAG, "vibrate called with repeat index out of bounds" +
                     (pattern.length=" + pattern.length + ", index=" + repeat +")");
                throw new ArrayIndexOutOfBoundsException();
            }
    
            try {
                vibrate(VibrationEffect.createWaveform(pattern, repeat), attributes);
            } catch (IllegalArgumentException iae) {
                Log.e(TAG, "Failed to create VibrationEffect", iae);
           }
        }

    所以我们需要在清单文件中添加vibrator使用的权限

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

    2,实现调用,vibrator实现灭屏震动依赖AudioAttributes的设置,这里我们需要使用USAGE_ALARM作为类型

    AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
                 .setContentType(AudioAttributes.USAGE_ALARM) /*USAGE_ALARM*/
                 .setUsage(AudioAttributes.USAGE_ALARM)
                 .build();

    获得震动服务的句柄

    Vibrator mVibrator;
    mVibrator = (Vibrator)getSystemService(Context.VIBRATOR_SERVICE);

    调用系统函数,函数的参数说明文章开头有介绍

    mVibrator.vibrate(new long[]{1000, 2000, 3000, 4000}, 0, VIBRATION_ATTRIBUTES);

     

    实现的关键是AudioAttributes的属性设置,不同的设置实现的效果不一样,灭屏震动,可以监听屏幕的状态,在灭屏时调用上述方法,使马达运行。

    3,取消震动

    mVibrator.cancel()

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • android Vibrator实现手机震动功能

    千次阅读 2017-05-02 15:06:35
    uses-permission android:name="android.permission.VIBRATE"/> 第二步:获取 Vibrator 服务 mVibrator = (Vibrator)getSystemService(VIBRATOR_SERVICE); 第三步:检测手机硬件是否有振动器 mVibrator....
  • Android Vibrator的使用

    2016-06-14 07:44:22
    什么是VibratorVibrator是Android的震动服务,通过如下的代码获取实例 Vibrator mVibrator = (Vibrator)getSystemService(Service.VIBRATOR_SERVICE);
  • Android中手机震动的设置(Vibrator)的步骤: a、通过系统服务获得手机震动服务,Vibrator vibrator = (Vibrator)getSystemService(VIBRATOR_SERVICE); b、得到震动服务后检测vibrator是否存在: vibrator....
  • Android手机震动主要用到的类是Vibrator类。该类作为一个系统级的服务类,可以通过 Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); 来获得实例。 该类主要包含的方法如下: ...
  • Android Vibrator使用

    2017-06-06 09:27:32
    Android Vibrator使用VibratorAndroid提供的一个手机振动服务。 手机振动是很多场合需要用到的功能,如消息提示,游戏等。 Vibrator主要提供了以下几种常用方法: abstract void cancel() abstract boolean ...
  • android Vibrator 仿微信摇一摇

    热门讨论 2013-06-14 15:34:02
    android 重力感应仪,高仿微信摇一摇更能!
  • android Vibrator

    2012-02-06 11:19:50
    http://roll.sohu.com/20110322/n304666791.shtml
  • Android Vibrator 震动

    2015-11-30 17:46:48
    关于震动,记录下,以便以后...Vibrator mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);第三步:震动调用震动方法,有3个方法控制震动 1、vibrate(long milliseconds):控制手机振动的毫秒数。
  • Android vibrator

    2014-06-03 20:04:09
    二、android驱动介绍 安卓总体架构是在 Linux内核基础上,增加硬件抽象层(HAL),运行库,java虚拟机,程序框架等组成的,具体如下图。   安卓的应用程序是从application fr
  • 添加权限 在AndroidManifest.xml...uses-permission android:name="android.permission.VIBRATE"/> 获取Vibrator vibrator = (Vibrator)context.getSystemService(this.VIBRATOR_SERVICE); 简单震动 先...
  • 本节我们介绍的是Vibrator(振动器),是手机自带的振动器,其实就是Android给我们提供的用于机身震动的一个服务!当收到推送消息的时候我们可以设置震动提醒。
  • Android Vibrator震动效果

    2017-05-17 12:16:00
    android震动器:Vibrator Android手机中的震动由Vibrator实现。 Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE); vibrator.vibrate(time);//定义事件震动长短。time为时间,long型,毫秒...
  • android Vibrator 用法

    2015-12-11 20:50:00
    private Vibrator mvibrator; 1、服务的句柄  mvibrator = (Vibrator) getSystemService... 或者 mvibrator = (Vibrator)getApplication().getSystemService(Service.VIBRATOR_SERVICE); 開始震动有两个...
  • Android Vibrator 振动器

    2021-06-05 13:40:59
    修改 MainActivity.java 实现逻辑package cn.twle.android.vibrator;import android.app.Service;import android.content...import android.os.Vibrator;import android.support.v7.app.AppCompatActivity;import an...
  • android Vibrator 使用

    2019-10-05 00:42:30
    private Vibrator vibrator; 取得震动服务的句柄 vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE); 或者vibrator = (Vibrator)getApplication().getSystemService(Service.VIBRATOR_SERVICE); 开始...
  • android Vibrator震动效果

    2012-09-18 20:17:00
    Vibrator为震动对象 Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE); //震动频率 long[] pattern = { 1000, 1800, 1000, 1800 }; // OFF/ON/OFF/ON... vibrator.vibrate(pattern, 2);// -1...
  • AndroidVibrator

    2021-06-06 04:53:24
    简介android.os.Vibrator是Andoroid中负责震动的类,是个系统级别,获取对象的方法如下:Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);震动和取消震动vibrator.vibrate(2000);vibrator....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,135
精华内容 2,854
关键字:

androidvibrator