操作系统

• 用法：grep [-acinv] [–color=auto] '搜索关键词' filename
  1. -a，将 binary 文件以 text 文件的方式搜寻数据;
  2. -c，计算找到 '搜寻字符串' 的次数;
  3. -i，忽略大小写的不同，所以大小写视为相同;
  4. -n，顺便输出行号;
  5. -v，反向选择，亦即显示出没有 '搜寻字符串' 内容的那一行;
  6. –color=auto，可以将找到的关键词部分加上颜色的显示喔！
• 用例：

  1. 在当前目录下找到所有文件中包含关键字Scd的行

     cat * | grep -n Scd
     

• 用法：过于复杂；
• 用例：

  1. 在当前目录下找到所有（包括子目录）文件名后缀是".c", ".h"的文件名路径并 输出到文件cscope.files

     find . -name "*.[ch]" >cscope.files
     

• 键位修改：修改理论见网址， 看完后可知目录下有ctrl配置文件，里面就有直接调换alt和ctrl的配置；

android中的Bundle一般用于携带数据，类似于Map，用于存放key-value键值对，其提 供了各种putXx()和getXx()方法，putXx()用于往Bundle对象中放入数据，getXx()用 于从Bundle对象中获取数据。比如Bundle常用与组件之间进行数据传输，我们可以将 Bundle设置好数据后，利用Intent的putExtras()方法将Bundle捆绑到Intent中，然后 再传递给别的组件；

Intent可以用于启动别的组件比如Activity和Service等，并在Intent中绑定一定的数 据，传递给目标组件。

• 获取年月日

  import    java.text.SimpleDateFormat;     
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");     
  Date curDate = new Date(System.currentTimeMillis());//获取当前时间     
  String str = formatter.format(curDate);     
  

• 获取当前的年月时分

  SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");     
  String date = sDateFormat.format(new java.util.Date());  
  

• 获取当前的年月

  SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");  
  String date=sdf.format(new java.util.Date());  
  

• 获取指定时区的时间

  df = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL,Locale.CHINA);
  System.out.println(df.format(new Date()));
  

• 确定系统时间制式

  ContentResolver cv = this.getContentResolver();
  String strTimeFormat = android.provider.Settings.System.getString(cv,
                                 android.provider.Settings.System.TIME_12_24);
  if(strTimeFormat.equals("24")){
     Log.i("activity","24");
  }
  

• 取得系统时间日期

  Calendar c = Calendar.getInstance();
  year = c.get(Calendar.YEAR) /*取得系统日期*/
  month = c.grt(Calendar.MONTH)
  day = c.get(Calendar.DAY_OF_MONTH)
  hour = c.get(Calendar.HOUR_OF_DAY);/*取得系统时间*/
  minute = c.get(Calendar.MINUTE)
  

• 利用TIMER获取

  Time t=new Time(); // or Time t=new Time("GMT+8"); 加上Time Zone资料。
  t.setToNow(); // 取得系统时间。
  int year = t.year;
  int month = t.month;
  int date = t.monthDay;
  int hour = t.hour; // 0-23
  int minute = t.minute;
  int second = t.second;
  

Android运行在各种各样的设备中，有小屏幕的手机，超大屏的平板甚至电视。针对屏 幕尺寸的差距，很多情况下，都是先针对手机开发一套App，然后拷贝一份，修改布局 以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么，当然 了，必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成 Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的 Fragment组成，更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件， 这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是，你可以动态 的添加、替换和移除某个Fragment; Fragment必须是依存与Activity而存在的，因此 Activity的生命周期会直接影响到Fragment的生命周期, Fragment的生命周期见图 \ref{img-fragment-cycle};

• button透明：xml中使用android:background="@android:color/transparent"

实现某个菜单框里面有多个选项，点击后可以展示各个字符菜单项，点击后可以产生 点击事件，可以将某个int值和字符菜单项对应；实现方法：

1. 定义两个array资源：

   //字符菜单项
   <string-array name="gps_type_options">
       <item>GPS</item>
       <item>GPS and GLONASS</item>
       <item>GPS and BEIDOU</item>
   </string-array>
   

   //int对应值
   <integer-array name="gps_type_values">
       <item>0</item>
       <item>1</item>
       <item>2</item>
   </integer-array>
   

2. xml中定义器件

   <Spinner
       android:id="@+id/spinnerType"
       android:layout_width="0dip"
       android:layout_height="wrap_content"
       android:layout_marginRight="8dip"
       android:layout_weight="1" />
   

3. 在源文件中获取这2个资源：

   String[] gpsTypeOptions = getResources().getStringArray(R.array.gps_type_options);
       int[] gpsTypeValues = getResources().getIntArray(R.array.gps_type_values);
   

4. 绑定两者成adapter:

   private IntArrayAdapter mGPSTypeAdapter;
       mGPSTypeAdapter = new IntArrayAdapter(this, gpsTypeOptions, gpsTypeValues);
   

5. 将adapter装配到view上：

   private Spinner mSpinnerType;
   mSpinnerType = (Spinner) findViewById(R.id.spinnerType);
   mSpinnerType.setAdapter(mGPSTypeAdapter);
       mSpinnerType.setOnItemSelectedListener(onItemSelectedListener);
   

6. 实现点击事件：

   private OnItemSelectedListener onItemSelectedListener = new OnItemSelectedListener() {
           @Override
           public void onItemSelected(AdapterView<?> adapter,View view,int position,long id) {
               if (adapter == mSpinnerType) {
                   mGPSTypePostion = position;
               }
           }
           @Override
           public void onNothingSelected(AdapterView<?> arg0) {}
   };
   

正方形的复选框选项

1. xml中定义器件

   <CheckBox 
     android:id="@+id/cb"
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content"
     android:checked="false"
     android:text="已婚" />
   

2. 源码中获取器件

   private CheckBox mCheckKeep;
   mCheckKeep = (CheckBox) findViewById(R.id.checkKeep);
   
   

3. 监听事件

   //绑定监听器
   cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
       @Override
       public void onCheckedChanged(CompoundButton arg0, boolean arg1) {
       Toast.makeText(MyActivity.this, 
        arg1?"选中了":"取消了选中"    , Toast.LENGTH_LONG).show();
      }
    });
   

4. 也可以查询获得结果

   if(!cb.isChecked()){
   }
   

单选框可以将多个选项汇聚到一个组中，这个组中的每个单选项是互斥的，选一个其 他的就不能选。

• xml文件

  <RadioGroup
      android:id="@+id/shoes_sel"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_x="3px"
      android:layout_y="54px" >
      <RadioButton
          android:id="@+id/RadioButton1"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="工厂测试"/>
      <RadioButton
          android:id="@+id/RadioButton2"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="生产测试"/>
  </RadioGroup>
  

• 源码中获取：

  mRadioGroup = (RadioGroup) findViewById(R.id.shoes_sel);  
  mRadio1 = (RadioButton) findViewById(R.id.RadioButton1);  
  mRadio2 = (RadioButton) findViewById(R.id.RadioButton2); 
  

• 监听器：

  mRadioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {  
    public void onCheckedChanged(RadioGroup group, int checkedId){
        if (checkedId == mRadio2.getId()){
        //todo
        }  
        else{  
        //todo
        }  
    }  
  });  
  

比如可以在某个按键后触发一个对话框出来要求用户输入数据，然后点确定等操作。 Java代码如下

final AlertDialog dialog = new AlertDialog.Builder(this).create();//对话框对象
//向系统请求一个inflater
LayoutInflater inflater = (LayoutInflater) this.getSystemService(MainActivity.this.LAYOUT_INFLATER_SERVICE);
//该对话框的布局layout
LinearLayout layout = (LinearLayout)inflater.inflate(R.layout.dialog, null);
dialog.setView(layout);
dialog.getWindow().setWindowAnimations(R.style.DialogAnimationStyle);
dialog.show();

//获取对话框中的控件元素，和普通的界面操作一样
final EditText et = (EditText) dialog.getWindow().findViewById(R.id.et_value);
Button close_bt = (Button)dialog.getWindow().findViewById(R.id.close_bt);
close_bt.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
    dialog.dismiss();
    }
});
Button sure_bt = (Button) dialog.getWindow().findViewById(R.id.sure_bt);
sure_bt.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
    String string =et.getText().toString();
    if(string == null)
        dialog.dismiss();
    Calibrate = currentPressure - Float.parseFloat(string);
    dialog.dismiss();
    }
});

相关的界面布局xml文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="300dip"
    android:layout_height="wrap_content"
    android:background="#ffffff"
    android:orientation="vertical" >
    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dip"
        android:layout_marginLeft="10dip"
        android:textSize="20dip"
        android:text="校正" />
    <View 
        android:layout_width="match_parent"
                  android:layout_height="1dip"
                  android:layout_marginTop="10dip"
                  android:background="#009acd" />
    <LinearLayout 
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dip" >
        <TextView
            android:layout_width="100dip"
            android:layout_height="wrap_content"
            android:textSize="15dip"
            android:gravity="center_horizontal"
            android:text="当前值" />
        <TextView
            android:id="@+id/textView3"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="TextView" />
    </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content" 
            android:layout_marginTop="20dip">
            <TextView
                android:id="@+id/textView2"
                android:layout_width="100dip"
                android:layout_height="wrap_content"
                android:gravity="center_horizontal"
                android:textSize="15dip"
                android:text="校正值" />
            <EditText
                android:id="@+id/et_value"
                android:layout_width="200dip"
                android:layout_height="wrap_content"
                android:background="#fff0f5"
                android:numeric="integer"
                android:text="" />
        </LinearLayout>
                <View 
                    android:layout_width="wrap_content"
                    android:layout_height="1dip"
                    android:layout_marginTop="20dip"
                    android:background="@color/darkgray">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="45dp" >
        <Button
            android:id="@+id/close_bt"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="@drawable/bt_style"
            android:layout_weight="1"
            android:text="取消" />
                <View 
                    android:layout_width="1dip"
                    android:layout_height="wrap_content"
                    android:background="@color/darkgray"/>
        <Button
            android:id="@+id/sure_bt"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="@drawable/bt_style"
            android:layout_weight="1"
            android:text="确定" />
    </LinearLayout>
</LinearLayout>

要做绑定服务操作，client需要调用bindService() , 调用后，系统将调用server的onBind()方法，这个方法将返回一个IBinder，这个 IBinder正是反给client，client使用此IBinder来调用server实现的各种服务接口，client要取得这个IBinder，需要实现一个接口 ServiceConnection 作为bindService的参数，此ServiceConnection中的方法onServiceConnected将被系统回调(在onBind执行完后)，而 onBind返回的IBinder正是作为参数传给onServiceConnected，这样client就可以在onServiceConnected里面获得该IBinder；

功能主要是跟UI线程交互用，主要有：

1. 用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其 他处理工作 ；
2. 你可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；
3. 通过handler的延时发送message，可以延时处理一些事务的处理；

4. 线程处理功能：可以使用Handler的post方法，将要处理的事务放在一个thread里面，然后将该线程post到Handler的线程队列中(其实 这个线程和activity主线程是同一个线程，只是运行了线程的run方法)，则该事务将会在thread里面执行，如果使用 postDelayed(thread, time)方法，还能设置一个延时time后执行该事务，类似于timer功能； 实例如下所示。

   //使用handler时首先要创建一个handler
   Handler handler = new Handler();
   //要用handler来处理多线程可以使用runnable接口，这里先定义该接口
   //线程中运行该接口的run函数
   Runnable update_thread = new Runnable(){
       public void run(){
       //线程每次执行时输出"UpdateThread..."文字,且自动换行
       //textview的append功能和Qt中的append类似，不会覆盖前面
       //的内容，只是Qt中的append默认是自动换行模式
       text_view.append("\nUpdateThread...");
       //延时1s后又将线程加入到线程队列中
       handler.postDelayed(update_thread, 1000);
       }
   };
   //将线程接口立刻送到线程队列中
   handler.post(update_thread);
   //将接口从线程队列中移除
   handler.removeCallbacks(update_thread);
   

5. 异步消息处理功能：同样也是使用上面线程处理功能，将某个线程thread，post到handler的线程队列中，线程队列中处理事务，并可 以使用handler的sendMessage()，方法向handler中发送message，然后在handler中可以使用handleMessage来处理这个消息；实例如下：

   //创建一个handler，内部完成处理消息方法
   Handler update_progress_bar = new Handler(){
       public void handleMessage(Message msg) {
       super.handleMessage(msg);
       //显示进度条
       progress_bar.setProgress(msg.arg1);
       //重新把进程加入到进程队列中
       update_progress_bar.post(update_thread);
       }
   };
   update_progress_bar.post(update_thread);//post线程
   Runnable update_thread = new Runnable() {
       int i = 0;
       public void run() {
       i += 10;
       //首先获得一个消息结构
       Message msg = update_progress_bar.obtainMessage();
       //给消息结构的arg1参数赋值
       msg.arg1 = i;
       //延时1s
       Thread.sleep(1000);
       //把消息发送到消息队列中
       update_progress_bar.sendMessage(msg);
       if(i == 100)
           update_progress_bar.removeCallbacks(update_thread);//移除
       }
   };
   

很多软件会有配置文件，里面存放这程序运行当中的各个属性值，由于其配置信息并不多，如果采用数据库来存放并不划算，因为数据库 连接跟操作等耗时大大影响了程序的效率，因此我们使用键值这种一一对应的关系来存放这些配置信息。SharedPreferences正是Android 中用于实现这中存储方式的技术。 SharedPreferences的使用非常简单，能够轻松的存放数据和读取数据。SharedPreferences只能保存简单类型的数据，例如，String、 int等。一般会将复杂类型的数据转换成Base64编码，然后将转换后的数据以字符串的形式保存在 XML文件中，再用SharedPreferences保 存。使用SharedPreferences保存key-value对的步骤如下。

1. 使用Activity类的getSharedPreferences方法获得SharedPreferences对象，其中存储key-value的文件的名称由 getSharedPreferences方法的第一个参数指定。
2. 使用SharedPreferences接口的edit获得SharedPreferences.Editor对象。
3. 通过SharedPreferences.Editor接口的putXxx方法保存key-value对。其中Xxx表示不同的数据类型。例如：字符串类型的value需要用 putString方法。
4. 通过SharedPreferences.Editor接口的commit方法保存key-value对。commit方法相当于数据库事务中的提交（commit）操作。

具体代码的书写流程为。

• 存放数据信息
  1. 打开Preferences，名称为setting，如果存在则打开它，否则创建新的Preferences SharedPreferences settings = getSharedPreferences(“setting”, 0);
  2. 让setting处于编辑状态SharedPreferences.Editor editor = settings.edit();
  3. 存放数据editor.putString(“name”,”ATAAW”);editor.putString(“URL”,”ATAAW.COM”);
  4. 完成提交editor.commit();
• 读取数据信息
  1. 获取Preferences: SharedPreferences settings = getSharedPreferences(“setting”, 0);
  2. 取出数据String name = settings.getString(“name”,”默认值”); String url = setting.getString(“URL”,”default”);

其中创建的Preferences文件存放位置可以在Eclipse中查看：DDMS->File Explorer /<package name>/shared_prefs/setting.xml

• LocationManagerService：简称LMS，统一管理android平台中能够提供位置服务的 相关模块；
• LocationManager：简称LM，为需要使用位置服务的应用程序服务，LMS和LM通过 binder进行交互；
• LocationProvider：简称LP，表示android平台中能够提供位置服务的相关模块的统 称，在所有位置提供者中，android framework实现了其中的PassiveProvider和 GpsLocationProvider，这两个LP由LMS创建并允许在系统进程中；
• LocationProviderInterface：LP必须实现这个接口，这些接口对应的对象实例由 LMS来创建和管理；
• NetworkLocationProvider：由网络提供的位置服务，android原生代码中不提供相 关功能，一般第三方厂商会提供；
• GMS：GoogleMobileService，由Google提供的NetworkLocationProvider，国内的一 般由百度提供；
• ILocationProviderProxy：由于一些LP是由第三方提供，他们运行在应用程序所在 的进程中，所以系统定了这个接口使LMS管理这些由应用程序提供的位置服务；
• LocationProviderBase：第三方提供LP，必须实现这个抽象类；
• FusedLocationProvider：它自身不提供位置信息，而是综合GpsLP和NetworkLP的位 置信息，然后向使用者提供最符合使用者需求的数据，平衡电量和数据精度要求；
• GeocodeProxy：由于需要将位置信息和地址相互转换，而有些位置信息由第三方提 供，所以LMS利用这个和第三方应用中实现GeocodeProxy的对象进行交互。

1. 先创建一个LocationManager对象，用于和LMS交互；
2. 然后调用LocationManager的requestLocationUpdates以设置一个回调接口对象 LocationListener，同时指出要使用哪个LP，或指定定位精度，由系统决定选择LP；
3. 当LP更新相关信息后，LocationListener对应的函数将被调用，应用程序可以在这 些回调函数中做相应处理；
4. 如果应用程序需要在位置和地址信息做转换，则使用Geocoder类提供的函数；

大体思路如下。

1. 获取待模拟的位置；

2. 将位置信息植入需要的Provider里面, 下面示例代码以模拟位置植入GPS_PROVIDER 中为例；

   //xml权限 
   <uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION">
   public static void setLocation(Context context, LatLonBean bean) {  
        LocationManager locmanag = (LocationManager) context  
            .getSystemService(Context.LOCATION_SERVICE);  
        //关键代码
        String mock = LocationManager.GPS_PROVIDER;  
        locmanag.addTestProvider(mock, false, true, false, false, false, false,  
            false, 0, 5);  
        locmanag.setTestProviderEnabled(mock, true);  
        //构造位置信息
        Location loc = new Location(mock);  
        loc.setTime(System.currentTimeMillis());  
        loc.setLatitude(Double.parseDouble(bean.getLat()));  
        loc.setLongitude(Double.parseDouble(bean.getLon()));  
        loc.setAccuracy(Criteria.ACCURACY_FINE);// 精确度  
        loc.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());// 实时运行时间  
        locmanag.setTestProviderStatus(mock, LocationProvider.AVAILABLE, null,  
            System.currentTimeMillis());  
        //位置信息植入
        locmanag.setTestProviderLocation(mock, loc);  
    }  
   

3. 在android手机设置请确保您已在“允许模拟位置”复选框打勾 ；
4. 像普通使用gps定位一样的使用onLocationChanged()会被系统回调。

• BluetoothAdapter：代表手机本地的蓝牙模块，BluetoothAdapter是所有蓝牙互操 作的入口。使用它，你可以discover其他的蓝牙设备，轮询已经bonded(paired)的 设备列表，使用MAC地址实例化一个远端Bluetoothdevice，生成一个 BluetoothServerSocket来监听其他设备。
• BluetoothDevice：代表一个远端的蓝牙设备，本地蓝牙模块使用BluetoothDevice 通过一个BluetoothSocket来请求一个远端设备连接或者请求远端设备的设备名，地 址，绑定状态等；
• BluetoothSocket：代表一个接口，通过这个接口应用程序可以利用InputStream和 OutputStream来和其他蓝牙设备交换数据；
• BluetoothServerSocket：代表一个server socket，它用于监听收到的请求。为了 连接两个android设备，某个设备必须开启一个server socket，当一个远端蓝牙设 备发起一个连接请求到这个设备时，这个设备如果接受这个请求，它的 BluetoothServerSocket会返回一个BluetoothSocket给它；
• BluetoothClass：用于描述蓝牙设备的一般属性和能力。它是只读的属性集，定义 了设备的主次设备类和它的服务，然而这个BluetoothClass并不是这个蓝牙设备支 持的所有蓝牙profile和services的描述；
• BluetoothProfile：是一个蓝牙profile的接口；
• BluetoothHeadset：提供对手机上蓝牙耳机的支持，它包含蓝牙耳机和免提的 profile；
• BluetoothA2dp：定义了通过蓝牙连接的设备间传输音频流的质量，A2DP表示 Advanced Audio Distribution Profile；
• BluetoothHealth：代表了Health Device Profile；
• BluetoothHealthCallback：它是一个BluetoothHealth回调的抽象类。这个回调处 理接收到的应用程序注册状态以及蓝牙通道状态的更新；
• BluetoothHealthAppConfiguration：代表应用程序关于BluetoothHealth的配置；
• BluetoothProfile.ServiceListener：它是一个通知BluetoothProfile IPC客户端 的接口，通知对service连接的状态；

应用程序要用蓝牙功能，必须要声明蓝牙权限“BLUETOOTH”。代码如下

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

如果应用程序还需要“初始化设备发现”，操作“蓝牙设置”，那还需要声明 “BLUETOOTH\_ADMIN”的权限，另外这个权限可以赋予一些功能，比如发现本地蓝牙 设备，修改蓝牙设置；如有要使用“BLUETOOTH\_ADMIN”的声明，还必须要有上面的 “BLUETOOTH”权限。

如果要使用蓝牙，需检查手机是否支持蓝牙，并且要保证已经使能。这需要两步操作。

1. 获取BluetoothAdapter:BluetoothAdapter是所有蓝牙活动所必须要求的。要获得 BluetoothAdapter可以调用getDefaultAdapter()方法，它将返回一个 BluetoothAdapter，如果返回null，代表设备不支持蓝牙，代码如下。

   BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
   if (mBluetoothAdapter == null) {
        // Device does not support Bluetooth
   }
   

2. 使能蓝牙:使用蓝牙前要确定蓝牙是否已经使能，使用isEnable()方法，如果返回 false，表示蓝牙是禁能的。要请求蓝牙开启，可以使用 startActivityForResult()带上ACTION\_REQUEST\_{ENABLE的intent}，这样将会触 发一个系统设置的请求来使能蓝牙，代码如下, 将会出现一个对话框请求用户使能 蓝牙，用户可以允许也可以不允许，ACTION\_REQUEST\_{ENABLE是一个本地定义的} 整数(大于0)，并且会在onActivityResult()回调方法中返回作为requestCode参数， 如果使能蓝牙成功，Activity会在onActivityResult()收到RESULT\_OK结果码，否 则结果码是RESULT\_CANCEL

   if (!mBluetoothAdapter.isEnabled()) {
    Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
   }
   

   同样，应用程序还可以监听ACTION\_STATE\_{CHANGED广播intent}，这个intent会在 蓝牙状态变化时被系统广播出来， 这个广播包含指示蓝牙新旧状态的额外域： EXTRA\_{STATE和EXTRA}\_PREVIOUS\_STATE。这2个域的值可能取 STATE\_TURNING\_ON, STATE\_ON,STATE\_OFF，STATE\_TURNING\_OFF。

可以使用BluetoothAdapter搜索远端设备，要么通过“搜索设备”，要么通过轮询配 对绑定列表里面的设备。搜索设备通过一个扫描过程搜索周边的蓝牙设备并向他们请 求一些信息(这个过程大概有“discovering”，“inquiring”，“scanning”)。然 而这个被搜索到的设备只有在使能了可发现属性后，才会回应这些请求，回应信息大 概有设备名，类别，唯一的MAC地址。有了这些后，搜索设备的发起方就可以选择一个 设备初始化一个链接操作。一旦和远端设备进行链接，并且是首次链接，一个配对请 求就会自动的呈现给用户。当配对过程完成后，远端设备的基本信息(比如设备名，类 别，MAC)就会被保存下来并能够通过蓝牙API读取，使用一个已知的MAC地址可以在任 何时候发起连接操作而不需要再进行搜索过程。要记住的是已配对和已连接有所不同， 配对意味着两个设备知道互相的存在，拥有一个用于认证的共享的链接密钥 (link-key)，能够建立一个加密的链路。连接意味着设备间当前共享一个RFCOMM通道， 可以互相进行数据传输。当前的android蓝牙API要求设备在建立RFCOMM通道前做配对 操作。(配对是在使用蓝牙API初始化一个加密连接时自动进行)下面的章节描述的是已 经配对设备如何进行寻找设备，或者使用设备搜索过程来搜索设备。

在进行搜索设备前，先轮询已配对设备的集合看看是否有我们需要的设备，调用 BluetoothAdapter的getBondedDevices()即可。它将返回一个已配对设备的集合。比 如，可以轮询所有的设备并使用ArrayAdapter将设备名展示给用户。

Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
    // Loop through paired devices
    for (BluetoothDevice device : pairedDevices) {
    // Add the name and address to an array adapter to show in a ListView
    mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }
}

为了初始化一个连接，仅需要从BluetoothDevice对象中获得MAC地址。

要发起搜索设备，只需要简单的调用startDiscovery().这个过程是异步的，调用这个 方法会立刻返回一个布尔值指示搜索是否成功启动。搜索过程常常先inquiry scan大 约12秒，再使用page scan去获取每个设备的蓝牙设备名。应用程序注册一个 BroadcastReceiver来接收“ACTION\_FOUND”的intent，对于每个搜索到的设备，系 统将会广播这个intent，这个intent会包含额外域EXTRA\_{DEVICE和EXTRA}\_CLASS，对 应着“BluetoothDevice”和“BluetoothClass”。代码如下

// Create a BroadcastReceiver for ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    // When discovery finds a device
    if (BluetoothDevice.ACTION_FOUND.equals(action)) {
        // Get the BluetoothDevice object from the Intent
        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
        // Add the name and address to an array adapter to show in a ListView
        mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }
    }
};
// Register the BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy

警告：做设备搜索是个非常耗费系统资源的操作，一旦发现了目标设备，确保在连接 前使用cancelDiscovery()停止掉搜索过程，并且如果已经保持了一个连接，再搜索操 作势必会减少连接的可用带宽，所以当连接设备时最好不要做搜索操作。

如果愿意本地设备被其他设备搜索到，可使用ACTION\_REQUEST\_{DISCOVERABLE的} intent调用startActivityForResult(Intent，int)，它将向系统发起一个请求进行可 发现性设置。默认将保持120秒时间，也可以通过给intent增加 EXTRA\_DISCOVERABLE\_{DURATION的额外域值来改变这个持续时间}。这个域值最大可设 3600秒，0代表始终可发现。设置为其他值将自动设成120秒，下面代码设置持续时间 为300秒。

Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);

系统将显示一个对话框来请求设备可发现性的用户权限。如果用户选择YES，设备将保 持这个时间的可发现性，activity也将收到一个回调onActivityResult(), 里面会附 带一个等于持续时间的result code。如果选择了NO，或者发送错误，这个result code将是RESULT\_CANCEL。
注意：如果设备没有开启蓝牙，而使能了蓝牙可发现性，将会自动的开启蓝牙。
如果希望在系统的可发现性改变时被通知，可以注册一个BroadcastReceiver来监听 ACTION\_SCAN\_MODE\_{CHANGED的intent}。这个intent将包含两个额外域， EXTRA\_SCAN\_MODE和EXTRA\_PREVIOUS\_SCAN\_MODE，对应着新旧扫描模式。其可能 值有SCAN\_MODE\_CONNECTABLE\_DISCOVERABLE, SCAN\_MODE\_CONNECTABLE, 或 SCAN\_MODE\_NONE，指示了设备要么处于可发现模式，不处于可发现模式但是可以接 收连接请求，既不处于可发现模式也不能接收连接请求。如果只是想初始化一个到远 端设备的链接，可以不用开启可发现模式。使能可发现模式仅仅只是在应用程序需要 主导一个可以接收连接的server socket，因为远端设备在初始化一个连接前必须能够 发现这个设备。

为了应用程序在设备间建立连接，必须实现服务端和客户端机制，因为一个设备必须 开启server socket，另一个设备必须初始化这个连接(使用设备的MAC地址)。当服务 端和客户端在共同的RFCOMM通道都有了已连接的BluetoothSocket则可认为两者已连接。 从此后，每个设备获得输入输出流和数据传输就可开始，这部分要点在后面介绍。
服务端设备和客户端设备获得BluetoothSocket的方式不同。服务端当有一个连接进入 被接受时就获得了，而客户端当开启一个RFCOMM通道给服务端时就获得了。
注意：如果两个设备之前没有配对过，android framework将会自动显示一个配对请求 通知或者对话框给用户(就是那个带密码的对话框)。这样当尝试连接设备是，应用程 序不需要关注设备是否配对过。RFCOMM连接尝试将会被阻塞直到用户成功配对，或者 用户拒绝配对，或者配对失败而超时。

当要连接两个设备时，其中一个必须作为一个服务端保存一个打开的 BluetoothServerSocket。它的目的是监听进来的链接请求，并且当接受时，提供一个 可连接的BluetoothSocket。当BluetoothSocket已经从BluetoothServerSocket获得后， BluetoothServerSocket就可以丢弃了，除非还想介入其他连接。

1. 通过调用listenUsingRfcommWithServiceRecord(String, UUID)来获得 BluetoothServerSocket。这个String是服务的标示名，系统会自动将它写入 SDP(service discovery protocol)的数据库入口(标示名可以随意编写，并且可以 直接采用应用程序的名字)。UUID也同样被包含在数据库入口并且是同客户端的连 接协议的基础。当客户端试图连接这个设备，他会携带一个UUID，唯一代表了它想 连接的服务 。
2. 开始调用accept()来监听连接请求。这是一个阻塞调用。他会立刻返回不管连接是 否被接受。只有当远端设备使用了能够匹配这个注册的在监听的服务端Socket的 UUID来发出连接请求，连接才回被接受。当连接成功后，accept()会返回一个已连 接的BluetoothSocket。
3. 除非想继续接收连接请求，否则调用close().这会释放服务端Socket和它的资源， 但是不会关闭被accept()返回的BluetoothSocket。与TCP/IP不同的是，RFCOMM在 同一时刻每个通道只允许一个连接的客户端，所以在大多数情况在接受了连接请求 后立刻调用BluetoothServiceSocket的close()。

accept()调用不应该在主Activity的UI线程上执行，因为它是阻塞调用会阻止程序的 交互操作。常常使用一个新的线程来做所有的BluetoothServerSocket和 BluetoothSocket的工作。要退出accept()这样的阻塞调用，可以从其他的线程调用 BluetoothServerSocket(或BluetoothSocket)的close()，阻塞调用会立刻返回。注意 BluetoothServerSocket和BluetoothSocket所有的方法都是线程安全的。
代码实例：这里有一个简单线程调用，用于服务模块接收进来的连接。

private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    } catch (IOException e) { }
    mmServerSocket = tmp;
    }

    public void run() {
    BluetoothSocket socket = null;
    // Keep listening until exception occurs or a socket is returned
    while (true) {
        try {
        socket = mmServerSocket.accept();
        } catch (IOException e) {
        break;
        }
        // If a connection was accepted
        if (socket != null) {
        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(socket);
        mmServerSocket.close();
        break;
        }
    }
    }

    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
    try {
        mmServerSocket.close();
    } catch (IOException e) { }
    }
}

在这个例子中，只打算接收一个连接请求，所以一旦连接被接受并且BluetoothSocket被接受，应用程序发送一个已接受的 BluetoothSocket给一个单独的线程，然后关闭BluetoothServerSocket并且跳出循环。 注意当accept()返回BluetoothSocket后，socket就已经连接，所以不应该再调用connect()(像在客户端侧做的那样)。 manageConnectedSocket()在应用中是个虚方法，他会初始化线程来传输数据，如前面介绍说的。 最好一旦监听完连接请求后，就关闭BluetoothServerSocket。在这个例子中，一旦BluetoothSocket()被接受，close()就被调用。当需 要在服务端Socket停止监听时，也可以在线程中提供一个public方法关闭这个private的BluetoothSocket。

为了初始化一个到远端设备(它保持着一个开放的服务端Socket)的连接，必须首先获 得一个代表远端设备的BluetoothDevice对象(上面有介绍)。然后用这个对象获取一个 BluetoothSocket并初始化连接。基本流程如下。

1. 调用createRfcommSocketToServiceRecord(UUID)使用BluetoothDevice获取一个 BluetoothSocket。这样会初始化一个BluetoothSocket连接到BluetoothDevice。 这个传入的UUID和服务端设备调用BluetoothServiceSocket的 listenUsingRfcommWithServiceRecord(String, UUID)使用的UUID匹配。在服务端 和客户端应用程序中使用这个相同的UUID是一种硬编码。
2. 调用connect()初始化连接。一旦调用这个方法，系统将会发起一个SDP搜寻远端设 备以匹配这个UUID。如果搜寻成功并且远端设备接受了这个连接，就会在连接期间 共享这个RFCOMM通道，并且connect()返回。这个方法是阻塞调用。不管任何原因， 如果这个连接失败或者connect()调用超时(大概12秒)，那么它会抛出一个异常。 因为connect()是个阻塞调用，连接过程应该总是在一个独立于主Activity线程的 线程中使用。

注意：应该确保当调用connect()时，设备没有进行搜索操作。如果在继续搜索，那么 连接的尝试将会强烈的减慢并失败。代码实例：下面是初始化蓝牙连接的线程实例。

private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
    // Use a temporary object that is later assigned to mmSocket,
    // because mmSocket is final
    BluetoothSocket tmp = null;
    mmDevice = device;

    // Get a BluetoothSocket to connect with the given BluetoothDevice
    try {
        // MY_UUID is the app's UUID string, also used by the server code
        tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
    } catch (IOException e) { }
    mmSocket = tmp;
    }

    public void run() {
    // Cancel discovery because it will slow down the connection
    mBluetoothAdapter.cancelDiscovery();

    try {
        // Connect the device through the socket. This will block
        // until it succeeds or throws an exception
        mmSocket.connect();
    } catch (IOException connectException) {
        // Unable to connect; close the socket and get out
        try {
        mmSocket.close();
        } catch (IOException closeException) { }
        return;
    }

    // Do work to manage the connection (in a separate thread)
    manageConnectedSocket(mmSocket);
    }

    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
    try {
        mmSocket.close();
    } catch (IOException e) { }
    }
}

当成功的链接两个设备，每个都会拥有一个已连接的BluetoothSocket。从此将会有趣 了因为可以在设备间分享数据。使用BluetoothSocket，这个传输任意数据的过程将会 很简单。

1. 获取InputStream和OutputStream，他们通过Socket处理传输，对应着使用 getInputStream()和getOutputStream()。
2. 使用read(byte[])和write(byte[])读写数据流。

很简单，当然有一些实现细节需要考虑。首先也是最重要的，需要使用一个专门的线 程来对所有的流进行读写。这个很重要，因为read(byte[])和write(byte[])两个方法 都是阻塞调用。read(byte[])调用时会被阻塞，除非从流中读到了一些数据， write(byte[])常常不会被阻塞，但是当远端设备没有调用read(byte[])迅速的读走数 据，并且交互buffer已经满了，而进行流控时会被阻塞。所以线程中的主循环应该专 门用于读取InputStream。线程中可以有一个单独的public方法来初始化OutputStream 的写入。代码实例。

private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
    mmSocket = socket;
    InputStream tmpIn = null;
    OutputStream tmpOut = null;

    // Get the input and output streams, using temp objects because
    // member streams are final
    try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();
    } catch (IOException e) { }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
    }

    public void run() {
    byte[] buffer = new byte[1024];  // buffer store for the stream
    int bytes; // bytes returned from read()

    // Keep listening to the InputStream until an exception occurs
    while (true) {
        try {
        // Read from the InputStream
        bytes = mmInStream.read(buffer);
        // Send the obtained bytes to the UI activity
        mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
            .sendToTarget();
        } catch (IOException e) {
        break;
        }
    }
    }

    /* Call this from the main activity to send data to the remote device */
    public void write(byte[] bytes) {
    try {
        mmOutStream.write(bytes);
    } catch (IOException e) { }
    }

    /* Call this from the main activity to shutdown the connection */
    public void cancel() {
    try {
        mmSocket.close();
    } catch (IOException e) { }
    }
}

构造函数获得一个必要的流，一经执行线程将会等待InputStream接收数据。当read(byte[])从流里返回一些数据时，将会使用父类的一 个成员Handler来将数据发送给主Activity。然后它将返回并且等待更多的数据从流里获得。 对外发送数据就和从主Activity中调用线程的write()方法一样简单，只需要传入需要发送的数据。这个方法会调用write(byte[])来发送 数据给远端设备。 线程的cancel()方法很重要，链接可以在任何时候通过关闭BluetoothSocket来中断。当使用完蓝牙连接时调用它是很有必要的。

从android3.0开始，蓝牙API包含了对蓝牙Profile的支持。Bluetooth Profile是个无 线接口，以蓝牙为基础沟通不同的设备。免提Profile就是一例。对于手机连接到无线 耳机，两个设备都必须支持免提Profile。可以实现接口BluetoothProfile写入一个你 自己的类别来支持一个特定的蓝牙Profile。android蓝牙API提供下面蓝牙Profile的 实现。

1. Headset：耳机；
2. A2DP：Advanced Audio Distribution Profile；
3. Health Device：android4.0以上(API level 14)

下面是使用这些Profile的简单步骤。

1. 获取默认的Adapter(BluetoothAdapter)；
2. 使用getProfileProxy()来和这个Profile相关的代理Profile建立连接。下面的例 子展示代理Profile对象是BluetoothHeadset的一个实例。
3. 设置BluetoothProfile.ServiceListener。这个Listener当连接或者断开连接到服 务端时通知BluetoothProfile进程客户端。
4. 在onServiceConnected()中获得代理Profile对象的句柄。
5. 一旦有代理Profile对象，就可以利用它监视连接状态和做关于Profile的其他操作。

代码实例，下面的代码片段展示了怎样连接到BluetoothHeadset代理对象。

BluetoothHeadset mBluetoothHeadset;

// Get the default adapter
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

// Establish connection to the proxy.
mBluetoothAdapter.getProfileProxy(context, mProfileListener, BluetoothProfile.HEADSET);

private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() {
    public void onServiceConnected(int profile, BluetoothProfile proxy) {
    if (profile == BluetoothProfile.HEADSET) {
        mBluetoothHeadset = (BluetoothHeadset) proxy;
    }
    }
    public void onServiceDisconnected(int profile) {
    if (profile == BluetoothProfile.HEADSET) {
        mBluetoothHeadset = null;
    }
    }
};
// ... call functions on mBluetoothHeadset
// Close proxy connection after use.
mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset);

从android3.0开始，应用程序就能注册接收预定义的由Headset发出的系统通知。

从android4.0开始，引入对健康设备Profile(HDP)的支持。

传感器类型定义在Sensor.java类中。

1. 加速度传感器：Sensor.TYPE\_{ACCELEROMETER};
2. 磁传感器：Sensor.TYPE\_{MAGNETICFIELD};
3. 方向传感器：Sensor.TYPE\_ORIENTATION;
4. 陀螺仪传感器：Sensor.TYPE\_GYROSCOPE;
5. 感光传感器：Sensor.TYPE\_LIGHT;
6. 压力传感器：Sensor.TYPE\_PRESSURE；
7. 温度传感器：Sensor.TYPE\_TEMPERATURE；
8. 接近传感器：Sensor.TYPE\_PROXIMITY；
9. 重力传感器：Sensor.TYPE\_GRAVITY；
10. 线性加速度传感器：Sensor.TYPE\_LINEAR\_ACCELERATION；
11. 旋转传感器：Sensor.TYPE\_ROTATION\_VECTOR；
12. 相对湿度传感器：Sensor.TYPE\_RELATIVE\_HUMIDITY；
13. 环境温度传感器：Sensor.TYPE\_AMBIENT\_TEMPERATURE；
14. 磁场标定传感器：Sensor.TYPE\_MAGNETIC\_FIELD\_UNCALIBRATED；
15. 游戏旋转矢量传感器：Sensor.TYPE\_GAME\_ROTATION\_VECTOR；
16. 陀螺仪标定传感器：Sensor.TYPE\_GYROSCOPE\_UNCALIBRATED；
17. Sensor.TYPE\_SIGNIFICANT\_MOTION
18. Sensor.TYPE\_STEP\_DETECTOR
19. Sensor.TYPE\_STEP\_COUNTER
20. Sensor.TYPE\_GEOMAGNETIC\_ROTATION\_VECTOR
21. Sensor.TYPE\_HEART\_RATE\_MONITOR
22. Sensor.TYPE\_WAKE\_UP\_TILT\_DETECTOR
23. Sensor.TYPE\_WAKE\_GESTURE
24. Sensor.TYPE\_GLANCE\_GESTURE
25. Sensor.TYPE\_PICK\_UP\_GESTURE

1. 向系统申请传感器服务：

   sm = (SensorManager) getSystemService(SENSOR_SERVICE);
   

2. 利用该服务获取传感器适配器：

   accSensor = sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
   if(presSensor == null){
      Log.i(TAG, "no accelerometer");
      return;
   }
   

3. 实例化传感器数据监听器接口：

   SensorEventListener sensorEventListener = new SensorEventListener() {
        @Override
        public void onSensorChanged(SensorEvent event) {
         //todo
        }
        @Override
        public void onAccuracyChanged(Sensor sensor, int accuracy) {
        //todo
        }
   }
   

4. 向传感器服务注册监听器：其中最后一个参数代表多长时间采集一次传感器数据 (单位us)，系统集成了3个时间

   • SensorManager.SENSOR\_DELAY\_FASTEST：尽可能快的获取传感器数据；
   • SensorManager.SENSOR\_DELAY\_NORMAL：一般速度；
   • SensorManager.SENSOR\_DELAY\_GAME：适配游戏；
   • SensorManager.SENSOR\_DELAY\_UI：适配UI；

   sm.registerListener(sensorEventListener, accSensor, SensorManager.SENSOR_DELAY_FASTEST);
   

5. 用完后卸载监听器：

   if(presSensor != null){
        sm.unregisterListener(sensorEventListener);
   }
   

Android的hal，简单来说，就是对Linux内核驱动程序的封装，向上提供接口， 屏蔽低层的实现细节。也就是说，把对硬件的支持分成了两层.

• 用户空间:User Space, hal运行在用户空间;
• 内核空间:Kernel Space, Linux内核驱动程序运行在内核空间;

把hal和内核驱动整合在一起放在内核空间不可行吗？从技术实现的角度来看， 是可以的，然而从商业的角度来看，把对硬件的支持逻辑都放在内核空间，可 能会损害厂家的利益。一般划分.

• Linux内核代码:版权遵循GNU License, 在发布产品时，必须公布源代码;
• Android源代码:版权遵循Apache License, 在发布产品时，无须发布源代码;

如果把对硬件支持的所有代码都放在Linux驱动层，那就意味着发布时要公开驱 动程序的源代码，而公开源代码就意味着把硬件的相关参数和实现都公开了,损 害很大。因此，Android才会想到把对硬件的支持分成hal和内核驱动层，内核 驱动层只提供简单的访问硬件逻辑，例如读写硬件寄存器的通道，至于从硬件 中读写到了什么值，都放在hal中去了，这样就可以把商业秘密隐藏起来了。

也正是由于这个分层的原因，Android被踢出了Linux内核主线代码树中。 Android放在内核空间的驱动程序对硬件的支持是不完整的，把Linux内核移植 到别的机器上去时，由于缺乏hal的支持，硬件就完全不能用了，这也是为什么 说Android是开放系统而不是开源系统的原因。

android从下到上涉及到了android系统多层，如图2所示。

• 硬件驱动层：driver层, 一般实现简单io操作，如iic，uart等;
• 硬件抽象层：hal层，控制driver层的io做些逻辑操作；
• 运行时库：jni层，将下层的c域运行时相互转换到高层的java虚拟机域；
• 应用程序框架层：framework层，利用aidl技术进程通信，从进程角度做划分；
• api：对framework层做进一步抽象，提炼api便于app调用硬件功能；

为了方便描述为Android系统编写内核驱动程序的过程，使用一个虚拟的硬件设 备，这个设备只有一个4字节的寄存器，可读可写。把这个虚拟的设备命名为 “hello”，而这个内核驱动程序也命名为hello驱动程序。其实，Android内核 驱动程序和一般Linux内核驱动程序的编写方法是一样的，都是以Linux模块的 形式实现的。

这里介绍Android系统如何在hal中增加硬件模块来和内核驱动程序交互。完成 内核驱动程序后，可以在Android系统中得到三个文件，这里通过设备文件 /dev/hello来连接硬件抽象层模块和Linux内核驱动程序模块 。

• /dev/hello；
• /sys/class/hello/hello/val；
• /proc/hello。

• PV操作：P源自于荷兰语parsseren，即英语的pass；V源自于荷兰语verhoog，即英 语的increment。P(S)V(S)操作是信号量的两个原子操作，S为信号量semaphore，相 当于一个标志，可以代表一个资源，一个事件等；
• 变量的非原子操作：更新结构体的多个成员变量，或者是更新的变量其长度超过了 架构体系的自然长度(比如，更新一个16位机上的32位变量)均是非原子操作，如果 这样的操作被中断，将可能导致数据损坏或者丢失；
• 函数重入：如果一个函数可以安全的被多个任务调用，或在任务与中断中均可调用， 则这个函数是可以重入的；一般每个任务都单独维护自己的栈空间及其自身在内存 寄存器组中的值。如果一个函数除访问自己栈空间上分配的数据或是内核寄存器中 的数据外，会访问其他任何数据，则这个函数是不可重入的。
• 临界区：当某资源需要被多个任务访问使用时，此资源叫临界区，开始访问此资源， 表示进入临界区；如果要进入临界区，一般安全的做饭是讲所有的中断或者优先级 关闭，防止在访问临界区资源时，被打断，并且访问临界区资源的程序必须要尽快 结束；
• 二值信号量：用于同步，可以给某资源配置一个二值信号量，当一个任务要访问某 资源时，如果此二值信号量不可用，则该任务不可访问该资源，可以通过在中断中 给予(GIVE)此信号量，则此任务就可以获得(TAKE)该信号量，访问该资源，达到同 步作用，用于同步的信号量，用完后便丢弃，不再归还；
• 互斥信号量：用于访问一些具有互斥效果的资源，类似二值信号量，当某任务需要 访问某资源时，需要先获得(TAKE)该资源的令牌(信号量)，用完后，再归还(GIVE) 该资源的令牌，一个任务只有获得了该资源的令牌后才能访问该资源，否则不允许 访问进入阻塞状态，用于互斥的信号量必须归还；
• 优先级翻转：指两个不同优先级的任务在允许时，低优先级的任务获得了某资源的 互斥信号量，并未执行完，此时高优先级的任务也开始运行，并且也要使用该资源， 从而获取该资源的互斥信号量，然后此时低优先级的任务并未释放该互斥信号量， 则高优先级的任务进入阻塞状态，等待低优先级的任务执行完释放信号量，从而产 生了高优先级的任务等待低优先级任务的不合理现象；
• 死锁：当两个任务都在等待被对方持有的资源时，两个任务都无法继续执行，这种 情况被称为死锁；
• 守护任务：守护任务提供了一个比较好的方法来实现互斥功能，而不用担心会发生 优先级翻转和死锁，守护任务是对某个资源具有唯一所有权的任务，只有守护任务 才可直接访问其守护的资源，其他任何任务只能间接的通过守护任务提供访问服务；