Android 스텝 센서 기능 구현
본문 소스 코드:https://github.com/lifegh/StepOrient
Android 4.4 이상 버 전,일부 휴대 전화 에는 스텝 센서 가 직접 사용 할 수 있 습 니 다.
일부 휴대 전 화 는 없 지만 가속도 센서 가 있어 서 걸음 계산 기능 도 실현 할 수 있 습 니 다(가속도 파 봉 파 곡 을 계산 하여 사람 이 한 걸음 걷 는 것 을 판단 해 야 합 니 다)!
호출
public class MainActivity extends AppCompatActivity implements StepSensorBase.StepCallBack{
.........
@Override
public void Step(int stepNum) {
//
stepText.setText(" :" + stepNum);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
stepText = (TextView) findViewById(R.id.step_text);
// , 、
stepSensor = new StepSensorPedometer(this, this);
if (!stepSensor.registerStep()) {
Toast.makeText(this, " ！", Toast.LENGTH_SHORT).show();
stepSensor = new StepSensorAcceleration(this, this);
if (!stepSensor.registerStep()) {
Toast.makeText(this, " ！", Toast.LENGTH_SHORT).show();
}
}
}
.......
}
/**
* ， 、
*/
public abstract class StepSensorBase implements SensorEventListener {
private Context context;
protected StepCallBack stepCallBack;
protected SensorManager sensorManager;
protected static int CURRENT_SETP = 0;
protected boolean isAvailable = false;
public StepSensorBase(Context context, StepCallBack stepCallBack) {
this.context = context;
this.stepCallBack = stepCallBack;
}
public interface StepCallBack {
/**
*
*/
void Step(int stepNum);
}
/**
*
*/
public boolean registerStep() {
if (sensorManager != null) {
sensorManager.unregisterListener(this);
sensorManager = null;
}
sensorManager = SensorUtil.getInstance().getSensorManager(context);
registerStepListener();
return isAvailable;
}
/**
*
*/
protected abstract void registerStepListener();
/**
*
*/
public abstract void unregisterStep();
}
/**
*
*/
public class StepSensorPedometer extends StepSensorBase {
private final String TAG = "StepSensorPedometer";
private int lastStep = -1;
private int liveStep = 0;
private int increment = 0;
private int sensorMode = 0; //
public StepSensorPedometer(Context context, StepCallBack stepCallBack) {
super(context, stepCallBack);
}
@Override
protected void registerStepListener() {
Sensor detectorSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
Sensor countSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
if (sensorManager.registerListener(this, detectorSensor, SensorManager.SENSOR_DELAY_GAME)) {
isAvailable = true;
sensorMode = 0;
Log.i(TAG, " Detector ！");
} else if (sensorManager.registerListener(this, countSensor, SensorManager.SENSOR_DELAY_GAME)) {
isAvailable = true;
sensorMode = 1;
Log.i(TAG, " Counter ！");
} else {
isAvailable = false;
Log.i(TAG, " ！");
}
}
@Override
public void unregisterStep() {
sensorManager.unregisterListener(this);
}
@Override
public void onSensorChanged(SensorEvent event) {
liveStep = (int) event.values[0];
if (sensorMode == 0) {
Log.i(TAG, "Detector ："+liveStep);
StepSensorBase.CURRENT_SETP += liveStep;
} else if (sensorMode == 1) {
Log.i(TAG, "Counter ："+liveStep);
StepSensorBase.CURRENT_SETP = liveStep;
}
stepCallBack.Step(StepSensorBase.CURRENT_SETP);
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
}
/**
*
*/
public class StepSensorAcceleration extends StepSensorBase {
private final String TAG = "StepSensorAcceleration";
//
final int valueNum = 5;
//
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;
//
float minValue = 11f;
float maxValue = 19.6f;
/**
* 0- 1- 2-
*/
private int CountTimeState = 0;
public static int TEMP_STEP = 0;
private int lastStep = -1;
// x、y、z
public static float average = 0;
private Timer timer;
// 3.5 ，3.5 ，
private long duration = 3500;
private TimeCount time;
public StepSensorAcceleration(Context context, StepCallBack stepCallBack) {
super(context, stepCallBack);
}
@Override
protected void registerStepListener() {
//
isAvailable = sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_GAME);
if (isAvailable) {
Log.i(TAG, " ！");
} else {
Log.i(TAG, " ！");
}
}
@Override
public void unregisterStep() {
sensorManager.unregisterListener(this);
}
public void onAccuracyChanged(Sensor arg0, int arg1) {
}
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
synchronized (this) {
if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
calc_step(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 == 2) {
StepSensorBase.CURRENT_SETP++;
// if (stepCallBack != null) {
stepCallBack.Step(StepSensorBase.CURRENT_SETP);
// }
// }
}
/*
*
* ：
* 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;
}
// Log.v(TAG, "oldValue:" + oldValue);
if (!isDirectionUp && lastStatus
&& (continueUpFormerCount >= 2 && (oldValue >= minValue && oldValue < maxValue))) {
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) {
// Log.v(TAG, " 8");
ave = (float) 4.3;
} else if (ave >= 7 && ave < 8) {
// Log.v(TAG, "7-8");
ave = (float) 3.3;
} else if (ave >= 4 && ave < 7) {
// Log.v(TAG, "4-7");
ave = (float) 2.3;
} else if (ave >= 3 && ave < 4) {
// Log.v(TAG, "3-4");
ave = (float) 2.0;
} else {
// Log.v(TAG, "else");
ave = (float) 1.7;
}
return ave;
}
class TimeCount extends CountDownTimer {
public TimeCount(long millisInFuture, long countDownInterval) {
super(millisInFuture, countDownInterval);
}
@Override
public void onFinish() {
// ，
time.cancel();
StepSensorBase.CURRENT_SETP += TEMP_STEP;
lastStep = -1;
Log.v(TAG, " ");
timer = new Timer(true);
TimerTask task = new TimerTask() {
public void run() {
if (lastStep == StepSensorBase.CURRENT_SETP) {
timer.cancel();
CountTimeState = 0;
lastStep = -1;
TEMP_STEP = 0;
Log.v(TAG, " ：" + StepSensorBase.CURRENT_SETP);
} else {
lastStep = StepSensorBase.CURRENT_SETP;
}
}
};
timer.schedule(task, 0, 2000);
CountTimeState = 2;
}
@Override
public void onTick(long millisUntilFinished) {
if (lastStep == TEMP_STEP) {
Log.v(TAG, "onTick :" + TEMP_STEP);
time.cancel();
CountTimeState = 0;
lastStep = -1;
TEMP_STEP = 0;
} else {
lastStep = TEMP_STEP;
}
}
}
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Bitrise에서 배포 어플리케이션 설정 테스트하기이 글은 Bitrise 광고 달력의 23일째 글입니다. 자체 또는 당사 등에서 Bitrise 구축 서비스를 사용합니다. 그나저나 며칠 전 Bitrise User Group Meetup #3에서 아래 슬라이드를 발표했...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
