android 静音与振动
1,设置静音和振动
静音和振动都属于来电后的动作.所以在设置静音和振动时都只是设置一些标识,并往数据库写入相应标识.
文件：packages/apps/settings/src/com/android/settings/SoundAndDisplaySettings.java
private CheckBoxPreference mSilent;
private CheckBoxPreference mVibrate;
private void setRingerMode(boolean silent, boolean vibrate) {
if (silent) {
mAudioManager.setRingerMode(vibrate ? AudioManager.RINGER_MODE_VIBRATE :
AudioManager.RINGER_MODE_SILENT);
} else {
mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
mAudioManager.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER,
vibrate ? AudioManager.VIBRATE_SETTING_ON
: AudioManager.VIBRATE_SETTING_OFF);
}
}
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
if (preference == mSilent || preference == mVibrate) {
setRingerMode(mSilent.isChecked(), mVibrate.isChecked());
if (preference == mSilent) updateState(false);
}
...
静音和振动是复选框按钮,两个中有一个发生变化时调用setRingerMode对状态进行设置;如下状态描术:
RINGER_MODE_SILENT 静音,且无振动
RINGER_MODE_VIBRATE 静音,但有振动
RINGER_MODE_NORMAL 正常声音,振动开关由setVibrateSetting决定.
铃响模式的设置是通过mAudioManager(音频管理器)来实现的.
2 音频管理器服务
mAudioManager所在服务如下:
文件: frameworks/base/media/java/android/media/AudioManager.java
public static final int RINGER_MODE_SILENT = 0;
public static final int RINGER_MODE_VIBRATE = 1;
public static final int RINGER_MODE_NORMAL = 2;
public void setRingerMode(int ringerMode) {
IAudioService service = getService();
try {
service.setRingerMode(ringerMode);
} catch (RemoteException e) {
Log.e(TAG, "Dead object in setRingerMode", e);
}
}
将铃响模式值传给音频接口服务IaudioService
public static final int VIBRATE_TYPE_RINGER = 0;
public static final int VIBRATE_TYPE_NOTIFICATION = 1;
public static final int VIBRATE_SETTING_OFF = 0;
public static final int VIBRATE_SETTING_ON = 1;
public static final int VIBRATE_SETTING_ONLY_SILENT = 2;
public void setVibrateSetting(int vibrateTyp , int vibrateSetting) {
IAudioService service = getService();
try {
service.setVibrateSetting(vibrateType, vibrateSetting);
} catch (RemoteException e) {
Log.e(TAG, "Dead object in setVibrateSetting", e);
}
}
将振动类型和振动设置传给音频接口服务IaudioService,IaudioService的定义如下:
frameworks/base/media/java/android/media/IAudioService.aidl
frameworks/base/media/java/android/media/AudioService.java
文件: frameworks/base/media/java/android/media/AudioService.java
文件: frameworks/base/core/java/android/provider/Settings.java
public void setRingerMode(int ringerMode) {
synchronized (mSettingsLock) {
if (ringerMode != mRingerMode) {
setRingerModeInt(ringerMode, true);
// Send sticky broadcast
broadcastRingerMode();
}
}
}
将对应模式下的音量写入数据库,并将该模式广播.
public void setVibrateSetting(int vibrateType, int vibrateSetting) {
mVibrateSetting = getValueForVibrateSetting(mVibrateSetting, vibrateType, vibrateSetting);
// Broadcast change
broadcastVibrateSetting(vibrateType);
// Post message to set ringer mode (it in turn will post a message
// to persist)
sendMsg(mAudioHandler, MSG_PERSIST_VIBRATE_SETTING, SHARED_MSG, SENDMSG_NOOP, 0, 0,
null, 0);
}
同样将振动模式写入数据库,并广播该模式.
3 硬件服务
文件：frameworks/base/services/java/com/android/server/HardwareService.java
开始振动：
public void vibrate(long milliseconds, IBinder token) {
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
!= PackageManager.PERMISSION_GRANTED) {
throw new SecurityException("Requires VIBRATE permission");
}
// We're running in the system server so we cannot crash. Check for a
// timeout of 0 or negative. This will ensure that a vibration has
// either a timeout of > 0 or a non-null pattern.
if (milliseconds <= 0 || (mCurrentVibration != null
&& mCurrentVibration.hasLongerTimeout(milliseconds))) {
// Ignore this vibration since the current vibration will play for
// longer than milliseconds.
return;
}
Vibration vib = new Vibration(token, milliseconds);
synchronized (mVibrations) {
removeVibrationLocked(token);
doCancelVibrateLocked();
mCurrentVibration = vib;
startVibrationLocked(vib);
}
}
private void startVibrationLocked(final Vibration vib) {
if (vib.mTimeout != 0) {
vibratorOn(vib.mTimeout);
mH.postDelayed(mVibrationRunnable, vib.mTimeout);
} else {
// mThread better be null here. doCancelVibrate should always be
// called before startNextVibrationLocked or startVibrationLocked.
mThread = new VibrateThread(vib);
mThread.start();
}
}
该接口允许设置振动的时间长度，通过调用vibratorOn(vib.mTimeout);实现对底层硬件的操作。
取消振动：
public void cancelVibrate(IBinder token) {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.VIBRATE,
"cancelVibrate");
// so wakelock calls will succeed
long identity = Binder.clearCallingIdentity();
try {
synchronized (mVibrations) {
final Vibration vib = removeVibrationLocked(token);
if (vib == mCurrentVibration) {
doCancelVibrateLocked();
startNextVibrationLocked();
}
}
}
finally {
Binder.restoreCallingIdentity(identity);
}
}
private void doCancelVibrateLocked() {
if (mThread != null) {
synchronized (mThread) {
mThread.mDone = true;
mThread.notify();
}
mThread = null;
}
vibratorOff ();
mH.removeCallbacks(mVibrationRunnable);
}
该接口允许停止振动，通过调用vibratorOff();实现对底层硬件的操作。
4 硬件调用
vibratorOn、vibratorOff对应的jni代码如下：
文件：frameworks/base/services/jni/com_android_server_HardwareService.cpp
static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms)
{
// LOGI("vibratorOn/n");
vibrator_on(timeout_ms);
}
static void vibratorOff(JNIEnv *env, jobject clazz)
{
// LOGI("vibratorOff/n");
vibrator_off();
}
vibrator_on、vibrator_off 接口的提供者为如下硬件原型。
5, 硬件原型
文件：hardware/libhardware_legacy/vibrator/vibrator.c
#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
if (qemu_check()) {
return qemu_control_command( "vibrator:%d", timeout_ms );
}
#endif
fd = open(THE_DEVICE, O_RDWR);
if(fd < 0)
return errno;
nwr = sprintf(value, "%d/n", timeout_ms);
ret = write(fd, value, nwr);
close(fd);
return (ret == nwr) ? 0 : -1;
}
int vibrator_on(int timeout_ms)
{
/* constant on, up to maximum allowed time */
return sendit(timeout_ms);
}
int vibrator_off()
{
return sendit(0);
}
由以上代码可知，开启振动时是往文件/sys/class/timed_output/vibrator/enable写入振动的时间长度；关闭振动时，其时间长度为0。/sys/class/timed_output/vibrator/enable 的真实路径根据实际作修改。
6,驱动代码
创建timed_output类
kernel/drivers/staging/android/Timed_output.c
在sys/class目录创建timed_output子目录和文件enable
timed_output_class = class_create(THIS_MODULE, "timed_output");创建timed_output子目录
ret = device_create_file(tdev->dev, &dev_attr_enable);在sys/class/timed_output子目录创建文件enable
static int create_timed_output_class(void)
{
if (!timed_output_class) {
timed_output_class = class_create(THIS_MODULE, "timed_output");
if (IS_ERR(timed_output_class))
return PTR_ERR(timed_output_class);
atomic_set(&device_count, 0);
}
return 0;
}
int timed_output_dev_register(struct timed_output_dev *tdev)
{
int ret;
if (!tdev || !tdev->name || !tdev->enable || !tdev->get_time)
return -EINVAL;
ret = create_timed_output_class();
if (ret < 0)
return ret;
tdev->index = atomic_inc_return(&device_count);
tdev->dev = device_create(timed_output_class, NULL,
MKDEV(0, tdev->index), NULL, tdev->name);
if (IS_ERR(tdev->dev))
return PTR_ERR(tdev->dev);
ret = device_create_file(tdev->dev, &dev_attr_enable);
if (ret < 0)
goto err_create_file;
dev_set_drvdata(tdev->dev, tdev);
tdev->state = 0;
return 0;
err_create_file:
device_destroy(timed_output_class, MKDEV(0, tdev->index));
printk(KERN_ERR "timed_output: Failed to register driver %s/n",
tdev->name);
return ret;
}
EXPORT_SYMBOL_GPL(timed_output_dev_register);
驱动注册马达的驱动，注册一个定时器用于控制震动时间（回调函数vibrator_timer_func），注册两个队列，一共给马达打开用，一共为马达震动关闭用。
static void pmic_vibrator_on(struct work_struct *work)
{
set_pmic_vibrator(1);
}
static void pmic_vibrator_off(struct work_struct *work)
{
set_pmic_vibrator(0);
}
static void timed_vibrator_on(struct timed_output_dev *sdev)
{
schedule_work(&work_vibrator_on);
}
static void timed_vibrator_off(struct timed_output_dev *sdev)
{
schedule_work(&work_vibrator_off);
}
static void vibrator_enable(struct timed_output_dev *dev, int value)
{
hrtimer_cancel(&vibe_timer);
if (value == 0)
timed_vibrator_off(dev);
else {
value = (value > 15000 ? 15000 : value);
timed_vibrator_on(dev);
hrtimer_start(&vibe_timer,
ktime_set(value / 1000, (value % 1000) * 1000000),
HRTIMER_MODE_REL);
}
}
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 enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
timed_vibrator_off(NULL);
return HRTIMER_NORESTART;
}
static struct timed_output_dev pmic_vibrator = {
.name = "vibrator",
.get_time = vibrator_get_time,
.enable = vibrator_enable,
};
void __init pxa_init_pmic_vibrator(void)
{
INIT_WORK(&work_vibrator_on, pmic_vibrator_on);
INIT_WORK(&work_vibrator_off, pmic_vibrator_off);
hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vibe_timer.function = vibrator_timer_func;
timed_output_dev_register(&pmic_vibrator);
}
当上层要设置马达震动时，往文件/sys/class/timed_output/vibrator/enable写入振动的时间长度，通过
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);
int value;
sscanf(buf, "%d", &value);
tdev->enable(tdev, value);
return size;
}
调用驱动的enable函数也就是vibrator_enable（ .enable = vibrator_enable,）
vibrator_enable
|
|
v
timed_vibrator_on(dev);
|
|
v
schedule_work(&work_vibrator_on);
|
|
v
pmic_vibrator_on
|
|
v
set_pmic_vibrator(1); //给马达供电震动
|
|
v
hrtimer_start(&vibe_timer,
ktime_set(value / 1000, (value % 1000) * 1000000),
HRTIMER_MODE_REL);
最终是设置马达的硬件控制驱动管给马达供电，并且启动定时器，定时时间是上层给的参数。
定时时间到了就调用定时器的回调函数vibrator_timer_func
vibrator_timer_func
|
|
v
timed_vibrator_off(NULL);
|
|
v
schedule_work(&work_vibrator_off);
|
|
v
pmic_vibrator_off
|
|
v
set_pmic_vibrator(0); //断开马达的供电，马达停止震动
最终是设置马达的硬件控制驱动管断开马达供电，停止马达震动