1、进程保活

杨帅
1 parent ad8287cf
Showing 31 changed files with 2106 additions and 10 deletions
app/build.gradle
app/src/main/AndroidManifest.xml
app/src/main/java/com/example/modulepedometer/MainActivity.java
app/src/main/java/com/example/modulepedometer/MyApp.java
app/src/main/res/values/strings.xml
moudle_pedometer/build.gradle
moudle_pedometer/src/debug/res/mipmap-hdpi/ic_launcher.png
moudle_pedometer/src/debug/res/mipmap-ldpi/ic_launcher.png
moudle_pedometer/src/debug/res/mipmap-xhdpi/ic_launcher.png
moudle_pedometer/src/debug/res/mipmap-xxhdpi/ic_launcher.png
moudle_pedometer/src/debug/res/mipmap-xxxhdpi/ic_launcher.png
moudle_pedometer/src/main/AndroidManifest.xml
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/model/step/StepCount.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/model/step/StepCountListener.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/model/step/StepDetector.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/model/step/StepValuePassListener.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/receivers/MyReceiver.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/service/KeepLiveService.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/service/StepService.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/sql/db/BaseDbHelper.java
 apply plugin: 'com.android.application'
+apply plugin: 'com.alibaba.arouter'
+
+static def stringValue(def value) {
+    return "\"${value}\""
+}
  
 android {
     compileSdkVersion 28
     defaultConfig {
-        applicationId "com.example.modulepedometer"
-        minSdkVersion 15
-        targetSdkVersion 28
+        applicationId "com.cnlive.strike"
+        minSdkVersion 16
+        targetSdkVersion 27
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        multiDexEnabled true
+        javaCompileOptions {
+            annotationProcessorOptions {
+                arguments = [AROUTER_MODULE_NAME: project.getName(), AROUTER_GENERATE_DOC: "enable"]
+            }
+        }
     }
     buildTypes {
+        debug {
+            applicationIdSuffix ".debug"
+            resValue("string", "app_name", "网++ 内测")
+            buildConfigField("String", "APP_ID", stringValue("802_jhbqccxw08"))
+            buildConfigField("String", "APP_KEY", stringValue("9c5619e9be747bb3b925dd215ca5923d86f12c09b9394f"))
+            buildConfigField("String", "APP_SCERET", stringValue("1e6380cb347255e777f72b5aa60f41daa68443a132aaea"))
+        }
         release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            resValue("string", "app_name", "网++")
+            buildConfigField("String", "APP_ID", stringValue("769_jetj7bq525"))
+            buildConfigField("String", "APP_KEY", stringValue("0d57b045ec0c3988a682d94c644e66b9b8e0d2b8ef937d"))
+            buildConfigField("String", "APP_SCERET", stringValue("275e8dc29274a1186d82f65bc607c231d02bcb3bfd8976"))
         }
     }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    dataBinding {
+        enabled true
+    }
+    dexOptions {
+        javaMaxHeapSize '4g'
+    }
+
+    compileOptions {
+        sourceCompatibility 1.8
+        targetCompatibility 1.8
+    }
 }
  
 dependencies {
@@ -25,4 +61,12 @@ dependencies {
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'com.android.support.test:runner:1.0.2'
     androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
+    implementation project(':moudle_pedometer')
+    implementation "com.cnlive.libs:base:$rootProject.libBase"
+    implementation "com.qmuiteam:qmui:$rootProject.qmui"
+    implementation "com.cnlive:app_arch:$rootProject.appArch"
+
+    //ARouter
+    implementation "com.alibaba:arouter-api:$rootProject.arouterApiVersion"
+    annotationProcessor "com.alibaba:arouter-compiler:$rootProject.arouterCompilerVersion"
 }
@@ -2,7 +2,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.example.modulepedometer">
  
+
+
+
     <application
+        android:name=".MyApp"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
 package com.example.modulepedometer;
  
+import android.content.Intent;
 import android.support.v7.app.AppCompatActivity;
 import android.os.Bundle;
  
+import com.alibaba.android.arouter.launcher.ARouter;
+import com.cnlive.moudle.pedometer.ui.activity.PedometerMainActivity;
+
 public class MainActivity extends AppCompatActivity {
  
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
+        ARouter.getInstance()
+                .build("/moudle_pedometer/InterestActivity")
+                .navigation(this);
+        finish();
     }
 }
+package com.example.modulepedometer;
+
+import android.app.Application;
+
+import com.alibaba.android.arouter.launcher.ARouter;
+import com.cnlive.libs.base.application.AppConfig;
+
+public class MyApp extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        String userId = "";
+        AppConfig.init(getApplicationContext(), BuildConfig.APP_ID, BuildConfig.APP_KEY, BuildConfig.APP_SCERET,
+                0, BuildConfig.DEBUG, "", "",
+                userId, "", "", "", "");
+        initARouter();
+    }
+
+    /**
+     * 初始化阿里的路由
+     */
+    private void initARouter() {
+        if (BuildConfig.DEBUG) {   // 这两行必须写在init之前，否则这些配置在init过程中将无效
+            ARouter.openLog();     // 打印日志
+            ARouter.openDebug();   // 开启调试模式(如果在InstantRun模式下运行，必须开启调试模式！线上版本需要关闭,否则有安全风险)
+            ARouter.printStackTrace(); // 打印日志的时候打印线程堆栈
+        }
+        ARouter.init(this); // 尽可能早，推荐在Application中初始化
+    }
+}
 <resources>
-    <string name="app_name">ModulePedometer</string>
+    <!--<string name="app_name">ModulePedometer</string>-->
 </resources>
@@ -42,7 +42,7 @@ android {
     }
 //greendao配置
     greendao {
-        schemaVersion 1                            //版本号，升级时可配置
+        schemaVersion 1                           //版本号，升级时可配置
         daoPackage 'com.cnlive.moudle.pedometer.sql.dao'     //包名
         targetGenDir 'src/main/java'                 //生成目录
     }
@@ -68,6 +68,7 @@ dependencies {
     implementation "com.github.bumptech.glide:glide:$rootProject.glide"
     implementation "jp.wasabeef:glide-transformations:$rootProject.glideTransformations"
     implementation 'com.android.support:support-v4:28.0.0'
+    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
     annotationProcessor "com.github.bumptech.glide:compiler:$rootProject.compiler"
  
     //--------------------------------------------------------
+<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.example.moudle_pedometer" />
+    xmlns:tools="http://schemas.android.com/tools"
+    package="com.example.moudle_pedometer">
+
+    <!-- 申请权限 -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+    <!--计歩需要的权限-->
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission
+        android:name="android.permission.WRITE_SETTINGS"
+        tools:ignore="ProtectedPermissions" />
+
+    <uses-feature android:name="android.hardware.sensor.accelerometer" />
+
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission
+        android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"
+        tools:ignore="ProtectedPermissions" />
+
+    <uses-feature
+        android:name="android.hardware.sensor.stepcounter"
+        android:required="true" />
+    <uses-feature
+        android:name="android.hardware.sensor.stepdetector"
+        android:required="true" />
+
+    <application>
+        <service
+            android:name="com.cnlive.moudle.pedometer.service.KeepLiveService"
+            android:enabled="true"
+            android:exported="true"
+            android:priority="1000"
+            android:process=":remote" />
+        <service
+            android:name="com.cnlive.moudle.pedometer.service.StepService"
+            android:enabled="true"
+            android:exported="true"
+            android:priority="1000"
+            android:process=":step">
+            <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>
+
+        <activity android:name="com.cnlive.moudle.pedometer.ui.activity.PedometerMainActivity" />
+
+        <receiver
+            android:name="com.cnlive.moudle.pedometer.receivers.MyReceiver"
+            android:enabled="true"
+            android:exported="true">
+            <intent-filter android:priority="1000">
+                <action android:name="com.cnlive.moudle.pedometer.receivers.MyReceiver" />
+                <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
+                <action android:name="android.net.wifi.STATE_CHANGE" />
+                <action android:name="com.example.myservice.MyReceiver" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>
 \ No newline at end of file
+package com.cnlive.moudle.pedometer.model.step;
+
+/**
+ * Created by dylan on 16/9/27.
+ */
+
+/*
+* 根据StepDetector传入的步点"数"步子
+* */
+public class StepCount implements StepCountListener {
+
+    private int count = 0;
+    private int mCount = 0;
+    private StepValuePassListener mStepValuePassListener;
+    private long timeOfLastPeak = 0;
+    private long timeOfThisPeak = 0;
+    private StepDetector stepDetector;
+
+    public StepCount() {
+        stepDetector = new StepDetector();
+        stepDetector.initListener(this);
+    }
+    public StepDetector getStepDetector(){
+        return stepDetector;
+    }
+
+    /*
+        * 连续走十步才会开始计步
+        * 连续走了9步以下,停留超过3秒,则计数清空
+        * */
+    @Override
+    public void countStep() {
+        this.timeOfLastPeak = this.timeOfThisPeak;
+        this.timeOfThisPeak = System.currentTimeMillis();
+        if (this.timeOfThisPeak - this.timeOfLastPeak <= 3000L) {
+            if (this.count < 9) {
+                this.count++;
+            } else if (this.count == 9) {
+                this.count++;
+                this.mCount += this.count;
+                notifyListener();
+            } else {
+                this.mCount++;
+                notifyListener();
+            }
+        } else {//超时
+            this.count = 1;//为1,不是0
+        }
+
+    }
+
+    public void initListener(StepValuePassListener listener) {
+        this.mStepValuePassListener = listener;
+    }
+
+    public void notifyListener() {
+        if (this.mStepValuePassListener != null)
+            this.mStepValuePassListener.stepChanged(this.mCount);
+    }
+
+
+    public void setSteps(int initValue) {
+        this.mCount = initValue;
+        this.count = 0;
+        timeOfLastPeak = 0;
+        timeOfThisPeak = 0;
+        notifyListener();
+    }
+}
+package com.cnlive.moudle.pedometer.model.step;
+
+
+public interface StepCountListener {
+    void countStep();
+}
+package com.cnlive.moudle.pedometer.model.step;
+
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+/*
+ * 算法的主要部分,检测是否是步点
+ * */
+
+public class StepDetector 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.3;
+    //初始阈值
+    float ThreadValue = (float) 2.0;
+    //波峰波谷时间差
+    int TimeInterval = 250;
+    private StepCountListener mStepListeners;
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        for (int i = 0; i < 3; i++) {
+            oriValues[i] = event.values[i];
+        }
+        gravityNew = (float) Math.sqrt(oriValues[0] * oriValues[0]
+                + oriValues[1] * oriValues[1] + oriValues[2] * oriValues[2]);
+        detectorNewStep(gravityNew);
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        //
+    }
+
+    public void initListener(StepCountListener listener) {
+        this.mStepListeners = listener;
+    }
+
+    /*
+     * 检测步子，并开始计步
+     * 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 >= TimeInterval
+                        && (peakOfWave - valleyOfWave >= ThreadValue)) {
+                    timeOfThisPeak = timeOfNow;
+                    /*
+                     * 更新界面的处理，不涉及到算法
+                     * 一般在通知更新界面之前，增加下面处理，为了处理无效运动：
+                     * 1.连续记录10才开始计步
+                     * 2.例如记录的9步用户停住超过3秒，则前面的记录失效，下次从头开始
+                     * 3.连续记录了9步用户还在运动，之前的数据才有效
+                     * */
+                    mStepListeners.countStep();
+                }
+                if (timeOfNow - timeOfLastPeak >= TimeInterval
+                        && (peakOfWave - valleyOfWave >= InitialValue)) {
+                    timeOfThisPeak = timeOfNow;
+                    ThreadValue = peakValleyThread(peakOfWave - valleyOfWave);
+                }
+            }
+        }
+        gravityOld = values;
+    }
+
+    /*
+     * 检测波峰
+     * 以下四个条件判断为波峰：
+     * 1.目前点为下降的趋势：isDirectionUp为false
+     * 2.之前的点为上升的趋势：lastStatus为true
+     * 3.到波峰为止，持续上升大于等于2次
+     * 4.波峰值大于20
+     * 记录波谷值
+     * 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 >= 20)) {
+            peakOfWave = oldValue;
+            return true;
+        } else if (!lastStatus && isDirectionUp) {
+            valleyOfWave = oldValue;
+            return false;
+        } else {
+            return false;
+        }
+    }
+
+    /*
+     * 阈值的计算
+     * 1.通过波峰波谷的差值计算阈值
+     * 2.记录4个值，存入tempValue[]数组中
+     * 3.在将数组传入函数averageValue中计算阈值
+     * */
+    public float peakValleyThread(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;
+    }
+
+}
+package com.cnlive.moudle.pedometer.model.step;
+
+
+public interface StepValuePassListener {
+    void stepChanged(int steps);
+}
+package com.cnlive.moudle.pedometer.receivers;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.PowerManager;
+import android.util.Log;
+
+import com.cnlive.moudle.pedometer.service.KeepLiveService;
+import com.cnlive.moudle.pedometer.service.StepService;
+import com.cnlive.moudle.pedometer.utils.ServiceUtils;
+
+public class MyReceiver extends BroadcastReceiver {
+
+    private PowerManager.WakeLock wakeLock = null;
+
+    public MyReceiver() {
+
+    }
+
+    public MyReceiver(PowerManager.WakeLock wakeLock) {
+        super();
+        this.wakeLock = wakeLock;
+    }
+
+    @SuppressLint("Wakelock")
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Log.e("广播", "接收到广播:" + intent.getAction());
+        if (!ServiceUtils.isServiceRunning(context, "com.cnlive.moudle.pedometer.service.KeepLiveService")) {
+            context.startService(new Intent(context, KeepLiveService.class));
+            Log.e("启动服务", "启动MyIntentService");
+        }
+        if (!ServiceUtils.isServiceRunning(context, "com.cnlive.moudle.pedometer.service.StepService")) {
+            context.startService(new Intent(context, StepService.class));
+            Log.e("启动服务", "启动MyTestService");
+        }
+
+        String action = intent.getAction();
+
+        if (Intent.ACTION_SCREEN_OFF.equals(action)) {
+            if (null != wakeLock && !(wakeLock.isHeld())) {
+                wakeLock.acquire();
+                Log.e("启动电量锁", "启动");
+            }
+            //启动保活服务
+//            KeepLiveService.getInstance().startPlaySong();
+
+//            Log.e("启动保活", "启动");
+        } else if (Intent.ACTION_SCREEN_ON.equals(action) || Intent.ACTION_USER_PRESENT.equals(action)) {
+            if (null != wakeLock && wakeLock.isHeld()) {
+                wakeLock.release();
+                Log.e("重置电量锁", "释放");
+            }
+            //暂停保活服务
+//            KeepLiveService.getInstance().stopPlaySong();
+//            Log.e("停止保活", "停止");
+        }
+
+    }
+}
+package com.cnlive.moudle.pedometer.service;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.media.MediaPlayer;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.support.v4.app.NotificationCompat;
+import android.util.Log;
+import android.widget.RemoteViews;
+
+import com.cnlive.libs.base.util.SharedPreferencesHelper;
+import com.cnlive.moudle.pedometer.receivers.MyReceiver;
+import com.cnlive.moudle.pedometer.utils.ServiceUtils;
+import com.example.moudle_pedometer.R;
+
+import java.io.IOException;
+
+/**
+ * @author ShinnyYang
+ * 维持后台运行的服务
+ */
+public class KeepLiveService extends Service implements MediaPlayer.OnCompletionListener {
+    //唤醒锁
+    private PowerManager.WakeLock wakeLock = null;
+    //电源管理器
+    private PowerManager powerManager = null;
+    //音频播放器
+    public static MediaPlayer mMediaPlayer;
+    //广播
+    private static MyReceiver myReceiver;
+    private String CHANNEL_ONE_ID = "com.cnlive";
+    private String CHANNEL_ONE_NAME = "Channel One";
+    private NotificationManager mNM;
+    private Notification notification = null;
+    //是否在后台运行
+    public static boolean isKeepService = true;
+    private static KeepLiveService instance;
+    private int startId;
+
+    public KeepLiveService() {
+    }
+
+    public static KeepLiveService getInstance() {
+        if (instance == null) {
+            instance = new KeepLiveService();
+            return instance;
+        } else {
+            return instance;
+        }
+    }
+
+    @Override
+    public void onCreate() {
+        instance = this;
+//        if (!ServiceUtils.isServiceRunning(getApplicationContext(), "com.cnlive.moudle.pedometer.service.StepService")) {
+//            startService(new Intent(getApplicationContext(), StepService.class));
+//        }
+        init();
+        initBroadCastReceiver();
+        super.onCreate();
+    }
+
+    /**
+     * 初始化广播
+     */
+    private void initBroadCastReceiver() {
+        if (wakeLock != null) {
+            myReceiver = new MyReceiver(wakeLock);
+        } else {
+            myReceiver = new MyReceiver();
+        }
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
+        intentFilter.addAction(Intent.ACTION_SCREEN_ON);
+//        intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
+//        intentFilter.addAction(Intent.ACTION_TIME_CHANGED);
+//        intentFilter.addAction(Intent.ACTION_POWER_CONNECTED);
+//        intentFilter.addAction(Intent.ACTION_POWER_DISCONNECTED);
+        intentFilter.addAction("com.cnlive.moudle.pedometer.receivers.MyReceiver");
+        registerReceiver(myReceiver, intentFilter);
+    }
+
+    /**
+     * 初始化相关参数
+     */
+    @SuppressLint("InvalidWakeLockTag")
+    private void init() {
+        if (null == powerManager) {
+            powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        }
+        if (null == wakeLock) {
+            wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "track upload");
+        }
+        if (null == mNM) {
+            mNM = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+        }
+
+    }
+
+    @SuppressLint("WrongConstant")
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        this.startId = startId;
+        showHideForegroundNotification();
+        startPlaySong();
+        flags = START_STICKY;
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    //开始、暂停播放
+    public void startPlaySong() {
+        if (mMediaPlayer == null) {
+            mMediaPlayer = MediaPlayer.create(getApplicationContext(), R.raw.no_kill);
+            Log.e("音乐启动播放,播放对象为： ", "" + mMediaPlayer.hashCode());
+        } else {
+            Log.e("音乐启动播放,播放对象为： ", "" + mMediaPlayer.hashCode());
+        }
+        mMediaPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
+        if (!mMediaPlayer.isPlaying()) {
+            mMediaPlayer.start();
+        }
+        Log.e("是否播放:", mMediaPlayer.isPlaying() + "");
+        mMediaPlayer.setOnCompletionListener(this);
+        mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
+            @Override
+            public void onPrepared(MediaPlayer mediaPlayer) {
+                Log.e("加载完成:", "");
+
+            }
+        });
+    }
+
+    //停止播放销毁对象
+    public void stopPlaySong() {
+        if (mMediaPlayer != null) {
+            mMediaPlayer.stop();
+            Log.e("音乐停止播放,播放对象为：", "" + mMediaPlayer.hashCode());
+            Log.e("音乐播放器是否在循环：", "" + mMediaPlayer.isLooping());
+            Log.e("音乐播放器是否还在播放：", "" + mMediaPlayer.isPlaying());
+            mMediaPlayer.release();
+            Log.e("播放对象销毁,播放对象为：", "" + mMediaPlayer.hashCode());
+            mMediaPlayer = null;
+        }
+    }
+
+
+    private void showHideForegroundNotification() {
+        NotificationChannel channel = null;
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+            channel = new NotificationChannel(CHANNEL_ONE_ID, CHANNEL_ONE_NAME,
+                    NotificationManager.IMPORTANCE_HIGH);
+            channel.enableLights(false);
+            channel.enableVibration(false);
+            channel.setVibrationPattern(new long[]{0});
+            channel.setSound(null, null);
+            mNM.createNotificationChannel(channel);
+        }
+        notification = new NotificationCompat.Builder(this, CHANNEL_ONE_ID)
+                .setWhen(System.currentTimeMillis())
+                .setSound(null)
+                .build();
+        // 0 隐藏前台服务通知
+        startForeground(0, notification);
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        Log.e("keep", "停止后");
+        if (myReceiver != null) {
+            unregisterReceiver(myReceiver);
+        }
+        stopForeground(true);
+        stopPlaySong();
+        boolean result = SharedPreferencesHelper.getInstance(getApplicationContext()).getBoolean("isKeepAlive", false);
+        Log.e("状态", result + "");
+        //判断是否保持服务
+        if (result) {
+//            // 重启自己
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                startForegroundService(new Intent(getApplicationContext(), KeepLiveService.class));
+            } else {
+                startService(new Intent(getApplicationContext(), KeepLiveService.class));
+            }
+            //发送重启广播
+            sendRestartBroadCast();
+        }
+    }
+
+
+    /**
+     * 发送重启广播
+     */
+    private void sendRestartBroadCast() {
+        Intent intent = new Intent(" com.cnlive.moudle.pedometer.receivers.MyReceiver");
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            intent.setComponent(new ComponentName(getPackageName(), " com.cnlive.moudle.pedometer.receivers.MyReceiver"));//高版本Android发送广播需要加这句
+        }
+        sendBroadcast(intent);
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        // TODO: Return the communication channel to the service.
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+
+    /**
+     * 歌曲播放完成
+     *
+     * @param mediaPlayer
+     */
+    @Override
+    public void onCompletion(MediaPlayer mediaPlayer) {
+        if (isKeepService) {
+            mediaPlayer.start();
+        }
+        Intent intent = new Intent(" com.cnlive.moudle.pedometer.receivers.MyReceiver");
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            intent.setComponent(new ComponentName(getPackageName(), " com.cnlive.moudle.pedometer.receivers.MyReceiver"));//高版本Android发送广播需要加这句
+        }
+        sendBroadcast(intent);
+        Log.e("重新播放", "开始");
+    }
+}
+package com.cnlive.moudle.pedometer.service;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Binder;
+import android.os.Build;
+import android.os.CountDownTimer;
+import android.os.IBinder;
+import android.support.v4.app.NotificationCompat;
+import android.util.Log;
+import android.widget.RemoteViews;
+
+import com.cnlive.moudle.pedometer.model.step.StepCount;
+import com.cnlive.moudle.pedometer.model.step.StepValuePassListener;
+import com.cnlive.moudle.pedometer.sql.dao.UserStepEntityDao;
+import com.cnlive.moudle.pedometer.sql.db.DbCore;
+import com.cnlive.moudle.pedometer.sql.entity.UserStepEntity;
+import com.cnlive.moudle.pedometer.ui.activity.PedometerMainActivity;
+import com.cnlive.moudle.pedometer.utils.ServiceUtils;
+import com.example.moudle_pedometer.R;
+import com.orhanobut.logger.Logger;
+
+import org.greenrobot.greendao.DbUtils;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+public class StepService extends Service implements SensorEventListener {
+    private String TAG = "StepService";
+    public static boolean isKeep = true;
+    /**
+     * 通知栏相关
+     */
+    private String CHANNEL_ONE_ID = "com.cnlive";
+    private String CHANNEL_ONE_NAME = "Channel Two";
+    private NotificationManager mNM;
+    private Notification notification = null;
+    private RemoteViews remoteViews;
+    /**
+     * 默认为30秒进行一次存储
+     */
+    private static int duration = 30 * 1000;
+    /**
+     * 当前的日期
+     */
+    private static String CURRENT_DATE = "";
+    /**
+     * 传感器管理对象
+     */
+    private SensorManager sensorManager;
+    /**
+     * 广播接受者
+     */
+    private BroadcastReceiver mBatInfoReceiver;
+    /**
+     * 保存记步计时器
+     */
+    private TimeCount time;
+    /**
+     * 当前所走的步数
+     */
+    private int CURRENT_STEP;
+    /**
+     * 计步传感器类型  Sensor.TYPE_STEP_COUNTER或者Sensor.TYPE_STEP_DETECTOR
+     */
+    private static int stepSensorType = -1;
+    /**
+     * 每次第一次启动记步服务时是否从系统中获取了已有的步数记录
+     */
+    private boolean hasRecord = false;
+    /**
+     * 系统中获取到的已有的步数
+     */
+    private int hasStepCount = 0;
+    /**
+     * 上一次的步数
+     */
+    private int previousStepCount = 0;
+    /**
+     * 加速度传感器中获取的步数
+     */
+    private StepCount mStepCount;
+    /**
+     * IBinder对象，向Activity传递数据的桥梁
+     */
+    private StepBinder stepBinder = new StepBinder();
+    private String userId;
+
+    public StepService() {
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        init();
+        //显示计步通知
+        showStartForegroundNotification();
+        userId = "123";
+        initTodayData(userId);
+        initBroadcastReceiver();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                startStepDetector();
+            }
+        }).start();
+        startTimeCount();
+    }
+
+    private void init() {
+        if (remoteViews == null) {
+            remoteViews = new RemoteViews(getPackageName(), R.layout.custom_step_notification);
+        }
+        if (null == mNM) {
+            mNM = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+        }
+    }
+
+    @SuppressLint("WrongConstant")
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (!ServiceUtils.isServiceRunning(getApplicationContext(), "com.cnlive.moudle.pedometer.service.KeepLiveService")) {
+            startService(new Intent(getApplicationContext(), KeepLiveService.class));
+        }
+        flags = START_STICKY;
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    private void showStartForegroundNotification() {
+        NotificationChannel channel = null;
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+            channel = new NotificationChannel(CHANNEL_ONE_ID, CHANNEL_ONE_NAME,
+                    NotificationManager.IMPORTANCE_HIGH);
+            channel.enableLights(false);
+            channel.setSound(null, null);
+//            channel.setLightColor(getColor(R.color.colorPrimary));
+            channel.enableVibration(false);
+            channel.setVibrationPattern(new long[]{0});
+            channel.setSound(null, null);
+            mNM.createNotificationChannel(channel);
+        }
+        Intent notificationIntent = new Intent(this, PedometerMainActivity.class);
+        notification = new NotificationCompat.Builder(this, CHANNEL_ONE_ID)
+                .setContentIntent(PendingIntent.getActivity(this, 0, notificationIntent, 0))
+                .setSmallIcon(R.drawable.ic_icon)
+//                .setContentText("前台服务正在运行")
+//                .setContentTitle("标题")
+                .setCustomContentView(remoteViews)
+                .setSound(null)
+                .setWhen(System.currentTimeMillis())
+                .build();
+        startForeground(1, notification);
+
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return stepBinder;
+    }
+
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        //取消前台进程
+        stopForeground(true);
+        unregisterReceiver(mBatInfoReceiver);
+        stopSelf();
+        if (isKeep) {
+            sendRestartBroadCast();
+        }
+        Log.e("杀死", "MyTestService");
+    }
+
+    /**
+     * 发送重启广播
+     */
+    private void sendRestartBroadCast() {
+        Intent intent = new Intent(" com.cnlive.moudle.pedometer.receivers.MyReceiver");
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            intent.setComponent(new ComponentName(getPackageName(), " com.cnlive.moudle.pedometer.receivers.MyReceiver"));//高版本Android发送广播需要加这句
+        }
+        sendBroadcast(intent);
+    }
+
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int i) {
+
+    }
+
+    /**
+     * @获取默认的pendingIntent,为了防止2.3及以下版本报错
+     * @flags属性: 在顶部常驻:Notification.FLAG_ONGOING_EVENT
+     * 点击去除： Notification.FLAG_AUTO_CANCEL
+     */
+    public PendingIntent getDefalutIntent(int flags) {
+        PendingIntent pendingIntent = PendingIntent.getActivity(this, 1, new Intent(), flags);
+        return pendingIntent;
+    }
+
+    /**
+     * 获取当天日期
+     *
+     * @return
+     */
+    private String getTodayDate() {
+        Date date = new Date(System.currentTimeMillis());
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        return sdf.format(date);
+    }
+
+    /**
+     * 初始化当天的步数
+     */
+    private void initTodayData(String userId) {
+        CURRENT_DATE = getTodayDate();
+        DbCore.init(getApplicationContext(), "Step.db");
+//        //获取当天的数据，用于展示 CURRENT_DATE
+        List<UserStepEntity> list = DbCore.getDaoSession().getUserStepEntityDao().queryBuilder().where(UserStepEntityDao.Properties.UserId.eq(userId), UserStepEntityDao.Properties.Date.eq(CURRENT_DATE)).list();
+        if (list.size() == 0 || list.isEmpty()) {
+            CURRENT_STEP = 0;
+        } else if (list.size() == 1) {
+            Log.v(TAG, "StepData=" + list.get(0).toString());
+            CURRENT_STEP = Integer.parseInt(list.get(0).getStepCount());
+        } else {
+            Log.v(TAG, "出错了！");
+        }
+        if (mStepCount != null) {
+            mStepCount.setSteps(CURRENT_STEP);
+        }
+        updateNotification();
+    }
+
+    private void updateNotification() {
+        remoteViews.setTextViewText(R.id.tv_step_count, CURRENT_STEP + "");
+        mNM.notify(1, notification);
+
+    }
+
+    /**
+     * 注册广播
+     */
+    private void initBroadcastReceiver() {
+        final IntentFilter filter = new IntentFilter();
+        // 屏幕灭屏广播
+        filter.addAction(Intent.ACTION_SCREEN_OFF);
+        //关机广播
+        filter.addAction(Intent.ACTION_SHUTDOWN);
+        // 屏幕亮屏广播
+        filter.addAction(Intent.ACTION_SCREEN_ON);
+        // 屏幕解锁广播
+//        filter.addAction(Intent.ACTION_USER_PRESENT);
+        // 当长按电源键弹出“关机”对话或者锁屏时系统会发出这个广播
+        // example：有时候会用到系统对话框，权限可能很高，会覆盖在锁屏界面或者“关机”对话框之上，
+        // 所以监听这个广播，当收到时就隐藏自己的对话，如点击pad右下角部分弹出的对话框
+        filter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
+        //监听日期变化
+        filter.addAction(Intent.ACTION_DATE_CHANGED);
+        filter.addAction(Intent.ACTION_TIME_CHANGED);
+        filter.addAction(Intent.ACTION_TIME_TICK);
+
+        mBatInfoReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(final Context context, final Intent intent) {
+                String action = intent.getAction();
+                if (Intent.ACTION_SCREEN_ON.equals(action)) {
+                    Log.d(TAG, "screen on");
+                } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
+                    Log.d(TAG, "screen off");
+                    //改为60秒一存储
+                    duration = 60000;
+                } else if (Intent.ACTION_USER_PRESENT.equals(action)) {
+                    Log.d(TAG, "screen unlock");
+                    save();
+                    //改为30秒一存储
+                    duration = 30000;
+                } else if (Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(intent.getAction())) {
+                    Log.i(TAG, " receive Intent.ACTION_CLOSE_SYSTEM_DIALOGS");
+                    //保存一次
+                    save();
+                } else if (Intent.ACTION_SHUTDOWN.equals(intent.getAction())) {
+                    Log.i(TAG, " receive ACTION_SHUTDOWN");
+                    save();
+                } else if (Intent.ACTION_DATE_CHANGED.equals(action)) {//日期变化步数重置为0
+//                    Logger.d("重置步数" + StepDcretor.CURRENT_STEP);
+                    save();
+                    isNewDay();
+                } else if (Intent.ACTION_TIME_CHANGED.equals(action)) {
+                    //时间变化步数重置为0
+//                    isCall();
+                    save();
+                    isNewDay();
+                } else if (Intent.ACTION_TIME_TICK.equals(action)) {//日期变化步数重置为0
+//                    isCall();
+//                    Logger.d("重置步数" + StepDcretor.CURRENT_STEP);
+                    save();
+                    isNewDay();
+                }
+            }
+        };
+        registerReceiver(mBatInfoReceiver, filter);
+    }
+
+    /**
+     * 获取当前步数
+     *
+     * @return
+     */
+    public int getStepCount() {
+        return CURRENT_STEP;
+    }
+
+    /**
+     * 监听晚上0点变化初始化数据
+     */
+    private void isNewDay() {
+        String time = "00:00";
+        if (time.equals(new SimpleDateFormat("HH:mm").format(new Date())) || !CURRENT_DATE.equals(getTodayDate())) {
+            initTodayData(userId);
+        }
+    }
+
+//    /**
+//     * 监听时间变化提醒用户锻炼
+//     */
+//    private void isCall() {
+//        String time = this.getSharedPreferences("share_date", Context.MODE_MULTI_PROCESS).getString("achieveTime", "21:00");
+//        String plan = this.getSharedPreferences("share_date", Context.MODE_MULTI_PROCESS).getString("planWalk_QTY", "7000");
+//        String remind = this.getSharedPreferences("share_date", Context.MODE_MULTI_PROCESS).getString("remind", "1");
+//        Logger.d("time=" + time + "\n" +
+//                "new SimpleDateFormat(\"HH: mm\").format(new Date()))=" + new SimpleDateFormat("HH:mm").format(new Date()));
+//        if (("1".equals(remind)) &&
+//                (CURRENT_STEP < Integer.parseInt(plan)) &&
+//                (time.equals(new SimpleDateFormat("HH:mm").format(new Date())))
+//        ) {
+//            remindNotify();
+//        }
+//
+//    }
+    /**
+     * 提醒锻炼通知栏
+     */
+//    private void remindNotify() {
+//
+//        //设置点击跳转
+//        Intent hangIntent = new Intent(this, MainActivity.class);
+//        PendingIntent hangPendingIntent = PendingIntent.getActivity(this, 0, hangIntent, PendingIntent.FLAG_CANCEL_CURRENT);
+//
+//        String plan = this.getSharedPreferences("share_date", Context.MODE_MULTI_PROCESS).getString("planWalk_QTY", "7000");
+//        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this);
+//        mBuilder.setContentTitle("今日步数" + CURRENT_STEP + " 步")
+//                .setContentText("距离目标还差" + (Integer.valueOf(plan) - CURRENT_STEP) + "步，加油！")
+//                .setContentIntent(hangPendingIntent)
+//                .setTicker(getResources().getString(R.string.app_name) + "提醒您开始锻炼了")//通知首次出现在通知栏，带上升动画效果的
+//                .setWhen(System.currentTimeMillis())//通知产生的时间，会在通知信息里显示
+//                .setPriority(Notification.PRIORITY_DEFAULT)//设置该通知优先级
+//                .setAutoCancel(true)//设置这个标志当用户单击面板就可以让通知将自动取消
+//                .setOngoing(false)//ture，设置他为一个正在进行的通知。他们通常是用来表示一个后台任务,用户积极参与(如播放音乐)或以某种方式正在等待,因此占用设备(如一个文件下载,同步操作,主动网络连接)
+//                .setDefaults(Notification.DEFAULT_VIBRATE | Notification.DEFAULT_SOUND)//向通知添加声音、闪灯和振动效果的最简单、最一致的方式是使用当前的用户默认设置，使用defaults属性，可以组合：
+//                //Notification.DEFAULT_ALL  Notification.DEFAULT_SOUND 添加声音 // requires VIBRATE permission
+//                .setSmallIcon(R.mipmap.logo);
+//        NotificationManager mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+//        mNotificationManager.notify(notify_remind_id, mBuilder.build());
+//    }
+
+    /**
+     * 获取传感器实例
+     */
+    private void startStepDetector() {
+        if (sensorManager != null) {
+            sensorManager = null;
+        }
+        // 获取传感器管理器的实例
+        sensorManager = (SensorManager) this
+                .getSystemService(SENSOR_SERVICE);
+        //android4.4以后可以使用计步传感器
+        int VERSION_CODES = Build.VERSION.SDK_INT;
+        if (VERSION_CODES >= 19) {
+            addCountStepListener();
+        } else {
+            addBasePedometerListener();
+        }
+    }
+
+    /**
+     * 添加传感器监听
+     * 1. TYPE_STEP_COUNTER API的解释说返回从开机被激活后统计的步数，当重启手机后该数据归零，
+     * 该传感器是一个硬件传感器所以它是低功耗的。
+     * 为了能持续的计步，请不要反注册事件，就算手机处于休眠状态它依然会计步。
+     * 当激活的时候依然会上报步数。该sensor适合在长时间的计步需求。
+     * <p>
+     * 2.TYPE_STEP_DETECTOR翻译过来就是走路检测，
+     * API文档也确实是这样说的，该sensor只用来监监测走步，每次返回数字1.0。
+     * 如果需要长事件的计步请使用TYPE_STEP_COUNTER。
+     */
+    private void addCountStepListener() {
+        Sensor countSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
+        Sensor detectorSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
+        if (countSensor != null) {
+            stepSensorType = Sensor.TYPE_STEP_COUNTER;
+            Log.v(TAG, "Sensor.TYPE_STEP_COUNTER");
+            sensorManager.registerListener(StepService.this, countSensor, SensorManager.SENSOR_DELAY_NORMAL);
+        } else if (detectorSensor != null) {
+            stepSensorType = Sensor.TYPE_STEP_DETECTOR;
+            Log.v(TAG, "Sensor.TYPE_STEP_DETECTOR");
+            sensorManager.registerListener(StepService.this, detectorSensor, SensorManager.SENSOR_DELAY_NORMAL);
+        } else {
+            Log.v(TAG, "Count sensor not available!");
+            addBasePedometerListener();
+        }
+    }
+
+    /**
+     * 通过加速度传感器来记步
+     */
+    private void addBasePedometerListener() {
+        mStepCount = new StepCount();
+        mStepCount.setSteps(CURRENT_STEP);
+        // 获得传感器的类型，这里获得的类型是加速度传感器
+        // 此方法用来注册，只有注册过才会生效，参数：SensorEventListener的实例，Sensor的实例，更新速率
+        Sensor sensor = sensorManager
+                .getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+        boolean isAvailable = sensorManager.registerListener(mStepCount.getStepDetector(), sensor,
+                SensorManager.SENSOR_DELAY_UI);
+        mStepCount.initListener(new StepValuePassListener() {
+            @Override
+            public void stepChanged(int steps) {
+                CURRENT_STEP = steps;
+                updateNotification();
+            }
+        });
+        if (isAvailable) {
+            Log.v(TAG, "加速度传感器可以使用");
+        } else {
+            Log.v(TAG, "加速度传感器无法使用");
+        }
+    }
+
+    /**
+     * 传感器监听回调
+     * 记步的关键代码
+     * 1. TYPE_STEP_COUNTER API的解释说返回从开机被激活后统计的步数，当重启手机后该数据归零，
+     * 该传感器是一个硬件传感器所以它是低功耗的。
+     * 为了能持续的计步，请不要反注册事件，就算手机处于休眠状态它依然会计步。
+     * 当激活的时候依然会上报步数。该sensor适合在长时间的计步需求。
+     * <p>
+     * 2.TYPE_STEP_DETECTOR翻译过来就是走路检测，
+     * API文档也确实是这样说的，该sensor只用来监监测走步，每次返回数字1.0。
+     * 如果需要长事件的计步请使用TYPE_STEP_COUNTER。
+     *
+     * @param event
+     */
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (stepSensorType == Sensor.TYPE_STEP_COUNTER) {
+            //获取当前传感器返回的临时步数
+            int tempStep = (int) event.values[0];
+            //首次如果没有获取手机系统中已有的步数则获取一次系统中APP还未开始记步的步数
+            if (!hasRecord) {
+                hasRecord = true;
+                hasStepCount = tempStep;
+            } else {
+                //获取APP打开到现在的总步数=本次系统回调的总步数-APP打开之前已有的步数
+                int thisStepCount = tempStep - hasStepCount;
+                //本次有效步数=（APP打开后所记录的总步数-上一次APP打开后所记录的总步数）
+                int thisStep = thisStepCount - previousStepCount;
+                //总步数=现有的步数+本次有效步数
+                CURRENT_STEP += (thisStep);
+                //记录最后一次APP打开到现在的总步数
+                previousStepCount = thisStepCount;
+            }
+            Logger.d("tempStep" + tempStep);
+        } else if (stepSensorType == Sensor.TYPE_STEP_DETECTOR) {
+            if (event.values[0] == 1.0) {
+                CURRENT_STEP++;
+            }
+        }
+        updateNotification();
+    }
+
+    /**
+     * 保存记步数据
+     */
+    private void save() {
+        int tempStep = CURRENT_STEP;
+
+        List<UserStepEntity> list = DbCore.getDaoSession().getUserStepEntityDao().queryBuilder().where(UserStepEntityDao.Properties.UserId.eq(userId), UserStepEntityDao.Properties.Date.eq(CURRENT_DATE)).list();
+        if (list.size() == 0 || list.isEmpty()) {
+            UserStepEntity data = new UserStepEntity();
+            data.setUuid(UUID.randomUUID().toString());
+            data.setUserId(userId);
+            data.setDate(CURRENT_DATE);
+            data.setStepCount(tempStep + "");
+            DbCore.getDaoSession().getUserStepEntityDao().insert(data);
+        } else if (list.size() == 1) {
+            UserStepEntity data = list.get(0);
+            data.setStepCount(tempStep + "");
+            DbCore.getDaoSession().getUserStepEntityDao().update(data);
+        } else {
+        }
+    }
+
+    /**
+     * 保存记步数据
+     */
+    class TimeCount extends CountDownTimer {
+        public TimeCount(long millisInFuture, long countDownInterval) {
+            super(millisInFuture, countDownInterval);
+        }
+
+        @Override
+        public void onFinish() {
+            // 如果计时器正常结束，则开始计步
+            time.cancel();
+            save();
+            startTimeCount();
+        }
+
+        @Override
+        public void onTick(long millisUntilFinished) {
+
+        }
+
+    }
+
+    /**
+     * 开始保存记步数据
+     */
+    private void startTimeCount() {
+        if (time == null) {
+            time = new TimeCount(duration, 1000);
+        }
+        time.start();
+    }
+
+    /**
+     * 向Activity传递数据的纽带
+     */
+    public class StepBinder extends Binder {
+
+        /**
+         * 获取当前service对象
+         *
+         * @return StepService
+         */
+        public StepService getService() {
+            return StepService.this;
+        }
+    }
+}
+/*
+******************************* Copyright (c)*********************************\
+**
+**                 (c) Copyright 2015, 蒋朋, china, qd. sd
+**                          All Rights Reserved
+**
+**                           By()
+**                         
+**-----------------------------------版本信息------------------------------------
+** 版    本: V0.1
+**
+**------------------------------------------------------------------------------
+********************************End of Head************************************\
+*/
+
+package com.cnlive.moudle.pedometer.sql.db;
+
+
+import org.greenrobot.greendao.AbstractDao;
+import org.greenrobot.greendao.query.QueryBuilder;
+
+import java.util.List;
+
+/**
+ * 文 件 名: BaseDbHelper
+ * 说   明:  greedDAO 基础辅助类
+ * 创 建 人: 蒋朋
+ * 创建日期: 16-7-19 10:19
+ * 邮   箱: jp19891017@gmail.com
+ * 博   客: http://jp1017.github.io
+ * 修改时间：
+ * 修改备注：
+ */
+public class BaseDbHelper<T, K> {
+    private AbstractDao<T, K> mDao;
+
+
+    public BaseDbHelper(AbstractDao dao) {
+        mDao = dao;
+    }
+
+
+    public void save(T item) {
+        mDao.insert(item);
+    }
+
+    public void save(T... items) {
+        mDao.insertInTx(items);
+    }
+
+    public void save(List<T> items) {
+        mDao.insertInTx(items);
+    }
+
+    public void saveOrUpdate(T item) {
+        mDao.insertOrReplace(item);
+    }
+
+    public void saveOrUpdate(T... items) {
+        mDao.insertOrReplaceInTx(items);
+    }
+
+    public void saveOrUpdate(List<T> items) {
+        mDao.insertOrReplaceInTx(items);
+    }
+
+    public void deleteByKey(K key) {
+        mDao.deleteByKey(key);
+    }
+
+    public void delete(T item) {
+        mDao.delete(item);
+    }
+
+    public void delete(T... items) {
+        mDao.deleteInTx(items);
+    }
+
+    public void delete(List<T> items) {
+        mDao.deleteInTx(items);
+    }
+
+    public void deleteAll() {
+        mDao.deleteAll();
+    }
+
+
+    public void update(T item) {
+        mDao.update(item);
+    }
+
+    public void update(T... items) {
+        mDao.updateInTx(items);
+    }
+
+    public void update(List<T> items) {
+        mDao.updateInTx(items);
+    }
+
+    public  T query(K key) {
+        return  mDao.load(key);
+    }
+
+    public List<T> queryAll() {
+        return mDao.loadAll();
+    }
+
+    public List<T> query(String where, String... params) {
+
+        return mDao.queryRaw(where, params);
+    }
+
+    public QueryBuilder<T> queryBuilder() {
+
+        return mDao.queryBuilder();
+    }
+
+    public long count() {
+        return mDao.count();
+    }
+
+    public void refresh(T item) {
+        mDao.refresh(item);
+
+    }
+
+    public void detach(T item) {
+        mDao.detach(item);
+    }
+}
+package com.cnlive.moudle.pedometer.sql.db;
+
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.support.annotation.NonNull;
+import android.text.TextUtils;
+import android.util.Log;
+
+import org.greenrobot.greendao.AbstractDao;
+import org.greenrobot.greendao.database.Database;
+import org.greenrobot.greendao.database.StandardDatabase;
+import org.greenrobot.greendao.internal.DaoConfig;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * greenDao升级类
+ */
+public class DBMigrationHelper {
+    public static boolean DEBUG = false;
+    private static String TAG = "MigrationHelper2";
+    private static final String SQLITE_MASTER = "sqlite_master";
+    private static final String SQLITE_TEMP_MASTER = "sqlite_temp_master";
+
+    public static void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        printLog("【The Old Database Version】" + db.getVersion());
+        Database database = new StandardDatabase(db);
+        migrate(database, daoClasses);
+    }
+
+    public static void migrate(Database database, Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        printLog("【Generate temp table】start");
+        generateTempTables(database, daoClasses);
+        printLog("【Generate temp table】complete");
+
+        dropAllTables(database, true, daoClasses);
+        createAllTables(database, false, daoClasses);
+
+        printLog("【Restore data】start");
+        restoreData(database, daoClasses);
+        printLog("【Restore data】complete");
+    }
+
+    private static void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        for (int i = 0; i < daoClasses.length; i++) {
+            String tempTableName = null;
+
+            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
+            String tableName = daoConfig.tablename;
+            if (!isTableExists(db, false, tableName)) {
+                printLog("【New Table】" + tableName);
+                continue;
+            }
+            try {
+                tempTableName = daoConfig.tablename.concat("_TEMP");
+                StringBuilder dropTableStringBuilder = new StringBuilder();
+                dropTableStringBuilder.append("DROP TABLE IF EXISTS ").append(tempTableName).append(";");
+                db.execSQL(dropTableStringBuilder.toString());
+
+                StringBuilder insertTableStringBuilder = new StringBuilder();
+                insertTableStringBuilder.append("CREATE TEMPORARY TABLE ").append(tempTableName);
+                insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";");
+                db.execSQL(insertTableStringBuilder.toString());
+                printLog("【Table】" + tableName + "\n ---Columns-->" + getColumnsStr(daoConfig));
+                printLog("【Generate temp table】" + tempTableName);
+            } catch (SQLException e) {
+                Log.e(TAG, "【Failed to generate temp table】" + tempTableName, e);
+            }
+        }
+    }
+
+    private static boolean isTableExists(Database db, boolean isTemp, String tableName) {
+        if (db == null || TextUtils.isEmpty(tableName)) {
+            return false;
+        }
+        String dbName = isTemp ? SQLITE_TEMP_MASTER : SQLITE_MASTER;
+        String sql = "SELECT COUNT(*) FROM " + dbName + " WHERE type = ? AND name = ?";
+        Cursor cursor = null;
+        int count = 0;
+        try {
+            cursor = db.rawQuery(sql, new String[]{"table", tableName});
+            if (cursor == null || !cursor.moveToFirst()) {
+                return false;
+            }
+            count = cursor.getInt(0);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+        return count > 0;
+    }
+
+
+    private static String getColumnsStr(DaoConfig daoConfig) {
+        if (daoConfig == null) {
+            return "no columns";
+        }
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < daoConfig.allColumns.length; i++) {
+            builder.append(daoConfig.allColumns[i]);
+            builder.append(",");
+        }
+        if (builder.length() > 0) {
+            builder.deleteCharAt(builder.length() - 1);
+        }
+        return builder.toString();
+    }
+
+
+    private static void dropAllTables(Database db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        reflectMethod(db, "dropTable", ifExists, daoClasses);
+        printLog("【Drop all table】");
+    }
+
+    private static void createAllTables(Database db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        reflectMethod(db, "createTable", ifNotExists, daoClasses);
+        printLog("【Create all table】");
+    }
+
+    /**
+     * dao class already define the sql exec method, so just invoke it
+     */
+    private static void reflectMethod(Database db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        if (daoClasses.length < 1) {
+            return;
+        }
+        try {
+            for (Class cls : daoClasses) {
+                Method method = cls.getDeclaredMethod(methodName, Database.class, boolean.class);
+                method.invoke(null, db, isExists);
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void restoreData(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
+        for (int i = 0; i < daoClasses.length; i++) {
+            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
+            String tableName = daoConfig.tablename;
+            String tempTableName = daoConfig.tablename.concat("_TEMP");
+
+            if (!isTableExists(db, true, tempTableName)) {
+                continue;
+            }
+
+            try {
+                // get all columns from tempTable, take careful to use the columns list
+                List<String> columns = getColumns(db, tempTableName);
+                ArrayList<String> properties = new ArrayList<>(columns.size());
+                for (int j = 0; j < daoConfig.properties.length; j++) {
+                    String columnName = daoConfig.properties[j].columnName;
+                    if (columns.contains(columnName)) {
+                        properties.add(columnName);
+                    }
+                }
+                if (properties.size() > 0) {
+                    final String columnSQL = TextUtils.join(",", properties);
+
+                    StringBuilder insertTableStringBuilder = new StringBuilder();
+                    insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
+                    insertTableStringBuilder.append(columnSQL);
+                    insertTableStringBuilder.append(") SELECT ");
+                    insertTableStringBuilder.append(columnSQL);
+                    insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
+                    db.execSQL(insertTableStringBuilder.toString());
+                    printLog("【Restore data】 to " + tableName);
+                }
+                StringBuilder dropTableStringBuilder = new StringBuilder();
+                dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
+                db.execSQL(dropTableStringBuilder.toString());
+                printLog("【Drop temp table】" + tempTableName);
+            } catch (SQLException e) {
+                Log.e(TAG, "【Failed to restore data from temp table 】" + tempTableName, e);
+            }
+        }
+    }
+
+    private static List<String> getColumns(Database db, String tableName) {
+        List<String> columns = null;
+        Cursor cursor = null;
+        try {
+            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 0", null);
+            if (null != cursor && cursor.getColumnCount() > 0) {
+                columns = Arrays.asList(cursor.getColumnNames());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            if (null == columns) {
+                columns = new ArrayList<>();
+            }
+        }
+        return columns;
+    }
+
+    private static void printLog(String info) {
+        if (DEBUG) {
+            Log.d(TAG, info);
+        }
+    }
+
+
+}
+package com.cnlive.moudle.pedometer.sql.db;
+
+import android.content.Context;
+import android.text.TextUtils;
+
+
+import com.cnlive.moudle.pedometer.sql.dao.DaoMaster;
+import com.cnlive.moudle.pedometer.sql.dao.DaoSession;
+
+import org.greenrobot.greendao.query.QueryBuilder;
+
+/**
+ * 文 件 名: DbCore
+ * 说   明: 核心辅助类，用于获取DaoMaster和DaoSession
+ * 参   考：http://blog.inet198.cn/?sbsujjbcy/article/details/48156683
+ * 创 建 人: 蒋朋
+ * 创建日期: 16-7-19 10:12
+ * 邮   箱: jp19891017@gmail.com
+ * 博   客: http://jp1017.github.io
+ * 修改时间：
+ * 修改备注：
+ */
+public class DbCore {
+    private static final String DEFAULT_DB_NAME = "-strike-sp-db";
+    private static DaoMaster daoMaster;
+    private static DaoSession daoSession;
+
+    private static Context mContext;
+    private static String DB_NAME;
+    private static char[] databasePassword = "com.cnlive.strike_Passw0rd".toCharArray();
+
+    public static void init(Context context) {
+        init(context, DEFAULT_DB_NAME);
+    }
+
+    public static void init(Context context, String dbName) {
+        if (context == null) {
+            throw new IllegalArgumentException("context can't be null");
+        }
+        if (TextUtils.isEmpty(dbName)) {
+            DB_NAME = DEFAULT_DB_NAME;
+        } else {
+            DB_NAME = dbName;
+        }
+        mContext = context.getApplicationContext();
+        String pathDatabase = mContext.getDatabasePath(DB_NAME).getAbsolutePath();
+
+    }
+
+    public static DaoMaster getDaoMaster() {
+        if (daoMaster == null) {
+            //此处不可用 DaoMaster.DevOpenHelper, 那是开发辅助类，我们要自定义一个，方便升级
+            DaoMaster.OpenHelper helper = new MyOpenHelper(mContext, DB_NAME);
+            daoMaster = new DaoMaster(helper.getWritableDb());
+        }
+        return daoMaster;
+    }
+
+    public static DaoSession getDaoSession() {
+        if (daoSession == null) {
+            if (daoMaster == null) {
+                daoMaster = getDaoMaster();
+            }
+            daoSession = daoMaster.newSession();
+        }
+        return daoSession;
+    }
+
+    public static void enableQueryBuilderLog() {
+        QueryBuilder.LOG_SQL = true;
+        QueryBuilder.LOG_VALUES = true;
+    }
+}
+/*
+ ******************* Copyright (c) ***********************\
+ **
+ **         (c) Copyright 2016, 蒋朋, china, sxkj. sd
+ **                  All Rights Reserved
+ **
+ **                 By(青岛世新科技有限公司)
+ **                    www.qdsxkj.com
+ **
+ **                       _oo0oo_
+ **                      o8888888o
+ **                      88" . "88
+ **                      (| -_- |)
+ **                      0\  =  /0
+ **                    ___/`---'\___
+ **                  .' \\|     |// '.
+ **                 / \\|||  :  |||// \
+ **                / _||||| -:- |||||- \
+ **               |   | \\\  -  /// |   |
+ **               | \_|  ''\---/''  |_/ |
+ **               \  .-\__  '-'  ___/-. /
+ **             ___'. .'  /--.--\  `. .'___
+ **          ."" '<  `.___\_<|>_/___.' >' "".
+ **         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
+ **         \  \ `_.   \_ __\ /__ _/   .-` /  /
+ **     =====`-.____`.___ \_____/___.-`___.-'=====
+ **                       `=---='
+ **
+ **
+ **     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ **
+ **               佛祖保佑         永无BUG
+ **
+ **
+ **                   南无本师释迦牟尼佛
+ **
+
+ **----------------------版本信息------------------------
+ ** 版    本: V0.1
+ **
+ ******************* End of Head **********************\
+ */
+
+package com.cnlive.moudle.pedometer.sql.db;
+
+import android.content.Context;
+
+import com.cnlive.moudle.pedometer.sql.dao.DaoMaster;
+import com.cnlive.moudle.pedometer.sql.dao.UserStepEntityDao;
+import com.cnlive.moudle.pedometer.sql.entity.UserStepEntity;
+
+import org.greenrobot.greendao.database.Database;
+
+/**
+ * 文 件 名: MyOpenHelper
+ * 创 建 人: 蒋朋
+ * 创建日期: 16-10-11 08:28
+ * 邮    箱: jp19891017@gmail.com
+ * 博    客: https://jp1017.github.io/
+ * 描    述:
+ * 修 改 人:
+ * 修改时间：
+ * 修改备注：
+ */
+
+public class MyOpenHelper extends DaoMaster.OpenHelper {
+    public MyOpenHelper(Context context, String name) {
+        super(context, name);
+    }
+
+    @Override
+    public void onUpgrade(Database db, int oldVersion, int newVersion) {
+        try {
+            //判断版本， 设置需要修改得表  我这边设置一个 FileInfo
+            DBMigrationHelper.migrate(db, UserStepEntityDao.class);
+        } catch (ClassCastException e) {
+        }
+//        KLog.w("db version update from " + oldVersion + " to " + newVersion);
+//        MigrationHelper.migrate(db, new MigrationHelper.ReCreateAllTableListener() {
+//
+//            @Override
+//            public void onCreateAllTables(Database db, boolean ifNotExists) {
+//                DaoMaster.createAllTables(db, ifNotExists);
+//            }
+//
+//            @Override
+//            public void onDropAllTables(Database db, boolean ifExists) {
+//                DaoMaster.dropAllTables(db, ifExists);
+//            }
+//        },G106InfoDao.class);//, GovernanceTechnologyDao.class, TestData3Dao.class
+//    }
+        switch (oldVersion) {
+            case 1:
+
+                //不能先删除表，否则数据都木了
+//                StudentDao.dropTable(db, true);
+
+//                StudentDao.createTable(db, true);
+
+                // 加入新字段 score
+//                db.execSQL("ALTER TABLE 'STUDENT' ADD 'SCORE' TEXT;");
+
+                break;
+        }
+
+    }
+}
@@ -2,37 +2,60 @@ package com.cnlive.moudle.pedometer.sql.entity;
  
 import org.greenrobot.greendao.annotation.Entity;
 import org.greenrobot.greendao.annotation.Generated;
+import org.greenrobot.greendao.annotation.Id;
  
 @Entity
 public class UserStepEntity {
+    @Id
+    private String uuid;
     private String userId;
     private String date;
     private String stepCount;
-    @Generated(hash = 1638365954)
-    public UserStepEntity(String userId, String date, String stepCount) {
+
+    @Generated(hash = 1772281523)
+    public UserStepEntity(String uuid, String userId, String date,
+            String stepCount) {
+        this.uuid = uuid;
         this.userId = userId;
         this.date = date;
         this.stepCount = stepCount;
     }
+
     @Generated(hash = 273857141)
     public UserStepEntity() {
     }
+
     public String getUserId() {
         return this.userId;
     }
+
     public void setUserId(String userId) {
         this.userId = userId;
     }
+
     public String getDate() {
         return this.date;
     }
+
     public void setDate(String date) {
         this.date = date;
     }
+
     public String getStepCount() {
         return this.stepCount;
     }
+
     public void setStepCount(String stepCount) {
         this.stepCount = stepCount;
     }
+
+    public String getUuid() {
+        return this.uuid;
+    }
+
+    public void setUuid(String uuid) {
+        this.uuid = uuid;
+    }
+
+
 }
+package com.cnlive.moudle.pedometer.ui.activity;
+
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.support.v4.app.NotificationManagerCompat;
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.cnlive.libs.base.util.SharedPreferencesHelper;
+import com.cnlive.moudle.pedometer.service.KeepLiveService;
+import com.cnlive.moudle.pedometer.service.StepService;
+import com.cnlive.moudle.pedometer.utils.ServiceUtils;
+import com.example.moudle_pedometer.R;
+
+import static android.app.Notification.EXTRA_CHANNEL_ID;
+import static android.provider.Settings.EXTRA_APP_PACKAGE;
+
+/**
+ * 计步器主activity
+ */
+@Route(path = "/moudle_pedometer/InterestActivity")
+public class PedometerMainActivity extends AppCompatActivity {
+    private NotificationManagerCompat notificationManagerCompat;
+    private boolean isOpen;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_pedometer_main);
+        SharedPreferencesHelper.getInstance(getApplicationContext()).setValue("isKeepAlive", true);
+//        new Handler().postDelayed(new Runnable() {
+//            @Override
+//            public void run() {
+//                Log.e("停止服务", "停止");
+//                StepService.isKeep = false;
+//                stopService(new Intent(PedometerMainActivity.this, StepService.class));
+//                SharedPreferencesHelper.getInstance(getApplicationContext()).setValue("isKeepAlive", false);
+//                new Handler().postDelayed(new Runnable() {
+//                    @Override
+//                    public void run() {
+//                        stopService(new Intent(PedometerMainActivity.this, KeepLiveService.class));
+//
+//                    }
+//                }, 100);
+//            }
+//        }, 10000);
+
+//        Intent intent = new Intent();
+//        ComponentName componentName = new ComponentName("com.android.settings", "com.android.settings.SubSettings");
+//        intent.setComponent(componentName);
+//        intent.putExtra(EXTRA_APP_PACKAGE, getPackageName());
+//        intent.putExtra(EXTRA_CHANNEL_ID, getApplicationInfo().uid);
+//        startActivity(intent);
+    }
+
+    private void check() {
+        //监测通知权限是否打开
+        notificationManagerCompat = NotificationManagerCompat.from(this);
+        isOpen = notificationManagerCompat.areNotificationsEnabled();
+        if (isOpen) {
+            startService(new Intent(getApplicationContext(), StepService.class));
+        } else {
+            goToSettingNo();
+        }
+    }
+
+    private void goToSettingNo() {
+        Intent intent1 = new Intent();
+        try {
+            // 根据isOpened结果，判断是否需要提醒用户跳转AppInfo页面，去打开App通知权限
+            intent1.setAction(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                //这种方案适用于 API 26, 即8.0（含8.0）以上可以用
+                intent1.putExtra(EXTRA_APP_PACKAGE, getPackageName());
+                intent1.putExtra(EXTRA_CHANNEL_ID, getApplicationInfo().uid);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                //这种方案适用于 API21——25，即 5.0——7.1 之间的版本可以使用
+                intent1.putExtra("app_package", getPackageName());
+                intent1.putExtra("app_uid", getApplicationInfo().uid);
+            }
+
+            // 小米6 -MIUI9.6-8.0.0系统，是个特例，通知设置界面只能控制"允许使用通知圆点"——然而这个玩意并没有卵用，我想对雷布斯说：I'm not ok!!!
+            //  if ("MI 6".equals(Build.MODEL)) {
+            //      intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+            //      Uri uri = Uri.fromParts("package", getPackageName(), null);
+            //      intent.setData(uri);
+            //      // intent.setAction("com.android.settings/.SubSettings");
+            //  }
+            startActivity(intent1);
+        } catch (Exception e) {
+            //其他低版本或者异常情况，走该节点。进入APP设置界面
+            intent1.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+            intent1.putExtra("package", getPackageName());
+            startActivity(intent1);
+        }
+        Toast.makeText(getApplicationContext(), "您尚未开启通知权限,无法进行计步", Toast.LENGTH_LONG).show();
+    }
+
+    @Override
+    protected void onRestart() {
+        super.onRestart();
+
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        check();
+        PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
+
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+            boolean hasIgnored = powerManager.isIgnoringBatteryOptimizations(getPackageName());
+            if (!hasIgnored) {
+                Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
+                intent.setData(Uri.parse("package:" + getPackageName()));
+                PackageManager pm = getPackageManager();
+                if (intent.resolveActivity(pm) != null) {
+                    startActivity(intent);
+                }
+            }
+        }
+    }
+}
+package com.cnlive.moudle.pedometer.utils;
+
+import android.app.ActivityManager;
+import android.content.Context;
+
+import com.cnlive.libs.base.util.SharedPreferencesHelper;
+
+import java.util.ArrayList;
+
+
+/**
+ * 服务工具类
+ */
+public class ServiceUtils {
+
+    /**
+     * 判断服务是否开启
+     *
+     * @return
+     */
+    public static boolean isServiceRunning(Context context, String ServiceName) {
+        if (("").equals(ServiceName) || ServiceName == null)
+            return false;
+        ActivityManager myManager = (ActivityManager) context
+                .getSystemService(Context.ACTIVITY_SERVICE);
+        ArrayList<ActivityManager.RunningServiceInfo> runningService = (ArrayList<ActivityManager.RunningServiceInfo>) myManager
+                .getRunningServices(30);
+        for (int i = 0; i < runningService.size(); i++) {
+            if (runningService.get(i).service.getClassName().toString()
+                    .equals(ServiceName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean getIsKeepState(Context context, String value) {
+        boolean result = SharedPreferencesHelper.getInstance(context).getBoolean(value, false);
+        return result;
+    }
+
+    public static void setIsKeepState(Context context, String value, boolean state) {
+        SharedPreferencesHelper.getInstance(context).setValue(value, state);
+
+    }
+}
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.cnlive.moudle.pedometer.ui.activity.PedometerMainActivity">
+
+</android.support.constraint.ConstraintLayout>
+<?xml version="1.0" encoding="utf-8"?>
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:gravity="center_vertical">
+
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:orientation="vertical">
+
+            <TextView
+                android:id="@+id/tv_tip"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginLeft="10dp"
+                android:layout_marginTop="3dp"
+                android:text="今日步数"
+                android:textColor="#707070"
+                android:textSize="14sp" />
+
+            <LinearLayout
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content">
+
+                <TextView
+                    android:id="@+id/tv_step_count"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_centerHorizontal="true"
+                    android:layout_marginLeft="15dp"
+                    android:text="0"
+                    android:textColor="#707070"
+                    android:textSize="20sp" />
+
+                <TextView
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_centerHorizontal="true"
+                    android:layout_marginLeft="3dp"
+                    android:text="步"
+                    android:textColor="#707070"
+                    android:textSize="14sp" />
+            </LinearLayout>
+        </LinearLayout>
+
+        <LinearLayout
+            android:layout_width="0dp"
+            android:layout_height="match_parent"
+            android:layout_weight="1"
+            android:gravity="right|center">
+
+            <ImageView
+                android:id="@+id/iv_icon"
+                android:layout_width="35dp"
+                android:layout_height="35dp"
+                android:layout_marginRight="10dp"
+                android:src="@drawable/ic_icon" />
+        </LinearLayout>
+    </LinearLayout>
+
+
+</LinearLayout>