Android振动器 android.os.Vibrator

1.Java层 frameworks/base/core/java/android/os/Vibrator.java

  Vibrator类的实力可以通过 getSystemService(VIBRATOR_SERVICE)获得实例。

 两个方法：public abstract void vibrate(long milliseconds);/public abstract void vibrate(long[] pattern, int repeat);                public abstract void cancel(); 查找路径：Activity.java-->ContextThemeWrapper.java-->ContextWrapper.java-->Context.java,getSystemService是Context.java类的抽象方法。其实现的类是ContextImpl.java，其中有段静态代码，注册所有context下能使用到的service。

 registerService(VIBRATOR_SERVICE, new ServiceFetcher() {                public Object createService(ContextImpl ctx) {                    return new SystemVibrator();                }});

Vibrator类只是个抽象类，具体实现的代码位于 SystemVibrator。位于\frameworks\base\core\java\android\os\目录下。两个方法的实现代码如下：

@Override    public void vibrate(long milliseconds) {        if (mService == null) {            Log.w(TAG, "Failed to vibrate; no vibrator service.");            return;        }        try {            mService.vibrate(milliseconds, mToken);        } catch (RemoteException e) {            Log.w(TAG, "Failed to vibrate.", e);        }    }

与

@Override    public void vibrate(long[] pattern, int repeat) {        if (mService == null) {            Log.w(TAG, "Failed to vibrate; no vibrator service.");            return;        }        // catch this here because the server will do nothing.  pattern may        // not be null, let that be checked, because the server will drop it        // anyway        if (repeat < pattern.length) {            try {                mService.vibratePattern(pattern, repeat, mToken);            } catch (RemoteException e) {                Log.w(TAG, "Failed to vibrate.", e);            }        } else {            throw new ArrayIndexOutOfBoundsException();        }    }

还有

@Override    public void cancel() {        if (mService == null) {            return;        }        try {            mService.cancelVibrate(mToken);        } catch (RemoteException e) {            Log.w(TAG, "Failed to cancel vibration.", e);        }    }

  查看mService，其声明代码如下：

 

mService = IVibratorService.Stub.asInterface(                ServiceManager.getService("vibrator"));

 /*这里跟Binder机制有关。。。断片ing*/

 

定义是private final IVibratorService mService;

所以找找这个IVibratorService吧。 查找下\frameworks\base\core\java\android\os\IVibratorService.aidl，这里定义了接口。

package android.os;/** {@hide} */interface IVibratorService{    boolean hasVibrator();    void vibrate(long milliseconds, IBinder token);    void vibratePattern(in long[] pattern, int repeat, IBinder token);    void cancelVibrate(IBinder token);}

 具体的实现位于VibratorService.java。(\frameworks\base\services\java\com\android\server\)

  public class VibratorService extends IVibratorService.Stub

 然后是vibrate方法：

public void vibrate(long milliseconds, IBinder token) {        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)                != PackageManager.PERMISSION_GRANTED) {            throw new SecurityException("Requires VIBRATE permission");        }        int uid = Binder.getCallingUid();        // 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, uid);        synchronized (mVibrations) {            removeVibrationLocked(token);            doCancelVibrateLocked();            mCurrentVibration = vib;            startVibrationLocked(vib);        }    }

         然后是startVibrationLocked方法。

private void startVibrationLocked(final Vibration vib) {        if (vib.mTimeout != 0) {            doVibratorOn(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();        }    }

       翻看了VibrateThread的run方法，最终还是调用了doVibratorOn方法。        所以看doVibratorOn方法：

private void doVibratorOn(long millis) {        synchronized (mInputDeviceVibrators) {            final int vibratorCount = mInputDeviceVibrators.size();            if (vibratorCount != 0) {                for (int i = 0; i < vibratorCount; i++) {                    mInputDeviceVibrators.get(i).vibrate(millis);                }            } else {                vibratorOn(millis);            }        }    }

          |---------首先是vibratorCount这个，假如这个不为0，那么是调用 Vibrator的vibrate方法。。断片：vibratorCount这个表示什么意义！           mInputDeviceVibrators的声明如下：

private final ArrayList
    
      mInputDeviceVibrators = new ArrayList
     
      ();
     
    

     里面的每一个元素都是一个Vibrator的实力，Vibrator是个抽闲类。      mInputDeviceVibrators会在VibratorService.java中的updateInputDeviceVibrators方法添加元素：

mInputDeviceVibrators.clear();if (mVibrateInputDevicesSetting) {	int[] ids = mIm.getInputDeviceIds();	for (int i = 0; i < ids.length; i++) {		InputDevice device = mIm.getInputDevice(ids[i]);		Vibrator vibrator = device.getVibrator();		if (vibrator.hasVibrator()) {			mInputDeviceVibrators.add(vibrator);		}	}}

      查看InputDevice类的getVibrator

public Vibrator getVibrator() {        synchronized (mMotionRanges) {            if (mVibrator == null) {                if (mHasVibrator) {                    mVibrator = InputManager.getInstance().getInputDeviceVibrator(mId);                } else {                    mVibrator = NullVibrator.getInstance();                }            }            return mVibrator;        }    }

所以数组 mInputDeviceVibrators中的元素有两种，都是抽象类Vibrator的子类：

        一种是InputDeviceVibrator类，一种就是NullVibrator类了。

      先说说InputDeviceVibrator类。

private final class InputDeviceVibrator extends Vibrator {        private final int mDeviceId;        private final Binder mToken;        public InputDeviceVibrator(int deviceId) {            mDeviceId = deviceId;            mToken = new Binder();        }        @Override        public boolean hasVibrator() {            return true;        }        @Override        public void vibrate(long milliseconds) {            vibrate(new long[] { 0, milliseconds}, -1);        }        @Override        public void vibrate(long[] pattern, int repeat) {            if (repeat >= pattern.length) {                throw new ArrayIndexOutOfBoundsException();            }            try {                mIm.vibrate(mDeviceId, pattern, repeat, mToken);            } catch (RemoteException ex) {                Log.w(TAG, "Failed to vibrate.", ex);            }        }        @Override        public void cancel() {            try {                mIm.cancelVibrate(mDeviceId, mToken);            } catch (RemoteException ex) {                Log.w(TAG, "Failed to cancel vibration.", ex);            }        }    }

       这里关注public void vibrate(long[] pattern, int repeat)方法，最终调用mIm.vibrate(mDeviceId, pattern, repeat, mToken)。。坑爹的，mIm是个抽象类，又得去找其实例，然后穿越到InputManagerService.java，放看起vibrate方法：

public void vibrate(int deviceId, long[] pattern, int repeat, IBinder token) {        if (repeat >= pattern.length) {            throw new ArrayIndexOutOfBoundsException();        }        VibratorToken v;        synchronized (mVibratorLock) {            v = mVibratorTokens.get(token);            if (v == null) {                v = new VibratorToken(deviceId, token, mNextVibratorTokenValue++);                try {                    token.linkToDeath(v, 0);                } catch (RemoteException ex) {                    // give up                    throw new RuntimeException(ex);                }                mVibratorTokens.put(token, v);            }        }        synchronized (v) {            v.mVibrating = true;            nativeVibrate(mPtr, deviceId, pattern, repeat, v.mTokenValue);        }    }

           这里调用了JNI方法nativeVibrate，同样，InputDeviceVibrator的cancel方法也到了这里：

public void cancelVibrate(int deviceId, IBinder token) {        VibratorToken v;        synchronized (mVibratorLock) {            v = mVibratorTokens.get(token);            if (v == null || v.mDeviceId != deviceId) {                return; // nothing to cancel            }        }        cancelVibrateIfNeeded(v);    }

              cancelVibrateIfNeeded方法最终调用nativeCancelVibrate方法。到达JNI层。               |||||||||               再来看看NullVibrator类。。不过既然是Null。。。那就是Null实现。               自此，vibrate跟cancel到达的JNI层的接口是：

private static native void nativeVibrate(int ptr, int deviceId, long[] pattern,            int repeat, int token);    private static native void nativeCancelVibrate(int ptr, int deviceId, int token);

       |-------然后是vibratorCount为0的情况，直接调用vibratorOn，cancel同理。        自此，vibrate跟cancel到达的JNI层的接口是：

native static void vibratorOn(long milliseconds);    native static void vibratorOff();

2.JNI层

--对于nativeVibrate/nativeCancelVibrate，其实现位于com_android_server_input_InputManagerService.cpp中.

static void nativeVibrate(JNIEnv* env,        jclass clazz, jint ptr, jint deviceId, jlongArray patternObj,        jint repeat, jint token) {    NativeInputManager* im = reinterpret_cast
    
     (ptr);    size_t patternSize = env->GetArrayLength(patternObj);    if (patternSize > MAX_VIBRATE_PATTERN_SIZE) {        ALOGI("Skipped requested vibration because the pattern size is %d "                "which is more than the maximum supported size of %d.",                patternSize, MAX_VIBRATE_PATTERN_SIZE);        return; // limit to reasonable size    }    jlong* patternMillis = static_cast
     
      (env->GetPrimitiveArrayCritical(            patternObj, NULL));    nsecs_t pattern[patternSize];    for (size_t i = 0; i < patternSize; i++) {        pattern[i] = max(jlong(0), min(patternMillis[i],                MAX_VIBRATE_PATTERN_DELAY_NSECS / 1000000LL)) * 1000000LL;    }    env->ReleasePrimitiveArrayCritical(patternObj, patternMillis, JNI_ABORT);    im->getInputManager()->getReader()->vibrate(deviceId, pattern, patternSize, repeat, token);}static void nativeCancelVibrate(JNIEnv* env,        jclass clazz, jint ptr, jint deviceId, jint token) {    NativeInputManager* im = reinterpret_cast
      
       (ptr);    im->getInputManager()->getReader()->cancelVibrate(deviceId, token);}
      
     
    

-- 对于vibratorOn /vibratorOff，其实现位于com_android_server_VibratorService.cpp中 

static JNINativeMethod method_table[] = {    { "vibratorExists", "()Z", (void*)vibratorExists },    { "vibratorOn", "(J)V", (void*)vibratorOn },    { "vibratorOff", "()V", (void*)vibratorOff }};

      

static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms){    // ALOGI("vibratorOn\n");    vibrator_on(timeout_ms);}static void vibratorOff(JNIEnv *env, jobject clazz){    // ALOGI("vibratorOff\n");    vibrator_off();}

3.HAL层      vib rator_on/vibrator_off的定义位于头文件<hardware_legacy/vibrator.h>（\hardware\libhardware_legacy\include\hardware_legacy\）

/** * Turn on vibrator * * @param timeout_ms number of milliseconds to vibrate * * @return 0 if successful, -1 if error */int vibrator_on(int timeout_ms);/** * Turn off vibrator * * @return 0 if successful, -1 if error */int vibrator_off();

HAL已经完成了实现。  \hardware\libhardware_legacy\vibrator\vibrator.c

/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */#include 
    
     #include "qemu.h"#include 
     
      #include 
      
       #include 
       
        #include 
        
         #define THE_DEVICE "/sys/class/timed_output/vibrator/enable"int vibrator_exists(){    int fd;#ifdef QEMU_HARDWARE    if (qemu_check()) {        return 1;    }#endif    fd = open(THE_DEVICE, O_RDWR);    if(fd < 0)        return 0;    close(fd);    return 1;}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);}
        
       
      
     
    

    这里使用的是Android的timed output机制，通过操纵/sys/class/timed_output/vibrator/enable节点启动或者停止启动器。

4.内核层 先看看timed output的驱动代码，位于Linux_Kernel_3x\drivers\staging\android\下。

#ifndef _LINUX_TIMED_OUTPUT_H#define _LINUX_TIMED_OUTPUT_Hstruct timed_output_dev {	const char	*name;	/* enable the output and set the timer */	void	(*enable)(struct timed_output_dev *sdev, int timeout);	/* returns the current number of milliseconds remaining on the timer */	int		(*get_time)(struct timed_output_dev *sdev);	/* private data */	struct device	*dev;	int		index;	int		state;};extern int timed_output_dev_register(struct timed_output_dev *dev);extern void timed_output_dev_unregister(struct timed_output_dev *dev);#endif

所有的timed output实现都需要定义在结构体timed_output_dev中。

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