xie0812
xie0812

Android之 看“马达”如何贯通Android系统 (从硬件设计 --> 驱动 --> HAL --> JNI --> Framework --> Application)

 在Android 2.3(Gingerbread) 系统的时候，我写过一篇关于“Android 震动马达系统“的文章，当时的Linux内核还是2.6版本的。写那篇文章的目的，是想彻底的了解从硬件到驱动，再到应用的运作流程。完成了之后，文章一直仍在草稿箱里面没发表；今天看到，决定整理一下，重新发表。目的是想和大家分享自己对Android系统的一点认识：以马达为代表，来考究“Android是如何一步步工作的。它从硬件设计，到Linux驱动，再到HAL，再到JNI，再到Framework，最后到被应用调用，这整套的流程到底是怎么样的！”

    转载请注明出处：http://www.cnblogs.com/skywang12345/p/3404808.html

Part 1 马达的硬件设计

    马达的震动原理很简单，给马达通电，马达就能震动。至于马达是如何工作，如何将电能转化为机械能，这不是我们关心的重点。但是，我们要需要了解如何控制马达的通电。在硬件上，我们是通过一个IO口(GPIO)去控制；对于马达而言，我们可以将IO理解为一个开关。当开关合上时，马达震动；开关断开，马达停止震动。

    GPIO(General Purpose Input Output)，称为通用输入/输出。它可以被配置为中断、输入、输出等类型，从而对各个IO进行控制。对于马达而已，GPIO就相当于一个开关。下面看看硬件原理图中的马达部分，如下图：

 

注：上面原理图对应CPU是“三星A8”。不同平台的马达，马达的接法和GPIO都不一样；但原理都是类似的。

原理图中红线标注部分的含义：GPH3_3是马达的GPIO。三星A8中有很多组GPIO，而马达对应和GPH3_3连接。

 

Part 2 马达的驱动代码

    知道马达的硬件设计之后，我们就可以进行Linux Driver开发工作，也就是编写马达的驱动。Linux的一个非常重要的特点，一切都是文件！而我们进行Linux Driver开发的目的，就是将硬件设备映射成一个文件；然后，我们可以通过操作文件，来操作对应的硬件设备。

    OK！理解了驱动的作用和原理之后，我们接下来开发讲解马达的驱动开发。

 

1. Datasheet中相关信息

    我们知道，马达是通过GPIO去控制；接下来，我们就是找到马达对应的GPIO信息，然后控制该GPIO即可。

    通过马达的原理图，我们知道马达和GPH3_3相连接。我们查阅“三星A8 的Datasheet”，查找GPH3_3的相关信息。

   所谓Datasheet，就是CPU芯片的数据手册。
   上面记载了CPU的功能特性和操作方式等信息。任何一个厂家在发布它的芯片时，都会提供对应的Datasheet给它的客户；客户根据Datasheet上面所描述的CPU的特性，就可以进行相关的开发(当然，实际开发中可能还需要芯片厂商的支持)。例如，国内手机都是采用MTK平台，对于MTK方案开发商来说，它要开发MTK6577的产品。那么首先，MTK原厂会提供一份MTK6577的BSP包，BSP包中包括了MTK6577的Datasheet，也就是该芯片的数据手册。方案开发商有任何关于MTK6577的问题，都可以查阅该Datasheet。
    三星A8的Datasheet中，关于GPH3_3的信息如下：

说明：

(01) GPH3_3对应CPU中的寄存器是GPH3CON[3]。

(02) [15:12] 表示寄存器的第12~15位，一个寄存器共32 bits。而第三列的 0000, 0001, 0010, 0011, 1111表示“寄存器取不同值的时候，该GPIO的功能”。

例如， 0000表示将该GPIO作为输入，0001表示将GPIO作为输出，1111表示将该GPIO作为中断。

           前面，我们已经说过，操作马达就是相当与将它作为一个开关操作。因此，我们需要将马达的GPIO设为“输入”类型；然后输入1，相当于开启马达；输入0，则是关闭马达！

 

下面，我们需要做的就是在Driver中将GPH3_3(也就是GPH3CON[3])映射为一个文件节点，并将它配置为“输入”类型，即将GPH3CON[3]的寄存器值设为0000。

 

2. 马达的驱动

    我们编写马达驱动(drivers/misc/misc_sysfs.c)，将马达(vibrator)注册道platform总线上。源码如下：

复制代码 
  1 #include 
  2 #include 
  3 #include 
  4 #include 
  5 #include 
  6 #include 
  7 #include 
  8 #include 
  9 #include 
 10 #include 
 11 #include 
 12 
 13 // vibrator 对应的GPIO
 14 #define  VIBRATOR_POWER_PORT (S5PV210_GPH3(3))
 15 
 16 typedef struct combo_module__t    {
 17     unsigned char            status_vibrator;
 18 }    combo_module_t    ;
 19 
 20 static combo_module_t combo_module;
 21 
 22 /*
 23  * vibrator初始化函数：申请GPIO，并初始化vibrator状态。
 24  */
 25 static void combo_module_init(void)
 26 {
 27     if(gpio_request(VIBRATOR_POWER_PORT, "vibrator power"))    {
 28         printk("misc_sysfs.c request vibrator gpio failse.\n");
 29     }
 30     gpio_pull_updown(VIBRATOR_POWER_PORT, PullDisable);
 31       gpio_direction_output(VIBRATOR_POWER_PORT, GPIO_LOW);    
 32 
 33     combo_module.status_vibrator  = 0;
 34 }
 35 
 36 /*
 37  * vibrator控制函数
 38  */
 39 staticvoid combo_module_control(void)
 40 {
 41     if(combo_module.status_vibrator)
 42     {
 43         gpio_direction_output(VIBRATOR_POWER_PORT, GPIO_HIGH);
 44     }
 45     else    
 46     {
 47         gpio_direction_output(VIBRATOR_POWER_PORT, GPIO_LOW);
 48     }
 49 
 50 }
 51 
 52 
 53 ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 54 
 55 static ssize_t show_vibrator_onoff (struct device *dev, struct device_attribute *attr, char *buf)
 56 {
 57     return    sprintf(buf, "%d\n", combo_module.status_vibrator);
 58 }
 59 
 60 static ssize_t set_vibrator_onoff (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 61 {
 62      unsigned int    val;
 63 
 64     if(!(sscanf(buf, "%u\n", &val)))     return    -EINVAL;
 65 
 66     //printk("set_vibrator_onoff:%d\n",val);
 67 
 68     if(!val )    
 69     {
 70         combo_module.status_vibrator = 0;
 71         combo_module_control();
 72     }
 73     else        
 74     {
 75         combo_module.status_vibrator = 1;
 76         combo_module_control();
 77 
 78         msleep(val);
 79 
 80         combo_module.status_vibrator = 0;
 81         combo_module_control();
 82     }
 83     
 84     return count;
 85 }
 86 
 87 static    ssize_t show_vibrator_onoff    (struct device *dev, struct device_attribute *attr, char *buf);
 88 static     ssize_t set_vibrator_onoff    (struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
 89 // 将vibrator注册到sysfs文件系统。
 90 // 参数说明：
 91 //       vibrator_onoff      : vibrator对应在sysfs下的文件节点名称
 92 //       S_IRWXUGO           : 文件节点的属性
 93 //       show_vibrator_onoff : 对应的读函数
 94 //       set_vibrator_onoff  : 对应的写函数
 95 static DEVICE_ATTR(vibrator_onoff, S_IRWXUGO, show_vibrator_onoff, set_vibrator_onoff);
 96 
 97 
 98 static struct attribute *control_sysfs_entries[] = {
 99     &dev_attr_vibrator_onoff.attr,
100     NULL
101 };
102 
103 static struct attribute_group control_sysfs_attr_group = {
104     .name   = NULL,
105     .attrs  = control_sysfs_entries,
106 };
107 
108 static int control_sysfs_probe(struct platform_device *pdev)    
109 {
110     printk("vibrator probe");
111     combo_module_init();
112     combo_module_control();
113     return    sysfs_create_group(&pdev->dev.kobj, &control_sysfs_attr_group);
114 }
115 
116 staticint control_sysfs_remove(struct platform_device *pdev)    
117 {
118     sysfs_remove_group(&pdev->dev.kobj, &control_sysfs_attr_group);
119     
120     return    0;
121 }
122 
123 #ifdef CONFIG_PM
124 static int control_sysfs_resume(struct platform_device *dev)
125 {
126 
127     combo_module_control();
128 
129     return  0;
130 }
131 
132 static int control_sysfs_suspend(struct platform_device *dev, pm_message_t state)
133 {
134     
135     combo_module_control();
136     
137     return  0;
138 }
139 #else
140 #define control_sysfs_suspend NULL
141 #define control_sysfs_resume NULL
142 #endif
143 
144 
145 static struct platform_driver control_sysfs_driver = {
146     .driver = {
147         .name = "misc_ctl",
148         .owner = THIS_MODULE,
149     },
150     .probe         = control_sysfs_probe,
151     .remove     = control_sysfs_remove,
152     .suspend    = control_sysfs_suspend,
153     .resume        = control_sysfs_resume,
154 };
155 
156 static int __init control_sysfs_init(void)
157 {    
158     // 将vibrator注册到platform总线
159     printk("vibrator init");
160     return platform_driver_register(&control_sysfs_driver);
161 }
162 
163 static void __exit control_sysfs_exit(void)
164 {
165    platform_driver_unregister(&control_sysfs_driver);
166 }
167 
168 
169 module_init(control_sysfs_init);
170 module_exit(control_sysfs_exit);
171 
172 
173 MODULE_DESCRIPTION("misc control driver");
174 MODULE_AUTHOR("other");
175 MODULE_LICENSE("GPL");
复制代码

说明：

若您熟悉驱动开发，应该很容易理解上面的代码。不熟悉也不要紧，您只需要了解“Linux系统中，一切都是文件”，上面代码的作用是，

将马达(vibrator)映射到“/sys/devices/platform/misc_ctl/vibrator_onoff”文件上，我们可以通过读写vibrator_onoff来操作马达的开启和关闭。

 

    有了马达的源码之后，我们还需要将该源码编译到Linux内核中。这就是通过Kconfig和Makefile来完成的，关于Kconfig和Makefile的知识，这里就不过多说明了。目前您只需要了解，通过Kconfig和Makefile，我们能将马达驱动编译到内核中，该驱动会在驱动加载的时候自动运行就可以了！

马达对应的Kconfig(driver/misc/Kconfig)内容如下：

config MISC_VIBRATOR
       tristate"misc vabrator"
       default y

马达对应的Makefile(driver/misc/Makefile)内容如下：

obj-$(CONFIG_MISC_VIBRATOR)   += misc_sysfs.o

 

至此，我们已经完成马达的驱动开发了！也就是说，我们已经成功的将马达映射到文件节点上；接下来，我们通过操作文件节点，就可以操作马达了。下面从HAL层到Framework曾，都是基于Android4.2系统进行说明的。

 

Part 3 马达的HAL实现

HAL (Hardware Abstraction Layer), 又称为“硬件抽象层”。在Linux驱动中，我们已经将马达设为映射为文件了；而该HAL层的存在的意义，就是“对设备文件进行操作，从而相当于硬件进行操作”。HAL层的作用，一是操作硬件设备，二是操作接口封装，外界能方便的使用HAL提供的接口直接操作硬件设备。

理解了HAL之后，我们看看Android中如何在HAL层对马达进行操作。

在Android系统中，我们在libhardware_legacy中，实现马达的HAL层控制。
马达在HAL中的代码路径：hardware/libhardware_legacy/vibrator/vibrator.c

vibrator.c的代码如下：

复制代码 
 1 /*
 2  * Copyright (C) 2008 The Android Open Source Project
 3  *
 4  * Licensed under the Apache License, Version 2.0 (the "License");
 5  * you may not use this file except in compliance with the License.
 6  * You may obtain a copy of the License at
 7  *
 8  *      http://www.apache.org/licenses/LICENSE-2.0
 9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include 
17 #include "qemu.h"
18 
19 #include 
20 #include 
21 #include 
22 #include 
23 
24 #define THE_DEVICE "/sys/devices/platform/misc_ctl/vibrator_onoff"
25 
26 int vibrator_exists()
27 {
28     int fd;
29 
30 #ifdef QEMU_HARDWARE
31     if (qemu_check()) {
32         return 1;
33     }
34 #endif
35 
36     fd = open(THE_DEVICE, O_RDWR);
37     if(fd < 0)
38         return 0;
39     close(fd);
40     return 1;
41 }
42 
43 static int sendit(int timeout_ms)
44 {
45     int nwr, ret, fd;
46     char value[20];
47 
48 #ifdef QEMU_HARDWARE
49     if (qemu_check()) {
50         return qemu_control_command( "vibrator:%d", timeout_ms );
51     }
52 #endif
53 
54     fd = open(THE_DEVICE, O_RDWR);
55     if(fd < 0)
56         return errno;
57 
58     nwr = sprintf(value, "%d\n", timeout_ms);
59     ret = write(fd, value, nwr);
60 
61     close(fd);
62 
63     return (ret == nwr) ? 0 : -1;
64 }
65 
66 int vibrator_on(int timeout_ms)
67 {
68     /* constant on, up to maximum allowed time */
69     return sendit(timeout_ms);
70 }
71 
72 int vibrator_off()
73 {
74     return sendit(0);
75 }
复制代码

 

在kernel的驱动中，我们已经将马达注册到sys文件系统中(/sys/devices/platform/misc_ctl/vibrator_onoff)。在vibrator.c中，我们就是通过读写“vibrator_onoff文件节点”来实现对马达的操作。

 

Part 4 马达的JNI部分

1 马达的JNI实现

JNI(Java Native Interface)，中文是“Java本地接口”。

JNI是Java中一种技术，它存在的意义，是保证本地代码(C/C++代码)能在任何Java虚拟机下工作。简单点说，Java通过JNI接口，能够调用到C/C++代码。 关于“JNI的更多内容”，请参考“Android JNI和NDK学习系列文章”。

在了解了vibrator的HAL层实现之后，我们再来看看android是如何通过JNI将震动马达注册到android系统中。马达对应的JNI层代码路径如下：frameworks/base/services/jni/com_android_server_VibratorService.cpp

com_android_server_VibratorService.cpp的源码如下：

复制代码 
 1 /*
 2  * Copyright (C) 2009 The Android Open Source Project
 3  *
 4  * Licensed under the Apache License, Version 2.0 (the "License");
 5  * you may not use this file except in compliance with the License.
 6  * You may obtain a copy of the License at
 7  *
 8  *      http://www.apache.org/licenses/LICENSE-2.0
 9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "VibratorService"
18 
19 #include "jni.h"
20 #include "JNIHelp.h"
21 #include "android_runtime/AndroidRuntime.h"
22 
23 #include 
24 #include 
25 #include 
26 
27 #include 
28 
29 namespace android
30 {
31 
32 static jboolean vibratorExists(JNIEnv *env, jobject clazz)
33 {
34     return vibrator_exists() > 0 ? JNI_TRUE : JNI_FALSE;
35 }
36 
37 static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms)
38 {
39     // ALOGI("vibratorOn\n");
40     vibrator_on(timeout_ms);
41 }
42 
43 static void vibratorOff(JNIEnv *env, jobject clazz)
44 {
45     // ALOGI("vibratorOff\n");
46     vibrator_off();
47 }
48 
49 static JNINativeMethod method_table[] = {
50     { "vibratorExists", "()Z", (void*)vibratorExists },
51     { "vibratorOn", "(J)V", (void*)vibratorOn },
52     { "vibratorOff", "()V", (void*)vibratorOff }
53 };
54 
55 int register_android_server_VibratorService(JNIEnv *env)
56 {
57     return jniRegisterNativeMethods(env, "com/android/server/VibratorService",
58             method_table, NELEM(method_table));
59 }
60 
61 };
复制代码

下面，对这部分的JNI代码进行简单说明。

(01) 通过 jniRegisterNativeMethods()，我们将method_table中的方法注册到 com.android.server.VibratorService.java 中。配对表格如下：

复制代码 
---------------------------------------------------++++-------------------------------------------
             VibratorService.java                          com_android_server_VibratorService.cpp   
native static boolean vibratorExists();                static jboolean vibratorExists(JNIEnv *env, jobject clazz)
native static void vibratorOn(long milliseconds);      static void vibratorOn(JNIEnv *env, jobject clazz, jlong timeout_ms)
native static void vibratorOff();                      static void vibratorOff(JNIEnv *env, jobject clazz)
复制代码

通过JNI，我们就能将Java层和HAL层的代码联系起来。
以vibratorOff()来说，我们在VibratorService.java中调用vibratorOff()；实际上会调用到com_android_server_VibratorService.cpp中的vibratorOff()函数；进一步会调用到vibrator_off()函数，而vibrator_off()是我们在 “HAL层的vibrator.c中的接口”。


2 马达的JNI如何和HAL关联方式

在继续接下来的研究之前，我们先搞清楚：JNI如何和HAL层代码关联起来的。即com_android_server_VibratorService.cpp是如何调用到vibrator.c中的代码的。
实际上道理很简单，我们先将vibrator.c封装成.so库；然后在com_android_server_VibratorService.cpp中导入该库，就可以调用vibrator.c的接口了。下面，看看Android中具体是如何做到的。

(01) vibrator.c封装到libhardware_legacy.so中的步骤

在hardware/libhardware_legacy/vibrator/Android.mk中，会将vibrator.c添加到 LOCAL_SRC_FILES 变量中。
hardware/libhardware_legacy/vibrator/Android.mk源码如下：

LOCAL_SRC_FILES += vibrator/vibrator.c

在hardware/libhardware_legacy/Android.mk中，它会调用子目录的Android.mk并将它们导入当前的Android.mk中。
hardware/libhardware_legacy/Android.mk源码如下：

复制代码 
legacy_modules := power uevent vibrator wifi qemu qemu_tracing

SAVE_MAKEFILES := $(call all-named-subdir-makefiles,$(legacy_modules))
LEGACY_AUDIO_MAKEFILES := $(call all-named-subdir-makefiles,audio)

include $(SAVE_MAKEFILES)

...

LOCAL_MODULE:= libhardware_legacy

include $(BUILD_SHARED_LIBRARY)
复制代码

在“我们编译Android系统”或“通过 mmm hardware/libhardware_legacy进行模块编译”的时候，就会生成库libhardware_legacy.so；而且vibrator.c被包含在该库中。

(02) 在 com_android_server_VibratorService.cpp 对应的Android.mk中，会导入libhardware_legacy.so。
com_android_server_VibratorService.cpp 对应的frameworks/base/services/jni/Android.mk 的源码如下：

复制代码 
LOCAL_SRC_FILES:= \
com_android_server_VibratorService.cpp \
...

LOCAL_SHARED_LIBRARIES := \
libhardware_legacy \
...


LOCAL_MODULE:= libandroid_servers

include $(BUILD_SHARED_LIBRARY)
复制代码

 

Part 5 马达的Framework层实现

应用层操作马达，是通过马达服务进行操作的。而马达服务是通过aidl实现的，aidl是Android进程间的通信方式。关于aidl的更多说明可以参考“Android Service总结06 之AIDL”。

马达服务涉及的主要文件如下：

1 frameworks/base/services/java/com/android/server/SystemServer.java
2 frameworks/base/services/java/com/android/server/VibratorService.java
3 frameworks/base/core/java/android/os/IVibratorService.aidl
4 frameworks/base/core/java/android/os/Vibrator.java
5 frameworks/base/core/java/android/os/SystemVibrator.java

下面，对这几个文件的功能进行简要说明。

文件1: SystemServer.java
           它是系统服务，作用是启动、管理系统服务，包括“马达服务、Wifi服务、Activity管理服务”等等。
           SystemServer是通过Zygote启动的，而Zygote又是在init中启动的，init则是kernel加载完毕之后启动的第一个进程。在这里，我们只需要知道“SystemServer是用来启动/管理马达服务即可。”

文件2: IVibratorService.aidl
           它是马达服务对应的aidl配置文件。我们在aidl中定义了其它进程可以访问的外部接口；然后再通过VibratorService.java实现这些接口。

文件3: VibratorService.java
           它是马达服务对应的aidl接口的实现程序。它实现IVibratorService.aidl的接口，从而实现马达服务；它的函数接口，是通过调用JNI层对应的马达控制函数来实现的。

文件4: Vibrator.java
           它是马达服务开放给应用层的调用类。理论上讲，我们完全可以通过aidl直接调用马达服务，而不需要Vibrator.java类。但是！既然它存在，就肯定有它的理由。事实的确如此，Google之所以这么做。有以下几个原因：
           第一，提供统一而且方便的服务调用方式。这里的“统一”，是指和所有其它的系统服务一样，我们调用服务时，需先通过getSystemService()获取服务，然后再调用服务的函数接口。这里的“方便”，是指若我们直接通过aidl调用，操作比较繁琐(若你用过aidl就会知道，需要先实现ServiceConnection接口以获取IBinder对象，然后再通过IBinder对象调用aidl的接口)； 而Vibrator.java封装之后的接口，将许多细节都隐藏了，非常便于应用者调用！
          第二，基于安全的考虑。Vibrator.java封装隐藏了许多细节，而这些都是应用开发者不必要知道的。
          第三，Vibrator是抽象类。它便于我们支持不同类型的马达：包括“将马达直接映射到文件”以及“将马达注册到输入子系统”中。

文件5: SystemVibrator.java
         它是Vibrator.java的子类，实现了马达的服务接口。

下面，我们继续Read The Fucking Source Code，加深对上面知识的理解。

1 SystemServer.java

在frameworks/base/services/java/com/android/server/SystemServer.java中关于马达的代码如下：

复制代码 
 1 {
 2     VibratorService vibrator = null;
 3 
 4     Slog.i(TAG, "Vibrator Service");
 5     vibrator = new VibratorService(context);
 6     ServiceManager.addService("vibrator", vibrator);
 7 
 8     ...
 9 
10     try {
11         vibrator.systemReady();
12     } catch (Throwable e) {
13         reportWtf("making Vibrator Service ready", e);
14     }
15 }
复制代码

从中，我们知道：
(01) SystemServer中会通过VibratorService()新建马达服务，并将其添加到ServiceManager中。
(02) 在Android系统启动完成之后，SystemServer会调用vibrator.systemReady()。

 

2 IVibratorService.aidl

在查看VibratorService.java之前，我们先看看它对应的aidl文件。frameworks/base/core/java/android/os/IVibratorService.aidl源码如下：

复制代码 
 1 package android.os;
 2 
 3 /** {@hide} */
 4 interface IVibratorService
 5 {
 6     boolean hasVibrator();
 7     void vibrate(long milliseconds, IBinder token);
 8     void vibratePattern(in long[] pattern, int repeat, IBinder token);
 9     void cancelVibrate(IBinder token);
10 }
复制代码

 

3 VibratorService.java

frameworks/base/services/java/com/android/server/VibratorService.java源码如下：

复制代码 
  1 /*
  2  * Copyright (C) 2008 The Android Open Source Project
  3  *
  4  * Licensed under the Apache License, Version 2.0 (the "License");
  5  * you may not use this file except in compliance with the License.
  6  * You may obtain a copy of the License at
  7  *
  8  *      http://www.apache.org/licenses/LICENSE-2.0
  9  *
 10  * Unless required by applicable law or agreed to in writing, software
 11  * distributed under the License is distributed on an "AS IS" BASIS,
 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  * See the License for the specific language governing permissions and
 14  * limitations under the License.
 15  */
 16 
 17 package com.android.server;
 18 
 19 import android.content.BroadcastReceiver;
 20 import android.content.Context;
 21 import android.content.Intent;
 22 import android.content.IntentFilter;
 23 import android.content.pm.PackageManager;
 24 import android.database.ContentObserver;
 25 import android.hardware.input.InputManager;
 26 import android.os.Handler;
 27 import android.os.IVibratorService;
 28 import android.os.PowerManager;
 29 import android.os.Process;
 30 import android.os.RemoteException;
 31 import android.os.IBinder;
 32 import android.os.Binder;
 33 import android.os.SystemClock;
 34 import android.os.UserHandle;
 35 import android.os.Vibrator;
 36 import android.os.WorkSource;
 37 import android.provider.Settings;
 38 import android.provider.Settings.SettingNotFoundException;
 39 import android.util.Slog;
 40 import android.view.InputDevice;
 41 
 42 import java.util.ArrayList;
 43 import java.util.LinkedList;
 44 import java.util.ListIterator;
 45 
 46 public class VibratorService extends IVibratorService.Stub
 47         implements InputManager.InputDeviceListener {
 48     private static final String TAG = "VibratorService";
 49 
 50     private final LinkedList mVibrations;
 51     private Vibration mCurrentVibration;
 52     private final WorkSource mTmpWorkSource = new WorkSource();
 53     private final Handler mH = new Handler();
 54 
 55     private final Context mContext;
 56     private final PowerManager.WakeLock mWakeLock;
 57     private InputManager mIm;
 58 
 59     volatile VibrateThread mThread;
 60 
 61     // mInputDeviceVibrators lock should be acquired after mVibrations lock, if both are
 62     // to be acquired
 63     private final ArrayList mInputDeviceVibrators = new ArrayList();
 64     private boolean mVibrateInputDevicesSetting; // guarded by mInputDeviceVibrators
 65     private boolean mInputDeviceListenerRegistered; // guarded by mInputDeviceVibrators
 66 
 67     native static boolean vibratorExists();
 68     native static void vibratorOn(long milliseconds);
 69     native static void vibratorOff();
 70 
 71     private class Vibration implements IBinder.DeathRecipient {
 72         private final IBinder mToken;
 73         private final long    mTimeout;
 74         private final long    mStartTime;
 75         private final long[]  mPattern;
 76         private final int     mRepeat;
 77         private final int     mUid;
 78 
 79         Vibration(IBinder token, long millis, int uid) {
 80             this(token, millis, null, 0, uid);
 81         }
 82 
 83         Vibration(IBinder token, long[] pattern, int repeat, int uid) {
 84             this(token, 0, pattern, repeat, uid);
 85         }
 86 
 87         private Vibration(IBinder token, long millis, long[] pattern,
 88                 int repeat, int uid) {
 89             mToken = token;
 90             mTimeout = millis;
 91             mStartTime = SystemClock.uptimeMillis();
 92             mPattern = pattern;
 93             mRepeat = repeat;
 94             mUid = uid;
 95         }
 96 
 97         public void binderDied() {
 98             synchronized (mVibrations) {
 99                 mVibrations.remove(this);
100                 if (this == mCurrentVibration) {
101                     doCancelVibrateLocked();
102                     startNextVibrationLocked();
103                 }
104             }
105         }
106 
107         public boolean hasLongerTimeout(long millis) {
108             if (mTimeout == 0) {
109                 // This is a pattern, return false to play the simple
110                 // vibration.
111                 return false;
112             }
113             if ((mStartTime + mTimeout)
114                     < (SystemClock.uptimeMillis() + millis)) {
115                 // If this vibration will end before the time passed in, let
116                 // the new vibration play.
117                 return false;
118             }
119             return true;
120         }
121     }
122 
123     VibratorService(Context context) {
124         // Reset the hardware to a default state, in case this is a runtime
125         // restart instead of a fresh boot.
126         vibratorOff();
127 
128         mContext = context;
129         PowerManager pm = (PowerManager)context.getSystemService(
130                 Context.POWER_SERVICE);
131         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*vibrator*");
132         mWakeLock.setReferenceCounted(true);
133 
134         mVibrations = new LinkedList();
135 
136         IntentFilter filter = new IntentFilter();
137         filter.addAction(Intent.ACTION_SCREEN_OFF);
138         context.registerReceiver(mIntentReceiver, filter);
139     }
140 
141     public void systemReady() {
142         mIm = (InputManager)mContext.getSystemService(Context.INPUT_SERVICE);
143 
144         mContext.getContentResolver().registerContentObserver(
145                 Settings.System.getUriFor(Settings.System.VIBRATE_INPUT_DEVICES), true,
146                 new ContentObserver(mH) {
147                     @Override
148                     public void onChange(boolean selfChange) {
149                         updateInputDeviceVibrators();
150                     }
151                 }, UserHandle.USER_ALL);
152 
153         mContext.registerReceiver(new BroadcastReceiver() {
154             @Override
155             public void onReceive(Context context, Intent intent) {
156                 updateInputDeviceVibrators();
157             }
158         }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mH);
159 
160         updateInputDeviceVibrators();
161     }
162 
163     public boolean hasVibrator() {
164         return doVibratorExists();
165     }
166 
167     public void vibrate(long milliseconds, IBinder token) {
168         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
169                 != PackageManager.PERMISSION_GRANTED) {
170             throw new SecurityException("Requires VIBRATE permission");
171         }
172         int uid = Binder.getCallingUid();
173         // We're running in the system server so we cannot crash. Check for a
174         // timeout of 0 or negative. This will ensure that a vibration has
175         // either a timeout of > 0 or a non-null pattern.
176         if (milliseconds <= 0 || (mCurrentVibration != null
177                 && mCurrentVibration.hasLongerTimeout(milliseconds))) {
178             // Ignore this vibration since the current vibration will play for
179             // longer than milliseconds.
180             return;
181         }
182 
183         Vibration vib = new Vibration(token, milliseconds, uid);
184         synchronized (mVibrations) {
185             removeVibrationLocked(token);
186             doCancelVibrateLocked();
187             mCurrentVibration = vib;
188             startVibrationLocked(vib);
189         }
190     }
191 
192     private boolean isAll0(long[] pattern) {
193         int N = pattern.length;
194         for (int i = 0; i < N; i++) {
195             if (pattern[i] != 0) {
196                 return false;
197             }
198         }
199         return true;
200     }
201 
202     public void vibratePattern(long[] pattern, int repeat, IBinder token) {
203         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
204                 != PackageManager.PERMISSION_GRANTED) {
205             throw new SecurityException("Requires VIBRATE permission");
206         }
207         int uid = Binder.getCallingUid();
208         // so wakelock calls will succeed
209         long identity = Binder.clearCallingIdentity();
210         try {
211             if (false) {
212                 String s = "";
213                 int N = pattern.length;
214                 for (int i=0; i) {
215                     s += " " + pattern[i];
216                 }
217                 Slog.i(TAG, "vibrating with pattern: " + s);
218             }
219 
220             // we're running in the server so we can't fail
221             if (pattern == null || pattern.length == 0
222                     || isAll0(pattern)
223                     || repeat >= pattern.length || token == null) {
224                 return;
225             }
226 
227             Vibration vib = new Vibration(token, pattern, repeat, uid);
228             try {
229                 token.linkToDeath(vib, 0);
230             } catch (RemoteException e) {
231                 return;
232             }
233 
234             synchronized (mVibrations) {
235                 removeVibrationLocked(token);
236                 doCancelVibrateLocked();
237                 if (repeat >= 0) {
238                     mVibrations.addFirst(vib);
239                     startNextVibrationLocked();
240                 } else {
241                     // A negative repeat means that this pattern is not meant
242                     // to repeat. Treat it like a simple vibration.
243                     mCurrentVibration = vib;
244                     startVibrationLocked(vib);
245                 }
246             }
247         }
248         finally {
249             Binder.restoreCallingIdentity(identity);
250         }
251     }
252 
253     public void cancelVibrate(IBinder token) {
254         mContext.enforceCallingOrSelfPermission(
255                 android.Manifest.permission.VIBRATE,
256                 "cancelVibrate");
257 
258         // so wakelock calls will succeed
259         long identity = Binder.clearCallingIdentity();
260         try {
261             synchronized (mVibrations) {
262                 final Vibration vib = removeVibrationLocked(token);
263                 if (vib == mCurrentVibration) {
264                     doCancelVibrateLocked();
265                     startNextVibrationLocked();
266                 }
267             }
268         }
269         finally {
270             Binder.restoreCallingIdentity(identity);
271         }
272     }
273 
274     private final Runnable mVibrationRunnable = new Runnable() {
275         public void run() {
276             synchronized (mVibrations) {
277                 doCancelVibrateLocked();
278                 startNextVibrationLocked();
279             }
280         }
281     };
282 
283     // Lock held on mVibrations
284     private void doCancelVibrateLocked() {
285         if (mThread != null) {
286             synchronized (mThread) {
287                 mThread.mDone = true;
288                 mThread.notify();
289             }
290             mThread = null;
291         }
292         doVibratorOff();
293         mH.removeCallbacks(mVibrationRunnable);
294     }
295 
296     // Lock held on mVibrations
297     private void startNextVibrationLocked() {
298         if (mVibrations.size() <= 0) {
299             mCurrentVibration = null;
300             return;
301         }
302         mCurrentVibration = mVibrations.getFirst();
303         startVibrationLocked(mCurrentVibration);
304     }
305 
306     // Lock held on mVibrations
307     private void startVibrationLocked(final Vibration vib) {
308         if (vib.mTimeout != 0) {
309             doVibratorOn(vib.mTimeout);
310             mH.postDelayed(mVibrationRunnable, vib.mTimeout);
311         } else {
312             // mThread better be null here. doCancelVibrate should always be
313             // called before startNextVibrationLocked or startVibrationLocked.
314             mThread = new VibrateThread(vib);
315             mThread.start();
316         }
317     }
318 
319     // Lock held on mVibrations
320     private Vibration removeVibrationLocked(IBinder token) {
321         ListIterator iter = mVibrations.listIterator(0);
322         while (iter.hasNext()) {
323             Vibration vib = iter.next();
324             if (vib.mToken == token) {
325                 iter.remove();
326                 unlinkVibration(vib);
327                 return vib;
328             }
329         }
330         // We might be looking for a simple vibration which is only stored in
331         // mCurrentVibration.
332         if (mCurrentVibration != null && mCurrentVibration.mToken == token) {
333             unlinkVibration(mCurrentVibration);
334             return mCurrentVibration;
335         }
336         return null;
337     }
338 
339     private void unlinkVibration(Vibration vib) {
340         if (vib.mPattern != null) {
341             // If Vibration object has a pattern,
342             // the Vibration object has also been linkedToDeath.
343             vib.mToken.unlinkToDeath(vib, 0);
344         }
345     }
346 
347     private void updateInputDeviceVibrators() {
348         synchronized (mVibrations) {
349             doCancelVibrateLocked();
350 
351             synchronized (mInputDeviceVibrators) {
352                 mVibrateInputDevicesSetting = false;
353                 try {
354                     mVibrateInputDevicesSetting = Settings.System.getIntForUser(
355                             mContext.getContentResolver(),
356                             Settings.System.VIBRATE_INPUT_DEVICES, UserHandle.USER_CURRENT) > 0;
357                 } catch (SettingNotFoundException snfe) {
358                 }
359 
360                 if (mVibrateInputDevicesSetting) {
361                     if (!mInputDeviceListenerRegistered) {
362                         mInputDeviceListenerRegistered = true;
363                         mIm.registerInputDeviceListener(this, mH);
364                     }
365                 } else {
366                     if (mInputDeviceListenerRegistered) {
367                         mInputDeviceListenerRegistered = false;
368                         mIm.unregisterInputDeviceListener(this);
369                     }
370                 }
371 
372                 mInputDeviceVibrators.clear();
373                 if (mVibrateInputDevicesSetting) {
374                     int[] ids = mIm.getInputDeviceIds();
375                     for (int i = 0; i < ids.length; i++) {
376                         InputDevice device = mIm.getInputDevice(ids[i]);
377                         Vibrator vibrator = device.getVibrator();
378                         if (vibrator.hasVibrator()) {
379                             mInputDeviceVibrators.add(vibrator);
380                         }
381                     }
382                 }
383             }
384 
385             startNextVibrationLocked();
386         }
387     }
388 
389     @Override
390     public void onInputDeviceAdded(int deviceId) {
391         updateInputDeviceVibrators();
392     }
393 
394     @Override
395     public void onInputDeviceChanged(int deviceId) {
396         updateInputDeviceVibrators();
397     }
398 
399     @Override
400     public void onInputDeviceRemoved(int deviceId) {
401         updateInputDeviceVibrators();
402     }
403 
404     private boolean doVibratorExists() {
405         // For now, we choose to ignore the presence of input devices that have vibrators
406         // when reporting whether the device has a vibrator.  Applications often use this
407         // information to decide whether to enable certain features so they expect the
408         // result of hasVibrator() to be constant.  For now, just report whether
409         // the device has a built-in vibrator.
410         //synchronized (mInputDeviceVibrators) {
411         //    return !mInputDeviceVibrators.isEmpty() || vibratorExists();
412         //}
413         return vibratorExists();
414     }
415 
416     private void doVibratorOn(long millis) {
417         synchronized (mInputDeviceVibrators) {
418             final int vibratorCount = mInputDeviceVibrators.size();
419             if (vibratorCount != 0) {
420                 for (int i = 0; i < vibratorCount; i++) {
421                     mInputDeviceVibrators.get(i).vibrate(millis);
422                 }
423             } else {
424                 vibratorOn(millis);
425             }
426         }
427     }
428 
429     private void doVibratorOff() {
430         synchronized (mInputDeviceVibrators) {
431             final int vibratorCount = mInputDeviceVibrators.size();
432             if (vibratorCount != 0) {
433                 for (int i = 0; i < vibratorCount; i++) {
434                     mInputDeviceVibrators.get(i).cancel();
435                 }
436             } else {
437                 vibratorOff();
438             }
439         }
440     }
441 
442     private class VibrateThread extends Thread {
443         final Vibration mVibration;
444         boolean mDone;
445 
446         VibrateThread(Vibration vib) {
447             mVibration = vib;
448             mTmpWorkSource.set(vib.mUid);
449             mWakeLock.setWorkSource(mTmpWorkSource);
450             mWakeLock.acquire();
451         }
452 
453         private void delay(long duration) {
454             if (duration > 0) {
455                 long bedtime = duration + SystemClock.uptimeMillis();
456                 do {
457                     try {
458                         this.wait(duration);
459                     }
460                     catch (InterruptedException e) {
461                     }
462                     if (mDone) {
463                         break;
464                     }
465                     duration = bedtime - SystemClock.uptimeMillis();
466                 } while (duration > 0);
467             }
468         }
469 
470         public void run() {
471             Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);
472             synchronized (this) {
473                 int index = 0;
474                 long[] pattern = mVibration.mPattern;
475                 int len = pattern.length;
476                 int repeat = mVibration.mRepeat;
477                 long duration = 0;
478 
479                 while (!mDone) {
480                     // add off-time duration to any accumulated on-time duration
481                     if (index < len) {
482                         duration += pattern[index++];
483                     }
484 
485                     // sleep until it is time to start the vibrator
486                     delay(duration);
487                     if (mDone) {
488                         break;
489                     }
490 
491                     if (index < len) {
492                         // read on-time duration and start the vibrator
493                         // duration is saved for delay() at top of loop
494                         duration = pattern[index++];
495                         if (duration > 0) {
496                             VibratorService.this.doVibratorOn(duration);
497                         }
498                     } else {
499                         if (repeat < 0) {
500                             break;
501                         } else {
502                             index = repeat;
503                             duration = 0;
504                         }
505                     }
506                 }
507                 mWakeLock.release();
508             }
509             synchronized (mVibrations) {
510                 if (mThread == this) {
511                     mThread = null;
512                 }
513                 if (!mDone) {
514                     // If this vibration finished naturally, start the next
515                     // vibration.
516                     mVibrations.remove(mVibration);
517                     unlinkVibration(mVibration);
518                     startNextVibrationLocked();
519                 }
520             }
521         }
522     };
523 
524     BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
525         public void onReceive(Context context, Intent intent) {
526             if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
527                 synchronized (mVibrations) {
528                     doCancelVibrateLocked();
529 
530                     int size = mVibrations.size();
531                     for(int i = 0; i < size; i++) {
532                         unlinkVibration(mVibrations.get(i));
533                     }
534 
535                     mVibrations.clear();
536                 }
537             }
538         }
539     };
540 }
复制代码

其中，VibratorService实际上是通过“本地方法”去控制马达的。例如，hasVibratora()最终是通过vibratorExists()来判断马达是否存在的。

 

4 Vibrator.java

frameworks/base/core/java/android/os/Vibrator.java源码如下：

复制代码 
 1 package android.os;
 2 
 3 import android.content.Context;
 4 
 5 public abstract class Vibrator {
 6 
 7     public Vibrator() {
 8     }
 9 
10     public abstract boolean hasVibrator();
11     
12     public abstract void vibrate(long milliseconds);
13 
14     public abstract void vibrate(long[] pattern, int repeat);
15 
16     public abstract void cancel();
17 }
复制代码

 

5 SystemVibrator.java

frameworks/base/core/java/android/os/SystemVibrator.java源码如下：

复制代码 
 1 /*
 2  * Copyright (C) 2012 The Android Open Source Project
 3  *
 4  * Licensed under the Apache License, Version 2.0 (the "License");
 5  * you may not use this file except in compliance with the License.
 6  * You may obtain a copy of the License at
 7  *
 8  *      http://www.apache.org/licenses/LICENSE-2.0
 9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.os;
18 
19 import android.util.Log;
20 
21 /**
22  * Vibrator implementation that controls the main system vibrator.
23  *
24  * @hide
25  */
26 public class SystemVibrator extends Vibrator {
27     private static final String TAG = "Vibrator";
28 
29     private final IVibratorService mService;
30     private final Binder mToken = new Binder();
31 
32     public SystemVibrator() {
33         mService = IVibratorService.Stub.asInterface(
34                 ServiceManager.getService("vibrator"));
35     }
36 
37     @Override
38     public boolean hasVibrator() {
39         if (mService == null) {
40             Log.w(TAG, "Failed to vibrate; no vibrator service.");
41             return false;
42         }
43         try {
44             return mService.hasVibrator();
45         } catch (RemoteException e) {
46         }
47         return false;
48     }
49 
50     @Override
51     public void vibrate(long milliseconds) {
52         if (mService == null) {
53             Log.w(TAG, "Failed to vibrate; no vibrator service.");
54             return;
55         }
56         try {
57             mService.vibrate(milliseconds, mToken);
58         } catch (RemoteException e) {
59             Log.w(TAG, "Failed to vibrate.", e);
60         }
61     }
62 
63     @Override
64     public void vibrate(long[] pattern, int repeat) {
65         if (mService == null) {
66             Log.w(TAG, "Failed to vibrate; no vibrator service.");
67             return;
68         }
69         // catch this here because the server will do nothing.  pattern may
70         // not be null, let that be checked, because the server will drop it
71         // anyway
72         if (repeat < pattern.length) {
73             try {
74                 mService.vibratePattern(pattern, repeat, mToken);
75             } catch (RemoteException e) {
76                 Log.w(TAG, "Failed to vibrate.", e);
77             }
78         } else {
79             throw new ArrayIndexOutOfBoundsException();
80         }
81     }
82 
83     @Override
84     public void cancel() {
85         if (mService == null) {
86             return;
87         }
88         try {
89             mService.cancelVibrate(mToken);
90         } catch (RemoteException e) {
91             Log.w(TAG, "Failed to cancel vibration.", e);
92         }
93     }
94 }
复制代码

说明：
(01) 在构造函数SystemVibrator()中，我们通过 IVibratorService.Stub.asInterface(ServiceManager.getService("vibrator")) 获取马达服务，实际上获取的是VibratorService对象。
(02) SystemVibrator的接口都是调用VibratorService接口实现的。

 

在讲解“应用层如何通过getSystemService(VIBRATOR_SERVICE)获取马达服务，然后进一步的操作马达”之前，我们先看看应用层的马达操作示例！

 

Part 6 马达的应用示例

1 权限

调用马达服务，需要在manifest中添加相应的权限：


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

2 源码

源码如下：

复制代码 
 1 package com.test;
 2 
 3 import android.app.Activity;
 4 import android.os.Bundle;
 5 import android.os.Vibrator;
 6 import android.view.View;
 7 import android.view.View.OnClickListener;
 8 import android.widget.Button;
 9 import android.widget.ToggleButton;
10 import android.util.Log;
11 
12 public class VibratorTest extends Activity {
13     private static final String TAG = "skywang-->VibratorTest";
14 
15     private Vibrator mVibrator;
16     private Button mOnce = null;
17     private ToggleButton mEndless = null;
18 
19     @Override
20     protected void onCreate(Bundle savedInstanceState) {
21         super.onCreate(savedInstanceState);
22         setContentView(R.layout.main);
23 
24         // 获取震动马达服务
25         mVibrator= (Vibrator) getSystemService(VIBRATOR_SERVICE);
26 
27         mOnce = (Button) findViewById(R.id.vib_once);
28         mOnce.setOnClickListener(new View.OnClickListener() {
29             
30             @Override
31             public void onClick(View view) {
32                 //震动指定时间
33                 mVibrator.vibrate(100);
34             }
35         });
36 
37         mEndless = (ToggleButton) findViewById(R.id.vib_endless);
38         mEndless.setOnClickListener(new OnClickListener() {
39             @Override
40             public void onClick(View v) {
41                 if (mEndless.isChecked()) {
42                     //等待100ms后，按数组所给数值间隔震动；其后为重复次数，-1为不重复，0一直震动
43                     mVibrator.vibrate(new long[]{100,20,100,40,100,60}, 0);
44                 } else {
45                     // 取消震动 
46                     mVibrator.cancel();
47                 }
48             }
49         });
50 
51     }
52 
53     @Override
54     protected void onStop() {
55         super.onStop();
56         if (mVibrator != null)
57             mVibrator= null;
58     }
59 }
复制代码 
点击下载：Android马达应用代码

 

Part 7 马达的应用如何调用到马达服务的

接下来，我们分析一下如何获取马达服务的：即 mVibrator= (Vibrator) getSystemService(VIBRATOR_SERVICE) 的工作原理。

1. Context.java中的getSystemService()

getSystemService()定义在frameworks/base/core/java/android/content/Context.java中，源码如下：

public abstract Object getSystemService(String name);

Context.java中的getSystemService() 是个抽象方法，它的实现在ContextImpl.java中。

 

2. ContextImpl.java中的getSystemService()

frameworks/base/core/java/android/app/ContextImpl.java中的 getSystemService() 源码如下：

1 @Override
2 public Object getSystemService(String name) {
3     ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
4     return fetcher == null ? null : fetcher.getService(this);
5 }

 

3. ContextImpl.java中的SYSTEM_SERVICE_MAP

SYSTEM_SERVICE_MAP是一个HashMap对象，它的相关代码如下：

复制代码 
 1 private static final HashMap SYSTEM_SERVICE_MAP =
 2         new HashMap();
 3 
 4 SYSTEM_SERVICE_MAP的初始化，是在ContextImpl.java通过static静态模块完成的。源码如下：
 5 static {
 6 
 7     ...
 8 
 9     // 注册“传感器服务”
10     registerService(SENSOR_SERVICE, new ServiceFetcher() {
11             public Object createService(ContextImpl ctx) {
12                 return new SystemSensorManager(ctx.mMainThread.getHandler().getLooper());
13             }});
14 
15     // 注册其它服务 ...
16 
17     // 注册马达服务
18     registerService(VIBRATOR_SERVICE, new ServiceFetcher() {
19             public Object createService(ContextImpl ctx) {
20                 return new SystemVibrator();
21             }});
22 
23     ...
24 }
复制代码

说明：在上面的static静态模块中，会通过registerService()注册一系列的服务，包括马达服务。注册服务是通过registerService()实现的，下面我们看看registerService()的定义。

复制代码 
1 private static int sNextPerContextServiceCacheIndex = 0;
2 private static void registerService(String serviceName, ServiceFetcher fetcher) {
3     if (!(fetcher instanceof StaticServiceFetcher)) {
4         fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;
5     }
6     SYSTEM_SERVICE_MAP.put(serviceName, fetcher);
7 }
复制代码

    从中，我们知道，在registerService()中，会通过 SYSTEM_SERVICE_MAP.put(serviceName, fetcher) 将serviceName和fetcher添加到哈希表SYSTEM_SERVICE_MAP中。
    对马达服务而言，添加到哈希表SYSTEM_SERVICE_MAP中的key-value中的key是VIBRATOR_SERVICE，value则是ServiceFetcher对象；而且该匿名ServiceFetcher对象的createService()方法会“通过new SystemVibrator()”返回SystemVibrator对象。而SystemVibrator我们在前面已经介绍过了，它是马达服务对外提供接口的类。

OK，接着往下看。

 

3. ContextImpl.java中的fetcher.getService(this)

1 public Object getSystemService(String name) {
2     ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
3     return fetcher == null ? null : fetcher.getService(this);
4 }

我们已经知道SYSTEM_SERVICE_MAP是哈希表，通过SYSTEM_SERVICE_MAP.get(name)返回的是ServiceFetcher对象。
由于fetcher不为null，所以，getSystemService()会返回fetcher.getService(this)。我们看看ServiceFetcher中getService()源码：

复制代码 
 1 static class ServiceFetcher {
 2     int mContextCacheIndex = -1;
 3 
 4     public Object getService(ContextImpl ctx) {
 5         ArrayList cache = ctx.mServiceCache;
 6         Object service;
 7         synchronized (cache) {
 8             if (cache.size() == 0) {
 9 
10                 // “服务对象”缓冲
11                 for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) {
12                     cache.add(null);
13                 }
14             } else {
15                 service = cache.get(mContextCacheIndex);
16                 if (service != null) {
17                     return service;
18                 }
19             }
20             service = createService(ctx);
21             cache.set(mContextCacheIndex, service);
22             return service;
23         }
24     }
25 
26     public Object createService(ContextImpl ctx) {
27         throw new RuntimeException("Not implemented");
28     }
29 } 
    
 
     复制代码 
    
 
    
   
从中，我们发现，getService()实际上返回的是“通过createService(ctx)创建的service对象”。
 而在registerService()注册马达服务时，我们匿名实现了createService()方法：它实际上是通过 new SystemVibrator() 返回SystemVibrator对象。
 
   
至此，我们知道：getSystemService(VIBRATOR_SERVICE) 返回的是 SystemVibrator对象！SystemVibrator前面已经分析过，这里就不再说明了。
 
   
  
 
   
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(andriod驱动开发,andriod驱动开发)

        

            

                
    
                    
  • Python 课程10-单元测试
                        可愛小吉
Python教學python单元测试开发语言TDDunittest
                        
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
    
                    
    • 
                    
  • Linux驱动开发-字符设备驱动开发
                        可能只会写BUG
linuxlinux驱动开发c语言linux驱动开发运维
                        
    linux驱动开发1.驱动程序的类型2.驱动开发流程字符设备驱动1.基本概念2.字符设备驱动的基本结构架构字符设备驱动开发中常用的API示例以下代码加入了设备类和设备实例的创建linux驱动开发1.驱动程序的类型在Linux中，驱动程序主要有以下几种类型：字符设备驱动：处理字节流的设备，如串口、键盘等。它们通过字符设备接口（如/dev/tty）与用户空间进行交互。块设备驱动：处理块存储设备，如硬盘
    
                    
    • 
                    
  • shell 笔记_s1=abc,s2=def,[-z‘‘‘]&；&；echo‘$s1‘ echo‘$s2‘的输出是什么
                        2024云技术
运维linux面试
                        
    最全的Linux教程，Linux从入门到精通======================linux从入门到精通(第2版)Linux系统移植Linux驱动开发入门与实战LINUX系统移植第2版Linux开源网络全栈详解从DPDK到OpenFlow第一份《Linux从入门到精通》466页====================内容简介====本书是获得了很多读者好评的Linux经典畅销书**《Linu
    
                    
    • 
                    
  • 深入探究Spring Framework源码与核心组件
                        纸寿司

                        
    本文还有配套的精品资源，点击获取简介：SpringFramework是Java开发中广泛使用的框架，其源码的阅读和理解对于开发者来说是宝贵的学习资源。本文将介绍依赖注入、ApplicationContext、Bean生命周期、AOP、数据访问集成、MVC模式、注解驱动开发、测试支持、SpringBoot以及SpringCloud等关键概念。通过这些核心组件的学习，可以更好地掌握Spring的高级功
    
                    
    • 
                    
  • 常用C语言单元测试工具介绍
                        不安分的小女孩博客
c语言单元测试开发语言
                        
    常用C语言单元测试工具介绍单元测试准则C/C++怎么做好单元测试最完整的自动化测试流程软件测试用例自动生成技术研究论文单元测试是保证软件质量非常有效的手段，无论是从测试理论早期介入测试的理念来看或是从单元测试不受UI影响可以高速批量验证的特性，所以业界所倡导的测试驱动开发，这个里面提到的测试驱动更多的就是指单元测试驱动。但一般开发团队还是很少的系统化的执行单元测试，针对应用软件的测试更多是由专业测
    
                    
    • 
                    
  • 软件测试题(1)
                        妙舞汉宫人
软件测试软件测试
                        
    1.有关"测试驱动开发"，下列说法正确的有？正确答案:ABCDA.TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码B.TDD的基本思路就是通过测试来推动整个开发得进行，但测试驱动开发并不只是单纯的测试工作，而是把需求分析，设计，质量控制量化的过程。C.TDD的重要目的不仅仅是测试软件，测试工作保证代码质量仅仅是其中一部分，而且是在开发过程中帮助客户和程序员
    
                    
    • 
                    
  • 鸿蒙（Harmony）、安卓（Android）、AOSP
                        xiphi1978
android内核
                        
    鸿蒙（Harmony）、安卓（Android）、AOSP华为鸿蒙2.0发布，铺天盖地的关于鸿蒙的文章，有点晕，也不太能看得懂，很惭愧，所以特意查了一下，感觉能够科普到能看懂相关新闻的程度。例如AOSP，GWS，HWS等，和大家分享一下：先说关键概念AOSP是什么我们都知道Andriod是一个开源系统，指的就是AOSP，就是AndroidOpenSoftwareProject的缩写，这个系统是goo
    
                    
    • 
                    
  • windows驱动开发-内核编程技术汇总(二)
                        sului
windows驱动开发
                        
    使用NTSTATUS值许多内核模式标准驱动程序例程和驱动程序支持例程使用NTSTATUS类型返回值。此外，在完成IRP时，驱动程序在IRP的IO_STATUS_BLOCK结构中提供NTSTATUS类型的值。NTSTATUS类型在Ntdef.h中定义，系统提供的状态代码在Ntstatus.h中定义。供应商还可以定义专用状态代码，尽管他们很少需要。NTSTATUS值分为四种类型：成功值、信息值、警告和
    
                    
    • 
                    
  • Linux进程间通信方式之管道(pipe)_
                        前端老侯
运维linux面试
                        
    最全的Linux教程，Linux从入门到精通======================linux从入门到精通(第2版)Linux系统移植Linux驱动开发入门与实战LINUX系统移植第2版Linux开源网络全栈详解从DPDK到OpenFlow第一份《Linux从入门到精通》466页====================内容简介====本书是获得了很多读者好评的Linux经典畅销书**《Linu
    
                    
    • 
                    
  • 手把手教你从开发进度划分测试
                        Jarrett_Zheng
单元测试压力测试
                        
    一.单元测试（UnitTesting）单元测试：软件单元测试的对象是可独立编译或汇编的程序模块。测试的对象是软件测试中的最小单位：模块。测试阶段：编码后或者编码前（TDD：测试驱动开发）注：一般编码后测试测试对象：最小模块测试人员：测试工程师或开发人员测试依据：代码和注释+详细文档测试方法：白盒测试测试内容：模块接口测试、局部数据结构测试、独立执行路径测试、错误处理路径测试、边界条件测试注释：1、
    
                    
    • 
                    
  • Linux内核(4)——Linux设备文件open函数从应用到内核全过程解析
                        Embedded-Xin
Linux驱动/内核编程块设备驱动linux嵌入式c++物联网服务器
                        
    学习并整理了下open等系统调用，从用户态如何调用到内核态的全过程。1.Linux内核目录总览2.Linux文件系统与设备驱动关系这是在Linux设备驱动开发详解里找的两张图，内容很形象。当用户程序通过系统调用陷入内核态时，会先经过VFS，也就是虚拟文件系统，使用不同的file_operations，在这里会根据操作的文件类型，来进行不同操作。3.系统调用完成内核调用全过程详解3.1用户态确认好自
    
                    
    • 
                    
  • HarmonyOS驱动开发：USB驱动程序开发套件
                        小小煤球
OpenHarmony鸿蒙开发HarmonyOS网络linux鸿蒙华为harmonyos前端移动开发
                        
    场景介绍USBDDK（USBDriverDevelopKit）是为开发者提供的USB驱动程序开发套件，支持开发者基于用户态，在应用层开发USB设备驱动。提供了一系列主机侧访问设备的接口，包括主机侧打开和关闭接口、管道同步异步读写通信、控制传输、中断传输等。接口说明名称描述OH_Usb_Init(void)初始化DDK。OH_Usb_Release(void)释放DDK。OH_Usb_GetDevi
    
                    
    • 
                    
  • 鸿蒙南向实战：LCD驱动框架开发
                        小小煤球
鸿蒙开发HarmonyOSOpenHarmony计算机外设鸿蒙harmonyos华为前端鸿蒙系统驱动开发
                        
    功能简介LCD（LiquidCrystalDisplay）驱动编程，通过对显示器上电、初始化显示器驱动IC（IntegratedCircuit）内部寄存器等操作，使其可以正常工作。基于HDF（HardwareDriverFoundation）驱动框架构建的Display驱动模型作用如下：为LCD器件驱动开发提供了基础驱动框架，提升驱动开发效率。便于开发的器件驱动实现跨OS、跨芯片平台迁移。基于HD
    
                    
    • 
                    
  • 【Linux驱动】Input子系统
                        青椒炒鸡蛋.
Linux驱动linux
                        
    输入子系统（Input子系统）1.什么是输入子系统？什么是输入设备？常见的摄入设备有键盘、鼠标、触摸屏等等，用户通过这些输入设备与Linux系统进行数据交换。什么是输入系统？输入设备的种类繁多，能否统一它们的接口？既在驱动层面统一，也在应用程序层面统一？Linux系统为了统一管理这些输入设备，实现了一套能兼容所有输入设备的框架——输入子系统。驱动开发人员基于这套框架开发出程序，应用开发人员可以使用
    
                    
    • 
                    
  • Linux驱动开发之Input子系统
                        陈子陌
Input子系统linux
                        
    一、引言在Linux驱动开发的学习过程中，Input子系统绝对是你绕不开的一道关卡。在Linux系统中，不论是按键、鼠标、键盘，亦或者是触摸屏，统统都使用Input子系统来处理输入事件。二、Input子系统1、Input子系统概述Input就是输入的意思，因此Input子系统就是管理输入的系统，和Pinctrl、Gpio子系统一样，都是Linux内核针对某一类设备而创建的框架。不同的输入设备在In
    
                    
    • 
                    
  • 驱动开发之 input 子系统
                        @seven@
驱动开发linux
                        
    1.input子系统介绍input就是输入的意思，input子系统就是管理输入的子系统，和pinctrl、gpio子系统一样，都是Linux内核针对某一类设备而创建的框架。比如按键输入、键盘、鼠标、触摸屏等等这些都属于输入设备，不同的输入设备所代表的含义不同，按键和键盘就是代表按键信息，鼠标和触摸屏代表坐标信息，因此在应用层的处理就不同，对于驱动编写者而言不需要去关心应用层的事情，驱动层只需要按照
    
                    
    • 
                    
  • Linux驱动开发—设备模型框架 kobject创建属性文件
                        Trump. yang
嵌入式开发linux驱动开发
                        
    文章目录什么是属性文件？1.sysfs与kobject2.属性文件的作用3.属性文件的基本操作4.典型的属性文件用例5.创建属性文件的步骤6.示例代码7.效果图使用ATTR宏定义优化__ATTR用法解析1.`__ATTR()`宏的定义2.`__ATTR()`宏的参数3.优化示例优化关键点解析1.数据结构定义2.属性定义3.属性的读写方法4.sysfs操作接口什么是属性文件？在Linux内核中，属性
    
                    
    • 
                    
  • Linux驱动开发—在自己总线下注册设备和驱动
                        Trump. yang
嵌入式开发linux驱动开发
                        
    书接上回:Linux驱动开发—创建总线，创建属性文件-CSDN博客创建完总线，就可以进行本次实验了文章目录前备知识如何引用导出的符号在总线下注册设备device_register函数解析使用示例关键点：实验结果在总线下注册驱动driver_register函数解析使用示例实验结果总线，设备，设备驱动三者完整代码加载设备和加载驱动没有先后顺序1.设备与驱动的动态匹配2.总线的`match`机制3.延
    
                    
    • 
                    
  • 嵌入式面经篇十——驱动开发
                        须尽欢~~
嵌入式软件面经驱动开发
                        
    文章目录前言一、驱动开发1、Linux驱动程序的功能是什么？2、内核程序中申请内存使用什么函数？3、内核程序中申请内存和应用程序时申请内存有什么区别？4、自旋锁和信号量在互斥使用时需要注意什么？在中断服务程序里面的互斥是使用自旋锁还是信号量？5、驱动卸载异常可能是由什么原因引起的？6、Linux中引入模块机制有什么好处？7、Linux设备驱动程序中，使用哪两个函数进行中断处理程序的注册和注销？8、
    
                    
    • 
                    
  • 学习Rust的第22天：mini_grep第2部分
                        老父亲的能量嘎嘣脆
rust学习rust开发语言
                        
    书接上文，在本文中，我们学习了如何通过将Rust程序的逻辑移至单独的库箱中并采用测试驱动开发(TDD)实践来重构Rust程序。通过在实现功能之前编写测试，我们确保了代码的可靠性。我们涵盖了基本的Rust概念，例如错误处理、环境变量和命令行参数。本文最后提出了最后一个改进：将错误消息重定向到stderr以提供更好的用户体验。Recap回顾Thisisourcodesofar这是我们到目前为止的代码u
    
                    
    • 
                    
  • linux设备驱动开发详解源码,linux设备驱动开发详解光盘源码.rar
                        hi啊
linux设备驱动开发详解源码
                        
    压缩包:linux设备驱动开发详解光盘源码.rar列表19/busybox源代码/busybox-1.2.1.tar.bz219/MTD工具/mtd-utils-1.0.0.tar.gz19/nand驱动范例/s3c2410.c19/nor驱动范例/s3c2410nor.c19/yaffs&yaffs2源代码/yaffs.tar.gz19/yaffs&yaffs2源代码/yaffs2.tar.gz
    
                    
    • 
                    
  • 一步步基于HAL库STM32程序RCT6移植到ZET6
                        tt555555555555
STM32stm32arm
                        
    一份来自于大牛室友@Top嵌入式的博客_CSDN博客-Linux驱动开发,STM32,U-Boot源码分析领域博主的代码，他是基于STM32c8t6的HAL库编写的，由于我只有正点原子精英板，于是便从零开始学习。欢迎大佬指正。一.更改启动文件32单片机启动文件为startup_stm32f103x6.sstartup_stm32f103xb.sstartup_stm32f103xe.sstartu
    
                    
    • 
                    
  • 驱动开发系列13 - Linux Graphics 图形驱动概述（二）
                        黑不溜秋的
GPU驱动专栏LinuxGraphicsDriver
                        
    目录一：概述二：Linux图形驱动演进3.1X11基础结构3.2DRI/DRM基础结构四：帧缓冲区驱动程序4.1创建帧缓冲器驱动程序4.2帧缓冲区操作五：直接渲染管理器（DRM）5.1内核模块（DRM）5.2DRM批量缓冲区提交模型5.2.1硬件共享5.2.2内存管理和安全5.3模式设置5.4libdrm六：X.Org驱动程序6.1创建基本驱动程序6.2ShadowFB加速一：概述多年来，Linu
    
                    
    • 
                    
  • 编程调试解bug和性能分析 Debugging and Profiling Testing TDD Logging gdb Sanitizers Coredump Dynamic Tracin
                        EwenWanW
bugtddgdb
                        
    编程调试解bug和性能分析DebuggingandProfiling在编程中，调试（Debugging）、性能分析（Profiling）、测试（Testing）、测试驱动开发（TDD）、日志（Logging）、GDB调试器、Sanitizers、CoreDump以及动态追踪（DynamicTracing）等工具和技术都是帮助开发者找出并修复代码中的错误（bug）、优化程序性能的重要方法。下面我将分
    
                    
    • 
                    
  • Linux外设接口使用及内核驱动开发---Ubuntu搭建Linux内核开发环境
                        Jason.rr
linuxubuntu驱动开发
                        
    文章目录前言一、安装依赖二、下载Linux内核源代码1.从Github下载2.从官网下载三、编译安装内核配置内核编译安装内核/模块：选用内核四、内核驱动例子前言进行Linux嵌入式系统开发时，如果还没有嵌入式系统的开发环境，可以先基于PC机Ubuntu系统进行开发.第一步就需要搭建内核开发环境．一、安装依赖sudoapt-getupdatesudoapt-getinstallbuild-essen
    
                    
    • 
                    
  • PoEAA笔记-7.通盘考虑
                        ariestse9
笔记PoEAAJava
                        
    本文源自《PoEAA》，如预知详细内容请阅读原书通盘考虑好的决策不是一成不变的。架构重构很难，人们也经常忽视它的代价，但是并非不可能。我给的建议就是：即使你对极限编程不感兴趣，你还是应该认真考虑三方面的技术实践：持续集成、测试驱动开发和重构。这些技术虽然不是万能的灵丹妙药，但他们能够帮助你在需要的时候更容易地改变你的系统。除非你比迄今为止我见过的人更能干或更走运。8.1从领域层开始这个过程可以从决
    
                    
    • 
                    
  • 前台自动化测试：基于敏捷测试驱动开发(TDD)的自动化测试原理
                        咖啡加剁椒..
软件测试驱动开发tdd功能测试软件测试自动化测试程序人生职场和发展
                        
    一、自动化测试概述自动化测试主要应用到查询结果的自动化比较，把借助自动化把相同的数据库数据的相同查询条件查询到的结果同理想的数据进行自动化比较或者同已经保障的数据进行不同版本的自动化比较，减轻人为的重复验证测试。多用户并发操作需要自动化模拟来保障大量用户的执行操作，减少对影响资源的依赖。自动化在迭代1开始进行搭建，在迭代2能够具备自动化能力。二、测试目的本文档主要描述NPB的自动化测试粒度、原理及
    
                    
    • 
                    
  • 【GPU驱动开发】-GPU架构简介
                        怪怪王
GPU驱动驱动开发GPUAIchatgpt架构
                        
    前言不必害怕未知，无需恐惧犯错，做一个Creator！GPU（GraphicsProcessingUnit，图形处理单元）是一种专门用于处理图形和并行计算的处理器。GPU系统架构通常包括硬件和软件层面的组件。一、总体流程应用程序请求图形操作：应用程序通过图形API（如OpenGL、Vulkan）发送图形操作请求。图形API调用GPU驱动程序：图形API将请求传递给GPU驱动程序。GPU驱动程序解释
    
                    
    • 
                    
  • 【DDD】学习笔记-薪资管理系统的测试驱动开发2
                        码农丁丁
软件工程#领域驱动设计DDD微服务领域驱动设计测试驱动
                        
    测试驱动开发的过程满足简单设计并编写新的测试当代码满足重用性和可读性之后，就应遵循简单设计的第四条原则“若无必要，勿增实体”，不要盲目地考虑为其增加新的软件元素。这时，需要暂时停止重构，编写新的测试。现在，要测试加班的用例，需提供超过8小时的工作时间卡。测试代码已经定义了创建工作时间卡的方法，新测试的需求差异仅在于工作时长，为了测试代码的重用，可以提取createTimeCards()方法的参数，
    
                    
    • 
                    
  • D-Bus学习（二）：基本概念
                        恺风
Linux嵌入式Linuxinterfaceobjectserverpathsocketunix
                        
    D-Bus的方式在移动手机操作系统中非常重要，包括Maemo，Moblin等以Linux为基础的操作系统。估计Andriod也大量使用。D-Bus的相关学习资料见：http://www.freedesktop.org/wiki/Software/dbus，在网上也有大量的学习资料，在http://blog.chinaunix.net/u3/111961/中有不少的中文资料，收集了很多网络资料。我决
    
                    
    • 
                                
  • 设计模式介绍
                                    tntxia
设计模式
                                    
    设计模式来源于土木工程师 克里斯托弗 亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。 
 
亚历山大与萨拉-石川佳纯和穆雷 西乐弗斯坦合作
    
                                
    • 
                                
  • android高级组件使用(一)
                                    百合不是茶
androidRatingBarSpinner
                                    
    1、自动完成文本框（AutoCompleteTextView） 
 
 AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。 
 使用AutoCompleteTex
    
                                
    • 
                                
  • [网络与通讯]路由器市场大有潜力可挖掘
                                    comsci
网络
                                    
       
       如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题..... 
 
       这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入 
 
 &nbs
    
                                
    • 
                                
  • 自写简单Redis内存统计shell
                                    商人shang
Linux shell统计Redis内存
                                    
    #!/bin/bash
address="192.168.150.128:6666,192.168.150.128:6666"  
hosts=(${address//,/ })  

sfile="staticts.log"

for hostitem in ${hosts[@]}  
do  
    ipport=(${hostitem
    
                                
    • 
                                
  • 单例模式(饿汉 vs懒汉)
                                    oloz
单例模式
                                    
    package 单例模式;
/*
 * 应用场景:保证在整个应用之中某个对象的实例只有一个
 * 单例模式种的《 懒汉模式》  
 * */
public class Singleton {
	
	//01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例
	private Singleton(){};
	
	//02 申明类得唯一实例
	priva
    
                                
    • 
                                
  • springMvc json支持
                                    杨白白
json springmvc
                                    
    1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 
 
 
2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 
 

@RequestMapping("helloJson")
public @ResponseBody
    JsonTest helloJson() {
   
    
                                
    • 
                                
  • android播放，掃描添加本地音頻文件
                                    小桔子

                                    
            最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
    
                                
    • 
                                
  • oracle常用命令
                                    aichenglong
oracledba常用命令
                                    
    1 创建临时表空间 
create temporary tablespace user_temp  
tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' 
size 50m  
autoextend on  
next 50m maxsize 20480m  
extent management local
    
                                
    • 
                                
  • 25个Eclipse插件
                                    AILIKES
eclipse插件
                                    
    提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
    
                                
    • 
                                
  • Spring MVC拦截器+注解方式实现防止表单重复提交
                                    baalwolf
spring mvc
                                    
    原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。      
1.新建注解： 
     
?       1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   
    
                                
    • 
                                
  • 《Javascript高级程序设计(第3版)》闭包理解
                                    bijian1013
JavaScript
                                    
    “闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》 
  
      看以下代码： 
<script type="text/javascript">
    function outer() {
        var i = 10;
        return f
    
                                
    • 
                                
  • AngularJS Module类的方法
                                    bijian1013
JavaScriptAngularJSModule
                                    
            AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。 
一.Main方法在哪里 
        如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
    
                                
    • 
                                
  • [Maven学习笔记七]Maven插件和目标
                                    bit1129
maven插件
                                    
    插件(plugin)和目标(goal) 
Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标 
  
使用插件和目标使得我们可以干预
    
                                
    • 
                                
  • 【Hadoop八】Yarn的资源调度策略
                                    bit1129
hadoop
                                    
    1. Hadoop的三种调度策略 
Hadoop提供了3中作业调用的策略， 
 
 FIFO Scheduler 
 Fair Scheduler 
 Capacity Scheduler 
 
以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度 
  2. 多用户资源共享的调度 
    
                                
    • 
                                
  • Nginx使用Linux内存加速静态文件访问
                                    ronin47

                                    
    Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。 
先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res 
shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：      
    
                                
    • 
                                
  • 关于Unity3D中的Shader的知识
                                    brotherlamp
unityunity资料unity教程unity视频unity自学
                                    
    首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
    
                                
    • 
                                
  • CopyOnWriteArrayList vs ArrayList
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 总述：
 * 1.ArrayListi不是线程安全的，CopyO
    
                                
    • 
                                
  • 内存中栈和堆的区别
                                    chicony
内存
                                    
      
1、内存分配方面： 
 
    堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。 
 
    栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
    
                                
    • 
                                
  • 回答一位网友对Scala的提问
                                    chenchao051
scalamap
                                    
    本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。  问题 写道   对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢  
   先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
    
                                
    • 
                                
  • mysql 取每组前几条记录
                                    daizj
mysql分组最大值最小值每组三条记录
                                    
    一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录    1.用子查询：   SELECT * FROM tableName a  WHERE 3>   (SELECT COUNT(*) FROM  tableName b WHERE b.id=a.id AND b.cnt>a. cnt)   ORDER BY a.id,a.account DE
    
                                
    • 
                                
  • HTTP深入浅出 http请求
                                    dcj3sjt126com
http
                                    
        HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
    
                                
    • 
                                
  • 判断MySQL记录是否存在方法比较
                                    dcj3sjt126com
mysql
                                    
    把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。 
　　我这里总结了判断记录是否存在的常用方法： 
　　sql语句：  select   count ( * )  from  tablename;  
　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
    
                                
    • 
                                
  • 对HTML XML的一点认识
                                    e200702084
htmlxml
                                    
    感谢http://www.w3school.com.cn提供的资料 
HTML 文档中的每个成分都是一个节点。 
节点 
根据 DOM，HTML 文档中的每个成分都是一个节点。 
 
DOM 是这样规定的： 
 
整个文档是一个文档节点 
每个 HTML 标签是一个元素节点 
包含在 HTML 元素中的文本是文本节点 
每一个 HTML 属性是一个属性节点 
注释属于注释节点 
Node 层次 

    
                                
    • 
                                
  • jquery分页插件
                                    genaiwei
jqueryWeb前端分页插件
                                    
    //jquery页码控件// 创建一个闭包    (function($) {      // 插件的定义      $.fn.pageTool = function(options) {          var totalPa
    
                                
    • 
                                
  • Mybatis与Ibatis对照入门于学习
                                    Josh_Persistence
mybatisibatis区别联系
                                    
    一、为什么使用IBatis/Mybatis 
        对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
    
                                
    • 
                                
  • C中怎样合理决定使用那种整数类型？
                                    秋风扫落叶
c数据类型
                                    
    如果需要大数值(大于32767或小于32767), 使用long 型。 否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。 除此之外, 就使用 int 型。 如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。 但是, 要注意在表达式中混用有符号和无符号值的情况。 
  
 &nbs
    
                                
    • 
                                
  • maven问题
                                    zhb8015
maven问题
                                    
      
问题1： 
Eclipse 中 新建maven项目 无法添加src/main/java 问题 
   eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。 
    按照maven目录结构，添加src/main/ja
    
                                
    • 
                                
  • (二)androidpn-server tomcat版源码解析之--push消息处理
                                    spjich
javaandrodipn推送
                                    
    在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。 
先贴一段XmppIoHandler的部分代码 
/**
     * Invoked from an I/O proc
    
                                
    • 
                                
  • 用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题
                                    中华好儿孙
JavaScriptAjaxWeb上传文件FormData
                                    
    
var formData = new FormData($("#inputFileForm")[0]);
$.ajax({
		type:'post',
		url:webRoot+"/electronicContractUrl/webapp/uploadfile",
		data:formData,
		async: false,
		ca
    
                                
    • 
                                
  • mybatis常用jdbcType数据类型
                                    ysj5125094
mybatismapperjdbcType
                                    
      
MyBatis 通过包含的jdbcType
类型 
BIT         FLOAT      CHAR          
    
                                
    •