关于Android编程之光线传感器用法详解和光线传感器程序的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于android–方向传感器和加速度传感器之间的差异、Android传感器--光照传

关于Android编程之光线传感器用法详解和光线传感器程序的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于android – 方向传感器和加速度传感器之间的差异、Android 传感器--光照传感器详解及使用、Android 传感器开发详解、Android 如何获取传感器的数据方法详解等相关知识的信息别忘了在本站进行查找喔。

• Android编程之光线传感器用法详解（光线传感器程序）
• android – 方向传感器和加速度传感器之间的差异
• Android 传感器--光照传感器详解及使用
• Android 传感器开发详解
• Android 如何获取传感器的数据方法详解

Android编程之光线传感器用法详解（光线传感器程序）

本文实例讲述了Android编程之光线传感器用法。分享给大家供大家参考，具体如下：

Android手机自带光线传感器，通常我们手机的屏幕自动亮度都是用光线传感器来实现的。该传感器在前置摄像头附近，此外，还有一个距离传感器。这里主要讲解如何使用Android手机的光线传感器。

获得感应器服务

Android开发中要使用光线传感器，需要先获得系统传感器服务Context.SENSOR_SERVICE，获得方法如下：

SensorManager senserManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

获得光线传感器

SensorManager是系统传感器服务，是系统所有传感器的管理器。通过它，我们获得制定类型的传感器，获得光线传感器的方法如下：

Sensor sensor = senserManager.getDefaultSensor(Sensor.TYPE_LIGHT);

代码中Sensor.TYPE_LIGHT是指光线传感器。

Sensor中还有许多其他的传感器，这里暂不讨论。

编写监听器

有了sensor对象之后，我们需要对该感应器进行监听，使用 SensorEventListener 接口，主要有onSensorChanged()和onAccuracyChanged()这两个方法，代码如下：

SensorEventListener listener = new SensorEventListener() {
  @Override
  public void onAccuracyChanged(Sensor sensor,int accuracy) {
    //当传感器精度发生变化时
  }
  @Override
  public void onSensorChanged(SensorEvent event) {
    //当传感器监测到的数值发生变化时
  }
};

注册监听器

接下来我们还需要调用SensorManager的registerListener()方法来注册SensorEventListener才能使其生效，registerListener()方法包含三个参数：SensorEventListener实例，Sensor的实例和传感器输出信息更新速率。

传感器输出信息更新速率有：

SENSOR_DELAY_UI
SENSOR_DELAY_norMAL
SENSOR_DELAY_GAME
SENSOR_DELAY_FASTEST

总共四种值可选，它们的更新速率是依次递增的。

注册SensorEventListener的代码如下：

senserManager.registerListener(listener,senser,SensorManager.SENSOR_ DELAY_norMAL);

注销监听器

最后，当程序退出或传感器使用完毕时，一定要调用unregisterListener()方法将使用的资源释放掉，如下所示：

sensorManager.unregisterListener(listener);

DEMO示例：

package com.test.sensor.light;
import android.app.Activity;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.widget.TextView;
public class MainActivity extends Activity {
  //感应器管理器
  private SensorManager sensorManager;
  //光线亮度
  private TextView light;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //当前Activity的内容是一个TextView
    light = new TextView(this);
    setContentView(light);
    //获得感应器服务
    sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    //获得光线感应器
    Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    //注册监听器
    sensorManager.registerListener(listener,sensor,SensorManager. SENSOR_DELAY_norMAL);
  }
  //Activity被销毁
  @Override
  protected void onDestroy() {
    super.onDestroy();
    //注销监听器
    if (sensorManager != null) {
      sensorManager.unregisterListener(listener);
    }
  }
  //感应器事件监听器
  private SensorEventListener listener = new SensorEventListener() {
    //当感应器精度发生变化
    @Override
    public void onAccuracyChanged(Sensor sensor,int accuracy) {
    }
    //当传感器监测到的数值发生变化时
    @Override
    public void onSensorChanged(SensorEvent event) {
      // values数组中第一个值就是当前的光照强度
      float value = event.values[0];
      light.setText("当前亮度 " + value + " lx(勒克斯)");
    }
  };
}

备注：开发使用光线传感器无需声明Android Manifest权限

另外，对于一些程序，在改变当前程序屏幕亮度的时候，可以考虑加入光照传感器的判断。

因为大部分这些程序，会出现这样的一个问题，当（在非自动亮度调节模式）设定屏幕亮度为一个值时，再设置为自动亮度调节模式的时候是无效的。

更多关于Android相关内容感兴趣的读者可查看本站专题：《Android开发入门与进阶教程》、《Android视图View技巧总结》、《Android编程之activity操作技巧总结》、《Android操作SQLite数据库技巧总结》、《Android操作json格式数据技巧总结》、《Android资源操作技巧汇总》及《Android控件用法总结》

希望本文所述对大家Android程序设计有所帮助。

android – 方向传感器和加速度传感器之间的差异

Android 传感器--光照传感器详解及使用

Android 设备中有许多传感器，其中有一个传感器控制着你屏幕亮度的变化。当你在很暗的地方使用手机，你设备的屏幕会自动调暗，从而保护你眼睛。

起着这样作用，Android是通过一款光照传感器来获取你周围环境亮度的变化。光照传感器一般在手机的顶部的位置。

要在程序中使用这款传感器

（1）首先要获取SensorManager传感器管理器服务：SensorManager sensorManager=(SensorManager)getSystemService(Context.SENSOR_SERVICE);

（2）获取光照传感器：Sensor liaghtSensor=sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)//Sensor.TYPE_LIGHT 代表光照传感器

（3）注册和监视光照传感器：

sensorManager.registerListener(new SensorEventListener() {
 @Override
 public void onSensorChanged(SensorEvent event) {
//监视传感器的改变

//accuracy 传感器的精度 通过event.accuracy获取

//values 传感器传回的数值 如event.values[0] 获取光线强度lux

//timestamp 传感器事件发生的时间（以纳秒为单位）
}

 @Override
 public void onAccuracyChanged(Sensor sensor,int accuracy) {
//对传感器精度的改变做出反应
}
 },sensor,SensorManager.SENSOR_DELAY_norMAL);

一个简单的获取光照传感器光线强度lux的代码：

public class MainActivity extends Activity {

  private TextView value_tv;

  private SensorManager sensorMamager;

  private Sensor sensor;

  @Override

  protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    value_tv=(TextView) findViewById(R.id.value_tv);

    //获取SensorManager对象

    sensorMamager=(SensorManager) getSystemService(SENSOR_SERVICE);

    //获取Sensor对象

    sensor=sensorMamager.getDefaultSensor(Sensor.TYPE_LIGHT);

    sensorMamager.registerListener(new SensorEventListener() {

       

      @Override

      public void onSensorChanged(SensorEvent event) {

         //获取精度 

        float acc = event.accuracy; 

        //获取光线强度 

        float lux = event.values[0];  

        value_tv.setText("acc:"+acc+";"+"lux："+lux);

      }

       

      @Override

      public void onAccuracyChanged(Sensor sensor,int accuracy) {

        // Todo 自动生成的方法存根

      }

    },SensorManager.SENSOR_DELAY_norMAL);

  }

} 

对于一些程序，在改变当前程序屏幕亮度的时候，可以考虑加入光照传感器的判断。

因为大部分这些程序，会出现这样的一个问题，当（在非自动亮度调节模式）设定屏幕亮度为一个值时，再设置为自动亮度调节模式的时候是无效的。

 以上就是对Android 传感器 光照传感的资料整理，后续继续补充相关资料，谢谢大家对本站的支持！

Android 传感器开发详解

• 前言
• 使用
  • 第一步
  • 第二步
  • 第三步
• 方向传感器
• 陀螺仪传感器
• 磁场传感器
• 重力传感器
• 线性加速度传感器
• 温度传感器
• 光传感器
• 压力传感器
• 心率传感器
• 实例获取各传感器数据并展示

前言

Android系统提供了对传感器的支持，如果手机的硬件提供了这些传感器的话，那么我们就可以通过代码获取手机外部的状态。比如说手机的摆放状态、外界的磁场、温度和压力等等。 
对于我们开发者来说，开发传感器十分简单。只需要注册监听器，接收回调的数据就行了，下面来详细介绍下各传感器的开发。

使用

第一步

// 获取传感器管理对象
SensorManager mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

• 1
• 2

• 1
• 2

第二步

// 获取传感器的类型(TYPE_ACCELEROMETER:加速度传感器)
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

• 1
• 2

• 1
• 2

这里我们除了可以获取加速度传感器之外，还可以获取其他类型的传感器，如： 
* Sensor.TYPE_ORIENTATION：方向传感器。 
* Sensor.TYPE_GYROSCOPE：陀螺仪传感器。 
* Sensor.TYPE_MAGNETIC_FIELD：磁场传感器。 
* Sensor.TYPE_GRAVITY：重力传感器。 
* Sensor.TYPE_LINEAR_ACCELERATION：线性加速度传感器。 
* Sensor.TYPE_AMBIENT_TEMPERATURE：温度传感器。 
* Sensor.TYPE_LIGHT：光传感器。 
* Sensor.TYPE_PRESSURE：压力传感器。

第三步

在onResume()方法中监听传感器传回的数据：

@Override
protected void onResume() {
    super.onResume();
    // 为加速度传感器注册监听器
    mSensorManager.registerListener(new SensorEventListener() {
        // 当传感器的值改变的时候回调该方法
        @Override
        public void onSensorChanged(SensorEvent event) {

        }
        // 当传感器精度发生改变时回调该方法
        @Override
        public void onAccuracyChanged(Sensor sensor, int accuracy) {

        }
    }, mSensor, SensorManager.SENSOR_DELAY_GAME);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

其中，registerListener(SensorEventListener listener, Sensor sensor,int samplingPeriodUs)的三个参数说明如下： 
listener：监听传感器时间的监听器，该监听器需要实现SensorEventListener接口。 
sensor：传感器对象。 
samplingPeriodUs：指定获取传感器频率，一共有如下几种： 
* SensorManager.SENSOR_DELAY_FASTEST：最快，延迟最小，同时也最消耗资源，一般只有特别依赖传感器的应用使用该频率，否则不推荐。 
* SensorManager.SENSOR_DELAY_GAME：适合游戏的频率，一般有实时性要求的应用适合使用这种频率。 
* SensorManager.SENSOR_DELAY_NORMAL：正常频率，一般对实时性要求不高的应用适合使用这种频率。 
* SensorManager.SENSOR_DELAY_UI：适合普通应用的频率，这种模式比较省电，而且系统开销小，但延迟大，因此只适合普通小程序使用。

并在onStop()方法中取消注册：

@Override
protected void onStop() {
    super.onStop();
    // 取消监听
    mSensorManager.unregisterListener(this);
}

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

简单3步，就完成了监听加速度传感器的开发，是不是so easy？

下面一个列子，演示了完整的监听加速度传感器的开发，并将结果显示到屏幕上：

public class MainActivity extends AppCompatActivity implements SensorEventListener{

    private SensorManager mSensorManager;
    private TextView mTxtValue;
    private Sensor mSensor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTxtValue = (TextView) findViewById(R.id.txt_value);

        // 获取传感器管理对象
        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        // 获取传感器的类型(TYPE_ACCELEROMETER:加速度传感器)
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 为加速度传感器注册监听器
        mSensorManager.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_GAME);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 取消监听
        mSensorManager.unregisterListener(this);
    }

    // 当传感器的值改变的时候回调该方法
    @Override
    public void onSensorChanged(SensorEvent event) {
        float[] values = event.values;
        StringBuilder sb = new StringBuilder();
        sb.append("X方向的加速度：");
        sb.append(values[0]);
        sb.append("\nY方向的加速度：");
        sb.append(values[1]);
        sb.append("\nZ方向的加速度：");
        sb.append(values[2]);
        mTxtValue.setText(sb.toString());
    }

    // 当传感器精度发生改变时回调该方法
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52

运行结果： 

方向传感器

方向传感器用于感应手机的摆放位置，它给我们返回了三个角度，这三个角度可以确定手机的摆放状态。 
* 第一个角度：表示手机顶部朝向与正北方的夹角。当手机绕着Z轴旋转时，该角度值发生改变。比如，当该角度为0度时，表明手机顶部朝向正北；该角度为90度时，表明手机顶部朝向正东；该角度为180度时，表明手机朝向正南；该角度为270度时，表明手机顶部朝向正西。 
* 第二个角度：表示手机顶部或尾部翘起的高度。当手机绕着X轴倾斜时，该角度值发生变化，该角度的取值范围是-180~180度。假设手机屏幕朝上水平放在桌子上，如果桌子是完全水平的，该角度值应该是0度。假如从手机顶部开始抬起，直到将手机沿X轴旋转180度(屏幕向下水平放在桌子上)，在这个旋转的过程中，该角度值会从0度变化到-180度。也就是说，从手机顶部抬起时，该角度的值会逐渐减少，直到等于-180度；如果从手机底部开始抬起，直到将手机沿X轴旋转180度(屏幕向下水平放在桌子上)，该角度的值会从0度变化到180度，也就是说，从手机底部抬起时，该角度的值会逐渐增大，直到等于180度。 
* 第三个角度：表示手机左侧或右侧翘起的角度。当手机绕着Y轴倾斜时，该角度值发生改变。该角度的取值范围是：-90~90度。假设将手机屏幕朝上水平放在桌面上，如果桌面是完全水平的，该角度应该为0度。如果将手机从左侧开始慢慢抬起，知道将手机沿着Y轴旋转90度(手机与桌面垂直)，在这个旋转的过程中，该角度值会从0度变化到-90度。也就是说，从手机左侧开始抬起时，该角度的值会逐渐的减少，知道等于-90度。如果从手机的右侧抬起，则刚好相反，会从0度变化，直到90度。

通过在应用程序中使用方向传感器，可以实现如：地图导航、水平仪、指南针等应用。

陀螺仪传感器

陀螺仪传感器用于感应手机的旋转速度。陀螺仪传感器给我们返回了当前设备的X、Y、Z三个坐标轴（坐标系统与加速度传感器一模一样）的旋转速度。旋转速度的单位是弧度/秒，旋转速度为： 
正值代表逆时针旋转，负值代表顺时针旋转。关于返回的三个角速度说明如下： 
* 第一个值：代表该设备绕X轴旋转的角速度。 
* 第二个值：代表该设备绕Y轴旋转的角速度。 
* 第三个值：代表该设备绕Z轴旋转的角速度。

磁场传感器

磁场感应器主要读取设备周围的磁场强度。即便是设备周围没有任何直接的磁场，设备也会始终处于地球的磁场中，除非你不在地球。。随着手机设备摆放状态的改变，周围磁场在手机的X、Y、Z方向上的影响也会发生改变。磁场传感器会返回三个数据，分别代表周围磁场分解到X、Y、Z三个方向的磁场分量，磁场数据的单位是微特斯拉。

重力传感器

重力传感器会返回一个三维向量，这个三维向量可显示重力的方向和强度。重力传感器的坐标系统和加速度传感器的坐标系统相同。

线性加速度传感器

线性加速度传感器返回一个三维向量显示设备在各个方向的加速度（不包含重力加速度）。线性加速度传感器的坐标系统和加速度传感器的坐标系统相同。 
线性加速度传感器、重力传感器、加速度传感器，这三者输出值的关系如下： 
加速度传感器 = 重力传感器　+　线性加速度传感器。

温度传感器

温度传感器用于获取设备所处环境的温度。温度传感器会返回一个数据，代表手机设备周围的温度，单位是摄氏度。

光传感器

光传感器用于获取设备周围光的强度。光传感器会返回一个数据，代表手机周围光的强度，单位是勒克斯。

压力传感器

压力传感器用于获取设备周围压力的大小。压力传感器会返回一个数据，代表设备周围压力的大小。

心率传感器

心率传感器是在5.0之后新增的一个传感器，用于返回佩戴设备的人每分钟的心跳次数。该传感器返回的数据准确性可以通过SensorEvent的accuracy进行判断，如果该属性值为：SENSOR_STATUS_UNRELIABLE或SENSOR_STATUS_NO_CONTACT，则表明传感器返回的数据是不太可靠的，应该丢弃。 
在使用心率传感器时，需要增加如下权限：

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

• 1

• 1

实例（获取各传感器数据并展示）

public class MainActivity extends AppCompatActivity implements SensorEventListener{

    private SensorManager mSensorManager;
    private TextView mTxtValue1;
    private TextView mTxtValue2;
    private TextView mTxtValue3;
    private TextView mTxtValue4;
    private TextView mTxtValue5;
    private TextView mTxtValue6;
    private TextView mTxtValue7;
    private TextView mTxtValue8;
    private TextView mTxtValue9;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTxtValue1 = (TextView) findViewById(R.id.txt_value1);
        mTxtValue2 = (TextView) findViewById(R.id.txt_value2);
        mTxtValue3 = (TextView) findViewById(R.id.txt_value3);
        mTxtValue4 = (TextView) findViewById(R.id.txt_value4);
        mTxtValue5 = (TextView) findViewById(R.id.txt_value5);
        mTxtValue6 = (TextView) findViewById(R.id.txt_value6);
        mTxtValue7 = (TextView) findViewById(R.id.txt_value7);
        mTxtValue8 = (TextView) findViewById(R.id.txt_value8);
        mTxtValue9 = (TextView) findViewById(R.id.txt_value9);

        // 获取传感器管理对象
        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 为加速度传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_GAME);
        // 为方向传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION), SensorManager.SENSOR_DELAY_GAME);
        // 为陀螺仪传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE), SensorManager.SENSOR_DELAY_GAME);
        // 为磁场传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD), SensorManager.SENSOR_DELAY_GAME);
        // 为重力传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY), SensorManager.SENSOR_DELAY_GAME);
        // 为线性加速度传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION), SensorManager.SENSOR_DELAY_GAME);
        // 为温度传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_AMBIENT_TEMPERATURE), SensorManager.SENSOR_DELAY_GAME);
        // 为光传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT), SensorManager.SENSOR_DELAY_GAME);
        // 为压力传感器注册监听器
        mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE), SensorManager.SENSOR_DELAY_GAME);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 取消监听
        mSensorManager.unregisterListener(this);
    }

    // 当传感器的值改变的时候回调该方法
    @Override
    public void onSensorChanged(SensorEvent event) {
        float[] values = event.values;
        // 获取传感器类型
        int type = event.sensor.getType();
        StringBuilder sb;
        switch (type){
            case Sensor.TYPE_ACCELEROMETER:
                sb = new StringBuilder();
                sb.append("加速度传感器返回数据：");
                sb.append("\nX方向的加速度：");
                sb.append(values[0]);
                sb.append("\nY方向的加速度：");
                sb.append(values[1]);
                sb.append("\nZ方向的加速度：");
                sb.append(values[2]);
                mTxtValue1.setText(sb.toString());
                break;
            case Sensor.TYPE_ORIENTATION:
                sb = new StringBuilder();
                sb.append("\n方向传感器返回数据：");
                sb.append("\n绕Z轴转过的角度：");
                sb.append(values[0]);
                sb.append("\n绕X轴转过的角度：");
                sb.append(values[1]);
                sb.append("\n绕Y轴转过的角度：");
                sb.append(values[2]);
                mTxtValue2.setText(sb.toString());
                break;
            case Sensor.TYPE_GYROSCOPE:
                sb = new StringBuilder();
                sb.append("\n陀螺仪传感器返回数据：");
                sb.append("\n绕X轴旋转的角速度：");
                sb.append(values[0]);
                sb.append("\n绕Y轴旋转的角速度：");
                sb.append(values[1]);
                sb.append("\n绕Z轴旋转的角速度：");
                sb.append(values[2]);
                mTxtValue3.setText(sb.toString());
                break;
            case Sensor.TYPE_MAGNETIC_FIELD:
                sb = new StringBuilder();
                sb.append("\n磁场传感器返回数据：");
                sb.append("\nX轴方向上的磁场强度：");
                sb.append(values[0]);
                sb.append("\nY轴方向上的磁场强度：");
                sb.append(values[1]);
                sb.append("\nZ轴方向上的磁场强度：");
                sb.append(values[2]);
                mTxtValue4.setText(sb.toString());
                break;
            case Sensor.TYPE_GRAVITY:
                sb = new StringBuilder();
                sb.append("\n重力传感器返回数据：");
                sb.append("\nX轴方向上的重力：");
                sb.append(values[0]);
                sb.append("\nY轴方向上的重力：");
                sb.append(values[1]);
                sb.append("\nZ轴方向上的重力：");
                sb.append(values[2]);
                mTxtValue5.setText(sb.toString());
                break;
            case Sensor.TYPE_LINEAR_ACCELERATION:
                sb = new StringBuilder();
                sb.append("\n线性加速度传感器返回数据：");
                sb.append("\nX轴方向上的线性加速度：");
                sb.append(values[0]);
                sb.append("\nY轴方向上的线性加速度：");
                sb.append(values[1]);
                sb.append("\nZ轴方向上的线性加速度：");
                sb.append(values[2]);
                mTxtValue6.setText(sb.toString());
                break;
            case Sensor.TYPE_AMBIENT_TEMPERATURE:
                sb = new StringBuilder();
                sb.append("\n温度传感器返回数据：");
                sb.append("\n当前温度为：");
                sb.append(values[0]);
                mTxtValue7.setText(sb.toString());
                break;
            case Sensor.TYPE_LIGHT:
                sb = new StringBuilder();
                sb.append("\n光传感器返回数据：");
                sb.append("\n当前光的强度为：");
                sb.append(values[0]);
                mTxtValue8.setText(sb.toString());
                break;
            case Sensor.TYPE_PRESSURE:
                sb = new StringBuilder();
                sb.append("\n压力传感器返回数据：");
                sb.append("\n当前压力为：");
                sb.append(values[0]);
                mTxtValue9.setText(sb.toString());
                break;
        }
    }

    // 当传感器精度发生改变时回调该方法
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165

运行结果： 

Android 如何获取传感器的数据方法详解

1 传感器简介

传感器 Sensor 是一种检测装置，能感受到被测量的信息，并能将感受到的信息，按一定规律变换成为电信号或其他所需形式的信息输出，以满足信息的传输、处理、存储、显示、记录和控制等要求。 Android 提供了对设备传感器的支持，只要 Android 设备的硬件提供了这些传感器，Android 应用可以通过传感器来获取设备的外界条件，包括手机的运行状态、当前摆放的方向等。Android 系统还提供了驱动程序去管理这些传感器硬件，可以通过监听器的方式监听传感器硬件感知到的外部环境的变化。

Android 平台支持三大类传感器：

有些传感器基于硬件，有些基于软件。基于硬件的传感器是内置在手机或平板设备中的物理组件。这类传感器通过直接测量特定的环境属性（如加速度、地磁场强度或角度变化）来采集数据。基于软件的传感器不是物理设备，它们只是模仿基于硬件的传感器。基于软件的传感器从一个或多个基于硬件的传感器获取数据，有时被称为虚拟传感器或合成传感器。比如线性加速度传感器和重力传感器就是基于软件的传感器。

传感器弃用说明：

• Android 2.2（API 级别 8）已弃用方向传感器，Android 4.4W（API 级别 20）已弃用此传感器类型 TYPE_ORIENTATION。替代方法见后面示例代码。
• 温度传感器已在 Android 4.0（API 级别 14）中弃用，不同设备具有不同的实现。

2 传感器的使用

2.1 获取传感器服务

Android 中内置了很多系统级的服务，用于给开发人员使用，而传感器也是通过传感器服务 SensorManager 来管理的。而在 Android 组件中获取系统服务，使用方法 Context.getSystemService(String) 即可，它的参数均以 static final 的方式定义在 Context 中，而获取 SensorManager 需要传入 Context.SENSOR_SERVICE。

SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

2.2 获取待监听的传感器

传感器服务管理设备上所有的传感器，所以需要获取待监听的传感器。 可以通过在 getSensorList() 方法中传入 TYPE_ALL 来获取设备上的所有传感器：

List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

也可以通过指定的 type 参数获取到相对应的传感器，如果设备上有多个特定类型的传感器，则必须将其中一个指定为默认传感器。如果没有指定默认传感器，则该方法调用会返回 null，这表示设备没有该类型的传感器。

Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

注意使用前先判断传感器是否存在。

运行时检测。

if (sensor != null) {
    //传感器存在
} else {
    //传感器不存在
}

使用清单文件来限定目标设备必须带有指定传感器配置。

<uses-feature
    android:name="android.hardware.sensor.accelerometer"
    android:required="true" />

对于某一个传感器，它的一些具体信息的获取方法如下：

• getMaximumRange() 最大取值范围
• getName() 设备名称
• getPower() 功率
• getResolution() 精度
• getType() 传感器类型
• getVentor() 设备供应商
• getVersion() 设备版本号

2.3 注册传感器的监听器

获得 SensorManager 和 Sensor 对象之后，就可以为其 Sensor 注册监听器了。为传感器注册监听器，使用 SensorManager.registerListener() 方法即可，它存在多个重载方法，但是有些方法已经过时了，下面提供一个常用的方法：

boolean registerListener(SensorEventListener listener,Sensor sensor,int rateUs)

上面方法参数的意义：listener：传感器的监听器、sensor：待监听的传感器、rateUs：传感器的采样率。 从 registerListener() 方法可以看出，它需要传递一个 SensorEventListener 对象，它就是传感器的监听器，其中包含两个方法，需要开发人员去实现它：

• void onSensorChanged(SensorEvent event)：当传感器感应的值发生变化时回调。
• void onAccuracyChanged(Sensor sensor,int accuracy)：当传感器精度发生变化时回调。 对于上面两个方法，传感器的精度一般是不会发生改变的，所以我们一般主要的代码量在 onSensorChanged()中。

在 onSensorChanged(SensorEvent event) 方法中有一个参数 event，通过 event 可以获取传感器的类型以及传感器的数据。

• 获取传感器的类型：event.sensor.getType()
• 获取传感器的数据：event.values[i]，i为0,1,2...，不同传感器，event.values[i] 对应的数据不同。以加速度传感器为例，values[0] 表示x轴上的加速度，values[1] 表示y轴上的加速度，values[2] 表示z轴上的加速度。

registerListener() 方法还有一个 rateUs 的参数，它表示监听传感器改变的采样率，就是从传感器获取值的频率。它被定义以 static final 的形式定义在 SensorManager 中，方便我们直接使用，它定义了如下几个参数：

Android 为我们提供了这几个采样率的参数，方便我们使用。但对于选择那种采样率而言，并不是越快越好，要参照实际开发的应用的情况来说，采样率越大，将越耗费资源，包括电量、CPU 等，所以要根据实际情况选择，毕竟再强大的应用，如果造成设备续航能力的降低，也是会被用户所不喜的。

2.4 注销传感器的监听器

当使用完传感器之后，需要为其注销监听器，因为传感器的监听器并不会因为应用的结束而自行释放资源，需要开发人员在适当的时候主动注销。注销传感器监听器使用 SensorManager.unregisterListener() 方法即可，和监听器的注册方法一样，它也具有多个重载的方法，但是有一些已经被弃用了，下面介绍一个常用的：

void unregisterListener(SensorEventListener listener)

3 示例代码

Java 代码如下：

public class MainActivity extends AppCompatActivity {
    private final String TAG = "sensor-sample";
    private TextView mAccelerometerSensorTextView;
    private TextView mMagneticSensorTextView;
    private TextView mGyroscopeSensorTextView;
    private TextView mOrientationSensorTextView;
    private SensorManager mSensorManager;
    private MySensorEventListener mMySensorEventListener;
    private float[] mAccelerometerReading = new float[3];
    private float[] mMagneticFieldReading = new float[3];
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mAccelerometerSensorTextView = findViewById(R.id.accelerometer_sensor);
        mMagneticSensorTextView = findViewById(R.id.magnetic_sensor);
        mGyroscopeSensorTextView = findViewById(R.id.gyroscope_sensor);
        mOrientationSensorTextView = findViewById(R.id.orientation_sensor);

        this.mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        this.mMySensorEventListener = new MySensorEventListener();
    }
    @Override
    protected void onResume() {
        super.onResume();
        if (mSensorManager == null) {
            return;
        }
        Sensor accelerometerSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometerSensor != null) {
            //register accelerometer sensor listener
            mSensorManager.registerListener(mMySensorEventListener, accelerometerSensor, SensorManager.SENSOR_DELAY_UI);
        } else {
            Log.d(TAG, "Accelerometer sensors are not supported on current devices.");
        }
        Sensor magneticSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticSensor != null) {
            //register magnetic sensor listener
            mSensorManager.registerListener(mMySensorEventListener, magneticSensor, SensorManager.SENSOR_DELAY_UI);
        } else {
            Log.d(TAG, "Magnetic sensors are not supported on current devices.");
        }
        Sensor gyroscopeSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
        if (gyroscopeSensor != null) {
            //register gyroscope sensor listener
            mSensorManager.registerListener(mMySensorEventListener, gyroscopeSensor, SensorManager.SENSOR_DELAY_UI);
        } else {
            Log.d(TAG, "Gyroscope sensors are not supported on current devices.");
        }
    }
    @Override
    protected void onPause() {
        super.onPause();
        if (mSensorManager == null) {
            return;
        }
        //unregister all listener
        mSensorManager.unregisterListener(mMySensorEventListener);
    }

    /*
    This orientation sensor was deprecated in Android 2.2 (API level 8), and this sensor type was deprecated in Android 4.4W (API level 20).
    The sensor framework provides alternate methods for acquiring device orientation.
     */
    private void calculateOrientation() {
        final float[] rotationMatrix = new float[9];
        SensorManager.getRotationMatrix(rotationMatrix, null, mAccelerometerReading, mMagneticFieldReading);

        final float[] orientationAngles = new float[3];
        SensorManager.getOrientation(rotationMatrix, orientationAngles);
        Log.d(TAG, "orientation data[x:" + orientationAngles[0] + ", y:" + orientationAngles[1] + ", z:" + orientationAngles[2] + "]");
        mOrientationSensorTextView.setText("[x:" + orientationAngles[0] + ", y:" + orientationAngles[1] + ", z:" + orientationAngles[2] + "]");
    }
    private class MySensorEventListener implements SensorEventListener {
        @Override
        public void onSensorChanged(SensorEvent event) {
            if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                mAccelerometerReading = event.values;
                Log.d(TAG, "accelerometer data[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
                mAccelerometerSensorTextView.setText("[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
            } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
                mMagneticFieldReading = event.values;
                Log.d(TAG, "magnetic data[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
                mMagneticSensorTextView.setText("[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
            } else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
                Log.d(TAG, "gyroscope data[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
                mGyroscopeSensorTextView.setText("[x:" + event.values[0] + ", y:" + event.values[1] + ", z:" + event.values[2] + "]");
            }
            calculateOrientation();
        }
        @Override
        public void onAccuracyChanged(Sensor sensor, int accuracy) {
            Log.d(TAG, "onAccuracyChanged:" + sensor.getType() + "->" + accuracy);
        }

    }
}

运行效果如下：

到此这篇关于Android 如何获取传感器的数据的文章就介绍到这了,更多相关Android 获取传感器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

今天的关于Android编程之光线传感器用法详解和光线传感器程序的分享已经结束，谢谢您的关注，如果想了解更多关于android – 方向传感器和加速度传感器之间的差异、Android 传感器--光照传感器详解及使用、Android 传感器开发详解、Android 如何获取传感器的数据方法详解的相关知识，请在本站进行查询。