bi511304183

转载加原创Android振动器调试

一：振动器系统结构和移植内容

振动器负责控制引动电话的振动功能，Android中的振动器系统是一个专供这方面功能的小系统，提供根据时间振动的功能。

振动器系统包含了驱动程序、硬件抽象层、JNI部分、Java框架类等几个部分，也向Java应用程序层提供了简单的API作为平台接口。

Android振动器系统的基本层次结构如图23-1所示。

图23-1 Android振动器系统的基本层次结构

1 振动器部分的结构

Android振动器系统自下而上包含了驱动程序、振动器系统硬件抽象层、振动器系统Java框架类、Java框架中振动器系统使用等几个部分，其结构如图23-2所示。

图23-2 Android振动器系统的结构

自下而上，Android的振动器系统分成了以下部分。

（1）驱动程序：特定硬件平台振动器的驱动程序，通常基于Android的Timed Output驱动框架实现

（2）硬件抽象层

光系统硬件抽象层接口路径为：hardware/libhardware_legacy/include/hardware_legacy/ vibrator.h

振动器系统的硬件抽象层在Android中已经具有默认实现，代码路径：

hardware/libhardware_legacy/vibrator/vibrator.c

振动器的硬件抽象层通常并不需要重新实现，是libhardware_legacy.so的一部分。

（3）JNI部分

代码路径：frameworks/base/services/jni/com_android_server_VibratorService.cpp

这个类是振动器的JNI部分，通过调用硬件抽象层向上层提供接口。

（4）Java部分

代码路径：

frameworks/base/services/java/com/android/server/VibratorService.java

frameworks/base/core/java/android/os/Vibrator.java

VibratorService.java通过调用，VibratorService JNI来实现com.android.server包中的VibratorService类。这个类不是平台的API，被Android系统Java框架中的一小部分调用。

Vibrator.java文件实现了android.os包中的Vibrator类，这是向Java层提供的API。

2 移植内容

针对特定的硬件平台，振动器系统的移植有两种方法。

第一种方法（通常情况）：由于已经具有硬件抽象层，振动器系统的移植只需要实现驱动程序即可。这个驱动程序需要基于Android内核中的Timed Output驱动框架。

第二种方法：根据自己实现的驱动程序，重新实现振动器的硬件抽象层定义接口（需要在libhardware_legacy.so库中），由于振动器硬件抽象层的接口非常简单，因此这种实现方式也不会很复杂。

二：移植与调试的要点

1 驱动程序

vibrator驱动提供上层接口有很多种，这里介绍两种方式：一种是timeout方式，一种是属性节点。

一、timeout方式

Vibrator的驱动程序只需要实现振动的接口即可，这是一个输出设备，需要接受振动时间作为参数。由于比较简单，因此Vibrator的驱动程序可以使用多种方式来实现。

在Android中，推荐基于Android内核定义Timed Output驱动程序框架来实现Vibrator的驱动程序。

Timed Output的含义为定时输出，用于定时发出某个输出。实际上，这种驱动程序依然是基于sys文件系统来完成的。

drivers/staging/android/目录timed_output.h中定义timed_output_dev结构体，其中包含enable和get_time这两个函数指针，实现结构体后，使用timed_output_dev_register()和timed_output_dev_unregister()函数注册和注销即可。

Timed Output驱动程序框架将为每个设备在/sys/class/timed_output/目录中建立一个子目录，设备子目录中的enable文件就是设备的控制文件。读enable文件表示获得剩余时间，写这个文件表示根据时间振动。

Timed Output驱动的设备调试，通过sys文件系统即可。

对于Vibrator设备，其实现的Timed Output驱动程序的名称应该为“vibrator”。因此Vibrator设备在sys文件系统中的方法如下所示：

# echo "10000" > /sys/class/timed_output/vibrator/enable

# cat /sys/class/timed_output/vibrator/enable

3290

# echo "0" > /sys/class/timed_output/vibrator/enable

对于enable文件，“写”表示使能指定的时间，“读”表示获取剩余时间。

二文件属性节点

这种方法就是直接用kernel sys系统创建文件节点，提供上层接口，直接操作底层gpio口或者PWM等控制器。

2 硬件抽象层的内容

2.1 硬件抽象层的接口

Vibrator硬件抽象层的接口在hardware/libhardware_legacy/include/hardware_legacy/目录的vibrator.h文件中定义：

int vibrator_on(int timeout_ms); // 开始振动

int vibrator_off(); // 关闭振动

vibrator.h文件中定义两个接口，分别表示振动和关闭，振动开始以毫秒（ms）作为时间单位。

提示：Timed Output类型驱动本身有获得剩余时间的能力（读enable文件），但是在Android Vibrator硬件抽象层以上的各层接口都没有使用这个功能。

2.2 标准硬件抽象层的实现

Vibrator硬件抽象层具有标准的实现，在hardware/libhardware_legacy/vibrator/目录的vibrator.c中。

其中实现的核心内容为sendit()函数，这个函数的内容如下所示：

[html] view plain copy print ?

<PRE class=cpp name="code">#define THE_DEVICE "/sys/class/timed_output/vibrator/enable"
static int sendit(int timeout_ms)
{
int nwr, ret, fd;
char value[20];
#ifdef QEMU_HARDWARE // 使用QEMU的情况
if (qemu_check()) {
return qemu_control_command( "vibrator:%d", timeout_ms );
}
#endif
fd = open(THE_DEVICE, O_RDWR); // 读取sys文件系统中的内容
if(fd < 0) return errno;
nwr = sprintf(value, "%d\n", timeout_ms);
ret = write(fd, value, nwr);
close(fd);
return (ret == nwr) ? 0 : -1;
}
</PRE>
<PRE></PRE>
sendit()函数负责根据时间“振动”：在真实的硬件中，通过sys文件系统的文件进行控制；如果是模拟器环境则通过QEMU发送命令。
vibrator_on()调用sendit()以时间作为参数，vibrator_on()调用sendit()以0作为参数。
上层的情况和注意事项
frameworks/base/services/jni/目录中的com_android_server_VibratorService.cpp文件是Vibrator硬件抽象层的调用者，它同时也向Java提供JNI支持。
其中，为JNI定义的方法列表如下所示：
<PRE class=cpp name="code">　static JNINativeMethod method_table[] = {
　　{ "vibratorOn", "(J)V", (void*)vibratorOn }, // 振动器开
　　{ "vibratorOff", "()V", (void*)vibratorOff } // 振动器关
　　};
　　int register_android_server_VibratorService(JNIEnv *env) {
　　return jniRegisterNativeMethods(env, "com/android/server/VibratorService",
　　method_table, NELEM(method_table));
　　}
　　//vibratorOn()和vibratorOff()这两个函数的实现分别如下所示：
　　
　　static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms){
　　vibrator_on(timeout_ms);
　　}
　　static void vibratorOff(JNIEnv *env, jobject clazz){
　　vibrator_off();
　　}
</PRE>
frameworks/base/services/java/com/android/server/目录中的VibratorService.java通过调用VibratorService JNI来实现com.android.server包中的VibratorService类。
frameworks/base/core/java/android/os/目录中的Vibrator.java文件实现了android.os包中的Vibrator类。它通过调用vibrator的Java服务来实现(获得名称为vibrator的服务)，配合同目录中的IVibratorService.aidl文件向应用程序层提供Vibrator的相关API。
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Timeout方式的驱动程序
<PRE class=cpp name="code">#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/workqueue.h>
#include "timed_output.h"
#include <linux/hrtimer.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <mach/mt_typedefs.h>
#include <mach/mt_pll.h>
#include <mach/mt_gpt.h>
#define VERSION "v 0.1"
#define VIB_DEVICE "mt_vibrator"
#define COUNT_DOWN_TIME 50
#define VIBR_HRTIMER
#ifndef VIBR_HRTIMER
XGPT_NUM Vibrator_XGPT = XGPT7;
#endif
/******************************************************************************
Error Code No.
******************************************************************************/
#define RSUCCESS 0
/******************************************************************************
Debug Message Settings
******************************************************************************/
/* Debug message event */
#define DBG_EVT_NONE 0x00000000 /* No event */
#define DBG_EVT_INT 0x00000001 /* Interrupt related event */
#define DBG_EVT_TASKLET 0x00000002 /* Tasklet related event */
#define DBG_EVT_ALL 0xffffffff
#define DBG_EVT_MASK (DBG_EVT_TASKLET)
#if 1
#define MSG(evt, fmt, args...) \
do { \
if ((DBG_EVT_##evt) & DBG_EVT_MASK) { \
printk(fmt, ##args); \
} \
} while(0)
#define MSG_FUNC_ENTRY(f) MSG(FUC, "<FUN_ENT>: %s\n", __FUNCTION__)
#else
#define MSG(evt, fmt, args...) do{}while(0)
#define MSG_FUNC_ENTRY(f) do{}while(0)
#endif
#define VIBR_CON0 ((volatile unsigned long*)(0xF702F7B0))
static int vibr_Enable(void)
{
printk("[vibrator]vibr_Enable \n");
hwPowerOn(MT_POWER_LDO_VIBR, VOL_2800 , "VIBR");
return 0;
}
static int vibr_Disable(void)
{
while((INREG32(VIBR_CON0)&1))
{
printk("[vibrator]vibr_Disable \n");
hwPowerDown(MT_POWER_LDO_VIBR , "VIBR");
//printk("[vibrator]vibr_Disable:VIBR_CON0=0x%x \r\n", INREG32(VIBR_CON0));
}
return 0;
}
/******************************************************************************
Global Definations
******************************************************************************/
//static struct work_struct vibrator_work;
static struct hrtimer vibe_timer;
static spinlock_t vibe_lock;
static int vibrator_get_time(struct timed_output_dev *dev)
{
if (hrtimer_active(&vibe_timer))
{
ktime_t r = hrtimer_get_remaining(&vibe_timer);
return r.tv.sec * 1000 + r.tv.nsec / 1000000;
}
else
return 0;
}
static void vibrator_enable(struct timed_output_dev *dev, int value)
{
unsigned long flags;
spin_lock_irqsave(&vibe_lock, flags);
#ifdef VIBR_HRTIMER
while(hrtimer_cancel(&vibe_timer))
{
printk("[vibrator]vibrator_enable: try to cancel hrtimer \n");
}
#else
XGPT_Reset(Vibrator_XGPT);
#endif
if (value == 0)
{
printk("[vibrator]vibrator_enable: disable \n");
vibr_Disable();
}
else
{
value = ((value > 15000) ? 15000 : value);
printk("[vibrator]vibrator_enable: vibrator start: %d \n", value);
#ifdef VIBR_HRTIMER
hrtimer_start(&vibe_timer,
ktime_set(value / 1000, (value % 1000) * 1000000),
HRTIMER_MODE_REL);
#else
XGPT_CONFIG config;
config.num = Vibrator_XGPT;
config.clkDiv = 0;
config.mode = XGPT_ONE_SHOT;
config.bIrqEnable = TRUE;
config.u4Compare = value*32768/1000;
if(!XGPT_Config(config))
{
printk("[vibrator]vibrator_enable: config XGPT: %d fail!\n", value);
}
XGPT_Start(Vibrator_XGPT);
#endif
vibr_Enable();
}
spin_unlock_irqrestore(&vibe_lock, flags);
}
#ifdef VIBR_HRTIMER
static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
printk("[vibrator]vibrator_timer_func: vibrator will disable \n");
vibr_Disable();
return HRTIMER_NORESTART;
}
#else
void vibrator_timer_func(UINT16 temp)
{
printk("[vibrator]vibrator_timer_func: vibrator will disable \n");
vibr_Disable();
}
#endif
static struct timed_output_dev mt_vibrator =
{
.name = "vibrator",
.get_time = vibrator_get_time,
.enable = vibrator_enable,
};
static int vib_probe(struct platform_device *pdev)
{
return 0;
}
static int vib_remove(struct platform_device *pdev)
{
return 0;
}
static void vib_shutdown(struct platform_device *pdev)
{
vibr_Disable();
}
/******************************************************************************
Device driver structure
*****************************************************************************/
static struct platform_driver vibrator_driver =
{
.probe = vib_probe,
.remove = vib_remove,
.shutdown = vib_shutdown,
.driver = {
.name = VIB_DEVICE,
},
};
static ssize_t store_vibr_on(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)
{
if(buf != NULL && size != 0)
{
printk("[vibrator]buf is %s and size is %d \n",buf,size);
if(buf[0]== '0')
{
vibr_Disable();
}else
{
vibr_Enable();
}
}
return size;
}
static DEVICE_ATTR(vibr_on, 0664, NULL, store_vibr_on);
/******************************************************************************
* vib_mod_init
*
* DESCRIPTION:
* Register the vibrator device driver !
*
* PARAMETERS:
* None
*
* RETURNS:
* None
*
* NOTES:
* RSUCCESS : Success
*
******************************************************************************/
static s32 __devinit vib_mod_init(void)
{
s32 ret;
printk("Mk MT vibrator driver register, version %s\n", VERSION);
spin_lock_init(&vibe_lock);
#ifdef VIBR_HRTIMER
hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vibe_timer.function = vibrator_timer_func;
#else
XGPT_Init(Vibrator_XGPT, vibrator_timer_func);
#endif
timed_output_dev_register(&mt_vibrator);
ret = platform_driver_register(&vibrator_driver);
if(ret)
{
printk("[vibrator]Unable to register vibrator driver (%d)\n", ret);
return ret;
}
ret = device_create_file(mt_vibrator.dev,&dev_attr_vibr_on);
if(ret)
{
printk("[vibrator]device_create_file vibr_on fail! \n");
}
printk("[vibrator]vib_mod_init Done \n");
return RSUCCESS;
}
/******************************************************************************
* vib_mod_exit
*
* DESCRIPTION:
* Free the device driver !
*
* PARAMETERS:
* None
*
* RETURNS:
* None
*
* NOTES:
* None
*
******************************************************************************/
static void __exit vib_mod_exit(void)
{
printk("Mk MT vibrator driver unregister, version %s \n", VERSION);
printk("[vibrator]vib_mod_exit Done \n");
}
module_init(vib_mod_init);
module_exit(vib_mod_exit);
MODULE_AUTHOR("Mk Inc.");
MODULE_DESCRIPTION("MT Vibrator Driver (VIB)");
MODULE_LICENSE("GPL");</PRE>
<PRE></PRE>
<PRE></PRE>

  
  
  
  
   
   
   
    
    [cpp]  
    view plain 
    copy 
    print 
    ? 
   
  
  
  
  
  
  
  
  
   
   
   
   #define THE_DEVICE "/sys/class/timed_output/vibrator/enable"   
   
   
   
     
   
   
   
   static int sendit(int timeout_ms)  
   
   
   
     
   
   
   
   {  
   
   
   
     
   
   
   
       int nwr, ret, fd;  
   
   
   
     
   
   
   
       char value[20];  
   
   
   
     
   
   
   
   #ifdef QEMU_HARDWARE                // 使用QEMU的情况   
   
   
   
     
   
   
   
       if (qemu_check()) {  
   
   
   
     
   
   
   
           return qemu_control_command( "vibrator:%d", timeout_ms );  
   
   
   
     
   
   
   
       }  
   
   
   
     
   
   
   
   #endif   
   
   
   
     
   
   
   
       fd = open(THE_DEVICE, O_RDWR);               // 读取sys文件系统中的内容   
   
   
   
     
   
   
   
       if(fd < 0) return errno;  
   
   
   
     
   
   
   
       nwr = sprintf(value, "%d\n", timeout_ms);  
   
   
   
     
   
   
   
       ret = write(fd, value, nwr);  
   
   
   
     
   
   
   
       close(fd);  
   
   
   
     
   
   
   
       return (ret == nwr) ? 0 : -1;  
   
   
   
     
   
   
   
   }

#define THE_DEVICE "/sys/class/timed_output/vibrator/enable"

static int sendit(int timeout_ms)

{

    int nwr, ret, fd;

    char value[20];

#ifdef QEMU_HARDWARE                // 使用QEMU的情况

    if (qemu_check()) {

        return qemu_control_command( "vibrator:%d", timeout_ms );

    }

#endif

    fd = open(THE_DEVICE, O_RDWR);               // 读取sys文件系统中的内容

    if(fd < 0) return errno;

    nwr = sprintf(value, "%d\n", timeout_ms);

    ret = write(fd, value, nwr);

    close(fd);

    return (ret == nwr) ? 0 : -1;

}

sendit()函数负责根据时间“振动”：在真实的硬件中，通过sys文件系统的文件进行控制；如果是模拟器环境则通过QEMU发送命令。

vibrator_on()调用sendit()以时间作为参数，vibrator_on()调用sendit()以0作为参数。

上层的情况和注意事项

　　frameworks/base/services/jni/目录中的com_android_server_VibratorService.cpp文件是Vibrator硬件抽象层的调用者，它同时也向Java提供JNI支持。

　　其中，为JNI定义的方法列表如下所示：

  
  
  
  
   
   
   
    
    [cpp]  
    view plain 
    copy 
    print 
    ? 
   
  
  
  
  
  
  
  
  
   
   
   
   　static JNINativeMethod method_table[] = {  
   
   
   
     
   
   
   
   　　{ "vibratorOn", "(J)V", (void*)vibratorOn }, // 振动器开   
   
   
   
     
   
   
   
   　　{ "vibratorOff", "()V", (void*)vibratorOff } // 振动器关   
   
   
   
     
   
   
   
   　　};  
   
   
   
     
   
   
   
   　　int register_android_server_VibratorService(JNIEnv *env) {  
   
   
   
     
   
   
   
   　　return jniRegisterNativeMethods(env, "com/android/server/VibratorService",  
   
   
   
     
   
   
   
   　　method_table, NELEM(method_table));  
   
   
   
     
   
   
   
   　　}  
   
   
   
   　　//vibratorOn()和vibratorOff()这两个函数的实现分别如下所示：   
   
   
   
     
   
   
   
   　　   
   
   
   
     
   
   
   
   　　static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms){  
   
   
   
     
   
   
   
   　　vibrator_on(timeout_ms);  
   
   
   
     
   
   
   
   　　}  
   
   
   
     
   
   
   
   　　static void vibratorOff(JNIEnv *env, jobject clazz){  
   
   
   
     
   
   
   
   　　vibrator_off();  
   
   
   
     
   
   
   
   　　}

　static JNINativeMethod method_table[] = {

　　{ "vibratorOn", "(J)V", (void*)vibratorOn }, // 振动器开

　　{ "vibratorOff", "()V", (void*)vibratorOff } // 振动器关

　　};

　　int register_android_server_VibratorService(JNIEnv *env) {

　　return jniRegisterNativeMethods(env, "com/android/server/VibratorService",

　　method_table, NELEM(method_table));

　　}
　　//vibratorOn()和vibratorOff()这两个函数的实现分别如下所示：

　　 

　　static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms){

　　vibrator_on(timeout_ms);

　　}

　　static void vibratorOff(JNIEnv *env, jobject clazz){

　　vibrator_off();

　　}

        frameworks/base/services/java/com/android/server/目录中的VibratorService.java通过调用VibratorService JNI来实现com.android.server包中的VibratorService类。

　　frameworks/base/core/java/android/os/目录中的Vibrator.java文件实现了android.os包中的Vibrator类。它通过调用vibrator的Java服务来实现(获得名称为vibrator的服务)，配合同目录中的IVibratorService.aidl文件向应用程序层提供Vibrator的相关API。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

我具体的驱动程序

  
  
  
  
   
   
   
    
    [cpp]  
    view plain 
    copy 
    print 
    ? 
   
  
  
  
  
  
  
  
  
   
   
   
   #include <linux/init.h>   
   
   
   
   #include <linux/module.h>   
   
   
   
   #include <linux/kernel.h>   
   
   
   
   #include <linux/types.h>   
   
   
   
   #include <linux/device.h>   
   
   
   
   #include <linux/workqueue.h>   
   
   
   
     
   
   
   
   #include "timed_output.h"   
   
   
   
   #include <linux/hrtimer.h>   
   
   
   
   #include <linux/err.h>   
   
   
   
   #include <linux/platform_device.h>   
   
   
   
   #include <linux/spinlock.h>   
   
   
   
     
   
   
   
   #include <linux/jiffies.h>   
   
   
   
   #include <linux/timer.h>   
   
   
   
     
   
   
   
   #include <mach/mt_typedefs.h>   
   
   
   
   #include <mach/mt_pll.h>   
   
   
   
   #include <mach/mt_gpt.h>   
   
   
   
     
   
   
   
   #define VERSION                         "v 0.1"   
   
   
   
   #define VIB_DEVICE                      "mt_vibrator"   
   
   
   
     
   
   
   
   #define COUNT_DOWN_TIME                 50   
   
   
   
     
   
   
   
   #define VIBR_HRTIMER   
   
   
   
     
   
   
   
   #ifndef VIBR_HRTIMER   
   
   
   
   XGPT_NUM Vibrator_XGPT = XGPT7;  
   
   
   
   #endif   
   
   
   
     
   
   
   
   /****************************************************************************** 
   
   
   
   Error Code No. 
   
   
   
   ******************************************************************************/  
   
   
   
   #define RSUCCESS        0   
   
   
   
     
   
   
   
   /****************************************************************************** 
   
   
   
   Debug Message Settings 
   
   
   
   ******************************************************************************/  
   
   
   
     
   
   
   
   /* Debug message event */  
   
   
   
   #define DBG_EVT_NONE        0x00000000  /* No event */   
   
   
   
   #define DBG_EVT_INT         0x00000001  /* Interrupt related event */   
   
   
   
   #define DBG_EVT_TASKLET     0x00000002  /* Tasklet related event */   
   
   
   
     
   
   
   
   #define DBG_EVT_ALL         0xffffffff   
   
   
   
      
   
   
   
   #define DBG_EVT_MASK        (DBG_EVT_TASKLET)   
   
   
   
     
   
   
   
   #if 1   
   
   
   
   #define MSG(evt, fmt, args...) \   
   
   
   
   do {    \  
   
   
   
       if ((DBG_EVT_##evt) & DBG_EVT_MASK) { \  
   
   
   
           printk(fmt, ##args); \  
   
   
   
       } \  
   
   
   
   } while(0)  
   
   
   
     
   
   
   
   #define MSG_FUNC_ENTRY(f)   MSG(FUC, "<FUN_ENT>: %s\n", __FUNCTION__)   
   
   
   
   #else   
   
   
   
   #define MSG(evt, fmt, args...) do{}while(0)   
   
   
   
   #define MSG_FUNC_ENTRY(f)      do{}while(0)   
   
   
   
   #endif   
   
   
   
     
   
   
   
   #define VIBR_CON0 ((volatile unsigned long*)(0xF702F7B0))   
   
   
   
     
   
   
   
   static int vibr_Enable(void)  
   
   
   
   {  
   
   
   
       printk("[vibrator]vibr_Enable \n");  
   
   
   
       hwPowerOn(MT_POWER_LDO_VIBR, VOL_2800 , "VIBR");  
   
   
   
       return 0;  
   
   
   
   }  
   
   
   
     
   
   
   
   static int vibr_Disable(void)  
   
   
   
   {  
   
   
   
       while((INREG32(VIBR_CON0)&1))  
   
   
   
       {  
   
   
   
           printk("[vibrator]vibr_Disable \n");  
   
   
   
       hwPowerDown(MT_POWER_LDO_VIBR , "VIBR");  
   
   
   
           //printk("[vibrator]vibr_Disable:VIBR_CON0=0x%x \r\n", INREG32(VIBR_CON0));   
   
   
   
       }  
   
   
   
         
   
   
   
       return 0;  
   
   
   
   }  
   
   
   
     
   
   
   
     
   
   
   
   /****************************************************************************** 
   
   
   
   Global Definations 
   
   
   
   ******************************************************************************/  
   
   
   
   //static struct work_struct vibrator_work;   
   
   
   
   static struct hrtimer vibe_timer;  
   
   
   
   static spinlock_t vibe_lock;  
   
   
   
     
   
   
   
     
   
   
   
   static int vibrator_get_time(struct timed_output_dev *dev)  
   
   
   
   {  
   
   
   
       if (hrtimer_active(&vibe_timer))   
   
   
   
       {  
   
   
   
           ktime_t r = hrtimer_get_remaining(&vibe_timer);  
   
   
   
           return r.tv.sec * 1000 + r.tv.nsec / 1000000;  
   
   
   
       }   
   
   
   
       else  
   
   
   
           return 0;  
   
   
   
   }  
   
   
   
     
   
   
   
   static void vibrator_enable(struct timed_output_dev *dev, int value)  
   
   
   
   {  
   
   
   
           unsigned long   flags;  
   
   
   
     
   
   
   
       spin_lock_irqsave(&vibe_lock, flags);  
   
   
   
     
   
   
   
           #ifdef VIBR_HRTIMER   
   
   
   
       while(hrtimer_cancel(&vibe_timer))  
   
   
   
           {  
   
   
   
               printk("[vibrator]vibrator_enable: try to cancel hrtimer \n");  
   
   
   
           }  
   
   
   
       #else   
   
   
   
           XGPT_Reset(Vibrator_XGPT);  
   
   
   
           #endif   
   
   
   
     
   
   
   
       if (value == 0)  
   
   
   
           {        
   
   
   
               printk("[vibrator]vibrator_enable: disable \n");  
   
   
   
               vibr_Disable();  
   
   
   
               
   
   
   
           }  
   
   
   
       else   
   
   
   
       {  
   
   
   
               value = ((value > 15000) ? 15000 : value);  
   
   
   
               printk("[vibrator]vibrator_enable: vibrator start: %d \n", value);   
   
   
   
              
   
   
   
               #ifdef VIBR_HRTIMER   
   
   
   
           hrtimer_start(&vibe_timer,   
   
   
   
               ktime_set(value / 1000, (value % 1000) * 1000000),  
   
   
   
               HRTIMER_MODE_REL);  
   
   
   
     
   
   
   
               #else   
   
   
   
               XGPT_CONFIG config;  
   
   
   
               config.num = Vibrator_XGPT;  
   
   
   
               config.clkDiv = 0;  
   
   
   
               config.mode = XGPT_ONE_SHOT;  
   
   
   
               config.bIrqEnable = TRUE;  
   
   
   
               config.u4Compare = value*32768/1000;  
   
   
   
                 
   
   
   
               if(!XGPT_Config(config))  
   
   
   
               {  
   
   
   
                   printk("[vibrator]vibrator_enable: config XGPT: %d fail!\n", value);   
   
   
   
               }  
   
   
   
                 
   
   
   
               XGPT_Start(Vibrator_XGPT);  
   
   
   
               #endif   
   
   
   
                
   
   
   
               vibr_Enable();  
   
   
   
                
   
   
   
       }  
   
   
   
       spin_unlock_irqrestore(&vibe_lock, flags);  
   
   
   
     
   
   
   
   }  
   
   
   
     
   
   
   
     
   
   
   
   #ifdef VIBR_HRTIMER   
   
   
   
   static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)  
   
   
   
   {  
   
   
   
        printk("[vibrator]vibrator_timer_func: vibrator will disable \n");  
   
   
   
     
   
   
   
       vibr_Disable();  
   
   
   
                 
   
   
   
       return HRTIMER_NORESTART;  
   
   
   
   }  
   
   
   
     
   
   
   
   #else   
   
   
   
   void vibrator_timer_func(UINT16 temp)  
   
   
   
   {  
   
   
   
       printk("[vibrator]vibrator_timer_func: vibrator will disable \n");  
   
   
   
     
   
   
   
       vibr_Disable();  
   
   
   
   }  
   
   
   
   #endif   
   
   
   
     
   
   
   
     
   
   
   
   static struct timed_output_dev mt_vibrator =   
   
   
   
   {  
   
   
   
       .name = "vibrator",  
   
   
   
       .get_time = vibrator_get_time,  
   
   
   
       .enable = vibrator_enable,  
   
   
   
   };  
   
   
   
     
   
   
   
   static int vib_probe(struct platform_device *pdev)  
   
   
   
   {  
   
   
   
       return 0;  
   
   
   
   }  
   
   
   
     
   
   
   
   static int vib_remove(struct platform_device *pdev)  
   
   
   
   {  
   
   
   
       return 0;  
   
   
   
   }  
   
   
   
     
   
   
   
   static void vib_shutdown(struct platform_device *pdev)  
   
   
   
   {  
   
   
   
           vibr_Disable();  
   
   
   
     
   
   
   
   }  
   
   
   
   /****************************************************************************** 
   
   
   
   Device driver structure 
   
   
   
   *****************************************************************************/  
   
   
   
   static struct platform_driver vibrator_driver =   
   
   
   
   {  
   
   
   
       .probe      = vib_probe,  
   
   
   
       .remove     = vib_remove,  
   
   
   
       .shutdown = vib_shutdown,  
   
   
   
       .driver     = {  
   
   
   
       .name = VIB_DEVICE,  
   
   
   
       },  
   
   
   
   };  
   
   
   
     
   
   
   
   static ssize_t store_vibr_on(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)  
   
   
   
   {  
   
   
   
       if(buf != NULL && size != 0)  
   
   
   
       {  
   
   
   
           printk("[vibrator]buf is %s and size is %d \n",buf,size);  
   
   
   
           if(buf[0]== '0')  
   
   
   
           {  
   
   
   
               vibr_Disable();  
   
   
   
           }else  
   
   
   
           {  
   
   
   
               vibr_Enable();  
   
   
   
           }  
   
   
   
       }  
   
   
   
       return size;  
   
   
   
   }  
   
   
   
     
   
   
   
   static DEVICE_ATTR(vibr_on, 0664, NULL, store_vibr_on);  
   
   
   
     
   
   
   
   /****************************************************************************** 
   
   
   
    * vib_mod_init 
   
   
   
    *  
   
   
   
    * DESCRIPTION: 
   
   
   
    *   Register the vibrator device driver !  
   
   
   
    *  
   
   
   
    * PARAMETERS:  
   
   
   
    *   None 
   
   
   
    *  
   
   
   
    * RETURNS:  
   
   
   
    *   None 
   
   
   
    *  
   
   
   
    * NOTES:  
   
   
   
    *   RSUCCESS : Success 
   
   
   
    *  
   
   
   
    ******************************************************************************/  
   
   
   
     
   
   
   
   static s32 __devinit vib_mod_init(void)  
   
   
   
   {     
   
   
   
       s32 ret;  
   
   
   
     
   
   
   
       printk("Mk MT vibrator driver register, version %s\n", VERSION);  
   
   
   
     
   
   
   
       spin_lock_init(&vibe_lock);  
   
   
   
         
   
   
   
           #ifdef VIBR_HRTIMER   
   
   
   
       hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);  
   
   
   
       vibe_timer.function = vibrator_timer_func;  
   
   
   
     
   
   
   
           #else   
   
   
   
           XGPT_Init(Vibrator_XGPT, vibrator_timer_func);  
   
   
   
           #endif   
   
   
   
         
   
   
   
       timed_output_dev_register(&mt_vibrator);  
   
   
   
     
   
   
   
           ret = platform_driver_register(&vibrator_driver);  
   
   
   
     
   
   
   
           if(ret)   
   
   
   
           {  
   
   
   
           printk("[vibrator]Unable to register vibrator driver (%d)\n", ret);  
   
   
   
           return ret;  
   
   
   
           }     
   
   
   
     
   
   
   
       ret = device_create_file(mt_vibrator.dev,&dev_attr_vibr_on);  
   
   
   
       if(ret)  
   
   
   
       {  
   
   
   
           printk("[vibrator]device_create_file vibr_on fail! \n");  
   
   
   
       }  
   
   
   
         
   
   
   
       printk("[vibrator]vib_mod_init Done \n");  
   
   
   
      
   
   
   
       return RSUCCESS;  
   
   
   
   }  
   
   
   
     
   
   
   
   /****************************************************************************** 
   
   
   
    * vib_mod_exit 
   
   
   
    *  
   
   
   
    * DESCRIPTION:  
   
   
   
    *   Free the device driver !  
   
   
   
    *  
   
   
   
    * PARAMETERS:  
   
   
   
    *   None 
   
   
   
    *  
   
   
   
    * RETURNS:  
   
   
   
    *   None 
   
   
   
    *  
   
   
   
    * NOTES:  
   
   
   
    *   None 
   
   
   
    *  
   
   
   
    ******************************************************************************/  
   
   
   
      
   
   
   
   static void __exit vib_mod_exit(void)  
   
   
   
   {  
   
   
   
       printk("Mk MT vibrator driver unregister, version %s \n", VERSION);  
   
   
   
       printk("[vibrator]vib_mod_exit Done \n");  
   
   
   
   }  
   
   
   
     
   
   
   
   module_init(vib_mod_init);  
   
   
   
   module_exit(vib_mod_exit);  
   
   
   
   MODULE_AUTHOR("Mk Inc.");  
   
   
   
   MODULE_DESCRIPTION("MT Vibrator Driver (VIB)");  
   
   
   
   MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/workqueue.h>

#include "timed_output.h"
#include <linux/hrtimer.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>

#include <linux/jiffies.h>
#include <linux/timer.h>

#include <mach/mt_typedefs.h>
#include <mach/mt_pll.h>
#include <mach/mt_gpt.h>

#define VERSION					        "v 0.1"
#define VIB_DEVICE	        			"mt_vibrator"

#define COUNT_DOWN_TIME					50

#define VIBR_HRTIMER

#ifndef VIBR_HRTIMER
XGPT_NUM Vibrator_XGPT = XGPT7;
#endif

/******************************************************************************
Error Code No.
******************************************************************************/
#define RSUCCESS        0

/******************************************************************************
Debug Message Settings
******************************************************************************/

/* Debug message event */
#define DBG_EVT_NONE		0x00000000	/* No event */
#define DBG_EVT_INT			0x00000001	/* Interrupt related event */
#define DBG_EVT_TASKLET		0x00000002	/* Tasklet related event */

#define DBG_EVT_ALL			0xffffffff
 
#define DBG_EVT_MASK      	(DBG_EVT_TASKLET)

#if 1
#define MSG(evt, fmt, args...) \
do {	\
	if ((DBG_EVT_##evt) & DBG_EVT_MASK) { \
		printk(fmt, ##args); \
	} \
} while(0)

#define MSG_FUNC_ENTRY(f)	MSG(FUC, "<FUN_ENT>: %s\n", __FUNCTION__)
#else
#define MSG(evt, fmt, args...) do{}while(0)
#define MSG_FUNC_ENTRY(f)	   do{}while(0)
#endif

#define VIBR_CON0 ((volatile unsigned long*)(0xF702F7B0))

static int vibr_Enable(void)
{
    printk("[vibrator]vibr_Enable \n");
	hwPowerOn(MT_POWER_LDO_VIBR, VOL_2800 , "VIBR");
	return 0;
}

static int vibr_Disable(void)
{
    while((INREG32(VIBR_CON0)&1))
    {
        printk("[vibrator]vibr_Disable \n");
	hwPowerDown(MT_POWER_LDO_VIBR , "VIBR");
        //printk("[vibrator]vibr_Disable:VIBR_CON0=0x%x \r\n", INREG32(VIBR_CON0));
    }
	
	return 0;
}


/******************************************************************************
Global Definations
******************************************************************************/
//static struct work_struct vibrator_work;
static struct hrtimer vibe_timer;
static spinlock_t vibe_lock;


static int vibrator_get_time(struct timed_output_dev *dev)
{
	if (hrtimer_active(&vibe_timer)) 
	{
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} 
	else
		return 0;
}

static void vibrator_enable(struct timed_output_dev *dev, int value)
{
        unsigned long   flags;

	spin_lock_irqsave(&vibe_lock, flags);

        #ifdef VIBR_HRTIMER
	while(hrtimer_cancel(&vibe_timer))
        {
            printk("[vibrator]vibrator_enable: try to cancel hrtimer \n");
        }
	#else
        XGPT_Reset(Vibrator_XGPT);
        #endif

	if (value == 0)
        {      
            printk("[vibrator]vibrator_enable: disable \n");
            vibr_Disable();
          
        }
	else 
	{
			value = ((value > 15000) ? 15000 : value);
            printk("[vibrator]vibrator_enable: vibrator start: %d \n", value); 
         
            #ifdef VIBR_HRTIMER
	    hrtimer_start(&vibe_timer, 
			ktime_set(value / 1000, (value % 1000) * 1000000),
			HRTIMER_MODE_REL);

            #else
            XGPT_CONFIG config;
			config.num = Vibrator_XGPT;
            config.clkDiv = 0;
            config.mode = XGPT_ONE_SHOT;
            config.bIrqEnable = TRUE;
            config.u4Compare = value*32768/1000;
            
            if(!XGPT_Config(config))
            {
                printk("[vibrator]vibrator_enable: config XGPT: %d fail!\n", value); 
            }
            
            XGPT_Start(Vibrator_XGPT);
            #endif
           
            vibr_Enable();
           
	}
	spin_unlock_irqrestore(&vibe_lock, flags);

}


#ifdef VIBR_HRTIMER
static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
     printk("[vibrator]vibrator_timer_func: vibrator will disable \n");

    vibr_Disable();
            
 	return HRTIMER_NORESTART;
}

#else
void vibrator_timer_func(UINT16 temp)
{
    printk("[vibrator]vibrator_timer_func: vibrator will disable \n");

    vibr_Disable();
}
#endif


static struct timed_output_dev mt_vibrator = 
{
	.name = "vibrator",
	.get_time = vibrator_get_time,
	.enable = vibrator_enable,
};

static int vib_probe(struct platform_device *pdev)
{
	return 0;
}

static int vib_remove(struct platform_device *pdev)
{
	return 0;
}

static void vib_shutdown(struct platform_device *pdev)
{
		vibr_Disable();

}
/******************************************************************************
Device driver structure
*****************************************************************************/
static struct platform_driver vibrator_driver = 
{
    .probe		= vib_probe,
	.remove	    = vib_remove,
    .shutdown = vib_shutdown,
    .driver     = {
    .name = VIB_DEVICE,
    },
};

static ssize_t store_vibr_on(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)
{
	if(buf != NULL && size != 0)
	{
		printk("[vibrator]buf is %s and size is %d \n",buf,size);
		if(buf[0]== '0')
		{
			vibr_Disable();
		}else
		{
			vibr_Enable();
		}
	}
	return size;
}

static DEVICE_ATTR(vibr_on, 0664, NULL, store_vibr_on);

/******************************************************************************
 * vib_mod_init
 * 
 * DESCRIPTION:
 *   Register the vibrator device driver ! 
 * 
 * PARAMETERS: 
 *   None
 * 
 * RETURNS: 
 *   None
 * 
 * NOTES: 
 *   RSUCCESS : Success
 * 
 ******************************************************************************/

static s32 __devinit vib_mod_init(void)
{	
	s32 ret;

	printk("Mk MT vibrator driver register, version %s\n", VERSION);

	spin_lock_init(&vibe_lock);
    
        #ifdef VIBR_HRTIMER
	hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	vibe_timer.function = vibrator_timer_func;

        #else
        XGPT_Init(Vibrator_XGPT, vibrator_timer_func);
        #endif
    
	timed_output_dev_register(&mt_vibrator);

        ret = platform_driver_register(&vibrator_driver);

        if(ret) 
        {
		printk("[vibrator]Unable to register vibrator driver (%d)\n", ret);
		return ret;
        }	

	ret = device_create_file(mt_vibrator.dev,&dev_attr_vibr_on);
    if(ret)
    {
        printk("[vibrator]device_create_file vibr_on fail! \n");
    }
    
	printk("[vibrator]vib_mod_init Done \n");
 
    return RSUCCESS;
}

/******************************************************************************
 * vib_mod_exit
 * 
 * DESCRIPTION: 
 *   Free the device driver ! 
 * 
 * PARAMETERS: 
 *   None
 * 
 * RETURNS: 
 *   None
 * 
 * NOTES: 
 *   None
 * 
 ******************************************************************************/
 
static void __exit vib_mod_exit(void)
{
	printk("Mk MT vibrator driver unregister, version %s \n", VERSION);
	printk("[vibrator]vib_mod_exit Done \n");
}

module_init(vib_mod_init);
module_exit(vib_mod_exit);
MODULE_AUTHOR("Mk Inc.");
MODULE_DESCRIPTION("MT Vibrator Driver (VIB)");
MODULE_LICENSE("GPL");

<P><STRONG>SYS文件系统方式的驱动程序</STRONG></P>

#include <linux/module.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/lnw_gpio.h>
#include <asm/intel-mid.h>

#define VIBRA_ENABLE_GPIO 91

struct vibra_info {
 int     enabled;
 struct mutex lock;
 struct device *dev;
 const char *name;
 int gpio_en;
};
/* Enable's vibra driver */
static void vibra_enable(struct vibra_info *info)
{
 mutex_lock(&info->lock);
 gpio_set_value(info->gpio_en, 1);
 info->enabled = true;
 mutex_unlock(&info->lock);
}
static void vibra_disable(struct vibra_info *info)
{
 mutex_lock(&info->lock);
 gpio_set_value(info->gpio_en, 0);
 info->enabled = false;
 mutex_unlock(&info->lock);
}

/******************************************************************************
 * SYSFS                                                                                            *
 ******************************************************************************/
static ssize_t vibra_show_vibrator(struct device *dev,
  struct device_attribute *attr, const char *buf, size_t size)
{
 struct vibra_info *info = dev_get_drvdata(dev);
 return sprintf(buf, "%d\n", info->enabled);
}
static ssize_t vibra_set_vibrator(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t size)
{
 long vibrator_enable;
 struct vibra_info *info = dev_get_drvdata(dev);
 if (kstrtol(buf, 10, &vibrator_enable))
  return -EINVAL;
 else if (vibrator_enable == 0)
  vibra_disable(info);
 else if (vibrator_enable == 1)
  vibra_enable(info);
 else
  return -EINVAL;
 return size;
}
static DEVICE_ATTR(vibrator, S_IWUSR | S_IRUGO,
     vibra_show_vibrator,vibra_set_vibrator);
static struct attribute *gpio_vibra_attrs[] = {
 &dev_attr_vibrator.attr,
 NULL,
};
static struct attribute_group gpio_vibra_attr_group = {
 .attrs = gpio_vibra_attrs,
};
#if CONFIG_PM
static int vibra_runtime_suspend(struct device *dev)
{
 printk("In %s\n", __func__);
 return 0;
}
static int vibra_runtime_resume(struct device *dev)
{
 printk("In %s\n", __func__);
 return 0;
}
static const struct dev_pm_ops intel_mid_vibra_pm_ops = {
 .suspend = vibra_runtime_suspend,
 .resume = vibra_runtime_resume,
};
#endif
static int __devinit gpio_vibra_probe(struct platform_device *pdev)
{
 struct vibra_info *info;
 struct mid_vibra_probe *data;
 int ret = 0;
 
 info =  kzalloc(sizeof(*info), GFP_KERNEL);
 if (!info)
  return -ENOMEM;
 info->gpio_en = VIBRA_ENABLE_GPIO;
 printk("using gpios en: %d", info->gpio_en);
 ret = gpio_request_one(info->gpio_en, GPIOF_DIR_OUT, "VIBRA ENABLE");
 if (ret != 0) {
  pr_err("gpio_request(%d) fails:%d\n", info->gpio_en, ret);
  goto out;
 }
 info->name = "intel_mid:vibrator";
 mutex_init(&info->lock);

 ret = sysfs_create_group(&pdev->dev.kobj, &gpio_vibra_attr_group);
 if (ret) {
  pr_err("Unable to export keys/switches, error: %d\n",ret);
  goto do_freegpio_vibra_enable;
 }
 platform_set_drvdata(pdev, info);
 return ret;
do_freegpio_vibra_enable:
 sysfs_remove_group(&pdev->dev.kobj, &gpio_vibra_attr_group);
 gpio_free(info->gpio_en);
out:
 return ret;
}
static void __devexit gpio_vibra_remove(struct platform_device *pdev)
{
 struct vibra_info *info = platform_get_drvdata(pdev);
 gpio_free(info->gpio_en);
 sysfs_remove_group(&pdev->dev.kobj, &gpio_vibra_attr_group);
}
static struct of_device_id gpio_vibra_of_match[] = {
 { .compatible = "gpio-vibra", },
 { },
};
MODULE_DEVICE_TABLE(of, gpio_vibra_of_match);

static struct platform_driver gpio_vibra_device_driver = {
 .probe  = gpio_vibra_probe,
 .remove  = __devexit_p(gpio_vibra_remove),
 .driver  = {
  .name = "gpio-vibra",
  .owner = THIS_MODULE,
#ifdef CONFIG_PM_SLEEP
  .pm = &intel_mid_vibra_pm_ops,
#endif
 .of_match_table = gpio_vibra_of_match,
 }
};

static int __init gpio_vibra_init(void)
{
 int ret = 0;
 ret = platform_driver_register(&gpio_vibra_device_driver);
 if (ret)
  pr_err("vib driver register failed\n");
 return ret;
}
static void __exit gpio_vibra_exit(void)
{
 platform_driver_unregister(&gpio_vibra_device_driver);
 printk("intel_mid_vibra driver exited\n");
 return;
}
static struct platform_device vb_device = {
 .name  = "gpio-vibra",
 .id  = -1,
 .dev  = {
  .platform_data = NULL,//&gpio_keys,
 },
};
static int __init vibra_platform_init(void)
{
 return platform_device_register(&vb_device);
}

late_initcall(vibra_platform_init);
module_init(gpio_vibra_init);
module_exit(gpio_vibra_exit);
MODULE_ALIAS("gpio:intel_mid_vibra");
MODULE_DESCRIPTION("gpio control Vibra driver");
MODULE_LICENSE("GPL v2");

更多 1

你可能感兴趣的:(Vibrator)

MT25003D开关机振动 tianxiaoMCU
定义位置1、开机振动定义在mcu\plutommi\mmi\Bootup\BootupSrc\BootupFlow.c的mmi_bootup_flow_early_init函数中，具体如下：#ifdefined(__MMI_POWER_ON_OFF_MUTE__)||defined(__SMART_TERMINAL_SUPPER__)srv_vibrator_play_once();#endif2
Android System Service系统服务--1 福哥哥哥 android System Service AIDL
因为工作中经常需要解决一些framework层的问题，而framework层功能一般都是systemservice的代理stub，然后封装相关接口，并提供给APP层使用，systemservice则在不同的进程中运行，这样实现了分层，隔离，跨进程等需求。下面以Vibrator为例，总结一下实现流程定义一个抽象类Vibrator，定义了应用中可以访问的一些抽象方法frameworks/base/co
Android 10.0 framework 默认开启振动安卓兼职framework应用工程师 android framework 默认开启振动开启振动
1.概述在10.0的系统产品开发中，系统settings的声音菜单下有一个开启震动的功能开关，默认是关闭的，由于项目的需要要求开启震动功能，所以就要看源码震动开关是怎么打开的Android开启振动主要运用了Vibrator（振动器），系统中有一个Vibrator抽象类，我们可以通过获取Vibrator实例调用里面的方法来完成振动功能。app关于振动的相关api如下Vibratorvibrator=
Android Vibrator 手机震动夏沫琅琊 android android 智能手机
AndroidVibrator手机震动本篇文章主要讲下手机震动.1:检测是否支持震动/***@paramcontext*@return*是否支持手机震动*/publicstaticbooleanhasVibrator(Contextcontext){ObjectsystemService=context.getSystemService(Context.VIBRATOR_SERVICE);retu
安卓的惊喜特性：探索这些令人兴奋的新功能！独行侠影 android Android
安卓操作系统一直以其灵活性和可定制性而闻名。除了众所周知的功能外，安卓还隐藏了一些令人惊喜的特性，让用户能够更好地体验和个性化他们的设备。在本文中，我们将介绍一些令人兴奋的安卓特性，并提供相应的源代码，让您亲自尝试这些功能。触摸反馈安卓设备可以通过触摸反馈来提供更丰富的用户体验。通过使用Vibrator类，您可以在触摸屏幕时产生震动反馈。以下是一个简单的示例代码，演示如何在按钮点击时触发震动效果：
HarmonyOS 振动效果开发指导 HarmonyOS开发者华为 HarmonyOS
Vibrator开发概述振动器模块服务最大化开放硬工最新马达器件能力，通过拓展原生马达服务实现振动与交互融合设计，打造细腻精致的一体化振动体验和差异化体验，提升用户交互效率和易用性、提升用户体验、增强品牌竞争力。运作机制Vibrator属于控制类小器件，主要包含以下四个模块：VibratorAPI，VibratorFramework，VibratorService和HDF层。图1控制类小器件中的V
Android 使用Vibrator服务实现点击按钮带有震动效果 i小灰
Vibrator振动器，是手机自带的振动器哦，不要想成岛国用的那种神秘东西哦~~Vibrator是Android给我们提供的用于机身震动的一个服务哦更多详情可见官方API文档：Vibrator在这里插入图片描述在这里插入图片描述如何使用？首先添加震动权限：获得Vibrator实例：VibratormVibrator=(Vibrator)getSystemService(VIBRATOR_SERVI
Android硬件服务框架实例之Vibrator(驱动到应用) kevin@1024 Android framework vibrator 硬件服务 android android框架
转载于：http://www.cnblogs.com/skywang12345/p/3404808.html，内容有所修改，这篇vibrator源码是基于安卓7.1分析。系列：安卓硬件访问服务框架安卓从零添加硬件服务实例（驱动到app调用）目的是想和大家分享自己对Android系统的一点认识：以马达为代表，来考究“Android是如何一步步工作的。它从硬件设计，到Linux驱动，再到HAL，再到J
android 学习手机震动 cnjzy0106 android 手机 service
privateVibratorvibrator;this.vibrator=(Vibrator)this.activity.getSystemService(this.activity.VIBRATOR_SERVICE);this.vibrator.vibrate(500);AndroidManifest.xmlhttp://dl.vmall.com/c0mo4dqu65http://dl.vma
加速度传感器被罚站的树
importandroid.content.Context;importandroid.hardware.Sensor;importandroid.hardware.SensorEvent;importandroid.hardware.SensorEventListener;importandroid.hardware.SensorManager;importandroid.os.Vibrator
Android振动器(Vibrator) 在下嗷呜 1024程序员节 android java
1.获取权限振动器权限仅需静态申请在清单文件中声明：android.permission.VIBRATE2.振动器的使用//获取系统服务-振动器Vibratorvibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);//判断是否有振动器if(vibrator.hasVibrator()){//振动（参数为振动毫秒数-long型）vibrator.
RK3568平台开发系列：振动器系统架构各层详解 Android TechGlide 系统架构 android Android
RK3568平台开发系列：振动器系统架构各层详解Android在本文中，我们将深入探讨RK3568平台上振动器系统的架构各层，并提供相应的源代码示例。振动器系统在Android设备中扮演着重要的角色，它能够为用户提供触觉反馈，增强用户体验。应用层在Android上使用振动器，首先需要在应用层进行相关的操作。通常，我们可以通过使用系统提供的Vibrator类来实现振动功能。以下是一个示例代码，演示如
Androidの点击按钮Vibrator震动 SteamPY
SteamPy,实现聊天，点击用户头像@功能时候，需要震动提示感.1.使用简介初始化获取Vibrator对象vibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);或者vibrator=(Vibrator)getApplication().getSystemService(Service.VIBRATOR_SERVICE);开始震动1.vibra
Android 高版（>=10）本中无法在后台震动旺仔爸
上方法VibratormVibrator=(Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE);long[]patern={0,1000,1000};AudioAttributesaudioAttributes=null;if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.LOLLIPOP)
Android 摇一摇功能实现胡洁_ec66
现在有不少的应用开始实现了摇一摇功能，今天就把摇一摇的实现过程做一下记录。用到知识点1.加速度传感器2.补间动画3.手机震动(Vibrator)4.较短声音/音效的播放(SoundPool)首先布局文件布局写了好了就开始实现摇一摇功能了。首先实现摇一摇的操作publicclassShakeListenerimplementsSensorEventListener{//速度阈值，当摇晃速度达到这值后
Android开发振动和响铃码农来搬砖
我们在做Android开发的时候，有时候会用到振动和响铃的功能，特别是一些有关通信类的，在接受到消息的时候需要通过振动和响铃的方式去提醒用户，下面就简单介绍一下具体怎么操作的。1、振动功能的实现（1）首先我们需要加入振动的权限（2）我们需要用到Vibrator类去实现振动功能，下面说一下需要用到的几个方法：//检查硬件是否有振动器booleanhasVibrator()//控制手机振动millis
Android振动器使用方法详解
本文实例为大家分享了Android振动器使用方法的具体代码，供大家参考，具体内容如下效果图：选择相应的毫秒数，就会振动相应的秒数。实现步骤：一、创建activity_vibrator.xml布局之后绘制，下拉列表，每一列的高度和每一列中字体的颜色和太小等属性在这里面设置item_select.xml布局如下：之后在VibratorActivity中实现振动功能：publicclassVibrato
Android 手机震动 ChenME
权限使用Vibratorvibrator=(Vibrator)_activity.getSystemService(VIBRATOR_SERVICE);vibrator.vibrate(100);
Android应用实现点击按钮震动
本项目为大家分享了Android应用实现点击按钮震动的具体代码，供大家参考，具体内容如下项目中需要实现点击应用中的按钮，有震动效果。震动效果可以在设置中进行关闭。具体实现如下。编写震动帮助类：VibrateHelp.javaimportandroid.content.Context;importandroid.os.Vibrator;/***震动帮助类*androidManifest.xml中加入
Android 手机震动提示效果 Android Vibrator 手机震动 bug樱樱 Android android
在码农的世界里，优美的应用体验，来源于程序员对细节的处理以及自我要求的境界，年轻人也是忙忙碌碌的码农中一员，每天、每周，都会留下一些脚印，就是这些创作的内容，有一种执着，就是不知为什么，如果你迷茫，不妨来瞅瞅码农的轨迹。如果你有兴趣可以关注一下公众号biglead来获取更多分享内容。在手机App中的一些业务场景，如用户点击按钮操作震动提示一下或者是扫码环节中扫码成功震动提示一下用户，是一个不错的细
怎么用 Cocos2d- 3.x 实现手机震动放梦追逐-李超 Cocos2d-x总结学习
在很多时候，我们都看到很多游戏里面有手机震动的这种效果，今天给大家分享一下怎么用Cocos2d-3.x实现手机震动。废话不多说，直接进入主题，请看1、首先你需要建一个Coco2dx的项目，确保当前项目能打包到Android手机上，并没有错误2、建立一个Vibrator的类，然后在.hpp里面实现：#ifndefVibrator_hpp#defineVibrator_hpp#include#incl
permissions required by Vibrator.vibrate: android.permission.VIBRATE weixin_33860147 移动开发 java
转载于:https://www.cnblogs.com/zuochanzi/p/9025958.html
android实现震动和声音 TroubleDuoduo Adroid学习心得
直接上类震动和声音是一起的publicclassTipHelper{staticContextmyContext;staticVibratorvibrator;staticMediaPlayermediaPlayer;publicTipHelper(Contextcontext){myContext=context;vibrator=(Vibrator)myContext.getSystemSer
从底层驱动到上层APP的流程（3） water_clj
先按照andorid标准在HAL层添加对JIN的接口到目录下：t61_0511/alps/hardware/libhardware/include/hardware创建cameravibrator.h文件（同理我们也仿照vibrator的方法copyvibrator.h的代码并rename为cameravibrator.h）再到目录：alps/hardware/libhardware/module
Android：Vibrator 北方的天空2000
简介android.os.Vibrator是Andoroid中负责震动的类，是个系统级别，获取对象的方法如下：Vibratorvibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);震动和取消震动vibrator.vibrate(2000);vibrator.cancel();注意：震动一定要加权限方法方法说明vibrate(longmillis
Android 震动示例--心跳效果 raylueng Android
正在开发第二个游戏，计时就要结束的时候，为了营造紧张的气氛，会利用手机自身的震动模拟心跳效果，其实这个心跳效果做起来真的非常的简单。所以直接上代码了（注意模拟器是模拟不了震动的，得真机测试哦）：程序效果：packagecom.ray.test;importandroid.app.Activity;importandroid.os.Bundle;importandroid.os.Vibrator;i
Android Vibrator开启振动功能 Ruomiz
image前言Android开启振动主要运用了Vibrator（振动器），系统中有一个Vibrator抽象类，我们可以通过获取Vibrator实例调用里面的方法来完成振动功能。Vibratorvibrator=(Vibrator)getSystemServic(Service.VIBRATOR_SERVICE);记得加权限：方法和参数vibrator.vibrate(1000);//设置手机振动v
EditText之ClearEditText pszh
1.首先看下代码吧importandroid.content.Context;importandroid.graphics.drawable.Drawable;importandroid.os.Vibrator;importandroid.text.Editable;importandroid.text.TextWatcher;importandroid.util.AttributeSet;imp
短视频app开源源码Android 如何实现手机震动云豹网络科技技术类 java android 安卓反射 python
一、Android的震动实现——Vibrator类在开发过程中，需要实现震动，网上有好些例子，这里就不阐述了，直接上code.一定要在AndroidManifest.xml增加权限；获取Vibrator实例；vibrator=(Vibrator)VibrateActivity.this.getSystemService(VibrateActivity.VIBRATOR_SERVICE);3)使用的
Android Vibrator的使用 yuxiyu! Android
Vibrator主要用于控制Android手机的震动，其用法比较简单，获取震动器Vibrator对象主要使用如下方法：vibrator=(Vibrator)getSystemService(Context.VIBRATOR_SERVICE);要控制手机震动，必须在配置文件中声明权限：然后是调用Vibrator对象的方法，控制手机震动有两种方式，一种是让手机震动多少秒，主要使用如下方法：vibrat
桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？换个号韩国红果果 html 小球碰撞
稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
《高性能HTML5》读后整理的Web性能优化内容白糖_ html5
读后感先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。
[JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop 商城系统 jshop 电商系统
在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。在jshop中，对RequestContextHolder的
算法之时间复杂度周凡杨 java 算法时间复杂度效率
在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况。这样用大写O()来体现算法时间复杂度的记法，
Java事务处理 g21121 java
一、什么是Java事务通常的观念认为，事务仅与数据库相关。事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
Linux awk命令详解 510888780 linux
一. AWK 说明 awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。 awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
android permission 布衣凌宇 Permission
<uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
Oracle和谷歌Java Android官司将推迟 aijuans java oracle
北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
linux shell 常用命令 antlove linux shell command
grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术 Java解析xml文档 dom技术 XML配置数据库连接
XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习 XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML: DOM解析XML文件 SA
underscore.js 学习（二） bijian1013 JavaScript underscore
Array Functions 所有数组函数对参数对象一样适用。1.first _.first(array, [n]) 别名: head, take 返回array的第一个元素，设置了参数n，就
plSql介绍 bijian1013 oracle 数据库 plsql
/* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
【Nginx一】Nginx安装与总体介绍 bit1129 nginx
启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件
spring mvc开发中浏览器兼容的奇怪问题 bitray jquery Ajax springMVC 浏览器上传文件
最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件. 在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
Lua的io库函数列表 ronin47 lua io
1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
java-26-左旋转字符串 bylijinnan java
public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。 1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
[轨道与计算]新的并行计算架构 comsci 并行计算
我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？
重复执行某段代码 dai_lm android
用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
Java实现堆栈（list实现） datageek 数据结构——堆栈
public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DB backup
一：通过备份王等软件进行备份前台进不去？用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。解决方法：学会修改网站配置文件，大多是由co
github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com github git webhook
转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！工具/原料 github 方法/步骤
">的作用" target="_blank">JSP中的作用蕃薯耀
JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
linux下SAMBA服务安装与配置 hanqunfeng linux
局域网使用的文件共享服务。一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
guava cache IXHONG cache
缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScript jquery css
这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码： (
美国人的福利和中国人的储蓄 nannan408
今天看了篇文章，震动很大，说的是美国的福利。美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
C语言算法之打渔晒网问题 qiufeihu c 算法
如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。代码如下： #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
XML中DOCTYPE字段的解析 wyzuomumu xml
DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL. 私有DTD <!DOCTYPErootSYST