android 计步器代码(prdometer)

package com.example.pedometer;

import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Handler.Callback;
import android.os.Message;
import android.os.Messenger;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.util.Log;
import android.widget.TextView;

public class MainActivity extends Activity implements Callback {

private static final String TAG="nsc";
public static final int MSG_FROM_CLIENT = 0;
public static final int MSG_FROM_SERVER = 1;//返回服务
public static final int REQUEST_SERVER = 2;//取消服务
private long TIME_INTERVAL = 500;

private TextView text;
private Handler delayHandler;
private Messenger messenger;
private Messenger mGetReplyMessenger = new Messenger(new Handler(this));

ServiceConnection conn = new ServiceConnection() {

@Override
public void onServiceDisconnected(ComponentName arg0) {
// TODO Auto-generated method stub

}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
try{
messenger = new Messenger(service);
Message msg = Message.obtain(null,MSG_FROM_CLIENT);
msg.replyTo = mGetReplyMessenger;//replyTo消息管理器
Log.d(TAG,"msg ="+ msg);
messenger.send(msg);//发送消息出去
}catch(Exception e){
e.printStackTrace();
}
}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
initUI();//初始化ui和启动线程
setupService();//启动服务
}

/**
* 启动服务
*/
private void setupService() {
// TODO Auto-generated method stub
Intent intent = new Intent(this,StepService.class);
//使用这个ServiceConnection，客户端可以绑定到一个service，通过把它传给bindService()
//第一个bindService()的参数是一个明确指定了要绑定的service的Intent．
//第二个参数是ServiceConnection对象．
//第三个参数是一个标志，它表明绑定中的操作．它一般应是BIND_AUTO_CREATE，这样就会在service不存在时创建一个．其它可选的值是BIND_DEBUG_UNBIND和BIND_NOT_FOREGROUND,不想指定时设为0即可．。
bindService(intent, conn, BIND_AUTO_CREATE);//BIND_AUTO_CREATE =1
startService(intent);
}

private void initUI() {
// TODO Auto-generated method stub
text = (TextView)findViewById(R.id.text);
delayHandler = new Handler(this);
}

@Override
public boolean handleMessage(Message msg) {
// TODO Auto-generated method stub
switch(msg.what){
case MSG_FROM_SERVER:
Log.d(TAG,"text="+ msg.getData().getInt("step"));
text.setText(msg.getData().getInt("step")+"");//显示记步数
//延时500ms发送值为REQUEST_SERVER 消息
delayHandler.sendEmptyMessageDelayed(REQUEST_SERVER, TIME_INTERVAL);
break;
case REQUEST_SERVER:
try{
Message message = Message.obtain(null,MSG_FROM_CLIENT);//发送消息
message.replyTo = mGetReplyMessenger;
Log.d(TAG,"message="+ message);
messenger.send(message);
}catch(Exception e){
e.printStackTrace();
}
break;
}
return false;
}

@Override
protected void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy();
unbindService(conn);//解除服务的绑定
}

}

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:background="@drawable/aa"
tools:context=".MainActivity" >

<TextView
android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#000000"
android:layout_centerInParent="true"
android:textSize="100sp"/>

</RelativeLayout>

package com.example.pedometer;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.util.Log;

public class StepService extends Service implements SensorEventListener {

private final static String TAG="SetpService";

private SensorManager sensorManager;
private StepDcretor stepDetector;
private BroadcastReceiver mBroadcastReceiver;
private final static int MSG=0;
private final static int MSG_SERVER=1;

//计步器传感器类型 0-counter 1-detector
private static int stepSensor = -1;

private Messenger messenger = new Messenger(new MessenerHandler());
private static class MessenerHandler extends Handler{

@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
switch(msg.what){
case MSG:
try{
Messenger messenger = msg.replyTo;
Message replyMsg = Message.obtain(null, MSG_SERVER);
Bundle bundle = new Bundle();
bundle.putInt("step", StepDcretor.CURRENT_SETP);
replyMsg.setData(bundle);
Log.d(TAG, replyMsg+"");
messenger.send(replyMsg);
}catch(Exception e){
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}

}

@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return messenger.getBinder();
}

@Override
@Deprecated
public void onStart(Intent intent, int startId) {
// TODO Auto-generated method stub
super.onStart(intent, startId);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
return START_STICKY;
}

private void startStepDetector(){
if(sensorManager != null && stepDetector !=null){
sensorManager.unregisterListener(stepDetector);
sensorManager = null;
stepDetector = null;
}
//getLock(this);
//获取传感器管理器的实例
sensorManager = (SensorManager)this.getSystemService(SENSOR_SERVICE);
//android 4.4以后可以使用计步传感器  在根据API不同版本分别执行addCountStepListener和addBasePedoListener两个方法
int VERSION_CODES = android.os.Build.VERSION.SDK_INT;
Log.d(TAG, VERSION_CODES+"");
if(VERSION_CODES>19){//sdk版本
addCountStepListener();
}else{
addBasePedoListener();
}
}

private void addBasePedoListener() {
// TODO Auto-generated method stub
stepDetector = new StepDcretor(this);
// 获得传感器的类型，这里获得的类型是加速度传感器
// 此方法用来注册，只有注册过才会生效，参数：SensorEventListener的实例，Sensor的实例，更新速率
Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
// sensorManager.unregisterListener(stepDetector);
sensorManager.registerListener(stepDetector, sensor,SensorManager.SENSOR_DELAY_UI);
stepDetector.setOnSensorChangeListener(new StepDcretor.OnSensorChangeListener() {

@Override
public void onChange() {
// updateNotification("今日步数：" + StepDcretor.CURRENT_SETP + " 步");
}
});
}

private void addCountStepListener() {
// TODO Auto-generated method stub
//android 两种计步方式 detector启动后，确认了，才启动counter.
Sensor detectorSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);//计步传感器
Sensor countSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);//步行检测传感器
if (countSensor != null) {
stepSensor = 0;
Log.v("base", "countSensor");
//第一个参数是Listener，第二个参数是所得传感器类型，第三个参数值获取传感器信息的频率
sensorManager.registerListener(StepService.this, countSensor, SensorManager.SENSOR_DELAY_UI);
} else if (detectorSensor != null) {
stepSensor = 1;
Log.v("base", "detector");
sensorManager.registerListener(StepService.this, detectorSensor, SensorManager.SENSOR_DELAY_UI);
} else {
Log.v("xf", "Count sensor not available!");
addBasePedoListener();
}
}

@Override
public void onSensorChanged(SensorEvent event) {
// TODO Auto-generated method stub
if(stepSensor ==0){
StepDcretor.CURRENT_SETP = (int)event.values[0];
}else if(stepSensor ==1){
StepDcretor.CURRENT_SETP++;
}
//updateNotification("今日步数：" + StepDcretor.CURRENT_SETP + " 步");
}

@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
//这里开启了一个线程，因为后台服务也是在主线程中进行，这样可以安全点，防止主线程阻塞
new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
startStepDetector();
}
}).start();

}
@Override
public void onDestroy() {
// TODO Auto-generated method stub
unregisterReceiver(mBroadcastReceiver);//注销广播
Intent intent = new Intent(this,StepService.class);
startService(intent);//重新启动StepService 服务
super.onDestroy();
}

@Override
public boolean onUnbind(Intent intent) {
// TODO Auto-generated method stub
return super.onUnbind(intent);
}

@Override
public void onAccuracyChanged(Sensor arg0, int arg1) {
// TODO Auto-generated method stub

}

}

package com.example.pedometer;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.os.CountDownTimer;
import android.util.Log;

import java.util.Timer;
import java.util.TimerTask;

public class StepDcretor implements SensorEventListener {
//存放三轴数据
float[] oriValues = new float[3];
final int valueNum = 4;
//用于存放计算阈值的波峰波谷差值
float[] tempValue = new float[valueNum];
int tempCount = 0;
//是否上升的标志位
boolean isDirectionUp = false;
//持续上升次数
int continueUpCount = 0;
//上一点的持续上升的次数，为了记录波峰的上升次数
int continueUpFormerCount = 0;
//上一点的状态，上升还是下降
boolean lastStatus = false;
//波峰值
float peakOfWave = 0;
//波谷值
float valleyOfWave = 0;
//此次波峰的时间
long timeOfThisPeak = 0;
//上次波峰的时间
long timeOfLastPeak = 0;
//当前的时间
long timeOfNow = 0;
//当前传感器的值
float gravityNew = 0;
//上次传感器的值
float gravityOld = 0;
//动态阈值需要动态的数据，这个值用于这些动态数据的阈值
final float initialValue = (float) 1.7;
//初始阈值
float ThreadValue = (float) 2.0;

private final String TAG = "StepDcretor";
// alpha 由 t / (t + dT)计算得来，其中 t 是低通滤波器的时间常数，dT 是事件报送频率
//    private final float alpha = 0.8f;
//    private long perCalTime = 0;
//
//    //最新修改的精度值
//    private final float minValue = 9.8f;
//    private final float maxValue = 9.9f;
//    //9.5f
//    private final float verminValue = 8.5f;
//    //10.0f
//    private final float vermaxValue = 11.5f;
//    private final float minTime = 150;
//    private final float maxTime = 2000;

/**
* 0-准备计时   1-计时中  2-准备为正常计步计时  3-正常计步中
*/
private int CountTimeState = 0;
public static int CURRENT_SETP = 0;
public static int TEMP_STEP = 0;
private int lastStep = -1;
// 加速计的三个维度数值
public static float[] gravity = new float[3];
public static float[] linear_acceleration = new float[3];
//用三个维度算出的平均值
public static float average = 0;

private Timer timer;
// 倒计时4秒，4秒内不会显示计步，用于屏蔽细微波动
private long duration = 4000;
private TimeCount time;

OnSensorChangeListener onSensorChangeListener;

public interface OnSensorChangeListener {
void onChange();
}

public StepDcretor(Context context) {
super();
}

public void onAccuracyChanged(Sensor arg0, int arg1) {

}

public OnSensorChangeListener getOnSensorChangeListener() {
return onSensorChangeListener;
}

public void setOnSensorChangeListener(
OnSensorChangeListener onSensorChangeListener) {
this.onSensorChangeListener = onSensorChangeListener;
}

public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
synchronized (this) {
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
calc_step(event);
}
}
}
/**
* 获取传感器xyz值 然后传入  DetectorNewStep
* @param event
*/
synchronized private void calc_step(SensorEvent event) {
average = (float) Math.sqrt(Math.pow(event.values[0], 2)
+ Math.pow(event.values[1], 2) + Math.pow(event.values[2], 2));
DetectorNewStep(average);
}

/*
* 检测步子，并开始计步
* 1.传入sersor中的数据
* 2.如果检测到了波峰，并且符合时间差以及阈值的条件，则判定为1步
* 3.符合时间差条件，波峰波谷差值大于initialValue，则将该差值纳入阈值的计算中
* */
public void DetectorNewStep(float values) {
if (gravityOld == 0) {
gravityOld = values;
} else {
if (DetectorPeak(values, gravityOld)) {
timeOfLastPeak = timeOfThisPeak;
timeOfNow = System.currentTimeMillis();
if (timeOfNow - timeOfLastPeak >= 200
&& (peakOfWave - valleyOfWave >= ThreadValue) && timeOfNow - timeOfLastPeak <= 2000) {
timeOfThisPeak = timeOfNow;
//更新界面的处理，不涉及到算法
preStep();
}
if (timeOfNow - timeOfLastPeak >= 200
&& (peakOfWave - valleyOfWave >= initialValue)) {
timeOfThisPeak = timeOfNow;
ThreadValue = Peak_Valley_Thread(peakOfWave - valleyOfWave);
}
}
}
gravityOld = values;
}

/**
*
*/
private void preStep() {
if (CountTimeState == 0) {
// 开启计时器
time = new TimeCount(duration, 700);
time.start();
CountTimeState = 1;
Log.v(TAG, "开启计时器");
} else if (CountTimeState == 1) {
TEMP_STEP++;
Log.v(TAG, "计步中 TEMP_STEP:" + TEMP_STEP);
} else if (CountTimeState == 3) {
CURRENT_SETP++;
if (onSensorChangeListener != null) {
onSensorChangeListener.onChange();
}
}
}

/*
* 检测波峰
* 以下四个条件判断为波峰：
* 1.目前点为下降的趋势：isDirectionUp为false
* 2.之前的点为上升的趋势：lastStatus为true
* 3.到波峰为止，持续上升大于等于2次
* 4.波峰值大于1.2g,小于2g
* 记录波谷值
* 1.观察波形图，可以发现在出现步子的地方，波谷的下一个就是波峰，有比较明显的特征以及差值
* 2.所以要记录每次的波谷值，为了和下次的波峰做对比
* */
public boolean DetectorPeak(float newValue, float oldValue) {
lastStatus = isDirectionUp;
if (newValue >= oldValue) {
isDirectionUp = true;
continueUpCount++;
} else {
continueUpFormerCount = continueUpCount;//记住上升次数，如果下降则清零
continueUpCount = 0;
isDirectionUp = false;
}

if (!isDirectionUp && lastStatus
&& (continueUpFormerCount >= 2 && (oldValue >= 11.76 && oldValue < 19.6))) {
peakOfWave = oldValue;//算出波峰值
return true;
} else if (!lastStatus && isDirectionUp) {
valleyOfWave = oldValue;
return false;
} else {
return false;
}
}

/*
* 阈值的计算
* 1.通过波峰波谷的差值计算阈值
* 2.记录4个值，存入tempValue[]数组中
* 3.在将数组传入函数averageValue中计算阈值
* */
public float Peak_Valley_Thread(float value) {
float tempThread = ThreadValue;
if (tempCount < valueNum) {
tempValue[tempCount] = value;
tempCount++;
} else {
tempThread = averageValue(tempValue, valueNum);
for (int i = 1; i < valueNum; i++) {
tempValue[i - 1] = tempValue[i];
}
tempValue[valueNum - 1] = value;
}
return tempThread;

}

/*
* 梯度化阈值
* 1.计算数组的均值
* 2.通过均值将阈值梯度化在一个范围里
* */
public float averageValue(float value[], int n) {
float ave = 0;
for (int i = 0; i < n; i++) {
ave += value[i];
}
ave = ave / valueNum;
if (ave >= 8)
ave = (float) 4.3;
else if (ave >= 7 && ave < 8)
ave = (float) 3.3;
else if (ave >= 4 && ave < 7)
ave = (float) 2.3;
else if (ave >= 3 && ave < 4)
ave = (float) 2.0;
else {
ave = (float) 1.3;
}
return ave;
}

class TimeCount extends CountDownTimer {
public TimeCount(long millisInFuture, long countDownInterval) {
super(millisInFuture, countDownInterval);
}

@Override
public void onFinish() {
// 如果计时器正常结束，则开始计步
time.cancel();
CURRENT_SETP += TEMP_STEP;
lastStep = -1;
//            CountTimeState = 2;
Log.v(TAG, "计时正常结束");

timer = new Timer(true);
TimerTask task = new TimerTask() {
public void run() {
if (lastStep == CURRENT_SETP) {
timer.cancel();
CountTimeState = 0;
lastStep = -1;
TEMP_STEP = 0;
Log.v(TAG, "停止计步：" + CURRENT_SETP);
} else {
lastStep = CURRENT_SETP;
}
}
};
timer.schedule(task, 0, 3000);
CountTimeState = 3;//正常记步
}

@Override
public void onTick(long millisUntilFinished) {
if (lastStep == TEMP_STEP) {
Log.v(TAG, "onTick 计时停止");
time.cancel();
CountTimeState = 0;
lastStep = -1;
TEMP_STEP = 0;
} else {
lastStep = TEMP_STEP;
}
}

}
//废弃的算法
//    private void oldCalStep(SensorEvent event) {
//        // 用低通滤波器分离出重力加速度
//        gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
//        gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
//        gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];
//
//        average = (float) Math.sqrt(Math.pow(gravity[0], 2)
//                + Math.pow(gravity[1], 2) + Math.pow(gravity[2], 2));
//
//        if (average <= minValue) {
//            Log.v("xfblog", "低");
//            perCalTime = System.currentTimeMillis();
//        }
//        else if (average >= maxValue) {
//            Log.v("xfblog", "高");
//            float betweentime = System.currentTimeMillis()
//                    - perCalTime;
//            if (betweentime >= minTime && betweentime < maxTime) {
//                perCalTime = 0;
//                if (CountTimeState == 0) {
//                    // 开启计时器
//                    time = new TimeCount(duration, 800);
//                    time.start();
//                    CountTimeState = 1;
//                    Log.v(TAG, "开启计时器");
//                } else if (CountTimeState == 1) {
//                    TEMP_STEP++;
//                    Log.v(TAG, "计步中 TEMP_STEP:" + TEMP_STEP);
//                }
//                else if (CountTimeState == 3) {
//                    CURRENT_SETP++;
//                    if (onSensorChangeListener != null) {
//                        onSensorChangeListener.onChange();
//                    }
//                }
//
//
//            }
//        }
//    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.pedometer"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="18" />

<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.VIBRATE"/>
<uses-permission android:name="android.permission.WRITE_SETTINGS" />
<uses-feature android:name="android.hardware.sensor.accelerometer" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.pedometer.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service
android:name="com.example.pedometer.StepService"
android:process="com.example.pedometer.step"
android:priority="1000">
<intent-filter >
<!-- 系统启动完成后会调用-->
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<action android:name="android.intent.action.DATE_CHANGED"/>
<action android:name="android.intent.action.MEDIA_MOUNTED" />
<action android:name="android.intent.action.USER_PRESENT" />
<action android:name="android.intent.action.ACTION_TIME_TICK" />
<action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
<action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
</intent-filter>
</service>
</application>

</manifest>