Android & Vibrator

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\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_H 

 struct 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文件表示获得剩余时间，写这个文件表示根据时间振动。
这个具体情况具体实现，参考：
http://tech.it168.com/a2012/0201/1305/000001305847.shtmlhttp://tech.it168.com/a2012/0201/1305/000001305847.shtml